diff --git a/3rdparty/ext_gmic/CMakeLists.txt b/3rdparty/ext_gmic/CMakeLists.txt
index c97d6e9080..0ceb0b85d9 100644
--- a/3rdparty/ext_gmic/CMakeLists.txt
+++ b/3rdparty/ext_gmic/CMakeLists.txt
@@ -1,41 +1,41 @@
 SET(PREFIX_ext_gmic "${EXTPREFIX}" )
 
 # Download the gmic sources
 ExternalProject_Add( ext_gmic_base
     DOWNLOAD_DIR ${EXTERNALS_DOWNLOAD_DIR}
-    URL https://gmic.eu/files/source/gmic_2.5.6.tar.gz
-    URL_MD5 8deabebc29081657986ae6531e3fc1d7
+    URL https://gmic.eu/files/source/gmic_2.6.7.tar.gz
+    URL_MD5 1d55ec5d349ccf0ef78cf8d1b4a42af8
 
     PATCH_COMMAND ${PATCH_COMMAND} -p1 -i ${CMAKE_CURRENT_SOURCE_DIR}/cmake.diff
           COMMAND  ${PATCH_COMMAND} -p1 -i ${CMAKE_CURRENT_SOURCE_DIR}/no_threads.diff
 
     SOURCE_DIR gmic
 
     CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${PREFIX_ext_gmic} -D -DCMAKE_BUILD_TYPE=Release ${GLOBAL_PROFILE}
 
     BUILD_COMMAND ""
     INSTALL_COMMAND ""
 
     BUILD_IN_SOURCE 1
 )
 
 # Download and build gmic-qt
 # FIXME: Forcing CMAKE_BUILD_TYPE to Release
 ExternalProject_Add( ext_gmic_qt
     DOWNLOAD_DIR ${EXTERNALS_DOWNLOAD_DIR}
-    URL https://github.com/c-koi/gmic-qt/archive/v.2.5.6.tar.gz
-    URL_MD5 4e7cf71d6348d44f98d3c132433c358c
+    URL https://github.com/c-koi/gmic-qt/archive/v.2.6.7.tar.gz
+    URL_MD5 bdbd6e77d78e478e8653c1396065afc5
     PATCH_COMMAND ${PATCH_COMMAND} -p1 -i ${CMAKE_CURRENT_SOURCE_DIR}/desktop_icon.diff
 
     SOURCE_DIR gmic-qt
     INSTALL_DIR ${PREFIX_ext_gmic}
 
     CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${PREFIX_ext_gmic} -DGMIC_QT_HOST=krita -DCMAKE_BUILD_TYPE=Release ${GLOBAL_PROFILE}
 
     UPDATE_COMMAND ""
 
     DEPENDS ext_gmic_base
 )
 
 add_custom_target(ext_gmic)
 add_dependencies(ext_gmic ext_gmic_qt)
diff --git a/CMakeLists.txt b/CMakeLists.txt
index baa079c32b..9bf875a02e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,929 +1,929 @@
 project(krita)
 
 message(STATUS "Using CMake version: ${CMAKE_VERSION}")
 
-cmake_minimum_required(VERSION 2.8.12 FATAL_ERROR)
+cmake_minimum_required(VERSION 3.0.0 FATAL_ERROR)
 
 set(MIN_QT_VERSION 5.9.0)
 
-set(MIN_FRAMEWORKS_VERSION 5.18.0)
+set(MIN_FRAMEWORKS_VERSION 5.44.0)
 
 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.11 -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_definitions(-Wno-suggest-override -Wextra)
 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
 )
 
 # KConfig deprecated authorizeKAction. In order to be warning free,
 # compile with the updated function when the dependency is new enough.
 # Remove this (and the uses of the define) when the minimum KF5
 # version is >= 5.24.0.
 if (${KF5Config_VERSION} VERSION_LESS "5.24.0" )
     message("Old KConfig (< 5.24.0) found.")
     add_definitions(-DKCONFIG_BEFORE_5_24)
 endif()
 
 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)
 
     find_package(XCB COMPONENTS XCB ATOM)
     set(HAVE_XCB ${XCB_FOUND})
 else()
     set(HAVE_DBUS FALSE)
     set(HAVE_X11 FALSE)
     set(HAVE_XCB 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.8.0" )
     add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x50900)
 elseif(${Qt5_VERSION} VERSION_GREATER "5.7.0" )
     add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x50800)
 elseif(${Qt5_VERSION} VERSION_GREATER "5.6.0" )
     add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x50700)
 else()
     add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x50600)
 endif()
 
 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")
 
 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()
 
     #Handle Vc master
     if(Vc_COMPILER_IS_GCC OR Vc_COMPILER_IS_CLANG)
         AddCompilerFlag("-std=c++11" _ok)
         if(NOT _ok)
             AddCompilerFlag("-std=c++0x" _ok)
         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/CMakeLists.txt b/krita/CMakeLists.txt
index e9b3b9d258..7a43235875 100644
--- a/krita/CMakeLists.txt
+++ b/krita/CMakeLists.txt
@@ -1,113 +1,113 @@
 project(krita)
 
 include_directories(SYSTEM
     ${EIGEN3_INCLUDE_DIR}
     ${Vc_INCLUDE_DIR}
 )
 
 add_subdirectory( dtd )
 add_subdirectory( data )
 add_subdirectory( integration )
 # Install the application icons following the the freedesktop icon theme spec
 add_subdirectory( pics/app )
 
 if (ANDROID)
     include_directories (${Qt5AndroidExtras_INCLUDE_DIRS})
 endif()
 
 set(krita_SRCS main.cc)
 
 # Set the application icon on the application
 if (NOT APPLE)
-    file(GLOB ICON_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/pics/app/*-apps-calligrakrita.png")
+    file(GLOB ICON_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/pics/app/*-apps-krita.png")
 else()
     set(ICON_SRCS
-         "${CMAKE_CURRENT_SOURCE_DIR}/pics/app/16-apps-calligrakrita.png"
-         "${CMAKE_CURRENT_SOURCE_DIR}/pics/app/32-apps-calligrakrita.png"
-         "${CMAKE_CURRENT_SOURCE_DIR}/pics/app/48-apps-calligrakrita.png"
-         "${CMAKE_CURRENT_SOURCE_DIR}/pics/app/128-apps-calligrakrita.png"
-         "${CMAKE_CURRENT_SOURCE_DIR}/pics/app/256-apps-calligrakrita.png"
-         "${CMAKE_CURRENT_SOURCE_DIR}/pics/app/512-apps-calligrakrita.png"
-         "${CMAKE_CURRENT_SOURCE_DIR}/pics/app/1024-apps-calligrakrita.png"
+         "${CMAKE_CURRENT_SOURCE_DIR}/pics/app/16-apps-krita.png"
+         "${CMAKE_CURRENT_SOURCE_DIR}/pics/app/32-apps-krita.png"
+         "${CMAKE_CURRENT_SOURCE_DIR}/pics/app/48-apps-krita.png"
+         "${CMAKE_CURRENT_SOURCE_DIR}/pics/app/128-apps-krita.png"
+         "${CMAKE_CURRENT_SOURCE_DIR}/pics/app/256-apps-krita.png"
+         "${CMAKE_CURRENT_SOURCE_DIR}/pics/app/512-apps-krita.png"
+         "${CMAKE_CURRENT_SOURCE_DIR}/pics/app/1024-apps-krita.png"
     )
 endif() 
 ecm_add_app_icon(krita_SRCS ICONS ${ICON_SRCS})
 
 # Install the mimetype icons
 ecm_install_icons(ICONS
     "${CMAKE_CURRENT_SOURCE_DIR}/pics/mimetypes/16-mimetypes-application-x-krita.png"
     "${CMAKE_CURRENT_SOURCE_DIR}/pics/mimetypes/22-mimetypes-application-x-krita.png"
     "${CMAKE_CURRENT_SOURCE_DIR}/pics/mimetypes/32-mimetypes-application-x-krita.png"
     "${CMAKE_CURRENT_SOURCE_DIR}/pics/mimetypes/48-mimetypes-application-x-krita.png"
     "${CMAKE_CURRENT_SOURCE_DIR}/pics/mimetypes/64-mimetypes-application-x-krita.png"
     "${CMAKE_CURRENT_SOURCE_DIR}/pics/mimetypes/128-mimetypes-application-x-krita.png"
     "${CMAKE_CURRENT_SOURCE_DIR}/pics/mimetypes/256-mimetypes-application-x-krita.png"
     "${CMAKE_CURRENT_SOURCE_DIR}/pics/mimetypes/512-mimetypes-application-x-krita.png"
     "${CMAKE_CURRENT_SOURCE_DIR}/pics/mimetypes/1024-mimetypes-application-x-krita.png"
     DESTINATION ${KDE_INSTALL_ICONDIR} THEME hicolor)
 
 # separate listing, both used by Krita and KritaSketch
 set(krita_QRCS
     ${CMAKE_SOURCE_DIR}/krita/krita.qrc
     ${CMAKE_SOURCE_DIR}/krita/pics/Breeze-dark/breeze-dark-icons.qrc
     ${CMAKE_SOURCE_DIR}/krita/pics/Breeze-light/breeze-light-icons.qrc
     ${CMAKE_SOURCE_DIR}/krita/pics/layerbox/layerbox-icons.qrc
     ${CMAKE_SOURCE_DIR}/krita/pics/layerbox/svg/layerbox-svg-icons.qrc
     ${CMAKE_SOURCE_DIR}/krita/pics/layers/layers-icons.qrc
     ${CMAKE_SOURCE_DIR}/krita/pics/misc-light/misc-light-icons.qrc
     ${CMAKE_SOURCE_DIR}/krita/pics/misc-dark/misc-dark-icons.qrc
     ${CMAKE_SOURCE_DIR}/krita/pics/paintops/paintops-icons.qrc
     ${CMAKE_SOURCE_DIR}/krita/pics/tools/SVG/16/tools-svg-16-icons.qrc
     ${CMAKE_SOURCE_DIR}/krita/pics/tool_transform/tool-transform-icons.qrc
     ${CMAKE_SOURCE_DIR}/krita/pics/svg/svg-icons.qrc
     ${CMAKE_SOURCE_DIR}/libs/flake/flake.qrc
     ${CMAKE_SOURCE_DIR}/libs/widgets/kritawidgets.qrc
     ${CMAKE_SOURCE_DIR}/pics/icons.qrc
     ${CMAKE_SOURCE_DIR}/krita/data/aboutdata/aboutdata.qrc
     ${CMAKE_SOURCE_DIR}/krita/data/shaders/shaders.qrc
     ${CMAKE_SOURCE_DIR}/krita/data/cursors/cursors.qrc
     CACHE INTERNAL "krita_QRCS"
 )
 
 qt5_add_resources(krita_SRCS ${krita_QRCS})
 
 if (ANDROID)
     add_library(krita SHARED ${krita_SRCS})
     target_link_libraries(krita PRIVATE Qt5::AndroidExtras)
 else()
     add_executable(krita ${krita_SRCS})
 endif()
 target_link_libraries(krita 
     PRIVATE
                       kritaui 
                       Qt5::Core
                       Qt5::Gui
                       Qt5::Widgets
                       Qt5::Xml
                       Qt5::Network
                       Qt5::PrintSupport
                       Qt5::Svg
                       Qt5::Concurrent)
 if(HAVE_KCRASH)
     target_link_libraries(krita PRIVATE KF5::Crash)
 endif()
 
 if (APPLE)
     set_target_properties(krita PROPERTIES INSTALL_RPATH "@loader_path/../../../../lib;@loader_path/../lib;@loader_path/../Frameworks;@executable_path/../lib;@executable_path/../Frameworks")
     set_target_properties(krita PROPERTIES MACOSX_BUNDLE_INFO_PLIST ${CMAKE_CURRENT_SOURCE_DIR}/Info.plist.template)
     set_target_properties(krita PROPERTIES MACOSX_BUNDLE_GUI_IDENTIFIER "org.krita")
     set_target_properties(krita PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME "Krita")
     set_target_properties(krita PROPERTIES MACOSX_BUNDLE_ICON_FILE "krita_SRCS.icns")
     set_target_properties(krita PROPERTIES MACOSX_BUNDLE_LONG_VERSION_STRING ${KRITA_VERSION_STRING})
     set_target_properties(krita PROPERTIES MACOSX_BUNDLE_SHORT_VERSION_STRING ${KRITA_VERSION_STRING})
     set_target_properties(krita PROPERTIES MACOSX_BUNDLE_VERSION ${KRITA_VERSION_STRING})
     set_target_properties(krita PROPERTIES MACOSX_BUNDLE_COPYRIGHT "GNU Public License, V2 or, at your option, any later version.")
 endif ()
 
 install(TARGETS krita ${INSTALL_TARGETS_DEFAULT_ARGS})
 install(PROGRAMS org.kde.krita.desktop  DESTINATION ${XDG_APPS_INSTALL_DIR})
 install(FILES  krita.action kritamenu.action DESTINATION ${DATA_INSTALL_DIR}/krita/actions)
 install(FILES  org.kde.krita.appdata.xml DESTINATION ${KDE_INSTALL_METAINFODIR} )
 
 install(DIRECTORY DESTINATION ${DATA_INSTALL_DIR}/krita/shortcuts)
 
diff --git a/krita/data/aboutdata/developers.txt b/krita/data/aboutdata/developers.txt
index 69f73890f5..75961c6bd1 100644
--- a/krita/data/aboutdata/developers.txt
+++ b/krita/data/aboutdata/developers.txt
@@ -1,201 +1,202 @@
 Boudewijn Rempt
 Aaron J. Seigo
 Adam Celarek
 Adam Pigg
 Adriaan de Groot
 Adrian Page
 Adrian Schroeter
 Albert Astals Cid
 Alberto Villa
 Alexander Neundorf
 Alexander Potashev
 Alexis Ménard
 Alfredo Beaumont Sainz
 Allen Winter
 Ana Beatriz Guerrero López
 Andras Mantia
 Andreas Hartmetz
 Andreas Lundin
 André Marcelo Alvarenga
 Andrew Coles
 Andre Woebbeking
 Andrius da Costa Ribas
 Andy Fawcett
 Anne-Marie Mahfouf
 Ariya Hidayat
 Arjen Hiemstra
 Bart Coppens
 Ben Cooksley
 Benjamin K. Stuhl
 Benjamin Meyer
 Benjamin Reed
 Benoît Jacob
 Ben Schleimer
 Bernhard Rosenkraenzer
 Bo Thorsen
 Brad Hards
 Bram Schoenmakers
 Burkhard Lück
 Carlo Segato
 C. Boemann
 Christer Stenbrenden
 Christian Ehrlicher
 Christian Mueller
 Christoph Feck
 Chusslove Illich
 Clarence Dang
 Cyrille Berger
 Daniel M. Duley
 Daniel Molkentin
 Dan Leinir Turthra Jensen
 Dan Meltzer
 Danny Allen
 David Faure
 David Gowers
 Dirk Mueller
 Dirk Schönberger
 Dmitry Kazakov
 Edward Apap
 Elvis Stansvik
 Emanuele Tamponi
 Emmet O'Neill
 Enrique Matías Sánchez
 Eoin O'Neill
 Fabian Kosmale
 Frank Osterfeld
 Frederik Schwarzer
 Fredrik Edemar
 Fredy Yanardi
 Friedrich W. H. Kossebau
 Gábor Lehel
 Gary Cramblitt
 Geoffry Song
 Gioele Barabucci
 Giovanni Venturi
 Gopalakrishna Bhat A
 Hanna Scott
 Harald Sitter
 Hasso Tepper
 Helge Deller
 Helio Castro
 Hideki Saito
 Hoàng Đức Hiếu
 Hugo Pereira Da Costa
 Inge Wallin
 Ingo Klöcker
 İsmail Dönmez
 Ivan Yossi
 Jaime
 Jaime Torres
 Jaison Lee
 Jakob Petsovits
 Jakub Stachowski
 Jan Hambrecht
 Jarosław Staniek
 Jens Herden
 Jessica Hall
 Johannes Simon
 John Layt
 Jonathan Riddell
 Jonathan Singer
 José Luis Vergara
 Juan Luis Boya García
 Juan Palacios
 Jure Repinc
 Kai-Uwe Behrmann
+Karl Ove Hufthammer
 Kevin Krammer
 Kevin Ottens
 Kurt Pfeifle
 Laurent Montel
 Lauri Watts
 Leo Savernik
 Lukáš Tinkl
 Lukáš Tvrdý
 Maciej Mrozowski
 Malcolm Hunter
 Manuel Riecke
 manu tortosa
 Marc Pegon
 Marijn Kruisselbrink
 Martin Ellis
 Martin Gräßlin
 Matthew Woehlke
 Matthias Klumpp
 Matthias Kretz
 Matus Talcik
 Maximiliano Curia
 Melchior Franz
 Michael David Howell
 Michael Drueing
 Michael Thaler
 Michel Hermier
 Mohit Goyal
 Mojtaba Shahi Senobari
 Montel Laurent
 Moritz Molch
 Nick Shaforostoff
 Nicolas Goutte
 Olivier Goffart
 Patrick Julien
 Patrick Spendrin
 Pavel Belskiy
 Pavel Heimlich
 Peter Simonsson
 Pierre Ducroquet
 Pierre Stirnweiss
 Pino Toscano
 Rafael Fernández López
 Raphael Langerhorst
 Rex Dieter
 Rob Buis
 Roopesh Chander
 Sahil Nagpal
 Salil Kapur
 Samuel Buttigieg
 Sander Koning
 Sascha Suelzer
 Scott Petrovic
 Scott Wheeler
 Sebastian Sauer
 Shivaraman Aiyer
 Siddharth Sharma
 Silvio Heinrich
 Somsubhra Bairi
 Spencer Brown
 Srikanth Tiyyagura
 Stefan Nikolaus
 Stephan Binner
 Stephan Kulow
 Stuart Dickson
 Sune Vuorela
 Sven Langkamp
 Thiago Macieira
 Thomas Capricelli
 Thomas Friedrichsmeier
 Thomas Klausner
 Thomas Nagy
 Thomas Zander
 Thorsten Staerk
 Thorsten Zachmann
 Tim Beaulen
 Timothée Giet
 Tobias Koenig
 Tom Burdick
 Torio Mlshi
 Torsten Rahn
 Unai Garro
 Urs Wolfer
 Vadim Zhukov
 Vera Lukman
 Victor Lafon
 Victor Wåhlström
 Volker Krause
 Waldo Bastian
 Werner Trobin
 Wilco Greven
 Will Entriken
 William Steidtmann
 Wolthera van Hovell
 Yann Bodson
 Yue Liu
 Yuri Chornoivan
diff --git a/krita/data/actions/MoveTool.action b/krita/data/actions/MoveTool.action
index e350b59233..c3d2094e72 100644
--- a/krita/data/actions/MoveTool.action
+++ b/krita/data/actions/MoveTool.action
@@ -1,95 +1,95 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ActionCollection version="2" name="Tools">
   <Actions category="Path Tool">
     <text>Path Tool</text>
     <Action name="movetool-move-up">
       <iconText>Move up</iconText>
       <shortcut>Up</shortcut>
       <toolTip>Move up</toolTip>
       <icon></icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
       <text>Move up</text>
     </Action>
     <Action name="movetool-move-down">
       <iconText>Move down</iconText>
       <shortcut>Down</shortcut>
       <toolTip>Move down</toolTip>
       <icon></icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
       <text>Move down</text>
     </Action>
     <Action name="movetool-show-coordinates">
       <iconText>Show Coordinates</iconText>
       <shortcut>Ctrl+Alt+Shift+C</shortcut>
       <toolTip>Show absolute coordinates and offset while move action</toolTip>
       <icon></icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>true</isCheckable>
       <text>Show Coordinates</text>
     </Action>
     <Action name="movetool-move-left">
       <iconText>Move left</iconText>
       <shortcut>Left</shortcut>
       <toolTip>Move left</toolTip>
       <icon></icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
       <text>Move left</text>
     </Action>
     <Action name="movetool-move-right">
       <iconText>Move right</iconText>
       <shortcut>Right</shortcut>
       <toolTip>Move right</toolTip>
       <icon></icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
     </Action>
     <Action name="movetool-move-up-more">
       <iconText>Move up more</iconText>
       <shortcut>Shift+Up</shortcut>
       <toolTip>Move up more</toolTip>
       <icon></icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
       <text>Move up more</text>
     </Action>
     <Action name="movetool-move-down-more">
       <iconText>Move down more</iconText>
       <shortcut>Shift+Down</shortcut>
       <toolTip>Move down more</toolTip>
       <icon></icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
       <text>Move down more</text>
     </Action>
     <Action name="movetool-move-left-more">
       <iconText>Move left more</iconText>
       <shortcut>Shift+Left</shortcut>
       <toolTip>Move left more</toolTip>
       <icon></icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
       <text>Move left more</text>
     </Action>
     <Action name="movetool-move-right-more">
       <iconText>Move right more</iconText>
       <shortcut>Shift+Right</shortcut>
       <toolTip>Move right more</toolTip>
       <icon></icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
-      <text>Move right</text>
+      <text>Move right more</text>
     </Action>
   </Actions>
 </ActionCollection>
diff --git a/krita/data/input/painttoolsaicompatible.profile b/krita/data/input/painttoolsaicompatible.profile
index f63d3f8498..97c999563f 100644
--- a/krita/data/input/painttoolsaicompatible.profile
+++ b/krita/data/input/painttoolsaicompatible.profile
@@ -1,68 +1,68 @@
 [Alternate Invocation]
 0={4;2;[];2;0;0}
 1={2;2;[1000023,1000021];1;0;0}
 2={3;2;[1000021,1000023];2;0;0}
 3={5;2;[1000021];2;0;0}
 4={0;2;[1000021,1000020];1;0;0}
 5={1;2;[1000023,1000020];1;0;0}
 
 [Change Primary Setting]
 0={0;2;[1000021,1000023];1;0;0}
 
 [Exposure or Gamma]
 0={0;2;[59];1;0;0}
 
 [General]
 name=Paint Tool Sai Compatible
-version=3
+version=4
 
 [Pan Canvas]
 0={4;1;[];0;0;0}
 1={3;1;[];0;0;0}
 2={2;1;[];0;0;0}
 3={1;1;[];0;0;0}
 4={0;2;[];4;0;0}
 5={0;2;[20];1;0;0}
 6={0;4;[];0;0;2}
 
 [Rotate Canvas]
 0={3;1;[36];0;0;0}
 1={4;1;[1000010];0;0;0}
 2={2;1;[1000011];0;0;0}
 3={0;2;[1000020];4;0;0}
 4={4;2;[1000023,20];2;0;0}
 5={0;2;[20,1000023];1;0;0}
 6={4;1;[1000006];0;0;0}
 
 [Select Layer]
 0={0;2;[52];1;0;0}
 
 [Show Popup Palette]
 0={0;2;[1000021,1000023];2;0;0}
 
 [Switch Time]
 0={1;1;[1000012];0;0;0}
 1={0;1;[1000014];0;0;0}
 
 [Tool Invocation]
 0={2;1;[1000000];0;0;0}
 1={1;1;[1000004];0;0;0}
 2={0;2;[];1;0;0}
 3={1;1;[1000005];0;0;0}
 4={3;2;[56];1;0;0}
 
 [Zoom Canvas]
 0={2;3;[];0;1;0}
 1={0;2;[1000021];4;0;0}
 10={0;2;[1000021,20];1;0;0}
 11={0;4;[];0;0;1}
 12={6;1;[33];0;0;0}
 13={1;2;[1000021,1000023,20];1;0;0}
 2={5;1;[32];0;0;0}
 3={2;1;[2b];0;0;0}
 4={4;1;[1000010];0;0;0}
 5={3;1;[2d];0;0;0}
 6={2;1;[3d];0;0;0}
 7={3;3;[];0;2;0}
 8={2;1;[1000021,20];0;0;0}
 9={3;1;[1000021,1000023,20];0;0;0}
diff --git a/krita/data/input/photoshopcompatible.profile b/krita/data/input/photoshopcompatible.profile
index 5ba7902184..f56d232186 100644
--- a/krita/data/input/photoshopcompatible.profile
+++ b/krita/data/input/photoshopcompatible.profile
@@ -1,65 +1,65 @@
 [Alternate Invocation]
 0={1;2;[1000023,1000020];1;0;0}
 1={0;2;[1000021,1000020];1;0;0}
 2={5;2;[];0;0;0}
 3={3;2;[];0;0;0}
 4={2;2;[];0;0;0}
 5={4;2;[1000023];1;0;0}
 
 [Change Primary Setting]
 0={0;2;[];0;0;0}
 
 [Exposure or Gamma]
 0={0;2;[];0;0;0}
 
 [General]
 name=Photoshop Compatible
-version=3
+version=4
 
 [Pan Canvas]
 0={0;4;[];0;0;2}
 1={0;2;[20];1;0;0}
 2={0;2;[];4;0;0}
 3={1;1;[];0;0;0}
 4={2;1;[];0;0;0}
 5={3;1;[];0;0;0}
 6={4;1;[];0;0;0}
 
 [Rotate Canvas]
 0={0;2;[1000020,20];1;0;0}
 1={1;2;[1000020,1000023,20];1;0;0}
 2={0;2;[1000020];4;0;0}
 3={2;1;[34];0;0;0}
 4={4;1;[35];0;0;0}
 5={3;1;[36];0;0;0}
 
 [Select Layer]
 0={0;2;[];0;0;0}
 
 [Show Popup Palette]
 0={0;2;[];2;0;0}
 
 [Switch Time]
 0={0;1;[1000014];0;0;0}
 1={1;1;[1000012];0;0;0}
 
 [Tool Invocation]
 0={3;2;[1000020];1;0;0}
 1={1;1;[1000005];0;0;0}
 2={0;2;[];1;0;0}
 3={1;1;[1000004];0;0;0}
 4={2;1;[1000000];0;0;0}
 
 [Zoom Canvas]
 0={0;2;[1000021];4;0;0}
 1={2;3;[];0;1;0}
 10={1;2;[1000021,1000023,20];1;0;0}
 11={6;1;[];0;0;0}
 2={3;3;[];0;2;0}
 3={2;1;[3d];0;0;0}
 4={3;1;[2d];0;0;0}
 5={4;1;[1000021,31];0;0;0}
 6={2;1;[2b];0;0;0}
 7={5;1;[1000021,30];0;0;0}
 8={0;4;[];0;0;1}
 9={0;2;[1000021,20];1;0;0}
diff --git a/krita/data/input/tabletpro.profile b/krita/data/input/tabletpro.profile
index 8c5fd77261..14f2cb74f6 100644
--- a/krita/data/input/tabletpro.profile
+++ b/krita/data/input/tabletpro.profile
@@ -1,69 +1,69 @@
 [Alternate Invocation]
 0={4;2;[1000021];1;0;0}
 1={2;2;[1000023,1000021];1;0;0}
 2={3;2;[1000021,1000023];2;0;0}
 3={5;2;[1000021];2;0;0}
 4={0;2;[1000021,1000020];1;0;0}
 5={1;2;[1000023,1000020];1;0;0}
 
 [Change Primary Setting]
 0={0;2;[1000020];1;0;0}
 
 [Exposure or Gamma]
 0={0;2;[59];1;0;0}
 
 [General]
 name=Tablet Pro (for use with the Tablet Pro application on Windows)
-version=3
+version=4
 
 [Pan Canvas]
 0={4;1;[];0;0;0}
 1={3;1;[];0;0;0}
 2={2;1;[];0;0;0}
 3={1;1;[];0;0;0}
 4={0;2;[];4;0;0}
 5={0;2;[20];1;0;0}
 6={0;4;[];0;0;2}
 
 [Rotate Canvas]
 0={3;1;[36];0;0;0}
 1={4;1;[35];0;0;0}
 2={2;1;[34];0;0;0}
 3={0;2;[1000020];4;0;0}
 4={1;2;[1000020,1000023,20];1;0;0}
 5={0;2;[1000020,20];1;0;0}
 6={0;2;[1000039];1;0;0}
 
 [Select Layer]
 0={0;2;[52];1;0;0}
 1={1;2;[1000020,52];1;0;0}
 
 [Show Popup Palette]
 0={0;2;[];2;0;0}
 1={0;1;[1000032];0;0;0}
 
 [Switch Time]
 0={1;1;[1000012];0;0;0}
 1={0;1;[1000014];0;0;0}
 
 [Tool Invocation]
 0={2;1;[1000000];0;0;0}
 1={1;1;[1000004];0;0;0}
 2={0;2;[];1;0;0}
 3={1;1;[1000005];0;0;0}
 4={3;2;[56];1;0;0}
 
 [Zoom Canvas]
 0={0;4;[];0;0;1}
 1={0;2;[5a];1;0;0}
 10={4;1;[31];0;0;0}
 11={5;1;[32];0;0;0}
 12={2;1;[2b];0;0;0}
 2={3;3;[];0;2;0}
 3={2;3;[];0;1;0}
 4={0;2;[1000021];4;0;0}
 5={6;1;[33];0;0;0}
 6={1;2;[1000021,1000023,20];1;0;0}
 7={0;2;[1000021,20];1;0;0}
 8={3;1;[2d];0;0;0}
 9={2;1;[3d];0;0;0}
diff --git a/krita/data/templates/comics/a4_waffle_grid.desktop b/krita/data/templates/comics/a4_waffle_grid.desktop
index 085824b713..1532082c74 100644
--- a/krita/data/templates/comics/a4_waffle_grid.desktop
+++ b/krita/data/templates/comics/a4_waffle_grid.desktop
@@ -1,75 +1,75 @@
 [Desktop Entry]
 Type=Link
 URL=.source/a4_waffle_grid.kra
 Icon=template_comics_empty
 Name=waffle-iron grid
 Name[bs]=mreža sječenog željeza
 Name[ca]=Reixa de ferro
 Name[ca@valencia]=Reixa de ferro
 Name[da]=vaffeljernsgitter
 Name[de]=Waffeleisengitter
 Name[el]=waffle-iron κάνναβος
 Name[en_GB]=waffle-iron grid
 Name[es]=rejilla de hierro para gofres
 Name[et]=Vahvlimasina ruudustik
 Name[eu]=gofreetarako burdinazko sareta
 Name[fi]=vohvelirautaruudukko
 Name[fr]=Grille en métal gaufré
 Name[gl]=Grade de 3×5 viñetas
 Name[is]=vöfflujárnshnit
 Name[it]=Griglia a wafer
 Name[ja]=格子状コマ
 Name[kk]=торлы көзді
 Name[ko]=waffle-iron 그리드
 Name[nb]=vaffeljern-rutenett
 Name[nds]=Wafeliesengadder
 Name[nl]=wafelijzer-raster
 Name[nn]=Vaffeljarn-rutenett
 Name[pl]=siatka gofrownicy
 Name[pt]=grelha de ferro para 'waffles'
 Name[pt_BR]=Grade de ferro vazia
 Name[ru]=Страница с ячейками
 Name[sk]=vaflovo-železná mriežka
 Name[sv]=våffelmönster
 Name[tr]=waffle-çelik ızgara
 Name[uk]=сітка з комірками
 Name[wa]=grile di fier a wåfes
 Name[x-test]=xxwaffle-iron gridxx
 Name[zh_CN]=十五宫格
 Name[zh_TW]=鬆餅機格線
 Comment=300 dpi, A4 waffle-iron grid comic page with ink and color layers
 Comment[bs]=300 dpi, A4 mreža sječenog željeza stranica stripa s slojevima za tintu i bojemreža sječenog željeza
 Comment[ca]=300 ppp, pàgina de còmic amb reixa de ferro amb capes de tinta i color
 Comment[ca@valencia]=300 ppp, pàgina de còmic amb reixa de ferro amb capes de tinta i color
 Comment[da]=300 dpi, A4 tegneserieside i vaffeljernsgitter med blæk og farvelag
 Comment[de]=Comicseite mit Waffeleisengitter-Muster, Tinten- und Farbebenen. Format A4, Auflösung 300 dpi.
 Comment[el]=300 dpi, σελίδα κόμικ A4 με waffle-iron κάνναβο και στρώματα μελάνης και χρώματος
 Comment[en_GB]=300 dpi, A4 waffle-iron grid comic page with ink and colour layers
 Comment[es]=página de cómic con rejilla de hierro para gofres de tamaño A4, a 300 ppp, con tinta y capas de colores
 Comment[et]=300 DPI A4 vahvlimasina ruudustikuga koomiksilehekülg tindi- ja värvikihiga
 Comment[eu]=300 dpi, A4 gofreetarako burdinazko saretadun komiki-orri tintadun eta kolore-geruzaduna
 Comment[fi]=300 dpi:n A4-kokoinen vohvelirautaruudukko sarjakuvalle muste- ja väritasoin
 Comment[fr]=Page de bande dessinée avec grille en métal gaufré en A4 300 dpi avec encre et calques de couleurs
-Comment[gl]=Páxina de banda deseñada de grade en A4 a 300 dpi con 3×5 viñetas regulares e capas de tinta e cor.
+Comment[gl]=Páxina de banda deseñada en A4 a 300 dpi cunha grade de 3×5 viñetas regulares e capas de tinta e cor.
 Comment[is]=300 pát, A4 vöfflujárnshnit teiknimyndasíða með lögum fyrir blek og liti
 Comment[it]=Pagina di fumetti con griglia a wafer a 300 dpi, A4, con livelli per inchiostro e colore
 Comment[ja]=300 dpi A4 サイズの、ペン入れレイヤーと彩色レイヤーを備えた格子状コマテンプレート
 Comment[kk]=300 н/д A4 торлы көзді парақтағы комикс
 Comment[ko]=300 dpi, A4 waffle-iron 그리드 만화 페이지 잉크 및 컬러 레이어
 Comment[nb]=300 dpi, A4 tegneserieside med vaffeljern-rutenett, med tusj- og fargelag
 Comment[nds]=300 dpi, A4 Wafeliesengadder-Comicsiet mit Dint un Klöörlagen.
 Comment[nl]=300 dpi, A4 wafelijzer-raster strippagina met inkt en kleurlagen
 Comment[nn]=300 ppt. vaffelforma A4-rutenett med eigne lag for strek og for fargelegging
 Comment[pl]=300 dpi, strona A4 siatki gofrownicy z warstwami tuszu i koloru
 Comment[pt]=banda desenhada A4, em grelha de 'waffle' a 300 ppp, com camadas de cores e de pinturas
 Comment[pt_BR]=Página de quadrinhos A4, em grade de ferro a 300 ppp, com camadas de cores e de pinturas
 Comment[ru]=300 dpi, страница комикса в формате A4 с ячейками и слоями контуров и цветов
 Comment[sk]=300 dpi, A4 vaflovo železná mriežka komiksovej strany s atramentom a farebnými vrstvami
 Comment[sv]=300 punkter/tum, A4 våffelmönstrad seriesida med bläck- och färglager
 Comment[tr]=300 dpi, A4 waffle-çelik ızgara mürekkep ve renk katmanlı çizgi roman sayfası
 Comment[uk]=300 т/д, сторінка коміксу у форматі A4 з комірками та шарами контурів та кольорів
 Comment[wa]=Pådje A4 di binde d' imådjes avou on discôpaedje come ene grile di fier a wåfes avou des coûtches d' intche eyet d' coleurs.
 Comment[x-test]=xx300 dpi, A4 waffle-iron grid comic page with ink and color layersxx
 Comment[zh_CN]=300 DPI，A4 尺寸的十五宫格网格漫画页，内置线稿和着色图层
 Comment[zh_TW]=300 dpi，A4 大小的烘餅鐵模狀的格線，有墨水與顏色圖層
 X-Krita-Version=28
diff --git a/krita/krita.action b/krita/krita.action
index 0ba5289881..d575792eb0 100644
--- a/krita/krita.action
+++ b/krita/krita.action
@@ -1,3640 +1,3652 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ActionCollection version="2" name="Krita">
   <Actions category="General">
     <text>General</text>
     <Action name="open_resources_directory">
       <icon></icon>
       <text>Open Resources Folder</text>
       <whatsThis>Opens a file browser at the location Krita saves resources such as brushes to.</whatsThis>
       <toolTip>Opens a file browser at the location Krita saves resources such as brushes to.</toolTip>
       <iconText>Open Resources Folder</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="edit_blacklist_cleanup">
       <icon></icon>
       <text>Cleanup removed files...</text>
       <whatsThis></whatsThis>
       <toolTip>Cleanup removed files</toolTip>
       <iconText>Cleanup removed files</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="windows_cascade">
       <icon></icon>
       <text>C&amp;ascade</text>
       <whatsThis></whatsThis>
       <toolTip>Cascade</toolTip>
       <iconText>Cascade</iconText>
       <activationFlags>10</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="windows_tile">
       <icon></icon>
       <text>&amp;Tile</text>
       <whatsThis></whatsThis>
       <toolTip>Tile</toolTip>
       <iconText>Tile</iconText>
       <activationFlags>10</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="create_bundle">
       <icon></icon>
       <text>Create Resource Bundle...</text>
       <whatsThis></whatsThis>
       <toolTip>Create Resource Bundle</toolTip>
       <iconText>Create Resource Bundle</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="mainToolBar">
       <icon></icon>
       <text>Show File Toolbar</text>
       <whatsThis></whatsThis>
       <toolTip>Show File Toolbar</toolTip>
       <iconText>Show File Toolbar</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="show_color_selector">
       <icon></icon>
       <text>Show color selector</text>
       <whatsThis></whatsThis>
       <toolTip>Show color selector</toolTip>
       <iconText>Show color selector</iconText>
       <shortcut>Shift+I</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="show_mypaint_shade_selector">
       <icon></icon>
       <text>Show MyPaint shade selector</text>
       <whatsThis></whatsThis>
       <toolTip>Show MyPaint shade selector</toolTip>
       <iconText>Show MyPaint shade selector</iconText>
       <shortcut>Shift+M</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="show_minimal_shade_selector">
       <icon></icon>
       <text>Show minimal shade selector</text>
       <whatsThis></whatsThis>
       <toolTip>Show minimal shade selector</toolTip>
       <iconText>Show minimal shade selector</iconText>
       <shortcut>Shift+N</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="show_color_history">
       <icon></icon>
       <text>Show color history</text>
       <whatsThis></whatsThis>
       <toolTip>Show color history</toolTip>
       <iconText>Show color history</iconText>
       <shortcut>H</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="show_common_colors">
       <icon></icon>
       <text>Show common colors</text>
       <whatsThis></whatsThis>
       <toolTip>Show common colors</toolTip>
       <iconText>Show common colors</iconText>
       <shortcut>U</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="show_tool_options">
       <icon></icon>
       <text>Show Tool Options</text>
       <whatsThis></whatsThis>
       <toolTip>Show Tool Options</toolTip>
       <iconText>Show Tool Options</iconText>
       <shortcut>\</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="show_brush_editor">
       <icon></icon>
       <text>Show Brush Editor</text>
       <whatsThis></whatsThis>
       <toolTip>Show Brush Editor</toolTip>
       <iconText>Show Brush Editor</iconText>
       <shortcut>F5</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="show_brush_presets">
       <icon></icon>
       <text>Show Brush Presets</text>
       <whatsThis></whatsThis>
       <toolTip>Show Brush Presets</toolTip>
       <iconText>Show Brush Presets</iconText>
       <shortcut>F6</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="tablet_debugger">
       <icon></icon>
       <text>Toggle Tablet Debugger</text>
       <whatsThis></whatsThis>
       <toolTip>Toggle Tablet Debugger</toolTip>
       <iconText>Toggle Tablet Debugger</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+Shift+T</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
 
 
     <Action name="buginfo">
       <icon></icon>
       <text>Show system information for bug reports.</text>
       <whatsThis></whatsThis>
       <toolTip>Show system information for bug reports.</toolTip>
       <iconText>Show system information for bug reports.</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
 
     <Action name="rename_composition">
       <icon></icon>
       <text>Rename Composition...</text>
       <whatsThis></whatsThis>
       <toolTip>Rename Composition</toolTip>
       <iconText>Rename Composition</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="update_composition">
       <icon></icon>
       <text>Update Composition</text>
       <whatsThis></whatsThis>
       <toolTip>Update Composition</toolTip>
       <iconText>Update Composition</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="ruler_pixel_multiple2">
       <icon></icon>
       <text>Use multiple of 2 for pixel scale</text>
       <whatsThis>Use multiple of 2 for pixel scale</whatsThis>
       <toolTip>Use multiple of 2 for pixel scale</toolTip>
       <iconText>Use multiple of 2 for pixel scale</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="invert_selection">
       <icon></icon>
       <text>&amp;Invert Selection</text>
       <whatsThis></whatsThis>
       <toolTip>Invert current selection</toolTip>
       <iconText>Invert Selection</iconText>
       <activationFlags>10000000000</activationFlags>
       <activationConditions>100</activationConditions>
       <shortcut>Ctrl+Shift+I</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="create_snapshot">
       <icon></icon>
       <text>Create Snapshot</text>
       <whatsThis></whatsThis>
       <toolTip>Create Snapshot</toolTip>
       <iconText></iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="switchto_snapshot">
       <icon></icon>
       <text>Switch to Selected Snapshot</text>
       <whatsThis></whatsThis>
       <toolTip>Switch to selected snapshot</toolTip>
       <iconText></iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="remove_snapshot">
       <icon></icon>
       <text>Remove Selected Snapshot</text>
       <whatsThis></whatsThis>
       <toolTip>Remove Selected Snapshot</toolTip>
       <iconText></iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
   </Actions>
 
   <Actions category="Painting">
     <text>Painting</text>
     <Action name="make_brush_color_lighter">
       <icon>lightness-increase</icon>
       <text>Make brush color lighter</text>
       <whatsThis></whatsThis>
       <toolTip>Make brush color lighter</toolTip>
       <iconText>Make brush color lighter</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>L</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="make_brush_color_darker">
       <icon>lightness-decrease</icon>
       <text>Make brush color darker</text>
       <whatsThis></whatsThis>
       <toolTip>Make brush color darker</toolTip>
       <iconText>Make brush color darker</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>K</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="make_brush_color_saturated">
       <icon></icon>
       <text>Make brush color more saturated</text>
       <whatsThis></whatsThis>
       <toolTip>Make brush color more saturated</toolTip>
       <iconText>Make brush color more saturated</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="make_brush_color_desaturated">
       <icon></icon>
       <text>Make brush color more desaturated</text>
       <whatsThis></whatsThis>
       <toolTip>Make brush color more desaturated</toolTip>
       <iconText>Make brush color more desaturated</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="shift_brush_color_clockwise">
       <icon></icon>
       <text>Shift brush color hue clockwise</text>
       <whatsThis></whatsThis>
       <toolTip>Shift brush color hue clockwise</toolTip>
       <iconText>Shift brush color hue clockwise</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="shift_brush_color_counter_clockwise">
       <icon></icon>
       <text>Shift brush color hue counter-clockwise</text>
       <whatsThis></whatsThis>
       <toolTip>Shift brush color hue counter-clockwise</toolTip>
       <iconText>Shift brush color hue counter-clockwise</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="make_brush_color_redder">
       <icon></icon>
       <text>Make brush color more red</text>
       <whatsThis></whatsThis>
       <toolTip>Make brush color more red</toolTip>
       <iconText>Make brush color more red</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="make_brush_color_greener">
       <icon></icon>
       <text>Make brush color more green</text>
       <whatsThis></whatsThis>
       <toolTip>Make brush color more green</toolTip>
       <iconText>Make brush color more green</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="make_brush_color_bluer">
       <icon></icon>
       <text>Make brush color more blue</text>
       <whatsThis></whatsThis>
       <toolTip>Make brush color more blue</toolTip>
       <iconText>Make brush color more blue</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="make_brush_color_yellower">
       <icon></icon>
     <text>Make brush color more yellow</text>
       <whatsThis></whatsThis>
       <toolTip>Make brush color more yellow</toolTip>
       <iconText>Make brush color more yellow</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="increase_opacity">
       <icon>opacity-increase</icon>
       <text>Increase opacity</text>
       <whatsThis></whatsThis>
       <toolTip>Increase opacity</toolTip>
       <iconText>Increase opacity</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>O</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="decrease_opacity">
       <icon>opacity-decrease</icon>
       <text>Decrease opacity</text>
       <whatsThis></whatsThis>
       <toolTip>Decrease opacity</toolTip>
       <iconText>Decrease opacity</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>I</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="erase_action">
       <icon>draw-eraser</icon>
       <text>Set eraser mode</text>
       <whatsThis></whatsThis>
       <toolTip>Set eraser mode</toolTip>
       <iconText>Set eraser mode</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>E</shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="reload_preset_action">
       <icon>view-refresh</icon>
       <text>Reload Original Preset</text>
       <whatsThis></whatsThis>
       <toolTip>Reload Original Preset</toolTip>
       <iconText>Reload Original Preset</iconText>
       <activationFlags>10000</activationFlags>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="preserve_alpha">
       <icon>transparency-unlocked</icon>
       <text>Preserve Alpha</text>
       <whatsThis></whatsThis>
       <toolTip>Preserve Alpha</toolTip>
       <iconText>Preserve Alpha</iconText>
       <activationFlags>10000</activationFlags>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="disable_pressure">
       <icon>transform_icons_penPressure</icon>
       <text>Use Pen Pressure</text>
       <whatsThis></whatsThis>
       <toolTip>Use Pen Pressure</toolTip>
       <iconText>Use Pen Pressure</iconText>
       <activationFlags>10000</activationFlags>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="hmirror_action">
       <icon>symmetry-horizontal</icon>
       <text>Horizontal Mirror Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Horizontal Mirror Tool</toolTip>
       <iconText>Horizontal Mirror Tool</iconText>
       <activationFlags>0</activationFlags>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="vmirror_action">
       <icon>symmetry-vertical</icon>
       <text>Vertical Mirror Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Vertical Mirror Tool</toolTip>
       <iconText>Vertical Mirror Tool</iconText>
       <activationFlags>0</activationFlags>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="mirrorX-hideDecorations">
       <icon></icon>
       <text>Hide Mirror X Line</text>
       <whatsThis></whatsThis>
       <toolTip>Hide Mirror X Line</toolTip>
       <iconText>Hide Mirror X Line</iconText>
       <activationFlags>10000</activationFlags>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="mirrorY-hideDecorations">
       <icon></icon>
       <text>Hide Mirror Y Line</text>
       <whatsThis></whatsThis>
       <toolTip>Hide Mirror Y Line</toolTip>
       <iconText>Hide Mirror Y Line</iconText>
       <activationFlags>10000</activationFlags>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
    <Action name="mirrorX-lock">
       <icon></icon>
       <text>Lock</text>
       <whatsThis></whatsThis>
       <toolTip>Lock X Line</toolTip>
       <iconText>Lock X Line</iconText>
       <activationFlags>10000</activationFlags>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
    <Action name="mirrorY-lock">
       <icon></icon>
       <text>Lock Y Line</text>
       <whatsThis></whatsThis>
       <toolTip>Lock Y Line</toolTip>
       <iconText>Lock Y Line</iconText>
       <activationFlags>10000</activationFlags>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
    <Action name="mirrorX-moveToCenter">
       <icon></icon>
-      <text>Move to Canvas Center</text>
+      <text>Move to Canvas Center X</text>
       <whatsThis></whatsThis>
       <toolTip>Move to Canvas Center X</toolTip>
       <iconText>Move to Canvas Center X</iconText>
       <activationFlags>10000</activationFlags>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="mirrorY-moveToCenter">
       <icon></icon>
       <text>Move to Canvas Center Y</text>
       <whatsThis></whatsThis>
       <toolTip>Move to Canvas Center Y</toolTip>
       <iconText>Move to Canvas Center Y</iconText>
       <activationFlags>10000</activationFlags>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="toggle-selection-overlay-mode">
       <icon></icon>
       <text>&amp;Toggle Selection Display Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Toggle Selection Display Mode</toolTip>
       <iconText>Toggle Selection Display Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="next_favorite_preset">
       <icon></icon>
       <text>Next Favourite Preset</text>
       <whatsThis></whatsThis>
       <toolTip>Next Favourite Preset</toolTip>
       <iconText>Next Favourite Preset</iconText>
       <shortcut>,</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="previous_favorite_preset">
       <icon></icon>
       <text>Previous Favourite Preset</text>
       <whatsThis></whatsThis>
       <toolTip>Previous Favourite Preset</toolTip>
       <iconText>Previous Favourite Preset</iconText>
       <shortcut>.</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="previous_preset">
       <icon>preset-switcher</icon>
       <text>Switch to Previous Preset</text>
       <whatsThis></whatsThis>
       <toolTip>Switch to Previous Preset</toolTip>
       <iconText>Switch to Previous Preset</iconText>
       <shortcut>/</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="BrushesAndStuff">
       <icon></icon>
       <text>Hide Brushes and Stuff Toolbar</text>
       <whatsThis></whatsThis>
       <toolTip>Hide Brushes and Stuff Toolbar</toolTip>
       <iconText>Hide Brushes and Stuff Toolbar</iconText>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="reset_fg_bg">
       <icon></icon>
       <text>Reset Foreground and Background Color</text>
       <whatsThis></whatsThis>
       <toolTip>Reset Foreground and Background Color</toolTip>
       <iconText>Reset Foreground and Background Color</iconText>
       <shortcut>D</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="toggle_fg_bg">
       <icon></icon>
       <text>Swap Foreground and Background Color</text>
       <whatsThis></whatsThis>
       <toolTip>Swap Foreground and Background Color</toolTip>
       <iconText>Swap Foreground and Background Color</iconText>
       <shortcut>X</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="selection_tool_mode_add">
       <icon></icon>
       <text>Selection Mode: Add</text>
       <whatsThis></whatsThis>
       <toolTip>Selection Mode: Add</toolTip>
       <iconText>Selection Mode: Add</iconText>
       <shortcut>A</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="selection_tool_mode_subtract">
       <icon></icon>
       <text>Selection Mode: Subtract</text>
       <whatsThis></whatsThis>
       <toolTip>Selection Mode: Subtract</toolTip>
       <iconText>Selection Mode: Subtract</iconText>
       <shortcut>S</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="selection_tool_mode_intersect">
       <icon></icon>
       <text>Selection Mode: Intersect</text>
       <whatsThis></whatsThis>
       <toolTip>Selection Mode: Intersect</toolTip>
       <iconText>Selection Mode: Intersect</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="selection_tool_mode_replace">
       <icon></icon>
       <text>Selection Mode: Replace</text>
       <whatsThis></whatsThis>
       <toolTip>Selection Mode: Replace</toolTip>
       <iconText>Selection Mode: Replace</iconText>
       <shortcut>R</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="set_weighted_brush_smoothing">
       <icon>smoothing-weighted</icon>
       <text>Brush Smoothing: Weighted</text>
       <whatsThis></whatsThis>
       <toolTip>Brush Smoothing: Weighted</toolTip>
       <iconText>Brush Smoothing: Weighted</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="set_no_brush_smoothing">
       <icon>smoothing-no</icon>
       <text>Brush Smoothing: Disabled</text>
       <whatsThis></whatsThis>
       <toolTip>Brush Smoothing: Disabled</toolTip>
       <iconText>Brush Smoothing: Disabled</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="set_stabilizer_brush_smoothing">
       <icon>smoothing-stabilizer</icon>
       <text>Brush Smoothing: Stabilizer</text>
       <whatsThis></whatsThis>
       <toolTip>Brush Smoothing: Stabilizer</toolTip>
       <iconText>Brush Smoothing: Stabilizer</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="decrease_brush_size">
       <icon>brushsize-decrease</icon>
       <text>Decrease Brush Size</text>
       <whatsThis></whatsThis>
       <toolTip>Decrease Brush Size</toolTip>
       <iconText>Decrease Brush Size</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>[</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="set_simple_brush_smoothing">
       <icon>smoothing-basic</icon>
       <text>Brush Smoothing: Basic</text>
       <whatsThis></whatsThis>
       <toolTip>Brush Smoothing: Basic</toolTip>
       <iconText>Brush Smoothing: Basic</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="increase_brush_size">
       <icon>brushsize-increase</icon>
       <text>Increase Brush Size</text>
       <whatsThis></whatsThis>
       <toolTip>Increase Brush Size</toolTip>
       <iconText>Increase Brush Size</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>]</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="toggle_assistant">
       <icon></icon>
       <text>Toggle Assistant</text>
       <whatsThis></whatsThis>
       <toolTip>Toggle Assistant</toolTip>
       <iconText>ToggleAssistant</iconText>
       <shortcut>Ctrl+Shift+L</shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="undo_polygon_selection">
       <icon></icon>
       <text>Undo Polygon Selection Points</text>
       <whatsThis></whatsThis>
       <toolTip>Undo Polygon Selection Points</toolTip>
       <iconText>Undo Polygon Selection Points</iconText>
       <shortcut>Shift+Z</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="fill_selection_foreground_color_opacity">
       <icon></icon>
       <text>Fill with Foreground Color (Opacity)</text>
       <whatsThis></whatsThis>
       <toolTip>Fill with Foreground Color (Opacity)</toolTip>
       <iconText>Fill with Foreground Color (Opacity)</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut>Ctrl+Shift+Backspace</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="fill_selection_background_color_opacity">
       <icon></icon>
       <text>Fill with Background Color (Opacity)</text>
       <whatsThis></whatsThis>
       <toolTip>Fill with Background Color (Opacity)</toolTip>
       <iconText>Fill with Background Color (Opacity)</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut>Ctrl+Backspace</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="fill_selection_pattern_opacity">
       <icon></icon>
       <text>Fill with Pattern (Opacity)</text>
       <whatsThis></whatsThis>
       <toolTip>Fill with Pattern (Opacity)</toolTip>
       <iconText>Fill with Pattern (Opacity)</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="convert_selection_to_shape">
       <icon></icon>
       <text>Convert &amp;to Shape</text>
       <whatsThis></whatsThis>
       <toolTip>Convert to Shape</toolTip>
       <iconText>Convert to Shape</iconText>
       <activationFlags>10000000000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="show-global-selection-mask">
       <icon></icon>
       <text>&amp;Show Global Selection Mask</text>
       <whatsThis></whatsThis>
       <toolTip>Shows global selection as a usual selection mask in &lt;interface>Layers&lt;/interface> docker</toolTip>
       <iconText>Show Global Selection Mask</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>100</activationConditions>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
   </Actions>
 
   <Actions category="Filters">
     <text>Filters</text>
     <Action name="krita_filter_colortoalpha">
       <icon>color-to-alpha</icon>
       <text>&amp;Color to Alpha...</text>
       <whatsThis></whatsThis>
       <toolTip>Color to Alpha</toolTip>
       <iconText>Color to Alpha</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_top edge detections">
       <icon></icon>
       <text>&amp;Top Edge Detection</text>
       <whatsThis></whatsThis>
       <toolTip>Top Edge Detection</toolTip>
       <iconText>Top Edge Detection</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_indexcolors">
       <icon></icon>
       <text>&amp;Index Colors...</text>
       <whatsThis></whatsThis>
       <toolTip>Index Colors</toolTip>
       <iconText>Index Colors</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_emboss horizontal only">
       <icon></icon>
       <text>Emboss Horizontal &amp;Only</text>
       <whatsThis></whatsThis>
       <toolTip>Emboss Horizontal Only</toolTip>
       <iconText>Emboss Horizontal Only</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_dodge">
       <icon></icon>
       <text>D&amp;odge</text>
       <whatsThis></whatsThis>
       <toolTip>Dodge</toolTip>
       <iconText>Dodge</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_sharpen">
       <icon></icon>
       <text>&amp;Sharpen</text>
       <whatsThis></whatsThis>
       <toolTip>Sharpen</toolTip>
       <iconText>Sharpen</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_burn">
       <icon></icon>
       <text>B&amp;urn</text>
       <whatsThis></whatsThis>
       <toolTip>Burn</toolTip>
       <iconText>Burn</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_mean removal">
       <icon></icon>
       <text>&amp;Mean Removal</text>
       <whatsThis></whatsThis>
       <toolTip>Mean Removal</toolTip>
       <iconText>Mean Removal</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_gaussian blur">
       <icon></icon>
       <text>&amp;Gaussian Blur...</text>
       <whatsThis></whatsThis>
       <toolTip>Gaussian Blur</toolTip>
       <iconText>Gaussian Blur</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_emboss all directions">
       <icon></icon>
       <text>Emboss &amp;in All Directions</text>
       <whatsThis></whatsThis>
       <toolTip>Emboss in All Directions</toolTip>
       <iconText>Emboss in All Directions</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_smalltiles">
       <icon></icon>
       <text>&amp;Small Tiles...</text>
       <whatsThis></whatsThis>
       <toolTip>Small Tiles</toolTip>
       <iconText>Small Tiles</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_levels">
       <icon></icon>
       <text>&amp;Levels...</text>
       <whatsThis></whatsThis>
       <toolTip>Levels</toolTip>
       <iconText>Levels</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+L</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_sobel">
       <icon></icon>
       <text>&amp;Sobel...</text>
       <whatsThis></whatsThis>
       <toolTip>Sobel</toolTip>
       <iconText>Sobel</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_wave">
       <icon></icon>
       <text>&amp;Wave...</text>
       <whatsThis></whatsThis>
       <toolTip>Wave</toolTip>
       <iconText>Wave</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_motion blur">
       <icon></icon>
       <text>&amp;Motion Blur...</text>
       <whatsThis></whatsThis>
       <toolTip>Motion Blur</toolTip>
       <iconText>Motion Blur</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_invert">
       <icon></icon>
       <text>&amp;Invert</text>
       <whatsThis></whatsThis>
       <toolTip>Invert</toolTip>
       <iconText>Invert</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+I</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_perchannel">
       <icon></icon>
       <text>&amp;Color Adjustment curves...</text>
       <whatsThis></whatsThis>
       <toolTip>Color Adjustment curves</toolTip>
       <iconText>Color Adjustment curves</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+M</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_pixelize">
       <icon></icon>
       <text>Pi&amp;xelize...</text>
       <whatsThis></whatsThis>
       <toolTip>Pixelize</toolTip>
       <iconText>Pixelize</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_emboss laplascian">
       <icon></icon>
       <text>Emboss (&amp;Laplacian)</text>
       <whatsThis></whatsThis>
       <toolTip>Emboss (Laplacian)</toolTip>
       <iconText>Emboss (Laplacian)</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_left edge detections">
       <icon></icon>
       <text>&amp;Left Edge Detection</text>
       <whatsThis></whatsThis>
       <toolTip>Left Edge Detection</toolTip>
       <iconText>Left Edge Detection</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_blur">
       <icon></icon>
       <text>&amp;Blur...</text>
       <whatsThis></whatsThis>
       <toolTip>Blur</toolTip>
       <iconText>Blur</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_raindrops">
       <icon></icon>
       <text>&amp;Raindrops...</text>
       <whatsThis></whatsThis>
       <toolTip>Raindrops</toolTip>
       <iconText>Raindrops</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_bottom edge detections">
       <icon></icon>
       <text>&amp;Bottom Edge Detection</text>
       <whatsThis></whatsThis>
       <toolTip>Bottom Edge Detection</toolTip>
       <iconText>Bottom Edge Detection</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_noise">
       <icon></icon>
       <text>&amp;Random Noise...</text>
       <whatsThis></whatsThis>
       <toolTip>Random Noise</toolTip>
       <iconText>Random Noise</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_brightnesscontrast">
       <icon></icon>
       <text>&amp;Brightness/Contrast curve...</text>
       <whatsThis></whatsThis>
       <toolTip>Brightness/Contrast curve</toolTip>
       <iconText>Brightness/Contrast curve</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_colorbalance">
       <icon></icon>
       <text>Colo&amp;r Balance...</text>
       <whatsThis></whatsThis>
       <toolTip>Color Balance</toolTip>
       <iconText>Color Balance</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+B</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_phongbumpmap">
       <icon></icon>
       <text>&amp;Phong Bumpmap...</text>
       <whatsThis></whatsThis>
       <toolTip>Phong Bumpmap</toolTip>
       <iconText>Phong Bumpmap</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_desaturate">
       <icon></icon>
       <text>&amp;Desaturate</text>
       <whatsThis></whatsThis>
       <toolTip>Desaturate</toolTip>
       <iconText>Desaturate</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+Shift+U</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_colortransfer">
       <icon></icon>
       <text>Color &amp;Transfer...</text>
       <whatsThis></whatsThis>
       <toolTip>Color Transfer</toolTip>
       <iconText>Color Transfer</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_emboss vertical only">
       <icon></icon>
       <text>Emboss &amp;Vertical Only</text>
       <whatsThis></whatsThis>
       <toolTip>Emboss Vertical Only</toolTip>
       <iconText>Emboss Vertical Only</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_lens blur">
       <icon></icon>
       <text>&amp;Lens Blur...</text>
       <whatsThis></whatsThis>
       <toolTip>Lens Blur</toolTip>
       <iconText>Lens Blur</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_minimize">
       <icon></icon>
       <text>M&amp;inimize Channel</text>
       <whatsThis></whatsThis>
       <toolTip>Minimize Channel</toolTip>
       <iconText>Minimize Channel</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_maximize">
       <icon></icon>
       <text>M&amp;aximize Channel</text>
       <whatsThis></whatsThis>
       <toolTip>Maximize Channel</toolTip>
       <iconText>Maximize Channel</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_oilpaint">
       <icon></icon>
       <text>&amp;Oilpaint...</text>
       <whatsThis></whatsThis>
       <toolTip>Oilpaint</toolTip>
       <iconText>Oilpaint</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_right edge detections">
       <icon></icon>
       <text>&amp;Right Edge Detection</text>
       <whatsThis></whatsThis>
       <toolTip>Right Edge Detection</toolTip>
       <iconText>Right Edge Detection</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_autocontrast">
       <icon></icon>
       <text>&amp;Auto Contrast</text>
       <whatsThis></whatsThis>
       <toolTip>Auto Contrast</toolTip>
       <iconText>Auto Contrast</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_roundcorners">
       <icon></icon>
       <text>&amp;Round Corners...</text>
       <whatsThis></whatsThis>
       <toolTip>Round Corners</toolTip>
       <iconText>Round Corners</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_unsharp">
       <icon></icon>
       <text>&amp;Unsharp Mask...</text>
       <whatsThis></whatsThis>
       <toolTip>Unsharp Mask</toolTip>
       <iconText>Unsharp Mask</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_emboss">
       <icon></icon>
       <text>&amp;Emboss with Variable Depth...</text>
       <whatsThis></whatsThis>
       <toolTip>Emboss with Variable Depth</toolTip>
       <iconText>Emboss with Variable Depth</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_emboss horizontal and vertical">
       <icon></icon>
       <text>Emboss &amp;Horizontal &amp;&amp; Vertical</text>
       <whatsThis></whatsThis>
       <toolTip>Emboss Horizontal &amp; Vertical</toolTip>
       <iconText>Emboss Horizontal &amp; Vertical</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_randompick">
       <icon></icon>
       <text>Random &amp;Pick...</text>
       <whatsThis></whatsThis>
       <toolTip>Random Pick</toolTip>
       <iconText>Random Pick</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_gaussiannoisereducer">
       <icon></icon>
       <text>&amp;Gaussian Noise Reduction...</text>
       <whatsThis></whatsThis>
       <toolTip>Gaussian Noise Reduction</toolTip>
       <iconText>Gaussian Noise Reduction</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_posterize">
       <icon></icon>
       <text>&amp;Posterize...</text>
       <whatsThis></whatsThis>
       <toolTip>Posterize</toolTip>
       <iconText>Posterize</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_waveletnoisereducer">
       <icon></icon>
       <text>&amp;Wavelet Noise Reducer...</text>
       <whatsThis></whatsThis>
       <toolTip>Wavelet Noise Reducer</toolTip>
       <iconText>Wavelet Noise Reducer</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_hsvadjustment">
       <icon></icon>
       <text>&amp;HSV Adjustment...</text>
       <whatsThis></whatsThis>
       <toolTip>HSV Adjustment</toolTip>
       <iconText>HSV Adjustment</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+U</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
   </Actions>
 
   <Actions category="tool-shortcuts">
     <text>Tool Shortcuts</text>
     <Action name="KritaShape/KisToolDyna">
       <icon></icon>
       <text>Dynamic Brush Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Dynamic Brush Tool</toolTip>
       <iconText>Dynamic Brush Tool</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KisToolCrop">
       <icon></icon>
       <text>Crop Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Crop the image to an area</toolTip>
       <iconText>Crop the image to an area</iconText>
       <shortcut>C</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KisToolPolygon">
       <icon></icon>
       <text>Polygon Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Polygon Tool. Shift-mouseclick ends the polygon.</toolTip>
       <iconText>Polygon Tool. Shift-mouseclick ends the polygon.</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KritaShape/KisToolRectangle">
       <icon></icon>
       <text>Rectangle Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Rectangle Tool</toolTip>
       <iconText>Rectangle Tool</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KritaShape/KisToolMultiBrush">
       <icon></icon>
       <text>Multibrush Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Multibrush Tool</toolTip>
       <iconText>Multibrush Tool</iconText>
       <shortcut>Q</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KritaShape/KisToolLazyBrush">
       <icon></icon>
       <text>Colorize Mask Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Colorize Mask Tool</toolTip>
       <iconText>Colorize Mask Tool</iconText>
       <shortcut></shortcut>
       <statusTip></statusTip>
     </Action>
     <Action name="KritaShape/KisToolSmartPatch">
       <icon></icon>
       <text>Smart Patch Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Smart Patch Tool</toolTip>
       <iconText>Smart Patch Tool</iconText>
       <shortcut></shortcut>
       <statusTip></statusTip>
     </Action>
     <Action name="PanTool">
       <icon></icon>
       <text>Pan Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Pan Tool</toolTip>
       <iconText>Pan Tool</iconText>
       <shortcut></shortcut>
       <statusTip></statusTip>
     </Action>
     <Action name="InteractionTool">
       <icon></icon>
       <text>Select Shapes Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Select Shapes Tool</toolTip>
       <iconText>Select Shapes Tool</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KritaSelected/KisToolColorPicker">
       <icon></icon>
       <text>Color Picker</text>
       <whatsThis></whatsThis>
       <toolTip>Select a color from the image or current layer</toolTip>
       <iconText>Select a color from the image or current layer</iconText>
       <shortcut>P</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KisToolSelectOutline">
       <icon></icon>
       <text>Outline Selection Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Outline Selection Tool</toolTip>
       <iconText>Outline Selection Tool</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KisToolSelectPath">
       <icon></icon>
       <text>Bezier Curve Selection Tool</text>
       <whatsThis></whatsThis>
-      <toolTip>Select a </toolTip>
+      <toolTip>Bezier Curve Selection Tool</toolTip>
       <iconText>Bezier Curve Selection Tool</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KisToolSelectSimilar">
       <icon></icon>
       <text>Similar Color Selection Tool</text>
       <whatsThis></whatsThis>
-      <toolTip>Select a </toolTip>
+      <toolTip>Similar Color Selection Tool</toolTip>
       <iconText>Similar Color Selection Tool</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KritaFill/KisToolFill">
       <icon></icon>
       <text>Fill Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Fill a contiguous area of color with a color, or fill a selection.</toolTip>
       <iconText>Fill a contiguous area of color with a color, or fill a selection.</iconText>
       <shortcut>F</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KritaShape/KisToolLine">
       <icon></icon>
       <text>Line Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Line Tool</toolTip>
       <iconText>Line Tool</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KisToolPencil">
       <icon></icon>
       <text>Freehand Path Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Freehand Path Tool</toolTip>
       <iconText>Freehand Path Tool</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KisToolPath">
       <icon></icon>
       <text>Bezier Curve Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Bezier Curve Tool. Shift-mouseclick or double-click ends the curve.</toolTip>
       <iconText>Bezier Curve Tool. Shift-mouseclick or double-click ends the curve.</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KritaShape/KisToolEllipse">
       <icon></icon>
       <text>Ellipse Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Ellipse Tool</toolTip>
       <iconText>Ellipse Tool</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KritaShape/KisToolBrush">
       <icon></icon>
       <text>Freehand Brush Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Freehand Brush Tool</toolTip>
       <iconText>Freehand Brush Tool</iconText>
       <shortcut>B</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="CreateShapesTool">
       <icon></icon>
       <text>Create object</text>
       <whatsThis></whatsThis>
       <toolTip>Create object</toolTip>
       <iconText>Create object</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KisToolSelectElliptical">
       <icon></icon>
       <text>Elliptical Selection Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Elliptical Selection Tool</toolTip>
       <iconText>Elliptical Selection Tool</iconText>
       <shortcut>J</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KisToolSelectContiguous">
       <icon></icon>
       <text>Contiguous Selection Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Contiguous Selection Tool</toolTip>
       <iconText>Contiguous Selection Tool</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KarbonPatternTool">
       <icon></icon>
       <text>Pattern editing</text>
       <whatsThis></whatsThis>
       <toolTip>Pattern editing</toolTip>
       <iconText>Pattern editing</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="ReviewTool">
       <icon></icon>
       <text>Review</text>
       <whatsThis></whatsThis>
       <toolTip>Review</toolTip>
       <iconText>Review</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KritaFill/KisToolGradient">
       <icon></icon>
       <text>Draw a gradient.</text>
       <whatsThis></whatsThis>
       <toolTip>Draw a gradient.</toolTip>
       <iconText>Draw a gradient.</iconText>
       <shortcut>G</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KisToolSelectPolygonal">
       <icon></icon>
       <text>Polygonal Selection Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Polygonal Selection Tool</toolTip>
       <iconText>Polygonal Selection Tool</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KritaShape/KisToolMeasure">
       <icon></icon>
       <text>Measurement Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Measure the distance between two points</toolTip>
       <iconText>Measure the distance between two points</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KisToolSelectRectangular">
       <icon></icon>
       <text>Rectangular Selection Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Rectangular Selection Tool</toolTip>
       <iconText>Rectangular Selection Tool</iconText>
       <shortcut>Ctrl+R</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KritaTransform/KisToolMove">
       <icon></icon>
       <text>Move Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Move a layer</toolTip>
       <iconText>Move a layer</iconText>
       <shortcut>T</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="VectorTool">
       <icon></icon>
       <text>Vector Image Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Vector Image (EMF/WMF/SVM/SVG) tool</toolTip>
       <iconText>Vector Image (EMF/WMF/SVM/SVG) tool</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KarbonCalligraphyTool">
       <icon></icon>
       <text>Calligraphy</text>
       <whatsThis></whatsThis>
       <toolTip>Calligraphy</toolTip>
       <iconText>Calligraphy</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="PathTool">
       <icon></icon>
       <text>Path editing</text>
       <whatsThis></whatsThis>
       <toolTip>Path editing</toolTip>
       <iconText>Path editing</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="ZoomTool">
       <icon></icon>
       <text>Zoom Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Zoom Tool</toolTip>
       <iconText>Zoom Tool</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KisToolPolyline">
       <icon></icon>
       <text>Polyline Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Polyline Tool. Shift-mouseclick ends the polyline.</toolTip>
       <iconText>Polyline Tool. Shift-mouseclick ends the polyline.</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KisToolTransform">
       <icon></icon>
       <text>Transform Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Transform a layer or a selection</toolTip>
       <iconText>Transform a layer or a selection</iconText>
       <shortcut>Ctrl+T</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KisAssistantTool">
       <icon></icon>
       <text>Assistant Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Assistant Tool</toolTip>
       <iconText>Assistant Tool</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KarbonGradientTool">
       <icon></icon>
       <text>Gradient Editing Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Gradient editing</toolTip>
       <iconText>Gradient editing</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="ToolReferenceImages">
       <icon></icon>
       <text>Reference Images Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Reference Images Tool</toolTip>
       <iconText>Reference Images Tool</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
   </Actions>
 
   <Actions category="Blending Modes">
     <text>Blending Modes</text>
 
 <!-- commented out in the code right now
     <Action name="Next Blending Mode">
       <icon></icon>
       <text>Next Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Next Blending Mode</toolTip>
       <iconText>Next Blending Mode</iconText>
       <shortcut>Alt+Shift++</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Previous Blending Mode">
       <icon></icon>
       <text>Previous Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Previous Blending Mode</toolTip>
       <iconText>Previous Blending Mode</iconText>
       <shortcut>Alt+Shift+-</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 -->
     <Action name="Select Normal Blending Mode">
       <icon></icon>
       <text>Select Normal Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Normal Blending Mode</toolTip>
       <iconText>Select Normal Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+N</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Dissolve Blending Mode">
       <icon></icon>
       <text>Select Dissolve Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Dissolve Blending Mode</toolTip>
       <iconText>Select Dissolve Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+I</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Behind Blending Mode">
       <icon></icon>
       <text>Select Behind Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Behind Blending Mode</toolTip>
       <iconText>Select Behind Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+Q</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Clear Blending Mode">
       <icon></icon>
       <text>Select Clear Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Clear Blending Mode</toolTip>
       <iconText>Select Clear Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+R</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Darken Blending Mode">
       <icon></icon>
       <text>Select Darken Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Darken Blending Mode</toolTip>
       <iconText>Select Darken Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+K</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Multiply Blending Mode">
       <icon></icon>
       <text>Select Multiply Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Multiply Blending Mode</toolTip>
       <iconText>Select Multiply Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+M</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Color Burn Blending Mode">
       <icon></icon>
       <text>Select Color Burn Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Color Burn Blending Mode</toolTip>
       <iconText>Select Color Burn Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+B</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Linear Burn Blending Mode">
       <icon></icon>
       <text>Select Linear Burn Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Linear Burn Blending Mode</toolTip>
       <iconText>Select Linear Burn Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+A</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Lighten Blending Mode">
       <icon></icon>
       <text>Select Lighten Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Lighten Blending Mode</toolTip>
       <iconText>Select Lighten Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+G</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Screen Blending Mode">
       <icon></icon>
       <text>Select Screen Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Screen Blending Mode</toolTip>
       <iconText>Select Screen Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+S</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Color Dodge Blending Mode">
       <icon></icon>
       <text>Select Color Dodge Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Color Dodge Blending Mode</toolTip>
       <iconText>Select Color Dodge Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+D</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Linear Dodge Blending Mode">
       <icon></icon>
       <text>Select Linear Dodge Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Linear Dodge Blending Mode</toolTip>
       <iconText>Select Linear Dodge Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+W</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Overlay Blending Mode">
       <icon></icon>
       <text>Select Overlay Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Overlay Blending Mode</toolTip>
       <iconText>Select Overlay Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+O</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Hard Overlay Blending Mode">
       <icon></icon>
       <text>Select Hard Overlay Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Hard Overlay Blending Mode</toolTip>
       <iconText>Select Hard Overlay Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+P</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Soft Light Blending Mode">
       <icon></icon>
       <text>Select Soft Light Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Soft Light Blending Mode</toolTip>
       <iconText>Select Soft Light Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+F</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Hard Light Blending Mode">
       <icon></icon>
       <text>Select Hard Light Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Hard Light Blending Mode</toolTip>
       <iconText>Select Hard Light Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+H</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Vivid Light Blending Mode">
       <icon></icon>
       <text>Select Vivid Light Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Vivid Light Blending Mode</toolTip>
       <iconText>Select Vivid Light Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+V</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Linear Light Blending Mode">
       <icon></icon>
       <text>Select Linear Light Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Linear Light Blending Mode</toolTip>
       <iconText>Select Linear Light Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+J</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Pin Light Blending Mode">
       <icon></icon>
       <text>Select Pin Light Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Pin Light Blending Mode</toolTip>
       <iconText>Select Pin Light Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+Z</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Hard Mix Blending Mode">
       <icon></icon>
       <text>Select Hard Mix Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Hard Mix Blending Mode</toolTip>
       <iconText>Select Hard Mix Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+L</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Difference Blending Mode">
       <icon></icon>
       <text>Select Difference Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Difference Blending Mode</toolTip>
       <iconText>Select Difference Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+E</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Exclusion Blending Mode">
       <icon></icon>
       <text>Select Exclusion Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Exclusion Blending Mode</toolTip>
       <iconText>Select Exclusion Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+X</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Hue Blending Mode">
       <icon></icon>
       <text>Select Hue Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Hue Blending Mode</toolTip>
       <iconText>Select Hue Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+U</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Saturation Blending Mode">
       <icon></icon>
       <text>Select Saturation Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Saturation Blending Mode</toolTip>
       <iconText>Select Saturation Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+T</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Color Blending Mode">
       <icon></icon>
       <text>Select Color Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Color Blending Mode</toolTip>
       <iconText>Select Color Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+C</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Luminosity Blending Mode">
       <icon></icon>
       <text>Select Luminosity Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Luminosity Blending Mode</toolTip>
       <iconText>Select Luminosity Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+Y</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
   </Actions>
 
   <Actions category="Animation">
     <text>Animation</text>
     <Action name="previous_frame">
       <icon></icon>
       <text>Previous frame</text>
       <whatsThis></whatsThis>
       <toolTip>Move to previous frame</toolTip>
       <iconText>Move to previous frame</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="next_frame">
       <icon></icon>
       <text>Next frame</text>
       <whatsThis></whatsThis>
       <toolTip>Move to next frame</toolTip>
       <iconText>Move to next frame</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="toggle_playback">
       <icon></icon>
       <text>Play / pause animation</text>
       <whatsThis></whatsThis>
       <toolTip>Play / pause animation</toolTip>
       <iconText>Play / pause animation</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="add_blank_frame">
       <icon>addblankframe</icon>
       <text>Create Blank Frame</text>
       <whatsThis></whatsThis>
       <toolTip>Add blank frame</toolTip>
       <iconText>Add blank frame</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="add_duplicate_frame">
       <icon>addduplicateframe</icon>
       <text>Create Duplicate Frame</text>
       <whatsThis></whatsThis>
       <toolTip>Add duplicate frame</toolTip>
       <iconText>Add duplicate frame</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="toggle_onion_skin">
       <icon></icon>
       <text>Toggle onion skin</text>
       <whatsThis></whatsThis>
       <toolTip>Toggle onion skin</toolTip>
       <iconText>Toggle onion skin</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="previous_keyframe">
       <icon></icon>
       <text>Previous Keyframe</text>
       <whatsThis></whatsThis>
       <toolTip></toolTip>
       <iconText></iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="next_keyframe">
       <icon></icon>
       <text>Next Keyframe</text>
       <whatsThis></whatsThis>
       <toolTip></toolTip>
       <iconText></iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="first_frame">
       <icon></icon>
       <text>First Frame</text>
       <whatsThis></whatsThis>
       <toolTip></toolTip>
       <iconText></iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="last_frame">
       <icon></icon>
       <text>Last Frame</text>
       <whatsThis></whatsThis>
       <toolTip></toolTip>
       <iconText></iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="lazy_frame">
       <icon></icon>
       <text>Auto Frame Mode</text>
       <whatsThis></whatsThis>
       <toolTip></toolTip>
       <iconText></iconText>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="drop_frames">
       <icon></icon>
       <text></text>
       <whatsThis></whatsThis>
       <toolTip></toolTip>
       <iconText></iconText>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="show_in_timeline">
       <icon></icon>
       <text>Show in Timeline</text>
       <whatsThis></whatsThis>
       <toolTip></toolTip>
       <iconText></iconText>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="insert_keyframe_left">
       <icon></icon>
       <text>Insert Keyframe Left</text>
       <whatsThis></whatsThis>
       <toolTip>Insert keyframes to the left of selection, moving the tail of animation to the right.</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="insert_keyframe_right">
       <icon></icon>
       <text>Insert Keyframe Right</text>
       <whatsThis></whatsThis>
       <toolTip>Insert keyframes to the right of selection, moving the tail of animation to the right.</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="insert_multiple_keyframes">
       <icon></icon>
       <text>Insert Multiple Keyframes</text>
       <whatsThis></whatsThis>
       <toolTip>Insert several keyframes based on user parameters.</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="remove_frames_and_pull">
       <icon></icon>
       <text>Remove Frame and Pull</text>
       <whatsThis></whatsThis>
       <toolTip>Remove keyframes moving the tail of animation to the left</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="remove_frames">
       <icon>deletekeyframe</icon>
       <text>Remove Keyframe</text>
       <whatsThis></whatsThis>
       <toolTip>Remove keyframes without moving anything around</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="insert_column_left">
       <icon></icon>
       <text>Insert Column Left</text>
       <whatsThis></whatsThis>
       <toolTip>Insert column to the left of selection, moving the tail of animation to the right</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="insert_column_right">
       <icon></icon>
       <text>Insert Column Right</text>
       <whatsThis></whatsThis>
       <toolTip>Insert column to the right of selection, moving the tail of animation to the right</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="insert_multiple_columns">
       <icon></icon>
       <text>Insert Multiple Columns</text>
       <whatsThis></whatsThis>
       <toolTip>Insert several columns based on user parameters.</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="remove_columns_and_pull">
       <icon></icon>
       <text>Remove Column and Pull</text>
       <whatsThis></whatsThis>
       <toolTip>Remove columns moving the tail of animation to the left</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="remove_columns">
       <icon></icon>
       <text>Remove Column</text>
       <whatsThis></whatsThis>
       <toolTip>Remove columns without moving anything around</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="insert_hold_frame">
       <icon></icon>
       <text>Insert Hold Frame</text>
       <whatsThis></whatsThis>
       <toolTip>Insert a hold frame after every keyframe</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="insert_multiple_hold_frames">
       <icon></icon>
       <text>Insert Multiple Hold Frames</text>
       <whatsThis></whatsThis>
       <toolTip>Insert N hold frames after every keyframe</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="remove_hold_frame">
       <icon></icon>
       <text>Remove Hold Frame</text>
       <whatsThis></whatsThis>
       <toolTip>Remove a hold frame after every keyframe</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="remove_multiple_hold_frames">
       <icon></icon>
       <text>Remove Multiple Hold Frames</text>
       <whatsThis></whatsThis>
       <toolTip>Remove N hold frames after every keyframe</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="insert_hold_column">
       <icon></icon>
       <text>Insert Hold Column</text>
       <whatsThis></whatsThis>
       <toolTip>Insert a hold column into the frame at the current position</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="insert_multiple_hold_columns">
       <icon></icon>
       <text>Insert Multiple Hold Columns</text>
       <whatsThis></whatsThis>
       <toolTip>Insert N hold columns into the frame at the current position</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="remove_hold_column">
       <icon></icon>
       <text>Remove Hold Column</text>
       <whatsThis></whatsThis>
       <toolTip>Remove a hold column from the frame at the current position</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="remove_multiple_hold_columns">
       <icon></icon>
       <text>Remove Multiple Hold Columns</text>
       <whatsThis></whatsThis>
       <toolTip>Remove N hold columns from the frame at the current position</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="mirror_frames">
       <icon></icon>
       <text>Mirror Frames</text>
       <whatsThis></whatsThis>
       <toolTip>Mirror frames' position</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="mirror_columns">
       <icon></icon>
       <text>Mirror Columns</text>
       <whatsThis></whatsThis>
       <toolTip>Mirror columns' position</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="copy_frames_to_clipboard">
       <icon></icon>
       <text>Copy to Clipboard</text>
       <whatsThis></whatsThis>
       <toolTip>Copy frames to clipboard</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="cut_frames_to_clipboard">
       <icon></icon>
       <text>Cut to Clipboard</text>
       <whatsThis></whatsThis>
       <toolTip>Cut frames to clipboard</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="paste_frames_from_clipboard">
       <icon></icon>
       <text>Paste from Clipboard</text>
       <whatsThis></whatsThis>
       <toolTip>Paste frames from clipboard</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="copy_columns_to_clipboard">
       <icon></icon>
       <text>Copy Columns to Clipboard</text>
       <whatsThis></whatsThis>
       <toolTip>Copy columns to clipboard</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="cut_columns_to_clipboard">
       <icon></icon>
       <text>Cut Columns to Clipboard</text>
       <whatsThis></whatsThis>
       <toolTip>Cut columns to clipboard</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="paste_columns_from_clipboard">
       <icon></icon>
       <text>Paste Columns from Clipboard</text>
       <whatsThis></whatsThis>
       <toolTip>Paste columns from clipboard</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
 
 
     <Action name="set_start_time">
       <icon></icon>
       <text>Set Start Time</text>
       <whatsThis></whatsThis>
       <toolTip></toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
 
     <Action name="set_end_time">
       <icon></icon>
       <text>Set End Time</text>
       <whatsThis></whatsThis>
       <toolTip></toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
 
     <Action name="update_playback_range">
       <icon></icon>
       <text>Update Playback Range</text>
       <whatsThis></whatsThis>
       <toolTip></toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
 
   </Actions>
 
   <Actions category="Layers">
     <text>Layers</text>
 
     <Action name="activateNextLayer">
       <icon></icon>
       <text>Activate next layer</text>
       <whatsThis></whatsThis>
       <toolTip>Activate next layer</toolTip>
       <iconText>Activate next layer</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>PgUp</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="activatePreviousLayer">
       <icon></icon>
       <text>Activate previous layer</text>
       <whatsThis></whatsThis>
       <toolTip>Activate previous layer</toolTip>
       <iconText>Activate previous layer</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>PgDown</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="switchToPreviouslyActiveNode">
       <icon></icon>
       <text>Activate previously selected layer</text>
       <whatsThis></whatsThis>
       <toolTip>Activate previously selected layer</toolTip>
       <iconText>Activate previously selected layer</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>;</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="add_new_group_layer">
       <icon>groupLayer</icon>
       <text>&amp;Group Layer</text>
       <whatsThis></whatsThis>
       <toolTip>Group Layer</toolTip>
       <iconText>Group Layer</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="add_new_clone_layer">
       <icon>cloneLayer</icon>
       <text>&amp;Clone Layer</text>
       <whatsThis></whatsThis>
       <toolTip>Clone Layer</toolTip>
       <iconText>Clone Layer</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="add_new_shape_layer">
       <icon>vectorLayer</icon>
       <text>&amp;Vector Layer</text>
       <whatsThis></whatsThis>
       <toolTip>Vector Layer</toolTip>
       <iconText>Vector Layer</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="add_new_adjustment_layer">
       <icon>filterLayer</icon>
       <text>&amp;Filter Layer...</text>
       <whatsThis></whatsThis>
       <toolTip>Filter Layer</toolTip>
       <iconText>Filter Layer</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="add_new_fill_layer">
       <icon>fillLayer</icon>
       <text>&amp;Fill Layer...</text>
       <whatsThis></whatsThis>
       <toolTip>Fill Layer</toolTip>
       <iconText>Fill Layer</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="add_new_file_layer">
       <icon>fileLayer</icon>
       <text>&amp;File Layer...</text>
       <whatsThis></whatsThis>
       <toolTip>File Layer</toolTip>
       <iconText>File Layer</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="add_new_transparency_mask">
       <icon>transparencyMask</icon>
       <text>&amp;Transparency Mask</text>
       <whatsThis></whatsThis>
       <toolTip>Transparency Mask</toolTip>
       <iconText>Transparency Mask</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="add_new_filter_mask">
       <icon>filterMask</icon>
       <text>&amp;Filter Mask...</text>
       <whatsThis></whatsThis>
       <toolTip>Filter Mask</toolTip>
       <iconText>Filter Mask</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="add_new_colorize_mask">
       <icon>filterMask</icon>
       <text>&amp;Colorize Mask</text>
       <whatsThis></whatsThis>
       <toolTip>Colorize Mask</toolTip>
       <iconText>Colorize Mask</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="add_new_transform_mask">
       <icon>transformMask</icon>
       <text>&amp;Transform Mask...</text>
       <whatsThis></whatsThis>
       <toolTip>Transform Mask</toolTip>
       <iconText>Transform Mask</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="add_new_selection_mask">
       <icon>selectionMask</icon>
       <text>&amp;Local Selection</text>
       <whatsThis></whatsThis>
       <toolTip>Local Selection</toolTip>
       <iconText>Local Selection</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="isolate_layer">
       <icon>view-filter</icon>
       <text>&amp;Isolate Layer</text>
       <whatsThis></whatsThis>
       <toolTip>Isolate Layer</toolTip>
       <iconText>Isolate Layer</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="toggle_layer_lock">
       <icon>layer-locked</icon>
       <text>&amp;Toggle layer lock</text>
       <whatsThis></whatsThis>
       <toolTip>Toggle layer lock</toolTip>
       <iconText>Toggle layer lock</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="toggle_layer_visibility">
       <icon>visible</icon>
       <text>Toggle layer &amp;visibility</text>
       <whatsThis></whatsThis>
       <toolTip>Toggle layer visibility</toolTip>
       <iconText>Toggle layer visibility</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="toggle_layer_alpha_lock">
       <icon>transparency-locked</icon>
       <text>Toggle layer &amp;alpha</text>
       <whatsThis></whatsThis>
       <toolTip>Toggle layer alpha</toolTip>
       <iconText>Toggle layer alpha</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="toggle_layer_inherit_alpha">
       <icon>transparency-enabled</icon>
       <text>Toggle layer alpha &amp;inheritance</text>
       <whatsThis></whatsThis>
       <toolTip>Toggle layer alpha inheritance</toolTip>
       <iconText>Toggle layer alpha inheritance</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="add_new_paint_layer">
       <icon>paintLayer</icon>
       <text>&amp;Paint Layer</text>
       <whatsThis></whatsThis>
       <toolTip>Paint Layer</toolTip>
       <iconText>Paint Layer</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Insert</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="new_from_visible">
       <icon></icon>
       <text>&amp;New Layer From Visible</text>
       <whatsThis></whatsThis>
       <toolTip>New layer from visible</toolTip>
       <iconText>New layer from visible</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="duplicatelayer">
       <icon>duplicatelayer</icon>
       <text>&amp;Duplicate Layer or Mask</text>
       <whatsThis></whatsThis>
       <toolTip>Duplicate Layer or Mask</toolTip>
       <iconText>Duplicate Layer or Mask</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+J</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="cut_selection_to_new_layer">
       <icon></icon>
       <text>&amp;Cut Selection to New Layer</text>
       <whatsThis></whatsThis>
       <toolTip>Cut Selection to New Layer</toolTip>
       <iconText>Cut Selection to New Layer</iconText>
       <activationFlags>100000000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut>Ctrl+Shift+J</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="copy_selection_to_new_layer">
       <icon></icon>
       <text>Copy &amp;Selection to New Layer</text>
       <whatsThis></whatsThis>
       <toolTip>Copy Selection to New Layer</toolTip>
       <iconText>Copy Selection to New Layer</iconText>
       <activationFlags>100000000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+Alt+J</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="copy_layer_clipboard">
       <icon></icon>
       <text>Copy Layer</text>
       <whatsThis></whatsThis>
       <toolTip>Copy layer to clipboard</toolTip>
       <iconText>Copy layer to clipboard</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="cut_layer_clipboard">
       <icon></icon>
       <text>Cut Layer</text>
       <whatsThis></whatsThis>
       <toolTip>Cut layer to clipboard</toolTip>
       <iconText>Cut layer to clipboard</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="paste_layer_from_clipboard">
       <icon></icon>
       <text>Paste Layer</text>
       <whatsThis></whatsThis>
       <toolTip>Paste layer from clipboard</toolTip>
       <iconText>Paste layer from clipboard</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="create_quick_group">
       <icon></icon>
       <text>Quick Group</text>
       <whatsThis></whatsThis>
       <toolTip>Create a group layer containing selected layers</toolTip>
       <iconText>Quick Group</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+G</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="quick_ungroup">
       <icon></icon>
       <text>Quick Ungroup</text>
       <whatsThis></whatsThis>
       <toolTip>Remove grouping of the layers or remove one layer out of the group</toolTip>
       <iconText>Quick Ungroup</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+Alt+G</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="create_quick_clipping_group">
       <icon></icon>
       <text>Quick Clipping Group</text>
       <whatsThis></whatsThis>
       <toolTip>Group selected layers and add a layer with clipped alpha channel</toolTip>
       <iconText>Quick Clipping Group</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+Shift+G</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="select_all_layers">
       <icon></icon>
       <text>All Layers</text>
       <whatsThis></whatsThis>
       <toolTip>Select all layers</toolTip>
       <iconText>Select all layers</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="select_visible_layers">
       <icon></icon>
       <text>Visible Layers</text>
       <whatsThis></whatsThis>
       <toolTip>Select all visible layers</toolTip>
       <iconText>Select all visible layers</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="select_locked_layers">
       <icon></icon>
       <text>Locked Layers</text>
       <whatsThis></whatsThis>
       <toolTip>Select all locked layers</toolTip>
       <iconText>Select all locked layers</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="select_invisible_layers">
       <icon></icon>
       <text>Invisible Layers</text>
       <whatsThis></whatsThis>
       <toolTip>Select all invisible layers</toolTip>
       <iconText>Select all invisible layers</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="select_unlocked_layers">
       <icon></icon>
       <text>Unlocked Layers</text>
       <whatsThis></whatsThis>
       <toolTip>Select all unlocked layers</toolTip>
       <iconText>Select all unlocked layers</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="save_node_as_image">
       <icon>document-save</icon>
       <text>&amp;Save Layer/Mask...</text>
       <whatsThis></whatsThis>
       <toolTip>Save Layer/Mask</toolTip>
       <iconText>Save Layer/Mask</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
         <Action name="save_vector_node_to_svg">
       <icon>document-save</icon>
       <text>Save Vector Layer as SVG...</text>
       <whatsThis></whatsThis>
       <toolTip>Save Vector Layer as SVG</toolTip>
       <iconText>Save Vector Layer as SVG</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="save_groups_as_images">
       <icon>document-save</icon>
       <text>Save &amp;Group Layers...</text>
       <whatsThis></whatsThis>
       <toolTip>Save Group Layers</toolTip>
       <iconText>Save Group Layers</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="convert_group_to_animated">
       <icon></icon>
       <text>Convert group to &amp;animated layer</text>
       <whatsThis></whatsThis>
       <toolTip>Convert child layers into animation frames</toolTip>
       <iconText>Convert child layers into animation frames</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
+    </Action>
+        <Action name="convert_to_animated">
+      <icon></icon>
+      <text>Convert to &amp;animated layer</text>
+      <whatsThis></whatsThis>
+      <toolTip>Convert layer into animation frames</toolTip>
+      <iconText>Convert layer into animation frames</iconText>
+      <activationFlags>100000</activationFlags>
+      <activationConditions>0</activationConditions>
+      <shortcut></shortcut>
+      <isCheckable>false</isCheckable>
+      <statusTip></statusTip>
     </Action>
     <Action name="convert_to_file_layer">
       <icon>fileLayer</icon>
       <text>to &amp;File Layer</text>
       <whatsThis></whatsThis>
       <toolTip>Saves out the layers into a new image and then references that image.</toolTip>
       <iconText>Convert to File Layer</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="import_layer_from_file">
       <icon></icon>
       <text>I&amp;mport Layer...</text>
       <whatsThis></whatsThis>
       <toolTip>Import Layer</toolTip>
       <iconText>Import Layer</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="import_layer_as_paint_layer">
       <icon>paintLayer</icon>
       <text>&amp;as Paint Layer...</text>
       <whatsThis></whatsThis>
       <toolTip>as Paint Layer</toolTip>
       <iconText>as Paint Layer</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="import_layer_as_transparency_mask">
       <icon>transparencyMask</icon>
       <text>as &amp;Transparency Mask...</text>
       <whatsThis></whatsThis>
       <toolTip>as Transparency Mask</toolTip>
       <iconText>as Transparency Mask</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="import_layer_as_filter_mask">
       <icon>filterMask</icon>
       <text>as &amp;Filter Mask...</text>
       <whatsThis></whatsThis>
       <toolTip>as Filter Mask</toolTip>
       <iconText>as Filter Mask</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="import_layer_as_selection_mask">
       <icon>selectionMask</icon>
       <text>as &amp;Selection Mask...</text>
       <whatsThis></whatsThis>
       <toolTip>as Selection Mask</toolTip>
       <iconText>as Selection Mask</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="convert_to_paint_layer">
       <icon>paintLayer</icon>
       <text>to &amp;Paint Layer</text>
       <whatsThis></whatsThis>
       <toolTip>to Paint Layer</toolTip>
       <iconText>to Paint Layer</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="convert_to_transparency_mask">
       <icon>transparencyMask</icon>
       <text>to &amp;Transparency Mask</text>
       <whatsThis></whatsThis>
       <toolTip>to Transparency Mask</toolTip>
       <iconText>to Transparency Mask</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="convert_to_filter_mask">
       <icon>filterMask</icon>
       <text>to &amp;Filter Mask...</text>
       <whatsThis></whatsThis>
       <toolTip>to Filter Mask</toolTip>
       <iconText>to Filter Mask</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="convert_to_selection_mask">
       <icon>selectionMask</icon>
       <text>to &amp;Selection Mask</text>
       <whatsThis></whatsThis>
       <toolTip>to Selection Mask</toolTip>
       <iconText>to Selection Mask</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="split_alpha_into_mask">
       <icon>transparencyMask</icon>
       <text>&amp;Alpha into Mask</text>
       <whatsThis></whatsThis>
       <toolTip>Alpha into Mask</toolTip>
       <iconText>Alpha into Mask</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>10</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="split_alpha_write">
       <icon>transparency-enabled</icon>
       <text>&amp;Write as Alpha</text>
       <whatsThis></whatsThis>
       <toolTip>Write as Alpha</toolTip>
       <iconText>Write as Alpha</iconText>
       <activationFlags>1000000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="split_alpha_save_merged">
       <icon>document-save</icon>
       <text>&amp;Save Merged...</text>
       <whatsThis></whatsThis>
       <toolTip>Save Merged</toolTip>
       <iconText>Save Merged</iconText>
       <activationFlags>1000000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="layersplit">
       <icon>split-layer</icon>
       <text>Split Layer...</text>
       <whatsThis></whatsThis>
       <toolTip>Split Layer</toolTip>
       <iconText>Split Layer</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="waveletdecompose">
       <icon></icon>
       <text>Wavelet Decompose ...</text>
       <whatsThis></whatsThis>
       <toolTip>Wavelet Decompose</toolTip>
       <iconText>Wavelet Decompose</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="mirrorNodeX">
       <icon>symmetry-horizontal</icon>
       <text>Mirror Layer Hori&amp;zontally</text>
       <whatsThis></whatsThis>
       <toolTip>Mirror Layer Horizontally</toolTip>
       <iconText>Mirror Layer Horizontally</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="mirrorNodeY">
       <icon>symmetry-vertical</icon>
       <text>Mirror Layer &amp;Vertically</text>
       <whatsThis></whatsThis>
       <toolTip>Mirror Layer Vertically</toolTip>
       <iconText>Mirror Layer Vertically</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="rotatelayer">
       <icon></icon>
       <text>&amp;Rotate Layer...</text>
       <whatsThis></whatsThis>
       <toolTip>Rotate Layer</toolTip>
       <iconText>Rotate Layer</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="rotateLayerCW90">
       <icon>object-rotate-right</icon>
       <text>Rotate &amp;Layer 90° to the Right</text>
       <whatsThis></whatsThis>
       <toolTip>Rotate Layer 90° to the Right</toolTip>
       <iconText>Rotate Layer 90° to the Right</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="rotateLayerCCW90">
       <icon>object-rotate-left</icon>
       <text>Rotate Layer &amp;90° to the Left</text>
       <whatsThis></whatsThis>
       <toolTip>Rotate Layer 90° to the Left</toolTip>
       <iconText>Rotate Layer 90° to the Left</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="rotateLayer180">
       <icon></icon>
       <text>Rotate Layer &amp;180°</text>
       <whatsThis></whatsThis>
       <toolTip>Rotate Layer 180°</toolTip>
       <iconText>Rotate Layer 180°</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="layersize">
       <icon></icon>
       <text>Scale &amp;Layer to new Size...</text>
       <whatsThis></whatsThis>
       <toolTip>Scale Layer to new Size</toolTip>
       <iconText>Scale Layer to new Size</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="shearlayer">
       <icon></icon>
       <text>&amp;Shear Layer...</text>
       <whatsThis></whatsThis>
       <toolTip>Shear Layer</toolTip>
       <iconText>Shear Layer</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="mirrorAllNodesX">
       <icon>symmetry-horizontal</icon>
       <text>Mirror All Layers Hori&amp;zontally</text>
       <whatsThis></whatsThis>
       <toolTip>Mirror All Layers Horizontally</toolTip>
       <iconText>Mirror All Layers Horizontally</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="mirrorAllNodesY">
       <icon>symmetry-vertical</icon>
       <text>Mirror All Layers &amp;Vertically</text>
       <whatsThis></whatsThis>
       <toolTip>Mirror All Layers Vertically</toolTip>
       <iconText>Mirror All Layers Vertically</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="rotateAllLayers">
       <icon></icon>
       <text>&amp;Rotate All Layers...</text>
       <whatsThis></whatsThis>
       <toolTip>Rotate All Layers</toolTip>
       <iconText>Rotate All Layers</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="rotateAllLayersCW90">
       <icon>object-rotate-right</icon>
       <text>Rotate All &amp;Layers 90° to the Right</text>
       <whatsThis></whatsThis>
       <toolTip>Rotate All Layers 90° to the Right</toolTip>
       <iconText>Rotate All Layers 90° to the Right</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="rotateAllLayersCCW90">
       <icon>object-rotate-left</icon>
       <text>Rotate All Layers &amp;90° to the Left</text>
       <whatsThis></whatsThis>
       <toolTip>Rotate All Layers 90° to the Left</toolTip>
       <iconText>Rotate All Layers 90° to the Left</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="rotateAllLayers180">
       <icon></icon>
       <text>Rotate All Layers &amp;180°</text>
       <whatsThis></whatsThis>
       <toolTip>Rotate All Layers 180°</toolTip>
       <iconText>Rotate All Layers 180°</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="scaleAllLayers">
       <icon></icon>
       <text>Scale All &amp;Layers to new Size...</text>
       <whatsThis></whatsThis>
       <toolTip>Scale All Layers to new Size</toolTip>
       <iconText>Scale All Layers to new Size</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="shearAllLayers">
       <icon></icon>
       <text>&amp;Shear All Layers...</text>
       <whatsThis></whatsThis>
       <toolTip>Shear All Layers</toolTip>
       <iconText>Shear All Layers</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="offsetlayer">
       <icon></icon>
       <text>&amp;Offset Layer...</text>
       <whatsThis></whatsThis>
       <toolTip>Offset Layer</toolTip>
       <iconText>Offset Layer</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="clones_array">
       <icon></icon>
       <text>Clones &amp;Array...</text>
       <whatsThis></whatsThis>
       <toolTip>Clones Array</toolTip>
       <iconText>Clones Array</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="EditLayerMetaData">
       <icon></icon>
       <text>&amp;Edit metadata...</text>
       <whatsThis></whatsThis>
       <toolTip>Edit metadata</toolTip>
       <iconText>Edit metadata</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="histogram">
       <icon></icon>
       <text>&amp;Histogram...</text>
       <whatsThis></whatsThis>
       <toolTip>Histogram</toolTip>
       <iconText>Histogram</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="layercolorspaceconversion">
       <icon></icon>
       <text>&amp;Convert Layer Color Space...</text>
       <whatsThis></whatsThis>
       <toolTip>Convert Layer Color Space</toolTip>
       <iconText>Convert Layer Color Space</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="merge_layer">
       <icon>merge-layer-below</icon>
       <text>&amp;Merge with Layer Below</text>
       <whatsThis></whatsThis>
       <toolTip>Merge with Layer Below</toolTip>
       <iconText>Merge with Layer Below</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+E</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="flatten_layer">
       <icon></icon>
       <text>&amp;Flatten Layer</text>
       <whatsThis></whatsThis>
       <toolTip>Flatten Layer</toolTip>
       <iconText>Flatten Layer</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="rasterize_layer">
       <icon></icon>
       <text>Ras&amp;terize Layer</text>
       <whatsThis></whatsThis>
       <toolTip>Rasterize Layer</toolTip>
       <iconText>Rasterize Layer</iconText>
       <activationFlags>10000000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="flatten_image">
       <icon></icon>
       <text>Flatten ima&amp;ge</text>
       <whatsThis></whatsThis>
       <toolTip>Flatten image</toolTip>
       <iconText>Flatten image</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+Shift+E</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="layer_style">
       <icon></icon>
       <text>La&amp;yer Style...</text>
       <whatsThis></whatsThis>
       <toolTip>Layer Style</toolTip>
       <iconText>Layer Style</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="LayerGroupSwitcher/previous">
       <icon></icon>
       <text>Move into previous group</text>
       <whatsThis></whatsThis>
       <toolTip>Move into previous group</toolTip>
       <iconText>Move into previous group</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="LayerGroupSwitcher/next">
       <icon></icon>
       <text>Move into next group</text>
       <whatsThis></whatsThis>
       <toolTip>Move into next group</toolTip>
       <iconText>Move into next group</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="RenameCurrentLayer">
       <icon></icon>
       <text>Rename current layer</text>
       <whatsThis></whatsThis>
       <toolTip>Rename current layer</toolTip>
       <iconText>Rename current layer</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>F2</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="remove_layer">
       <icon>deletelayer</icon>
       <text>&amp;Remove Layer</text>
       <whatsThis></whatsThis>
       <toolTip>Remove Layer</toolTip>
       <iconText>Remove Layer</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut>Shift+Delete</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="move_layer_up">
       <icon>arrowupblr</icon>
       <text>Move Layer or Mask Up</text>
       <whatsThis></whatsThis>
       <toolTip>Move Layer or Mask Up</toolTip>
       <iconText></iconText>
       <shortcut>Ctrl+PgUp</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="move_layer_down">
       <icon>arrowdown</icon>
       <text>Move Layer or Mask Down</text>
       <whatsThis></whatsThis>
       <toolTip>Move Layer or Mask Down</toolTip>
       <iconText></iconText>
       <shortcut>Ctrl+PgDown</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="layer_properties">
       <icon>properties</icon>
       <text>&amp;Properties...</text>
       <whatsThis></whatsThis>
       <toolTip>Properties</toolTip>
       <iconText>Properties</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut>F3</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="set-copy-from">
       <icon></icon>
       <text>Set Copy F&amp;rom...</text>
       <whatsThis></whatsThis>
       <toolTip>Set the source for the selected clone layer(s).</toolTip>
       <iconText>Set Copy From</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
   </Actions>
 </ActionCollection>
diff --git a/krita/krita4.xmlgui b/krita/krita4.xmlgui
index 88160ddea8..11cc07a646 100644
--- a/krita/krita4.xmlgui
+++ b/krita/krita4.xmlgui
@@ -1,406 +1,407 @@
 <?xml version="1.0"?>
 <kpartgui xmlns="http://www.kde.org/standards/kxmlgui/1.0"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 name="Krita"
 version="430"
 xsi:schemaLocation="http://www.kde.org/standards/kxmlgui/1.0  http://www.kde.org/standards/kxmlgui/1.0/kxmlgui.xsd">
   <MenuBar>
     <Menu name="file">
       <text>&amp;File</text>
       <Action name="file_new"/>
       <Action name="file_open"/>
       <Action name="file_open_recent"/>
       <Separator/>
       <Action name="file_save"/>
       <Action name="file_save_as"/>
       <Action name="file_reload_file"/>
       <Separator/>
       <Action name="file_sessions"/>
       <Separator/>
       <Action name="file_import_file"/>
       <Action name="file_export_file"/>
       <Separator/>
       <Action name="file_export_pdf"/>
       <Separator/>
       <Action name="file_import_animation"/>
       <Action name="render_animation"/>
       <Separator/>
       <Action name="save_incremental_version"/>
       <Action name="save_incremental_backup"/>
       <Separator/>
       <Action name="create_template"/>
       <Action name="create_copy"/>
       <!--Separator/>
       <Action name="file_print"/>
       <Action name="file_print_preview"/-->
       <Separator/>
       <Action name="file_documentinfo"/>
       <Separator/>
       <Action name="file_close"/>
       <Action name="file_close_all"/>
       <Action name="file_quit"/>
     </Menu>
     <Menu name="edit">
       <text>&amp;Edit</text>
       <Action name="edit_undo"/>
       <Action name="edit_redo"/>
       <Separator/>
       <Action name="edit_cut"/>
       <Action name="edit_copy"/>
       <Action name="cut_sharp"/>
       <Action name="copy_sharp"/>
       <Action name="copy_merged"/>
       <Action name="edit_paste"/>
       <Action name="paste_at"/>
       <Action name="paste_new"/>
       <Action name="paste_as_reference"/>
       <Action name="clear"/>
       <Action name="fill_selection_foreground_color"/>
       <Action name="fill_selection_background_color"/>
       <Action name="fill_selection_pattern"/>
       <Menu name="fill_special">
         <text>Fill Special</text>
         <Action name="fill_selection_foreground_color_opacity"/>
         <Action name="fill_selection_background_color_opacity"/>
         <Action name="fill_selection_pattern_opacity"/>
       </Menu>
       <Action name="stroke_shapes"/>
       <Action name="stroke_selection"/>
       <Action name="delete"/>
       <Separator/>
       <Action name="revert"/>
     </Menu>
     <Menu name="view">
       <text>&amp;View</text>
       <Action name="view_show_canvas_only"/>
       <Action name="fullscreen"/>
+      <Action name="view_detached_canvas"/>
       <Action name="wrap_around_mode"/>
       <Action name="level_of_detail_mode"/>
       <Action name="softProof"/>
       <Action name="gamutCheck"/>
       <Separator/>
       <Menu name="Canvas">
           <text>&amp;Canvas</text>
           <Action name="mirror_canvas"/>
           <Separator/>
           <Action name="zoom_to_100pct" />
           <Action name="rotate_canvas_right" />
           <Action name="rotate_canvas_left" />
           <Action name="reset_canvas_rotation" />
           <!-- TODO: Something is not right with the way zoom actions are hooked up. These are in the KoZoomController.
                It seems they are not being properly placed in the view manager since the MDI changes were implemented
           -->
           <Action name="view_zoom_in"/>
           <Action name="view_zoom_out"/>
       </Menu>
       <!-- TODO: None of these actions are showing. There names must have been changed to something with the MDI changes?...
       <Action name="actual_pixels"/>
       <Action name="actual_size"/>
       <Action name="fit_to_canvas"/>
       -->
 
       <Separator/>
       <Action name="view_ruler"/>
       <Action name="rulers_track_mouse"/>
       <Action name="view_show_guides"/>
       <Action name="view_lock_guides"/>
       <Action name="showStatusBar" />
       <Separator/>
       <Action name="view_grid"/>
       <Action name="view_pixel_grid"/>
 
 
       <Separator/>
       <Menu name="SnapTo">
         <text>&amp;Snap To</text>
         <Action name="view_snap_to_guides"/>
             <Action name="view_snap_to_grid"/>
             <Action name="view_snap_to_pixel"/>
           <Action name="view_snap_orthogonal" />
             <Action name="view_snap_node" />
             <Action name="view_snap_extension" />
             <Action name="view_snap_intersection" />
             <Action name="view_snap_bounding_box" />
             <Action name="view_snap_image_bounds" />
              <Action name="view_snap_image_center" />
       </Menu>
       <Separator/>
 
       <Action name="view_toggle_painting_assistants"/>
       <Action name="view_toggle_assistant_previews"/>
       <Action name="view_toggle_reference_images"/>
       <Separator/>
       <Action name="view_palette_action_menu"/>
       <Separator/>
       <Action name="refresh_canvas"/>
     </Menu>
     <Menu name="Image">
       <text>&amp;Image</text>
       <Action name="image_properties"/>
       <Action name="image_color"/>
       <Action name="imagecolorspaceconversion"/>
       <Action name="duplicate_image"/>
       <Separator/>
       <Action name="trim_to_image"/>
       <Action name="resizeimagetolayer"/>
       <Action name="resizeimagetoselection"/>
       <Separator/>
       <Menu name="Rotate">
         <text>&amp;Rotate</text>
         <Action name="rotateimage"/>
         <Separator/>
         <Action name="rotateImageCW90"/>
         <Action name="rotateImageCCW90"/>
         <Action name="rotateImage180"/>
       </Menu>
       <Action name="shearimage"/>
       <Separator/>
       <Action name="mirrorImageHorizontal"/>
       <Action name="mirrorImageVertical"/>
       <Separator/>
       <Action name="imagesize"/>
       <Action name="offsetimage"/>
       <Action name="imageresolution"/>
       <Action name="canvassize"/>
       <Separator/>
       <Action name="imagesplit"/>
       <Action name="waveletdecompose"/>
       <Action name="separate"/>
     </Menu>
     <Menu name="Layer">
       <text>&amp;Layer</text>
       <Action name="cut_layer_clipboard"/>
       <Action name="copy_layer_clipboard"/>
       <Action name="paste_layer_from_clipboard"/>
       <Separator/>
       <Menu name="LayerNew">
         <text>New</text>
         <Action name="add_new_paint_layer"/>
         <Action name="new_from_visible"/>
         <Action name="duplicatelayer"/>
         <Separator/>
         <Action name="cut_selection_to_new_layer"/>
         <Action name="copy_selection_to_new_layer"/>
       </Menu>
       <Menu name="LayerImportExport">
         <text>&amp;Import/Export</text>
         <Action name="save_node_as_image"/>
         <Action name="save_vector_node_to_svg"/>
         <Action name="save_groups_as_images"/>
         <Separator/>
         <Action name="import_layer_from_file"/>
         <Menu name="LayerImportAs">
           <text>Import</text>
           <Action name="import_layer_as_paint_layer"/>
           <Action name="import_layer_as_transparency_mask"/>
           <Action name="import_layer_as_filter_mask"/>
           <Action name="import_layer_as_selection_mask"/>
         </Menu>
       </Menu>
       <Menu name="LayerConvert">
         <text>&amp;Convert</text>
         <Action name="convert_to_paint_layer"/>
         <Action name="convert_to_transparency_mask"/>
         <Action name="convert_to_filter_mask"/>
         <Action name="convert_to_selection_mask"/>
         <Action name="convert_to_file_layer"/>
         <Action name="convert_group_to_animated"/>
         <Action name="layercolorspaceconversion"/>
       </Menu>
       <Separator/>
       <Menu name="LayerSelect">
         <text>&amp;Select</text>
         <Action name="select_all_layers"/>
         <Action name="select_visible_layers"/>
         <Action name="select_invisible_layers"/>
         <Action name="select_locked_layers"/>
         <Action name="select_unlocked_layers"/>
       </Menu>
       <Menu name="LayerGroup">
          <text>&amp;Group</text>
          <Action name="create_quick_group"/>
          <Action name="create_quick_clipping_group"/>
          <Action name="quick_ungroup"/>
       </Menu>
       <Menu name="LayerTransform">
          <text>&amp;Transform</text>
          <Action name="mirrorNodeX"/>
          <Action name="mirrorNodeY"/>
          <Action name="layersize"/>
          <Menu name="Rotate">
              <text>&amp;Rotate</text>
              <Action name="rotatelayer"/>
              <Separator/>
              <Action name="rotateLayerCW90"/>
              <Action name="rotateLayerCCW90"/>
              <Action name="rotateLayer180"/>
          </Menu>
          <Action name="shearlayer"/>
          <Action name="offsetlayer"/>
       </Menu>
       <Menu name="LayerTransformAll">
          <text>Transform &amp;All Layers</text>
          <Action name="mirrorAllNodesX"/>
          <Action name="mirrorAllNodesY"/>
          <Action name="scaleAllLayers"/>
          <Menu name="Rotate">
              <text>&amp;Rotate</text>
              <Action name="rotateAllLayers"/>
              <Separator/>
              <Action name="rotateAllLayersCW90"/>
              <Action name="rotateAllLayersCCW90"/>
              <Action name="rotateAllLayers180"/>
          </Menu>
          <Action name="shearAllLayers"/>
       </Menu>
       <Menu name="LayerSplitAlpha">
          <text>S&amp;plit</text>
          <Menu name="LayerSplitAlpha">
              <text>S&amp;plit Alpha</text>
              <Action name="split_alpha_into_mask"/>
              <Action name="split_alpha_write"/>
              <Action name="split_alpha_save_merged"/>
          </Menu>
          <Action name="layersplit"/>
          <Action name="clones_array"/>
       </Menu>
 
       <Separator/>
       <Action name="EditLayerMetaData"/>
       <Action name="histogram"/>
       <Separator/>
       <Action name="merge_layer"/>
       <Action name="flatten_layer"/>
       <Action name="rasterize_layer"/>
       <Action name="merge_all_shape_layers"/>
       <Action name="flatten_image"/>
       <Action name="merge_selected_layers"/>
       <Separator/>
       <Action name="layer_style"/>
 
     </Menu>
     <Menu name="Select">
       <text>&amp;Select</text>
       <Action name="select_all"/>
       <Action name="deselect"/>
       <Action name="reselect"/>
       <Action name="invert_selection"/>
       <Separator/>
       <Action name="edit_selection"/>
       <Action name="convert_to_vector_selection"/>
       <Action name="convert_to_raster_selection"/>
       <Action name="convert_shapes_to_vector_selection"/>
       <Action name="convert_selection_to_shape"/>
       <Separator/>
       <Action name="feather"/>
       <Action name="similar"/>
       <Separator/>
       <Action name="toggle_display_selection"/>
       <Action name="show-global-selection-mask"/>
       <Action name="selectionscale"/>
       <Separator/>
       <Action name="colorrange"/>
       <Menu name="selectopaquemenu">
         <text>Select &amp;Opaque</text>
         <Action name="selectopaque"/>
         <Separator/>
         <Action name="selectopaque_add"/>
         <Action name="selectopaque_subtract"/>
         <Action name="selectopaque_intersect"/>
       </Menu>
       <Separator/>
       <Action name="featherselection"/>
       <Action name="growselection"/>
       <Action name="shrinkselection"/>
       <Action name="borderselection"/>
       <Action name="smoothselection"/>
     </Menu>
     <Menu name="Filter">
       <text>Filte&amp;r</text>
       <Action name="filter_apply_again"/>
       <Action name="filter_gallery"/>
       <Separator/>
       <Action name="adjust_filters"/>
       <Action name="artistic_filters"/>
       <Action name="blur_filters"/>
       <Action name="color_filters"/>
       <Action name="decor_filters"/>
       <Action name="edge_filters"/>
       <Action name="emboss_filters"/>
       <Action name="enhance_filters"/>
       <Action name="map_filters"/>
       <Action name="nonphotorealistic_filters"/>
       <Action name="other_filters"/>
       <Separator/>
       <Action name="QMic"/>
       <Action name="QMicAgain"/>
     </Menu>
     <Menu name="tools">
       <text>&amp;Tools</text>
       <Menu name="scripts"><text>Scripts</text></Menu>
     </Menu>
     <Menu name="settings">
       <text>Setti&amp;ngs</text>
       <Action name="options_configure"/>
       <Action name="manage_bundles"/>
       <Separator/>
       <Action name="options_configure_toolbars"/>
       <Merge name="StandardToolBarMenuHandler" />
       <Separator/>
       <Action name="view_toggledockers"/>
       <Action name="settings_dockers_menu"/>
       <Separator/>
       <Action name="theme_menu"/>
       <Separator/>
       <!-- `Configure Shortcuts` was moved into main configuration menu -->
       <!-- <Action name="options_configure_keybinding"/> -->
       <Separator/>
       <Action name="switch_application_language"/>
       <Action name="settings_active_author"/>
       <Separator/>
     </Menu>
     <Action name="window"/>
     <Separator/>
     <Menu name="help">
       <text>&amp;Help</text>
       <Action name="help_contents"/>
       <Action name="help_whats_this"/>
       <Separator/>
       <MergeLocal/>
       <Action name="help_show_tip"/>
       <Separator/>
       <Action name="help_report_bug"/>
       <Action name="buginfo"/>
       <Separator/>
       <Action name="help_about_app"/>
       <Action name="help_about_kde"/>
     </Menu>
   </MenuBar>
   <ToolBar name="mainToolBar" fullWidth="false" noMerge="1">
     <Text>File</Text>
     <Action name="file_new"/>
     <Action name="file_open"/>
     <Action name="file_save"/>
     <Separator/>
     <Action name="edit_undo"/>
     <Action name="edit_redo"/>
   </ToolBar>
   <ToolBar name="BrushesAndStuff" position="top">
     <Text>Brushes and Stuff</Text>
     <Action name="gradients"/>
     <Action name="patterns"/>
     <Separator/>
     <Action name="dual"/>
     <Separator/>
     <Action name="paintops"/>
     <Action name="paintop_options"/>
     <Action name="composite_actions"/>
     <Action name="brushslider1"/>
     <Action name="brushslider2"/>
     <Separator/>
     <Action name="mirror_actions"/>
     <Action name="expanding_spacer_1"/>
     <Action name="select_layout"/>
     <Action name="workspaces"/>
   </ToolBar>
 </kpartgui>
diff --git a/krita/kritamenu.action b/krita/kritamenu.action
index 5036540026..28584f0e39 100644
--- a/krita/kritamenu.action
+++ b/krita/kritamenu.action
@@ -1,1829 +1,1841 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ActionCollection version="2" name="Menu">
   <Actions category="File">
     <text>File</text>
     <Action name="file_new">
       <icon>document-new</icon>
       <text>&amp;New</text>
       <whatsThis></whatsThis>
       <toolTip>Create new document</toolTip>
       <iconText>New</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+N</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="file_open">
       <icon>document-open</icon>
       <text>&amp;Open...</text>
       <whatsThis></whatsThis>
       <toolTip>Open an existing document</toolTip>
       <iconText>Open</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+O</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="file_open_recent">
       <icon>document-open-recent</icon>
       <text>Open &amp;Recent</text>
       <whatsThis></whatsThis>
       <toolTip>Open a document which was recently opened</toolTip>
       <iconText>Open Recent</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="file_save">
       <icon>document-save</icon>
       <text>&amp;Save</text>
       <whatsThis></whatsThis>
       <toolTip>Save</toolTip>
       <iconText>Save</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+S</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="file_save_as">
       <icon>document-save-as</icon>
       <text>Save &amp;As...</text>
       <whatsThis></whatsThis>
       <toolTip>Save document under a new name</toolTip>
       <iconText>Save As</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+Shift+S</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 <!-- commented out in the code right now
     <Action name="file_reload_file">
       <icon></icon>
       <text>Reload</text>
       <whatsThis></whatsThis>
       <toolTip>Reload</toolTip>
       <iconText>Reload</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 -->
     <Action name="file_sessions">
       <icon></icon>
       <text>Sessions...</text>
       <whatsThis></whatsThis>
       <toolTip>Open session manager</toolTip>
       <iconText>Sessions</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="file_import_file">
       <icon>document-import</icon>
       <text>Open ex&amp;isting Document as Untitled Document...</text>
       <whatsThis></whatsThis>
       <toolTip>Open existing Document as Untitled Document</toolTip>
       <iconText>Open existing Document as Untitled Document</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="file_export_file">
       <icon>document-export</icon>
       <text>E&amp;xport...</text>
       <whatsThis></whatsThis>
       <toolTip>Export</toolTip>
       <iconText>Export</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="file_import_animation">
       <icon></icon>
       <text>Import animation frames...</text>
       <whatsThis></whatsThis>
       <toolTip>Import animation frames</toolTip>
       <iconText>Import animation frames</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="render_animation">
       <icon></icon>
       <text>&amp;Render Animation...</text>
       <whatsThis></whatsThis>
       <toolTip>Render Animation to GIF, Image Sequence or Video</toolTip>
       <iconText>Render Animation</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
       <Action name="render_animation_again">
       <icon></icon>
       <text>&amp;Render Animation Again</text>
       <whatsThis></whatsThis>
       <toolTip>Render Animation Again</toolTip>
       <iconText>Render Animation</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="save_incremental_version">
       <icon></icon>
       <text>Save Incremental &amp;Version</text>
       <whatsThis></whatsThis>
       <toolTip>Save Incremental Version</toolTip>
       <iconText>Save Incremental Version</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+Alt+S</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="save_incremental_backup">
       <icon></icon>
       <text>Save Incremental &amp;Backup</text>
       <whatsThis></whatsThis>
       <toolTip>Save Incremental Backup</toolTip>
       <iconText>Save Incremental Backup</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>F4</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="create_template">
       <icon></icon>
       <text>&amp;Create Template From Image...</text>
       <whatsThis></whatsThis>
       <toolTip>Create Template From Image</toolTip>
       <iconText>Create Template From Image</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="create_copy">
       <icon></icon>
       <text>Create Copy &amp;From Current Image</text>
       <whatsThis></whatsThis>
       <toolTip>Create Copy From Current Image</toolTip>
       <iconText>Create Copy From Current Image</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="file_print">
       <icon>document-print</icon>
       <text>&amp;Print...</text>
       <whatsThis></whatsThis>
       <toolTip>Print document</toolTip>
       <iconText>Print</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+P</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="file_print_preview">
       <icon>document-print-preview</icon>
       <text>Print Previe&amp;w</text>
       <whatsThis></whatsThis>
       <toolTip>Show a print preview of document</toolTip>
       <iconText>Print Preview</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="file_documentinfo">
       <icon>configure</icon>
       <text>&amp;Document Information</text>
       <whatsThis></whatsThis>
       <toolTip>Document Information</toolTip>
       <iconText>Document Information</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="file_close_all">
       <icon></icon>
       <text>&amp;Close All</text>
       <whatsThis></whatsThis>
       <toolTip>Close All</toolTip>
       <iconText>Close All</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+Shift+W</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="file_close">
       <icon></icon>
       <text>C&amp;lose</text>
       <whatsThis></whatsThis>
       <toolTip>Close</toolTip>
       <iconText>Close</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+W</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="file_quit">
       <icon></icon>
       <text>&amp;Quit</text>
       <whatsThis></whatsThis>
       <toolTip>Quit application</toolTip>
       <iconText>Quit</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+Q</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
   </Actions>
 
   <Actions category="Edit">
     <text>Edit</text>
     <Action name="edit_undo">
       <icon>edit-undo</icon>
       <text>Undo</text>
       <whatsThis></whatsThis>
       <toolTip>Undo last action</toolTip>
       <iconText>Undo</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+Z</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="edit_redo">
       <icon>edit-redo</icon>
       <text>Redo</text>
       <whatsThis></whatsThis>
       <toolTip>Redo last undone action</toolTip>
       <iconText>Redo</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+Shift+Z</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="edit_cut">
       <icon>edit-cut</icon>
       <text>Cu&amp;t</text>
       <whatsThis></whatsThis>
       <toolTip>Cut selection to clipboard</toolTip>
       <iconText>Cut</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+X</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="edit_copy">
       <icon>edit-copy</icon>
       <text>&amp;Copy</text>
       <whatsThis></whatsThis>
       <toolTip>Copy selection to clipboard</toolTip>
       <iconText>Copy</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+C</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="copy_sharp">
       <icon></icon>
       <text>C&amp;opy (sharp)</text>
       <whatsThis></whatsThis>
       <toolTip>Copy (sharp)</toolTip>
       <iconText>Copy (sharp)</iconText>
       <activationFlags>100000000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="cut_sharp">
       <icon></icon>
       <text>Cut (&amp;sharp)</text>
       <whatsThis></whatsThis>
       <toolTip>Cut (sharp)</toolTip>
       <iconText>Cut (sharp)</iconText>
       <activationFlags>100000000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="copy_merged">
       <icon></icon>
       <text>Copy &amp;merged</text>
       <whatsThis></whatsThis>
       <toolTip>Copy merged</toolTip>
       <iconText>Copy merged</iconText>
       <activationFlags>100000000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+Shift+C</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="edit_paste">
       <icon>edit-paste</icon>
       <text>&amp;Paste</text>
       <whatsThis></whatsThis>
       <toolTip>Paste clipboard content</toolTip>
       <iconText>Paste</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+V</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="paste_at">
       <icon></icon>
       <text>Paste at Cursor</text>
       <whatsThis></whatsThis>
       <toolTip>Paste at cursor</toolTip>
       <iconText>Paste at cursor</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+Alt+V</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="paste_new">
       <icon></icon>
       <text>Paste into &amp;New Image</text>
       <whatsThis></whatsThis>
       <toolTip>Paste into New Image</toolTip>
       <iconText>Paste into New Image</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+Shift+N</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="paste_as_reference">
       <icon></icon>
       <text>Paste as R&amp;eference Image</text>
       <whatsThis></whatsThis>
       <toolTip>Paste as Reference Image</toolTip>
       <iconText>Paste as Reference Image</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+Shift+R</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="clear">
       <icon>edit-clear</icon>
       <text>C&amp;lear</text>
       <whatsThis></whatsThis>
       <toolTip>Clear</toolTip>
       <iconText>Clear</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Del</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="fill_selection_foreground_color">
       <icon></icon>
       <text>&amp;Fill with Foreground Color</text>
       <whatsThis></whatsThis>
       <toolTip>Fill with Foreground Color</toolTip>
       <iconText>Fill with Foreground Color</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut>Shift+Backspace</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="fill_selection_background_color">
       <icon></icon>
       <text>Fill &amp;with Background Color</text>
       <whatsThis></whatsThis>
       <toolTip>Fill with Background Color</toolTip>
       <iconText>Fill with Background Color</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut>Backspace</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="fill_selection_pattern">
       <icon></icon>
       <text>F&amp;ill with Pattern</text>
       <whatsThis></whatsThis>
       <toolTip>Fill with Pattern</toolTip>
       <iconText>Fill with Pattern</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Actions category="EditFill">
       <text>Fill Special</text>
        <Action name="fill_selection_foreground_color_opacity">
         <icon></icon>
         <text>Fill with Foreground Color (Opacity)</text>
         <whatsThis></whatsThis>
         <toolTip>Fill with Foreground Color (Opacity)</toolTip>
         <iconText>Fill with Foreground Color (Opacity)</iconText>
         <activationFlags>10000</activationFlags>
         <activationConditions>1</activationConditions>
         <shortcut>Ctrl+Shift+Backspace</shortcut>
         <isCheckable>false</isCheckable>
         <statusTip></statusTip>
       </Action>
       <Action name="fill_selection_background_color_opacity">
         <icon></icon>
         <text>Fill with Background Color (Opacity)</text>
         <whatsThis></whatsThis>
         <toolTip>Fill with Background Color (Opacity)</toolTip>
         <iconText>Fill with Background Color (Opacity)</iconText>
         <activationFlags>10000</activationFlags>
         <activationConditions>1</activationConditions>
         <shortcut>Ctrl+Backspace</shortcut>
         <isCheckable>false</isCheckable>
         <statusTip></statusTip>
       </Action>
       <Action name="fill_selection_pattern_opacity">
         <icon></icon>
         <text>Fill with Pattern (Opacity)</text>
         <whatsThis></whatsThis>
         <toolTip>Fill with Pattern (Opacity)</toolTip>
         <iconText>Fill with Pattern (Opacity)</iconText>
         <activationFlags>10000</activationFlags>
         <activationConditions>1</activationConditions>
         <shortcut></shortcut>
         <isCheckable>false</isCheckable>
         <statusTip></statusTip>
       </Action>
     </Actions>
     <Action name="stroke_shapes">
       <icon></icon>
       <text>Stro&amp;ke selected shapes</text>
       <whatsThis></whatsThis>
       <toolTip>Stroke selected shapes</toolTip>
       <iconText>Stroke selected shapes</iconText>
       <activationFlags>1000000000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="stroke_selection">
       <icon></icon>
       <text>Stroke Selec&amp;tion...</text>
       <whatsThis></whatsThis>
       <toolTip>Stroke selection</toolTip>
       <iconText>Stroke selection</iconText>
       <activationFlags>10000000000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
 
     <Action name="delete_keyframe">
       <icon></icon>
       <text>Delete keyframe</text>
       <whatsThis></whatsThis>
       <toolTip>Delete keyframe</toolTip>
       <iconText>Delete keyframe</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
   </Actions>
 
 
   <Actions category="Window">
     <text>Window</text>
     <Action name="view_newwindow">
       <icon>window-new</icon>
       <text>&amp;New Window</text>
       <whatsThis></whatsThis>
       <toolTip>New Window</toolTip>
       <iconText>New Window</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="windows_next">
       <icon></icon>
       <text>N&amp;ext</text>
       <whatsThis></whatsThis>
       <toolTip>Next</toolTip>
       <iconText>Next</iconText>
       <activationFlags>10</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="windows_previous">
       <icon></icon>
       <text>Previous</text>
       <whatsThis></whatsThis>
       <toolTip>Previous</toolTip>
       <iconText>Previous</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
   </Actions>
 
   <Actions category="View">
     <text>View</text>
     <Action name="view_show_canvas_only">
       <icon>document-new</icon>
       <text>&amp;Show Canvas Only</text>
       <whatsThis></whatsThis>
       <toolTip>Show just the canvas or the whole window</toolTip>
       <iconText>Show Canvas Only</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Tab</shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="fullscreen">
       <icon>view-fullscreen</icon>
       <text>F&amp;ull Screen Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Display the window in full screen</toolTip>
       <iconText>Full Screen Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+Shift+F</shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
+    <Action name="view_detached_canvas">
+      <icon></icon>
+      <text>Detach canvas</text>
+      <whatsThis></whatsThis>
+      <toolTip>Show the canvas on a separate window</toolTip>
+      <iconText>Detach canvas</iconText>
+      <activationFlags>0</activationFlags>
+      <activationConditions>0</activationConditions>
+      <shortcut></shortcut>
+      <isCheckable>true</isCheckable>
+      <statusTip></statusTip>
+    </Action>
     <Action name="wrap_around_mode">
       <icon></icon>
       <text>&amp;Wrap Around Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Wrap Around Mode</toolTip>
       <iconText>Wrap Around Mode</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="level_of_detail_mode">
       <icon></icon>
       <text>&amp;Instant Preview Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Instant Preview Mode</toolTip>
       <iconText>Instant Preview Mode</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Shift+L</shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="softProof">
       <icon></icon>
       <text>Soft Proofing</text>
       <whatsThis></whatsThis>
       <toolTip>Turns on Soft Proofing</toolTip>
       <iconText>Turns on Soft Proofing</iconText>
       <shortcut>Ctrl+Y</shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="gamutCheck">
       <icon></icon>
       <text>Out of Gamut Warnings</text>
       <whatsThis></whatsThis>
       <toolTip>Turns on warnings for colors out of proofed gamut, needs soft proofing to be turned on.</toolTip>
       <iconText>Turns on warnings for colors out of proofed gamut, needs soft proofing to be turned on.</iconText>
       <shortcut>Ctrl+Shift+Y</shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="mirror_canvas">
       <icon>mirror-view</icon>
       <text>Mirror View</text>
       <whatsThis></whatsThis>
       <toolTip>Mirror View</toolTip>
       <iconText>Mirror View</iconText>
       <shortcut>M</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="zoom_to_100pct">
       <icon>zoom-original</icon>
       <text>&amp;Reset zoom</text>
       <whatsThis></whatsThis>
       <toolTip>Reset zoom</toolTip>
       <iconText>Reset zoom</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+0</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="view_zoom_in">
       <icon>zoom-in</icon>
       <text>Zoom &amp;In</text>
       <whatsThis></whatsThis>
       <toolTip>Zoom In</toolTip>
       <iconText></iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl++</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="view_zoom_out">
       <icon>zoom-out</icon>
       <text>Zoom &amp;Out</text>
       <whatsThis></whatsThis>
       <toolTip>Zoom Out</toolTip>
       <iconText></iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+-</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="rotate_canvas_right">
       <icon>rotate-canvas-right</icon>
       <text>Rotate &amp;Canvas Right</text>
       <whatsThis></whatsThis>
       <toolTip>Rotate Canvas Right</toolTip>
       <iconText>Rotate Canvas Right</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+]</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="rotate_canvas_left">
       <icon>rotate-canvas-left</icon>
       <text>Rotate Canvas &amp;Left</text>
       <whatsThis></whatsThis>
       <toolTip>Rotate Canvas Left</toolTip>
       <iconText>Rotate Canvas Left</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+[</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="reset_canvas_rotation">
       <icon>rotation-reset</icon>
       <text>Reset Canvas Rotation</text>
       <whatsThis></whatsThis>
       <toolTip>Reset Canvas Rotation</toolTip>
       <iconText>Reset Canvas Rotation</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="view_ruler">
       <icon></icon>
       <text>Show &amp;Rulers</text>
       <whatsThis>The rulers show the horizontal and vertical positions of the mouse on the image and can be used to position your mouse at the right place on the canvas. &lt;p>Uncheck this to hide the rulers.&lt;/p></whatsThis>
       <toolTip>Show Rulers</toolTip>
       <iconText>Show Rulers</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="rulers_track_mouse">
       <icon></icon>
       <text>Rulers Track Pointer</text>
       <whatsThis>The rulers will track current mouse position and show it on screen. It can cause suptle performance slowdown</whatsThis>
       <toolTip>Rulers Track Pointer</toolTip>
       <iconText>Rulers Track Pointer</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="view_show_guides">
       <icon></icon>
       <text>Show Guides</text>
       <whatsThis></whatsThis>
       <toolTip>Show or hide guides</toolTip>
       <iconText>Show Guides</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="view_lock_guides">
       <icon></icon>
       <text>Lock Guides</text>
       <whatsThis></whatsThis>
       <toolTip>Lock or unlock guides</toolTip>
       <iconText>Lock Guides</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="view_snap_to_guides">
       <icon></icon>
       <text>Snap to Guides</text>
       <whatsThis></whatsThis>
       <toolTip>Snap cursor to guides position</toolTip>
       <iconText>Snap to Guides</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="showStatusBar">
       <icon></icon>
       <text>Show Status &amp;Bar</text>
       <whatsThis></whatsThis>
       <toolTip>Show or hide the status bar</toolTip>
       <iconText>Show Status Bar</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="view_pixel_grid">
       <icon></icon>
       <text>Show Pixel Grid</text>
       <whatsThis></whatsThis>
       <toolTip>Show Pixel Grid</toolTip>
       <iconText>Show Pixel Grid</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1000</activationConditions>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="view_grid">
       <icon>view-grid</icon>
       <text>Show &amp;Grid</text>
       <whatsThis></whatsThis>
       <toolTip>Show Grid</toolTip>
       <iconText>Show Grid</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+Shift+'</shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="view_snap_to_grid">
       <icon></icon>
       <text>Snap To Grid</text>
       <whatsThis></whatsThis>
       <toolTip>Snap To Grid</toolTip>
       <iconText>Snap To Grid</iconText>
       <activationFlags>1000</activationFlags>
       <shortcut>Ctrl+Shift+;</shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="show_snap_options_popup">
       <icon></icon>
       <text>Show Snap Options Popup</text>
       <whatsThis></whatsThis>
       <toolTip>Show Snap Options Popup</toolTip>
       <iconText>Show Snap Options Popup</iconText>
       <activationFlags>1000</activationFlags>
       <shortcut>Shift+s</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="view_snap_orthogonal">
       <icon></icon>
       <text>Snap Orthogonal</text>
       <whatsThis></whatsThis>
       <toolTip>Snap Orthogonal</toolTip>
       <iconText>Snap Orthogonal</iconText>
       <activationFlags>1000</activationFlags>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="view_snap_node">
       <icon></icon>
       <text>Snap Node</text>
       <whatsThis></whatsThis>
       <toolTip>Snap Node</toolTip>
       <iconText>Snap Node</iconText>
       <activationFlags>1000</activationFlags>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="view_snap_extension">
       <icon></icon>
       <text>Snap Extension</text>
       <whatsThis></whatsThis>
       <toolTip>Snap Extension</toolTip>
       <iconText>Snap Extension</iconText>
       <activationFlags>1000</activationFlags>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="view_snap_to_pixel">
       <icon></icon>
       <text>Snap Pixel</text>
       <whatsThis></whatsThis>
       <toolTip>Snap Pixel</toolTip>
       <iconText>Snap Pixel</iconText>
       <activationFlags>1000</activationFlags>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="view_snap_intersection">
       <icon></icon>
       <text>Snap Intersection</text>
       <whatsThis></whatsThis>
       <toolTip>Snap Intersection</toolTip>
       <iconText>Snap Intersection</iconText>
       <activationFlags>1000</activationFlags>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="view_snap_bounding_box">
       <icon></icon>
       <text>Snap Bounding Box</text>
       <whatsThis></whatsThis>
       <toolTip>Snap Bounding Box</toolTip>
       <iconText>Snap Bounding Box</iconText>
       <activationFlags>1000</activationFlags>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="view_snap_image_bounds">
       <icon></icon>
       <text>Snap Image Bounds</text>
       <whatsThis></whatsThis>
       <toolTip>Snap Image Bounds</toolTip>
       <iconText>Snap Image Bounds</iconText>
       <activationFlags>1000</activationFlags>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="view_snap_image_center">
       <icon></icon>
       <text>Snap Image Center</text>
       <whatsThis></whatsThis>
       <toolTip>Snap Image Center</toolTip>
       <iconText>Snap Image Center</iconText>
       <activationFlags>1000</activationFlags>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="view_toggle_painting_assistants">
       <icon></icon>
       <text>S&amp;how Painting Assistants</text>
       <whatsThis></whatsThis>
       <toolTip>Show Painting Assistants</toolTip>
       <iconText>Show Painting Assistants</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="view_toggle_assistant_previews">
       <icon></icon>
       <text>Show &amp;Assistant Previews</text>
       <whatsThis></whatsThis>
       <toolTip>Show Assistant Previews</toolTip>
       <iconText>Show Assistant Previews</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="view_toggle_reference_images">
       <icon></icon>
       <text>S&amp;how Reference Images</text>
       <whatsThis></whatsThis>
       <toolTip>Show Reference Images</toolTip>
       <iconText>Show Reference Images</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
 
   </Actions>
 
   <Actions category="Image">
     <text>Image</text>
     <Action name="image_properties">
       <icon>document-properties</icon>
       <text>&amp;Properties...</text>
       <whatsThis></whatsThis>
       <toolTip>Properties</toolTip>
       <iconText>Properties</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="image_color">
       <icon>format-stroke-color</icon>
       <text>&amp;Image Background Color and Transparency...</text>
       <whatsThis></whatsThis>
       <toolTip>Change the background color of the image</toolTip>
       <iconText>Image Background Color and Transparency</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="imagecolorspaceconversion">
       <icon></icon>
       <text>&amp;Convert Image Color Space...</text>
       <whatsThis></whatsThis>
       <toolTip>Convert Image Color Space</toolTip>
       <iconText>Convert Image Color Space</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="trim_to_image">
       <icon>trim-to-image</icon>
       <text>&amp;Trim to Image Size</text>
       <whatsThis></whatsThis>
       <toolTip>Trim to Image Size</toolTip>
       <iconText>Trim to Image Size</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="resizeimagetolayer">
       <icon></icon>
       <text>Trim to Current &amp;Layer</text>
       <whatsThis></whatsThis>
       <toolTip>Trim to Current Layer</toolTip>
       <iconText>Trim to Current Layer</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="resizeimagetoselection">
       <icon></icon>
       <text>Trim to S&amp;election</text>
       <whatsThis></whatsThis>
       <toolTip>Trim to Selection</toolTip>
       <iconText>Trim to Selection</iconText>
       <activationFlags>100000000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="rotateimage">
       <icon></icon>
       <text>&amp;Rotate Image...</text>
       <whatsThis></whatsThis>
       <toolTip>Rotate Image</toolTip>
       <iconText>Rotate Image</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="rotateImageCW90">
       <icon>object-rotate-right</icon>
       <text>Rotate &amp;Image 90° to the Right</text>
       <whatsThis></whatsThis>
       <toolTip>Rotate Image 90° to the Right</toolTip>
       <iconText>Rotate Image 90° to the Right</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="rotateImageCCW90">
       <icon>object-rotate-left</icon>
       <text>Rotate Image &amp;90° to the Left</text>
       <whatsThis></whatsThis>
       <toolTip>Rotate Image 90° to the Left</toolTip>
       <iconText>Rotate Image 90° to the Left</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="rotateImage180">
       <icon></icon>
       <text>Rotate Image &amp;180°</text>
       <whatsThis></whatsThis>
       <toolTip>Rotate Image 180°</toolTip>
       <iconText>Rotate Image 180°</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="shearimage">
       <icon></icon>
       <text>&amp;Shear Image...</text>
       <whatsThis></whatsThis>
       <toolTip>Shear Image</toolTip>
       <iconText>Shear Image</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="mirrorImageHorizontal">
       <icon>symmetry-horizontal</icon>
       <text>&amp;Mirror Image Horizontally</text>
       <whatsThis></whatsThis>
       <toolTip>Mirror Image Horizontally</toolTip>
       <iconText>Mirror Image Horizontally</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="mirrorImageVertical">
       <icon>symmetry-vertical</icon>
       <text>Mirror Image &amp;Vertically</text>
       <whatsThis></whatsThis>
       <toolTip>Mirror Image Vertically</toolTip>
       <iconText>Mirror Image Vertically</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="imagesize">
       <icon></icon>
       <text>Scale Image To &amp;New Size...</text>
       <whatsThis></whatsThis>
       <toolTip>Scale Image To New Size</toolTip>
       <iconText>Scale Image To New Size</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+Alt+I</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="offsetimage">
       <icon></icon>
       <text>&amp;Offset Image...</text>
       <whatsThis></whatsThis>
       <toolTip>Offset Image</toolTip>
       <iconText>Offset Image</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="canvassize">
       <icon></icon>
       <text>R&amp;esize Canvas...</text>
       <whatsThis></whatsThis>
       <toolTip>Resize Canvas</toolTip>
       <iconText>Resize Canvas</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+Alt+C</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="imagesplit">
       <icon></icon>
       <text>Im&amp;age Split </text>
       <whatsThis></whatsThis>
       <toolTip>Image Split</toolTip>
       <iconText>Image Split</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="separate">
       <icon></icon>
       <text>Separate Ima&amp;ge...</text>
       <whatsThis></whatsThis>
       <toolTip>Separate Image</toolTip>
       <iconText>Separate Image</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
   </Actions>
 
   <Actions category="Select">
     <text>Select</text>
     <Action name="select_all">
       <icon>edit-select-all</icon>
       <text>Select &amp;All</text>
       <whatsThis></whatsThis>
       <toolTip>Select All</toolTip>
       <iconText>Select All</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+A</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="deselect">
-      <icon>edit-select-all</icon>
+      <icon>edit-select-none</icon>
       <text>&amp;Deselect</text>
       <whatsThis></whatsThis>
       <toolTip>Deselect</toolTip>
       <iconText>Deselect</iconText>
       <activationFlags>1100000000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+Shift+A</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="reselect">
       <icon></icon>
       <text>&amp;Reselect</text>
       <whatsThis></whatsThis>
       <toolTip>Reselect</toolTip>
       <iconText>Reselect</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+Shift+D</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="convert_to_vector_selection">
       <icon></icon>
       <text>&amp;Convert to Vector Selection</text>
       <whatsThis></whatsThis>
       <toolTip>Convert to Vector Selection</toolTip>
       <iconText>Convert to Vector Selection</iconText>
       <activationFlags>100000000000000000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="convert_to_raster_selection">
       <icon></icon>
       <text>&amp;Convert to Raster Selection</text>
       <whatsThis></whatsThis>
       <toolTip>Convert to Raster Selection</toolTip>
       <iconText>Convert to Raster Selection</iconText>
       <activationFlags>10000000000000000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="edit_selection">
       <icon></icon>
       <text>Edit Selection</text>
       <whatsThis></whatsThis>
       <toolTip>Edit Selection</toolTip>
       <iconText>Edit Selection</iconText>
       <activationFlags>10000000000</activationFlags>
       <activationConditions>100</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="convert_shapes_to_vector_selection">
       <icon></icon>
       <text>Convert Shapes to &amp;Vector Selection</text>
       <whatsThis></whatsThis>
       <toolTip>Convert Shapes to Vector Selection</toolTip>
       <iconText>Convert Shapes to Vector Selection</iconText>
       <activationFlags>1000000000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="featherselection">
       <icon></icon>
       <text>&amp;Feather Selection...</text>
       <whatsThis></whatsThis>
       <toolTip>Feather Selection</toolTip>
       <iconText>Feather Selection</iconText>
       <activationFlags>10000000000</activationFlags>
       <activationConditions>100</activationConditions>
       <shortcut>Shift+F6</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="toggle_display_selection">
       <icon></icon>
       <text>Dis&amp;play Selection</text>
       <whatsThis></whatsThis>
       <toolTip>Display Selection</toolTip>
       <iconText>Display Selection</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+H</shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="selectionscale">
       <icon></icon>
       <text>Sca&amp;le...</text>
       <whatsThis></whatsThis>
       <toolTip>Scale</toolTip>
       <iconText>Scale</iconText>
       <activationFlags>100000000</activationFlags>
       <activationConditions>100</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="colorrange">
       <icon></icon>
       <text>S&amp;elect from Color Range...</text>
       <whatsThis></whatsThis>
       <toolTip>Select from Color Range</toolTip>
       <iconText>Select from Color Range</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>100</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="selectopaque">
       <icon></icon>
       <text>Select &amp;Opaque (Replace)</text>
       <whatsThis></whatsThis>
       <toolTip>Select Opaque</toolTip>
       <iconText>Select Opaque</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>100</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="selectopaque_add">
       <icon></icon>
       <text>Select Opaque (&amp;Add)</text>
       <whatsThis></whatsThis>
       <toolTip>Select Opaque (Add)</toolTip>
       <iconText>Select Opaque (Add)</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>100</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="selectopaque_subtract">
       <icon></icon>
       <text>Select Opaque (&amp;Subtract)</text>
       <whatsThis></whatsThis>
       <toolTip>Select Opaque (Subtract)</toolTip>
       <iconText>Select Opaque (Subtract)</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>100</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="selectopaque_intersect">
       <icon></icon>
       <text>Select Opaque (&amp;Intersect)</text>
       <whatsThis></whatsThis>
       <toolTip>Select Opaque (Intersect)</toolTip>
       <iconText>Select Opaque (Intersect)</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>100</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="growselection">
       <icon></icon>
       <text>&amp;Grow Selection...</text>
       <whatsThis></whatsThis>
       <toolTip>Grow Selection</toolTip>
       <iconText>Grow Selection</iconText>
       <activationFlags>10000000000</activationFlags>
       <activationConditions>100</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="shrinkselection">
       <icon></icon>
       <text>S&amp;hrink Selection...</text>
       <whatsThis></whatsThis>
       <toolTip>Shrink Selection</toolTip>
       <iconText>Shrink Selection</iconText>
       <activationFlags>10000000000</activationFlags>
       <activationConditions>100</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="borderselection">
       <icon></icon>
       <text>&amp;Border Selection...</text>
       <whatsThis></whatsThis>
       <toolTip>Border Selection</toolTip>
       <iconText>Border Selection</iconText>
       <activationFlags>10000000000</activationFlags>
       <activationConditions>100</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="smoothselection">
       <icon></icon>
       <text>S&amp;mooth</text>
       <whatsThis></whatsThis>
       <toolTip>Smooth</toolTip>
       <iconText>Smooth</iconText>
       <activationFlags>10000000000</activationFlags>
       <activationConditions>100</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
   </Actions>
 
   <Actions category="Filter">
     <text>Filter</text>
     <Action name="filter_apply_again">
       <icon></icon>
       <text>&amp;Apply Filter Again</text>
       <whatsThis></whatsThis>
       <toolTip>Apply Filter Again</toolTip>
       <iconText>Apply Filter Again</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+F</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="adjust_filters">
       <icon></icon>
       <text>Adjust</text>
       <whatsThis></whatsThis>
       <toolTip>Adjust</toolTip>
       <iconText>Adjust</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="artistic_filters">
       <icon></icon>
       <text>Artistic</text>
       <whatsThis></whatsThis>
       <toolTip>Artistic</toolTip>
       <iconText>Artistic</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="blur_filters">
       <icon></icon>
       <text>Blur</text>
       <whatsThis></whatsThis>
       <toolTip>Blur</toolTip>
       <iconText>Blur</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="color_filters">
       <icon></icon>
       <text>Colors</text>
       <whatsThis></whatsThis>
       <toolTip>Colors</toolTip>
       <iconText>Colors</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="edge_filters">
       <icon></icon>
       <text>Edge Detection</text>
       <whatsThis></whatsThis>
       <toolTip>Edge Detection</toolTip>
       <iconText>Edge Detection</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="enhance_filters">
       <icon></icon>
       <text>Enhance</text>
       <whatsThis></whatsThis>
       <toolTip>Enhance</toolTip>
       <iconText>Enhance</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="emboss_filters">
       <icon></icon>
       <text>Emboss</text>
       <whatsThis></whatsThis>
       <toolTip>Emboss</toolTip>
       <iconText>Emboss</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="map_filters">
       <icon></icon>
       <text>Map</text>
       <whatsThis></whatsThis>
       <toolTip>Map</toolTip>
       <iconText>Map</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="other_filters">
       <icon></icon>
       <text>Other</text>
       <whatsThis></whatsThis>
       <toolTip>Other</toolTip>
       <iconText>Other</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="QMic">
       <icon>gmic</icon>
       <text>Start G'MIC-Qt</text>
       <whatsThis></whatsThis>
       <toolTip>Start G'Mic-Qt</toolTip>
       <iconText>Start G'Mic-Qt</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
   <Action name="QMicAgain">
       <icon>gmic</icon>
       <text>Re-apply the last G'MIC filter</text>
       <whatsThis></whatsThis>
       <toolTip>Apply the last G'Mic-Qt action again</toolTip>
       <iconText>Apply the last G'Mic-Qt action again</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
   </Actions>
 
   <Actions category="Settings">
     <text>Settings</text>
     <Action name="options_configure">
       <icon>configure</icon>
       <text>&amp;Configure Krita...</text>
       <whatsThis></whatsThis>
       <toolTip>Configure Krita</toolTip>
       <iconText>Configure Krita</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="manage_bundles">
       <icon></icon>
       <text>&amp;Manage Resources...</text>
       <whatsThis></whatsThis>
       <toolTip>Manage Resources</toolTip>
       <iconText>Manage Resources</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="switch_application_language">
       <icon>preferences-desktop-locale</icon>
       <text>Switch Application &amp;Language...</text>
       <whatsThis></whatsThis>
       <toolTip>Switch Application Language</toolTip>
       <iconText>Switch Application Language</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="view_toggledockers">
       <icon></icon>
       <text>&amp;Show Dockers</text>
       <whatsThis></whatsThis>
       <toolTip>Show Dockers</toolTip>
       <iconText>Show Dockers</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="options_configure_toolbars">
       <icon>configure</icon>
       <text>Configure Tool&amp;bars...</text>
       <whatsThis></whatsThis>
       <toolTip>Configure Toolbars</toolTip>
       <iconText>Configure Toolbars</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="settings_dockers_menu">
       <icon></icon>
       <text>Dockers</text>
       <whatsThis></whatsThis>
       <toolTip>Dockers</toolTip>
       <iconText>Dockers</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="theme_menu">
       <icon></icon>
       <text>&amp;Themes</text>
       <whatsThis></whatsThis>
       <toolTip>Themes</toolTip>
       <iconText>Themes</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="settings_active_author">
       <icon>im-user</icon>
       <text>Active Author Profile</text>
       <whatsThis></whatsThis>
       <toolTip>Active Author Profile</toolTip>
       <iconText>Active Author Profile</iconText>
       <shortcut></shortcut>
       <isCheckable></isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="options_configure_keybinding">
       <icon>configure-shortcuts</icon>
       <text>Configure S&amp;hortcuts...</text>
       <whatsThis></whatsThis>
       <toolTip>Configure Shortcuts</toolTip>
       <iconText>Configure Shortcuts</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="window">
       <icon></icon>
       <text>&amp;Window</text>
       <whatsThis></whatsThis>
       <toolTip>Window</toolTip>
       <iconText>Window</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
   </Actions>
 
   <Actions category="Help">
     <text>Help</text>
     <Action name="help_contents">
       <icon>help-contents</icon>
       <text>Krita &amp;Handbook</text>
       <whatsThis></whatsThis>
       <toolTip>Krita Handbook</toolTip>
       <iconText>Krita Handbook</iconText>
       <shortcut>F1</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="help_report_bug">
       <icon>tools-report-bug</icon>
       <text>&amp;Report Bug...</text>
       <whatsThis></whatsThis>
       <toolTip>Report Bug</toolTip>
       <iconText>Report Bug</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="help_about_app">
-      <icon>calligrakrita</icon>
+      <icon>krita</icon>
       <text>&amp;About Krita</text>
       <whatsThis></whatsThis>
       <toolTip>About Krita</toolTip>
       <iconText>About Krita</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="help_about_kde">
       <icon>kde</icon>
       <text>About &amp;KDE</text>
       <whatsThis></whatsThis>
       <toolTip>About KDE</toolTip>
       <iconText>About KDE</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
   </Actions>
 
   <Actions category="BrushesAndStuff">
     <text>Brushes and Stuff</text>
     <Action name="gradients">
       <icon></icon>
       <text>&amp;Gradients</text>
       <whatsThis></whatsThis>
       <toolTip>Gradients</toolTip>
       <iconText>Gradients</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="patterns">
       <icon></icon>
       <text>&amp;Patterns</text>
       <whatsThis></whatsThis>
       <toolTip>Patterns</toolTip>
       <iconText>Patterns</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="dual">
       <icon></icon>
       <text>&amp;Color</text>
       <whatsThis></whatsThis>
       <toolTip>Color</toolTip>
       <iconText>Color</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="paintops">
       <icon></icon>
       <text>&amp;Painter's Tools</text>
       <whatsThis></whatsThis>
       <toolTip>Painter's Tools</toolTip>
       <iconText>Painter's Tools</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="composite_actions">
       <icon></icon>
       <text>Brush composite</text>
       <whatsThis></whatsThis>
       <toolTip>Brush composite</toolTip>
       <iconText>Brush composite</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="brushslider1">
       <icon></icon>
       <text>Brush option slider 1</text>
       <whatsThis></whatsThis>
       <toolTip>Brush option slider 1</toolTip>
       <iconText>Brush option slider 1</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="brushslider2">
       <icon></icon>
       <text>Brush option slider 2</text>
       <whatsThis></whatsThis>
       <toolTip>Brush option slider 2</toolTip>
       <iconText>Brush option slider 2</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="brushslider3">
       <icon></icon>
       <text>Brush option slider 3</text>
       <whatsThis></whatsThis>
       <toolTip>Brush option slider 3</toolTip>
       <iconText>Brush option slider 3</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="mirror_actions">
       <icon></icon>
       <text>Mirror</text>
       <whatsThis></whatsThis>
       <toolTip>Mirror</toolTip>
       <iconText>Mirror</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="select_layout">
       <icon></icon>
       <text>Layouts</text>
       <whatsThis></whatsThis>
       <toolTip>Select layout</toolTip>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="workspaces">
       <icon></icon>
       <text>Workspaces</text>
       <whatsThis></whatsThis>
       <toolTip>Workspaces</toolTip>
       <iconText>Workspaces</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
 
   </Actions>
 </ActionCollection>
diff --git a/krita/org.kde.krita.appdata.xml b/krita/org.kde.krita.appdata.xml
index fcfd2e2c6f..5d9b9c9697 100644
--- a/krita/org.kde.krita.appdata.xml
+++ b/krita/org.kde.krita.appdata.xml
@@ -1,353 +1,373 @@
 <?xml version="1.0" encoding="utf-8"?>
 <component type="desktop">
   <id>org.kde.krita</id>
   <launchable type="desktop-id">org.kde.krita.desktop</launchable>
   <metadata_license>CC0-1.0</metadata_license>
   <project_license>GPL-3.0-only</project_license>
   <developer_name>Krita Foundation</developer_name>
   <developer_name xml:lang="ca">Fundació Krita</developer_name>
   <developer_name xml:lang="ca-valencia">Fundació Krita</developer_name>
   <developer_name xml:lang="cs">Krita Foundation</developer_name>
   <developer_name xml:lang="de">Krita Foundation</developer_name>
   <developer_name xml:lang="en-GB">Krita Foundation</developer_name>
   <developer_name xml:lang="es">Fundación Krita</developer_name>
   <developer_name xml:lang="eu">Krita Fundazioa</developer_name>
   <developer_name xml:lang="fi">Krita Foundation</developer_name>
   <developer_name xml:lang="fr">La Fondation Krita</developer_name>
   <developer_name xml:lang="gl">Fundación Krita</developer_name>
   <developer_name xml:lang="id">Asas Krita</developer_name>
   <developer_name xml:lang="it">Fondazione Krita</developer_name>
   <developer_name xml:lang="ko">Krita Foundation</developer_name>
   <developer_name xml:lang="nl">Krita Foundation</developer_name>
   <developer_name xml:lang="nn">Krita Foundation</developer_name>
   <developer_name xml:lang="pl">Fundacja Krity</developer_name>
   <developer_name xml:lang="pt">Fundação do Krita</developer_name>
   <developer_name xml:lang="pt-BR">Krita Foundation</developer_name>
+  <developer_name xml:lang="sk">Nadácia Krita</developer_name>
   <developer_name xml:lang="sv">Krita-stiftelsen</developer_name>
   <developer_name xml:lang="tr">Krita Vakfı</developer_name>
   <developer_name xml:lang="uk">Фундація Krita</developer_name>
   <developer_name xml:lang="x-test">xxKrita Foundationxx</developer_name>
   <developer_name xml:lang="zh-CN">Krita 基金会</developer_name>
   <developer_name xml:lang="zh-TW">Krita 基金會</developer_name>
   <update_contact>foundation@krita.org</update_contact>
   <name>Krita</name>
   <name xml:lang="ar">كريتا</name>
   <name xml:lang="ca">Krita</name>
   <name xml:lang="ca-valencia">Krita</name>
   <name xml:lang="cs">Krita</name>
   <name xml:lang="de">Krita</name>
   <name xml:lang="el">Krita</name>
   <name xml:lang="en-GB">Krita</name>
   <name xml:lang="es">Krita</name>
   <name xml:lang="eu">Krita</name>
   <name xml:lang="fi">Krita</name>
   <name xml:lang="fr">Krita</name>
   <name xml:lang="gl">Krita</name>
   <name xml:lang="id">Krita</name>
   <name xml:lang="it">Krita</name>
   <name xml:lang="ko">Krita</name>
   <name xml:lang="nl">Krita</name>
   <name xml:lang="nn">Krita</name>
   <name xml:lang="pl">Krita</name>
   <name xml:lang="pt">Krita</name>
   <name xml:lang="pt-BR">Krita</name>
   <name xml:lang="ru">Krita</name>
   <name xml:lang="sk">Krita</name>
   <name xml:lang="sv">Krita</name>
   <name xml:lang="tr">Krita</name>
   <name xml:lang="uk">Krita</name>
   <name xml:lang="x-test">xxKritaxx</name>
   <name xml:lang="zh-CN">Krita</name>
   <name xml:lang="zh-TW">Krita</name>
   <summary>Digital Painting, Creative Freedom</summary>
   <summary xml:lang="ar">رسم رقميّ، حريّة إبداعيّة</summary>
   <summary xml:lang="bs">Digitalno crtanje, kreativna sloboda</summary>
   <summary xml:lang="ca">Dibuix digital, Llibertat creativa</summary>
   <summary xml:lang="ca-valencia">Dibuix digital, Llibertat creativa</summary>
   <summary xml:lang="cs">Digitální malování, svoboda tvorby</summary>
   <summary xml:lang="da">Digital tegning, kunstnerisk frihed</summary>
   <summary xml:lang="de">Digitales Malen, kreative Freiheit</summary>
   <summary xml:lang="el">Ψηφιακή ζωγραφική, δημιουργική ελευθερία</summary>
   <summary xml:lang="en-GB">Digital Painting, Creative Freedom</summary>
   <summary xml:lang="es">Pintura digital, libertad creativa</summary>
   <summary xml:lang="et">Digitaalne joonistamine, loominguline vabadus</summary>
   <summary xml:lang="eu">Margolan digitala, sormen askatasuna</summary>
   <summary xml:lang="fi">Digitaalimaalaus, luova vapaus</summary>
   <summary xml:lang="fr">Peinture numérique, liberté créatrice</summary>
   <summary xml:lang="gl">Debuxo dixital, liberdade creativa</summary>
   <summary xml:lang="ia">Pictura digital, Libertate creative</summary>
   <summary xml:lang="id">Pelukisan Digital, Kebebasan Berkreatif</summary>
   <summary xml:lang="it">Pittura digitale, libertà creativa</summary>
   <summary xml:lang="ko">디지털 페인팅, 자유로운 창의성</summary>
   <summary xml:lang="nl">Digital Painting, Creative Freedom</summary>
   <summary xml:lang="nn">Digital teikning – kreativ fridom</summary>
   <summary xml:lang="pl">Cyfrowe malowanie, Wolność Twórcza</summary>
   <summary xml:lang="pt">Pintura Digital, Liberdade Criativa</summary>
   <summary xml:lang="pt-BR">Pintura digital, liberdade criativa</summary>
   <summary xml:lang="ru">Цифровое рисование. Творческая свобода</summary>
   <summary xml:lang="sk">Digitálne maľovanie, kreatívna sloboda</summary>
   <summary xml:lang="sv">Digital målning, kreativ frihet</summary>
   <summary xml:lang="tr">Sayısal Boyama, Yaratıcı Özgürlük</summary>
   <summary xml:lang="uk">Цифрове малювання, творча свобода</summary>
   <summary xml:lang="x-test">xxDigital Painting, Creative Freedomxx</summary>
   <summary xml:lang="zh-CN">自由挥洒数字绘画的无限创意</summary>
   <summary xml:lang="zh-TW">數位繪畫，創作自由</summary>
   <description>
     <p>Krita is the full-featured digital art studio.</p>
     <p xml:lang="bs">Krita je potpuni digitalni umjetnički studio.</p>
     <p xml:lang="ca">El Krita és l'estudi d'art digital ple de funcionalitats.</p>
     <p xml:lang="ca-valencia">El Krita és l'estudi d'art digital ple de funcionalitats.</p>
     <p xml:lang="de">Krita ist ein digitales Designstudio mit umfangreichen Funktionen.</p>
     <p xml:lang="el">Το Krita είναι ένα πλήρες χαρακτηριστικών ψηφιακό ατελιέ.</p>
     <p xml:lang="en-GB">Krita is the full-featured digital art studio.</p>
     <p xml:lang="es">Krita es un estudio de arte digital completo</p>
     <p xml:lang="et">Krita on rohkete võimalustega digitaalkunstistuudio.</p>
     <p xml:lang="eu">Krita arte lantegi digital osoa da.</p>
     <p xml:lang="fi">Krita on täyspiirteinen digitaiteen ateljee.</p>
     <p xml:lang="fr">Krita est le studio d'art numérique complet.</p>
     <p xml:lang="gl">Krita é un estudio completo de arte dixital.</p>
     <p xml:lang="ia">Krita es le studio de arte digital complete.</p>
     <p xml:lang="id">Krita adalah studio seni digital yang penuh dengan fitur.</p>
     <p xml:lang="it">Krita è uno studio d'arte digitale completo.</p>
     <p xml:lang="ja">Krita は、フル機能を備えたデジタルなアートスタジオです。</p>
     <p xml:lang="ko">Krita는 디지털 예술 스튜디오입니다.</p>
     <p xml:lang="nl">Krita is de digitale kunststudio vol mogelijkheden.</p>
     <p xml:lang="nn">Krita er ei funksjonsrik digital teiknestove.</p>
     <p xml:lang="pl">Krita jest pełnowymiarowym, cyfrowym studiem artystycznym</p>
     <p xml:lang="pt">O Krita é o estúdio de arte digital completo.</p>
     <p xml:lang="pt-BR">O Krita é o estúdio de arte digital completo.</p>
     <p xml:lang="ru">Krita — полнофункциональный инструмент для создания цифровой графики.</p>
     <p xml:lang="sk">Krita je plne vybavené digitálne umelecké štúdio.</p>
     <p xml:lang="sv">Krita är den fullfjädrade digitala konststudion.</p>
     <p xml:lang="tr">Krita, tam özellikli dijital sanat stüdyosudur.</p>
     <p xml:lang="uk">Krita — повноцінний комплекс для створення цифрових художніх творів.</p>
     <p xml:lang="x-test">xxKrita is the full-featured digital art studio.xx</p>
     <p xml:lang="zh-CN">Krita 是一款功能齐全的数字绘画工作室软件。</p>
     <p xml:lang="zh-TW">Krita 是全功能的數位藝術工作室。</p>
     <p>It is perfect for sketching and painting, and presents an end–to–end solution for creating digital painting files from scratch by masters.</p>
     <p xml:lang="bs">On je savršen za skiciranje i slikanje i predstavlja finalno rješenje za kreiranje digitalnih slika od nule s majstorima</p>
     <p xml:lang="ca">És perfecte per fer esbossos i pintar, i presenta una solució final per crear fitxers de dibuix digital des de zero per a mestres.</p>
     <p xml:lang="ca-valencia">És perfecte per fer esbossos i pintar, i presenta una solució final per crear fitxers de dibuix digital des de zero per a mestres.</p>
     <p xml:lang="el">Είναι ιδανικό για σκιτσογραφία και ζωγραφική, και παρουσιάζει μια από άκρη σε άκρη λύση για τη δημιουργία από το μηδέν αρχείων ψηφιακης ζωγραφικής από τους δασκάλους της τέχνης.</p>
     <p xml:lang="en-GB">It is perfect for sketching and painting, and presents an end–to–end solution for creating digital painting files from scratch by masters.</p>
     <p xml:lang="es">Es perfecto para diseñar y pintar, y ofrece una solución completa para crear desde cero archivos de pintura digital apta para profesionales.</p>
     <p xml:lang="et">See on suurepärane töövahend visandite ja joonistuste valmistamiseks ning annab andekatele kunstnikele võimaluse luua digitaalpilt algusest lõpuni just oma käe järgi.</p>
     <p xml:lang="eu">Zirriborratzeko eta margotzeko ezin hobea da, eta margolan digitalen fitxategiak hutsetik sortzeko muturretik-muturrera konponbide bat aurkezten du, maisuentzako mailakoa.</p>
     <p xml:lang="fi">Se on täydellinen luonnosteluun ja maalaukseen ja tarjoaa kokonaisratkaisun digitaalisten kuvatiedostojen luomiseen alusta alkaen.</p>
     <p xml:lang="fr">Il est parfait pour crayonner et peindre, et constitue une solution de bout en bout pour créer des fichier de peinture numérique depuis la feuille blanche jusqu'au épreuves finales.</p>
     <p xml:lang="gl">Resulta perfecto para debuxar e pintar, e presenta unha solución completa que permite aos mestres crear ficheiros de debuxo dixital desde cero.</p>
     <p xml:lang="ia">Illo es perfecte pro schizzar e pinger, e presenta un solution ab fin al fin pro crear files de pictura digital ab grattamentos per maestros.</p>
     <p xml:lang="id">Ini adalah sempurna untuk mensketsa dan melukis, dan menghadirkan sebuah solusi untuk menciptakan file-file pelukisan digital dari goresan si pelukis ulung.</p>
     <p xml:lang="it">Perfetto per fare schizzi e dipingere, prevede una soluzione completa che consente agli artisti di creare file di dipinti digitali partendo da zero.</p>
     <p xml:lang="ko">스케치, 페인팅을 위한 완벽한 도구이며, 생각에서부터 디지털 페인팅 파일을 만들어 낼 수 있는 종합적인 도구를 제공합니다.</p>
     <p xml:lang="nl">Het is perfect voor schetsen en schilderen en zet een end–to–end oplossing voor het maken van digitale bestanden voor schilderingen vanuit het niets door meesters.</p>
     <p xml:lang="nn">Passar perfekt for både teikning og måling, og dekkjer alle ledd i prosessen med å laga digitale måleri frå grunnen av.</p>
     <p xml:lang="pl">Nadaje się perfekcyjnie do szkicowania i malowania i dostarcza zupełnego rozwiązania dla tworzenia plików malowideł cyfrowych od zalążka.</p>
     <p xml:lang="pt">É perfeito para desenhos e pinturas, oferecendo uma solução final para criar ficheiros de pintura digital do zero por mestres.</p>
     <p xml:lang="pt-BR">É perfeito para desenhos e pinturas, oferecendo uma solução final para criar arquivos de desenho digital feitos a partir do zero por mestres.</p>
     <p xml:lang="ru">Она превосходно подходит для набросков и рисования, предоставляя мастерам самодостаточный инструмент для создания цифровой живописи с нуля.</p>
     <p xml:lang="sk">Je ideálna na skicovanie a maľovanie a poskytuje end-to-end riešenie na vytváranie súborov digitálneho maľovania od základu od profesionálov.</p>
     <p xml:lang="sv">Den är perfekt för att skissa och måla, samt erbjuder en helomfattande lösning för att skapa digitala målningsfiler från grunden av mästare.</p>
     <p xml:lang="tr">Eskiz ve boyama için mükemmeldir ve ustaların sıfırdan dijital boyama dosyaları oluşturmak için uçtan-uca bir çözüm sunar.</p>
     <p xml:lang="uk">Цей комплекс чудово пасує для створення ескізів та художніх зображень і є самодостатнім набором для створення файлів цифрових полотен «з нуля» для справжніх художників.</p>
     <p xml:lang="x-test">xxIt is perfect for sketching and painting, and presents an end–to–end solution for creating digital painting files from scratch by masters.xx</p>
     <p xml:lang="zh-CN">它专门为数字绘画设计，为美术工作者提供了一个从起草、上色到完成作品等整个创作流程的完整解决方案。</p>
     <p xml:lang="zh-TW">它是素描和繪畫的完美選擇，並提供了一個從零開始建立數位繪畫檔的端到端解決方案。</p>
     <p>
       Krita is a great choice for creating concept art, comics, textures for rendering and matte paintings. Krita supports many colorspaces like RGB and CMYK
       at 8 and 16 bits integer channels, as well as 16 and 32 bits floating point channels.
     </p>
     <p xml:lang="bs">Krita je odličan izbor za kreiranje konceptualne umjetnosti, stripove, teksture za obradu i mat slike. Krita podržava mnoge prostore boja kao RGB i CMIK na 8 i 16 bitnim cjelobrojnim kanalimaa, kao i 16 i 32 bita floating point kanalima.</p>
     <p xml:lang="ca">El Krita és una gran elecció per crear art conceptual, còmics, textures per renderitzar i pintures «matte». El Krita permet molts espais de color com el RGB i el CMYK a 8 i 16 bits de canals sencers, així com 16 i 32 bits de canals de coma flotant.</p>
     <p xml:lang="ca-valencia">El Krita és una gran elecció per crear art conceptual, còmics, textures per renderitzar i pintures «matte». El Krita permet molts espais de color com el RGB i el CMYK a 8 i 16 bits de canals sencers, així com 16 i 32 bits de canals de coma flotant.</p>
     <p xml:lang="el">Το Krita είναι μια εξαιρετική επιλογή για τη δημιουργία αφηρημένης τέχνης, ιστοριών με εικόνες, υφής για ζωγραφική αποτύπωσης και διάχυσης φωτός. Το Krita υποστηρίζει πολλούς χρωματικούς χώρους όπως τα RGB και CMYK σε 8 και 16 bit κανάλια ακεραίων καθώς επίσης και σε 16 και 32 bit κανάλια κινητής υποδιαστολής,</p>
     <p xml:lang="en-GB">Krita is a great choice for creating concept art, comics, textures for rendering and matte paintings. Krita supports many colourspaces like RGB and CMYK at 8 and 16 bits integer channels, as well as 16 and 32 bits floating point channels.</p>
     <p xml:lang="es">Krita es una gran elección para crear arte conceptual, cómics, texturas para renderizar y «matte paintings». Krita permite el uso de muchos espacios de color, como, por ejemplo, RGB y CMYK, tanto en canales de enteros de 8 y 16 bits, así como en canales de coma flotante de 16 y 32 bits.</p>
     <p xml:lang="et">Krita on üks paremaid valikuid kontseptuaalkunsti, koomiksite, tekstuuride ja digitaalmaalide loomiseks. Krita toetab paljusid värviruume, näiteks RGB ja CMYK 8 ja 16 täisarvulise bitiga kanali kohta, samuti 16 ja 32 ujukomabitiga kanali kohta.</p>
     <p xml:lang="eu">Krita aukera bikaina da kontzeptuzko artea, komikiak, errendatzeko ehundurak eta «matte» margolanak sortzeko. Kritak kolore-espazio ugari onartzen ditu hala nola GBU eta CMYK, 8 eta 16 biteko osoko kanaletan, baita 16 eta 32 biteko koma-higikorreko kanaletan.</p>
     <p xml:lang="fi">Krita on hyvä valinta konseptikuvituksen, sarjakuvien, pintakuvioiden ja maalausten luomiseen. Krita tukee useita väriavaruuksia kuten RGB:tä ja CMYK:ta 8 ja 16 bitin kokonaisluku- samoin kuin 16 ja 32 bitin liukulukukanavin.</p>
     <p xml:lang="fr">Krita est un très bon choix pour créer des concepts arts, des bandes-dessinées, des textures de rendu et des peintures. Krita prend en charge plusieurs espaces de couleurs comme RVB et CMJN avec les canaux de 8 et 16 bits entiers ainsi que les canaux de 16 et 32 bits flottants.</p>
     <p xml:lang="gl">Krita é unha gran opción para crear arte conceptual, texturas para renderización e pinturas mate. Krita permite usar moitos espazos de cores como RGB e CMYK con canles de 8 e 16 bits, así como canles de coma flotante de 16 e 32 bits.</p>
     <p xml:lang="ia">Krita es un grande selection pro crear arte de concepto, comics, texturas pro rendering e picturas opac. Krita supporta multe spatios de colores como RGB e CMYK con canales de integer a  8 e 16 bits, como anque canales floating point a 16 e 32 bits.</p>
     <p xml:lang="id">Krita adalah pilihan yang cocok untuk menciptakan konsep seni, komik, tekstur untuk rendering dan lukisan matte. Krita mendukung banyak ruang warna seperti RGB dan CMYK pada channel integer 8 dan 16 bit, serta channel floating point 16 dan 32 bit.</p>
     <p xml:lang="it">Krita rappresenta una scelta ottimale per  la creazione di arte concettuale, fumetti e texture per il rendering e il matte painting. Krita supporta molti spazi colori come RGB e CMYK a 8 e 16 bit per canali interi e 16 e 32 bit per canali a virgola mobile.</p>
     <p xml:lang="ja">コンセプトアート、コミック、3DCG 用テクスチャ、マットペイントを制作する方にとって、Krita は最適な選択です。Krita は、8/16 ビット整数/チャンネル、および 16/32 ビット浮動小数点/チャンネルの RGB や CMYK をはじめ、さまざまな色空間をサポートしています。</p>
     <p xml:lang="ko">Krita는 컨셉 아트, 만화, 렌더링용 텍스처, 풍경화 등을 그릴 때 사용할 수 있는 완벽한 도구입니다. RGB, CMYK와 같은 여러 색 공간 및 8비트/16비트 정수 채널, 16비트/32비트 부동 소수점 채널을 지원합니다.</p>
     <p xml:lang="nl">Krita is een goede keuze voor het maken van kunstconcepten, strips, textuur voor weergeven en matte schilderijen. Krita ondersteunt vele kleurruimten zoals RGB en CMYK in 8 en 16 bits kanalen met gehele getallen, evenals 16 en 32 bits kanalen met drijvende komma.</p>
     <p xml:lang="nn">Krita er det ideelle valet dersom du vil laga konseptskisser, teikneseriar, teksturar for 3D-rendering eller «matte paintings». Programmet støttar fleire fargerom, både RGB- og CMYK-baserte, med 8- og 16-bits heiltals- eller flyttalskanalar.</p>
     <p xml:lang="pl">Krita jest świetnym wyborem przy tworzeniu koncepcyjnej sztuki, komiksów, tekstur do wyświetlania i kaszet. Krita obsługuje wiele przestrzeni barw takich jak RGB oraz CMYK dla kanałów 8 oraz 16 bitowych wyrażonych w l. całkowitych, a także  16 oraz 32 bitowych wyrażonych w l. zmiennoprzecinkowych.</p>
     <p xml:lang="pt">O Krita é uma óptima escolha para criar arte conceptual, banda desenhada, texturas para desenho e pinturas. O Krita suporta diversos espaços de cores como o RGB e o CMYK com canais de cores inteiros a 8 e 16 bits, assim como canais de vírgula flutuante a 16 e a 32 bits.</p>
     <p xml:lang="pt-BR">O Krita é uma ótima escolha para criação de arte conceitual, histórias em quadrinhos, texturas para desenhos e pinturas. O Krita tem suporte a diversos espaços de cores como RGB e CMYK com canais de cores inteiros de 8 e 16 bits, assim como canais de ponto flutuante de 16 e 32 bits.</p>
     <p xml:lang="ru">Krita — отличный выбор для создания концепт-артов, комиксов, текстур для рендеринга и рисования. Она поддерживает множество цветовых пространств включая RGB и CMYK с 8 и 16 целыми битами на канал, а также 16 и 32 битами с плавающей запятой на канал.</p>
     <p xml:lang="sk">Krita je výborná voľba pre vytváranie konceptového umenia, textúr na renderovanie a matné kresby. Krita podporuje mnoho farebných priestorov ako RGB a CMYK na 8 a 16 bitových celočíselných kanáloch ako aj 16 a 32 bitových reálnych kanáloch.</p>
     <p xml:lang="sv">Krita är ett utmärkt val för att skapa concept art, serier, strukturer för återgivning och bakgrundsmålningar. Krita stöder många färgrymder som RGB och CMYK med 8- och 16-bitars heltal, samt 16- och 32-bitars flyttal.</p>
     <p xml:lang="tr">Krita, konsept sanat, çizgi roman, kaplama ve mat resimler için dokular oluşturmak için mükemmel bir seçimdir. Krita, 8 ve 16 bit tamsayı kanallarında RGB ve CMYK gibi birçok renk alanını ve 16 ve 32 bit kayan nokta kanallarını desteklemektedir.</p>
     <p xml:lang="uk">Krita — чудовий інструмент для створення концептуального живопису, коміксів, текстур для моделей та декорацій. У Krita передбачено підтримку багатьох просторів кольорів, зокрема RGB та CMYK з 8-бітовими та 16-бітовими цілими значеннями, а також 16-бітовими та 32-бітовими значеннями з рухомою крапкою для каналів кольорів.</p>
     <p xml:lang="x-test">xxKrita is a great choice for creating concept art, comics, textures for rendering and matte paintings. Krita supports many colorspaces like RGB and CMYK at 8 and 16 bits integer channels, as well as 16 and 32 bits floating point channels.xx</p>
     <p xml:lang="zh-CN">Krita 是绘制概念美术、漫画、纹理和电影布景的理想选择。Krita 支持多种色彩空间，如 8 位和 16 位整数及 16 位和 32 位浮点的 RGB 和 CMYK 颜色模型。</p>
     <p xml:lang="zh-TW">Krita 是創造概念藝術、漫畫、彩現紋理和場景繪畫的絕佳選擇。Krita 在 8 位元和 16 位元整數色版，以及 16 位元和 32 位元浮點色板中支援 RGB 和 CMYK 等多種色彩空間。</p>
     <p>Have fun painting with the advanced brush engines, amazing filters and many handy features that make Krita enormously productive.</p>
     <p xml:lang="bs">Zabavite se kreirajući napredne pogone četki, filtere i mnoge praktične osobine koje čine Krita vrlo produktivnim.</p>
     <p xml:lang="ca">Gaudiu pintant amb els motors avançats de pinzells, filtres impressionants i moltes característiques útils que fan el Krita molt productiu.</p>
     <p xml:lang="ca-valencia">Gaudiu pintant amb els motors avançats de pinzells, filtres impressionants i moltes característiques útils que fan el Krita molt productiu.</p>
     <p xml:lang="el">Διασκεδάστε ζωγραφίζοντας με τις προηγμένες μηχανές πινέλων, με εκπληκτικά φίλτρα και πολλά εύκολης χρήσης χαρακτηριστικά που παρέχουν στο Krita εξαιρετικά αυξημένη παραγωγικότητα.</p>
     <p xml:lang="en-GB">Have fun painting with the advanced brush engines, amazing filters and many handy features that make Krita enormously productive.</p>
     <p xml:lang="es">Diviértase pintando con los avanzados motores de pinceles, los espectaculares filtros y muchas funcionalidades prácticas que hacen que Krita sea enormemente productivo.</p>
     <p xml:lang="et">Joonistamise muudavad tunduvalt lõbusamaks võimsad pintslimootorid, imetabased filtrid ja veel paljud käepärased võimalused, mis muudavad Krita kasutaja tohutult tootlikuks.</p>
     <p xml:lang="eu">Marrazten ondo pasa ezazu, isipu motor aurreratuekin, iragazki txundigarriekin eta eginbide praktiko ugariekin, zeintzuek Krita ikaragarri emankorra egiten duten.</p>
     <p xml:lang="fi">Pidä hauskaa maalatessasi edistyneillä sivellinmoottoreilla, hämmästyttävillä suotimilla ja monilla muilla kätevillä ominaisuuksilla, jotka tekevät Kritasta tavattoman tehokkaan.</p>
     <p xml:lang="fr">Amusez-vous à peindre avec les outils de brosse avancés, les filtres incroyables et les nombreuses fonctionnalités pratiques qui rendent Krita extrêmement productif.</p>
     <p xml:lang="gl">Goza debuxando con motores de pincel avanzados, filtros fantásticos e moitas outras funcionalidades útiles que fan de Krita un programa extremadamente produtivo.</p>
     <p xml:lang="ia">Amusa te a pinger con le motores de pincel avantiate, filtros stupende e multe characteristicas amical que face Krita enormemente productive.</p>
     <p xml:lang="id">Bersenang-senanglah melukis dengan mesin kuas canggih, filter luar biasa dan banyak fitur berguna yang membuat Krita sangat produktif.</p>
     <p xml:lang="it">Divertiti a dipingere con gli avanzati sistemi di pennelli, i sorprendenti filtri e molte altre utili caratteristiche che fanno di Krita un software enormemente produttivo.</p>
     <p xml:lang="ja">Krita のソフトウェアとしての生産性を高めている先進的なブラシエンジンや素晴らしいフィルタのほか、便利な機能の数々をお楽しみください。</p>
     <p xml:lang="ko">Krita의 고급 브러시 엔진, 다양한 필터, 여러 도움이 되는 기능으로 생산성을 즐겁게 향상시킬 수 있습니다.</p>
     <p xml:lang="nl">Veel plezier met schilderen met the geavanceerde penseel-engines, filters vol verbazing en vele handige mogelijkheden die maken dat Krita enorm productief is.</p>
     <p xml:lang="nn">Leik deg med avanserte penselmotorar og fantastiske biletfilter – og mange andre nyttige funksjonar som gjer deg produktiv med Krita.</p>
     <p xml:lang="pl">Baw się przy malowaniu przy użyciu zaawansowanych silników pędzli, zadziwiających filtrów i wielu innych przydatnych cech, które czynią z Krity bardzo produktywną.</p>
     <p xml:lang="pt">Divirta-se a pintar com os motores de pincéis avançados, os filtros espantosos e muitas outras funcionalidades úteis que tornam o Krita altamente produtivo.</p>
     <p xml:lang="pt-BR">Divirta-se pintando com os mecanismos de pincéis avançados, filtros maravilhosos e muitas outras funcionalidades úteis que tornam o Krita altamente produtivo.</p>
     <p xml:lang="ru">Получайте удовольствие от использования особых кистевых движков, впечатляющих фильтров и множества других функций, делающих Krita сверхпродуктивной.</p>
     <p xml:lang="sk">Užívajte si maľovanie s pokročilými kresliacimi enginmi, úžasnými filtrami a mnohými užitočnými funkciami, ktoré robia Kritu veľmi produktívnu.</p>
     <p xml:lang="sv">Ha det så kul vid målning med de avancerade penselfunktionerna, fantastiska filtren och många praktiska funktioner som gör Krita så enormt produktiv.</p>
     <p xml:lang="tr">Gelişmiş fırça motorları, şaşırtıcı filtreler ve Krita'yı son derece üretken yapan bir çok kullanışlı özellikli boya ile iyi eğlenceler.</p>
     <p xml:lang="uk">Отримуйте задоволення від малювання за допомогою пензлів з найширшими можливостями, чудових фільтрів та багатьох зручних можливостей, які роблять Krita надзвичайно продуктивним засобом малювання.</p>
     <p xml:lang="x-test">xxHave fun painting with the advanced brush engines, amazing filters and many handy features that make Krita enormously productive.xx</p>
     <p xml:lang="zh-CN">Krita 具有功能强大的笔刷引擎、种类繁多的滤镜以及便于操作的交互设计，可让你尽情、高效地挥洒无限创意。</p>
     <p xml:lang="zh-TW">使用先進的筆刷引擎、驚人的濾鏡和許多方便的功能來開心地繪畫，讓 Krita 擁有巨大的生產力。</p>
   </description>
   <url type="homepage">https://www.krita.org/</url>
   <url type="faq">https://docs.krita.org/KritaFAQ.html</url>
   <url type="donation">https://krita.org/support-us/donations/</url>
   <url type="help">https://docs.krita.org/</url>
   <url type="bugtracker">https://docs.krita.org/en/untranslatable_pages/reporting_bugs.html</url>
   <screenshots>
     <screenshot type="default">
       <caption>Krita is a full-featured digital painting studio.</caption>
       <caption xml:lang="ca">Krita és un estudi de pintura digital ple de funcionalitats.</caption>
       <caption xml:lang="ca-valencia">Krita és un estudi de pintura digital ple de funcionalitats.</caption>
+      <caption xml:lang="de">Krita ist ein digitales Zeichenstudio mit umfangreichen Funktionen.</caption>
+      <caption xml:lang="en-GB">Krita is a full-featured digital painting studio.</caption>
       <caption xml:lang="es">Krita es un completo estudio de dibujo digital.</caption>
+      <caption xml:lang="gl">Krita é un estudio completo de debuxo dixital.</caption>
       <caption xml:lang="id">Krita adalah studio pelukisan digital dengan fitur yang lengkap.</caption>
       <caption xml:lang="it">Krita è uno studio d'arte digitale completo.</caption>
       <caption xml:lang="ko">Krita는 다기능 디지털 예술 스튜디오입니다.</caption>
       <caption xml:lang="nl">Krita is een digitale schilderstudio vol mogelijkheden.</caption>
       <caption xml:lang="nn">Krita er ei funksjonsrik digital teiknestove.</caption>
       <caption xml:lang="pl">Krita jest pełnowymiarowym, cyfrowym studiem artystycznym.</caption>
       <caption xml:lang="pt">O Krita é um estúdio de arte digital completo.</caption>
       <caption xml:lang="pt-BR">O Krita é um estúdio de pintura digital completo.</caption>
+      <caption xml:lang="sk">Krita je plnohodnotné digitálne maliarske štúdio.</caption>
       <caption xml:lang="sv">Krita är en fullfjädrad digital konststudio.</caption>
       <caption xml:lang="uk">Krita — повноцінний комплекс для цифрового малювання.</caption>
       <caption xml:lang="x-test">xxKrita is a full-featured digital painting studio.xx</caption>
       <caption xml:lang="zh-CN">Krita 是一款功能齐全的数字绘画工作室软件。</caption>
       <caption xml:lang="zh-TW">Krita 是全功能的數位繪圖工作室。</caption>
       <image>https://cdn.kde.org/screenshots/krita/2018-03-17_screenshot_001.png</image>
     </screenshot>
     <screenshot type="default">
       <caption>The startup window now also gives you the latest news about Krita.</caption>
       <caption xml:lang="ca">La finestra d'inici ara proporciona les darreres noticies quant al Krita.</caption>
       <caption xml:lang="ca-valencia">La finestra d'inici ara proporciona les darreres noticies quant al Krita.</caption>
+      <caption xml:lang="en-GB">The startup window now also gives you the latest news about Krita.</caption>
       <caption xml:lang="es">La ventana de bienvenida también le proporciona ahora las últimas noticias sobre Krita.</caption>
-      <caption xml:lang="id">Window pemulaian kini juga memberikan kamu kabar terbaru tentang Krita.</caption>
+      <caption xml:lang="gl">Agora a xanela de inicio tamén fornece as últimas novas sobre Krita.</caption>
+      <caption xml:lang="id">Window pemulaian kini juga memberikan kamu kabar terkini tentang Krita.</caption>
       <caption xml:lang="it">La finestra di avvio ora fornisce anche le ultime novità su Krita.</caption>
       <caption xml:lang="ko">시작 창에서 Krita의 최신 소식을 볼 수 있습니다.</caption>
       <caption xml:lang="nl">Het opstartvenster geeft u nu ook you het laatste nieuws over Krita.</caption>
       <caption xml:lang="nn">Oppstartsvindauget viser no siste nytt om Krita.</caption>
       <caption xml:lang="pl">Okno początkowe teraz wyświetla wieści o Kricie.</caption>
       <caption xml:lang="pt">A janela inicial agora também lhe dá as últimas notícias sobre o Krita.</caption>
+      <caption xml:lang="sk">V úvodnom okne sa tiež nachádzajú najnovšie správy o Krita.</caption>
       <caption xml:lang="sv">Startfönstret ger nu också senaste nytt om Krita.</caption>
       <caption xml:lang="uk">У початковому вікні програми ви можете бачити найсвіжіші новини щодо Krita.</caption>
       <caption xml:lang="x-test">xxThe startup window now also gives you the latest news about Krita.xx</caption>
       <caption xml:lang="zh-CN">启动画面现在可以为你呈现与 Krita 有关的最新资讯。</caption>
       <caption xml:lang="zh-TW">開始視窗也提供給您關於 Krita 的最新消息。</caption>
       <image>https://cdn.kde.org/screenshots/krita/2018-03-17_screenshot_002.png</image>
     </screenshot>
     <screenshot type="default">
       <caption>There are over ten immensely powerful brush engines.</caption>
       <caption xml:lang="ca">Hi ha uns deu motors de pinzell immensament potents.</caption>
       <caption xml:lang="ca-valencia">Hi ha uns deu motors de pinzell immensament potents.</caption>
+      <caption xml:lang="en-GB">There are over ten immensely powerful brush engines.</caption>
       <caption xml:lang="es">Existen unos diez inmensamente potentes motores de pinceles.</caption>
+      <caption xml:lang="gl">Hai máis de dez motores de pinceis inmensamente potentes.</caption>
       <caption xml:lang="id">Ada lebih dari sepuluh mesin kuas yang sangat manjur.</caption>
       <caption xml:lang="it">Ci sono oltre dieci motori di pennelli incredibilmente potenti.</caption>
       <caption xml:lang="ko">10가지 종류의 강력한 브러시 엔진을 사용할 수 있습니다.</caption>
       <caption xml:lang="nl">Er zijn meer dan tien immens krachtige penseelengines.</caption>
       <caption xml:lang="nn">Det finst meir enn ti enormt kraftige penselmotorar.</caption>
       <caption xml:lang="pl">Istnieje ponad dziesięć zaawansowanych silników pędzli.</caption>
       <caption xml:lang="pt">Existem mais de dez motores de pincéis extremamente poderosos.</caption>
+      <caption xml:lang="sk">Existuje viac ako desať nesmierne výkonných štetcových enginov.</caption>
       <caption xml:lang="sv">Det finns mer än tio enormt kraftfulla penselgränssnitt.</caption>
       <caption xml:lang="uk">У програмі передбачено понад десяток надзвичайно потужних рушіїв пензлів.</caption>
       <caption xml:lang="x-test">xxThere are over ten immensely powerful brush engines.xx</caption>
       <caption xml:lang="zh-CN">它具备超过十种相当强大的笔刷引擎。</caption>
       <image>https://cdn.kde.org/screenshots/krita/2018-03-17_screenshot_003.png</image>
     </screenshot>
     <screenshot type="default">
       <caption>Create and use gamut masks to give your images a coherent feel.</caption>
       <caption xml:lang="ca">Creeu i useu màscares de gamma per donar a les imatges una aparença coherent.</caption>
       <caption xml:lang="ca-valencia">Creeu i useu màscares de gamma per donar a les imatges una aparença coherent.</caption>
+      <caption xml:lang="en-GB">Create and use gamut masks to give your images a coherent feel.</caption>
       <caption xml:lang="es">Cree y use gamas para proporcionar a sus imágenes un aspecto coherente.</caption>
+      <caption xml:lang="gl">Crea e usa máscaras de gama para dar ás túas imaxes un aspecto coherente.</caption>
       <caption xml:lang="id">Ciptakan dan gunakan masker gamut untuk memberikan gambarmu sebuah suasana koheren.</caption>
       <caption xml:lang="it">Crea e utilizza maschere gamut per dare alle tue immagini un aspetto coerente.</caption>
       <caption xml:lang="ko">색역 마스크를 만들고 사용할 수 있습니다.</caption>
       <caption xml:lang="nl">Maak en gebruik gamut-maskers om uw afbeeldingen een coherent gevoel te geven.</caption>
       <caption xml:lang="nn">Bruk fargeområde-masker for å gje bileta eit heilsleg uttrykk.</caption>
       <caption xml:lang="pl">Stwórz i używaj masek gamut, aby nadać swoim obrazom spójny wygląd.</caption>
       <caption xml:lang="pt">Crie e use máscaras de gamute para dar às suas imagens uma aparência coerente.</caption>
+      <caption xml:lang="sk">Vytvorte a používajte gamutové masky, aby vašim obrázkom poskytli ucelený pocit.</caption>
       <caption xml:lang="sv">Att skapa och använda färgomfångsmasker ger bilder en sammanhängande känsla.</caption>
       <caption xml:lang="uk">Створюйте маски палітри і користуйтеся ними для надання вашим малюнкам однорідного вигляду.</caption>
       <caption xml:lang="x-test">xxCreate and use gamut masks to give your images a coherent feel.xx</caption>
       <caption xml:lang="zh-CN">创建并使用色域蒙版可以为你的图像带来更加一致的观感。</caption>
       <image>https://cdn.kde.org/screenshots/krita/2018-03-17_screenshot_004.png</image>
     </screenshot>
     <screenshot type="default">
       <caption>Into animation? Krita provides everything you need for traditional, hand-drawn animation.</caption>
       <caption xml:lang="ca">Esteu amb animacions? El Krita proporciona tol el que cal per a l'animació a mà tradicional.</caption>
       <caption xml:lang="ca-valencia">Esteu amb animacions? El Krita proporciona tol el que cal per a l'animació a mà tradicional.</caption>
+      <caption xml:lang="en-GB">Into animation? Krita provides everything you need for traditional, hand-drawn animation.</caption>
       <caption xml:lang="es">¿Trabaja con animación? Krita proporciona todo lo necesario para la animación manual tradicional.</caption>
+      <caption xml:lang="gl">Gusta das animacións? Krita fornece todo o necesario para animacións tradicionais debuxadas a man.</caption>
       <caption xml:lang="id">Soal animasi? krita menyediakan apa pun yang kamu perlukan untuk animasi gambar-tangan, tradisional.</caption>
       <caption xml:lang="it">Per le animazioni? Krita fornisce tutto ciò che ti server per l'animazione tradizionale, disegnata a mano.</caption>
       <caption xml:lang="ko">애니메이션을 만들 계획이 있으신가요? Krita를 통해서 수작업 애니메이션을 작업할 수 있습니다.</caption>
       <caption xml:lang="nl">Naar animatie? Krita biedt alles wat u nodig hebt voor traditionele, met de hand getekende animatie.</caption>
       <caption xml:lang="nn">Interessert i animasjon? Krita har alt du treng for tradisjonelle, handteikna animasjonar.</caption>
       <caption xml:lang="pl">Zajmujesz się animacjami? Krita zapewnia wszystko czego potrzebujesz do tworzenia tradycyjnych, ręcznie rysowanych animacji.</caption>
       <caption xml:lang="pt">Gosta de animação? O Krita oferece tudo o que precisa para o desenho animado tradicional e desenhado à mão.</caption>
+      <caption xml:lang="sk">Ste do animácie? Krita poskytuje všetko, čo potrebujete pre tradičné ručne kreslené animácie.</caption>
       <caption xml:lang="sv">Gillar du animering? Krita tillhandahåller allt som behövs för traditionella, handritade animeringar.</caption>
       <caption xml:lang="uk">Працюєте із анімацією? У Krita ви знайдете усе, що потрібно для створення традиційної, намальованої вручну анімації.</caption>
       <caption xml:lang="x-test">xxInto animation? Krita provides everything you need for traditional, hand-drawn animation.xx</caption>
       <caption xml:lang="zh-CN">喜欢制作动画吗？Krita 提供了制作传统手绘动画的全套工具。</caption>
       <caption xml:lang="zh-TW">想做動畫？Krita 提供您在傳統、手繪動畫所需的任何東西。</caption>
       <image>https://cdn.kde.org/screenshots/krita/2018-03-17_screenshot_005.png</image>
     </screenshot>
     <screenshot type="default">
       <caption>If you're new to digital painting, or want to know more about Krita's possibilities, there's an extensive, up-to-date manual.</caption>
       <caption xml:lang="ca">Si sou nou a la pintura digital, o voleu conèixer més quant a les possibilitats del Krita, hi ha un ampli manual actualitzat.</caption>
       <caption xml:lang="ca-valencia">Si sou nou a la pintura digital, o voleu conèixer més quant a les possibilitats del Krita, hi ha un ampli manual actualitzat.</caption>
+      <caption xml:lang="en-GB">If you're new to digital painting, or want to know more about Krita's possibilities, there's an extensive, up-to-date manual.</caption>
       <caption xml:lang="es">Si está empezando con el dibujo digital o si quiere saber más sobre la posibilidades de Krita, dispone de un extenso y actualizado manual.</caption>
+      <caption xml:lang="gl">Se está a empezar co debuxo dixital, ou quere saber máis sobre as posibilidades de Krita, existe un manual exhaustivo e actualizado.</caption>
       <caption xml:lang="id">Jika kamu baru dalam pelukisan digital, atau ingin mengetahui selebihnya tentang Krita, di situ ada manual yang update dan luas.</caption>
       <caption xml:lang="it">Se sei nuovo del disegno digitale, o vuoi saperne di più sulle possibilità di Krita, è disponibile un manuale completo e aggiornato.</caption>
       <caption xml:lang="ko">디지털 페인팅을 처음 시작하시거나, Krita의 기능을 더 알아 보려면 사용 설명서를 참조하십시오.</caption>
       <caption xml:lang="nl">Als u nieuw bent in digitaal schilderen of u wilt meer weten over de mogelijkheden van Krita, dan is er een uitgebreide, bijgewerkte handleiding.</caption>
       <caption xml:lang="nn">Viss du er nybegynnar innan digital teikning, eller ønskjer å veta meir om kva som er mogleg med Krita, finst det ei omfattande og oppdatert brukarhandbok.</caption>
       <caption xml:lang="pl">Jeśli cyfrowe malowanie to dla ciebie nowość, lub jeśli chcesz dowiedzieć się więcej o możliwościach Krity, to dostępny jest wyczerpująca i aktualna instrukcja obsługi.</caption>
       <caption xml:lang="pt">Se é novo na pintura digital, ou deseja saber mais sobre as possibilidades do Krita, existe um manual extenso e actualizado.</caption>
+      <caption xml:lang="sk">Ak ste v oblasti digitálnej maľby nováčikom alebo sa chcete dozvedieť viac o možnostiach programu Krita, existuje o tom rozsiahla a aktuálna príručka.</caption>
       <caption xml:lang="sv">Om digital målning är nytt för dig, eller om du vill veta mer om Kritas möjligheter, finns en omfattande, aktuell handbok.</caption>
       <caption xml:lang="uk">Якщо ви не маєте достатнього досвіду у цифровому малюванні або хочете дізнатися більше про можливості Krita, скористайтеся нашим докладним і актуальним підручником.</caption>
       <caption xml:lang="x-test">xxIf you're new to digital painting, or want to know more about Krita's possibilities, there's an extensive, up-to-date manual.xx</caption>
       <caption xml:lang="zh-CN">不管你是数字绘画的新手，还是想发现 Krita 更多的用法，你都可以在我们详尽并持续更新的使用手册中找到答案。</caption>
       <image>https://cdn.kde.org/screenshots/krita/2018-03-17_screenshot_006.png</image>
     </screenshot>
   </screenshots>
   <categories>
     <category>Graphics</category>
     <category>2DGraphics</category>
     <category>RasterGraphics</category>
   </categories>
   <project_group>KDE</project_group>
   <provides>
     <binary>krita</binary>
     <id>org.kde.krita.desktop</id>
   </provides>
   <content_rating type="oars-1.1"/>
   <releases>
     <release date="2019-05-29" version="4.3.0.0"/>
   </releases>
 </component>
diff --git a/krita/org.kde.krita.desktop b/krita/org.kde.krita.desktop
index ae6dbfec3d..c9ce012651 100644
--- a/krita/org.kde.krita.desktop
+++ b/krita/org.kde.krita.desktop
@@ -1,159 +1,159 @@
 [Desktop Entry]
 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
 Exec=krita %F
 GenericName=Digital Painting
 GenericName[ar]=رسم رقمي
 GenericName[bs]=Digitalno Bojenje
 GenericName[ca]=Dibuix digital
 GenericName[ca@valencia]=Dibuix digital
 GenericName[cs]=Digitální malování
 GenericName[da]=Digital tegning
 GenericName[de]=Digitales Malen
 GenericName[el]=Ψηφιακή ζωγραφική
 GenericName[en_GB]=Digital Painting
 GenericName[es]=Pintura digital
 GenericName[et]=Digitaalne joonistamine
 GenericName[eu]=Margolan digitala
 GenericName[fi]=Digitaalimaalaus
 GenericName[fr]=Peinture numérique
 GenericName[gl]=Debuxo dixital
 GenericName[hu]=Digitális festészet
 GenericName[ia]=Pintura Digital
 GenericName[is]=Stafræn málun
 GenericName[it]=Pittura digitale
 GenericName[ja]=デジタルペインティング
 GenericName[kk]=Цифрлық сурет салу
 GenericName[ko]=디지털 페인팅
 GenericName[lt]=Skaitmeninis piešimas
 GenericName[mr]=डिजिटल पेंटिंग
 GenericName[nb]=Digital maling
 GenericName[nl]=Digitaal schilderen
 GenericName[nn]=Digital teikning
 GenericName[pl]=Cyfrowe malowanie
 GenericName[pt]=Pintura Digital
 GenericName[pt_BR]=Pintura digital
 GenericName[ru]=Цифровая живопись
 GenericName[sk]=Digitálne maľovanie
 GenericName[sl]=Digitalno slikanje
 GenericName[sv]=Digital målning
 GenericName[tr]=Sayısal Boyama
 GenericName[ug]=سىفىرلىق رەسىم سىزغۇ
 GenericName[uk]=Цифрове малювання
 GenericName[x-test]=xxDigital Paintingxx
 GenericName[zh_CN]=数字绘画
 GenericName[zh_TW]=數位繪畫
 MimeType=application/x-krita;image/openraster;application/x-krita-paintoppreset;
 Comment=Digital Painting
 Comment[ar]=رسم رقمي
 Comment[bs]=Digitalno Bojenje
 Comment[ca]=Dibuix digital
 Comment[ca@valencia]=Dibuix digital
 Comment[cs]=Digitální malování
 Comment[da]=Digital tegning
 Comment[de]=Digitales Malen
 Comment[el]=Ψηφιακή ζωγραφική
 Comment[en_GB]=Digital Painting
 Comment[es]=Pintura digital
 Comment[et]=Digitaalne joonistamine
 Comment[eu]=Margolan digitala
 Comment[fi]=Digitaalimaalaus
 Comment[fr]=Peinture numérique
 Comment[gl]=Debuxo dixital.
 Comment[hu]=Digitális festészet
 Comment[ia]=Pintura Digital
 Comment[is]=Stafræn málun
 Comment[it]=Pittura digitale
 Comment[ja]=デジタルペインティング
 Comment[kk]=Цифрлық сурет салу
 Comment[ko]=디지털 페인팅
 Comment[lt]=Skaitmeninis piešimas
 Comment[mr]=डिजिटल पेंटिंग
 Comment[nb]=Digital maling
 Comment[nl]=Digitaal schilderen
 Comment[nn]=Digital teikning
 Comment[pl]=Cyfrowe malowanie
 Comment[pt]=Pintura Digital
 Comment[pt_BR]=Pintura digital
 Comment[ru]=Цифровая живопись
 Comment[sk]=Digitálne maľovanie
 Comment[sl]=Digitalno slikanje
 Comment[sv]=Digitalt målningsverktyg
 Comment[tr]=Sayısal Boyama
 Comment[ug]=سىفىرلىق رەسىم سىزغۇ
 Comment[uk]=Цифрове малювання
 Comment[x-test]=xxDigital Paintingxx
 Comment[zh_CN]=数字绘画
 Comment[zh_TW]=數位繪畫
 Type=Application
-Icon=calligrakrita
+Icon=krita
 Categories=Qt;KDE;Graphics;2DGraphics;RasterGraphics;
 X-KDE-NativeMimeType=application/x-krita
 X-KDE-ExtraNativeMimeTypes=
 StartupNotify=true
 X-Krita-Version=28
 StartupWMClass=krita
 # Always be the preferred handler for .kra files
 InitialPreference=99
diff --git a/krita/pics/app/1024-apps-calligrakrita.png b/krita/pics/app/1024-apps-krita.png
similarity index 100%
rename from krita/pics/app/1024-apps-calligrakrita.png
rename to krita/pics/app/1024-apps-krita.png
diff --git a/krita/pics/app/128-apps-calligrakrita.png b/krita/pics/app/128-apps-krita.png
similarity index 100%
rename from krita/pics/app/128-apps-calligrakrita.png
rename to krita/pics/app/128-apps-krita.png
diff --git a/krita/pics/app/16-apps-calligrakrita.png b/krita/pics/app/16-apps-krita.png
similarity index 100%
rename from krita/pics/app/16-apps-calligrakrita.png
rename to krita/pics/app/16-apps-krita.png
diff --git a/krita/pics/app/22-apps-calligrakrita.png b/krita/pics/app/22-apps-krita.png
similarity index 100%
rename from krita/pics/app/22-apps-calligrakrita.png
rename to krita/pics/app/22-apps-krita.png
diff --git a/krita/pics/app/256-apps-calligrakrita.png b/krita/pics/app/256-apps-krita.png
similarity index 100%
rename from krita/pics/app/256-apps-calligrakrita.png
rename to krita/pics/app/256-apps-krita.png
diff --git a/krita/pics/app/32-apps-calligrakrita.png b/krita/pics/app/32-apps-krita.png
similarity index 100%
rename from krita/pics/app/32-apps-calligrakrita.png
rename to krita/pics/app/32-apps-krita.png
diff --git a/krita/pics/app/48-apps-calligrakrita.png b/krita/pics/app/48-apps-krita.png
similarity index 100%
rename from krita/pics/app/48-apps-calligrakrita.png
rename to krita/pics/app/48-apps-krita.png
diff --git a/krita/pics/app/512-apps-calligrakrita.png b/krita/pics/app/512-apps-krita.png
similarity index 100%
rename from krita/pics/app/512-apps-calligrakrita.png
rename to krita/pics/app/512-apps-krita.png
diff --git a/krita/pics/app/64-apps-calligrakrita.png b/krita/pics/app/64-apps-krita.png
similarity index 100%
rename from krita/pics/app/64-apps-calligrakrita.png
rename to krita/pics/app/64-apps-krita.png
diff --git a/krita/pics/app/CMakeLists.txt b/krita/pics/app/CMakeLists.txt
index 7d0de0086e..10d95ebb78 100644
--- a/krita/pics/app/CMakeLists.txt
+++ b/krita/pics/app/CMakeLists.txt
@@ -1,14 +1,14 @@
 ecm_install_icons(
 ICONS
-1024-apps-calligrakrita.png                                                                          
-128-apps-calligrakrita.png                                                                           
-16-apps-calligrakrita.png                                                                            
-22-apps-calligrakrita.png                                                                            
-256-apps-calligrakrita.png                                                                           
-32-apps-calligrakrita.png                                                                            
-48-apps-calligrakrita.png                                                                            
-512-apps-calligrakrita.png                                                                           
-64-apps-calligrakrita.png
-sc-apps-calligrakrita.svgz
+1024-apps-krita.png                                                                          
+128-apps-krita.png                                                                           
+16-apps-krita.png                                                                            
+22-apps-krita.png                                                                            
+256-apps-krita.png                                                                           
+32-apps-krita.png                                                                            
+48-apps-krita.png                                                                            
+512-apps-krita.png                                                                           
+64-apps-krita.png
+sc-apps-krita.svgz
 DESTINATION
  ${ICON_INSTALL_DIR} )
diff --git a/krita/pics/app/sc-apps-calligrakrita.svgz b/krita/pics/app/sc-apps-krita.svgz
similarity index 100%
rename from krita/pics/app/sc-apps-calligrakrita.svgz
rename to krita/pics/app/sc-apps-krita.svgz
diff --git a/libs/flake/KoCanvasControllerWidget.cpp b/libs/flake/KoCanvasControllerWidget.cpp
index 3cda255127..42ada26175 100644
--- a/libs/flake/KoCanvasControllerWidget.cpp
+++ b/libs/flake/KoCanvasControllerWidget.cpp
@@ -1,626 +1,615 @@
 /* This file is part of the KDE project
  *
  * Copyright (C) 2006, 2008-2009 Thomas Zander <zander@kde.org>
  * Copyright (C) 2006 Peter Simonsson <peter.simonsson@gmail.com>
  * Copyright (C) 2006, 2009 Thorsten Zachmann <zachmann@kde.org>
  * Copyright (C) 2007-2010 Boudewijn Rempt <boud@valdyas.org>
  * Copyright (C) 2007 C. Boemann <cbo@boemann.dk>
  * Copyright (C) 2006-2008 Jan Hambrecht <jaham@gmx.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "KoCanvasControllerWidget.h"
 #include "KoCanvasControllerWidget_p.h"
 
 #include "KoCanvasControllerWidgetViewport_p.h"
 #include "KoShape.h"
 #include "KoViewConverter.h"
 #include "KoCanvasBase.h"
 #include "KoCanvasObserverBase.h"
 #include "KoCanvasSupervisor.h"
 #include "KoToolManager_p.h"
 
 #include <FlakeDebug.h>
 #include <QMouseEvent>
 #include <QPainter>
 #include <QScrollBar>
 #include <QEvent>
 #include <QDockWidget>
 #include <QTimer>
 #include <QPointer>
 
 #include <QOpenGLWidget>
 
 #include <math.h>
 
 void KoCanvasControllerWidget::Private::setDocumentOffset()
 {
     // The margins scroll the canvas widget inside the viewport, not
     // the document. The documentOffset is meant to be the value that
     // the canvas must add to the update rect in its paint event, to
     // compensate.
 
     QPoint pt(q->horizontalScrollBar()->value(), q->verticalScrollBar()->value());
     q->proxyObject->emitMoveDocumentOffset(pt);
 
     QWidget *canvasWidget = canvas->canvasWidget();
 
     if (canvasWidget) {
         // If it isn't an OpenGL canvas
         if (qobject_cast<QOpenGLWidget*>(canvasWidget) == 0) {
             QPoint diff = q->documentOffset() - pt;
             canvasWidget->scroll(diff.x(), diff.y(), canvasWidget->rect());
         }
     }
 
     q->setDocumentOffset(pt);
 }
 
 void KoCanvasControllerWidget::Private::resetScrollBars()
 {
     // The scrollbar value always points at the top-left corner of the
     // bit of image we paint.
 
     int docH = (int)q->documentSize().height() + q->margin();
     int docW = (int)q->documentSize().width() + q->margin();
     int drawH = viewportWidget->height();
     int drawW = viewportWidget->width();
 
     QScrollBar *hScroll = q->horizontalScrollBar();
     QScrollBar *vScroll = q->verticalScrollBar();
 
     int horizontalReserve = vastScrollingFactor * drawW;
     int verticalReserve = vastScrollingFactor * drawH;
 
     int xMin = -horizontalReserve;
     int yMin = -verticalReserve;
 
     int xMax = docW - drawW + horizontalReserve;
     int yMax = docH - drawH + verticalReserve;
 
     hScroll->setRange(xMin, xMax);
     vScroll->setRange(yMin, yMax);
 
     int fontheight = QFontMetrics(q->font()).height();
 
     vScroll->setPageStep(drawH);
     vScroll->setSingleStep(fontheight);
     hScroll->setPageStep(drawW);
     hScroll->setSingleStep(fontheight);
 
 }
 
 void KoCanvasControllerWidget::Private::emitPointerPositionChangedSignals(QEvent *event)
 {
     if (!canvas) return;
     if (!canvas->viewConverter()) return;
 
     QPoint pointerPos;
     QMouseEvent *mouseEvent = dynamic_cast<QMouseEvent*>(event);
     if (mouseEvent) {
         pointerPos = mouseEvent->pos();
     } else {
         QTabletEvent *tabletEvent = dynamic_cast<QTabletEvent*>(event);
         if (tabletEvent) {
             pointerPos = tabletEvent->pos();
         }
     }
 
     QPoint pixelPos = (pointerPos - canvas->documentOrigin()) + q->documentOffset();
     QPointF documentPos = canvas->viewConverter()->viewToDocument(pixelPos);
 
     q->proxyObject->emitDocumentMousePositionChanged(documentPos);
     q->proxyObject->emitCanvasMousePositionChanged(pointerPos);
 }
 
 
 #include <QTime>
 
 void KoCanvasControllerWidget::Private::activate()
 {
-    QWidget *parent = q;
-    while (parent->parentWidget()) {
-        parent = parent->parentWidget();
-    }
-    KoCanvasSupervisor *observerProvider = dynamic_cast<KoCanvasSupervisor*>(parent);
     if (!observerProvider) {
         return;
     }
-
     KoCanvasBase *canvas = q->canvas();
     Q_FOREACH (KoCanvasObserverBase *docker, observerProvider->canvasObservers()) {
         KoCanvasObserverBase *observer = dynamic_cast<KoCanvasObserverBase*>(docker);
         if (observer) {
             observer->setObservedCanvas(canvas);
         }
     }
 
 }
 
 void KoCanvasControllerWidget::Private::unsetCanvas()
 {
-    QWidget *parent = q;
-    while (parent->parentWidget()) {
-        parent = parent->parentWidget();
-    }
-    KoCanvasSupervisor *observerProvider = dynamic_cast<KoCanvasSupervisor*>(parent);
     if (!observerProvider) {
         return;
     }
     Q_FOREACH (KoCanvasObserverBase *docker, observerProvider->canvasObservers()) {
         KoCanvasObserverBase *observer = dynamic_cast<KoCanvasObserverBase*>(docker);
        if (observer) {
             if (observer->observedCanvas() == q->canvas()) {
                 observer->unsetObservedCanvas();
             }
         }
     }
 }
 
 ////////////
-KoCanvasControllerWidget::KoCanvasControllerWidget(KActionCollection * actionCollection, QWidget *parent)
+KoCanvasControllerWidget::KoCanvasControllerWidget(KActionCollection * actionCollection, KoCanvasSupervisor *observerProvider, QWidget *parent)
     : QAbstractScrollArea(parent)
     , KoCanvasController(actionCollection)
-    , d(new Private(this))
+    , d(new Private(this, observerProvider))
 {
     // We need to set this as QDeclarativeView sets them a bit different from QAbstractScrollArea
     setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
 
     // And then our own Viewport
     d->viewportWidget = new Viewport(this);
     setViewport(d->viewportWidget);
     d->viewportWidget->setFocusPolicy(Qt::NoFocus);
     setFocusPolicy(Qt::NoFocus);
     setFrameStyle(0);
 
     //setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
     setAutoFillBackground(false);
     /*
       Fixes:   apps starting at zero zoom.
       Details: Since the document is set on the mainwindow before loading commences the inial show/layout can choose
           to set the document to be very small, even to be zero pixels tall.  Setting a sane minimum size on the
           widget means we no longer get rounding errors in zooming and we no longer end up with zero-zoom.
       Note: KoPage apps should probably startup with a sane document size; for Krita that's impossible
      */
     setMinimumSize(QSize(50, 50));
     setMouseTracking(true);
 
     connect(horizontalScrollBar(), SIGNAL(valueChanged(int)), this, SLOT(updateCanvasOffsetX()));
     connect(verticalScrollBar(), SIGNAL(valueChanged(int)), this, SLOT(updateCanvasOffsetY()));
     connect(d->viewportWidget, SIGNAL(sizeChanged()), this, SLOT(updateCanvasOffsetX()));
     connect(proxyObject, SIGNAL(moveDocumentOffset(QPoint)), d->viewportWidget, SLOT(documentOffsetMoved(QPoint)));
 }
 
 KoCanvasControllerWidget::~KoCanvasControllerWidget()
 {
     delete d;
 }
 
 void KoCanvasControllerWidget::activate()
 {
     d->activate();
 }
 
 void KoCanvasControllerWidget::scrollContentsBy(int dx, int dy)
 {
     Q_UNUSED(dx);
     Q_UNUSED(dy);
     d->setDocumentOffset();
 }
 
 QSizeF KoCanvasControllerWidget::viewportSize() const
 {
     // Calculate viewport size aligned to device pixels to match KisOpenGLCanvas2.
     qreal dpr = viewport()->devicePixelRatioF();
     int viewportWidth = static_cast<int>(viewport()->width() * dpr);
     int viewportHeight = static_cast<int>(viewport()->height() * dpr);
     return QSizeF(viewportWidth / dpr, viewportHeight / dpr);
 }
 
 void KoCanvasControllerWidget::resizeEvent(QResizeEvent *resizeEvent)
 {
     proxyObject->emitSizeChanged(resizeEvent->size());
 
     // XXX: When resizing, keep the area we're looking at now in the
     // center of the resized view.
     resetScrollBars();
     d->setDocumentOffset();
 }
 
 void KoCanvasControllerWidget::setCanvas(KoCanvasBase *canvas)
 {
     if (d->canvas) {
         d->unsetCanvas();
         proxyObject->emitCanvasRemoved(this);
         d->canvas->setCanvasController(0);
         d->canvas->canvasWidget()->removeEventFilter(this);
     }
 
     d->canvas = canvas;
 
     if (d->canvas) {
         d->canvas->setCanvasController(this);
         changeCanvasWidget(d->canvas->canvasWidget());
 
         proxyObject->emitCanvasSet(this);
         QTimer::singleShot(0, this, SLOT(activate()));
 
         setPreferredCenterFractionX(0);
         setPreferredCenterFractionY(0);
     }
 }
 
 KoCanvasBase* KoCanvasControllerWidget::canvas() const
 {
     if (d->canvas.isNull()) return 0;
     return d->canvas;
 }
 
 void KoCanvasControllerWidget::changeCanvasWidget(QWidget *widget)
 {
     if (d->viewportWidget->canvas()) {
         widget->setCursor(d->viewportWidget->canvas()->cursor());
         d->viewportWidget->canvas()->removeEventFilter(this);
     }
 
     d->viewportWidget->setCanvas(widget);
     setFocusProxy(d->canvas->canvasWidget());
 }
 
 int KoCanvasControllerWidget::visibleHeight() const
 {
     if (d->canvas == 0)
         return 0;
     QWidget *canvasWidget = canvas()->canvasWidget();
 
     int height1;
     if (canvasWidget == 0)
         height1 = viewport()->height();
     else
         height1 = qMin(viewport()->height(), canvasWidget->height());
     int height2 = height();
     return qMin(height1, height2);
 }
 
 int KoCanvasControllerWidget::visibleWidth() const
 {
     if (d->canvas == 0)
         return 0;
     QWidget *canvasWidget = canvas()->canvasWidget();
 
     int width1;
     if (canvasWidget == 0)
         width1 = viewport()->width();
     else
         width1 = qMin(viewport()->width(), canvasWidget->width());
     int width2 = width();
     return qMin(width1, width2);
 }
 
 int KoCanvasControllerWidget::canvasOffsetX() const
 {
     int offset = -horizontalScrollBar()->value();
 
     if (d->canvas) {
         offset += d->canvas->canvasWidget()->x() + frameWidth();
     }
 
     return offset;
 }
 
 int KoCanvasControllerWidget::canvasOffsetY() const
 {
     int offset = -verticalScrollBar()->value();
 
     if (d->canvas) {
         offset += d->canvas->canvasWidget()->y() + frameWidth();
     }
 
     return offset;
 }
 
 void KoCanvasControllerWidget::updateCanvasOffsetX()
 {
     proxyObject->emitCanvasOffsetXChanged(canvasOffsetX());
     if (d->ignoreScrollSignals)
         return;
 
     setPreferredCenterFractionX((horizontalScrollBar()->value()
                                  + viewport()->width() / 2.0) / documentSize().width());
 }
 
 void KoCanvasControllerWidget::updateCanvasOffsetY()
 {
     proxyObject->emitCanvasOffsetYChanged(canvasOffsetY());
     if (d->ignoreScrollSignals)
         return;
 
     setPreferredCenterFractionY((verticalScrollBar()->value()
                                  + verticalScrollBar()->pageStep() / 2.0) / documentSize().height());
 }
 
 void KoCanvasControllerWidget::ensureVisible(KoShape *shape)
 {
     Q_ASSERT(shape);
     ensureVisible(d->canvas->viewConverter()->documentToView(shape->boundingRect()));
 }
 
 void KoCanvasControllerWidget::ensureVisible(const QRectF &rect, bool smooth)
 {
     QRect currentVisible(-canvasOffsetX(), -canvasOffsetY(), visibleWidth(), visibleHeight());
 
     QRect viewRect = rect.toRect();
     viewRect.translate(d->canvas->documentOrigin());
     if (!viewRect.isValid() || currentVisible.contains(viewRect))
         return; // its visible. Nothing to do.
 
     // if we move, we move a little more so the amount of times we have to move is less.
     int jumpWidth = smooth ? 0 : currentVisible.width() / 5;
     int jumpHeight = smooth ? 0 : currentVisible.height() / 5;
     if (!smooth && viewRect.width() + jumpWidth > currentVisible.width())
         jumpWidth = 0;
     if (!smooth && viewRect.height() + jumpHeight > currentVisible.height())
         jumpHeight = 0;
 
     int horizontalMove = 0;
     if (currentVisible.width() <= viewRect.width())      // center view
         horizontalMove = viewRect.center().x() - currentVisible.center().x();
     else if (currentVisible.x() > viewRect.x())          // move left
         horizontalMove = viewRect.x() - currentVisible.x() - jumpWidth;
     else if (currentVisible.right() < viewRect.right())  // move right
         horizontalMove = viewRect.right() - qMax(0, currentVisible.right() - jumpWidth);
 
     int verticalMove = 0;
     if (currentVisible.height() <= viewRect.height())       // center view
         verticalMove = viewRect.center().y() - currentVisible.center().y();
     if (currentVisible.y() > viewRect.y())               // move up
         verticalMove = viewRect.y() - currentVisible.y() - jumpHeight;
     else if (currentVisible.bottom() < viewRect.bottom()) // move down
         verticalMove = viewRect.bottom() - qMax(0, currentVisible.bottom() - jumpHeight);
 
     pan(QPoint(horizontalMove, verticalMove));
 }
 
 void KoCanvasControllerWidget::recenterPreferred()
 {
     const bool oldIgnoreScrollSignals = d->ignoreScrollSignals;
     d->ignoreScrollSignals = true;
 
     QPointF center = preferredCenter();
 
     // convert into a viewport based point
     center.rx() += d->canvas->canvasWidget()->x() + frameWidth();
     center.ry() += d->canvas->canvasWidget()->y() + frameWidth();
 
     // scroll to a new center point
     QPointF topLeft = center - 0.5 * QPointF(viewport()->width(), viewport()->height());
     setScrollBarValue(topLeft.toPoint());
 
     d->ignoreScrollSignals = oldIgnoreScrollSignals;
 }
 
 void KoCanvasControllerWidget::zoomIn(const QPoint &center)
 {
     zoomBy(center, sqrt(2.0));
 }
 
 void KoCanvasControllerWidget::zoomOut(const QPoint &center)
 {
     zoomBy(center, sqrt(0.5));
 }
 
 void KoCanvasControllerWidget::zoomBy(const QPoint &center, qreal zoom)
 {
     setPreferredCenterFractionX(1.0 * center.x() / documentSize().width());
     setPreferredCenterFractionY(1.0 * center.y() / documentSize().height());
 
     const bool oldIgnoreScrollSignals = d->ignoreScrollSignals;
     d->ignoreScrollSignals = true;
     proxyObject->emitZoomRelative(zoom, preferredCenter());
     d->ignoreScrollSignals = oldIgnoreScrollSignals;
 }
 
 void KoCanvasControllerWidget::zoomTo(const QRect &viewRect)
 {
     qreal scale;
 
     if (1.0 * viewport()->width() / viewRect.width() > 1.0 * viewport()->height() / viewRect.height())
         scale = 1.0 * viewport()->height() / viewRect.height();
     else
         scale = 1.0 * viewport()->width() / viewRect.width();
 
     zoomBy(viewRect.center(), scale);
 }
 
 void KoCanvasControllerWidget::updateDocumentSize(const QSizeF &sz, bool recalculateCenter)
 {
     // Don't update if the document-size didn't changed to prevent infinite loops and unneeded updates.
     if (KoCanvasController::documentSize() == sz)
         return;
 
     if (!recalculateCenter) {
         // assume the distance from the top stays equal and recalculate the center.
         setPreferredCenterFractionX(documentSize().width() * preferredCenterFractionX() / sz.width());
         setPreferredCenterFractionY(documentSize().height() * preferredCenterFractionY() / sz.height());
     }
 
     const bool oldIgnoreScrollSignals = d->ignoreScrollSignals;
     d->ignoreScrollSignals = true;
     KoCanvasController::setDocumentSize(sz);
     d->viewportWidget->setDocumentSize(sz);
     resetScrollBars();
 
     // Always emit the new offset.
     updateCanvasOffsetX();
     updateCanvasOffsetY();
 
     d->ignoreScrollSignals = oldIgnoreScrollSignals;
 }
 
 void KoCanvasControllerWidget::setZoomWithWheel(bool zoom)
 {
     d->zoomWithWheel = zoom;
 }
 
 void KoCanvasControllerWidget::setVastScrolling(qreal factor)
 {
     d->vastScrollingFactor = factor;
 }
 
 QPointF KoCanvasControllerWidget::currentCursorPosition() const
 {
     QWidget *canvasWidget = d->canvas->canvasWidget();
     const KoViewConverter *converter = d->canvas->viewConverter();
     return converter->viewToDocument(canvasWidget->mapFromGlobal(QCursor::pos()) + d->canvas->canvasController()->documentOffset() - canvasWidget->pos());
 }
 
 void KoCanvasControllerWidget::pan(const QPoint &distance)
 {
     QPoint sourcePoint = scrollBarValue();
     setScrollBarValue(sourcePoint + distance);
 }
 
 void KoCanvasControllerWidget::panUp()
 {
     pan(QPoint(0, verticalScrollBar()->singleStep()));
 }
 
 void KoCanvasControllerWidget::panDown()
 {
     pan(QPoint(0, -verticalScrollBar()->singleStep()));
 }
 
 void KoCanvasControllerWidget::panLeft()
 {
     pan(QPoint(horizontalScrollBar()->singleStep(), 0));
 }
 
 void KoCanvasControllerWidget::panRight()
 {
     pan(QPoint(-horizontalScrollBar()->singleStep(), 0));
 }
 
 void KoCanvasControllerWidget::setPreferredCenter(const QPointF &viewPoint)
 {
     setPreferredCenterFractionX(viewPoint.x() / documentSize().width());
     setPreferredCenterFractionY(viewPoint.y() / documentSize().height());
     recenterPreferred();
 }
 
 QPointF KoCanvasControllerWidget::preferredCenter() const
 {
     QPointF center;
     center.setX(preferredCenterFractionX() * documentSize().width());
     center.setY(preferredCenterFractionY() * documentSize().height());
     return center;
 }
 
 void KoCanvasControllerWidget::paintEvent(QPaintEvent *event)
 {
     QPainter gc(viewport());
     d->viewportWidget->handlePaintEvent(gc, event);
 }
 
 void KoCanvasControllerWidget::dragEnterEvent(QDragEnterEvent *event)
 {
     d->viewportWidget->handleDragEnterEvent(event);
 }
 
 void KoCanvasControllerWidget::dropEvent(QDropEvent *event)
 {
     d->viewportWidget->handleDropEvent(event);
 }
 
 void KoCanvasControllerWidget::dragMoveEvent(QDragMoveEvent *event)
 {
     d->viewportWidget->handleDragMoveEvent(event);
 }
 
 void KoCanvasControllerWidget::dragLeaveEvent(QDragLeaveEvent *event)
 {
     d->viewportWidget->handleDragLeaveEvent(event);
 }
 
 void KoCanvasControllerWidget::wheelEvent(QWheelEvent *event)
 {
     if (d->zoomWithWheel != ((event->modifiers() & Qt::ControlModifier) == Qt::ControlModifier)) {
         const qreal zoomCoeff = event->delta() > 0 ? sqrt(2.0) : sqrt(0.5);
         zoomRelativeToPoint(event->pos(), zoomCoeff);
 
         event->accept();
     } else
         QAbstractScrollArea::wheelEvent(event);
 }
 
 void KoCanvasControllerWidget::zoomRelativeToPoint(const QPoint &widgetPoint, qreal zoomCoeff)
 {
     const QPoint offset = scrollBarValue();
     const QPoint mousePos(widgetPoint + offset);
 
     const bool oldIgnoreScrollSignals = d->ignoreScrollSignals;
     d->ignoreScrollSignals = true;
     proxyObject->emitZoomRelative(zoomCoeff, mousePos);
     d->ignoreScrollSignals = oldIgnoreScrollSignals;
 }
 
 bool KoCanvasControllerWidget::focusNextPrevChild(bool)
 {
     // we always return false meaning the canvas takes keyboard focus, but never gives it away.
     return false;
 }
 
 void KoCanvasControllerWidget::setMargin(int margin)
 {
     KoCanvasController::setMargin(margin);
     Q_ASSERT(d->viewportWidget);
     d->viewportWidget->setMargin(margin);
 }
 
 QPoint KoCanvasControllerWidget::scrollBarValue() const
 {
     QScrollBar * hBar = horizontalScrollBar();
     QScrollBar * vBar = verticalScrollBar();
 
     return QPoint(hBar->value(), vBar->value());
 }
 
 void KoCanvasControllerWidget::setScrollBarValue(const QPoint &value)
 {
     QScrollBar * hBar = horizontalScrollBar();
     QScrollBar * vBar = verticalScrollBar();
 
     hBar->setValue(value.x());
     vBar->setValue(value.y());
 }
 
 void KoCanvasControllerWidget::resetScrollBars()
 {
     d->resetScrollBars();
 }
 
 qreal KoCanvasControllerWidget::vastScrollingFactor() const
 {
     return d->vastScrollingFactor;
 }
 
 KoCanvasControllerWidget::Private *KoCanvasControllerWidget::priv()
 {
     return d;
 }
 
 //have to include this because of Q_PRIVATE_SLOT
 #include "moc_KoCanvasControllerWidget.cpp"
diff --git a/libs/flake/KoCanvasControllerWidget.h b/libs/flake/KoCanvasControllerWidget.h
index a74e5f109b..a3494227d5 100644
--- a/libs/flake/KoCanvasControllerWidget.h
+++ b/libs/flake/KoCanvasControllerWidget.h
@@ -1,193 +1,193 @@
 /* This file is part of the KDE project
  * Copyright (C) 2006, 2008 Thomas Zander <zander@kde.org>
  * Copyright (C) 2007-2010 Boudewijn Rempt <boud@valdyas.org>
  * Copyright (C) 2007-2008 C. Boemann <cbo@boemann.dk>
  * Copyright (C) 2006-2007 Jan Hambrecht <jaham@gmx.net>
  * Copyright (C) 2009 Thorsten Zachmann <zachmann@kde.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #ifndef KOCANVASCONTROLLERWIDGET_H
 #define KOCANVASCONTROLLERWIDGET_H
 
 #include "kritaflake_export.h"
 
 #include <QAbstractScrollArea>
 #include <QPointer>
 #include "KoCanvasController.h"
 
 class KoShape;
 class KoCanvasBase;
-
+class KoCanvasSupervisor;
 /**
  * KoCanvasController implementation for QWidget based canvases
  */
 class KRITAFLAKE_EXPORT KoCanvasControllerWidget : public QAbstractScrollArea, public KoCanvasController
 {
     Q_OBJECT
 public:
 
     /**
      * Constructor.
      * @param actionCollection the action collection for this widget
      * @param parent the parent this widget will belong to
      */
-    explicit KoCanvasControllerWidget(KActionCollection * actionCollection, QWidget *parent = 0);
+    explicit KoCanvasControllerWidget(KActionCollection * actionCollection, KoCanvasSupervisor *observerProvider, QWidget *parent = 0);
     ~KoCanvasControllerWidget() override;
 
     /**
      * Reimplemented from QAbstractScrollArea.
      */
     void scrollContentsBy(int dx, int dy) override;
 
     QSizeF viewportSize() const override;
 
     /// Reimplemented from KoCanvasController
 
     /**
      * Activate this canvascontroller
      */
     virtual void activate();
 
     void setCanvas(KoCanvasBase *canvas) override;
 
     KoCanvasBase *canvas() const override;
 
     /**
      * Change the actual canvas widget used by the current canvas. This allows the canvas widget
      * to be changed while keeping the current KoCanvasBase canvas and its associated resources as
      * they are. This might be used, for example, to switch from a QWidget to a QOpenGLWidget canvas.
      * @param widget the new canvas widget.
      */
     virtual void changeCanvasWidget(QWidget *widget);
 
     int visibleHeight() const override;
     int visibleWidth() const override;
     int canvasOffsetX() const override;
     int canvasOffsetY() const override;
 
     void ensureVisible(const QRectF &rect, bool smooth = false) override;
 
     void ensureVisible(KoShape *shape) override;
 
     /**
      * will cause the toolOptionWidgetsChanged to be emitted and all
      * listeners to be updated to the new widget.
      *
      * FIXME: This doesn't belong her and it does an
      * inherits("KoView") so it too much tied to komain
      *
      * @param widgets the map of widgets
      */
     void setToolOptionWidgets(const QList<QPointer<QWidget> > &widgets);
 
     void zoomIn(const QPoint &center) override;
 
     void zoomOut(const QPoint &center) override;
 
     void zoomBy(const QPoint &center, qreal zoom) override;
 
     void zoomTo(const QRect &rect) override;
 
     /**
      * Zoom document keeping point \p widgetPoint unchanged
      * \param widgetPoint sticky point in widget pixels
      * \param zoomCoeff the zoom
      */
     virtual void zoomRelativeToPoint(const QPoint &widgetPoint, qreal zoomCoeff);
 
     void recenterPreferred() override;
 
     void setPreferredCenter(const QPointF &viewPoint) override;
 
     /// Returns the currently set preferred center point in view coordinates (pixels)
     QPointF preferredCenter() const override;
 
     void pan(const QPoint &distance) override;
 
     virtual void panUp() override;
     virtual void panDown() override;
     virtual void panLeft() override;
     virtual void panRight() override;
 
     void setMargin(int margin) override;
 
     QPoint scrollBarValue() const override;
 
     /**
      * Used by KisCanvasController to correct the scrollbars position
      * after the rotation.
      */
     void setScrollBarValue(const QPoint &value) override;
 
     void updateDocumentSize(const QSizeF &sz, bool recalculateCenter = true) override;
 
     /**
      * Set mouse wheel to zoom behaviour
      * @param zoom if true wheel will zoom instead of scroll, control modifier will scroll
      */
     void setZoomWithWheel(bool zoom) override;
 
     void setVastScrolling(qreal factor) override;
 
     QPointF currentCursorPosition() const override;
 
     void resetScrollBars() override;
 
     /**
      * \internal
      */
     class Private;
     KoCanvasControllerWidget::Private *priv();
 
 private Q_SLOTS:
 
     /// Called by the horizontal scrollbar when its value changes
     void updateCanvasOffsetX();
 
     /// Called by the vertical scrollbar when its value changes
     void updateCanvasOffsetY();
 
 protected:
     friend class KisZoomAndPanTest;
 
     qreal vastScrollingFactor() const;
 
     /// reimplemented from QWidget
     void paintEvent(QPaintEvent *event) override;
     /// reimplemented from QWidget
     void resizeEvent(QResizeEvent *resizeEvent) override;
     /// reimplemented from QWidget
     void dragEnterEvent(QDragEnterEvent *event) override;
     /// reimplemented from QWidget
     void dropEvent(QDropEvent *event) override;
     /// reimplemented from QWidget
     void dragMoveEvent(QDragMoveEvent *event) override;
     /// reimplemented from QWidget
     void dragLeaveEvent(QDragLeaveEvent *event) override;
     /// reimplemented from QWidget
     void wheelEvent(QWheelEvent *event) override;
     /// reimplemented from QWidget
     bool focusNextPrevChild(bool next) override;
 
 private:
     Q_PRIVATE_SLOT(d, void activate())
 
     Private * const d;
 };
 
 #endif
diff --git a/libs/flake/KoCanvasControllerWidget_p.h b/libs/flake/KoCanvasControllerWidget_p.h
index d111af73a1..cfb277c19f 100644
--- a/libs/flake/KoCanvasControllerWidget_p.h
+++ b/libs/flake/KoCanvasControllerWidget_p.h
@@ -1,68 +1,71 @@
 /* This file is part of the KDE project
  *
  * Copyright (C) 2006, 2008-2009 Thomas Zander <zander@kde.org>
  * Copyright (C) 2006 Peter Simonsson <peter.simonsson@gmail.com>
  * Copyright (C) 2006, 2009 Thorsten Zachmann <zachmann@kde.org>
  * Copyright (C) 2007-2010 Boudewijn Rempt <boud@valdyas.org>
  * Copyright (C) 2007 C. Boemann <cbo@boemann.dk>
  * Copyright (C) 2006-2008 Jan Hambrecht <jaham@gmx.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 #ifndef KoCanvasControllerWidget_p_h
 #define KoCanvasControllerWidget_p_h
 
 #include <FlakeDebug.h>
 
 #include <KoConfig.h>
+#include "KoCanvasSupervisor.h"
 
 class KoCanvasControllerWidget;
 class Viewport;
 class KoCanvasBase;
 
 class Q_DECL_HIDDEN KoCanvasControllerWidget::Private
 {
 public:
 
-    Private(KoCanvasControllerWidget *qq)
+    Private(KoCanvasControllerWidget *qq, KoCanvasSupervisor *observerProvider)
         : q(qq)
+        , observerProvider(observerProvider)
         , canvas(0)
         , ignoreScrollSignals(false)
         , zoomWithWheel(false)
         , vastScrollingFactor(0)
     {
     }
 
     /**
      * Gets called by the tool manager if this canvas controller is the current active canvas controller.
      */
     void setDocumentOffset();
 
     void resetScrollBars();
     void emitPointerPositionChangedSignals(QEvent *event);
 
     void activate();
     void unsetCanvas();
 
     KoCanvasControllerWidget *q;
+    KoCanvasSupervisor *observerProvider;
     QPointer<KoCanvasBase> canvas;
     Viewport *viewportWidget;
     bool ignoreScrollSignals;
     bool zoomWithWheel;
     qreal vastScrollingFactor;
 };
 
 #endif
diff --git a/libs/flake/KoShapeManager.cpp b/libs/flake/KoShapeManager.cpp
index ee88220e94..9541dcd4f6 100644
--- a/libs/flake/KoShapeManager.cpp
+++ b/libs/flake/KoShapeManager.cpp
@@ -1,634 +1,685 @@
 /* This file is part of the KDE project
 
    Copyright (C) 2006-2008 Thorsten Zachmann <zachmann@kde.org>
    Copyright (C) 2006-2010 Thomas Zander <zander@kde.org>
    Copyright (C) 2009-2010 Jan Hambrecht <jaham@gmx.net>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #include "KoShapeManager.h"
 #include "KoShapeManager_p.h"
 #include "KoSelection.h"
 #include "KoToolManager.h"
 #include "KoPointerEvent.h"
 #include "KoShape.h"
 #include "KoShape_p.h"
 #include "KoCanvasBase.h"
 #include "KoShapeContainer.h"
 #include "KoShapeStrokeModel.h"
 #include "KoShapeGroup.h"
 #include "KoToolProxy.h"
 #include "KoShapeShadow.h"
 #include "KoShapeLayer.h"
 #include "KoFilterEffect.h"
 #include "KoFilterEffectStack.h"
 #include "KoFilterEffectRenderContext.h"
 #include "KoShapeBackground.h"
 #include <KoRTree.h>
 #include "KoClipPath.h"
 #include "KoClipMaskPainter.h"
 #include "KoShapePaintingContext.h"
 #include "KoViewConverter.h"
 #include "KisQPainterStateSaver.h"
 #include "KoSvgTextChunkShape.h"
 #include "KoSvgTextShape.h"
 #include <QApplication>
 
 #include <QPainter>
 #include <QTimer>
 #include <FlakeDebug.h>
 
 #include "kis_painting_tweaks.h"
 
 bool KoShapeManager::Private::shapeUsedInRenderingTree(KoShape *shape)
 {
     // FIXME: make more general!
 
     return !dynamic_cast<KoShapeGroup*>(shape) &&
             !dynamic_cast<KoShapeLayer*>(shape) &&
             !(dynamic_cast<KoSvgTextChunkShape*>(shape) && !dynamic_cast<KoSvgTextShape*>(shape));
 }
 
 void KoShapeManager::Private::updateTree()
 {
+    QMutexLocker l(&this->treeMutex);
+
     // for detecting collisions between shapes.
     DetectCollision detector;
     bool selectionModified = false;
     bool anyModified = false;
     Q_FOREACH (KoShape *shape, aggregate4update) {
         if (shapeIndexesBeforeUpdate.contains(shape))
             detector.detect(tree, shape, shapeIndexesBeforeUpdate[shape]);
         selectionModified = selectionModified || selection->isSelected(shape);
         anyModified = true;
     }
 
     foreach (KoShape *shape, aggregate4update) {
         if (!shapeUsedInRenderingTree(shape)) continue;
 
         tree.remove(shape);
         QRectF br(shape->boundingRect());
         tree.insert(br, shape);
     }
 
     // do it again to see which shapes we intersect with _after_ moving.
     foreach (KoShape *shape, aggregate4update) {
         detector.detect(tree, shape, shapeIndexesBeforeUpdate[shape]);
     }
     aggregate4update.clear();
     shapeIndexesBeforeUpdate.clear();
 
     detector.fireSignals();
     if (selectionModified) {
         emit q->selectionContentChanged();
     }
     if (anyModified) {
         emit q->contentChanged();
     }
 }
 
 void KoShapeManager::Private::paintGroup(KoShapeGroup *group, QPainter &painter, const KoViewConverter &converter, KoShapePaintingContext &paintContext)
 {
     QList<KoShape*> shapes = group->shapes();
     std::sort(shapes.begin(), shapes.end(), KoShape::compareShapeZIndex);
     Q_FOREACH (KoShape *child, shapes) {
         // we paint recursively here, so we do not have to check recursively for visibility
         if (!child->isVisible(false))
             continue;
         KoShapeGroup *childGroup = dynamic_cast<KoShapeGroup*>(child);
         if (childGroup) {
             paintGroup(childGroup, painter, converter, paintContext);
         } else {
             painter.save();
             KoShapeManager::renderSingleShape(child, painter, converter, paintContext);
             painter.restore();
         }
     }
 }
 
 KoShapeManager::KoShapeManager(KoCanvasBase *canvas, const QList<KoShape *> &shapes)
     : d(new Private(this, canvas))
 {
     Q_ASSERT(d->canvas); // not optional.
     connect(d->selection, SIGNAL(selectionChanged()), this, SIGNAL(selectionChanged()));
     setShapes(shapes);
 
     /**
      * Shape manager uses signal compressors with timers, therefore
      * it might handle queued signals, therefore it should belong
      * to the GUI thread.
      */
     this->moveToThread(qApp->thread());
 }
 
 KoShapeManager::KoShapeManager(KoCanvasBase *canvas)
     : d(new Private(this, canvas))
 {
     Q_ASSERT(d->canvas); // not optional.
     connect(d->selection, SIGNAL(selectionChanged()), this, SIGNAL(selectionChanged()));
 
     // see a comment in another constructor
     this->moveToThread(qApp->thread());
 }
 
 void KoShapeManager::Private::unlinkFromShapesRecursively(const QList<KoShape*> &shapes)
 {
     Q_FOREACH (KoShape *shape, shapes) {
         shape->removeShapeManager(q);
 
         KoShapeContainer *container = dynamic_cast<KoShapeContainer*>(shape);
         if (container) {
             unlinkFromShapesRecursively(container->shapes());
         }
     }
 }
 
 KoShapeManager::~KoShapeManager()
 {
     d->unlinkFromShapesRecursively(d->shapes);
     d->shapes.clear();
 
     delete d;
 }
 
 void KoShapeManager::setShapes(const QList<KoShape *> &shapes, Repaint repaint)
 {
-    //clear selection
-    d->selection->deselectAll();
-    d->unlinkFromShapesRecursively(d->shapes);
-    d->aggregate4update.clear();
-    d->tree.clear();
-    d->shapes.clear();
+    {
+        QMutexLocker l1(&d->shapesMutex);
+        QMutexLocker l2(&d->treeMutex);
+
+        //clear selection
+        d->selection->deselectAll();
+        d->unlinkFromShapesRecursively(d->shapes);
+        d->aggregate4update.clear();
+        d->shapeIndexesBeforeUpdate.clear();
+        d->tree.clear();
+        d->shapes.clear();
+    }
 
     Q_FOREACH (KoShape *shape, shapes) {
         addShape(shape, repaint);
     }
 }
 
 void KoShapeManager::addShape(KoShape *shape, Repaint repaint)
 {
-    if (d->shapes.contains(shape))
-        return;
-    shape->addShapeManager(this);
-    d->shapes.append(shape);
+    {
+        QMutexLocker l1(&d->shapesMutex);
 
-    if (d->shapeUsedInRenderingTree(shape)) {
-        QRectF br(shape->boundingRect());
-        d->tree.insert(br, shape);
+        if (d->shapes.contains(shape))
+            return;
+        shape->addShapeManager(this);
+        d->shapes.append(shape);
+
+        if (d->shapeUsedInRenderingTree(shape)) {
+            QMutexLocker l2(&d->treeMutex);
+
+            QRectF br(shape->boundingRect());
+            d->tree.insert(br, shape);
+        }
     }
 
     if (repaint == PaintShapeOnAdd) {
         shape->update();
     }
 
     // add the children of a KoShapeContainer
     KoShapeContainer *container = dynamic_cast<KoShapeContainer*>(shape);
 
     if (container) {
         foreach (KoShape *containerShape, container->shapes()) {
             addShape(containerShape, repaint);
         }
     }
 
-    Private::DetectCollision detector;
-    detector.detect(d->tree, shape, shape->zIndex());
-    detector.fireSignals();
+    {
+        QMutexLocker l(&d->treeMutex);
+
+        Private::DetectCollision detector;
+        detector.detect(d->tree, shape, shape->zIndex());
+        detector.fireSignals();
+    }
 }
 
 void KoShapeManager::remove(KoShape *shape)
 {
-    Private::DetectCollision detector;
-    detector.detect(d->tree, shape, shape->zIndex());
-    detector.fireSignals();
+    {
+        QMutexLocker l1(&d->shapesMutex);
+        QMutexLocker l2(&d->treeMutex);
 
-    shape->update();
-    shape->removeShapeManager(this);
-    d->selection->deselect(shape);
-    d->aggregate4update.remove(shape);
+        Private::DetectCollision detector;
+        detector.detect(d->tree, shape, shape->zIndex());
+        detector.fireSignals();
+
+        shape->update();
+        shape->removeShapeManager(this);
+        d->selection->deselect(shape);
+        d->aggregate4update.remove(shape);
 
-    if (d->shapeUsedInRenderingTree(shape)) {
-        d->tree.remove(shape);
+        if (d->shapeUsedInRenderingTree(shape)) {
+            d->tree.remove(shape);
+        }
+        d->shapes.removeAll(shape);
     }
-    d->shapes.removeAll(shape);
 
     // remove the children of a KoShapeContainer
     KoShapeContainer *container = dynamic_cast<KoShapeContainer*>(shape);
     if (container) {
         foreach (KoShape *containerShape, container->shapes()) {
             remove(containerShape);
         }
     }
 }
 
 KoShapeManager::ShapeInterface::ShapeInterface(KoShapeManager *_q)
     : q(_q)
 {
 }
 
 void KoShapeManager::ShapeInterface::notifyShapeDestructed(KoShape *shape)
 {
+    QMutexLocker l1(&q->d->shapesMutex);
+    QMutexLocker l2(&q->d->treeMutex);
+
     q->d->selection->deselect(shape);
     q->d->aggregate4update.remove(shape);
 
     // we cannot access RTTI of the semi-destructed shape, so just
     // unlink it lazily
     if (q->d->tree.contains(shape)) {
         q->d->tree.remove(shape);
     }
 
     q->d->shapes.removeAll(shape);
 }
 
 
 KoShapeManager::ShapeInterface *KoShapeManager::shapeInterface()
 {
     return &d->shapeInterface;
 }
 
 
 void KoShapeManager::paint(QPainter &painter, const KoViewConverter &converter, bool forPrint)
 {
+    QMutexLocker l1(&d->shapesMutex);
+
     d->updateTree();
     painter.setPen(Qt::NoPen);  // painters by default have a black stroke, lets turn that off.
     painter.setBrush(Qt::NoBrush);
 
     QList<KoShape*> unsortedShapes;
     if (painter.hasClipping()) {
+        QMutexLocker l(&d->treeMutex);
+
         QRectF rect = converter.viewToDocument(KisPaintingTweaks::safeClipBoundingRect(painter));
         unsortedShapes = d->tree.intersects(rect);
     } else {
         unsortedShapes = shapes();
         warnFlake << "KoShapeManager::paint  Painting with a painter that has no clipping will lead to too much being painted!";
     }
 
     // filter all hidden shapes from the list
     // also filter shapes with a parent which has filter effects applied
     QList<KoShape*> sortedShapes;
     foreach (KoShape *shape, unsortedShapes) {
         if (!shape->isVisible())
             continue;
         bool addShapeToList = true;
         // check if one of the shapes ancestors have filter effects
         KoShapeContainer *parent = shape->parent();
         while (parent) {
             // parent must be part of the shape manager to be taken into account
             if (!d->shapes.contains(parent))
                 break;
             if (parent->filterEffectStack() && !parent->filterEffectStack()->isEmpty()) {
                 addShapeToList = false;
                 break;
             }
             parent = parent->parent();
         }
         if (addShapeToList) {
             sortedShapes.append(shape);
         } else if (parent) {
             sortedShapes.append(parent);
         }
     }
 
     std::sort(sortedShapes.begin(), sortedShapes.end(), KoShape::compareShapeZIndex);
 
     KoShapePaintingContext paintContext(d->canvas, forPrint); //FIXME
 
     foreach (KoShape *shape, sortedShapes) {
         renderSingleShape(shape, painter, converter, paintContext);
     }
 
 #ifdef CALLIGRA_RTREE_DEBUG
     // paint tree
     qreal zx = 0;
     qreal zy = 0;
     converter.zoom(&zx, &zy);
     painter.save();
     painter.scale(zx, zy);
     d->tree.paint(painter);
     painter.restore();
 #endif
 
     if (! forPrint) {
         KoShapePaintingContext paintContext(d->canvas, forPrint); //FIXME
         d->selection->paint(painter, converter, paintContext);
     }
 }
 
 void KoShapeManager::renderSingleShape(KoShape *shape, QPainter &painter, const KoViewConverter &converter, KoShapePaintingContext &paintContext)
 {
     KisQPainterStateSaver saver(&painter);
 
     // apply shape clipping
     KoClipPath::applyClipping(shape, painter, converter);
 
     // apply transformation
     painter.setTransform(shape->absoluteTransformation(&converter) * painter.transform());
 
     // paint the shape
     paintShape(shape, painter, converter, paintContext);
 }
 
 void KoShapeManager::paintShape(KoShape *shape, QPainter &painter, const KoViewConverter &converter, KoShapePaintingContext &paintContext)
 {
     qreal transparency = shape->transparency(true);
     if (transparency > 0.0) {
         painter.setOpacity(1.0-transparency);
     }
 
     if (shape->shadow()) {
         painter.save();
         shape->shadow()->paint(shape, painter, converter);
         painter.restore();
     }
     if (!shape->filterEffectStack() || shape->filterEffectStack()->isEmpty()) {
 
         QScopedPointer<KoClipMaskPainter> clipMaskPainter;
         QPainter *shapePainter = &painter;
 
         KoClipMask *clipMask = shape->clipMask();
         if (clipMask) {
             clipMaskPainter.reset(new KoClipMaskPainter(&painter, shape->boundingRect()));
             shapePainter = clipMaskPainter->shapePainter();
         }
 
         /**
          * We expect the shape to save/restore the painter's state itself. Such design was not
          * not always here, so we need a period of sanity checks to ensure all the shapes are
          * ported correctly.
          */
         const QTransform sanityCheckTransformSaved = shapePainter->transform();
 
         shape->paint(*shapePainter, converter, paintContext);
         shape->paintStroke(*shapePainter, converter, paintContext);
 
         KIS_SAFE_ASSERT_RECOVER(shapePainter->transform() == sanityCheckTransformSaved) {
             shapePainter->setTransform(sanityCheckTransformSaved);
         }
 
         if (clipMask) {
             shape->clipMask()->drawMask(clipMaskPainter->maskPainter(), shape);
             clipMaskPainter->renderOnGlobalPainter();
         }
 
     } else {
         // TODO: clipping mask is not implemented for this case!
 
         // There are filter effects, then we need to prerender the shape on an image, to filter it
         QRectF shapeBound(QPointF(), shape->size());
         // First step, compute the rectangle used for the image
         QRectF clipRegion = shape->filterEffectStack()->clipRectForBoundingRect(shapeBound);
         // convert clip region to view coordinates
         QRectF zoomedClipRegion = converter.documentToView(clipRegion);
         // determine the offset of the clipping rect from the shapes origin
         QPointF clippingOffset = zoomedClipRegion.topLeft();
 
         // Initialize the buffer image
         QImage sourceGraphic(zoomedClipRegion.size().toSize(), QImage::Format_ARGB32_Premultiplied);
         sourceGraphic.fill(qRgba(0,0,0,0));
 
         QHash<QString, QImage> imageBuffers;
 
         QSet<QString> requiredStdInputs = shape->filterEffectStack()->requiredStandarsInputs();
 
         if (requiredStdInputs.contains("SourceGraphic") || requiredStdInputs.contains("SourceAlpha")) {
             // Init the buffer painter
             QPainter imagePainter(&sourceGraphic);
             imagePainter.translate(-1.0f*clippingOffset);
             imagePainter.setPen(Qt::NoPen);
             imagePainter.setBrush(Qt::NoBrush);
             imagePainter.setRenderHint(QPainter::Antialiasing, painter.testRenderHint(QPainter::Antialiasing));
 
             // Paint the shape on the image
             KoShapeGroup *group = dynamic_cast<KoShapeGroup*>(shape);
             if (group) {
                 // the childrens matrix contains the groups matrix as well
                 // so we have to compensate for that before painting the children
                 imagePainter.setTransform(group->absoluteTransformation(&converter).inverted(), true);
                 Private::paintGroup(group, imagePainter, converter, paintContext);
             } else {
                 imagePainter.save();
                 shape->paint(imagePainter, converter, paintContext);
                 shape->paintStroke(imagePainter, converter, paintContext);
                 imagePainter.restore();
                 imagePainter.end();
             }
         }
         if (requiredStdInputs.contains("SourceAlpha")) {
             QImage sourceAlpha = sourceGraphic;
             sourceAlpha.fill(qRgba(0,0,0,255));
             sourceAlpha.setAlphaChannel(sourceGraphic.alphaChannel());
             imageBuffers.insert("SourceAlpha", sourceAlpha);
         }
         if (requiredStdInputs.contains("FillPaint")) {
             QImage fillPaint = sourceGraphic;
             if (shape->background()) {
                 QPainter fillPainter(&fillPaint);
                 QPainterPath fillPath;
                 fillPath.addRect(fillPaint.rect().adjusted(-1,-1,1,1));
                 shape->background()->paint(fillPainter, converter, paintContext, fillPath);
             } else {
                 fillPaint.fill(qRgba(0,0,0,0));
             }
             imageBuffers.insert("FillPaint", fillPaint);
         }
 
         imageBuffers.insert("SourceGraphic", sourceGraphic);
         imageBuffers.insert(QString(), sourceGraphic);
 
         KoFilterEffectRenderContext renderContext(converter);
         renderContext.setShapeBoundingBox(shapeBound);
 
         QImage result;
         QList<KoFilterEffect*> filterEffects = shape->filterEffectStack()->filterEffects();
         // Filter
         foreach (KoFilterEffect *filterEffect, filterEffects) {
             QRectF filterRegion = filterEffect->filterRectForBoundingRect(shapeBound);
             filterRegion = converter.documentToView(filterRegion);
             QRect subRegion = filterRegion.translated(-clippingOffset).toRect();
             // set current filter region
             renderContext.setFilterRegion(subRegion & sourceGraphic.rect());
 
             if (filterEffect->maximalInputCount() <= 1) {
                 QList<QString> inputs = filterEffect->inputs();
                 QString input = inputs.count() ? inputs.first() : QString();
                 // get input image from image buffers and apply the filter effect
                 QImage image = imageBuffers.value(input);
                 if (!image.isNull()) {
                     result = filterEffect->processImage(imageBuffers.value(input), renderContext);
                 }
             } else {
                 QList<QImage> inputImages;
                 Q_FOREACH (const QString &input, filterEffect->inputs()) {
                     QImage image = imageBuffers.value(input);
                     if (!image.isNull())
                         inputImages.append(imageBuffers.value(input));
                 }
                 // apply the filter effect
                 if (filterEffect->inputs().count() == inputImages.count())
                     result = filterEffect->processImages(inputImages, renderContext);
             }
             // store result of effect
             imageBuffers.insert(filterEffect->output(), result);
         }
 
         KoFilterEffect *lastEffect = filterEffects.last();
 
         // Paint the result
         painter.save();
         painter.drawImage(clippingOffset, imageBuffers.value(lastEffect->output()));
         painter.restore();
     }
 }
 
 KoShape *KoShapeManager::shapeAt(const QPointF &position, KoFlake::ShapeSelection selection, bool omitHiddenShapes)
 {
+    QMutexLocker l(&d->shapesMutex);
+
     d->updateTree();
-    QList<KoShape*> sortedShapes(d->tree.contains(position));
+    QList<KoShape*> sortedShapes;
+
+    {
+        QMutexLocker l(&d->treeMutex);
+        sortedShapes = d->tree.contains(position);
+    }
+
     std::sort(sortedShapes.begin(), sortedShapes.end(), KoShape::compareShapeZIndex);
     KoShape *firstUnselectedShape = 0;
     for (int count = sortedShapes.count() - 1; count >= 0; count--) {
         KoShape *shape = sortedShapes.at(count);
         if (omitHiddenShapes && ! shape->isVisible())
             continue;
         if (! shape->hitTest(position))
             continue;
 
         switch (selection) {
         case KoFlake::ShapeOnTop:
             if (shape->isSelectable())
                 return shape;
             break;
         case KoFlake::Selected:
             if (d->selection->isSelected(shape))
                 return shape;
             break;
         case KoFlake::Unselected:
             if (! d->selection->isSelected(shape))
                 return shape;
             break;
         case KoFlake::NextUnselected:
             // we want an unselected shape
             if (d->selection->isSelected(shape))
                 continue;
             // memorize the first unselected shape
             if (! firstUnselectedShape)
                 firstUnselectedShape = shape;
             // check if the shape above is selected
             if (count + 1 < sortedShapes.count() && d->selection->isSelected(sortedShapes.at(count + 1)))
                 return shape;
             break;
         }
     }
     // if we want the next unselected below a selected but there was none selected,
     // return the first found unselected shape
     if (selection == KoFlake::NextUnselected && firstUnselectedShape)
         return firstUnselectedShape;
 
     if (d->selection->hitTest(position))
         return d->selection;
 
     return 0; // missed everything
 }
 
 QList<KoShape *> KoShapeManager::shapesAt(const QRectF &rect, bool omitHiddenShapes, bool containedMode)
 {
+    QMutexLocker l(&d->shapesMutex);
+
     d->updateTree();
-    QList<KoShape*> shapes(containedMode ? d->tree.contained(rect) : d->tree.intersects(rect));
+    QList<KoShape*> shapes;
+
+    {
+        QMutexLocker l(&d->treeMutex);
+        shapes = containedMode ? d->tree.contained(rect) : d->tree.intersects(rect);
+    }
 
     for (int count = shapes.count() - 1; count >= 0; count--) {
 
         KoShape *shape = shapes.at(count);
 
         if (omitHiddenShapes && !shape->isVisible()) {
             shapes.removeAt(count);
         } else {
             const QPainterPath outline = shape->absoluteTransformation(0).map(shape->outline());
 
             if (!containedMode && !outline.intersects(rect) && !outline.contains(rect)) {
                 shapes.removeAt(count);
 
             } else if (containedMode) {
 
                 QPainterPath containingPath;
                 containingPath.addRect(rect);
 
                 if (!containingPath.contains(outline)) {
                     shapes.removeAt(count);
                 }
             }
         }
     }
 
     return shapes;
 }
 
 void KoShapeManager::update(const QRectF &rect, const KoShape *shape, bool selectionHandles)
 {
+    // TODO: do we need locking here?
+
     d->canvas->updateCanvas(rect);
     if (selectionHandles && d->selection->isSelected(shape)) {
         if (d->canvas->toolProxy())
             d->canvas->toolProxy()->repaintDecorations();
     }
 }
 
 void KoShapeManager::notifyShapeChanged(KoShape *shape)
 {
-    Q_ASSERT(shape);
-    if (d->aggregate4update.contains(shape)) {
-        return;
+    {
+        QMutexLocker l(&d->treeMutex);
+
+        Q_ASSERT(shape);
+        if (d->aggregate4update.contains(shape)) {
+            return;
+        }
+
+        d->aggregate4update.insert(shape);
+        d->shapeIndexesBeforeUpdate.insert(shape, shape->zIndex());
     }
-    const bool wasEmpty = d->aggregate4update.isEmpty();
-    d->aggregate4update.insert(shape);
-    d->shapeIndexesBeforeUpdate.insert(shape, shape->zIndex());
 
     KoShapeContainer *container = dynamic_cast<KoShapeContainer*>(shape);
     if (container) {
         Q_FOREACH (KoShape *child, container->shapes())
             notifyShapeChanged(child);
     }
-
-    if (wasEmpty && !d->aggregate4update.isEmpty()) {
-        d->updateTreeCompressor.start();
-    }
 }
 
 QList<KoShape*> KoShapeManager::shapes() const
 {
+    QMutexLocker l(&d->shapesMutex);
+
     return d->shapes;
 }
 
 QList<KoShape*> KoShapeManager::topLevelShapes() const
 {
+    QMutexLocker l(&d->shapesMutex);
+
     QList<KoShape*> shapes;
     // get all toplevel shapes
     Q_FOREACH (KoShape *shape, d->shapes) {
         if (!shape->parent() || dynamic_cast<KoShapeLayer*>(shape->parent())) {
             shapes.append(shape);
         }
     }
     return shapes;
 }
 
 KoSelection *KoShapeManager::selection() const
 {
     return d->selection;
 }
 
 KoCanvasBase *KoShapeManager::canvas()
 {
     return d->canvas;
 }
 
 //have to include this because of Q_PRIVATE_SLOT
 #include "moc_KoShapeManager.cpp"
diff --git a/libs/flake/KoShapeManager_p.h b/libs/flake/KoShapeManager_p.h
index 6e9e9e02ee..c6cbcdf60b 100644
--- a/libs/flake/KoShapeManager_p.h
+++ b/libs/flake/KoShapeManager_p.h
@@ -1,124 +1,123 @@
 /* This file is part of the KDE project
 
    Copyright (C) 2006-2008 Thorsten Zachmann <zachmann@kde.org>
    Copyright (C) 2006-2010 Thomas Zander <zander@kde.org>
    Copyright (C) 2009-2010 Jan Hambrecht <jaham@gmx.net>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 #ifndef KoShapeManager_p_h
 #define KoShapeManager_p_h
 
 #include "KoSelection.h"
 #include "KoShape.h"
 #include "KoShape_p.h"
 #include "KoShapeContainer.h"
 #include "KoShapeManager.h"
 #include <KoRTree.h>
-#include "kis_thread_safe_signal_compressor.h"
+#include <QMutex>
 
 
 class KoCanvasBase;
 class KoShapeGroup;
 class KoShapePaintingContext;
 class QPainter;
 
 class Q_DECL_HIDDEN KoShapeManager::Private
 {
 public:
     Private(KoShapeManager *shapeManager, KoCanvasBase *c)
         : selection(new KoSelection(shapeManager)),
           canvas(c),
           tree(4, 2),
           q(shapeManager),
-          shapeInterface(shapeManager),
-          updateTreeCompressor(100, KisSignalCompressor::FIRST_INACTIVE)
+          shapeInterface(shapeManager)
     {
-        connect(&updateTreeCompressor, SIGNAL(timeout()), q, SLOT(updateTree()));
     }
 
     ~Private() {
         delete selection;
     }
 
     /**
      * Update the tree when there are shapes in m_aggregate4update. This is done so not all
      * updates to the tree are done when they are asked for but when they are needed.
      */
     void updateTree();
 
     /**
      * Returns whether the shape should be added to the RTree for collision and ROI
      * detection.
      */
     bool shapeUsedInRenderingTree(KoShape *shape);
 
     /**
      * Recursively detach the shapes from this shape manager
      */
     void unlinkFromShapesRecursively(const QList<KoShape *> &shapes);
 
     /**
      * Recursively paints the given group shape to the specified painter
      * This is needed for filter effects on group shapes where the filter effect
      * applies to all the children of the group shape at once
      */
     static void paintGroup(KoShapeGroup *group, QPainter &painter, const KoViewConverter &converter, KoShapePaintingContext &paintContext);
 
     class DetectCollision
     {
     public:
         DetectCollision() {}
         void detect(KoRTree<KoShape *> &tree, KoShape *s, int prevZIndex) {
             Q_FOREACH (KoShape *shape, tree.intersects(s->boundingRect())) {
                 bool isChild = false;
                 KoShapeContainer *parent = s->parent();
                 while (parent && !isChild) {
                     if (parent == shape)
                         isChild = true;
                     parent = parent->parent();
                 }
                 if (isChild)
                     continue;
                 if (s->zIndex() <= shape->zIndex() && prevZIndex <= shape->zIndex())
                     // Moving a shape will only make it collide with shapes below it.
                     continue;
                 if (shape->collisionDetection() && !shapesWithCollisionDetection.contains(shape))
                     shapesWithCollisionDetection.append(shape);
             }
         }
 
         void fireSignals() {
             Q_FOREACH (KoShape *shape, shapesWithCollisionDetection)
                 shape->shapeChangedPriv(KoShape::CollisionDetected);
         }
 
     private:
         QList<KoShape*> shapesWithCollisionDetection;
     };
 
     QList<KoShape *> shapes;
     KoSelection *selection;
     KoCanvasBase *canvas;
     KoRTree<KoShape *> tree;
     QSet<KoShape *> aggregate4update;
     QHash<KoShape*, int> shapeIndexesBeforeUpdate;
     KoShapeManager *q;
     KoShapeManager::ShapeInterface shapeInterface;
-    KisThreadSafeSignalCompressor updateTreeCompressor;
+    QMutex shapesMutex;
+    QMutex treeMutex;
 };
 
 #endif
diff --git a/libs/image/3rdparty/lock_free_map/concurrent_map.h b/libs/image/3rdparty/lock_free_map/concurrent_map.h
index 6671927710..a7d5f8fa65 100644
--- a/libs/image/3rdparty/lock_free_map/concurrent_map.h
+++ b/libs/image/3rdparty/lock_free_map/concurrent_map.h
@@ -1,363 +1,366 @@
 /*------------------------------------------------------------------------
   Junction: Concurrent data structures in C++
   Copyright (c) 2016 Jeff Preshing
   Distributed under the Simplified BSD License.
   Original location: https://github.com/preshing/junction
   This software is distributed WITHOUT ANY WARRANTY; without even the
   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the LICENSE file for more information.
 ------------------------------------------------------------------------*/
 
 #ifndef CONCURRENTMAP_H
 #define CONCURRENTMAP_H
 
 #include "leapfrog.h"
 #include "qsbr.h"
 
 template <typename K, typename V, class KT = DefaultKeyTraits<K>, class VT = DefaultValueTraits<V> >
 class ConcurrentMap
 {
 public:
     typedef K Key;
     typedef V Value;
     typedef KT KeyTraits;
     typedef VT ValueTraits;
     typedef quint32 Hash;
     typedef Leapfrog<ConcurrentMap> Details;
 
 private:
     Atomic<typename Details::Table*> m_root;
     QSBR m_gc;
 
 public:
     ConcurrentMap(quint64 capacity = Details::InitialSize) : m_root(Details::Table::create(capacity))
     {
     }
 
     ~ConcurrentMap()
     {
         typename Details::Table* table = m_root.loadNonatomic();
         table->destroy();
         m_gc.flush();
     }
 
     QSBR &getGC()
     {
         return m_gc;
     }
 
     bool migrationInProcess()
     {
-        return (quint64) m_root.loadNonatomic()->jobCoordinator.loadConsume() != 1;
+        return quint64(m_root.loadNonatomic()->jobCoordinator.loadConsume()) > 1;
     }
 
     // publishTableMigration() is called by exactly one thread from Details::TableMigration::run()
     // after all the threads participating in the migration have completed their work.
     void publishTableMigration(typename Details::TableMigration* migration)
     {
         m_root.store(migration->m_destination, Release);
         // Caller will GC the TableMigration and the source table.
     }
 
     // A Mutator represents a known cell in the hash table.
     // It's meant for manipulations within a temporary function scope.
     // Obviously you must not call QSBR::Update while holding a Mutator.
     // Any operation that modifies the table (exchangeValue, eraseValue)
     // may be forced to follow a redirected cell, which changes the Mutator itself.
     // Note that even if the Mutator was constructed from an existing cell,
     // exchangeValue() can still trigger a resize if the existing cell was previously marked deleted,
     // or if another thread deletes the key between the two steps.
     class Mutator
     {
     private:
         friend class ConcurrentMap;
 
         ConcurrentMap& m_map;
         typename Details::Table* m_table;
         typename Details::Cell* m_cell;
         Value m_value;
 
         // Constructor: Find existing cell
         Mutator(ConcurrentMap& map, Key key, bool) : m_map(map), m_value(Value(ValueTraits::NullValue))
         {
             Hash hash = KeyTraits::hash(key);
             for (;;) {
                 m_table = m_map.m_root.load(Consume);
                 m_cell = Details::find(hash, m_table);
                 if (!m_cell) {
                     return;
                 }
 
                 Value value = m_cell->value.load(Consume);
                 if (value != Value(ValueTraits::Redirect)) {
                     // Found an existing value
                     m_value = value;
                     return;
                 }
                 // We've encountered a Redirect value. Help finish the migration.
                 m_table->jobCoordinator.participate();
                 // Try again using the latest root.
             }
         }
 
         // Constructor: Insert or find cell
         Mutator(ConcurrentMap& map, Key key) : m_map(map), m_value(Value(ValueTraits::NullValue))
         {
             Hash hash = KeyTraits::hash(key);
             for (;;) {
                 m_table = m_map.m_root.load(Consume);
                 quint64 overflowIdx;
                 switch (Details::insertOrFind(hash, m_table, m_cell, overflowIdx)) { // Modifies m_cell
                 case Details::InsertResult_InsertedNew: {
                     // We've inserted a new cell. Don't load m_cell->value.
                     return;
                 }
                 case Details::InsertResult_AlreadyFound: {
                     // The hash was already found in the table.
                     Value value = m_cell->value.load(Consume);
                     if (value == Value(ValueTraits::Redirect)) {
                         // We've encountered a Redirect value.
                         break; // Help finish the migration.
                     }
                     // Found an existing value
                     m_value = value;
                     return;
                 }
                 case Details::InsertResult_Overflow: {
                     // Unlike ConcurrentMap_Linear, we don't need to keep track of & pass a "mustDouble" flag.
                     // Passing overflowIdx is sufficient to prevent an infinite loop here.
                     // It defines the start of the range of cells to check while estimating total cells in use.
                     // After the first migration, deleted keys are purged, so if we hit this line during the
                     // second loop iteration, every cell in the range will be in use, thus the estimate will be 100%.
                     // (Concurrent deletes could result in further iterations, but it will eventually settle.)
                     Details::beginTableMigration(m_map, m_table, overflowIdx);
                     break;
                 }
                 }
                 // A migration has been started (either by us, or another thread). Participate until it's complete.
                 m_table->jobCoordinator.participate();
                 // Try again using the latest root.
             }
         }
 
     public:
         Value getValue() const
         {
             // Return previously loaded value. Don't load it again.
             return Value(m_value);
         }
 
         Value exchangeValue(Value desired)
         {
             for (;;) {
                 Value oldValue = m_value;
                 if (m_cell->value.compareExchangeStrong(m_value, desired, ConsumeRelease)) {
                     // Exchange was successful. Return previous value.
                     Value result = m_value;
                     m_value = desired; // Leave the mutator in a valid state
                     return result;
                 }
                 // The CAS failed and m_value has been updated with the latest value.
                 if (m_value != Value(ValueTraits::Redirect)) {
                     if (oldValue == Value(ValueTraits::NullValue) && m_value != Value(ValueTraits::NullValue)) {
                         // racing write inserted new value
                     }
                     // There was a racing write (or erase) to this cell.
                     // Pretend we exchanged with ourselves, and just let the racing write win.
                     return desired;
                 }
 
                 // We've encountered a Redirect value. Help finish the migration.
                 Hash hash = m_cell->hash.load(Relaxed);
                 for (;;) {
                     // Help complete the migration.
                     m_table->jobCoordinator.participate();
                     // Try again in the new table.
                     m_table = m_map.m_root.load(Consume);
                     m_value = Value(ValueTraits::NullValue);
                     quint64 overflowIdx;
 
                     switch (Details::insertOrFind(hash, m_table, m_cell, overflowIdx)) { // Modifies m_cell
                     case Details::InsertResult_AlreadyFound:
                         m_value = m_cell->value.load(Consume);
                         if (m_value == Value(ValueTraits::Redirect)) {
                             break;
                         }
                         goto breakOuter;
                     case Details::InsertResult_InsertedNew:
                         goto breakOuter;
                     case Details::InsertResult_Overflow:
                         Details::beginTableMigration(m_map, m_table, overflowIdx);
                         break;
                     }
                     // We were redirected... again
                 }
             breakOuter:;
                 // Try again in the new table.
             }
         }
 
         void assignValue(Value desired)
         {
             exchangeValue(desired);
         }
 
         Value eraseValue()
         {
             for (;;) {
                 if (m_value == Value(ValueTraits::NullValue)) {
                     return Value(m_value);
                 }
 
                 if (m_cell->value.compareExchangeStrong(m_value, Value(ValueTraits::NullValue), Consume)) {
                     // Exchange was successful and a non-NULL value was erased and returned by reference in m_value.
                     Value result = m_value;
                     m_value = Value(ValueTraits::NullValue); // Leave the mutator in a valid state
                     return result;
                 }
 
                 // The CAS failed and m_value has been updated with the latest value.
                 if (m_value != Value(ValueTraits::Redirect)) {
                     // There was a racing write (or erase) to this cell.
                     // Pretend we erased nothing, and just let the racing write win.
                     return Value(ValueTraits::NullValue);
                 }
 
                 // We've been redirected to a new table.
                 Hash hash = m_cell->hash.load(Relaxed); // Re-fetch hash
                 for (;;) {
                     // Help complete the migration.
                     m_table->jobCoordinator.participate();
                     // Try again in the new table.
                     m_table = m_map.m_root.load(Consume);
                     m_cell = Details::find(hash, m_table);
                     if (!m_cell) {
                         m_value = Value(ValueTraits::NullValue);
                         return m_value;
                     }
 
                     m_value = m_cell->value.load(Relaxed);
                     if (m_value != Value(ValueTraits::Redirect)) {
                         break;
                     }
                 }
             }
         }
     };
 
     Mutator insertOrFind(Key key)
     {
         return Mutator(*this, key);
     }
 
     Mutator find(Key key)
     {
         return Mutator(*this, key, false);
     }
 
     // Lookup without creating a temporary Mutator.
     Value get(Key key)
     {
         Hash hash = KeyTraits::hash(key);
         for (;;) {
             typename Details::Table* table = m_root.load(Consume);
             typename Details::Cell* cell = Details::find(hash, table);
             if (!cell) {
                 return Value(ValueTraits::NullValue);
             }
 
             Value value = cell->value.load(Consume);
             if (value != Value(ValueTraits::Redirect)) {
                 return value; // Found an existing value
             }
             // We've been redirected to a new table. Help with the migration.
             table->jobCoordinator.participate();
             // Try again in the new table.
         }
     }
 
     Value assign(Key key, Value desired)
     {
         Mutator iter(*this, key);
         return iter.exchangeValue(desired);
     }
 
     Value exchange(Key key, Value desired)
     {
         Mutator iter(*this, key);
         return iter.exchangeValue(desired);
     }
 
     Value erase(Key key)
     {
         Mutator iter(*this, key, false);
         return iter.eraseValue();
     }
 
     // The easiest way to implement an Iterator is to prevent all Redirects.
     // The currrent Iterator does that by forbidding concurrent inserts.
     // To make it work with concurrent inserts, we'd need a way to block TableMigrations.
     class Iterator
     {
     private:
         typename Details::Table* m_table;
         quint64 m_idx;
         Key m_hash;
         Value m_value;
 
     public:
         Iterator() = default;
         Iterator(ConcurrentMap& map)
         {
             // Since we've forbidden concurrent inserts (for now), nonatomic would suffice here, but let's plan ahead:
             m_table = map.m_root.load(Consume);
             m_idx = -1;
             next();
         }
 
         void setMap(ConcurrentMap& map)
         {
             m_table = map.m_root.load(Consume);
             m_idx = -1;
             next();
         }
 
         void next()
         {
             while (++m_idx <= m_table->sizeMask) {
                 // Index still inside range of table.
                 typename Details::CellGroup* group = m_table->getCellGroups() + (m_idx >> 2);
                 typename Details::Cell* cell = group->cells + (m_idx & 3);
                 m_hash = cell->hash.load(Relaxed);
 
                 if (m_hash != KeyTraits::NullHash) {
                     // Cell has been reserved.
                     m_value = cell->value.load(Relaxed);
                     if (m_value != Value(ValueTraits::NullValue))
                         return; // Yield this cell.
                 }
             }
             // That's the end of the map.
             m_hash = KeyTraits::NullHash;
             m_value = Value(ValueTraits::NullValue);
         }
 
         bool isValid() const
         {
+#ifdef SANITY_CHECK
+            KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(m_value != Value(ValueTraits::Redirect), false);
+#endif
             return m_value != Value(ValueTraits::NullValue);
         }
 
         Key getKey() const
         {
             // Since we've forbidden concurrent inserts (for now), nonatomic would suffice here, but let's plan ahead:
             return KeyTraits::dehash(m_hash);
         }
 
         Value getValue() const
         {
             return m_value;
         }
     };
 };
 
 #endif // CONCURRENTMAP_LEAPFROG_H
diff --git a/libs/image/brushengine/kis_paint_information.cc b/libs/image/brushengine/kis_paint_information.cc
index 80edf3bcd7..07a3f85bc7 100644
--- a/libs/image/brushengine/kis_paint_information.cc
+++ b/libs/image/brushengine/kis_paint_information.cc
@@ -1,643 +1,655 @@
 /*
  *  Copyright (c) 2007,2010 Cyrille Berger <cberger@cberger.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include <brushengine/kis_paint_information.h>
 
 #include <QDomElement>
 #include <boost/optional.hpp>
 
 #include "kis_paintop.h"
 #include "kis_algebra_2d.h"
 #include "kis_lod_transform.h"
 #include "kis_spacing_information.h"
 
 #include <kis_dom_utils.h>
 
 struct KisPaintInformation::Private {
     Private(const QPointF & pos_,
             qreal pressure_,
             qreal xTilt_, qreal yTilt_,
             qreal rotation_,
             qreal tangentialPressure_,
             qreal perspective_,
             qreal time_,
             qreal speed_,
             bool isHoveringMode_)
         :
         pos(pos_),
         pressure(pressure_),
         xTilt(xTilt_),
         yTilt(yTilt_),
         rotation(rotation_),
         tangentialPressure(tangentialPressure_),
         perspective(perspective_),
         time(time_),
         speed(speed_),
         isHoveringMode(isHoveringMode_),
         randomSource(0),
         perStrokeRandomSource(0),
         levelOfDetail(0)
     {
     }
 
 
 
     ~Private() {
         KIS_ASSERT_RECOVER_NOOP(!sanityIsRegistered);
     }
     Private(const Private &rhs) {
         copy(rhs);
     }
     Private& operator=(const Private &rhs) {
         copy(rhs);
         return *this;
     }
 
     void copy(const Private &rhs) {
         pos = rhs.pos;
         pressure = rhs.pressure;
         xTilt = rhs.xTilt;
         yTilt = rhs.yTilt;
         rotation = rhs.rotation;
         tangentialPressure = rhs.tangentialPressure;
         perspective = rhs.perspective;
         time = rhs.time;
         speed = rhs.speed;
         isHoveringMode = rhs.isHoveringMode;
         randomSource = rhs.randomSource;
         perStrokeRandomSource = rhs.perStrokeRandomSource;
         sanityIsRegistered = false; // HINT: we do not copy registration mark!
         directionHistoryInfo = rhs.directionHistoryInfo;
         canvasRotation = rhs.canvasRotation;
         canvasMirroredH = rhs.canvasMirroredH;
+        canvasMirroredV = rhs.canvasMirroredV;
+
         if (rhs.drawingAngleOverride) {
             drawingAngleOverride = *rhs.drawingAngleOverride;
         }
 
         levelOfDetail = rhs.levelOfDetail;
     }
 
 
     QPointF pos;
     qreal pressure;
     qreal xTilt;
     qreal yTilt;
     qreal rotation;
     qreal tangentialPressure;
     qreal perspective;
     qreal time;
     qreal speed;
     bool isHoveringMode;
     KisRandomSourceSP randomSource;
     KisPerStrokeRandomSourceSP perStrokeRandomSource;
-    int canvasRotation {0};
+    qreal canvasRotation {0};
     bool canvasMirroredH {false};
+    bool canvasMirroredV {false};
 
     boost::optional<qreal> drawingAngleOverride;
     bool sanityIsRegistered = false;
 
     struct DirectionHistoryInfo {
         DirectionHistoryInfo() {}
         DirectionHistoryInfo(qreal _totalDistance,
                              int _currentDabSeqNo,
                              qreal _lastAngle,
                              QPointF _lastPosition,
                              boost::optional<qreal> _lockedDrawingAngle)
             : totalStrokeLength(_totalDistance),
               currentDabSeqNo(_currentDabSeqNo),
               lastAngle(_lastAngle),
               lastPosition(_lastPosition),
               lockedDrawingAngle(_lockedDrawingAngle)
         {
         }
 
         qreal totalStrokeLength = 0.0;
         int currentDabSeqNo = 0;
         qreal lastAngle = 0.0;
         QPointF lastPosition;
         boost::optional<qreal> lockedDrawingAngle;
     };
     boost::optional<DirectionHistoryInfo> directionHistoryInfo;
 
     int levelOfDetail;
 
     void registerDistanceInfo(KisDistanceInformation *di) {
         directionHistoryInfo = DirectionHistoryInfo(di->scalarDistanceApprox(),
                                                     di->currentDabSeqNo(),
                                                     di->lastDrawingAngle(),
                                                     di->lastPosition(),
                                                     di->lockedDrawingAngleOptional());
 
 
         KIS_SAFE_ASSERT_RECOVER_NOOP(!sanityIsRegistered);
         sanityIsRegistered = true;
     }
 
     void unregisterDistanceInfo() {
         sanityIsRegistered = false;
     }
 };
 
 KisPaintInformation::DistanceInformationRegistrar::
 DistanceInformationRegistrar(KisPaintInformation *_p, KisDistanceInformation *distanceInfo)
     : p(_p)
 {
     p->d->registerDistanceInfo(distanceInfo);
 }
 
 KisPaintInformation::DistanceInformationRegistrar::DistanceInformationRegistrar(KisPaintInformation::DistanceInformationRegistrar &&rhs)
     : p(0)
 {
     std::swap(p, rhs.p);
 }
 
 KisPaintInformation::DistanceInformationRegistrar::
 ~DistanceInformationRegistrar()
 {
     if (p) {
         p->d->unregisterDistanceInfo();
     }
 }
 
 KisPaintInformation::KisPaintInformation(const QPointF & pos,
                                          qreal pressure,
                                          qreal xTilt, qreal yTilt,
                                          qreal rotation,
                                          qreal tangentialPressure,
                                          qreal perspective,
                                          qreal time,
                                          qreal speed)
     : d(new Private(pos,
                     pressure,
                     xTilt, yTilt,
                     rotation,
                     tangentialPressure,
                     perspective,
                     time,
                     speed,
                     false))
 {
 }
 
 KisPaintInformation::KisPaintInformation(const QPointF & pos,
                                          qreal pressure,
                                          qreal xTilt,
                                          qreal yTilt,
                                          qreal rotation)
     : d(new Private(pos,
                     pressure,
                     xTilt, yTilt,
                     rotation,
                     0.0,
                     1.0,
                     0.0,
                     0.0,
                     false))
 {
 
 }
 
 KisPaintInformation::KisPaintInformation(const QPointF &pos,
                                          qreal pressure)
     : d(new Private(pos,
                     pressure,
                     0.0, 0.0,
                     0.0,
                     0.0,
                     1.0,
                     0.0,
                     0.0,
                     false))
 {
 }
 
 KisPaintInformation::KisPaintInformation(const KisPaintInformation& rhs)
     : d(new Private(*rhs.d))
 {
 }
 
 void KisPaintInformation::operator=(const KisPaintInformation & rhs)
 {
     *d = *rhs.d;
 }
 
 KisPaintInformation::~KisPaintInformation()
 {
     delete d;
 }
 
 bool KisPaintInformation::isHoveringMode() const
 {
     return d->isHoveringMode;
 }
 
 
 KisPaintInformation
 KisPaintInformation::createHoveringModeInfo(const QPointF &pos,
         qreal pressure,
         qreal xTilt, qreal yTilt,
         qreal rotation,
         qreal tangentialPressure,
         qreal perspective,
         qreal speed,
-        int canvasrotation,
-        bool canvasMirroredH)
+        qreal canvasrotation,
+        bool canvasMirroredH,
+        bool canvasMirroredV)
 {
     KisPaintInformation info(pos,
                              pressure,
                              xTilt, yTilt,
                              rotation,
                              tangentialPressure,
                              perspective, 0, speed);
     info.d->isHoveringMode = true;
     info.d->canvasRotation = canvasrotation;
     info.d->canvasMirroredH = canvasMirroredH;
+    info.d->canvasMirroredV = canvasMirroredV;
     return info;
 }
 
 
-int KisPaintInformation::canvasRotation() const
+qreal KisPaintInformation::canvasRotation() const
 {
     return d->canvasRotation;
 }
 
-void KisPaintInformation::setCanvasRotation(int rotation)
+void KisPaintInformation::setCanvasRotation(qreal rotation)
 {
-    if (rotation < 0) {
-        d->canvasRotation= 360- abs(rotation % 360);
-    } else {
-        d->canvasRotation= rotation % 360;
-    }
-
+    d->canvasRotation = normalizeAngleDegrees(rotation);
 }
 
 bool KisPaintInformation::canvasMirroredH() const
 {
     return d->canvasMirroredH;
 }
 
-void KisPaintInformation::setCanvasHorizontalMirrorState(bool mir)
+void KisPaintInformation::setCanvasMirroredH(bool value)
 {
-    d->canvasMirroredH = mir;
+    d->canvasMirroredH = value;
+}
 
+bool KisPaintInformation::canvasMirroredV() const
+{
+    return d->canvasMirroredV;
+}
+
+void KisPaintInformation::setCanvasMirroredV(bool value)
+{
+    d->canvasMirroredV = value;
 }
 
 void KisPaintInformation::toXML(QDomDocument&, QDomElement& e) const
 {
     // hovering mode infos are not supposed to be saved
     KIS_ASSERT_RECOVER_NOOP(!d->isHoveringMode);
 
     e.setAttribute("pointX", QString::number(pos().x(), 'g', 15));
     e.setAttribute("pointY", QString::number(pos().y(), 'g', 15));
     e.setAttribute("pressure", QString::number(pressure(), 'g', 15));
     e.setAttribute("xTilt", QString::number(xTilt(), 'g', 15));
     e.setAttribute("yTilt", QString::number(yTilt(), 'g', 15));
     e.setAttribute("rotation", QString::number(rotation(), 'g', 15));
     e.setAttribute("tangentialPressure", QString::number(tangentialPressure(), 'g', 15));
     e.setAttribute("perspective", QString::number(perspective(), 'g', 15));
     e.setAttribute("time", QString::number(d->time, 'g', 15));
     e.setAttribute("speed", QString::number(d->speed, 'g', 15));
 }
 
 KisPaintInformation KisPaintInformation::fromXML(const QDomElement& e)
 {
     qreal pointX = qreal(KisDomUtils::toDouble(e.attribute("pointX", "0.0")));
     qreal pointY = qreal(KisDomUtils::toDouble(e.attribute("pointY", "0.0")));
     qreal pressure = qreal(KisDomUtils::toDouble(e.attribute("pressure", "0.0")));
     qreal rotation = qreal(KisDomUtils::toDouble(e.attribute("rotation", "0.0")));
     qreal tangentialPressure = qreal(KisDomUtils::toDouble(e.attribute("tangentialPressure", "0.0")));
     qreal perspective = qreal(KisDomUtils::toDouble(e.attribute("perspective", "0.0")));
     qreal xTilt = qreal(KisDomUtils::toDouble(e.attribute("xTilt", "0.0")));
     qreal yTilt = qreal(KisDomUtils::toDouble(e.attribute("yTilt", "0.0")));
     qreal time = KisDomUtils::toDouble(e.attribute("time", "0"));
     qreal speed = KisDomUtils::toDouble(e.attribute("speed", "0"));
 
     return KisPaintInformation(QPointF(pointX, pointY), pressure, xTilt, yTilt,
                                rotation, tangentialPressure, perspective, time, speed);
 }
 
 const QPointF& KisPaintInformation::pos() const
 {
     return d->pos;
 }
 
 void KisPaintInformation::setPos(const QPointF& p)
 {
     d->pos = p;
 }
 
 qreal KisPaintInformation::pressure() const
 {
     return d->pressure;
 }
 
 void KisPaintInformation::setPressure(qreal p)
 {
     d->pressure = p;
 }
 
 qreal KisPaintInformation::xTilt() const
 {
     return d->xTilt;
 }
 
 qreal KisPaintInformation::yTilt() const
 {
     return d->yTilt;
 }
 
 void KisPaintInformation::overrideDrawingAngle(qreal angle)
 {
     d->drawingAngleOverride = angle;
 }
 
 qreal KisPaintInformation::drawingAngleSafe(const KisDistanceInformation &distance) const
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!d->directionHistoryInfo, 0.0);
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(distance.hasLastDabInformation(), 0.0);
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!d->drawingAngleOverride, 0.0);
 
     return KisAlgebra2D::directionBetweenPoints(distance.lastPosition(),
                                                 pos(),
                                                 distance.lastDrawingAngle());
 
 }
 
 KisPaintInformation::DistanceInformationRegistrar
 KisPaintInformation::registerDistanceInformation(KisDistanceInformation *distance)
 {
     return DistanceInformationRegistrar(this, distance);
 }
 
 qreal KisPaintInformation::drawingAngle(bool considerLockedAngle) const
 {
     if (d->drawingAngleOverride) return *d->drawingAngleOverride;
 
     if (!d->directionHistoryInfo) {
         warnKrita << "KisPaintInformation::drawingAngleSafe()" << "DirectionHistoryInfo object is not available";
         return 0.0;
     }
 
     if (considerLockedAngle &&
         d->directionHistoryInfo->lockedDrawingAngle) {
 
         return *d->directionHistoryInfo->lockedDrawingAngle;
     }
 
     // If the start and end positions are the same, we can't compute an angle. In that case, use the
     // provided default.
     return KisAlgebra2D::directionBetweenPoints(d->directionHistoryInfo->lastPosition,
                                                 pos(),
                                                 d->directionHistoryInfo->lastAngle);
 }
 
 QPointF KisPaintInformation::drawingDirectionVector() const
 {
     const qreal angle = drawingAngle(false);
     return QPointF(cos(angle), sin(angle));
 }
 
 qreal KisPaintInformation::drawingDistance() const
 {
     if (!d->directionHistoryInfo) {
         warnKrita << "KisPaintInformation::drawingDistance()" << "DirectionHistoryInfo object is not available";
         return 1.0;
     }
 
     QVector2D diff(pos() - d->directionHistoryInfo->lastPosition);
     qreal length = diff.length();
 
     if (d->levelOfDetail) {
         length *= KisLodTransform::lodToInvScale(d->levelOfDetail);
     }
 
     return length;
 }
 
 qreal KisPaintInformation::drawingSpeed() const
 {
     return d->speed;
 }
 
 qreal KisPaintInformation::rotation() const
 {
     return d->rotation;
 }
 
 qreal KisPaintInformation::tangentialPressure() const
 {
     return d->tangentialPressure;
 }
 
 qreal KisPaintInformation::perspective() const
 {
     return d->perspective;
 }
 
 qreal KisPaintInformation::currentTime() const
 {
     return d->time;
 }
 
 int KisPaintInformation::currentDabSeqNo() const
 {
     if (!d->directionHistoryInfo) {
         warnKrita << "KisPaintInformation::currentDabSeqNo()" << "DirectionHistoryInfo object is not available";
         return 0;
     }
 
     return d->directionHistoryInfo->currentDabSeqNo;
 }
 
 qreal KisPaintInformation::totalStrokeLength() const
 {
     if (!d->directionHistoryInfo) {
         warnKrita << "KisPaintInformation::totalStrokeLength()" << "DirectionHistoryInfo object is not available";
         return 0;
     }
 
     return d->directionHistoryInfo->totalStrokeLength;
 }
 
 KisRandomSourceSP KisPaintInformation::randomSource() const
 {
     if (!d->randomSource) {
         qWarning() << "Accessing uninitialized random source!";
         d->randomSource = new KisRandomSource();
     }
 
     return d->randomSource;
 }
 
 void KisPaintInformation::setRandomSource(KisRandomSourceSP value)
 {
     d->randomSource = value;
 }
 
 KisPerStrokeRandomSourceSP KisPaintInformation::perStrokeRandomSource() const
 {
     if (!d->perStrokeRandomSource) {
         qWarning() << "Accessing uninitialized per stroke random source!";
         d->perStrokeRandomSource = new KisPerStrokeRandomSource();
     }
 
     return d->perStrokeRandomSource;
 }
 
 void KisPaintInformation::setPerStrokeRandomSource(KisPerStrokeRandomSourceSP value)
 {
     d->perStrokeRandomSource = value;
 }
 
 void KisPaintInformation::setLevelOfDetail(int levelOfDetail)
 {
     d->levelOfDetail = levelOfDetail;
 }
 
 QDebug operator<<(QDebug dbg, const KisPaintInformation &info)
 {
 #ifdef NDEBUG
     Q_UNUSED(info);
 #else
     dbg.nospace() << "Position: " << info.pos();
     dbg.nospace() << ", Pressure: " << info.pressure();
     dbg.nospace() << ", X Tilt: " << info.xTilt();
     dbg.nospace() << ", Y Tilt: " << info.yTilt();
     dbg.nospace() << ", Rotation: " << info.rotation();
     dbg.nospace() << ", Tangential Pressure: " << info.tangentialPressure();
     dbg.nospace() << ", Perspective: " << info.perspective();
     dbg.nospace() << ", Drawing Angle: " << info.drawingAngle();
     dbg.nospace() << ", Drawing Speed: " << info.drawingSpeed();
     dbg.nospace() << ", Drawing Distance: " << info.drawingDistance();
     dbg.nospace() << ", Time: " << info.currentTime();
 #endif
     return dbg.space();
 }
 
 KisPaintInformation KisPaintInformation::mixOnlyPosition(qreal t, const KisPaintInformation& mixedPi, const KisPaintInformation& basePi)
 {
     QPointF pt = (1 - t) * mixedPi.pos() + t * basePi.pos();
     return mixImpl(pt, t, mixedPi, basePi, true, false);
 }
 
 KisPaintInformation KisPaintInformation::mix(qreal t, const KisPaintInformation& pi1, const KisPaintInformation& pi2)
 {
     QPointF pt = (1 - t) * pi1.pos() + t * pi2.pos();
     return mix(pt, t, pi1, pi2);
 }
 
 KisPaintInformation KisPaintInformation::mix(const QPointF& p, qreal t, const KisPaintInformation& pi1, const KisPaintInformation& pi2)
 {
     return mixImpl(p, t, pi1, pi2, false, true);
 }
 
 KisPaintInformation KisPaintInformation::mixWithoutTime(qreal t, const KisPaintInformation& pi1, const KisPaintInformation& pi2)
 {
     QPointF pt = (1 - t) * pi1.pos() + t * pi2.pos();
     return mixWithoutTime(pt, t, pi1, pi2);
 }
 
 KisPaintInformation KisPaintInformation::mixWithoutTime(const QPointF& p, qreal t, const KisPaintInformation& pi1, const KisPaintInformation& pi2)
 {
     return mixImpl(p, t, pi1, pi2, false, false);
 }
 
 void KisPaintInformation::mixOtherOnlyPosition(qreal t, const KisPaintInformation& other)
 {
     QPointF pt = (1 - t) * other.pos() + t * this->pos();
     this->mixOtherImpl(pt, t, other, true, false);
 }
 
 void KisPaintInformation::mixOtherWithoutTime(qreal t, const KisPaintInformation& other)
 {
     QPointF pt = (1 - t) * other.pos() + t * this->pos();
     this->mixOtherImpl(pt, t, other, false, false);
 }
 
 KisPaintInformation KisPaintInformation::mixImpl(const QPointF &p, qreal t, const KisPaintInformation &pi1, const KisPaintInformation &pi2, bool posOnly, bool mixTime)
 {
     KisPaintInformation result(pi2);
     result.mixOtherImpl(p, t, pi1, posOnly, mixTime);
     return result;
 }
 
 void KisPaintInformation::mixOtherImpl(const QPointF &p, qreal t, const KisPaintInformation &other, bool posOnly, bool mixTime)
 {
     if (posOnly) {
         this->d->pos = p;
         this->d->isHoveringMode = false;
         this->d->levelOfDetail = 0;
         return;
     }
     else {
         qreal pressure = (1 - t) * other.pressure() + t * this->pressure();
         qreal xTilt = (1 - t) * other.xTilt() + t * this->xTilt();
         qreal yTilt = (1 - t) * other.yTilt() + t * this->yTilt();
 
         qreal rotation = other.rotation();
 
         if (other.rotation() != this->rotation()) {
             qreal a1 = kisDegreesToRadians(other.rotation());
             qreal a2 = kisDegreesToRadians(this->rotation());
             qreal distance = shortestAngularDistance(a2, a1);
 
             rotation = kisRadiansToDegrees(incrementInDirection(a1, t * distance, a2));
         }
 
         qreal tangentialPressure = (1 - t) * other.tangentialPressure() + t * this->tangentialPressure();
         qreal perspective = (1 - t) * other.perspective() + t * this->perspective();
         qreal time = mixTime ? ((1 - t) * other.currentTime() + t * this->currentTime()) : this->currentTime();
         qreal speed = (1 - t) * other.drawingSpeed() + t * this->drawingSpeed();
 
         KIS_ASSERT_RECOVER_NOOP(other.isHoveringMode() == this->isHoveringMode());
         *(this->d) = Private(p, pressure, xTilt, yTilt, rotation, tangentialPressure, perspective, time, speed, other.isHoveringMode());
+        this->d->canvasRotation = other.d->canvasRotation;
+        this->d->canvasMirroredH = other.d->canvasMirroredH;
+        this->d->canvasMirroredV = other.d->canvasMirroredV;
         this->d->randomSource = other.d->randomSource;
         this->d->perStrokeRandomSource = other.d->perStrokeRandomSource;
         // this->d->isHoveringMode = other.isHoveringMode();
         this->d->levelOfDetail = other.d->levelOfDetail;
     }
 }
 
 qreal KisPaintInformation::tiltDirection(const KisPaintInformation& info, bool normalize)
 {
     qreal xTilt = info.xTilt();
     qreal yTilt = info.yTilt();
     // radians -PI, PI
     qreal tiltDirection = atan2(-xTilt, yTilt);
     // if normalize is true map to 0.0..1.0
     return normalize ? (tiltDirection / (2 * M_PI) + 0.5) : tiltDirection;
 }
 
 qreal KisPaintInformation::tiltElevation(const KisPaintInformation& info, qreal maxTiltX, qreal maxTiltY, bool normalize)
 {
     qreal xTilt = qBound(qreal(-1.0), info.xTilt() / maxTiltX , qreal(1.0));
     qreal yTilt = qBound(qreal(-1.0), info.yTilt() / maxTiltY , qreal(1.0));
 
     qreal e;
     if (fabs(xTilt) > fabs(yTilt)) {
         e = sqrt(qreal(1.0) + yTilt * yTilt);
     } else {
         e = sqrt(qreal(1.0) + xTilt * xTilt);
     }
 
     qreal cosAlpha    = sqrt(xTilt * xTilt + yTilt * yTilt) / e;
     qreal tiltElevation = acos(cosAlpha); // in radians in [0, 0.5 * PI]
 
     // mapping to 0.0..1.0 if normalize is true
     return normalize ? (tiltElevation / (M_PI * qreal(0.5))) : tiltElevation;
 }
diff --git a/libs/image/brushengine/kis_paint_information.h b/libs/image/brushengine/kis_paint_information.h
index bc1067d38d..baa1bc0f0b 100644
--- a/libs/image/brushengine/kis_paint_information.h
+++ b/libs/image/brushengine/kis_paint_information.h
@@ -1,311 +1,324 @@
 /*
  *  Copyright (c) 2004 Cyrille Berger <cberger@cberger.net>
  *  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_INFORMATION_
 #define _KIS_PAINT_INFORMATION_
 
 #include <kis_debug.h>
 #include <QTime>
 
 #include "kis_global.h"
 #include "kritaimage_export.h"
 #include <kis_distance_information.h>
 #include "kis_random_source.h"
 #include "KisPerStrokeRandomSource.h"
 #include "kis_spacing_information.h"
 #include "kis_timing_information.h"
 
 
 class QDomDocument;
 class QDomElement;
 class KisDistanceInformation;
 
 
 /**
  * KisPaintInformation contains information about the input event that
  * causes the brush action to happen to the brush engine's paint
  * methods.
  *
  * XXX: we directly pass the KoPointerEvent x and y tilt to
  * KisPaintInformation, and their range is -60 to +60!
  *
  * @param pos: the position of the paint event in subpixel accuracy
  * @param pressure: the pressure of the stylus
  * @param xTilt: the angle between the device (a pen, for example) and
  * the perpendicular in the direction of the x axis. Positive values
  * are towards the bottom of the tablet. The angle is within the range
  * 0 to 1
  * @param yTilt: the angle between the device (a pen, for example) and
  * the perpendicular in the direction of the y axis. Positive values
  * are towards the bottom of the tablet. The angle is within the range
  * 0 to .
  * @param movement: current position minus the last position of the call to paintAt
  * @param rotation
  * @param tangentialPressure
  * @param perspective
  **/
 class KRITAIMAGE_EXPORT KisPaintInformation
 {
 public:
     /**
      * Note, that this class is relied on the compiler optimization
      * of the return value. So if it doesn't work for some reason,
      * please implement a proper copy c-tor
      */
     class KRITAIMAGE_EXPORT DistanceInformationRegistrar
     {
     public:
         DistanceInformationRegistrar(KisPaintInformation *_p, KisDistanceInformation *distanceInfo);
         DistanceInformationRegistrar(const DistanceInformationRegistrar &rhs) = delete;
         DistanceInformationRegistrar(DistanceInformationRegistrar &&rhs);
         ~DistanceInformationRegistrar();
     private:
         KisPaintInformation *p;
     };
 
 public:
 
     /**
      * Create a new KisPaintInformation object.
      */
     KisPaintInformation(const QPointF & pos,
                         qreal pressure,
                         qreal xTilt,
                         qreal yTilt,
                         qreal rotation,
                         qreal tangentialPressure,
                         qreal perspective,
                         qreal time,
                         qreal speed);
 
     KisPaintInformation(const QPointF & pos,
                         qreal pressure,
                         qreal xTilt,
                         qreal yTilt,
                         qreal rotation);
 
     KisPaintInformation(const QPointF & pos = QPointF(),
                         qreal pressure = PRESSURE_DEFAULT);
 
     KisPaintInformation(const KisPaintInformation& rhs);
 
     void operator=(const KisPaintInformation& rhs);
 
     ~KisPaintInformation();
 
     template <class PaintOp>
     void paintAt(PaintOp &op, KisDistanceInformation *distanceInfo) {
         KisSpacingInformation spacingInfo;
         KisTimingInformation timingInfo;
         {
             DistanceInformationRegistrar r = registerDistanceInformation(distanceInfo);
             spacingInfo = op.paintAt(*this);
             timingInfo = op.updateTimingImpl(*this);
 
             // Initiate the process of locking the drawing angle. The locked value will
             // always be present in the internals, but it will be requested but the users
             // with a special parameter of drawingAngle() only.
             if (!this->isHoveringMode()) {
                 distanceInfo->lockCurrentDrawingAngle(*this);
             }
         }
 
         distanceInfo->registerPaintedDab(*this, spacingInfo, timingInfo);
     }
 
     const QPointF& pos() const;
     void setPos(const QPointF& p);
 
     /// The pressure of the value (from 0.0 to 1.0)
     qreal pressure() const;
 
     /// Set the pressure
     void setPressure(qreal p);
 
     /// The tilt of the pen on the horizontal axis (from 0.0 to 1.0)
     qreal xTilt() const;
 
     /// The tilt of the pen on the vertical axis (from 0.0 to 1.0)
     qreal yTilt() const;
 
     /// XXX !!! :-| Please add dox!
     void overrideDrawingAngle(qreal angle);
 
     /// XXX !!! :-| Please add dox!
     qreal drawingAngleSafe(const KisDistanceInformation &distance) const;
 
     /**
      * Causes the specified distance information to be temporarily registered with this
      * KisPaintInformation object, so that the KisPaintInformation can compute certain values that
      * may be needed at painting time, such as the drawing direction. When the returned object is
      * destroyed, the KisDistanceInformation will be unregistered. At most one
      * KisDistanceInformation can be registered with a given KisPaintInformation at a time.
      */
     DistanceInformationRegistrar registerDistanceInformation(KisDistanceInformation *distance);
 
     /**
      * Current brush direction computed from the cursor movement
      *
      * WARNING: this method is available *only* inside paintAt() call,
      * that is when the distance information is registered.
      */
     qreal drawingAngle(bool considerLockedAngle = false) const;
 
     /**
      * Current brush direction vector computed from the cursor movement
      *
      * WARNING: this method is available *only* inside paintAt() call,
      * that is when the distance information is registered.
      */
     QPointF drawingDirectionVector() const;
 
     /**
      * Current brush speed computed from the cursor movement
      *
      * WARNING: this method is available *only* inside paintAt() call,
      * that is when the distance information is registered.
      */
     qreal drawingSpeed() const;
 
     /**
      * Current distance from the previous dab
      *
      * WARNING: this method is available *only* inside paintAt() call,
      * that is when the distance information is registered.
      */
     qreal drawingDistance() const;
 
     /// rotation as given by the tablet event
     qreal rotation() const;
 
     /// tangential pressure (i.e., rate for an airbrush device)
     qreal tangentialPressure() const;
 
     /// reciprocal of distance on the perspective grid
     qreal perspective() const;
 
     /// Number of ms since the beginning of the stroke
     qreal currentTime() const;
 
     /// Number of dabs painted since the beginning of the stroke
     int currentDabSeqNo() const;
 
     /// The length of the stroke **before** painting the current dab
     qreal totalStrokeLength() const;
 
     // random source for generating in-stroke effects
     KisRandomSourceSP randomSource() const;
 
     // the stroke should initialize random source of all the used
     // paint info objects, otherwise it shows a warning
     void setRandomSource(KisRandomSourceSP value);
 
     // random source for generating in-stroke effects, generates one(!) value per stroke
     KisPerStrokeRandomSourceSP perStrokeRandomSource() const;
 
     // the stroke should initialize per stroke random source of all the used
     // paint info objects, otherwise it shows a warning
     void setPerStrokeRandomSource(KisPerStrokeRandomSourceSP value);
 
     // set level of detail which info object has been generated for
     void setLevelOfDetail(int levelOfDetail);
 
     /**
      * The paint information may be generated not only during real
      * stroke when the actual painting is happening, but also when the
      * cursor is hovering the canvas. In this mode some of the sensors
      * work a bit differently. The most outstanding example is Fuzzy
      * sensor, which returns unit value in this mode, otherwise it is
      * too irritating for a user.
      *
      * This value is true only for paint information objects created with
      * createHoveringModeInfo() constructor.
      *
      * \see createHoveringModeInfo()
      */
     bool isHoveringMode() const;
 
     /**
      * Create a fake info object with isHoveringMode() property set to
      * true.
      *
      * \see isHoveringMode()
      */
     static KisPaintInformation createHoveringModeInfo(const QPointF &pos,
             qreal pressure = PRESSURE_DEFAULT,
             qreal xTilt = 0.0, qreal yTilt = 0.0,
             qreal rotation = 0.0,
             qreal tangentialPressure = 0.0,
             qreal perspective = 1.0,
 	        qreal speed = 0.0,
-            int canvasrotation = 0,
-            bool canvasMirroredH = false);
+            qreal canvasrotation = 0,
+            bool canvasMirroredH = false,
+            bool canvasMirroredV = false);
+
     /**
-     *Returns the canvas rotation if that has been given to the kispaintinformation.
+     * Returns the canvas rotation if that has been given to the kispaintinformation.
      */
-    int canvasRotation() const;
+    qreal canvasRotation() const;
+
     /**
-     *set the canvas rotation.
+     * Set the canvas rotation.
      */
-    void setCanvasRotation(int rotation);
+    void setCanvasRotation(qreal rotation);
 
-    /*
-     *Whether the canvas is mirrored for the paint-operation.
+    /**
+     * Whether the canvas is horizontally mirrored for the paint-operation.
      */
     bool canvasMirroredH() const;
 
-    /*
-     *Set whether the canvas is mirrored for the paint-operation.
+    /**
+     * Set whether the canvas is horizontally mirrored for the paint-operation.
+     */
+    void setCanvasMirroredH(bool value);
+
+    /**
+     * Whether the canvas is vertically mirrored for the paint-operation.
+     */
+    bool canvasMirroredV() const;
+
+    /**
+     * Set whether the canvas is vertically mirrored for the paint-operation.
      */
-    void setCanvasHorizontalMirrorState(bool mir);
+    void setCanvasMirroredV(bool value);
 
     void toXML(QDomDocument&, QDomElement&) const;
 
     static KisPaintInformation fromXML(const QDomElement&);
 
     // TODO: Refactor the static mix functions to non-static in-place mutation
     //       versions like mixOtherOnlyPosition and mixOtherWithoutTime.
     // Heap allocation on Windows is awfully slow and will fragment the memory
     // badly. Since KisPaintInformation allocates on the heap, we should re-use
     // existing instance whenever possible, especially in loops.
     // Ref: https://phabricator.kde.org/D6578
 
     /// (1-t) * p1 + t * p2
     static KisPaintInformation mixOnlyPosition(qreal t, const KisPaintInformation& mixedPi, const KisPaintInformation& basePi);
     static KisPaintInformation mix(const QPointF& p, qreal t, const KisPaintInformation& p1, const KisPaintInformation& p2);
     static KisPaintInformation mix(qreal t, const KisPaintInformation& pi1, const KisPaintInformation& pi2);
     static KisPaintInformation mixWithoutTime(const QPointF &p, qreal t, const KisPaintInformation &p1, const KisPaintInformation &p2);
     static KisPaintInformation mixWithoutTime(qreal t, const KisPaintInformation &pi1, const KisPaintInformation &pi2);
     void mixOtherOnlyPosition(qreal t, const KisPaintInformation& other);
     void mixOtherWithoutTime(qreal t, const KisPaintInformation& other);
     static qreal tiltDirection(const KisPaintInformation& info, bool normalize = true);
     static qreal tiltElevation(const KisPaintInformation& info, qreal maxTiltX = 60.0, qreal maxTiltY = 60.0, bool normalize = true);
 
 private:
     static KisPaintInformation mixImpl(const QPointF &p, qreal t, const KisPaintInformation &p1, const KisPaintInformation &p2, bool posOnly, bool mixTime);
     void mixOtherImpl(const QPointF &p, qreal t, const KisPaintInformation &other, bool posOnly, bool mixTime);
 
 private:
     struct Private;
     Private* const d;
 };
 
 KRITAIMAGE_EXPORT QDebug operator<<(QDebug debug, const KisPaintInformation& info);
 
 
 #endif
diff --git a/libs/image/brushengine/kis_paintop_settings.cpp b/libs/image/brushengine/kis_paintop_settings.cpp
index 2c7aba0e1a..ce3b06a39d 100644
--- a/libs/image/brushengine/kis_paintop_settings.cpp
+++ b/libs/image/brushengine/kis_paintop_settings.cpp
@@ -1,529 +1,510 @@
 /*
  *  Copyright (c) 2007 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2008 Lukáš Tvrdý <lukast.dev@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 <brushengine/kis_paintop_settings.h>
 
 #include <QImage>
 #include <QColor>
 #include <QPointer>
 
 #include <KoPointerEvent.h>
 #include <KoColor.h>
 #include <KoCompositeOpRegistry.h>
 #include <KoViewConverter.h>
 
 #include "kis_paint_layer.h"
 #include "kis_image.h"
 #include "kis_painter.h"
 #include "kis_paint_device.h"
 #include "kis_paintop_registry.h"
 #include "kis_timing_information.h"
 #include <brushengine/kis_paint_information.h>
 #include "kis_paintop_config_widget.h"
 #include <brushengine/kis_paintop_preset.h>
 #include "kis_paintop_settings_update_proxy.h"
 #include <time.h>
 #include <kis_types.h>
 #include <kis_signals_blocker.h>
 
 #include <brushengine/kis_locked_properties_server.h>
 #include <brushengine/kis_locked_properties_proxy.h>
 
 #include "KisPaintopSettingsIds.h"
 
 
 struct Q_DECL_HIDDEN KisPaintOpSettings::Private {
     Private()
         : disableDirtyNotifications(false)
     {}
 
     QPointer<KisPaintOpConfigWidget> settingsWidget;
     QString modelName;
     KisPaintOpPresetWSP preset;
     QList<KisUniformPaintOpPropertyWSP> uniformProperties;
 
     bool disableDirtyNotifications;
 
     class DirtyNotificationsLocker {
     public:
         DirtyNotificationsLocker(KisPaintOpSettings::Private *d)
             : m_d(d),
               m_oldNotificationsState(d->disableDirtyNotifications)
         {
             m_d->disableDirtyNotifications = true;
         }
 
         ~DirtyNotificationsLocker() {
             m_d->disableDirtyNotifications = m_oldNotificationsState;
         }
 
     private:
         KisPaintOpSettings::Private *m_d;
         bool m_oldNotificationsState;
         Q_DISABLE_COPY(DirtyNotificationsLocker)
     };
 
     KisPaintopSettingsUpdateProxy* updateProxyNoCreate() const {
         auto presetSP = preset.toStrongRef();
         return presetSP ? presetSP->updateProxyNoCreate() : 0;
     }
 
     KisPaintopSettingsUpdateProxy* updateProxyCreate() const {
         auto presetSP = preset.toStrongRef();
         return presetSP ? presetSP->updateProxy() : 0;
     }
 };
 
 
 KisPaintOpSettings::KisPaintOpSettings()
     : d(new Private)
 {
     d->preset = 0;
 }
 
 KisPaintOpSettings::~KisPaintOpSettings()
 {
 }
 
 KisPaintOpSettings::KisPaintOpSettings(const KisPaintOpSettings &rhs)
     : KisPropertiesConfiguration(rhs)
     , d(new Private)
 {
     d->settingsWidget = 0;
     d->preset = rhs.preset();
     d->modelName = rhs.modelName();
 }
 
 void KisPaintOpSettings::setOptionsWidget(KisPaintOpConfigWidget* widget)
 {
     d->settingsWidget = widget;
 }
 void KisPaintOpSettings::setPreset(KisPaintOpPresetWSP preset)
 {
     d->preset = preset;
 }
 KisPaintOpPresetWSP KisPaintOpSettings::preset() const
 {
     return d->preset;
 }
 
 bool KisPaintOpSettings::mousePressEvent(const KisPaintInformation &paintInformation, Qt::KeyboardModifiers modifiers, KisNodeWSP currentNode)
 {
     Q_UNUSED(modifiers);
     Q_UNUSED(currentNode);
     setRandomOffset(paintInformation);
     return true; // ignore the event by default
 }
 
 bool KisPaintOpSettings::mouseReleaseEvent()
 {
     return true; // ignore the event by default
 }
 
 void KisPaintOpSettings::setRandomOffset(const KisPaintInformation &paintInformation)
 {
     if (getBool("Texture/Pattern/Enabled")) {
         if (getBool("Texture/Pattern/isRandomOffsetX")) {
             setProperty("Texture/Pattern/OffsetX",
                         paintInformation.randomSource()->generate(0, KisPropertiesConfiguration::getInt("Texture/Pattern/MaximumOffsetX")));
         }
         if (getBool("Texture/Pattern/isRandomOffsetY")) {
             setProperty("Texture/Pattern/OffsetY",
                         paintInformation.randomSource()->generate(0, KisPropertiesConfiguration::getInt("Texture/Pattern/MaximumOffsetY")));
 
         }
     }
 
 }
 
 bool KisPaintOpSettings::hasMaskingSettings() const
 {
     return getBool(KisPaintOpUtils::MaskingBrushEnabledTag, false);
 }
 
 KisPaintOpSettingsSP KisPaintOpSettings::createMaskingSettings() const
 {
     if (!hasMaskingSettings()) return KisPaintOpSettingsSP();
 
     const KoID pixelBrushId(KisPaintOpUtils::MaskingBrushPaintOpId, QString());
 
     KisPaintOpSettingsSP maskingSettings = KisPaintOpRegistry::instance()->settings(pixelBrushId);
     this->getPrefixedProperties(KisPaintOpUtils::MaskingBrushPresetPrefix, maskingSettings);
 
     const bool useMasterSize = this->getBool(KisPaintOpUtils::MaskingBrushUseMasterSizeTag, true);
     if (useMasterSize) {
         const qreal masterSizeCoeff = getDouble(KisPaintOpUtils::MaskingBrushMasterSizeCoeffTag, 1.0);
         maskingSettings->setPaintOpSize(masterSizeCoeff * paintOpSize());
     }
 
     return maskingSettings;
 }
 
 QString KisPaintOpSettings::maskingBrushCompositeOp() const
 {
     return getString(KisPaintOpUtils::MaskingBrushCompositeOpTag, COMPOSITE_MULT);
 }
 
 KisPaintOpSettingsSP KisPaintOpSettings::clone() const
 {
     QString paintopID = getString("paintop");
     if (paintopID.isEmpty())
         return 0;
 
     KisPaintOpSettingsSP settings = KisPaintOpRegistry::instance()->settings(KoID(paintopID));
     QMapIterator<QString, QVariant> i(getProperties());
     while (i.hasNext()) {
         i.next();
         settings->setProperty(i.key(), QVariant(i.value()));
     }
     settings->setPreset(this->preset());
     return settings;
 }
 
 void KisPaintOpSettings::resetSettings(const QStringList &preserveProperties)
 {
     QStringList allKeys = preserveProperties;
     allKeys << "paintop";
 
     QHash<QString, QVariant> preserved;
     Q_FOREACH (const QString &key, allKeys) {
         if (hasProperty(key)) {
             preserved[key] = getProperty(key);
         }
     }
 
     clearProperties();
 
     for (auto it = preserved.constBegin(); it != preserved.constEnd(); ++it) {
         setProperty(it.key(), it.value());
     }
 }
 
 void KisPaintOpSettings::activate()
 {
 }
 
 void KisPaintOpSettings::setPaintOpOpacity(qreal value)
 {
     KisLockedPropertiesProxySP proxy(
                 KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(this));
 
     proxy->setProperty("OpacityValue", value);
 }
 
 void KisPaintOpSettings::setPaintOpFlow(qreal value)
 {
     KisLockedPropertiesProxySP proxy(
                 KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(this));
 
     proxy->setProperty("FlowValue", value);
 }
 
 void KisPaintOpSettings::setPaintOpCompositeOp(const QString &value)
 {
     KisLockedPropertiesProxySP proxy(
                 KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(this));
 
     proxy->setProperty("CompositeOp", value);
 }
 
 qreal KisPaintOpSettings::paintOpOpacity()
 {
     KisLockedPropertiesProxySP proxy = KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(this);
 
     return proxy->getDouble("OpacityValue", 1.0);
 }
 
 qreal KisPaintOpSettings::paintOpFlow()
 {
     KisLockedPropertiesProxySP proxy(
                 KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(this));
 
     return proxy->getDouble("FlowValue", 1.0);
 }
 
 QString KisPaintOpSettings::paintOpCompositeOp()
 {
     KisLockedPropertiesProxySP proxy(
                 KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(this));
 
     return proxy->getString("CompositeOp", COMPOSITE_OVER);
 }
 
 void KisPaintOpSettings::setEraserMode(bool value)
 {
     KisLockedPropertiesProxySP proxy(
                 KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(this));
 
     proxy->setProperty("EraserMode", value);
 }
 
 bool KisPaintOpSettings::eraserMode()
 {
     KisLockedPropertiesProxySP proxy(
                 KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(this));
 
     return proxy->getBool("EraserMode", false);
 }
 
 QString KisPaintOpSettings::effectivePaintOpCompositeOp()
 {
     return !eraserMode() ? paintOpCompositeOp() : COMPOSITE_ERASE;
 }
 
 qreal KisPaintOpSettings::savedEraserSize() const
 {
     return getDouble("SavedEraserSize", 0.0);
 }
 
 void KisPaintOpSettings::setSavedEraserSize(qreal value)
 {
     setProperty("SavedEraserSize", value);
     setPropertyNotSaved("SavedEraserSize");
 }
 
 qreal KisPaintOpSettings::savedBrushSize() const
 {
     return getDouble("SavedBrushSize", 0.0);
 }
 
 void KisPaintOpSettings::setSavedBrushSize(qreal value)
 {
     setProperty("SavedBrushSize", value);
     setPropertyNotSaved("SavedBrushSize");
 }
 
 qreal KisPaintOpSettings::savedEraserOpacity() const
 {
     return getDouble("SavedEraserOpacity", 0.0);
 }
 
 void KisPaintOpSettings::setSavedEraserOpacity(qreal value)
 {
     setProperty("SavedEraserOpacity", value);
     setPropertyNotSaved("SavedEraserOpacity");
 }
 
 qreal KisPaintOpSettings::savedBrushOpacity() const
 {
     return getDouble("SavedBrushOpacity", 0.0);
 }
 
 void KisPaintOpSettings::setSavedBrushOpacity(qreal value)
 {
     setProperty("SavedBrushOpacity", value);
     setPropertyNotSaved("SavedBrushOpacity");
 }
 
 QString KisPaintOpSettings::modelName() const
 {
     return d->modelName;
 }
 
 void KisPaintOpSettings::setModelName(const QString & modelName)
 {
     d->modelName = modelName;
 }
 
 KisPaintOpConfigWidget* KisPaintOpSettings::optionsWidget() const
 {
     if (d->settingsWidget.isNull())
         return 0;
 
     return d->settingsWidget.data();
 }
 
 bool KisPaintOpSettings::isValid() const
 {
     return true;
 }
 
 bool KisPaintOpSettings::isLoadable()
 {
     return isValid();
 }
 
 QString KisPaintOpSettings::indirectPaintingCompositeOp() const
 {
     return COMPOSITE_ALPHA_DARKEN;
 }
 
 bool KisPaintOpSettings::isAirbrushing() const
 {
     return getBool(AIRBRUSH_ENABLED, false);
 }
 
 qreal KisPaintOpSettings::airbrushInterval() const
 {
     qreal rate = getDouble(AIRBRUSH_RATE, 1.0);
     if (rate == 0.0) {
         return LONG_TIME;
     }
     else {
         return 1000.0 / rate;
     }
 }
 
 bool KisPaintOpSettings::useSpacingUpdates() const
 {
     return getBool(SPACING_USE_UPDATES, false);
 }
 
 bool KisPaintOpSettings::needsAsynchronousUpdates() const
 {
     return false;
 }
 
 QPainterPath KisPaintOpSettings::brushOutline(const KisPaintInformation &info, const OutlineMode &mode)
 {
     QPainterPath path;
     if (mode.isVisible) {
         path = ellipseOutline(10, 10, 1.0, 0);
 
         if (mode.showTiltDecoration) {
             path.addPath(makeTiltIndicator(info, QPointF(0.0, 0.0), 0.0, 2.0));
         }
 
         path.translate(info.pos());
     }
 
     return path;
 }
 
 QPainterPath KisPaintOpSettings::ellipseOutline(qreal width, qreal height, qreal scale, qreal rotation)
 {
     QPainterPath path;
     QRectF ellipse(0, 0, width * scale, height * scale);
     ellipse.translate(-ellipse.center());
     path.addEllipse(ellipse);
 
     QTransform m;
     m.reset();
     m.rotate(rotation);
     path = m.map(path);
     return path;
 }
 
 QPainterPath KisPaintOpSettings::makeTiltIndicator(KisPaintInformation const& info,
                                                    QPointF const& start, qreal maxLength, qreal angle)
 {
     if (maxLength == 0.0) maxLength = 50.0;
     maxLength = qMax(maxLength, 50.0);
     qreal const length = maxLength * (1 - info.tiltElevation(info, 60.0, 60.0, true));
     qreal const baseAngle = 360.0 - fmod(KisPaintInformation::tiltDirection(info, true) * 360.0 + 270.0, 360.0);
 
     QLineF guideLine = QLineF::fromPolar(length, baseAngle + angle);
     guideLine.translate(start);
     QPainterPath ret;
     ret.moveTo(guideLine.p1());
     ret.lineTo(guideLine.p2());
     guideLine.setAngle(baseAngle - angle);
     ret.lineTo(guideLine.p2());
     ret.lineTo(guideLine.p1());
     return ret;
 }
 
-void KisPaintOpSettings::setCanvasRotation(qreal angle)
-{
-    Private::DirtyNotificationsLocker locker(d.data());
-
-    setProperty("runtimeCanvasRotation", angle);
-    setPropertyNotSaved("runtimeCanvasRotation");
-}
-
-void KisPaintOpSettings::setCanvasMirroring(bool xAxisMirrored, bool yAxisMirrored)
-{
-    Private::DirtyNotificationsLocker locker(d.data());
-
-    setProperty("runtimeCanvasMirroredX", xAxisMirrored);
-    setPropertyNotSaved("runtimeCanvasMirroredX");
-
-    setProperty("runtimeCanvasMirroredY", yAxisMirrored);
-    setPropertyNotSaved("runtimeCanvasMirroredY");
-}
-
 void KisPaintOpSettings::setProperty(const QString & name, const QVariant & value)
 {
     if (value != KisPropertiesConfiguration::getProperty(name) &&
             !d->disableDirtyNotifications) {
         KisPaintOpPresetSP presetSP = preset().toStrongRef();
         if (presetSP) {
             presetSP->setDirty(true);
         }
     }
 
     KisPropertiesConfiguration::setProperty(name, value);
     onPropertyChanged();
 }
 
 
 void KisPaintOpSettings::onPropertyChanged()
 {
     KisPaintopSettingsUpdateProxy *proxy = d->updateProxyNoCreate();
 
     if (proxy) {
         proxy->notifySettingsChanged();
     }
 }
 
 bool KisPaintOpSettings::isLodUserAllowed(const KisPropertiesConfigurationSP config)
 {
     return config->getBool("lodUserAllowed", true);
 }
 
 void KisPaintOpSettings::setLodUserAllowed(KisPropertiesConfigurationSP config, bool value)
 {
     config->setProperty("lodUserAllowed", value);
 }
 
 bool KisPaintOpSettings::lodSizeThresholdSupported() const
 {
     return true;
 }
 
 qreal KisPaintOpSettings::lodSizeThreshold() const
 {
     return getDouble("lodSizeThreshold", 100.0);
 }
 
 void KisPaintOpSettings::setLodSizeThreshold(qreal value)
 {
     setProperty("lodSizeThreshold", value);
 }
 
 #include "kis_standard_uniform_properties_factory.h"
 
 QList<KisUniformPaintOpPropertySP> KisPaintOpSettings::uniformProperties(KisPaintOpSettingsSP settings)
 {
     QList<KisUniformPaintOpPropertySP> props =
             listWeakToStrong(d->uniformProperties);
 
 
     if (props.isEmpty()) {
         using namespace KisStandardUniformPropertiesFactory;
 
         props.append(createProperty(opacity, settings, d->updateProxyCreate()));
         props.append(createProperty(size, settings, d->updateProxyCreate()));
         props.append(createProperty(flow, settings, d->updateProxyCreate()));
 
         d->uniformProperties = listStrongToWeak(props);
     }
 
     return props;
 }
diff --git a/libs/image/brushengine/kis_paintop_settings.h b/libs/image/brushengine/kis_paintop_settings.h
index e884d7df74..7773fb8d2f 100644
--- a/libs/image/brushengine/kis_paintop_settings.h
+++ b/libs/image/brushengine/kis_paintop_settings.h
@@ -1,358 +1,349 @@
 /*
  *  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_PAINTOP_SETTINGS_H_
 #define KIS_PAINTOP_SETTINGS_H_
 
 #include "kis_types.h"
 #include "kritaimage_export.h"
 
 #include <QImage>
 #include <QScopedPointer>
 
 #include "kis_properties_configuration.h"
 #include <brushengine/kis_paint_information.h>
 #include <brushengine/kis_uniform_paintop_property.h>
 
 
 
 class KisPaintOpConfigWidget;
 class KisPaintopSettingsUpdateProxy;
 
 /**
  * Configuration property used to control whether airbrushing is enabled.
  */
 const QString AIRBRUSH_ENABLED = "PaintOpSettings/isAirbrushing";
 
 /**
  * Configuration property used to control airbrushing rate. The value should be in dabs per second.
  */
 const QString AIRBRUSH_RATE = "PaintOpSettings/rate";
 
 /**
  * Configuration property used to control whether airbrushing is configured to ignore distance-based
  * spacing.
  */
 const QString AIRBRUSH_IGNORE_SPACING = "PaintOpSettings/ignoreSpacing";
 
 /**
  * Configuration property used to control whether the spacing settings can be updated between
  * painted dabs.
  */
 const QString SPACING_USE_UPDATES = "PaintOpSettings/updateSpacingBetweenDabs";
 
 /**
  * This class is used to cache the settings for a paintop
  * between two creations. There is one KisPaintOpSettings per input device (mouse, tablet,
  * etc...).
  *
  * The settings may be stored in a preset. Note that if your
  * paintop's settings subclass has data that is not stored as a property, that data is not
  * saved and restored.
  *
  * The object also contains a pointer to its parent KisPaintOpPreset object.This is to control the DirtyPreset
  * property of KisPaintOpPreset. Whenever the settings are changed/modified from the original -- the preset is
  * set to dirty.
  */
 class KRITAIMAGE_EXPORT KisPaintOpSettings : public KisPropertiesConfiguration
 {
 
 public:
 
     KisPaintOpSettings();
     ~KisPaintOpSettings() override;
     KisPaintOpSettings(const KisPaintOpSettings &rhs);
 
     /**
      *
      */
     void setOptionsWidget(KisPaintOpConfigWidget* widget);
 
     /**
      * This function is called by a tool when the mouse is pressed. It's useful if
      * the paintop needs mouse interaction for instance in the case of the clone op.
      * If the tool is supposed to ignore the event, the paint op should return true
      * and if the tool is supposed to use the event, return false.
      * See kis_tool_freehand:tryPickByPaintOp()
      */
     virtual bool mousePressEvent(const KisPaintInformation &paintInformation, Qt::KeyboardModifiers modifiers, KisNodeWSP currentNode);
     /**
      * This function is called by a tool when the mouse is released. It's useful if
      * the paintop needs mouse interaction for instance in the case of the clone op.
      * If the tool is supposed to ignore the event, the paint op should return true
      * and if the tool is supposed to use the event, return false.
      */
     virtual bool mouseReleaseEvent();
     /**
      * Clone the current settings object. Override this if your settings instance doesn't
      * store everything as properties.
      */
     virtual KisPaintOpSettingsSP clone() const;
 
     /**
      * Removes all the settings from the object while keeping the paintop id,
      * which is loaded to the object by the factory
      */
     void resetSettings(const QStringList &preserveProperties = QStringList());
 
     /**
      * @return the node the paintop is working on.
      */
     KisNodeSP node() const;
 
     /**
      * Call this function when the paint op is selected or the tool is activated
      */
     virtual void activate();
 
     /**
      * XXX: Remove this after 2.0, when the paint operation (incremental/non incremental) will
      *      be completely handled in the paintop, not in the tool. This is a filthy hack to move
      *      the option to the right place, at least.
      * @return true if we paint incrementally, false if we paint like Photoshop. By default, paintops
      *      do not support non-incremental.
      */
     virtual bool paintIncremental() {
         return true;
     }
 
     /**
      * @return the composite op it to which the indirect painting device
      * should be initialized to. This is used by clone op to reset
      * the composite op to COMPOSITE_COPY
      */
     virtual QString indirectPaintingCompositeOp() const;
 
     /**
      * Whether this paintop wants to deposit paint even when not moving, i.e. the tool needs to
      * activate its timer. If this is true, painting updates need to be generated at regular
      * intervals even in the absence of input device events, e.g. when the cursor is not moving.
      *
      * The default implementation checks the property AIRBRUSH_ENABLED, defaulting to false if the
      * property is not found. This should be suitable for most paintops.
      */
     virtual bool isAirbrushing() const;
 
     /**
      * Indicates the minimum time interval that might be needed between airbrush dabs, in
      * milliseconds. A lower value means painting updates need to happen more frequently. This value
      * should be ignored if isAirbrushing() is false.
      *
      * The default implementation uses the property AIRBRUSH_RATE, defaulting to an interval of
      * one second if the property is not found. This should be suitable for most paintops.
      */
     virtual qreal airbrushInterval() const;
 
     /**
      * Indicates whether this configuration allows spacing information to be updated between painted
      * dabs during a stroke.
      */
     virtual bool useSpacingUpdates() const;
 
     /**
      * Indicates if the tool should call paintOp->doAsynchronousUpdate() inbetween
      * paintAt() calls to do the asynchronous rendering
      */
     virtual bool needsAsynchronousUpdates() const;
 
     /**
      * This structure defines the current mode for painting an outline.
      */
     struct OutlineMode {
         bool isVisible = false;
         bool forceCircle = false;
         bool showTiltDecoration = false;
         bool forceFullSize = false;
     };
 
     /**
      * Returns the brush outline in pixel coordinates. Tool is responsible for conversion into view coordinates.
      * Outline mode has to be passed to the paintop which builds the outline as some paintops have to paint outline
      * always like clone paintop indicating the duplicate position
      */
     virtual QPainterPath brushOutline(const KisPaintInformation &info, const OutlineMode &mode);
 
     /**
     * Helpers for drawing the brush outline
     */
     static QPainterPath ellipseOutline(qreal width, qreal height, qreal scale, qreal rotation);
 
     /**
      * Helper for drawing a triangle representing the tilt of the stylus.
      *
      * @param start is the offset from the brush's outline's bounding box
      * @param lengthScale is used for deciding the size of the triangle.
      * Brush diameter or width are common choices for this.
      * @param angle is the angle between the two sides of the triangle.
      */
     static QPainterPath makeTiltIndicator(KisPaintInformation const& info,
         QPointF const& start, qreal lengthScale, qreal angle);
 
     /**
      * Set paintop opacity directly in the properties
      */
     void setPaintOpOpacity(qreal value);
 
     /**
      * Set paintop flow directly in the properties
      */
     void setPaintOpFlow(qreal value);
 
     /**
      * Set paintop composite mode directly in the properties
      */
     void setPaintOpCompositeOp(const QString &value);
 
     /**
      * @return opacity saved in the properties
      */
     qreal paintOpOpacity();
 
     /**
      * @return flow saved in the properties
      */
     qreal paintOpFlow();
 
     /**
      * @return composite mode saved in the properties
      */
     QString paintOpCompositeOp();
 
     /**
      * Set paintop size directly in the properties
      */
     virtual void setPaintOpSize(qreal value) = 0;
 
     /**
      * @return size saved in the properties
      */
     virtual qreal paintOpSize() const = 0;
 
     void setEraserMode(bool value);
     bool eraserMode();
 
     qreal savedEraserSize() const;
     void setSavedEraserSize(qreal value);
     qreal savedBrushSize() const;
     void setSavedBrushSize(qreal value);
 
     qreal savedEraserOpacity() const;
     void setSavedEraserOpacity(qreal value);
     qreal savedBrushOpacity() const;
     void setSavedBrushOpacity(qreal value);
 
     QString effectivePaintOpCompositeOp();
 
     void setPreset(KisPaintOpPresetWSP preset);
 
     KisPaintOpPresetWSP preset() const;
 
     /**
      * @return filename of the 3D brush model, empty if no brush is set
      */
     virtual QString modelName() const;
 
     /**
     * Set filename of 3D brush model. By default no brush is set
     */
     void setModelName(const QString & modelName);
 
     /// Check if the settings are valid, setting might be invalid through missing brushes etc
     /// Overwrite if the settings of a paintop can be invalid
     /// @return state of the settings, default implementation is true
     virtual bool isValid() const;
 
     /// Check if the settings are loadable, that might the case if we can fallback to something
     /// Overwrite if the settings can do some kind of fallback
     /// @return loadable state of the settings, by default implementation return the same as isValid()
     virtual bool isLoadable();
 
-    /**
-     * These methods are populating properties with runtime
-     * information about canvas rotation/mirroring. This information
-     * is set directly by KisToolFreehand. Later the data is accessed
-     * by the pressure options to make a final decision.
-     */
-    void setCanvasRotation(qreal angle);
-    void setCanvasMirroring(bool xAxisMirrored, bool yAxisMirrored);
-
     /**
      * Overrides the method in KisPropertiesCofiguration to allow
      * onPropertyChanged() callback
      */
     void setProperty(const QString & name, const QVariant & value) override;
 
     virtual QList<KisUniformPaintOpPropertySP> uniformProperties(KisPaintOpSettingsSP settings);
 
     static bool isLodUserAllowed(const KisPropertiesConfigurationSP config);
     static void setLodUserAllowed(KisPropertiesConfigurationSP config, bool value);
 
     virtual bool lodSizeThresholdSupported() const;
 
     qreal lodSizeThreshold() const;
     void setLodSizeThreshold(qreal value);
 
     /**
     * @return the option widget of the paintop (can be 0 is no option widgets is set)
     */
     KisPaintOpConfigWidget* optionsWidget() const;
 
 
     /**
      * This function is called to set random offsets to the brush whenever the mouse is clicked. It is
      * specific to when the pattern option is set.
      *
      */
     virtual void setRandomOffset(const KisPaintInformation &paintInformation);
 
     /**
      * @return true if this preset demands a secondary masked brush running
      *         alongside it
      */
     bool hasMaskingSettings() const;
 
     /**
      * @return a newly created settings object representing a preset of the masking
      *         brush that should be run alongside the current brush
      */
     KisPaintOpSettingsSP createMaskingSettings() const;
 
     /**
      * @return a composite op id of the masked brush rendering algorithm.
      *
      * Please take into account that the brush itself always paints in alpha-
      * darken mode, but the final result is combined with this composite op.
      */
     QString maskingBrushCompositeOp() const;
 
 protected:
 
     /**
      * The callback is called every time when a property changes
      */
     virtual void onPropertyChanged();
 
 private:
 
 
 
     struct Private;
     const QScopedPointer<Private> d;
 };
 
 #endif
diff --git a/libs/image/commands_new/kis_saved_commands.cpp b/libs/image/commands_new/kis_saved_commands.cpp
index ddec094bd9..b6e04b57a5 100644
--- a/libs/image/commands_new/kis_saved_commands.cpp
+++ b/libs/image/commands_new/kis_saved_commands.cpp
@@ -1,305 +1,317 @@
 /*
  *  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()) return false;
+    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);
             }
         }
 
-        setExtraData(other->extraData()->clone());
+        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() != otherIt->command->id() ||
+        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
 {
     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);
         }
     }
     else {
         for(it = m_d->commands.end(); it != m_d->commands.begin();) {
             --it;
 
             *jobs << new KisStrokeStrategyUndoCommandBased::
                      Data(it->command,
                           undo,
                           it->sequentiality,
                           it->exclusivity);
         }
     }
 }
 
 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/kis_image.cc b/libs/image/kis_image.cc
index 93e204ffe4..068cfdf3a9 100644
--- a/libs/image/kis_image.cc
+++ b/libs/image/kis_image.cc
@@ -1,2049 +1,2067 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2007 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_image.h"
 
 #include <KoConfig.h> // WORDS_BIGENDIAN
 
 #include <stdlib.h>
 #include <math.h>
 
 #include <QImage>
 #include <QPainter>
 #include <QSize>
 #include <QDateTime>
 #include <QRect>
 #include <QRegion>
 #include <QtConcurrent>
 
 #include <klocalizedstring.h>
 
 #include "KoColorSpaceRegistry.h"
 #include "KoColor.h"
 #include "KoColorProfile.h"
 #include <KoCompositeOpRegistry.h>
 #include "KisProofingConfiguration.h"
 
 #include "kis_adjustment_layer.h"
 #include "kis_annotation.h"
 #include "kis_change_profile_visitor.h"
 #include "kis_colorspace_convert_visitor.h"
 #include "kis_count_visitor.h"
 #include "kis_filter_strategy.h"
 #include "kis_group_layer.h"
 #include "commands/kis_image_commands.h"
 #include "kis_layer.h"
 #include "kis_meta_data_merge_strategy_registry.h"
 #include "kis_name_server.h"
 #include "kis_paint_layer.h"
 #include "kis_projection_leaf.h"
 #include "kis_painter.h"
 #include "kis_selection.h"
 #include "kis_transaction.h"
 #include "kis_meta_data_merge_strategy.h"
 #include "kis_memory_statistics_server.h"
 
 #include "kis_image_config.h"
 #include "kis_update_scheduler.h"
 #include "kis_image_signal_router.h"
 #include "kis_image_animation_interface.h"
 #include "kis_stroke_strategy.h"
 #include "kis_simple_stroke_strategy.h"
 #include "kis_image_barrier_locker.h"
 
 
 #include "kis_undo_stores.h"
 #include "kis_legacy_undo_adapter.h"
 #include "kis_post_execution_undo_adapter.h"
 
 #include "kis_transform_worker.h"
 #include "kis_processing_applicator.h"
 #include "processing/kis_crop_processing_visitor.h"
 #include "processing/kis_crop_selections_processing_visitor.h"
 #include "processing/kis_transform_processing_visitor.h"
 #include "commands_new/kis_image_resize_command.h"
 #include "commands_new/kis_image_set_resolution_command.h"
 #include "commands_new/kis_activate_selection_mask_command.h"
 #include "kis_composite_progress_proxy.h"
 #include "kis_layer_composition.h"
 #include "kis_wrapped_rect.h"
 #include "kis_crop_saved_extra_data.h"
 #include "kis_layer_utils.h"
 
 #include "kis_lod_transform.h"
 
 #include "kis_suspend_projection_updates_stroke_strategy.h"
 #include "kis_sync_lod_cache_stroke_strategy.h"
 
 #include "kis_projection_updates_filter.h"
 
 #include "kis_layer_projection_plane.h"
 
 #include "kis_update_time_monitor.h"
 #include "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);
+    void notifyProjectionUpdatedInPatches(const QRect &rc, QVector<KisRunnableStrokeJobData *> &jobs);
 };
 
 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) {
         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;
                                                }
                                            });
     }
 
     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")),
               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,
                                       KoColorConversionTransformation::Intent renderingIntent,
                                       KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     if (!dstColorSpace) return;
 
     const KoColorSpace *srcColorSpace = m_d->colorSpace;
 
     undoAdapter()->beginMacro(kundo2_i18n("Convert Image Color Space"));
     undoAdapter()->addCommand(new KisImageLockCommand(KisImageWSP(this), true));
     undoAdapter()->addCommand(new KisImageSetProjectionColorSpaceCommand(KisImageWSP(this), dstColorSpace));
 
     KisColorSpaceConvertVisitor visitor(this, srcColorSpace, dstColorSpace, renderingIntent, conversionFlags);
     m_d->rootLayer->accept(visitor);
 
     undoAdapter()->addCommand(new KisImageLockCommand(KisImageWSP(this), false));
     undoAdapter()->endMacro();
 
     setModified();
 }
 
 bool KisImage::assignImageProfile(const KoColorProfile *profile)
 {
     if (!profile) return false;
 
     const KoColorSpace *dstCs = KoColorSpaceRegistry::instance()->colorSpace(colorSpace()->colorModelId().id(), colorSpace()->colorDepthId().id(), profile);
     const KoColorSpace *srcCs = colorSpace();
 
     if (!dstCs) return false;
 
     m_d->colorSpace = dstCs;
 
     KisChangeProfileVisitor visitor(srcCs, dstCs);
     bool retval = m_d->rootLayer->accept(visitor);
     m_d->signalRouter.emitNotification(ProfileChangedSignal);
     return retval;
 
 }
 
 void KisImage::convertProjectionColorSpace(const KoColorSpace *dstColorSpace)
 {
     if (*m_d->colorSpace == *dstColorSpace) return;
 
     undoAdapter()->beginMacro(kundo2_i18n("Convert Projection Color Space"));
     undoAdapter()->addCommand(new KisImageLockCommand(KisImageWSP(this), true));
     undoAdapter()->addCommand(new KisImageSetProjectionColorSpaceCommand(KisImageWSP(this), dstColorSpace));
     undoAdapter()->addCommand(new KisImageLockCommand(KisImageWSP(this), false));
     undoAdapter()->endMacro();
 
     setModified();
 }
 
 void KisImage::setProjectionColorSpace(const KoColorSpace * colorSpace)
 {
     m_d->colorSpace = colorSpace;
     m_d->rootLayer->resetCache();
     m_d->signalRouter.emitNotification(ColorSpaceChangedSignal);
 }
 
 const KoColorSpace * KisImage::colorSpace() const
 {
     return m_d->colorSpace;
 }
 
 const KoColorProfile * KisImage::profile() const
 {
     return colorSpace()->profile();
 }
 
 double KisImage::xRes() const
 {
     return m_d->xres;
 }
 
 double KisImage::yRes() const
 {
     return m_d->yres;
 }
 
 void KisImage::setResolution(double xres, double yres)
 {
     m_d->xres = xres;
     m_d->yres = yres;
     m_d->signalRouter.emitNotification(ResolutionChangedSignal);
 }
 
 QPointF KisImage::documentToPixel(const QPointF &documentCoord) const
 {
     return QPointF(documentCoord.x() * xRes(), documentCoord.y() * yRes());
 }
 
 QPoint KisImage::documentToImagePixelFloored(const QPointF &documentCoord) const
 {
     QPointF pixelCoord = documentToPixel(documentCoord);
     return QPoint(qFloor(pixelCoord.x()), qFloor(pixelCoord.y()));
 }
 
 QRectF KisImage::documentToPixel(const QRectF &documentRect) const
 {
     return QRectF(documentToPixel(documentRect.topLeft()), documentToPixel(documentRect.bottomRight()));
 }
 
 QPointF KisImage::pixelToDocument(const QPointF &pixelCoord) const
 {
     return QPointF(pixelCoord.x() / xRes(), pixelCoord.y() / yRes());
 }
 
 QPointF KisImage::pixelToDocument(const QPoint &pixelCoord) const
 {
     return QPointF((pixelCoord.x() + 0.5) / xRes(), (pixelCoord.y() + 0.5) / yRes());
 }
 
 QRectF KisImage::pixelToDocument(const QRectF &pixelCoord) const
 {
     return QRectF(pixelToDocument(pixelCoord.topLeft()), pixelToDocument(pixelCoord.bottomRight()));
 }
 
 qint32 KisImage::width() const
 {
     return m_d->width;
 }
 
 qint32 KisImage::height() const
 {
     return m_d->height;
 }
 
 KisGroupLayerSP KisImage::rootLayer() const
 {
     Q_ASSERT(m_d->rootLayer);
     return m_d->rootLayer;
 }
 
 KisPaintDeviceSP KisImage::projection() const
 {
     if (m_d->isolatedRootNode) {
         return m_d->isolatedRootNode->projection();
     }
 
 
     Q_ASSERT(m_d->rootLayer);
     KisPaintDeviceSP projection = m_d->rootLayer->projection();
     Q_ASSERT(projection);
     return projection;
 }
 
 qint32 KisImage::nlayers() const
 {
     QStringList list;
     list << "KisLayer";
 
     KisCountVisitor visitor(list, KoProperties());
     m_d->rootLayer->accept(visitor);
     return visitor.count();
 }
 
 qint32 KisImage::nHiddenLayers() const
 {
     QStringList list;
     list << "KisLayer";
     KoProperties properties;
     properties.setProperty("visible", false);
     KisCountVisitor visitor(list, properties);
     m_d->rootLayer->accept(visitor);
 
     return visitor.count();
 }
 
 void KisImage::flatten(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)
+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;
 
-            QtConcurrent::run(std::bind(&KisImage::notifyProjectionUpdated, q, patchRect));
+            KritaUtils::addJobConcurrent(jobs, std::bind(&KisImage::notifyProjectionUpdated, q, patchRect));
         }
     }
 }
 
 bool KisImage::startIsolatedMode(KisNodeSP node)
 {
-    struct StartIsolatedModeStroke : public KisSimpleStrokeStrategy {
+    struct StartIsolatedModeStroke : public KisRunnableBasedStrokeStrategy {
         StartIsolatedModeStroke(KisNodeSP node, KisImageSP image)
-            : KisSimpleStrokeStrategy("start-isolated-mode", kundo2_noi18n("start-isolated-mode")),
+            : KisRunnableBasedStrokeStrategy("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
-            m_image->m_d->notifyProjectionUpdatedInPatches(m_image->bounds());
+            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 KisSimpleStrokeStrategy {
+    struct StopIsolatedModeStroke : public KisRunnableBasedStrokeStrategy {
         StopIsolatedModeStroke(KisImageSP image)
-            : KisSimpleStrokeStrategy("stop-isolated-mode", kundo2_noi18n("stop-isolated-mode")),
+            : KisRunnableBasedStrokeStrategy("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
-            m_image->m_d->notifyProjectionUpdatedInPatches(m_image->bounds());
-            m_image->invalidateAllFrames();
+            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 asynchromously, so it is not
      * handled by disableUIUpdates() and other special signals of
      * KisImageSignalRouter
      */
     m_d->legacyUndoAdapter.emitSelectionChanged();
 
     /**
      * Editing of selection masks doesn't necessary produce a
      * setDirty() call, so in the end of the stroke we need to request
      * direct update of the UI's cache.
      */
     if (m_d->isolatedRootNode &&
         dynamic_cast<KisSelectionMask*>(m_d->isolatedRootNode.data())) {
 
         notifyProjectionUpdated(bounds());
     }
 }
 
 void KisImage::requestProjectionUpdateImpl(KisNode *node,
                                            const QVector<QRect> &rects,
                                            const QRect &cropRect)
 {
     if (rects.isEmpty()) return;
 
     m_d->scheduler.updateProjection(node, rects, cropRect);
 }
 
 void KisImage::requestProjectionUpdate(KisNode *node, const QVector<QRect> &rects, bool resetAnimationCache)
 {
     if (m_d->projectionUpdatesFilter
         && m_d->projectionUpdatesFilter->filter(this, node, rects, resetAnimationCache)) {
 
         return;
     }
 
     if (resetAnimationCache) {
         m_d->animationInterface->notifyNodeChanged(node, rects, false);
     }
 
     /**
      * Here we use 'permitted' instead of 'active' intentively,
      * because the updates may come after the actual stroke has been
      * finished. And having some more updates for the stroke not
      * supporting the wrap-around mode will not make much harm.
      */
     if (m_d->wrapAroundModePermitted) {
         QVector<QRect> allSplitRects;
 
         const QRect boundRect = effectiveLodBounds();
         Q_FOREACH (const QRect &rc, rects) {
             KisWrappedRect splitRect(rc, boundRect);
             allSplitRects.append(splitRect);
         }
 
         requestProjectionUpdateImpl(node, allSplitRects, boundRect);
 
     } else {
         requestProjectionUpdateImpl(node, rects, bounds());
     }
 
     KisNodeGraphListener::requestProjectionUpdate(node, rects, resetAnimationCache);
 }
 
 void KisImage::invalidateFrames(const KisTimeRange &range, const QRect &rect)
 {
     m_d->animationInterface->invalidateFrames(range, rect);
 }
 
 void KisImage::requestTimeSwitch(int time)
 {
     m_d->animationInterface->requestTimeSwitchNonGUI(time);
 }
 
 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::notifyNodeCollpasedChanged()
 {
     emit sigNodeCollapsedChanged();
 }
 
 KisImageAnimationInterface* KisImage::animationInterface() const
 {
     return m_d->animationInterface;
 }
 
 void KisImage::setProofingConfiguration(KisProofingConfigurationSP proofingConfig)
 {
     m_d->proofingConfig = proofingConfig;
     emit sigProofingConfigChanged();
 }
 
 KisProofingConfigurationSP KisImage::proofingConfiguration() const
 {
     if (m_d->proofingConfig) {
         return m_d->proofingConfig;
     }
     return KisProofingConfigurationSP();
 }
 
 QPointF KisImage::mirrorAxesCenter() const
 {
     return m_d->axesCenter;
 }
 
 void KisImage::setMirrorAxesCenter(const QPointF &value) const
 {
     m_d->axesCenter = value;
 }
 
 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 dea01e86a1..c259317d69 100644
--- a/libs/image/kis_image.h
+++ b/libs/image/kis_image.h
@@ -1,1185 +1,1193 @@
 /*
  *  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 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 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
      */
     void convertProjectionColorSpace(const KoColorSpace *dstColorSpace);
 
     // Get the profile associated with this image
     const KoColorProfile *  profile() const;
 
     /**
      * 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);
 
     /**
      * 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;
+    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;
+    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;
 
     /**
      * Notifies that the node collapsed state has changed
      */
     void notifyNodeCollpasedChanged();
 
     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 udpates
      * 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_image_config.cpp b/libs/image/kis_image_config.cpp
index 68ed256f3e..899280285b 100644
--- a/libs/image/kis_image_config.cpp
+++ b/libs/image/kis_image_config.cpp
@@ -1,600 +1,608 @@
 /*
  *  Copyright (c) 2010 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_image_config.h"
 
 #include <ksharedconfig.h>
 
 #include <KoConfig.h>
 #include <KoColorProfile.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorConversionTransformation.h>
 
 #include "kis_debug.h"
 
 #include <QThread>
 #include <QApplication>
 #include <QColor>
 #include <QDir>
 
 #include "kis_global.h"
 #include <cmath>
 
 #ifdef Q_OS_MACOS
 #include <errno.h>
 #endif
 
 KisImageConfig::KisImageConfig(bool readOnly)
     : m_config(KSharedConfig::openConfig()->group(QString()))
     , m_readOnly(readOnly)
 {
     if (!readOnly) {
         KIS_SAFE_ASSERT_RECOVER_RETURN(qApp->thread() == QThread::currentThread());
     }
 #ifdef Q_OS_MACOS
     // clear /var/folders/ swap path set by old broken Krita swap implementation in order to use new default swap dir.
     QString swap = m_config.readEntry("swaplocation", "");
     if (swap.startsWith("/var/folders/")) {
         m_config.deleteEntry("swaplocation");
     }
 #endif
 }
 
 KisImageConfig::~KisImageConfig()
 {
     if (m_readOnly) return;
 
     if (qApp->thread() != QThread::currentThread()) {
         dbgKrita << "KisImageConfig: requested config synchronization from nonGUI thread! Called from" << kisBacktrace();
         return;
     }
 
     m_config.sync();
 }
 
 bool KisImageConfig::enableProgressReporting(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("enableProgressReporting", true) : true;
 }
 
 void KisImageConfig::setEnableProgressReporting(bool value)
 {
     m_config.writeEntry("enableProgressReporting", value);
 }
 
 bool KisImageConfig::enablePerfLog(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("enablePerfLog", false) :false;
 }
 
 void KisImageConfig::setEnablePerfLog(bool value)
 {
     m_config.writeEntry("enablePerfLog", value);
 }
 
 qreal KisImageConfig::transformMaskOffBoundsReadArea() const
 {
     return m_config.readEntry("transformMaskOffBoundsReadArea", 0.5);
 }
 
 int KisImageConfig::updatePatchHeight() const
 {
     return m_config.readEntry("updatePatchHeight", 512);
 }
 
 void KisImageConfig::setUpdatePatchHeight(int value)
 {
     m_config.writeEntry("updatePatchHeight", value);
 }
 
 int KisImageConfig::updatePatchWidth() const
 {
     return m_config.readEntry("updatePatchWidth", 512);
 }
 
 void KisImageConfig::setUpdatePatchWidth(int value)
 {
     m_config.writeEntry("updatePatchWidth", value);
 }
 
 qreal KisImageConfig::maxCollectAlpha() const
 {
     return m_config.readEntry("maxCollectAlpha", 2.5);
 }
 
 qreal KisImageConfig::maxMergeAlpha() const
 {
     return m_config.readEntry("maxMergeAlpha", 1.);
 }
 
 qreal KisImageConfig::maxMergeCollectAlpha() const
 {
     return m_config.readEntry("maxMergeCollectAlpha", 1.5);
 }
 
 qreal KisImageConfig::schedulerBalancingRatio() const
 {
     /**
      * updates-queue-size / strokes-queue-size
      */
     return m_config.readEntry("schedulerBalancingRatio", 100.);
 }
 
 void KisImageConfig::setSchedulerBalancingRatio(qreal value)
 {
     m_config.writeEntry("schedulerBalancingRatio", value);
 }
 
 int KisImageConfig::maxSwapSize(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("maxSwapSize", 4096) : 4096; // in MiB
 }
 
 void KisImageConfig::setMaxSwapSize(int value)
 {
     m_config.writeEntry("maxSwapSize", value);
 }
 
 int KisImageConfig::swapSlabSize() const
 {
     return m_config.readEntry("swapSlabSize", 64); // in MiB
 }
 
 void KisImageConfig::setSwapSlabSize(int value)
 {
     m_config.writeEntry("swapSlabSize", value);
 }
 
 int KisImageConfig::swapWindowSize() const
 {
     return m_config.readEntry("swapWindowSize", 16); // in MiB
 }
 
 void KisImageConfig::setSwapWindowSize(int value)
 {
     m_config.writeEntry("swapWindowSize", value);
 }
 
 int KisImageConfig::tilesHardLimit() const
 {
     qreal hp = qreal(memoryHardLimitPercent()) / 100.0;
     qreal pp = qreal(memoryPoolLimitPercent()) / 100.0;
 
     return totalRAM() * hp * (1 - pp);
 }
 
 int KisImageConfig::tilesSoftLimit() const
 {
     qreal sp = qreal(memorySoftLimitPercent()) / 100.0;
 
     return tilesHardLimit() * sp;
 }
 
 int KisImageConfig::poolLimit() const
 {
     qreal hp = qreal(memoryHardLimitPercent()) / 100.0;
     qreal pp = qreal(memoryPoolLimitPercent()) / 100.0;
 
     return totalRAM() * hp * pp;
 }
 
 qreal KisImageConfig::memoryHardLimitPercent(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("memoryHardLimitPercent", 50.) : 50.;
 }
 
 void KisImageConfig::setMemoryHardLimitPercent(qreal value)
 {
     m_config.writeEntry("memoryHardLimitPercent", value);
 }
 
 qreal KisImageConfig::memorySoftLimitPercent(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("memorySoftLimitPercent", 2.) : 2.;
 }
 
 void KisImageConfig::setMemorySoftLimitPercent(qreal value)
 {
     m_config.writeEntry("memorySoftLimitPercent", value);
 }
 
 qreal KisImageConfig::memoryPoolLimitPercent(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("memoryPoolLimitPercent", 0.0) : 0.0;
 }
 
 void KisImageConfig::setMemoryPoolLimitPercent(qreal value)
 {
     m_config.writeEntry("memoryPoolLimitPercent", value);
 }
 
 QString KisImageConfig::safelyGetWritableTempLocation(const QString &suffix, const QString &configKey, bool requestDefault) const
 {
 #ifdef Q_OS_MACOS
     // On OSX, QDir::tempPath() gives us a folder we cannot reply upon (usually
     // something like /var/folders/.../...) and that will have vanished when we
     // try to create the tmp file in KisMemoryWindow::KisMemoryWindow using
     // swapFileTemplate. thus, we just pick the home folder if swapDir does not
     // tell us otherwise.
 
     // the other option here would be to use a "garbled name" temp file (i.e. no name
     // KRITA_SWAP_FILE_XXXXXX) in an obscure /var/folders place, which is not
     // nice to the user. having a clearly named swap file in the home folder is
     // much nicer to Krita's users.
 
     // furthermore, this is just a default and swapDir can always be configured
     // to another location.
 
     QString swap = QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation) + QDir::separator() + suffix;
 #else
     Q_UNUSED(suffix);
     QString swap = QDir::tempPath();
 #endif
     if (requestDefault) {
        return swap;
     }
     const QString configuredSwap = m_config.readEntry(configKey, swap);
     if (!configuredSwap.isEmpty()) {
         swap = configuredSwap;
     }
+
+    // Gosh, everything fails, nothing is writable, swap to the homedir
+    if (!QFileInfo(swap).isWritable()) {
+        swap = QDir::homePath();
+        Q_ASSERT(QFileInfo(swap).isWritable());
+    }
+
+
     return swap;
 }
 
 
 QString KisImageConfig::swapDir(bool requestDefault)
 {
     return safelyGetWritableTempLocation("swap", "swaplocation", requestDefault);
 }
 
 void KisImageConfig::setSwapDir(const QString &swapDir)
 {
     m_config.writeEntry("swaplocation", swapDir);
 }
 
 int KisImageConfig::numberOfOnionSkins() const
 {
     return m_config.readEntry("numberOfOnionSkins", 10);
 }
 
 void KisImageConfig::setNumberOfOnionSkins(int value)
 {
     m_config.writeEntry("numberOfOnionSkins", value);
 }
 
 int KisImageConfig::onionSkinTintFactor() const
 {
     return m_config.readEntry("onionSkinTintFactor", 192);
 }
 
 void KisImageConfig::setOnionSkinTintFactor(int value)
 {
     m_config.writeEntry("onionSkinTintFactor", value);
 }
 
 int KisImageConfig::onionSkinOpacity(int offset) const
 {
     int value = m_config.readEntry("onionSkinOpacity_" + QString::number(offset), -1);
 
     if (value < 0) {
         const int num = numberOfOnionSkins();
         const qreal dx = qreal(qAbs(offset)) / num;
         value = 0.7 * exp(-pow2(dx) / 0.5) * 255;
     }
 
     return value;
 }
 
 void KisImageConfig::setOnionSkinOpacity(int offset, int value)
 {
     m_config.writeEntry("onionSkinOpacity_" + QString::number(offset), value);
 }
 
 bool KisImageConfig::onionSkinState(int offset) const
 {
     bool enableByDefault = (qAbs(offset) <= 2);
     return m_config.readEntry("onionSkinState_" + QString::number(offset), enableByDefault);
 }
 
 void KisImageConfig::setOnionSkinState(int offset, bool value)
 {
     m_config.writeEntry("onionSkinState_" + QString::number(offset), value);
 }
 
 QColor KisImageConfig::onionSkinTintColorBackward() const
 {
     return m_config.readEntry("onionSkinTintColorBackward", QColor(Qt::red));
 }
 
 void KisImageConfig::setOnionSkinTintColorBackward(const QColor &value)
 {
     m_config.writeEntry("onionSkinTintColorBackward", value);
 }
 
 QColor KisImageConfig::onionSkinTintColorForward() const
 {
     return m_config.readEntry("oninSkinTintColorForward", QColor(Qt::green));
 }
 
 void KisImageConfig::setOnionSkinTintColorForward(const QColor &value)
 {
     m_config.writeEntry("oninSkinTintColorForward", value);
 }
 
 bool KisImageConfig::lazyFrameCreationEnabled(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("lazyFrameCreationEnabled", true) : true;
 }
 
 void KisImageConfig::setLazyFrameCreationEnabled(bool value)
 {
     m_config.writeEntry("lazyFrameCreationEnabled", value);
 }
 
 
 #if defined Q_OS_LINUX
 #include <sys/sysinfo.h>
 #elif defined Q_OS_FREEBSD || defined Q_OS_NETBSD || defined Q_OS_OPENBSD
 #include <sys/sysctl.h>
 #elif defined Q_OS_WIN
 #include <windows.h>
 #elif defined Q_OS_MACOS
 #include <sys/types.h>
 #include <sys/sysctl.h>
 #endif
 
 int KisImageConfig::totalRAM()
 {
     // let's think that default memory size is 1000MiB
     int totalMemory = 1000; // MiB
     int error = 1;
 
 #if defined Q_OS_LINUX
     struct sysinfo info;
 
     error = sysinfo(&info);
     if(!error) {
         totalMemory = info.totalram * info.mem_unit / (1UL << 20);
     }
 #elif defined Q_OS_FREEBSD || defined Q_OS_NETBSD || defined Q_OS_OPENBSD
     u_long physmem;
 #   if defined HW_PHYSMEM64 // NetBSD only
     int mib[] = {CTL_HW, HW_PHYSMEM64};
 #   else
     int mib[] = {CTL_HW, HW_PHYSMEM};
 #   endif
     size_t len = sizeof(physmem);
 
     error = sysctl(mib, 2, &physmem, &len, 0, 0);
     if(!error) {
         totalMemory = physmem >> 20;
     }
 #elif defined Q_OS_WIN
     MEMORYSTATUSEX status;
     status.dwLength = sizeof(status);
     error  = !GlobalMemoryStatusEx(&status);
 
     if (!error) {
         totalMemory = status.ullTotalPhys >> 20;
     }
 
     // For 32 bit windows, the total memory available is at max the 2GB per process memory limit.
 #   if defined ENV32BIT
     totalMemory = qMin(totalMemory, 2000);
 #   endif
 #elif defined Q_OS_MACOS
     int mib[2] = { CTL_HW, HW_MEMSIZE };
     u_int namelen = sizeof(mib) / sizeof(mib[0]);
     uint64_t size;
     size_t len = sizeof(size);
 
     errno = 0;
     if (sysctl(mib, namelen, &size, &len, 0, 0) >= 0) {
         totalMemory = size >> 20;
         error = 0;
     }
     else {
         dbgKrita << "sysctl(\"hw.memsize\") raised error" << strerror(errno);
     }
 #endif
 
     if (error) {
         warnKrita << "Cannot get the size of your RAM. Using 1 GiB by default.";
     }
 
     return totalMemory;
 }
 
 bool KisImageConfig::showAdditionalOnionSkinsSettings(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("showAdditionalOnionSkinsSettings", true) : true;
 }
 
 void KisImageConfig::setShowAdditionalOnionSkinsSettings(bool value)
 {
     m_config.writeEntry("showAdditionalOnionSkinsSettings", value);
 }
 
 int KisImageConfig::defaultFrameColorLabel() const
 {
     return m_config.readEntry("defaultFrameColorLabel", 0);
 }
 
 void KisImageConfig::setDefaultFrameColorLabel(int label)
 {
     m_config.writeEntry("defaultFrameColorLabel", label);
 }
 
 KisProofingConfigurationSP KisImageConfig::defaultProofingconfiguration()
 {
     KisProofingConfiguration *proofingConfig= new KisProofingConfiguration();
     proofingConfig->proofingProfile = m_config.readEntry("defaultProofingProfileName", "Chemical proof");
     proofingConfig->proofingModel = m_config.readEntry("defaultProofingProfileModel", "CMYKA");
     proofingConfig->proofingDepth = m_config.readEntry("defaultProofingProfileDepth", "U8");
     proofingConfig->intent = (KoColorConversionTransformation::Intent)m_config.readEntry("defaultProofingProfileIntent", 3);
     if (m_config.readEntry("defaultProofingBlackpointCompensation", true)) {
         proofingConfig->conversionFlags  |= KoColorConversionTransformation::ConversionFlag::BlackpointCompensation;
     } else {
         proofingConfig->conversionFlags  = proofingConfig->conversionFlags & ~KoColorConversionTransformation::ConversionFlag::BlackpointCompensation;
     }
     QColor def(Qt::green);
     m_config.readEntry("defaultProofingGamutwarning", def);
     KoColor col(KoColorSpaceRegistry::instance()->rgb8());
     col.fromQColor(def);
     col.setOpacity(1.0);
     proofingConfig->warningColor = col;
     proofingConfig->adaptationState = (double)m_config.readEntry("defaultProofingAdaptationState", 1.0);
     return toQShared(proofingConfig);
 }
 
 void KisImageConfig::setDefaultProofingConfig(const KoColorSpace *proofingSpace, int proofingIntent, bool blackPointCompensation, KoColor warningColor, double adaptationState)
 {
     m_config.writeEntry("defaultProofingProfileName", proofingSpace->profile()->name());
     m_config.writeEntry("defaultProofingProfileModel", proofingSpace->colorModelId().id());
     m_config.writeEntry("defaultProofingProfileDepth", proofingSpace->colorDepthId().id());
     m_config.writeEntry("defaultProofingProfileIntent", proofingIntent);
     m_config.writeEntry("defaultProofingBlackpointCompensation", blackPointCompensation);
     QColor c;
     c = warningColor.toQColor();
     m_config.writeEntry("defaultProofingGamutwarning", c);
     m_config.writeEntry("defaultProofingAdaptationState",adaptationState);
 }
 
 bool KisImageConfig::useLodForColorizeMask(bool requestDefault) const
 {
     return !requestDefault ?
         m_config.readEntry("useLodForColorizeMask", false) : false;
 }
 
 void KisImageConfig::setUseLodForColorizeMask(bool value)
 {
     m_config.writeEntry("useLodForColorizeMask", value);
 }
 
 int KisImageConfig::maxNumberOfThreads(bool defaultValue) const
 {
     return (defaultValue ? QThread::idealThreadCount() : m_config.readEntry("maxNumberOfThreads", QThread::idealThreadCount()));
 }
 
 void KisImageConfig::setMaxNumberOfThreads(int value)
 {
     if (value == QThread::idealThreadCount()) {
         m_config.deleteEntry("maxNumberOfThreads");
     } else {
         m_config.writeEntry("maxNumberOfThreads", value);
     }
 }
 
 int KisImageConfig::frameRenderingClones(bool defaultValue) const
 {
     const int defaultClonesCount = qMax(1, maxNumberOfThreads(defaultValue) / 2);
     return defaultValue ? defaultClonesCount : m_config.readEntry("frameRenderingClones", defaultClonesCount);
 }
 
 void KisImageConfig::setFrameRenderingClones(int value)
 {
     m_config.writeEntry("frameRenderingClones", value);
 }
 
 int KisImageConfig::fpsLimit(bool defaultValue) const
 {
     return defaultValue ? 100 : m_config.readEntry("fpsLimit", 100);
 }
 
 void KisImageConfig::setFpsLimit(int value)
 {
     m_config.writeEntry("fpsLimit", value);
 }
 
 bool KisImageConfig::useOnDiskAnimationCacheSwapping(bool defaultValue) const
 {
     return defaultValue ? true : m_config.readEntry("useOnDiskAnimationCacheSwapping", true);
 }
 
 void KisImageConfig::setUseOnDiskAnimationCacheSwapping(bool value)
 {
     m_config.writeEntry("useOnDiskAnimationCacheSwapping", value);
 }
 
 QString KisImageConfig::animationCacheDir(bool defaultValue) const
 {
     return safelyGetWritableTempLocation("animation_cache", "animationCacheDir", defaultValue);
 }
 
 void KisImageConfig::setAnimationCacheDir(const QString &value)
 {
     m_config.writeEntry("animationCacheDir", value);
 }
 
 bool KisImageConfig::useAnimationCacheFrameSizeLimit(bool defaultValue) const
 {
     return defaultValue ? true : m_config.readEntry("useAnimationCacheFrameSizeLimit", true);
 }
 
 void KisImageConfig::setUseAnimationCacheFrameSizeLimit(bool value)
 {
     m_config.writeEntry("useAnimationCacheFrameSizeLimit", value);
 }
 
 int KisImageConfig::animationCacheFrameSizeLimit(bool defaultValue) const
 {
     return defaultValue ? 2500 : m_config.readEntry("animationCacheFrameSizeLimit", 2500);
 }
 
 void KisImageConfig::setAnimationCacheFrameSizeLimit(int value)
 {
     m_config.writeEntry("animationCacheFrameSizeLimit", value);
 }
 
 bool KisImageConfig::useAnimationCacheRegionOfInterest(bool defaultValue) const
 {
     return defaultValue ? true : m_config.readEntry("useAnimationCacheRegionOfInterest", true);
 }
 
 void KisImageConfig::setUseAnimationCacheRegionOfInterest(bool value)
 {
     m_config.writeEntry("useAnimationCacheRegionOfInterest", value);
 }
 
 qreal KisImageConfig::animationCacheRegionOfInterestMargin(bool defaultValue) const
 {
     return defaultValue ? 0.25 : m_config.readEntry("animationCacheRegionOfInterestMargin", 0.25);
 }
 
 void KisImageConfig::setAnimationCacheRegionOfInterestMargin(qreal value)
 {
     m_config.writeEntry("animationCacheRegionOfInterestMargin", value);
 }
 
 QColor KisImageConfig::selectionOverlayMaskColor(bool defaultValue) const
 {
     QColor def(255, 0, 0, 128);
     return (defaultValue ? def : m_config.readEntry("selectionOverlayMaskColor", def));
 }
 
 void KisImageConfig::setSelectionOverlayMaskColor(const QColor &color)
 {
     m_config.writeEntry("selectionOverlayMaskColor", color);
 }
diff --git a/libs/image/kis_image_interfaces.h b/libs/image/kis_image_interfaces.h
index 4dc3387ca6..81c1465687 100644
--- a/libs/image/kis_image_interfaces.h
+++ b/libs/image/kis_image_interfaces.h
@@ -1,84 +1,86 @@
 /*
  *  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_IMAGE_INTERFACES_H
 #define __KIS_IMAGE_INTERFACES_H
 
 #include "kis_types.h"
 #include <kritaimage_export.h>
 
 class QRect;
 class KisStrokeStrategy;
 class KisStrokeJobData;
 class KisPostExecutionUndoAdapter;
 
 
 class KRITAIMAGE_EXPORT KisStrokesFacade
 {
 public:
     virtual ~KisStrokesFacade();
     virtual KisStrokeId startStroke(KisStrokeStrategy *strokeStrategy) = 0;
     virtual void addJob(KisStrokeId id, KisStrokeJobData *data) = 0;
     virtual void endStroke(KisStrokeId id) = 0;
     virtual bool cancelStroke(KisStrokeId id) = 0;
 };
 
 class KRITAIMAGE_EXPORT KisUpdatesFacade
 {
 public:
     virtual ~KisUpdatesFacade();
 
     virtual void blockUpdates() = 0;
     virtual void unblockUpdates() = 0;
 
     virtual void disableUIUpdates() = 0;
     virtual QVector<QRect> enableUIUpdates() = 0;
 
+    virtual bool hasUpdatesRunning() const = 0;
+
     virtual void notifyBatchUpdateStarted() = 0;
     virtual void notifyBatchUpdateEnded() = 0;
     virtual void notifyUIUpdateCompleted(const QRect &rc) = 0;
 
     virtual QRect bounds() const = 0;
 
     virtual void disableDirtyRequests() = 0;
     virtual void enableDirtyRequests() = 0;
 
     virtual void refreshGraphAsync(KisNodeSP root) = 0;
     virtual void refreshGraphAsync(KisNodeSP root, const QRect &rc) = 0;
     virtual void refreshGraphAsync(KisNodeSP root, const QRect &rc, const QRect &cropRect) = 0;
 
     virtual void setProjectionUpdatesFilter(KisProjectionUpdatesFilterSP filter) = 0;
     virtual KisProjectionUpdatesFilterSP projectionUpdatesFilter() const = 0;
 };
 
 class KRITAIMAGE_EXPORT KisProjectionUpdateListener
 {
 public:
     virtual ~KisProjectionUpdateListener();
     virtual void notifyProjectionUpdated(const QRect &rc) = 0;
 };
 
 class KRITAIMAGE_EXPORT KisStrokeUndoFacade
 {
 public:
     virtual ~KisStrokeUndoFacade();
     virtual KisPostExecutionUndoAdapter* postExecutionUndoAdapter() const = 0;
     virtual const KUndo2Command* lastExecutedCommand() const = 0;
 };
 
 #endif /* __KIS_IMAGE_INTERFACES_H */
diff --git a/libs/image/kis_mask.cc b/libs/image/kis_mask.cc
index 2a71588134..b07dd02001 100644
--- a/libs/image/kis_mask.cc
+++ b/libs/image/kis_mask.cc
@@ -1,511 +1,514 @@
 /*
  *  Copyright (c) 2006 Boudewijn Rempt <boud@valdyas.org>
  *            (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_mask.h"
 
 
 #include <kis_debug.h>
 
 // to prevent incomplete class types on "delete selection->flatten();"
 #include <kundo2command.h>
 
 #include <QScopedPointer>
 
 #include <KoColor.h>
 #include <KoColorSpace.h>
 #include <KoCompositeOpRegistry.h>
 
 #include "kis_paint_device.h"
 #include "kis_selection.h"
 #include "kis_pixel_selection.h"
 #include "kis_painter.h"
 
 #include "kis_image.h"
 #include "kis_layer.h"
 
 #include "kis_cached_paint_device.h"
 #include "kis_mask_projection_plane.h"
 
 #include "kis_raster_keyframe_channel.h"
 #include "KisSafeNodeProjectionStore.h"
 
 
 struct Q_DECL_HIDDEN KisMask::Private {
     Private(KisMask *_q)
         : q(_q),
           projectionPlane(new KisMaskProjectionPlane(q))
     {
     }
 
     mutable KisSelectionSP selection;
     KisCachedPaintDevice paintDeviceCache;
     KisMask *q;
 
     /**
      * Due to the design of the Kra format the X,Y offset of the paint
      * device belongs to the node, but not to the device itself.  So
      * the offset is set when the node is created, but not when the
      * selection is initialized. This causes the X,Y values to be
      * lost, since the selection doen not exist at the moment. That is
      * why we save it separately.
      */
     QScopedPointer<QPoint> deferredSelectionOffset;
 
     KisAbstractProjectionPlaneSP projectionPlane;
     KisSafeSelectionNodeProjectionStoreSP safeProjection;
 
     void initSelectionImpl(KisSelectionSP copyFrom, KisLayerSP parentLayer, KisPaintDeviceSP copyFromDevice);
 };
 
 KisMask::KisMask(const QString & name)
         : KisNode(nullptr)
         , m_d(new Private(this))
 {
     setName(name);
     m_d->safeProjection = new KisSafeSelectionNodeProjectionStore();
     m_d->safeProjection->setImage(image());
 }
 
 KisMask::KisMask(const KisMask& rhs)
         : KisNode(rhs)
         , KisIndirectPaintingSupport()
         , m_d(new Private(this))
 {
     setName(rhs.name());
 
     m_d->safeProjection = new KisSafeSelectionNodeProjectionStore(*rhs.m_d->safeProjection);
 
     if (rhs.m_d->selection) {
         m_d->selection = new KisSelection(*rhs.m_d->selection.data());
         m_d->selection->setParentNode(this);
 
         KisPixelSelectionSP pixelSelection = m_d->selection->pixelSelection();
         if (pixelSelection->framesInterface()) {
             addKeyframeChannel(pixelSelection->keyframeChannel());
             enableAnimation();
         }
     }
 }
 
 KisMask::~KisMask()
 {
     if (m_d->selection) {
         m_d->selection->setParentNode(0);
     }
 
     delete m_d;
 }
 
 void KisMask::setImage(KisImageWSP image)
 {
     KisPaintDeviceSP parentPaintDevice = parent() ? parent()->original() : 0;
     KisDefaultBoundsBaseSP defaultBounds = new KisSelectionDefaultBounds(parentPaintDevice, image);
     if (m_d->selection) {
         m_d->selection->setDefaultBounds(defaultBounds);
     }
 
     m_d->safeProjection->setImage(image);
 
     KisNode::setImage(image);
 }
 
 bool KisMask::allowAsChild(KisNodeSP node) const
 {
     Q_UNUSED(node);
     return false;
 }
 
 const KoColorSpace * KisMask::colorSpace() const
 {
     KisNodeSP parentNode = parent();
     return parentNode ? parentNode->colorSpace() : 0;
 }
 
 const KoCompositeOp * KisMask::compositeOp() const
 {
     /**
      * FIXME: This function duplicates the same function from
      * KisLayer. We can't move it to KisBaseNode as it doesn't
      * know anything about parent() method of KisNode
      * Please think it over...
      */
 
     const KoColorSpace *colorSpace = this->colorSpace();
     if (!colorSpace) return 0;
 
     const KoCompositeOp* op = colorSpace->compositeOp(compositeOpId());
     return op ? op : colorSpace->compositeOp(COMPOSITE_OVER);
 }
 
 void KisMask::initSelection(KisSelectionSP copyFrom, KisLayerSP parentLayer)
 {
     m_d->initSelectionImpl(copyFrom, parentLayer, 0);
 }
 
 void KisMask::initSelection(KisPaintDeviceSP copyFromDevice, KisLayerSP parentLayer)
 {
     m_d->initSelectionImpl(0, parentLayer, copyFromDevice);
 }
 
 void KisMask::initSelection(KisLayerSP parentLayer)
 {
     m_d->initSelectionImpl(0, parentLayer, 0);
 }
 
 void KisMask::Private::initSelectionImpl(KisSelectionSP copyFrom, KisLayerSP parentLayer, KisPaintDeviceSP copyFromDevice)
 {
     Q_ASSERT(parentLayer);
 
     KisPaintDeviceSP parentPaintDevice = parentLayer->original();
 
     if (copyFrom) {
         /**
          * We can't use setSelection as we may not have parent() yet
          */
         selection = new KisSelection(*copyFrom);
         selection->setDefaultBounds(new KisSelectionDefaultBounds(parentPaintDevice, parentLayer->image()));
         if (copyFrom->hasShapeSelection()) {
             delete selection->flatten();
         }
     } else if (copyFromDevice) {
         KritaUtils::DeviceCopyMode copyMode =
             q->inherits("KisFilterMask") || q->inherits("KisTransparencyMask") ?
             KritaUtils::CopyAllFrames : KritaUtils::CopySnapshot;
 
         selection = new KisSelection(copyFromDevice, copyMode, new KisSelectionDefaultBounds(parentPaintDevice, parentLayer->image()));
 
         KisPixelSelectionSP pixelSelection = selection->pixelSelection();
         if (pixelSelection->framesInterface()) {
-            q->addKeyframeChannel(pixelSelection->keyframeChannel());
+            KisRasterKeyframeChannel *keyframeChannel = pixelSelection->keyframeChannel();
+            keyframeChannel->setFilenameSuffix(".pixelselection");
+
+            q->addKeyframeChannel(keyframeChannel);
             q->enableAnimation();
         }
     } else {
         selection = new KisSelection(new KisSelectionDefaultBounds(parentPaintDevice, parentLayer->image()));
         selection->pixelSelection()->setDefaultPixel(KoColor(Qt::white, selection->pixelSelection()->colorSpace()));
 
         if (deferredSelectionOffset) {
             selection->setX(deferredSelectionOffset->x());
             selection->setY(deferredSelectionOffset->y());
             deferredSelectionOffset.reset();
         }
     }
     selection->setParentNode(q);
     selection->updateProjection();
 }
 
 KisSelectionSP KisMask::selection() const
 {
     return m_d->selection;
 }
 
 KisPaintDeviceSP KisMask::paintDevice() const
 {
     KisSelectionSP selection = this->selection();
     return selection ? selection->pixelSelection() : 0;
 }
 
 KisPaintDeviceSP KisMask::original() const
 {
     return paintDevice();
 }
 
 KisPaintDeviceSP KisMask::projection() const
 {
     KisPaintDeviceSP originalDevice = original();
     KisPaintDeviceSP result = originalDevice;
 
     KisSelectionSP selection = this->selection();
     if (selection && hasTemporaryTarget()) {
         result = m_d->safeProjection->getDeviceLazy(selection)->pixelSelection();
     }
 
     return result;
 }
 
 KisAbstractProjectionPlaneSP KisMask::projectionPlane() const
 {
     return m_d->projectionPlane;
 }
 
 void KisMask::setSelection(KisSelectionSP selection)
 {
     m_d->selection = selection;
     if (parent()) {
         const KisLayer *parentLayer = qobject_cast<const KisLayer*>(parent());
         m_d->selection->setDefaultBounds(new KisDefaultBounds(parentLayer->image()));
     }
     m_d->selection->setParentNode(this);
 }
 
 void KisMask::select(const QRect & rc, quint8 selectedness)
 {
     KisSelectionSP sel = selection();
     KisPixelSelectionSP psel = sel->pixelSelection();
     psel->select(rc, selectedness);
     sel->updateProjection(rc);
 }
 
 
 QRect KisMask::decorateRect(KisPaintDeviceSP &src,
                             KisPaintDeviceSP &dst,
                             const QRect & rc,
                             PositionToFilthy maskPos) const
 {
     Q_UNUSED(src);
     Q_UNUSED(dst);
     Q_UNUSED(maskPos);
     Q_ASSERT_X(0, "KisMask::decorateRect", "Should be overridden by successors");
     return rc;
 }
 
 bool KisMask::paintsOutsideSelection() const
 {
     return false;
 }
 
 void KisMask::apply(KisPaintDeviceSP projection, const QRect &applyRect, const QRect &needRect, PositionToFilthy maskPos) const
 {
     if (selection()) {
 
         flattenSelectionProjection(m_d->selection, applyRect);
 
         KisSelectionSP effectiveSelection = m_d->selection;
 
         {
             // Access temporary target under the lock held
             KisIndirectPaintingSupport::ReadLocker l(this);
 
             if (!paintsOutsideSelection()) {
                 // extent of m_d->selection should also be accessed under a lock,
                 // because it might be being merged in by the temporary target atm
                 QRect effectiveExtent = m_d->selection->selectedRect();
 
                 if (hasTemporaryTarget()) {
                     effectiveExtent |= temporaryTarget()->extent();
                 }
 
                 if(!effectiveExtent.intersects(applyRect)) {
                     return;
                 }
             }
 
             if (hasTemporaryTarget()) {
                 effectiveSelection = m_d->safeProjection->getDeviceLazy(m_d->selection);
 
                 KisPainter::copyAreaOptimized(applyRect.topLeft(),
                                               m_d->selection->pixelSelection(),
                                               effectiveSelection->pixelSelection(), applyRect);
 
                 KisPainter gc(effectiveSelection->pixelSelection());
                 setupTemporaryPainter(&gc);
                 gc.bitBlt(applyRect.topLeft(), temporaryTarget(), applyRect);
             } else {
                 m_d->safeProjection->releaseDevice();
             }
 
             mergeInMaskInternal(projection, effectiveSelection, applyRect, needRect, maskPos);
         }
 
     } else {
         mergeInMaskInternal(projection, 0, applyRect, needRect, maskPos);
     }
 }
 
 void KisMask::mergeInMaskInternal(KisPaintDeviceSP projection,
                                   KisSelectionSP effectiveSelection,
                                   const QRect &applyRect,
                                   const QRect &preparedNeedRect,
                                   KisNode::PositionToFilthy maskPos) const
 {
     KisPaintDeviceSP cacheDevice = m_d->paintDeviceCache.getDevice(projection);
 
     if (effectiveSelection) {
         QRect updatedRect = decorateRect(projection, cacheDevice, applyRect, maskPos);
 
         // masks don't have any compositioning
         KisPainter::copyAreaOptimized(updatedRect.topLeft(), cacheDevice, projection, updatedRect, effectiveSelection);
 
     } else {
         cacheDevice->makeCloneFromRough(projection, preparedNeedRect);
         projection->clear(preparedNeedRect);
 
         decorateRect(cacheDevice, projection, applyRect, maskPos);
     }
 
     m_d->paintDeviceCache.putDevice(cacheDevice);
 }
 
 void KisMask::flattenSelectionProjection(KisSelectionSP selection, const QRect &dirtyRect) const
 {
     selection->updateProjection(dirtyRect);
 }
 
 QRect KisMask::needRect(const QRect &rect,  PositionToFilthy pos) const
 {
     Q_UNUSED(pos);
     QRect resultRect = rect;
     if (m_d->selection) {
         QRect selectionExtent = m_d->selection->selectedRect();
 
         // copy for thread safety!
         KisPaintDeviceSP temporaryTarget = this->temporaryTarget();
 
         if (temporaryTarget) {
             selectionExtent |= temporaryTarget->extent();
         }
 
         resultRect &= selectionExtent;
     }
 
     return resultRect;
 }
 
 QRect KisMask::changeRect(const QRect &rect, PositionToFilthy pos) const
 {
     return KisMask::needRect(rect, pos);
 }
 
 QRect KisMask::extent() const
 {
     QRect resultRect;
 
     if (m_d->selection) {
         resultRect = m_d->selection->selectedRect();
 
         // copy for thread safety!
         KisPaintDeviceSP temporaryTarget = this->temporaryTarget();
 
         if (temporaryTarget) {
             resultRect |= temporaryTarget->extent();
         }
     } else if (KisNodeSP parent = this->parent()) {
         resultRect = parent->extent();
     }
 
     return resultRect;
 }
 
 QRect KisMask::exactBounds() const
 {
     QRect resultRect;
 
     if (m_d->selection) {
         resultRect = m_d->selection->selectedExactRect();
 
         // copy for thread safety!
         KisPaintDeviceSP temporaryTarget = this->temporaryTarget();
 
         if (temporaryTarget) {
             resultRect |= temporaryTarget->exactBounds();
         }
     } else if (KisNodeSP parent = this->parent()) {
         resultRect = parent->exactBounds();
     }
 
     return resultRect;
 }
 
 qint32 KisMask::x() const
 {
     return m_d->selection ? m_d->selection->x() :
            m_d->deferredSelectionOffset ? m_d->deferredSelectionOffset->x() :
            parent() ? parent()->x() : 0;
 }
 
 qint32 KisMask::y() const
 {
     return m_d->selection ? m_d->selection->y() :
            m_d->deferredSelectionOffset ? m_d->deferredSelectionOffset->y() :
            parent() ? parent()->y() : 0;
 }
 
 void KisMask::setX(qint32 x)
 {
     if (m_d->selection) {
         m_d->selection->setX(x);
     } else if (!m_d->deferredSelectionOffset) {
         m_d->deferredSelectionOffset.reset(new QPoint(x, 0));
     } else {
         m_d->deferredSelectionOffset->rx() = x;
     }
 }
 
 void KisMask::setY(qint32 y)
 {
     if (m_d->selection) {
         m_d->selection->setY(y);
     } else if (!m_d->deferredSelectionOffset) {
         m_d->deferredSelectionOffset.reset(new QPoint(0, y));
     } else {
         m_d->deferredSelectionOffset->ry() = y;
     }
 }
 
 QRect KisMask::nonDependentExtent() const
 {
     return QRect();
 }
 
 QImage KisMask::createThumbnail(qint32 w, qint32 h)
 {
     KisPaintDeviceSP originalDevice =
         selection() ? selection()->projection() : 0;
 
     return originalDevice ?
            originalDevice->createThumbnail(w, h, 1,
                                            KoColorConversionTransformation::internalRenderingIntent(),
                                            KoColorConversionTransformation::internalConversionFlags()) : QImage();
 }
 
 void KisMask::testingInitSelection(const QRect &rect, KisLayerSP parentLayer)
 {
     if (parentLayer) {
         m_d->selection = new KisSelection(new KisSelectionDefaultBounds(parentLayer->paintDevice(), parentLayer->image()));
     } else {
         m_d->selection = new KisSelection();
     }
 
     m_d->selection->pixelSelection()->select(rect, OPACITY_OPAQUE_U8);
     m_d->selection->updateProjection(rect);
     m_d->selection->setParentNode(this);
 }
 
 KisKeyframeChannel *KisMask::requestKeyframeChannel(const QString &id)
 {
     if (id == KisKeyframeChannel::Content.id()) {
         KisPaintDeviceSP device = paintDevice();
         if (device) {
             KisRasterKeyframeChannel *contentChannel = device->createKeyframeChannel(KisKeyframeChannel::Content);
             contentChannel->setFilenameSuffix(".pixelselection");
             return contentChannel;
        }
     }
 
     return KisNode::requestKeyframeChannel(id);
 }
 
 void KisMask::baseNodeChangedCallback()
 {
     KisNodeSP up = parent();
     KisLayer *layer = dynamic_cast<KisLayer*>(up.data());
     if (layer) {
         layer->notifyChildMaskChanged();
     }
     KisNode::baseNodeChangedCallback();
 }
diff --git a/libs/image/kis_paint_device.cc b/libs/image/kis_paint_device.cc
index 9ccb6d821a..8583d7cc41 100644
--- a/libs/image/kis_paint_device.cc
+++ b/libs/image/kis_paint_device.cc
@@ -1,2214 +1,2216 @@
 /*
  *  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;
 
     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);
 
     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));
     }
 
     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);
 
         q->setDefaultPixel(KoColor(srcData->dataManager()->defaultPixel(), colorSpace()));
         q->setDefaultBounds(src->defaultBounds());
     }
 
     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 DeviceChangeColorSpaceCommand : public KUndo2Command
     {
     public:
         DeviceChangeColorSpaceCommand(KisPaintDeviceSP device, KUndo2Command *parent = 0)
             : KUndo2Command(parent),
               m_firstRun(true),
               m_device(device)
         {
         }
 
         void emitNotifications()
         {
             m_device->emitColorSpaceChanged();
             m_device->setDirty();
         }
 
         void redo() override
         {
             KUndo2Command::redo();
 
             if (!m_firstRun) {
                 m_firstRun = false;
                 return;
             }
 
             emitNotifications();
         }
 
         void undo() override
         {
             KUndo2Command::undo();
             emitNotifications();
         }
 
     private:
         bool m_firstRun;
         KisPaintDeviceSP m_device;
     };
 
 
     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)
 {
     if (!profile) return false;
 
     const KoColorSpace *dstColorSpace =
         KoColorSpaceRegistry::instance()->colorSpace(colorSpace()->colorModelId().id(), colorSpace()->colorDepthId().id(), profile);
     if (!dstColorSpace) return false;
 
     QList<Data*> dataObjects = allDataObjects();
     Q_FOREACH (Data *data, dataObjects) {
         if (!data) continue;
         data->assignColorSpace(dstColorSpace);
     }
     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)
 {
     return m_d->assignProfile(profile);
 }
 
 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_update_scheduler.cpp b/libs/image/kis_update_scheduler.cpp
index 0196cb19b5..ad3a760e59 100644
--- a/libs/image/kis_update_scheduler.cpp
+++ b/libs/image/kis_update_scheduler.cpp
@@ -1,492 +1,497 @@
 /*
  *  Copyright (c) 2010 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_update_scheduler.h"
 
 #include "klocalizedstring.h"
 #include "kis_image_config.h"
 #include "kis_merge_walker.h"
 #include "kis_full_refresh_walker.h"
 
 #include "kis_updater_context.h"
 #include "kis_simple_update_queue.h"
 #include "kis_strokes_queue.h"
 
 #include "kis_queues_progress_updater.h"
 #include "KisImageConfigNotifier.h"
 
 #include <QReadWriteLock>
 #include "kis_lazy_wait_condition.h"
 #include <mutex>
 
 //#define DEBUG_BALANCING
 
 #ifdef DEBUG_BALANCING
 #define DEBUG_BALANCING_METRICS(decidedFirst, excl)                     \
     dbgKrita << "Balance decision:" << decidedFirst                     \
     << "(" << excl << ")"                                               \
     << "updates:" << m_d->updatesQueue.sizeMetric()                    \
     << "strokes:" << m_d->strokesQueue.sizeMetric()
 #else
 #define DEBUG_BALANCING_METRICS(decidedFirst, excl)
 #endif
 
 
 struct Q_DECL_HIDDEN KisUpdateScheduler::Private {
     Private(KisUpdateScheduler *_q, KisProjectionUpdateListener *p)
         : q(_q)
         , updaterContext(KisImageConfig(true).maxNumberOfThreads(), q)
         , projectionUpdateListener(p)
     {}
 
     KisUpdateScheduler *q;
 
     KisSimpleUpdateQueue updatesQueue;
     KisStrokesQueue strokesQueue;
     KisUpdaterContext updaterContext;
     bool processingBlocked = false;
     qreal defaultBalancingRatio = 1.0; // desired strokes-queue-size / updates-queue-size
     KisProjectionUpdateListener *projectionUpdateListener;
     KisQueuesProgressUpdater *progressUpdater = 0;
 
     QAtomicInt updatesLockCounter;
     QReadWriteLock updatesStartLock;
     KisLazyWaitCondition updatesFinishedCondition;
 
     qreal balancingRatio() const {
         const qreal strokeRatioOverride = strokesQueue.balancingRatioOverride();
         return strokeRatioOverride > 0 ? strokeRatioOverride : defaultBalancingRatio;
     }
 };
 
 KisUpdateScheduler::KisUpdateScheduler(KisProjectionUpdateListener *projectionUpdateListener, QObject *parent)
     : QObject(parent),
       m_d(new Private(this, projectionUpdateListener))
 {
     updateSettings();
     connectSignals();
 }
 
 KisUpdateScheduler::KisUpdateScheduler()
     : m_d(new Private(this, 0))
 {
 }
 
 KisUpdateScheduler::~KisUpdateScheduler()
 {
     delete m_d->progressUpdater;
     delete m_d;
 }
 
 void KisUpdateScheduler::setThreadsLimit(int value)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(!m_d->processingBlocked);
 
     /**
      * Thread limit can be changed without the full-featured barrier
      * lock, we can avoid waiting for all the jobs to complete. We
      * should just ensure there is no more jobs in the updater context.
      */
     lock();
     m_d->updaterContext.lock();
     m_d->updaterContext.setThreadsLimit(value);
     m_d->updaterContext.unlock();
     unlock(false);
 }
 
 int KisUpdateScheduler::threadsLimit() const
 {
     std::lock_guard<KisUpdaterContext> l(m_d->updaterContext);
     return m_d->updaterContext.threadsLimit();
 }
 
 void KisUpdateScheduler::connectSignals()
 {
     connect(KisImageConfigNotifier::instance(), SIGNAL(configChanged()),
             SLOT(updateSettings()));
 }
 
 void KisUpdateScheduler::setProgressProxy(KoProgressProxy *progressProxy)
 {
     delete m_d->progressUpdater;
     m_d->progressUpdater = progressProxy ?
         new KisQueuesProgressUpdater(progressProxy, this) : 0;
 }
 
 void KisUpdateScheduler::progressUpdate()
 {
     if (!m_d->progressUpdater) return;
 
     if(!m_d->strokesQueue.hasOpenedStrokes()) {
         QString jobName = m_d->strokesQueue.currentStrokeName().toString();
         if(jobName.isEmpty()) {
             jobName = i18n("Updating...");
         }
 
         int sizeMetric = m_d->strokesQueue.sizeMetric();
         if (!sizeMetric) {
             sizeMetric = m_d->updatesQueue.sizeMetric();
         }
 
         m_d->progressUpdater->updateProgress(sizeMetric, jobName);
     }
     else {
         m_d->progressUpdater->hide();
     }
 }
 
 void KisUpdateScheduler::updateProjection(KisNodeSP node, const QVector<QRect> &rects, const QRect &cropRect)
 {
     m_d->updatesQueue.addUpdateJob(node, rects, cropRect, currentLevelOfDetail());
     processQueues();
 }
 
 void KisUpdateScheduler::updateProjection(KisNodeSP node, const QRect &rc, const QRect &cropRect)
 {
     m_d->updatesQueue.addUpdateJob(node, rc, cropRect, currentLevelOfDetail());
     processQueues();
 }
 
 void KisUpdateScheduler::updateProjectionNoFilthy(KisNodeSP node, const QRect& rc, const QRect &cropRect)
 {
     m_d->updatesQueue.addUpdateNoFilthyJob(node, rc, cropRect, currentLevelOfDetail());
     processQueues();
 }
 
 void KisUpdateScheduler::fullRefreshAsync(KisNodeSP root, const QRect& rc, const QRect &cropRect)
 {
     m_d->updatesQueue.addFullRefreshJob(root, rc, cropRect, currentLevelOfDetail());
     processQueues();
 }
 
 void KisUpdateScheduler::fullRefresh(KisNodeSP root, const QRect& rc, const QRect &cropRect)
 {
     KisBaseRectsWalkerSP walker = new KisFullRefreshWalker(cropRect);
     walker->collectRects(root, rc);
 
     bool needLock = true;
 
     if(m_d->processingBlocked) {
         warnImage << "WARNING: Calling synchronous fullRefresh under a scheduler lock held";
         warnImage << "We will not assert for now, but please port caller's to strokes";
         warnImage << "to avoid this warning";
         needLock = false;
     }
 
     if(needLock) lock();
     m_d->updaterContext.lock();
 
     Q_ASSERT(m_d->updaterContext.isJobAllowed(walker));
     m_d->updaterContext.addMergeJob(walker);
     m_d->updaterContext.waitForDone();
 
     m_d->updaterContext.unlock();
     if(needLock) unlock(true);
 }
 
 void KisUpdateScheduler::addSpontaneousJob(KisSpontaneousJob *spontaneousJob)
 {
     m_d->updatesQueue.addSpontaneousJob(spontaneousJob);
     processQueues();
 }
 
+bool KisUpdateScheduler::hasUpdatesRunning() const
+{
+    return !m_d->updatesQueue.isEmpty();
+}
+
 KisStrokeId KisUpdateScheduler::startStroke(KisStrokeStrategy *strokeStrategy)
 {
     KisStrokeId id  = m_d->strokesQueue.startStroke(strokeStrategy);
     processQueues();
     return id;
 }
 
 void KisUpdateScheduler::addJob(KisStrokeId id, KisStrokeJobData *data)
 {
     m_d->strokesQueue.addJob(id, data);
     processQueues();
 }
 
 void KisUpdateScheduler::endStroke(KisStrokeId id)
 {
     m_d->strokesQueue.endStroke(id);
     processQueues();
 }
 
 bool KisUpdateScheduler::cancelStroke(KisStrokeId id)
 {
     bool result = m_d->strokesQueue.cancelStroke(id);
     processQueues();
     return result;
 }
 
 bool KisUpdateScheduler::tryCancelCurrentStrokeAsync()
 {
     return m_d->strokesQueue.tryCancelCurrentStrokeAsync();
 }
 
 UndoResult KisUpdateScheduler::tryUndoLastStrokeAsync()
 {
     return m_d->strokesQueue.tryUndoLastStrokeAsync();
 }
 
 bool KisUpdateScheduler::wrapAroundModeSupported() const
 {
     return m_d->strokesQueue.wrapAroundModeSupported();
 }
 
 void KisUpdateScheduler::setDesiredLevelOfDetail(int lod)
 {
     m_d->strokesQueue.setDesiredLevelOfDetail(lod);
 
     /**
      * The queue might have started an internal stroke for
      * cache synchronization. Process the queues to execute
      * it if needed.
      */
     processQueues();
 }
 
 void KisUpdateScheduler::explicitRegenerateLevelOfDetail()
 {
     m_d->strokesQueue.explicitRegenerateLevelOfDetail();
 
     // \see a comment in setDesiredLevelOfDetail()
     processQueues();
 }
 
 int KisUpdateScheduler::currentLevelOfDetail() const
 {
     int levelOfDetail = m_d->updaterContext.currentLevelOfDetail();
 
     if (levelOfDetail < 0) {
         levelOfDetail = m_d->updatesQueue.overrideLevelOfDetail();
     }
 
     if (levelOfDetail < 0) {
         levelOfDetail = 0;
     }
 
     return levelOfDetail;
 }
 
 void KisUpdateScheduler::setLod0ToNStrokeStrategyFactory(const KisLodSyncStrokeStrategyFactory &factory)
 {
     m_d->strokesQueue.setLod0ToNStrokeStrategyFactory(factory);
 }
 
 void KisUpdateScheduler::setSuspendUpdatesStrokeStrategyFactory(const KisSuspendResumeStrategyFactory &factory)
 {
     m_d->strokesQueue.setSuspendUpdatesStrokeStrategyFactory(factory);
 }
 
 void KisUpdateScheduler::setResumeUpdatesStrokeStrategyFactory(const KisSuspendResumeStrategyFactory &factory)
 {
     m_d->strokesQueue.setResumeUpdatesStrokeStrategyFactory(factory);
 }
 
 KisPostExecutionUndoAdapter *KisUpdateScheduler::lodNPostExecutionUndoAdapter() const
 {
     return m_d->strokesQueue.lodNPostExecutionUndoAdapter();
 }
 
 void KisUpdateScheduler::updateSettings()
 {
     m_d->updatesQueue.updateSettings();
     KisImageConfig config(true);
     m_d->defaultBalancingRatio = config.schedulerBalancingRatio();
     setThreadsLimit(config.maxNumberOfThreads());
 }
 
 void KisUpdateScheduler::lock()
 {
     m_d->processingBlocked = true;
     m_d->updaterContext.waitForDone();
 }
 
 void KisUpdateScheduler::unlock(bool resetLodLevels)
 {
     if (resetLodLevels) {
         /**
          * Legacy strokes may have changed the image while we didn't
          * control it. Notify the queue to take it into account.
          */
         m_d->strokesQueue.notifyUFOChangedImage();
     }
 
     m_d->processingBlocked = false;
     processQueues();
 }
 
 bool KisUpdateScheduler::isIdle()
 {
     bool result = false;
 
     if (tryBarrierLock()) {
         result = true;
         unlock(false);
     }
 
     return result;
 }
 
 void KisUpdateScheduler::waitForDone()
 {
     do {
         processQueues();
         m_d->updaterContext.waitForDone();
     } while(!m_d->updatesQueue.isEmpty() || !m_d->strokesQueue.isEmpty());
 }
 
 bool KisUpdateScheduler::tryBarrierLock()
 {
     if(!m_d->updatesQueue.isEmpty() || !m_d->strokesQueue.isEmpty()) {
         return false;
     }
 
     m_d->processingBlocked = true;
     m_d->updaterContext.waitForDone();
     if(!m_d->updatesQueue.isEmpty() || !m_d->strokesQueue.isEmpty()) {
         m_d->processingBlocked = false;
         processQueues();
         return false;
     }
 
     return true;
 }
 
 void KisUpdateScheduler::barrierLock()
 {
     do {
         m_d->processingBlocked = false;
         processQueues();
         m_d->processingBlocked = true;
         m_d->updaterContext.waitForDone();
     } while(!m_d->updatesQueue.isEmpty() || !m_d->strokesQueue.isEmpty());
 }
 
 void KisUpdateScheduler::processQueues()
 {
     wakeUpWaitingThreads();
 
     if(m_d->processingBlocked) return;
 
     if(m_d->strokesQueue.needsExclusiveAccess()) {
         DEBUG_BALANCING_METRICS("STROKES", "X");
         m_d->strokesQueue.processQueue(m_d->updaterContext,
                                         !m_d->updatesQueue.isEmpty());
 
         if(!m_d->strokesQueue.needsExclusiveAccess()) {
             tryProcessUpdatesQueue();
         }
     }
     else if(m_d->balancingRatio() * m_d->strokesQueue.sizeMetric() > m_d->updatesQueue.sizeMetric()) {
         DEBUG_BALANCING_METRICS("STROKES", "N");
         m_d->strokesQueue.processQueue(m_d->updaterContext,
                                         !m_d->updatesQueue.isEmpty());
         tryProcessUpdatesQueue();
     }
     else {
         DEBUG_BALANCING_METRICS("UPDATES", "N");
         tryProcessUpdatesQueue();
         m_d->strokesQueue.processQueue(m_d->updaterContext,
                                         !m_d->updatesQueue.isEmpty());
 
     }
 
     progressUpdate();
 }
 
 void KisUpdateScheduler::blockUpdates()
 {
     m_d->updatesFinishedCondition.initWaiting();
 
     m_d->updatesLockCounter.ref();
     while(haveUpdatesRunning()) {
         m_d->updatesFinishedCondition.wait();
     }
 
     m_d->updatesFinishedCondition.endWaiting();
 }
 
 void KisUpdateScheduler::unblockUpdates()
 {
     m_d->updatesLockCounter.deref();
     processQueues();
 }
 
 void KisUpdateScheduler::wakeUpWaitingThreads()
 {
     if(m_d->updatesLockCounter && !haveUpdatesRunning()) {
         m_d->updatesFinishedCondition.wakeAll();
     }
 }
 
 void KisUpdateScheduler::tryProcessUpdatesQueue()
 {
     QReadLocker locker(&m_d->updatesStartLock);
     if(m_d->updatesLockCounter) return;
 
     m_d->updatesQueue.processQueue(m_d->updaterContext);
 }
 
 bool KisUpdateScheduler::haveUpdatesRunning()
 {
     QWriteLocker locker(&m_d->updatesStartLock);
 
     qint32 numMergeJobs, numStrokeJobs;
     m_d->updaterContext.getJobsSnapshot(numMergeJobs, numStrokeJobs);
 
     return numMergeJobs;
 }
 
 void KisUpdateScheduler::continueUpdate(const QRect &rect)
 {
     Q_ASSERT(m_d->projectionUpdateListener);
     m_d->projectionUpdateListener->notifyProjectionUpdated(rect);
 }
 
 void KisUpdateScheduler::doSomeUsefulWork()
 {
     m_d->updatesQueue.optimize();
 }
 
 void KisUpdateScheduler::spareThreadAppeared()
 {
     processQueues();
 }
 
 KisTestableUpdateScheduler::KisTestableUpdateScheduler(KisProjectionUpdateListener *projectionUpdateListener,
                                                        qint32 threadCount)
 {
     Q_UNUSED(threadCount);
     updateSettings();
     m_d->projectionUpdateListener = projectionUpdateListener;
 
     // The queue will update settings in a constructor itself
     // m_d->updatesQueue = new KisTestableSimpleUpdateQueue();
     // m_d->strokesQueue = new KisStrokesQueue();
 
     connectSignals();
 }
 
 KisUpdaterContext *KisTestableUpdateScheduler::updaterContext()
 {
     return &m_d->updaterContext;
 }
 
 KisTestableSimpleUpdateQueue* KisTestableUpdateScheduler::updateQueue()
 {
     return dynamic_cast<KisTestableSimpleUpdateQueue*>(&m_d->updatesQueue);
 }
diff --git a/libs/image/kis_update_scheduler.h b/libs/image/kis_update_scheduler.h
index 477298a342..24b5a247d2 100644
--- a/libs/image/kis_update_scheduler.h
+++ b/libs/image/kis_update_scheduler.h
@@ -1,252 +1,254 @@
 /*
  *  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_UPDATE_SCHEDULER_H
 #define __KIS_UPDATE_SCHEDULER_H
 
 #include <QObject>
 #include "kritaimage_export.h"
 #include "kis_types.h"
 
 #include "kis_image_interfaces.h"
 #include "kis_stroke_strategy_factory.h"
 #include "kis_strokes_queue_undo_result.h"
 
 class QRect;
 class KoProgressProxy;
 class KisProjectionUpdateListener;
 class KisSpontaneousJob;
 class KisPostExecutionUndoAdapter;
 
 
 class KRITAIMAGE_EXPORT KisUpdateScheduler : public QObject, public KisStrokesFacade
 {
     Q_OBJECT
 
 public:
     KisUpdateScheduler(KisProjectionUpdateListener *projectionUpdateListener, QObject *parent = 0);
     ~KisUpdateScheduler() override;
 
     /**
      * Set the number of threads used by the scheduler
      */
     void setThreadsLimit(int value);
 
     /**
      * Return the number of threads available to the scheduler
      */
     int threadsLimit() const;
 
     /**
      * Sets the proxy that is going to be notified about the progress
      * of processing of the queues. If you want to switch the proxy
      * on runtime, you should do it under the lock held.
      *
      * \see lock(), unlock()
      */
     void setProgressProxy(KoProgressProxy *progressProxy);
 
     /**
      * Blocks processing of the queues.
      * The function will wait until all the executing jobs
      * are finished.
      * NOTE: you may add new jobs while the block held, but they
      * will be delayed until unlock() is called.
      *
      * \see unlock()
      */
     void lock();
 
     /**
      * Unblocks the process and calls processQueues()
      *
      * \see processQueues()
      */
     void unlock(bool resetLodLevels = true);
 
     /**
      * Waits until all the running jobs are finished.
      *
      * If some other thread adds jobs in parallel, then you may
      * wait forever. If you you don't want it, consider lock() instead.
      *
      * \see lock()
      */
     void waitForDone();
 
     /**
      * Waits until the queues become empty, then blocks the processing.
      * To unblock processing you should use unlock().
      *
      * If some other thread adds jobs in parallel, then you may
      * wait forever. If you you don't want it, consider lock() instead.
      *
      * \see unlock(), lock()
      */
     void barrierLock();
 
 
     /**
      * Works like barrier lock, but returns false immediately if barrierLock
      * can't be acquired.
      *
      * \see barrierLock()
      */
     bool tryBarrierLock();
 
     /**
      * Tells if there are no strokes or updates are running at the
      * moment. Internally calls to tryBarrierLock(), so it is not O(1).
      */
     bool isIdle();
 
     /**
      * Blocks all the updates from execution. It doesn't affect
      * strokes execution in any way. This type of lock is supposed
      * to be held by the strokes themselves when they need a short
      * access to some parts of the projection of the image.
      *
      * From all the other places you should use usual lock()/unlock()
      * methods
      *
      * \see lock(), unlock()
      */
     void blockUpdates();
 
     /**
      * Unblocks updates from execution previously locked by blockUpdates()
      *
      * \see blockUpdates()
      */
     void unblockUpdates();
 
     void updateProjection(KisNodeSP node, const QVector<QRect> &rects, const QRect &cropRect);
     void updateProjection(KisNodeSP node, const QRect &rc, const QRect &cropRect);
     void updateProjectionNoFilthy(KisNodeSP node, const QRect& rc, const QRect &cropRect);
     void fullRefreshAsync(KisNodeSP root, const QRect& rc, const QRect &cropRect);
     void fullRefresh(KisNodeSP root, const QRect& rc, const QRect &cropRect);
     void addSpontaneousJob(KisSpontaneousJob *spontaneousJob);
 
+    bool hasUpdatesRunning() const;
+
     KisStrokeId startStroke(KisStrokeStrategy *strokeStrategy) override;
     void addJob(KisStrokeId id, KisStrokeJobData *data) override;
     void endStroke(KisStrokeId id) override;
     bool cancelStroke(KisStrokeId id) override;
 
     /**
      * Sets the desired level of detail on which the strokes should
      * work.  Please note that this configuration will be applied
      * starting from the next stroke. Please also note that this value
      * is not guaranteed to coincide with the one returned by
      * currentLevelOfDetail()
      */
     void setDesiredLevelOfDetail(int lod);
 
     /**
      * 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();
 
     /**
      * Install a factory of a stroke strategy, that will be started
      * every time when the scheduler needs to synchronize LOD caches
      * of all the paint devices of the image.
      */
     void setLod0ToNStrokeStrategyFactory(const KisLodSyncStrokeStrategyFactory &factory);
 
     /**
      * Install a factory of a stroke strategy, that will be started
      * every time when the scheduler needs to postpone all the updates
      * of the *LOD0* strokes.
      */
     void setSuspendUpdatesStrokeStrategyFactory(const KisSuspendResumeStrategyFactory &factory);
 
     /**
      * \see setSuspendUpdatesStrokeStrategyFactory()
      */
     void setResumeUpdatesStrokeStrategyFactory(const KisSuspendResumeStrategyFactory &factory);
 
     KisPostExecutionUndoAdapter* lodNPostExecutionUndoAdapter() const;
 
 
     /**
      * tryCancelCurrentStrokeAsync() checks whether there is a
      * *running* stroke (which is being executed at this very moment)
      * which is not still open by the owner (endStroke() or
      * cancelStroke() have already been called) and cancels it.
      *
      * \return true if some stroke has been found and cancelled
      *
      * \note This method is *not* part of KisStrokesFacade! It is too
      *       low level for KisImage.  In KisImage it is combined with
      *       more high level requestStrokeCancellation().
      */
     bool tryCancelCurrentStrokeAsync();
 
     UndoResult tryUndoLastStrokeAsync();
 
     bool wrapAroundModeSupported() const;
     int currentLevelOfDetail() const;
 
     void continueUpdate(const QRect &rect);
     void doSomeUsefulWork();
     void spareThreadAppeared();
 
 protected:
     // Trivial constructor for testing support
     KisUpdateScheduler();
     void connectSignals();
     void processQueues();
 
 protected Q_SLOTS:
     /**
      * Called when it is necessary to reread configuration
      */
     void updateSettings();
 
 private:
     friend class UpdatesBlockTester;
     bool haveUpdatesRunning();
     void tryProcessUpdatesQueue();
     void wakeUpWaitingThreads();
 
     void progressUpdate();
 
 protected:
     struct Private;
     Private * const m_d;
 };
 
 
 class KisTestableSimpleUpdateQueue;
 class KisUpdaterContext;
 
 class KRITAIMAGE_EXPORT KisTestableUpdateScheduler : public KisUpdateScheduler
 {
 public:
     KisTestableUpdateScheduler(KisProjectionUpdateListener *projectionUpdateListener,
                                qint32 threadCount);
 
     KisUpdaterContext* updaterContext();
     KisTestableSimpleUpdateQueue* updateQueue();
     using KisUpdateScheduler::processQueues;
 };
 
 #endif /* __KIS_UPDATE_SCHEDULER_H */
 
diff --git a/libs/image/tests/data/rotation_120_result.png b/libs/image/tests/data/rotation_120_result.png
index b3b83c8982..c003a9eacf 100644
Binary files a/libs/image/tests/data/rotation_120_result.png and b/libs/image/tests/data/rotation_120_result.png differ
diff --git a/libs/image/tests/data/rotation_210_result.png b/libs/image/tests/data/rotation_210_result.png
index 393efdd777..3fb2c285bf 100644
Binary files a/libs/image/tests/data/rotation_210_result.png and b/libs/image/tests/data/rotation_210_result.png differ
diff --git a/libs/image/tests/data/rotation_300_result.png b/libs/image/tests/data/rotation_300_result.png
index 38944a451e..928376768c 100644
Binary files a/libs/image/tests/data/rotation_300_result.png and b/libs/image/tests/data/rotation_300_result.png differ
diff --git a/libs/image/tests/data/rotation_30_result.png b/libs/image/tests/data/rotation_30_result.png
index dcc99a5e64..e9befff875 100644
Binary files a/libs/image/tests/data/rotation_30_result.png and b/libs/image/tests/data/rotation_30_result.png differ
diff --git a/libs/image/tests/data/rotation_60_result.png b/libs/image/tests/data/rotation_60_result.png
index 0f07fd48e9..8875416173 100644
Binary files a/libs/image/tests/data/rotation_60_result.png and b/libs/image/tests/data/rotation_60_result.png differ
diff --git a/libs/image/tests/data/rotation_90_result.png b/libs/image/tests/data/rotation_90_result.png
index a3f2341cbb..aececb3ee6 100644
Binary files a/libs/image/tests/data/rotation_90_result.png and b/libs/image/tests/data/rotation_90_result.png differ
diff --git a/libs/image/tests/data/scaledownx_result.png b/libs/image/tests/data/scaledownx_result.png
index 1d708e2b29..05819a2713 100644
Binary files a/libs/image/tests/data/scaledownx_result.png and b/libs/image/tests/data/scaledownx_result.png differ
diff --git a/libs/image/tests/data/scaledowny_result.png b/libs/image/tests/data/scaledowny_result.png
index 8ac041caf3..dbe8faa3ee 100644
Binary files a/libs/image/tests/data/scaledowny_result.png and b/libs/image/tests/data/scaledowny_result.png differ
diff --git a/libs/image/tests/data/test_scaledown_result.png b/libs/image/tests/data/test_scaledown_result.png
index 409fac410d..037e9b6359 100644
Binary files a/libs/image/tests/data/test_scaledown_result.png and b/libs/image/tests/data/test_scaledown_result.png differ
diff --git a/libs/image/tests/kis_transform_worker_test.cpp b/libs/image/tests/kis_transform_worker_test.cpp
index 0613bd4967..48dfea4172 100644
--- a/libs/image/tests/kis_transform_worker_test.cpp
+++ b/libs/image/tests/kis_transform_worker_test.cpp
@@ -1,997 +1,993 @@
 /*
  *  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_transform_worker_test.h"
 
 #include <QTest>
 #include <KoProgressUpdater.h>
 #include <KoColor.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <QTransform>
 #include <QVector>
 
 #include "kis_types.h"
 #include "kis_image.h"
 #include "kis_filter_strategy.h"
 #include "kis_paint_device.h"
 #include "kis_transform_worker.h"
 #include "testutil.h"
 #include "kis_transaction.h"
 #include "kis_random_accessor_ng.h"
 
 void KisTransformWorkerTest::testCreation()
 {
     TestUtil::TestProgressBar bar;
     KoProgressUpdater pu(&bar);
     KoUpdaterPtr updater = pu.startSubtask();
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisFilterStrategy * filter = new KisBoxFilterStrategy();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     KisTransformWorker tw(dev, 1.0, 1.0,
                           1.0, 1.0,
                           0.0, 0.0,
                           1.5,
                           0, 0, updater, filter);
 }
 
 void testMirror(const QRect &imageRect, const QRect &mirrorRect, Qt::Orientation orientation)
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     qreal axis = QRectF(mirrorRect).center().x();
 
     KisRandomAccessorSP it = dev->createRandomAccessorNG(imageRect.x(), imageRect.y());
 
     int i = 0;
     for (int y = imageRect.y(); y < imageRect.y() + imageRect.height(); y++) {
         for (int x = imageRect.x(); x < imageRect.x() + imageRect.width(); x++) {
             it->moveTo(x, y);
 
             *reinterpret_cast<quint32*>(it->rawData()) = 0xFFFFFFFF - i++;
         }
     }
 
     QCOMPARE(dev->exactBounds(), imageRect);
 
 
     QImage srcImage = dev->convertToQImage(0, mirrorRect.x(), mirrorRect.y(), mirrorRect.width(), mirrorRect.height());
     QImage mirroredImage = srcImage.mirrored(orientation == Qt::Horizontal, orientation == Qt::Vertical);
     QImage result;
 
     //srcImage.save("input.png");
     //mirroredImage.save("mirror_expected.png");
 
     QBENCHMARK_ONCE {
         KisTransformWorker::mirror(dev, axis, orientation);
     }
     result = dev->convertToQImage(0, mirrorRect.x(), mirrorRect.y(), mirrorRect.width(), mirrorRect.height());
     QCOMPARE(result, mirroredImage);
 
     //result.save("mirror1.png");
 
     KisTransformWorker::mirror(dev, axis, orientation);
     result = dev->convertToQImage(0, mirrorRect.x(), mirrorRect.y(), mirrorRect.width(), mirrorRect.height());
     QCOMPARE(result, srcImage);
 
     //result.save("mirror2.png");
 
     KisTransformWorker::mirror(dev, axis, orientation);
     result = dev->convertToQImage(0, mirrorRect.x(), mirrorRect.y(), mirrorRect.width(), mirrorRect.height());
     QCOMPARE(result, mirroredImage);
 
     //result.save("mirror3.png");
 }
 
 void KisTransformWorkerTest::testMirrorX_Even()
 {
     testMirror(QRect(10,10,30,30), QRect(1,1,70,70), Qt::Horizontal);
 }
 
 void KisTransformWorkerTest::testMirrorX_Odd()
 {
     testMirror(QRect(10,10,30,30), QRect(1,1,71,71), Qt::Horizontal);
 }
 
 void KisTransformWorkerTest::testMirrorY_Even()
 {
     testMirror(QRect(10,10,30,30), QRect(1,1,70,70), Qt::Vertical);
 }
 
 void KisTransformWorkerTest::testMirrorY_Odd()
 {
     testMirror(QRect(10,10,30,30), QRect(1,1,71,71), Qt::Vertical);
 }
 
 void KisTransformWorkerTest::benchmarkMirrorX()
 {
     testMirror(QRect(10,10,4000,4000), QRect(1,1,7000,7000), Qt::Horizontal);
 }
 
 void KisTransformWorkerTest::benchmarkMirrorY()
 {
     testMirror(QRect(10,10,4000,4000), QRect(1,1,7000,7000), Qt::Vertical);
 }
 
 void KisTransformWorkerTest::testOffset()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     QString imageName("mirror_source.png");
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + imageName);
     QPoint bottomRight(image.width(), image.height());
     KisPaintDeviceSP dev2 = new KisPaintDevice(cs);
 
     QVector<QPoint> offsetPoints;
     offsetPoints.append(QPoint(image.width() / 2, image.height() / 2));     // offset to 1/2 of image
     offsetPoints.append(QPoint(image.width() / 4, image.height() / 4)); // offset to 1/4 of image
     offsetPoints.append(QPoint(image.width() - image.width() / 4, image.height() - image.height() / 4)); // offset to 3/4 of image
     offsetPoints.append(QPoint(image.width() / 4, 0));      // offset with y == 0
     offsetPoints.append(QPoint(0, image.height() / 4));     // offset with x == 0
 
     QPoint errpoint;
     QPoint backOffsetPoint;
     QImage result;
     int test = 0;
     QPoint origin(0,0);
     Q_FOREACH (QPoint offsetPoint, offsetPoints)
     {
         dev2->convertFromQImage(image, 0);
         KisTransformWorker::offset(dev2, offsetPoint, QRect(origin, image.size()) );
         backOffsetPoint = bottomRight - offsetPoint;
         KisTransformWorker::offset(dev2, backOffsetPoint , QRect(origin, image.size()) );
         result = dev2->convertToQImage(0, 0, 0, image.width(), image.height());
         if (!TestUtil::compareQImages(errpoint, image, result))
         {
             // They are the same, but should be mirrored
             image.save(QString("offset_test_%1_source.png").arg(test));
             result.save(QString("offset_test_%1_result.png").arg(test));
             QFAIL(QString("Failed to offset the image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
         }
     }
 }
 
 
 void KisTransformWorkerTest::testMirrorTransactionX()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "mirror_source.png");
     KisPaintDeviceSP dev2 = new KisPaintDevice(cs);
     dev2->convertFromQImage(image, 0);
 
     KisTransaction t(kundo2_noi18n("mirror"), dev2);
     KisTransformWorker::mirrorX(dev2);
     t.end();
 
     QImage result = dev2->convertToQImage(0, 0, 0, image.width(), image.height());
 
     image = image.mirrored(true, false);
 
     QPoint errpoint;
     if (!TestUtil::compareQImages(errpoint, image, result)) {
         // They are the same, but should be mirrored
         image.save("mirror_test_3_source.png");
         result.save("mirror_test_3_result.png");
         QFAIL(QString("Failed to mirror the image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
 
     }
 }
 void KisTransformWorkerTest::testMirrorTransactionY()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "mirror_source.png");
     KisPaintDeviceSP dev2 = new KisPaintDevice(cs);
     dev2->convertFromQImage(image, 0);
 
     KisTransaction t(kundo2_noi18n("mirror"), dev2);
     KisTransformWorker::mirrorY(dev2);
     t.end();
 
     QImage result = dev2->convertToQImage(0, 0, 0, image.width(), image.height());
 
     image = image.mirrored(false, true);
 
     QPoint errpoint;
     if (!TestUtil::compareQImages(errpoint, image, result)) {
         // They are the same, but should be mirrored
         image.save("mirror_test_4_source.png");
         result.save("mirror_test_4_result.png");
         QFAIL(QString("Failed to mirror the image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 }
 
 void KisTransformWorkerTest::testScaleUp()
 {
     TestUtil::TestProgressBar bar;
     KoProgressUpdater pu(&bar);
     KoUpdaterPtr updater = pu.startSubtask();
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "mirror_source.png");
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->convertFromQImage(image, 0);
 
     KisFilterStrategy * filter = new KisBoxFilterStrategy();
     KisTransaction t(dev);
     KisTransformWorker tw(dev, 2.4, 2.4,
                           0.0, 0.0,
                           0.0, 0.0,
                           0.0,
                           0, 0, updater, filter);
     tw.run();
     t.end();
 
     QRect rc = dev->exactBounds();
 
     QCOMPARE(rc.width(), qCeil(image.width() * 2.4));
     QCOMPARE(rc.height(), qCeil(image.height() * 2.4));
 
     QImage result = dev->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height());
     QPoint errpoint;
     image.load(QString(FILES_DATA_DIR) + QDir::separator() + "test_scaleup_result.png");
     if (!TestUtil::compareQImages(errpoint, image, result)) {
         image.save("test_scaleup_source.png");
         result.save("test_scaleup_result.png");
         QFAIL(QString("Failed to scale the image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 }
 
 
 void KisTransformWorkerTest::testXScaleUp()
 {
     TestUtil::TestProgressBar bar;
     KoProgressUpdater pu(&bar);
     KoUpdaterPtr updater = pu.startSubtask();
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "mirror_source.png");
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->convertFromQImage(image, 0);
 
     KisFilterStrategy * filter = new KisBoxFilterStrategy();
     KisTransaction t(dev);
     KisTransformWorker tw(dev, 2.0, 1.0,
                           0.0, 0.0,
                           0.0, 0.0,
                           0.0,
                           0, 0, updater, filter);
     tw.run();
     t.end();
 
     QRect rc = dev->exactBounds();
 
     QVERIFY(rc.width() == image.width() * 2);
     QVERIFY(rc.height() == image.height());
 
     QImage result = dev->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height());
     QPoint errpoint;
     image.load(QString(FILES_DATA_DIR) + QDir::separator() + "scaleupx_result.png");
     if (!TestUtil::compareQImages(errpoint, image, result)) {
         image.save("test_x_scaleup_source.png");
         result.save("test_x_scaleup_result.png");
         QFAIL(QString("Failed to scale up the image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 }
 
 void KisTransformWorkerTest::testYScaleUp()
 {
     TestUtil::TestProgressBar bar;
     KoProgressUpdater pu(&bar);
     KoUpdaterPtr updater = pu.startSubtask();
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "mirror_source.png");
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->convertFromQImage(image, 0);
 
     KisFilterStrategy * filter = new KisBoxFilterStrategy();
 
     KisTransaction t(dev);
     KisTransformWorker tw(dev, 1.0, 2.0,
                           0.0, 0.0,
                           0.0, 0.0,
                           0.0,
                           0, 0, updater, filter);
     tw.run();
     t.end();
 
     QRect rc = dev->exactBounds();
 
     QCOMPARE(rc.width(), image.width());
     QCOMPARE(rc.height(), image.height() * 2);
 
     QImage result = dev->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height());
     QPoint errpoint;
     image.load(QString(FILES_DATA_DIR) + QDir::separator() + "scaleupy_result.png");
     if (!TestUtil::compareQImages(errpoint, image, result)) {
         image.save("test_y_scaleup_source.png");
         result.save("test_y_scaleup_result.png");
         QFAIL(QString("Failed to scale up the image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 }
 
 void KisTransformWorkerTest::testIdentity()
 {
     TestUtil::TestProgressBar bar;
     KoProgressUpdater pu(&bar);
     KoUpdaterPtr updater = pu.startSubtask();
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "mirror_source.png");
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->convertFromQImage(image, 0);
     KisFilterStrategy * filter = new KisBoxFilterStrategy();
 
     KisTransaction t(dev);
     KisTransformWorker tw(dev, 1.0, 1.0,
                           0.0, 0.0,
                           0.0, 0.0,
                           0.0,
                           0, 0, updater, filter);
     tw.run();
     t.end();
 
     QRect rc = dev->exactBounds();
 
     QVERIFY(rc.width() ==image.width());
     QVERIFY(rc.height() == image.height());
 
     QImage result = dev->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height());
     QPoint errpoint;
     if (!TestUtil::compareQImages(errpoint, image, result)) {
         image.save("test_identity_source.png");
         result.save("test_identity_result.png");
         QFAIL(QString("Failed to apply identity transformation to image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 }
 
 void KisTransformWorkerTest::testScaleDown()
 {
     TestUtil::TestProgressBar bar;
     KoProgressUpdater pu(&bar);
     KoUpdaterPtr updater = pu.startSubtask();
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "mirror_source.png");
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->convertFromQImage(image, 0);
     KisFilterStrategy * filter = new KisBoxFilterStrategy();
 
     KisTransaction t(dev);
     KisTransformWorker tw(dev, 0.123, 0.123,
                           0.0, 0.0,
                           0.0, 0.0,
                           0.0,
                           0, 0, updater, filter);
     tw.run();
     t.end();
 
     QRect rc = dev->exactBounds();
 
     QCOMPARE(rc.width(), qCeil(image.width() * 0.123));
     QCOMPARE(rc.height(), qCeil(image.height() * 0.123));
 
 //    KisTransaction t2("test", dev);
 //    KisRandomAccessorSP ac = dev->createRandomAccessorNG(rc.x(), rc.y());
 //    for(int x = rc.x(); x < rc.width(); ++x) {
 //        for(int y = rc.y(); y < rc.height(); ++y) {
 //            ac->moveTo(x, y);
 //            cs->setOpacity(ac->rawData(), 0.5, 1);
 //        }
 //    }
 //    t2.end();
 
     QImage result = dev->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height());
     QPoint errpoint;
     image.load(QString(FILES_DATA_DIR) + QDir::separator() + "test_scaledown_result.png");
     if (!TestUtil::compareQImages(errpoint, image, result)) {
         image.save("test_scaledown_source.png");
         result.save("test_scaledown_result.png");
         QFAIL(QString("Failed to scale down the image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 }
 
 
 void KisTransformWorkerTest::testXScaleDown()
 {
     TestUtil::TestProgressBar bar;
     KoProgressUpdater pu(&bar);
     KoUpdaterPtr updater = pu.startSubtask();
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "mirror_source.png");
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->convertFromQImage(image, 0);
 
     KisFilterStrategy * filter = new KisBoxFilterStrategy();
 
     KisTransaction t(dev);
     KisTransformWorker tw(dev, 0.123, 1.0,
                           0.0, 0.0,
                           0.0, 0.0,
                           0.0,
                           0, 0, updater, filter);
     tw.run();
     t.end();
 
     QRect rc = dev->exactBounds();
-
-    QCOMPARE(rc.width(), qCeil(image.width() * 0.123));
-    QCOMPARE(rc.height(), image.height());
-
     QImage result = dev->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height());
     QPoint errpoint;
     image.load(QString(FILES_DATA_DIR) + QDir::separator() + "scaledownx_result.png");
     if (!TestUtil::compareQImages(errpoint, image, result)) {
         image.save("scaledownx_source.png");
         result.save("scaledownx_result.png");
         QFAIL(QString("Failed to scale down the image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 }
 
 void KisTransformWorkerTest::testYScaleDown()
 {
     TestUtil::TestProgressBar bar;
     KoProgressUpdater pu(&bar);
     KoUpdaterPtr updater = pu.startSubtask();
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "mirror_source.png");
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->convertFromQImage(image, 0);
 
     KisFilterStrategy * filter = new KisBoxFilterStrategy();
     KisTransaction t(dev);
     KisTransformWorker tw(dev, 1.0, 0.123,
                           0.0, 0.0,
                           0.0, 0.0,
                           0.0,
                           0, 0, updater, filter);
     tw.run();
     t.end();
 
     QRect rc = dev->exactBounds();
 
     QCOMPARE(rc.width(), image.width());
     QCOMPARE(rc.height(), qCeil(image.height() * 0.123));
 
     QImage result = dev->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height());
     QPoint errpoint;
     image.load(QString(FILES_DATA_DIR) + QDir::separator() + "scaledowny_result.png");
     if (!TestUtil::compareQImages(errpoint, image, result)) {
         image.save("scaledowny_source.png");
         result.save("scaledowny_result.png");
         QFAIL(QString("Failed to scale down the image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 }
 
 void KisTransformWorkerTest::testXShear()
 {
     TestUtil::TestProgressBar bar;
     KoProgressUpdater pu(&bar);
     KoUpdaterPtr updater = pu.startSubtask();
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "mirror_source.png");
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->convertFromQImage(image, 0);
 
     KisFilterStrategy * filter = new KisBoxFilterStrategy();
 
     KisTransaction t(dev);
     KisTransformWorker tw(dev, 1.0, 1.0,
                           1.0, 0.0,
                           300., 200.,
                           0.0,
                           0, 0, updater, filter);
     tw.run();
     t.end();
 
     QRect rc = dev->exactBounds();
 
     QVERIFY(rc.width() == 959);
     QVERIFY(rc.height() == image.height());
 
 //    KisTransaction t2("test", dev);
 //    KisRandomAccessorSP ac = dev->createRandomAccessorNG(rc.x(), rc.y());
 //    for(int x = rc.x(); x < rc.width(); ++x) {
 //        for(int y = rc.y(); y < rc.height(); ++y) {
 //            ac->moveTo(x, y);
 //            cs->setOpacity(ac->rawData(), 0.5, 1);
 //        }
 //    }
 //    t2.end();
 
     QImage result = dev->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height());
     QPoint errpoint;
     image.load(QString(FILES_DATA_DIR) + QDir::separator() + "shearx_result.png");
     if (!TestUtil::compareQImages(errpoint, image, result)) {
         image.save("shearx_source.png");
         result.save("shearx_result.png");
         QFAIL(QString("Failed to shear the image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 }
 
 
 void KisTransformWorkerTest::testYShear()
 {
     TestUtil::TestProgressBar bar;
     KoProgressUpdater pu(&bar);
     KoUpdaterPtr updater = pu.startSubtask();
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "mirror_source.png");
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->convertFromQImage(image, 0);
 
     KisFilterStrategy * filter = new KisBoxFilterStrategy();
 
     KisTransaction t(dev);
     KisTransformWorker tw(dev, 1.0, 1.0,
                           0.0, 1.0,
                           300., 200.,
                           0.0,
                           0, 0, updater, filter);
     tw.run();
     t.end();
 
     QRect rc = dev->exactBounds();
 
     QVERIFY(rc.width() == image.width());
     QVERIFY(rc.height() == 959);
 
 //    KisTransaction t2("test", dev);
 //    KisRandomAccessorSP ac = dev->createRandomAccessorNG(rc.x(), rc.y());
 //    for(int x = rc.x(); x < rc.width(); ++x) {
 //        for(int y = rc.y(); y < rc.height(); ++y) {
 //            ac->moveTo(x, y);
 //            cs->setOpacity(ac->rawData(), 0.5, 1);
 //        }
 //    }
 //    t2.end();
 
     QImage result = dev->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height());
     QPoint errpoint;
     image.load(QString(FILES_DATA_DIR) + QDir::separator() + "sheary_result.png");
     if (!TestUtil::compareQImages(errpoint, image, result)) {
         image.save("sheary_source.png");
         result.save("sheary_result.png");
         QFAIL(QString("Failed to shear the image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 
 }
 
 
 bool fuzzyCompareRects(const QRectF rc1, const QRectF rc2, qreal accuracy)
 {
     bool result =
         qAbs(rc1.x() - rc2.x()) < accuracy &&
         qAbs(rc1.y() - rc2.y()) < accuracy &&
         qAbs(rc1.width() - rc2.width()) < 2 * accuracy &&
         qAbs(rc1.height() - rc2.height()) < 2 * accuracy;
 
     if(!result) {
         dbgKrita << "Failed to fuzzy compare rects";
         dbgKrita << "\t" << ppVar(accuracy);
         dbgKrita << "\t" << "actual  " << rc1;
         dbgKrita << "\t" << "expected" << rc2;
         dbgKrita << "+---------------------------+";
     }
 
     return result;
 }
 
 void KisTransformWorkerTest::testMatrices()
 {
     TestUtil::TestProgressBar bar;
     KoProgressUpdater pu(&bar);
     KoUpdaterPtr updater = pu.startSubtask();
     KisFilterStrategy *filter = new KisBoxFilterStrategy();
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     QRect fillRect(0,0,300,200);
     KoColor fillColor(Qt::white, cs);
     dev->fill(fillRect, fillColor);
 
     qreal scaleX = 1.5, scaleY = 1.5;
     qreal shearX = 1, shearY = 1.33;
     qreal shearOrigX = 150, shearOrigY = 100;
     qreal angle = M_PI/6;
     qreal transX = 77, transY = 33;
 
     KisTransaction t(dev);
     KisTransformWorker tw(dev, scaleX, scaleY,
                           shearX, shearY,
                           shearOrigX, shearOrigY,
                           angle,
                           transX, transY,
                           updater, filter);
     tw.run();
     t.end();
 
     QPolygonF referencePolygon =
         tw.transform().map(QPolygonF(QRectF(fillRect)));
 
     QVERIFY(fuzzyCompareRects(dev->exactBounds(),
                               referencePolygon.boundingRect(), 3));
 }
 
 
 void testRotationImpl(qreal angle, QString filePrefix, bool useUniformColor = false, const QString &filterId = "NearestNeighbor")
 {
     TestUtil::TestProgressBar bar;
     KoProgressUpdater pu(&bar);
     KoUpdaterPtr updater = pu.startSubtask();
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     QImage image;
 
     if (!useUniformColor) {
         image = QImage(QString(FILES_DATA_DIR) + QDir::separator() + "mirror_source.png");
         dev->convertFromQImage(image, 0);
     } else {
         dev->fill(QRect(120, 130, 374, 217), KoColor(QColor(150, 180, 230), cs));
     }
 
     KisFilterStrategy * filter = KisFilterStrategyRegistry::instance()->value(filterId);
     Q_ASSERT(filter);
 
     KisTransaction t(dev);
     KisTransformWorker tw(dev, 1.0, 1.0,
                           0.0, 0.0,
                           0.0, 0.0,
                           angle,
                           0, 0, updater, filter);
     tw.run();
     t.end();
 
     QRect rc = dev->exactBounds();
 
     QImage result = dev->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height());
     QPoint errpoint;
 
     QString resFileName = QString("%1_result.png").arg(filePrefix);
     QString refFileName = QString("%1_expected.png").arg(filePrefix);
 
     image = QImage();
     image.load(QString(FILES_DATA_DIR) + QDir::separator() + resFileName);
     if (!TestUtil::compareQImages(errpoint, image, result)) {
         dbgKrita << filePrefix;
         image.save(refFileName);
         result.save(resFileName);
         QFAIL(QString("Failed to rotate the image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 }
 
 void KisTransformWorkerTest::testRotation()
 {
     testRotationImpl(M_PI/6, "rotation_30");
     testRotationImpl(M_PI/3, "rotation_60");
     testRotationImpl(M_PI/2,  "rotation_90");
     testRotationImpl(2*M_PI/3, "rotation_120");
     testRotationImpl(7*M_PI/6, "rotation_210");
     testRotationImpl(5*M_PI/3, "rotation_300");
     testRotationImpl(M_PI/6, "rotation_30_uniform_blin", true, "Bilinear");
     testRotationImpl(M_PI/6, "rotation_30_uniform_bcub", true, "Bicubic");
     testRotationImpl(M_PI/6, "rotation_30_uniform_lanc", true, "Lanczos3");
 }
 
 void KisTransformWorkerTest::testRotationSpecialCases()
 {
     TestUtil::TestProgressBar bar;
     KoProgressUpdater pu(&bar);
     KoUpdaterPtr updater = pu.startSubtask();
     KisFilterStrategy *filter = new KisBoxFilterStrategy();
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
 
     QRect fillRect(0,0,600,300);
     KoColor fillColor(Qt::white, cs);
     dev->fill(fillRect, fillColor);
 
     qreal scaleX = 0.5, scaleY = 0.5;
     qreal shearX = 0, shearY = 0;
     qreal shearOrigX = 0, shearOrigY = 0;
     qreal angle = M_PI;
     qreal transX = 300, transY = 150;
 
     KisTransaction t(dev);
     KisTransformWorker tw(dev, scaleX, scaleY,
                           shearX, shearY,
                           shearOrigX, shearOrigY,
                           angle,
                           transX, transY,
                           updater, filter);
     tw.run();
     t.end();
 
     QCOMPARE(dev->exactBounds(), QRect(0,0,300,150));
 }
 
 void KisTransformWorkerTest::testScaleUp5times()
 {
     TestUtil::TestProgressBar bar;
     KoProgressUpdater pu(&bar);
     KoUpdaterPtr updater = pu.startSubtask();
 
     QImage image(QSize(2000,2000), QImage::Format_ARGB32_Premultiplied);
     image.fill(QColor(Qt::green).rgba());
 
     int checkSize = 20;
     QImage tile(checkSize * 2, checkSize * 2, QImage::Format_ARGB32_Premultiplied);
     QPainter pt(&tile);
     pt.fillRect(tile.rect(), Qt::green);
     pt.fillRect(0, 0, checkSize, checkSize, Qt::white);
     pt.fillRect(checkSize, checkSize, checkSize, checkSize, Qt::white);
     pt.end();
 
     pt.begin(&image);
     pt.setBrush(QBrush(tile));
     pt.drawRect(image.rect());
     pt.end();
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->convertFromQImage(image, 0);
 
     KisFilterStrategy * filter = new KisBicubicFilterStrategy();
     KisTransaction t(dev);
 
     qreal SCALE = 5.0;
 
     KisTransformWorker tw(dev, SCALE, SCALE,
                           0.0, 0.0,
                           0.0, 0.0,
                           0.0,
                           0, 0, updater, filter);
     tw.run();
     t.end();
 
     QRect rc = dev->exactBounds();
 
 #if 0
     // here you can check the input and result images
     image.save("test_scale_2000_2000_input.bmp");
     QImage result = dev->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height());
     result.save("test_scale_2000_2000_" + QString::number(SCALE) + "_result.bmp");
 #endif
 
     QCOMPARE(rc.width(), qCeil(image.width() * SCALE));
     QCOMPARE(rc.height(), qCeil(image.height() * SCALE));
 }
 
 void KisTransformWorkerTest::rotate90Left()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "transform_rotate_test.png");
     KisPaintDeviceSP dev2 = new KisPaintDevice(cs);
     dev2->convertFromQImage(image, 0);
 
     QRect boundRect = dev2->exactBounds();
 
     KisTransaction t(kundo2_noi18n("rotate left 90"), dev2);
     QRect rc = KisTransformWorker::rotateLeft90(dev2, boundRect, 0, 0);
     t.end();
 
     QImage result = dev2->convertToQImage(0, rc.x(), rc.y(), image.width(), image.height());
     QTransform tf;
     QImage rotatedimage = image.transformed(tf.rotate(270));
 
     QPoint errpoint;
     if (!TestUtil::compareQImages(errpoint, rotatedimage, result)) {
         // They are the same, but should be mirrored
         image.save("rotate_90_left_test_1_source.png");
         rotatedimage.save("rotate_90_left_test_1_rotated_source.png");
         result.save("rotate_90_left_test_1_result.png");
         QFAIL(QString("Failed to rotate 90 left the image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 }
 
 void KisTransformWorkerTest::rotate90Right()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "transform_rotate_test.png");
     KisPaintDeviceSP dev2 = new KisPaintDevice(cs);
     dev2->convertFromQImage(image, 0);
 
     QRect boundRect = dev2->exactBounds();
 
     KisTransaction t(kundo2_noi18n("rotate right 90"), dev2);
     QRect rc = KisTransformWorker::rotateRight90(dev2, boundRect, 0, 0);
     t.end();
 
     QTransform tf;
     QImage rotatedimage = image.transformed(tf.rotate(90));
 
     QImage result = dev2->convertToQImage(0, rc.x(), rc.y(), image.width(), image.height());
 
     QPoint errpoint;
     if (!TestUtil::compareQImages(errpoint, rotatedimage, result)) {
         // They are the same, but should be mirrored
         image.save("rotate_90_right_test_1_source.png");
         rotatedimage.save("rotate_90_right_test_1_rotated_source.png");
         result.save("rotate_90_right_1_result.png");
         QFAIL(QString("Failed to rotate 90 right the image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 }
 
 void KisTransformWorkerTest::rotate180()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + "transform_rotate_test.png");
     KisPaintDeviceSP dev2 = new KisPaintDevice(cs);
     dev2->convertFromQImage(image, 0);
 
     QRect boundRect = dev2->exactBounds();
 
     KisTransaction t(kundo2_noi18n("rotate 180"), dev2);
     QRect rc = KisTransformWorker::rotate180(dev2, boundRect, 0, 0);
     t.end();
 
     QImage result = dev2->convertToQImage(0, rc.x(), rc.y(), image.width(), image.height());
 
     QTransform tf;
     QImage rotatedimage = image.transformed(tf.rotate(180));
 
     QPoint errpoint;
     if (!TestUtil::compareQImages(errpoint, rotatedimage, result)) {
         // They are the same, but should be mirrored
         image.save("rotate_180_1_source.png");
         rotatedimage.save("rotate_180_1_rotated_source.png");
         result.save("rotate_180_1_result.png");
         QFAIL(QString("Failed to rotate 180 the image, first different pixel: %1,%2 \n").arg(errpoint.x()).arg(errpoint.y()).toLatin1());
     }
 }
 
 void generateTestImage(QString inputFileName, qreal scale, qreal rotation, qreal xshear, KisFilterStrategy *filter, bool saveImage = true)
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     QImage image(QString(FILES_DATA_DIR) + QDir::separator() + inputFileName);
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->convertFromQImage(image, 0);
 
     TestUtil::TestProgressBar bar;
     KoProgressUpdater pu(&bar);
     KoUpdaterPtr updater = pu.startSubtask();
 
     KisTransformWorker tw(dev, scale, scale,
                           xshear, 0.0,
                           0.0, 0.0,
                           rotation,
                           0, 0,
                           updater, filter);
 
 
     tw.run();
 
     if (saveImage) {
         QStringList tmp = inputFileName.split('.');
         QString filename =
             QString("transform_%1_%2_%3_%4_%5_new.png")
             .arg(tmp[0]).arg(scale).arg(rotation).arg(xshear).arg(filter->name());
 
         dbgKrita << filename;
 
         dev->convertToQImage(0).save(filename);
     }
 }
 
 void KisTransformWorkerTest::benchmarkScale()
 {
     QBENCHMARK {
         generateTestImage("hakonepa.png", 1.379,0.0,0.0,new KisBicubicFilterStrategy(), false);
     }
 }
 
 void KisTransformWorkerTest::benchmarkRotate()
 {
     QBENCHMARK {
         generateTestImage("hakonepa.png", 1.0,M_PI/6.0,0.0,new KisBicubicFilterStrategy(), false);
     }
 }
 
 void KisTransformWorkerTest::benchmarkRotate1Q()
 {
     QBENCHMARK {
         generateTestImage("hakonepa.png", 1.0,2 * M_PI/3.0,0.0,new KisBicubicFilterStrategy(), false);
     }
 }
 
 void KisTransformWorkerTest::benchmarkShear()
 {
     QBENCHMARK {
         generateTestImage("hakonepa.png", 1.0,0.0,0.479,new KisBicubicFilterStrategy(), false);
     }
 }
 
 void KisTransformWorkerTest::benchmarkScaleRotateShear()
 {
     QBENCHMARK {
         generateTestImage("hakonepa.png", 1.379,M_PI/6.0,0.479,new KisBicubicFilterStrategy(), false);
     }
 }
 
 void KisTransformWorkerTest::generateTestImages()
 {
     QList<KisFilterStrategy*> filters;
     filters << new KisBoxFilterStrategy();
     filters << new KisHermiteFilterStrategy();
     filters << new KisBicubicFilterStrategy();
     filters << new KisBilinearFilterStrategy();
     filters << new KisBellFilterStrategy();
     filters << new KisBSplineFilterStrategy();
     filters << new KisLanczos3FilterStrategy();
     filters << new KisMitchellFilterStrategy();
 
     QStringList names;
     names << "hakonepa.png";
     //names << "star-chart-bars-full-600dpi.png";
 
     Q_FOREACH (const QString &name, names) {
         Q_FOREACH (KisFilterStrategy *filter, filters) {
             generateTestImage(name, 0.5,0.0,0.0,filter);
             generateTestImage(name, 0.734,0.0,0.0,filter);
             generateTestImage(name, 1.387,0.0,0.0,filter);
             generateTestImage(name, 2.0,0.0,0.0,filter);
             generateTestImage(name, 3.789,0.0,0.0,filter);
 
             generateTestImage(name, 1.0,M_PI/6,0.0,filter);
 
             generateTestImage(name, 1.0,0.0,0.5,filter);
         }
     }
 }
 
 #include "kis_perspectivetransform_worker.h"
 
 
 void KisTransformWorkerTest::testPartialProcessing()
 {
     TestUtil::TestProgressBar bar;
     KoProgressUpdater pu(&bar);
     KoUpdaterPtr updater = pu.startSubtask();
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     QImage image(TestUtil::fetchDataFileLazy("test_transform_quality.png"));
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->convertFromQImage(image, 0);
 
     KisTransaction t(dev);
 
     QTransform transform = QTransform::fromScale(2.0, 1.1);
     transform.shear(1.1, 0);
     transform.rotateRadians(M_PI / 18);
 
     KisPerspectiveTransformWorker tw(0, transform, updater);
     tw.runPartialDst(dev, dev, QRect(1200, 1200, 150, 150));
     tw.runPartialDst(dev, dev, QRect(1350, 1200, 150, 150));
     tw.runPartialDst(dev, dev, QRect(1200, 1350, 150, 150));
     tw.runPartialDst(dev, dev, QRect(1350, 1350, 150, 150));
 
     t.end();
 
     QImage result = dev->convertToQImage(0);
     TestUtil::checkQImage(result, "transform_test", "partial", "single");
 }
 
 QTEST_MAIN(KisTransformWorkerTest)
diff --git a/libs/image/tiles3/kis_tile_data_store.cc b/libs/image/tiles3/kis_tile_data_store.cc
index 493756b2ec..3cd2d8d94f 100644
--- a/libs/image/tiles3/kis_tile_data_store.cc
+++ b/libs/image/tiles3/kis_tile_data_store.cc
@@ -1,377 +1,374 @@
 /*
  *  Copyright (c) 2009 Dmitry Kazakov <dimula73@gmail.com>
  *  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.
  */
 
 // to disable assert when the leak tracker is active
 #include "config-memory-leak-tracker.h"
 
 #include <QGlobalStatic>
 
 #include "kis_tile_data_store.h"
 #include "kis_tile_data.h"
 #include "kis_debug.h"
 
 #include "kis_tile_data_store_iterators.h"
 
 Q_GLOBAL_STATIC(KisTileDataStore, s_instance)
 
 //#define DEBUG_PRECLONE
 
 #ifdef DEBUG_PRECLONE
 #include <stdio.h>
 #define DEBUG_PRECLONE_ACTION(action, oldTD, newTD) \
     printf("!!! %s:\t\t\t  0x%X -> 0x%X    \t\t!!!\n",  \
            action, (quintptr)oldTD, (quintptr) newTD)
 #define DEBUG_FREE_ACTION(td)                   \
     printf("Tile data free'd \t(0x%X)\n", td)
 #else
 #define DEBUG_PRECLONE_ACTION(action, oldTD, newTD)
 #define DEBUG_FREE_ACTION(td)
 #endif
 
 #ifdef DEBUG_HIT_MISS
 qint64 __preclone_miss = 0;
 qint64 __preclone_hit = 0;
 
 qint64 __preclone_miss_user_count = 0;
 qint64 __preclone_miss_age = 0;
 
 #define DEBUG_COUNT_PRECLONE_HIT(td) __preclone_hit++
 #define DEBUG_COUNT_PRECLONE_MISS(td) __preclone_miss++; __preclone_miss_user_count+=td->numUsers(); __preclone_miss_age+=td->age()
 #define DEBUG_REPORT_PRECLONE_EFFICIENCY()                      \
     dbgKrita << "Hits:" << __preclone_hit                       \
              << "of" << __preclone_hit + __preclone_miss        \
              << "("                                             \
              << qreal(__preclone_hit) / (__preclone_hit + __preclone_miss)       \
              << ")"                                             \
              << "miss users" << qreal(__preclone_miss_user_count) / __preclone_miss \
              << "miss age" << qreal(__preclone_miss_age) / __preclone_miss
 #else
 #define DEBUG_COUNT_PRECLONE_HIT(td)
 #define DEBUG_COUNT_PRECLONE_MISS(td)
 #define DEBUG_REPORT_PRECLONE_EFFICIENCY()
 #endif
 
 KisTileDataStore::KisTileDataStore()
     : m_pooler(this),
       m_swapper(this),
       m_numTiles(0),
       m_memoryMetric(0),
       m_counter(1),
       m_clockIndex(1)
 {
     m_pooler.start();
     m_swapper.start();
 }
 
 KisTileDataStore::~KisTileDataStore()
 {
     m_pooler.terminatePooler();
     m_swapper.terminateSwapper();
 
     if (numTiles() > 0) {
         errKrita << "Warning: some tiles have leaked:";
         errKrita << "\tTiles in memory:" << numTilesInMemory() << "\n"
                  << "\tTotal tiles:" << numTiles();
     }
 }
 
 KisTileDataStore* KisTileDataStore::instance()
 {
     return s_instance;
 }
 
 KisTileDataStore::MemoryStatistics KisTileDataStore::memoryStatistics()
 {
     // in case the pooler is disabled, we should force it
     // to update the stats
     if (!m_pooler.isRunning()) {
         m_pooler.forceUpdateMemoryStats();
     }
 
     QReadLocker lock(&m_iteratorLock);
 
     MemoryStatistics stats;
 
     const qint64 metricCoeff = KisTileData::WIDTH * KisTileData::HEIGHT;
 
     stats.realMemorySize = m_pooler.lastRealMemoryMetric() * metricCoeff;
     stats.historicalMemorySize = m_pooler.lastHistoricalMemoryMetric() * metricCoeff;
     stats.poolSize = m_pooler.lastPoolMemoryMetric() * metricCoeff;
 
     stats.totalMemorySize = memoryMetric() * metricCoeff + stats.poolSize;
 
     stats.swapSize = m_swappedStore.totalMemoryMetric() * metricCoeff;
 
     return stats;
 }
 
 inline void KisTileDataStore::registerTileDataImp(KisTileData *td)
 {
     int index = m_counter.fetchAndAddOrdered(1);
     td->m_tileNumber = index;
     m_tileDataMap.assign(index, td);
     m_numTiles.ref();
     m_memoryMetric += td->pixelSize();
 }
 
 void KisTileDataStore::registerTileData(KisTileData *td)
 {
     QReadLocker lock(&m_iteratorLock);
     registerTileDataImp(td);
 }
 
 inline void KisTileDataStore::unregisterTileDataImp(KisTileData *td)
 {
     if (m_clockIndex == td->m_tileNumber) {
         do {
             m_clockIndex.ref();
         } while (!m_tileDataMap.get(m_clockIndex.loadAcquire()) && m_clockIndex < m_counter);
     }
 
     int index = td->m_tileNumber;
     td->m_tileNumber = -1;
     m_tileDataMap.erase(index);
     m_numTiles.deref();
     m_memoryMetric -= td->pixelSize();
 }
 
 void KisTileDataStore::unregisterTileData(KisTileData *td)
 {
     QReadLocker lock(&m_iteratorLock);
     unregisterTileDataImp(td);
 }
 
 KisTileData *KisTileDataStore::allocTileData(qint32 pixelSize, const quint8 *defPixel)
 {
     KisTileData *td = new KisTileData(pixelSize, defPixel, this);
     registerTileData(td);
     return td;
 }
 
 KisTileData *KisTileDataStore::duplicateTileData(KisTileData *rhs)
 {
     KisTileData *td = 0;
 
     if (rhs->m_clonesStack.pop(td)) {
         DEBUG_PRECLONE_ACTION("+ Pre-clone HIT", rhs, td);
         DEBUG_COUNT_PRECLONE_HIT(rhs);
     } else {
         rhs->blockSwapping();
         td = new KisTileData(*rhs);
         rhs->unblockSwapping();
         DEBUG_PRECLONE_ACTION("- Pre-clone #MISS#", rhs, td);
         DEBUG_COUNT_PRECLONE_MISS(rhs);
     }
 
     registerTileData(td);
     return td;
 }
 
 void KisTileDataStore::freeTileData(KisTileData *td)
 {
     Q_ASSERT(td->m_store == this);
 
     DEBUG_FREE_ACTION(td);
 
     m_iteratorLock.lockForRead();
     td->m_swapLock.lockForWrite();
 
     if (!td->data()) {
         m_swappedStore.forgetTileData(td);
     } else {
         unregisterTileDataImp(td);
     }
 
     td->m_swapLock.unlock();
     m_iteratorLock.unlock();
 
     delete td;
 }
 
 void KisTileDataStore::ensureTileDataLoaded(KisTileData *td)
 {
 //    dbgKrita << "#### SWAP MISS! ####" << td << ppVar(td->mementoed()) << ppVar(td->age()) << ppVar(td->numUsers());
     checkFreeMemory();
 
     td->m_swapLock.lockForRead();
 
     while (!td->data()) {
         td->m_swapLock.unlock();
 
         /**
          * The order of this heavy locking is very important.
          * Change it only in case, you really know what you are doing.
          */
         m_iteratorLock.lockForWrite();
 
         /**
          * If someone has managed to load the td from swap, then, most
          * probably, they have already taken the swap lock. This may
          * lead to a deadlock, because COW mechanism breaks lock
          * ordering rules in duplicateTileData() (it takes m_listLock
          * while the swap lock is held). In our case it is enough just
          * to check whether the other thread has already fetched the
          * data. Please notice that we do not take both of the locks
          * while checking this, because holding m_listLock is
          * enough. Nothing can happen to the tile while we hold
          * m_listLock.
          */
 
         if (!td->data()) {
             td->m_swapLock.lockForWrite();
 
             m_swappedStore.swapInTileData(td);
             registerTileDataImp(td);
 
             td->m_swapLock.unlock();
         }
 
         m_iteratorLock.unlock();
 
         /**
          * <-- In theory, livelock is possible here...
          */
 
         td->m_swapLock.lockForRead();
     }
 }
 
 bool KisTileDataStore::trySwapTileData(KisTileData *td)
 {
     /**
      * This function is called with m_listLock acquired
      */
 
     bool result = false;
     if (!td->m_swapLock.tryLockForWrite()) return result;
 
     if (td->data()) {
-        unregisterTileDataImp(td);
         if (m_swappedStore.trySwapOutTileData(td)) {
+            unregisterTileDataImp(td);
             result = true;
-        } else {
-            result = false;
-            registerTileDataImp(td);
         }
     }
     td->m_swapLock.unlock();
 
     return result;
 }
 
 KisTileDataStoreIterator* KisTileDataStore::beginIteration()
 {
     m_iteratorLock.lockForWrite();
     return new KisTileDataStoreIterator(m_tileDataMap, this);
 }
 void KisTileDataStore::endIteration(KisTileDataStoreIterator* iterator)
 {
     delete iterator;
     m_iteratorLock.unlock();
 }
 
 KisTileDataStoreReverseIterator* KisTileDataStore::beginReverseIteration()
 {
     m_iteratorLock.lockForWrite();
     return new KisTileDataStoreReverseIterator(m_tileDataMap, this);
 }
 void KisTileDataStore::endIteration(KisTileDataStoreReverseIterator* iterator)
 {
     delete iterator;
     m_iteratorLock.unlock();
     DEBUG_REPORT_PRECLONE_EFFICIENCY();
 }
 
 KisTileDataStoreClockIterator* KisTileDataStore::beginClockIteration()
 {
     m_iteratorLock.lockForWrite();
     return new KisTileDataStoreClockIterator(m_tileDataMap, m_clockIndex.loadAcquire(), this);
 }
 
 void KisTileDataStore::endIteration(KisTileDataStoreClockIterator* iterator)
 {
     m_clockIndex = iterator->getFinalPosition();
     delete iterator;
     m_iteratorLock.unlock();
 }
 
 void KisTileDataStore::debugPrintList()
 {
     KisTileDataStoreIterator* iter = beginIteration();
     KisTileData *item = 0;
 
     while (iter->hasNext()) {
         item = iter->next();
         dbgTiles << "-------------------------\n"
                  << "TileData:\t\t\t" << item
                  << "\n  refCount:\t" << item->m_refCount;
     }
 
     endIteration(iter);
 }
 
 void KisTileDataStore::debugSwapAll()
 {
     KisTileDataStoreIterator* iter = beginIteration();
     KisTileData *item = 0;
 
     while (iter->hasNext()) {
         item = iter->next();
         iter->trySwapOut(item);
     }
 
     endIteration(iter);
 
 //    dbgKrita << "Number of tiles:" << numTiles();
 //    dbgKrita << "Tiles in memory:" << numTilesInMemory();
 //    m_swappedStore.debugStatistics();
 }
 
 void KisTileDataStore::debugClear()
 {
     QWriteLocker l(&m_iteratorLock);
     ConcurrentMap<int, KisTileData*>::Iterator iter(m_tileDataMap);
 
     while (iter.isValid()) {
         delete iter.getValue();
         iter.next();
     }
 
     m_counter = 1;
     m_clockIndex = 1;
     m_numTiles = 0;
     m_memoryMetric = 0;
 }
 
 void KisTileDataStore::testingRereadConfig()
 {
     m_pooler.testingRereadConfig();
     m_swapper.testingRereadConfig();
     kickPooler();
 }
 
 void KisTileDataStore::testingSuspendPooler()
 {
     m_pooler.terminatePooler();
 }
 
 void KisTileDataStore::testingResumePooler()
 {
     m_pooler.start();
 }
diff --git a/libs/libqml/KisSketchView.cpp b/libs/libqml/KisSketchView.cpp
index b606964ab7..0910d6ee8f 100644
--- a/libs/libqml/KisSketchView.cpp
+++ b/libs/libqml/KisSketchView.cpp
@@ -1,676 +1,673 @@
 /* This file is part of the KDE project
  * Copyright (C) 2012 Boudewijn Rempt <boud@kogmbh.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 "KisSketchView.h"
 
 #include <QApplication>
 #include <QScrollBar>
 #include <QFileInfo>
 
 #include <kactioncollection.h>
 
 #include <KoZoomController.h>
 #include <KoToolManager.h>
 
 #include "KisDocument.h"
 #include "kis_canvas2.h"
 #include <kis_canvas_controller.h>
 #include "KisViewManager.h"
 #include <kis_image_signal_router.h>
 #include <input/kis_input_manager.h>
 #include <kis_canvas_resource_provider.h>
 #include <kis_selection_manager.h>
 #include <KisPart.h>
 #include <kis_tool_freehand.h>
 #include <kis_paintop_box.h>
 #include "KisSelectionExtras.h"
 
 #include "ProgressProxy.h"
 #include "DocumentManager.h"
 
 class KisSketchView::Private
 {
 public:
     Private( KisSketchView* qq)
         : q(qq)
         , actionCollection(0)
         , doc(0)
         , viewManager(0)
         , view(0)
         , canvas(0)
         , canvasWidget(0)
         , selectionExtras(0)
         , undoAction(0)
         , redoAction(0)
         , tabletEventCount(0)
     { }
     ~Private() {
         delete selectionExtras;
     }
 
     void imageUpdated(const QRect &updated);
     void documentOffsetMoved();
     void zoomChanged();
     void resetDocumentPosition();
     void removeNodeAsync(KisNodeSP removedNode);
 
     KisSketchView* q;
 
     KActionCollection *actionCollection;
 
     QPointer<KisDocument> doc;
     QPointer<KisViewManager> viewManager;
     QPointer<KisView> view;
 
     QPointer<KisCanvas2> canvas;
     KUndo2Stack* undoStack;
 
     QWidget *canvasWidget;
 
     QString file;
 
     KisSelectionExtras *selectionExtras;
 
     QTimer *timer;
 
     QTimer *loadedTimer;
     QTimer *savedTimer;
     QAction* undoAction;
     QAction* redoAction;
 
     unsigned char tabletEventCount;
 };
 
 KisSketchView::KisSketchView(QQuickItem* parent)
     : QQuickItem(parent)
     , d(new Private(this))
 {
     // this is just an interaction overlay, the contents are painted on the sceneview background
     setFlag(QQuickItem::ItemHasContents, false);
     // QT5TODO
 //     setAcceptTouchEvents(true);
     setAcceptedMouseButtons(Qt::LeftButton | Qt::MiddleButton | Qt::RightButton);
     setAcceptHoverEvents(true);
 
     d->actionCollection = new KActionCollection(this, "krita");
     d->viewManager = 0; //new KisViewManager(qApp->activeWindow(), d->actionCollection);
 
     // QT5TODO
 //     grabGesture(Qt::PanGesture);
     //grabGesture(Qt::PinchGesture);
 
     KoZoomMode::setMinimumZoom(0.1);
     KoZoomMode::setMaximumZoom(16.0);
 
     d->timer = new QTimer(this);
     d->timer->setSingleShot(true);
     connect(d->timer, SIGNAL(timeout()), this, SLOT(resetDocumentPosition()));
 
     d->loadedTimer = new QTimer(this);
     d->loadedTimer->setSingleShot(true);
     d->loadedTimer->setInterval(100);
     connect(d->loadedTimer, SIGNAL(timeout()), SIGNAL(loadingFinished()));
 
     d->savedTimer = new QTimer(this);
     d->savedTimer->setSingleShot(true);
     d->savedTimer->setInterval(100);
     connect(d->savedTimer, SIGNAL(timeout()), SIGNAL(savingFinished()));
 
     connect(DocumentManager::instance(), SIGNAL(aboutToDeleteDocument()), SLOT(documentAboutToBeDeleted()));
     connect(DocumentManager::instance(), SIGNAL(documentChanged()), SLOT(documentChanged()));
     connect(DocumentManager::instance()->progressProxy(), SIGNAL(valueChanged(int)), SIGNAL(progress(int)));
     connect(DocumentManager::instance(), SIGNAL(documentSaved()), d->savedTimer, SLOT(start()));
 
     if (DocumentManager::instance()->document()) {
         documentChanged();
     }
 }
 
 KisSketchView::~KisSketchView()
 {
     if (d->doc) {
         DocumentManager::instance()->closeDocument();
     }
     if (d->canvasWidget) {
     // QT5TODO
 //         SketchDeclarativeView *v = qobject_cast<SketchDeclarativeView*>(scene()->views().at(0));
 //         if (v) {
 //             v->setCanvasWidget(0);
 //             v->setDrawCanvas(false);
 //         }
     }
 
     delete d;
 }
 
 QObject* KisSketchView::selectionManager() const
 {
     if (!d->viewManager)
         return 0;
     return d->viewManager->selectionManager();
 }
 
 QObject* KisSketchView::selectionExtras() const
 {
     if (!d->selectionExtras) {
         d->selectionExtras = new KisSelectionExtras(d->viewManager);
     }
     return d->selectionExtras;
 }
 
 QObject* KisSketchView::doc() const
 {
     return d->doc;
 }
 
 QObject* KisSketchView::view() const
 {
     return d->viewManager;
 }
 
 QString KisSketchView::file() const
 {
     return d->file;
 }
 
 QString KisSketchView::fileTitle() const
 {
     QFileInfo file(d->file);
     return file.fileName();
 }
 
 bool KisSketchView::isModified() const
 {
     if(d->doc)
         return d->doc->isModified();
 
     return false;
 }
 
 void KisSketchView::setFile(const QString& file)
 {
     if (!file.isEmpty() && file != d->file) {
         d->file = file;
         emit fileChanged();
 
         if (!file.startsWith("temp://")) {
             DocumentManager::instance()->openDocument(file);
         }
     }
 }
 
 void KisSketchView::componentComplete()
 {
 }
 
 bool KisSketchView::canUndo() const
 {
     if (d->undoAction)
         return d->undoAction->isEnabled();
     return false;
 }
 
 bool KisSketchView::canRedo() const
 {
     if (d->redoAction)
         return d->redoAction->isEnabled();
     return false;
 }
 
 int KisSketchView::imageHeight() const
 {
     if (d->doc)
         return d->doc->image()->height();
     return 0;
 }
 
 int KisSketchView::imageWidth() const
 {
     if (d->doc)
         return d->doc->image()->width();
     return 0;
 }
 
 void KisSketchView::undo()
 {
     d->undoAction->trigger();
 }
 
 void KisSketchView::redo()
 {
     d->redoAction->trigger();
 }
 
 void KisSketchView::zoomIn()
 {
     d->viewManager->actionCollection()->action("zoom_in")->trigger();
 }
 
 void KisSketchView::zoomOut()
 {
     d->viewManager->actionCollection()->action("zoom_out")->trigger();
 }
 
 void KisSketchView::save()
 {
     DocumentManager::instance()->save();
 }
 
 void KisSketchView::saveAs(const QString& fileName, const QString& mimeType)
 {
     DocumentManager::instance()->saveAs(fileName, mimeType);
 }
 
 void KisSketchView::documentAboutToBeDeleted()
 {
     if (d->undoAction)
         d->undoAction->disconnect(this);
 
     if (d->redoAction)
         d->redoAction->disconnect(this);
 
     delete d->view;
     d->view = 0;
 
     emit viewChanged();
 
     d->canvas = 0;
     d->canvasWidget = 0;
 }
 
 void KisSketchView::documentChanged()
 {
     d->doc = DocumentManager::instance()->document();
     if (!d->doc) return;
     if (!d->viewManager) return;
 
     connect(d->doc, SIGNAL(modified(bool)), SIGNAL(modifiedChanged()));
 
-    QPointer<KisView> view = qobject_cast<KisView*>(KisPart::instance()->createView(d->doc,
-                                                                                    d->viewManager->canvasResourceProvider()->resourceManager(),
-                                                                                    d->viewManager->actionCollection(),
-                                                                                    QApplication::activeWindow()));
+    QPointer<KisView> view = KisPart::instance()->createView(d->doc, d->viewManager, QApplication::activeWindow());
     view->setViewManager(d->viewManager);
     view->canvasBase()->setFavoriteResourceManager(d->viewManager->paintOpBox()->favoriteResourcesManager());
     view->slotLoadingFinished();
 
     d->view = view;
     d->canvas = d->view->canvasBase();
     d->view->setShowFloatingMessage(false);
     d->viewManager->setCurrentView(view);
     KisCanvasController *controller = static_cast<KisCanvasController*>(d->canvas->canvasController());
 
     connect(d->viewManager, SIGNAL(floatingMessageRequested(QString,QString)), this, SIGNAL(floatingMessageRequested(QString,QString)));
 
     controller->setGeometry(x(), y(), width(), height());
     d->view->hide();
 
     d->undoStack = d->doc->undoStack();
     d->undoAction = d->viewManager->actionCollection()->action("edit_undo");
     connect(d->undoAction, SIGNAL(changed()), this, SIGNAL(canUndoChanged()));
 
     d->redoAction = d->viewManager->actionCollection()->action("edit_redo");
     connect(d->redoAction, SIGNAL(changed()), this, SIGNAL(canRedoChanged()));
 
     KoToolManager::instance()->switchToolRequested( "KritaShape/KisToolBrush" );
 
     d->canvasWidget = d->canvas->canvasWidget();
 
 
 
     connect(d->doc->image(), SIGNAL(sigImageUpdated(QRect)), SLOT(imageUpdated(QRect)));
     connect(controller->proxyObject, SIGNAL(moveDocumentOffset(QPoint)), SLOT(documentOffsetMoved()));
     connect(d->view->zoomController(), SIGNAL(zoomChanged(KoZoomMode::Mode,qreal)), SLOT(zoomChanged()));
     connect(d->canvas, SIGNAL(updateCanvasRequested(QRect)), SLOT(imageUpdated(QRect)));
     connect(d->doc->image()->signalRouter(), SIGNAL(sigRemoveNodeAsync(KisNodeSP)), SLOT(removeNodeAsync(KisNodeSP)));
     connect(d->doc->image()->signalRouter(), SIGNAL(sigSizeChanged(QPointF,QPointF)), SIGNAL(imageSizeChanged()));
 
     // QT5TODO
 //     if(scene()) {
 //         SketchDeclarativeView *v = qobject_cast<SketchDeclarativeView*>(scene()->views().at(0));
 //         if (v) {
 //             v->setCanvasWidget(d->canvasWidget);
 //             v->setDrawCanvas(true);
 //         }
 //     }
 
     d->imageUpdated(d->canvas->image()->bounds());
 
     static_cast<KoZoomHandler*>(d->canvas->viewConverter())->setResolution(d->doc->image()->xRes(), d->doc->image()->yRes());
     d->view->zoomController()->setZoomMode(KoZoomMode::ZOOM_PAGE);
     controller->setScrollBarValue(QPoint(0, 0));
     controller->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
     controller->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
 
     geometryChanged(QRectF(x(), y(), width(), height()), QRectF());
 
     d->loadedTimer->start(100);
 
     d->viewManager->actionCollection()->action("zoom_to_100pct")->trigger();
     d->resetDocumentPosition();
 
     emit viewChanged();
 
 }
 
 bool KisSketchView::event( QEvent* event )
 {
     if (!d->viewManager) return false;
     if (!d->viewManager->canvasBase()) return false;
 
     KisCanvasController *controller = dynamic_cast<KisCanvasController*>(d->viewManager->canvasBase()->canvasController());
     if (!controller) return false;
 
 //    switch(static_cast<int>(event->type())) {
 //        case ViewModeSwitchEvent::AboutToSwitchViewModeEvent: {
 //            ViewModeSynchronisationObject* syncObject = static_cast<ViewModeSwitchEvent*>(event)->synchronisationObject();
 
 //            if (d->view && d->viewManager && d->viewManager->canvasBase()) {
 
 //                controller->setFocus();
 //                qApp->processEvents();
 
 //                KisCanvasResourceProvider* provider = d->view->resourceProvider();
 //                syncObject->backgroundColor = provider->bgColor();
 //                syncObject->foregroundColor = provider->fgColor();
 //                syncObject->exposure = provider->HDRExposure();
 //                syncObject->gamma = provider->HDRGamma();
 //                syncObject->compositeOp = provider->currentCompositeOp();
 //                syncObject->pattern = provider->currentPattern();
 //                syncObject->gradient = provider->currentGradient();
 //                syncObject->node = provider->currentNode();
 //                syncObject->paintOp = provider->currentPreset();
 //                syncObject->opacity = provider->opacity();
 //                syncObject->globalAlphaLock = provider->globalAlphaLock();
 
 //                syncObject->documentOffset = controller->scrollBarValue();
 //                syncObject->zoomLevel = d->view->zoomController()->zoomAction()->effectiveZoom();
 //                syncObject->rotationAngle = d->view->canvasBase()->rotationAngle();
 
 //                syncObject->activeToolId = KoToolManager::instance()->activeToolId();
 
 //                syncObject->gridConfig = d->view->document()->gridConfig();
 
 //                syncObject->mirrorHorizontal = provider->mirrorHorizontal();
 //                syncObject->mirrorVertical = provider->mirrorVertical();
 //                //syncObject->mirrorAxesCenter = provider->resourceManager()->resource(KisCanvasResourceProvider::MirrorAxesCenter).toPointF();
 
 //                KisToolFreehand* tool = qobject_cast<KisToolFreehand*>(KoToolManager::instance()->toolById(d->view->canvasBase(), syncObject->activeToolId));
 //                if(tool) {
 //                    syncObject->smoothingOptions = tool->smoothingOptions();
 //                }
 
 //                syncObject->initialized = true;
 //            }
 
 //            return true;
 //        }
 //        case ViewModeSwitchEvent::SwitchedToSketchModeEvent: {
 //            ViewModeSynchronisationObject* syncObject = static_cast<ViewModeSwitchEvent*>(event)->synchronisationObject();
 
 //            if (d->view && syncObject->initialized) {
 //                controller->setFocus();
 //                qApp->processEvents();
 
 //                KisToolFreehand* tool = qobject_cast<KisToolFreehand*>(KoToolManager::instance()->toolById(d->view->canvasBase(), syncObject->activeToolId));
 //                if(tool && syncObject->smoothingOptions) {
 //                    tool->smoothingOptions()->setSmoothingType(syncObject->smoothingOptions->smoothingType());
 //                    tool->smoothingOptions()->setSmoothPressure(syncObject->smoothingOptions->smoothPressure());
 //                    tool->smoothingOptions()->setTailAggressiveness(syncObject->smoothingOptions->tailAggressiveness());
 //                    tool->smoothingOptions()->setUseScalableDistance(syncObject->smoothingOptions->useScalableDistance());
 //                    tool->smoothingOptions()->setSmoothnessDistance(syncObject->smoothingOptions->smoothnessDistance());
 //                    tool->smoothingOptions()->setUseDelayDistance(syncObject->smoothingOptions->useDelayDistance());
 //                    tool->smoothingOptions()->setDelayDistance(syncObject->smoothingOptions->delayDistance());
 //                    tool->smoothingOptions()->setFinishStabilizedCurve(syncObject->smoothingOptions->finishStabilizedCurve());
 //                    tool->smoothingOptions()->setStabilizeSensors(syncObject->smoothingOptions->stabilizeSensors());
 //                    tool->updateSettingsViews();
 //                }
 
 //                KisCanvasResourceProvider* provider = d->view->resourceProvider();
 
 //                provider->setMirrorHorizontal(syncObject->mirrorHorizontal);
 //                provider->setMirrorVertical(syncObject->mirrorVertical);
 //                //provider->resourceManager()->setResource(KisCanvasResourceProvider::MirrorAxesCenter, syncObject->mirrorAxesCenter);
 
 //                provider->setPaintOpPreset(syncObject->paintOp);
 //                qApp->processEvents();
 
 //                KoToolManager::instance()->switchToolRequested("InteractionTool");
 //                qApp->processEvents();
 //                KoToolManager::instance()->switchToolRequested(syncObject->activeToolId);
 //                qApp->processEvents();
 
 //                provider->setBGColor(syncObject->backgroundColor);
 //                provider->setFGColor(syncObject->foregroundColor);
 //                provider->setHDRExposure(syncObject->exposure);
 //                provider->setHDRGamma(syncObject->gamma);
 //                provider->slotPatternActivated(syncObject->pattern);
 //                provider->slotGradientActivated(syncObject->gradient);
 //                provider->slotNodeActivated(syncObject->node);
 //                provider->setOpacity(syncObject->opacity);
 //                provider->setGlobalAlphaLock(syncObject->globalAlphaLock);
 //                provider->setCurrentCompositeOp(syncObject->compositeOp);
 
 //                d->view->document()->setGridConfig(syncObject->gridConfig);
 
 //                zoomIn();
 //                qApp->processEvents();
 
 //                d->view->zoomController()->setZoom(KoZoomMode::ZOOM_CONSTANT, syncObject->zoomLevel);
 //                controller->rotateCanvas(syncObject->rotationAngle - d->view->canvasBase()->rotationAngle());
 
 //                qApp->processEvents();
 //                QPoint newOffset = syncObject->documentOffset;
 //                controller->setScrollBarValue(newOffset);
 //            }
 
 //            return true;
 //        }
 //#ifdef Q_OS_X11
 //            if(d->tabletEventCount % 2 == 0)
 //#endif
 //                d->canvas->globalInputManager()->eventFilter(this, event);
 //            return true;
 //        case QEvent::KeyPress:
 //        case QEvent::KeyRelease:
 //            emit interactionStarted();
 //            QApplication::sendEvent(d->view, event);
 //            break;
 //        default:
 //            break;
 //    }
 
     return QQuickItem::event( event );
 }
 
     // QT5TODO
 #if 0
 bool KisSketchView::sceneEvent(QEvent* event)
 {
     if (d->canvas && d->canvasWidget) {
         switch(event->type()) {
         case QEvent::GraphicsSceneMousePress: {
             QGraphicsSceneMouseEvent *gsmevent = static_cast<QGraphicsSceneMouseEvent*>(event);
             QMouseEvent mevent(QMouseEvent::MouseButtonPress, gsmevent->pos().toPoint(), gsmevent->button(), gsmevent->buttons(), gsmevent->modifiers());
             QApplication::sendEvent(d->canvasWidget, &mevent);
             emit interactionStarted();
             return true;
         }
         case QEvent::GraphicsSceneMouseMove: {
             QGraphicsSceneMouseEvent *gsmevent = static_cast<QGraphicsSceneMouseEvent*>(event);
             QMouseEvent mevent(QMouseEvent::MouseMove, gsmevent->pos().toPoint(), gsmevent->button(), gsmevent->buttons(), gsmevent->modifiers());
             QApplication::sendEvent(d->canvasWidget, &mevent);
             update();
             emit interactionStarted();
             return true;
         }
         case QEvent::GraphicsSceneMouseRelease: {
             QGraphicsSceneMouseEvent *gsmevent = static_cast<QGraphicsSceneMouseEvent*>(event);
             QMouseEvent mevent(QMouseEvent::MouseButtonRelease, gsmevent->pos().toPoint(), gsmevent->button(), gsmevent->buttons(), gsmevent->modifiers());
             QApplication::sendEvent(d->canvasWidget, &mevent);
             emit interactionStarted();
             return true;
         }
         case QEvent::GraphicsSceneWheel: {
             QGraphicsSceneWheelEvent *gswevent = static_cast<QGraphicsSceneWheelEvent*>(event);
             QWheelEvent wevent(gswevent->pos().toPoint(), gswevent->delta(), gswevent->buttons(), gswevent->modifiers(), gswevent->orientation());
             QApplication::sendEvent(d->canvasWidget, &wevent);
             emit interactionStarted();
             return true;
         }
         case QEvent::GraphicsSceneHoverEnter: {
             QGraphicsSceneHoverEvent *hevent = static_cast<QGraphicsSceneHoverEvent*>(event);
             QHoverEvent e(QEvent::Enter, hevent->screenPos(), hevent->lastScreenPos());
             QApplication::sendEvent(d->canvasWidget, &e);
             return true;
         }
         case QEvent::GraphicsSceneHoverLeave: {
             QGraphicsSceneHoverEvent *hevent = static_cast<QGraphicsSceneHoverEvent*>(event);
             QHoverEvent e(QEvent::Leave, hevent->screenPos(), hevent->lastScreenPos());
             QApplication::sendEvent(d->canvasWidget, &e);
             return true;
         }
         case QEvent::TouchBegin: {
             QApplication::sendEvent(d->canvasWidget, event);
             event->accept();
             emit interactionStarted();
             return true;
         }
         case QEvent::TabletPress:
         case QEvent::TabletMove:
         case QEvent::TabletRelease:
             d->canvas->globalInputManager()->stopIgnoringEvents();
             QApplication::sendEvent(d->canvasWidget, event);
             return true;
         default:
             if (QApplication::sendEvent(d->canvasWidget, event)) {
                 emit interactionStarted();
                 return true;
             }
         }
     }
     return QQuickItem::sceneEvent(event);
 }
 #endif
 void KisSketchView::geometryChanged(const QRectF& newGeometry, const QRectF& oldGeometry)
 {
     if (d->canvasWidget && !newGeometry.isEmpty()) {
         d->view->resize(newGeometry.toRect().size());
         // If we don't ask for this event to be sent, the view does not actually handle
         // the resize, and we're stuck with a very oddly sized viewport
         QResizeEvent *event = new QResizeEvent(newGeometry.toRect().size(), d->view->size());
         QApplication::sendEvent(d->view, event);
         // This is a touch on the hackish side - i'm sure there's a better way of doing it
         // but it's taking a long time to work it out. Problem: When switching orientation,
         // the canvas is rendered wrong, in what looks like an off-by-one ish kind of fashion.
         if (oldGeometry.height() == oldGeometry.width() && oldGeometry.height() == newGeometry.width()) {
             // in this case, we've just rotated the display... do something useful!
             // Turns out we get /two/ resize events per rotation, one one per setting each height and width.
             // So we can't just check it normally. Annoying, but there you go.
             QTimer::singleShot(100, this, SLOT(centerDoc()));
             QTimer::singleShot(150, this, SLOT(zoomOut()));
         }
         if (oldGeometry.height() == oldGeometry.width() && oldGeometry.width() == newGeometry.height()) {
             // in this case, we've just rotated the display... do something useful!
             // Turns out we get /two/ resize events per rotation, one one per setting each height and width.
             // So we can't just check it normally. Annoying, but there you go.
             QTimer::singleShot(100, this, SLOT(centerDoc()));
             QTimer::singleShot(150, this, SLOT(zoomOut()));
         }
     }
 }
 
 void KisSketchView::centerDoc()
 {
     d->viewManager->zoomController()->setZoom(KoZoomMode::ZOOM_PAGE, 1.0);
 }
 
 void KisSketchView::Private::imageUpdated(const QRect &/*updated*/)
 {
     // QT5TODO
 //     if (q->scene()) {
 //         q->scene()->views().at(0)->update(updated);
 //         q->scene()->invalidate( 0, 0, q->width(), q->height() );
 //     }
 }
 
 void KisSketchView::Private::documentOffsetMoved()
 {
     // QT5TODO
 //     if (q->scene()) {
 //         q->scene()->views().at(0)->update();
 //         q->scene()->invalidate( 0, 0, q->width(), q->height() );
 //     }
 }
 
 void KisSketchView::Private::resetDocumentPosition()
 {
     viewManager->zoomController()->setZoomMode(KoZoomMode::ZOOM_PAGE);
 
     QPoint pos;
     KisCanvasController *controller = dynamic_cast<KisCanvasController*>(viewManager->canvasBase()->canvasController());
 
     if (!controller) return;
 
     QScrollBar *sb = controller->horizontalScrollBar();
     pos.rx() = sb->minimum() + (sb->maximum() - sb->minimum()) / 2;
 
     sb = controller->verticalScrollBar();
     pos.ry() = sb->minimum() + (sb->maximum() - sb->minimum()) / 2;
 
     controller->setScrollBarValue(pos);
 
 }
 
 
 void KisSketchView::Private::removeNodeAsync(KisNodeSP removedNode)
 {
     if (removedNode) {
         imageUpdated(removedNode->extent());
     }
 }
 
 void KisSketchView::Private::zoomChanged()
 {
     // QT5TODO
 //     if (q->scene()) {
 //         q->scene()->views().at(0)->update();
 //         q->scene()->invalidate( 0, 0, q->width(), q->height() );
 //     }
 }
 
 void KisSketchView::activate()
 {
     if (d->canvasWidget != d->canvas->canvasWidget()) {
         d->canvasWidget = d->canvas->canvasWidget();
     // QT5TODO
 // 		SketchDeclarativeView *v = qobject_cast<SketchDeclarativeView*>(scene()->views().at(0));
 // 		if (v) {
 // 			v->setCanvasWidget(d->canvasWidget);
 // 			v->setDrawCanvas(true);
 // 		}
     }
     d->canvasWidget->setFocus();
     Q_ASSERT(d->viewManager);
     KisCanvasController *controller = dynamic_cast<KisCanvasController*>(d->viewManager->canvasBase()->canvasController());
     Q_ASSERT(controller);
     controller->activate();
 }
 
 // for private slots
 #include "moc_KisSketchView.cpp"
diff --git a/libs/pigment/resources/KoColorSet.cpp b/libs/pigment/resources/KoColorSet.cpp
index aa80c8dc3e..e7f9ab0f18 100644
--- a/libs/pigment/resources/KoColorSet.cpp
+++ b/libs/pigment/resources/KoColorSet.cpp
@@ -1,1657 +1,1655 @@
 /*  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
 {
     int yInGroup = y;
     KisSwatch e;
     QString nameGroupFoundIn;
     for (const QString &groupName : d->groupNames) {
         if (yInGroup < d->groups[groupName].rowCount()) {
             nameGroupFoundIn = groupName;
             break;
         } else {
             yInGroup -= d->groups[groupName].rowCount();
         }
     }
     KisSwatchGroup &groupFoundIn = d->global();
     if (nameGroupFoundIn != GLOBAL_GROUP_NAME) {
         groupFoundIn = d->groups[nameGroupFoundIn];
     }
     if (groupFoundIn.checkEntry(x, yInGroup)) {
         e = groupFoundIn.getEntry(x, yInGroup);
     }
     return e;
 }
 
 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()
 {
     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)) {
         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) {
         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) {
         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)
-    , isGlobal(true)
-    , isEditable(false)
 {
     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() ? i18n("Untitled") : name);
+            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_p.h b/libs/pigment/resources/KoColorSet_p.h
index 3659d88aef..625cc38b17 100644
--- a/libs/pigment/resources/KoColorSet_p.h
+++ b/libs/pigment/resources/KoColorSet_p.h
@@ -1,74 +1,74 @@
 #ifndef KOCOLORSET_P_H
 #define KOCOLORSET_P_H
 
 #include <QHash>
 #include <QXmlStreamReader>
 #include <QDomElement>
 #include <QPointer>
 
 #include <KisSwatch.h>
 #include <KisSwatchGroup.h>
 
 #include "KoColorSet.h"
 
 struct RiffHeader {
     quint32 riff;
     quint32 size;
     quint32 signature;
     quint32 data;
     quint32 datasize;
     quint16 version;
     quint16 colorcount;
 };
 
 class KoColorSet::Private
 {
 private:
     typedef KisSwatchGroup::SwatchInfo SwatchInfoType;
 
 public:
     Private(KoColorSet *a_colorSet);
 
 public:
     KisSwatchGroup &global() {
         Q_ASSERT(groups.contains(GLOBAL_GROUP_NAME));
         return groups[GLOBAL_GROUP_NAME];
     }
 public:
     bool init();
 
     bool saveGpl(QIODevice *dev) const;
     bool loadGpl();
 
     bool loadAct();
     bool loadRiff();
     bool loadPsp();
     bool loadAco();
     bool loadXml();
     bool loadSbz();
 
     bool saveKpl(QIODevice *dev) const;
     bool loadKpl();
 
 public:
-    KoColorSet *colorSet;
+    KoColorSet *colorSet {0};
     KoColorSet::PaletteType paletteType;
     QByteArray data;
     QString comment;
     QStringList groupNames; //names of the groups, this is used to determine the order they are in.
     QHash<QString, KisSwatchGroup> groups; //grouped colors.
-    bool isGlobal;
-    bool isEditable;
+    bool isGlobal {true};
+    bool isEditable {false};
 
 private:
     KoColorSet::PaletteType detectFormat(const QString &fileName, const QByteArray &ba);
     void scribusParseColor(KoColorSet *set, QXmlStreamReader *xml);
     bool loadScribusXmlPalette(KoColorSet *set, QXmlStreamReader *xml);
     quint16 readShort(QIODevice *io);
 
     void saveKplGroup(QDomDocument &doc, QDomElement &groupEle,
                       const KisSwatchGroup *group, QSet<const KoColorSpace *> &colorSetSet) const;
     void loadKplGroup(const QDomDocument &doc, const QDomElement &parentElement, KisSwatchGroup *group);
 };
 
 #endif // KOCOLORSET_P_H
diff --git a/libs/ui/CMakeLists.txt b/libs/ui/CMakeLists.txt
index 31c9abcc14..6672b39c16 100644
--- a/libs/ui/CMakeLists.txt
+++ b/libs/ui/CMakeLists.txt
@@ -1,626 +1,627 @@
 include_directories(
     ${CMAKE_CURRENT_SOURCE_DIR}/qtlockedfile
 )
 
 include_directories(SYSTEM
     ${EIGEN3_INCLUDE_DIR}
     ${OCIO_INCLUDE_DIR}
 )
 
 if (ANDROID)
     add_definitions(-DQT_OPENGL_ES_3)
     add_definitions(-DHAS_ONLY_OPENGL_ES)
 endif()
 
 add_subdirectory( tests )
 
 if (APPLE)
     find_library(FOUNDATION_LIBRARY Foundation)
     find_library(APPKIT_LIBRARY AppKit)
 endif ()
 
 set(kritaui_LIB_SRCS
     canvas/kis_canvas_widget_base.cpp
     canvas/kis_canvas2.cpp
     canvas/kis_canvas_updates_compressor.cpp
     canvas/kis_canvas_controller.cpp
-    canvas/kis_paintop_transformation_connector.cpp
     canvas/kis_display_color_converter.cpp
     canvas/kis_display_filter.cpp
     canvas/kis_exposure_gamma_correction_interface.cpp
     canvas/kis_tool_proxy.cpp
     canvas/kis_canvas_decoration.cc
     canvas/kis_coordinates_converter.cpp
     canvas/kis_grid_manager.cpp
     canvas/kis_grid_decoration.cpp
     canvas/kis_grid_config.cpp
     canvas/kis_prescaled_projection.cpp
     canvas/kis_qpainter_canvas.cpp
     canvas/kis_projection_backend.cpp
     canvas/kis_update_info.cpp
     canvas/kis_image_patch.cpp
     canvas/kis_image_pyramid.cpp
     canvas/kis_infinity_manager.cpp
     canvas/kis_change_guides_command.cpp
     canvas/kis_guides_decoration.cpp
     canvas/kis_guides_manager.cpp
     canvas/kis_guides_config.cpp
     canvas/kis_snap_config.cpp
     canvas/kis_snap_line_strategy.cpp
     canvas/KisSnapPointStrategy.cpp
     canvas/KisSnapPixelStrategy.cpp
 	canvas/KisMirrorAxisConfig.cpp
 	dialogs/kis_about_application.cpp
     dialogs/kis_dlg_adj_layer_props.cc
     dialogs/kis_dlg_adjustment_layer.cc
     dialogs/kis_dlg_filter.cpp
     dialogs/kis_dlg_generator_layer.cpp
     dialogs/kis_dlg_file_layer.cpp
     dialogs/kis_dlg_filter.cpp
     dialogs/kis_dlg_stroke_selection_properties.cpp
     dialogs/kis_dlg_image_properties.cc
     dialogs/kis_dlg_layer_properties.cc
     dialogs/kis_dlg_preferences.cc
     dialogs/slider_and_spin_box_sync.cpp
     dialogs/kis_dlg_blacklist_cleanup.cpp
     dialogs/kis_dlg_layer_style.cpp
     dialogs/kis_dlg_png_import.cpp
     dialogs/kis_dlg_import_image_sequence.cpp
     dialogs/kis_delayed_save_dialog.cpp
     dialogs/KisSessionManagerDialog.cpp
     dialogs/KisNewWindowLayoutDialog.cpp
     dialogs/KisDlgChangeCloneSource.cpp
     flake/kis_node_dummies_graph.cpp
     flake/kis_dummies_facade_base.cpp
     flake/kis_dummies_facade.cpp
     flake/kis_node_shapes_graph.cpp
     flake/kis_node_shape.cpp
     flake/kis_shape_controller.cpp
     flake/kis_shape_layer.cc
     flake/kis_shape_layer_canvas.cpp
     flake/kis_shape_selection.cpp
     flake/kis_shape_selection_canvas.cpp
     flake/kis_shape_selection_model.cpp
     flake/kis_take_all_shapes_command.cpp
     brushhud/kis_uniform_paintop_property_widget.cpp
     brushhud/kis_brush_hud.cpp
     brushhud/kis_round_hud_button.cpp
     brushhud/kis_dlg_brush_hud_config.cpp
     brushhud/kis_brush_hud_properties_list.cpp
     brushhud/kis_brush_hud_properties_config.cpp
 
     kis_aspect_ratio_locker.cpp
     kis_autogradient.cc
     kis_bookmarked_configurations_editor.cc
     kis_bookmarked_configurations_model.cc
     kis_bookmarked_filter_configurations_model.cc
     KisPaintopPropertiesBase.cpp
     kis_canvas_resource_provider.cpp
     kis_derived_resources.cpp
     kis_categories_mapper.cpp
     kis_categorized_list_model.cpp
     kis_categorized_item_delegate.cpp
     kis_clipboard.cc
     kis_config.cc
     KisOcioConfiguration.cpp
     kis_control_frame.cpp
     kis_composite_ops_model.cc
     kis_paint_ops_model.cpp
     kis_cursor.cc
     kis_cursor_cache.cpp
     kis_custom_pattern.cc
     kis_file_layer.cpp
     kis_change_file_layer_command.h
     kis_safe_document_loader.cpp
     kis_splash_screen.cpp
     kis_filter_manager.cc
     kis_filters_model.cc
     KisImageBarrierLockerWithFeedback.cpp
     kis_image_manager.cc
     kis_image_view_converter.cpp
     kis_import_catcher.cc
     kis_layer_manager.cc
     kis_mask_manager.cc
     kis_mimedata.cpp
     kis_node_commands_adapter.cpp
     kis_node_manager.cpp
     kis_node_juggler_compressed.cpp
     kis_node_selection_adapter.cpp
     kis_node_insertion_adapter.cpp
     KisNodeDisplayModeAdapter.cpp
     kis_node_model.cpp
     kis_node_filter_proxy_model.cpp
     kis_model_index_converter_base.cpp
     kis_model_index_converter.cpp
     kis_model_index_converter_show_all.cpp
     kis_painting_assistant.cc
     kis_painting_assistants_decoration.cpp
     KisDecorationsManager.cpp
     kis_paintop_box.cc
     kis_paintop_option.cpp
     kis_paintop_options_model.cpp
     kis_paintop_settings_widget.cpp
     kis_popup_palette.cpp
     kis_png_converter.cpp
     kis_preference_set_registry.cpp
     KisResourceServerProvider.cpp
     KisResourceBundleServerProvider.cpp
     KisSelectedShapesProxy.cpp
     kis_selection_decoration.cc
     kis_selection_manager.cc
     KisSelectionActionsAdapter.cpp
     kis_statusbar.cc
     kis_zoom_manager.cc
     kis_favorite_resource_manager.cpp
     kis_workspace_resource.cpp
     kis_action.cpp
     kis_action_manager.cpp
     KisActionPlugin.cpp
     kis_canvas_controls_manager.cpp
     kis_tooltip_manager.cpp
     kis_multinode_property.cpp
     kis_stopgradient_editor.cpp
     KisWelcomePageWidget.cpp
     KisChangeCloneLayersCommand.cpp
 
     kisexiv2/kis_exif_io.cpp
     kisexiv2/kis_exiv2.cpp
     kisexiv2/kis_iptc_io.cpp
     kisexiv2/kis_xmp_io.cpp
 
     opengl/kis_opengl.cpp
     opengl/kis_opengl_canvas2.cpp
     opengl/kis_opengl_canvas_debugger.cpp
     opengl/kis_opengl_image_textures.cpp
     opengl/kis_texture_tile.cpp
     opengl/kis_opengl_shader_loader.cpp
     opengl/kis_texture_tile_info_pool.cpp
     opengl/KisOpenGLUpdateInfoBuilder.cpp
     opengl/KisOpenGLModeProber.cpp
     opengl/KisScreenInformationAdapter.cpp
     kis_fps_decoration.cpp
 
     tool/KisToolChangesTracker.cpp
     tool/KisToolChangesTrackerData.cpp
     tool/kis_selection_tool_helper.cpp
     tool/kis_selection_tool_config_widget_helper.cpp
     tool/kis_rectangle_constraint_widget.cpp
     tool/kis_shape_tool_helper.cpp
     tool/kis_tool.cc
     tool/kis_delegated_tool_policies.cpp
     tool/kis_tool_freehand.cc
     tool/kis_speed_smoother.cpp
     tool/kis_painting_information_builder.cpp
     tool/kis_stabilized_events_sampler.cpp
     tool/kis_tool_freehand_helper.cpp
     tool/kis_tool_multihand_helper.cpp
     tool/kis_figure_painting_tool_helper.cpp
+    tool/KisAsyncronousStrokeUpdateHelper.cpp
     tool/kis_tool_paint.cc
     tool/kis_tool_shape.cc
     tool/kis_tool_ellipse_base.cpp
     tool/kis_tool_rectangle_base.cpp
     tool/kis_tool_polyline_base.cpp
     tool/kis_tool_utils.cpp
     tool/kis_resources_snapshot.cpp
     tool/kis_smoothing_options.cpp
     tool/KisStabilizerDelayedPaintHelper.cpp
     tool/KisStrokeSpeedMonitor.cpp
     tool/strokes/freehand_stroke.cpp
     tool/strokes/KisStrokeEfficiencyMeasurer.cpp
     tool/strokes/kis_painter_based_stroke_strategy.cpp
     tool/strokes/kis_filter_stroke_strategy.cpp
     tool/strokes/kis_color_picker_stroke_strategy.cpp
     tool/strokes/KisFreehandStrokeInfo.cpp
     tool/strokes/KisMaskedFreehandStrokePainter.cpp
     tool/strokes/KisMaskingBrushRenderer.cpp
     tool/strokes/KisMaskingBrushCompositeOpFactory.cpp
     tool/strokes/move_stroke_strategy.cpp
     tool/KisSelectionToolFactoryBase.cpp
     tool/KisToolPaintFactoryBase.cpp
 
     widgets/kis_cmb_composite.cc
     widgets/kis_cmb_contour.cpp
     widgets/kis_cmb_gradient.cpp
     widgets/kis_paintop_list_widget.cpp
     widgets/kis_cmb_idlist.cc
     widgets/kis_color_space_selector.cc
     widgets/kis_advanced_color_space_selector.cc
     widgets/kis_cie_tongue_widget.cpp
     widgets/kis_tone_curve_widget.cpp
     widgets/kis_curve_widget.cpp
     widgets/kis_custom_image_widget.cc
     widgets/kis_image_from_clipboard_widget.cpp
     widgets/kis_double_widget.cc
     widgets/kis_filter_selector_widget.cc
     widgets/kis_gradient_chooser.cc
     widgets/kis_iconwidget.cc
     widgets/kis_mask_widgets.cpp
     widgets/kis_meta_data_merge_strategy_chooser_widget.cc
     widgets/kis_multi_bool_filter_widget.cc
     widgets/kis_multi_double_filter_widget.cc
     widgets/kis_multi_integer_filter_widget.cc
     widgets/kis_multipliers_double_slider_spinbox.cpp
     widgets/kis_paintop_presets_popup.cpp
     widgets/kis_tool_options_popup.cpp
     widgets/kis_paintop_presets_chooser_popup.cpp
     widgets/kis_paintop_presets_save.cpp
     widgets/kis_paintop_preset_icon_library.cpp
     widgets/kis_pattern_chooser.cc
 
     widgets/kis_preset_chooser.cpp
     widgets/kis_progress_widget.cpp
     widgets/kis_selection_options.cc
     widgets/kis_scratch_pad.cpp
     widgets/kis_scratch_pad_event_filter.cpp
     widgets/kis_preset_selector_strip.cpp
     widgets/kis_slider_spin_box.cpp
     widgets/KisSelectionPropertySlider.cpp
     widgets/kis_size_group.cpp
     widgets/kis_size_group_p.cpp
     widgets/kis_wdg_generator.cpp
     widgets/kis_workspace_chooser.cpp
     widgets/kis_categorized_list_view.cpp
     widgets/kis_widget_chooser.cpp
     widgets/kis_tool_button.cpp
     widgets/kis_floating_message.cpp
     widgets/kis_lod_availability_widget.cpp
     widgets/kis_color_label_selector_widget.cpp
     widgets/kis_color_filter_combo.cpp
     widgets/kis_elided_label.cpp
     widgets/kis_stopgradient_slider_widget.cpp
     widgets/kis_preset_live_preview_view.cpp
     widgets/KisScreenColorPicker.cpp
     widgets/KoDualColorButton.cpp
     widgets/KoStrokeConfigWidget.cpp
     widgets/KoFillConfigWidget.cpp
     widgets/KisLayerStyleAngleSelector.cpp
     widgets/KisMemoryReportButton.cpp
     widgets/KisDitherWidget.cpp
 
     KisPaletteEditor.cpp
     dialogs/KisDlgPaletteEditor.cpp
 
     widgets/KisNewsWidget.cpp
     widgets/KisGamutMaskToolbar.cpp
 
     utils/kis_document_aware_spin_box_unit_manager.cpp
     utils/KisSpinBoxSplineUnitConverter.cpp
     utils/KisClipboardUtil.cpp
     utils/KisDitherUtil.cpp
 
     input/kis_input_manager.cpp
     input/kis_input_manager_p.cpp
     input/kis_extended_modifiers_mapper.cpp
     input/kis_abstract_input_action.cpp
     input/kis_tool_invocation_action.cpp
     input/kis_pan_action.cpp
     input/kis_alternate_invocation_action.cpp
     input/kis_rotate_canvas_action.cpp
     input/kis_zoom_action.cpp
     input/kis_change_frame_action.cpp
     input/kis_gamma_exposure_action.cpp
     input/kis_show_palette_action.cpp
     input/kis_change_primary_setting_action.cpp
     input/kis_abstract_shortcut.cpp
     input/kis_native_gesture_shortcut.cpp
     input/kis_single_action_shortcut.cpp
     input/kis_stroke_shortcut.cpp
     input/kis_shortcut_matcher.cpp
     input/kis_select_layer_action.cpp
     input/KisQtWidgetsTweaker.cpp
     input/KisInputActionGroup.cpp
     input/kis_zoom_and_rotate_action.cpp
 
     operations/kis_operation.cpp
     operations/kis_operation_configuration.cpp
     operations/kis_operation_registry.cpp
     operations/kis_operation_ui_factory.cpp
     operations/kis_operation_ui_widget.cpp
     operations/kis_filter_selection_operation.cpp
     actions/kis_selection_action_factories.cpp
     actions/KisPasteActionFactories.cpp
     actions/KisTransformToolActivationCommand.cpp
     input/kis_touch_shortcut.cpp
     kis_document_undo_store.cpp
     kis_gui_context_command.cpp
     kis_gui_context_command_p.cpp
     input/kis_tablet_debugger.cpp
     input/kis_input_profile_manager.cpp
     input/kis_input_profile.cpp
     input/kis_shortcut_configuration.cpp
     input/config/kis_input_configuration_page.cpp
     input/config/kis_edit_profiles_dialog.cpp
     input/config/kis_input_profile_model.cpp
     input/config/kis_input_configuration_page_item.cpp
     input/config/kis_action_shortcuts_model.cpp
     input/config/kis_input_type_delegate.cpp
     input/config/kis_input_mode_delegate.cpp
     input/config/kis_input_button.cpp
     input/config/kis_input_editor_delegate.cpp
     input/config/kis_mouse_input_editor.cpp
     input/config/kis_wheel_input_editor.cpp
     input/config/kis_key_input_editor.cpp
     processing/fill_processing_visitor.cpp
     kis_asl_layer_style_serializer.cpp
     kis_psd_layer_style_resource.cpp
     canvas/kis_mirror_axis.cpp
 
     kis_abstract_perspective_grid.cpp
 
     KisApplication.cpp
     KisAutoSaveRecoveryDialog.cpp
     KisDetailsPane.cpp
     KisDocument.cpp
     KisCloneDocumentStroke.cpp
     kis_node_view_color_scheme.cpp
     KisImportExportFilter.cpp
     KisImportExportManager.cpp
     KisImportExportUtils.cpp
     kis_async_action_feedback.cpp
     KisMainWindow.cpp
     KisOpenPane.cpp
     KisPart.cpp
     KisPrintJob.cpp
     KisTemplate.cpp
     KisTemplateCreateDia.cpp
     KisTemplateGroup.cpp
     KisTemplates.cpp
     KisTemplatesPane.cpp
     KisTemplateTree.cpp
     KisUndoActionsUpdateManager.cpp
     KisView.cpp
+    KisCanvasWindow.cpp
     KisImportExportErrorCode.cpp
     KisImportExportAdditionalChecks.cpp
 
     thememanager.cpp
 
     kis_mainwindow_observer.cpp
     KisViewManager.cpp
     kis_mirror_manager.cpp
 
     qtlockedfile/qtlockedfile.cpp
 
     qtsingleapplication/qtlocalpeer.cpp
     qtsingleapplication/qtsingleapplication.cpp
 
     KisResourceBundle.cpp
     KisResourceBundleManifest.cpp
 
     kis_md5_generator.cpp
     KisApplicationArguments.cpp
 
     KisNetworkAccessManager.cpp
     KisMultiFeedRSSModel.cpp
     KisRemoteFileFetcher.cpp
 
     KisSaveGroupVisitor.cpp
     KisWindowLayoutResource.cpp
     KisWindowLayoutManager.cpp
     KisSessionResource.cpp
 
     KisReferenceImagesDecoration.cpp
     KisReferenceImage.cpp
     flake/KisReferenceImagesLayer.cpp
     flake/KisReferenceImagesLayer.h
     KisMouseClickEater.cpp
 )
 
 if(WIN32)
     # Private headers are needed for:
     #    * KisDlgCustomTabletResolution
     #    * KisScreenInformationAdapter
     include_directories(SYSTEM ${Qt5Gui_PRIVATE_INCLUDE_DIRS})
 
     set(kritaui_LIB_SRCS
         ${kritaui_LIB_SRCS}
         qtlockedfile/qtlockedfile_win.cpp
     )
     if (NOT USE_QT_TABLET_WINDOWS)
         set(kritaui_LIB_SRCS
             ${kritaui_LIB_SRCS}
             input/wintab/kis_tablet_support_win.cpp
             input/wintab/kis_screen_size_choice_dialog.cpp
             input/wintab/kis_tablet_support_win8.cpp
             )
     else()
         set(kritaui_LIB_SRCS
             ${kritaui_LIB_SRCS}
             dialogs/KisDlgCustomTabletResolution.cpp
             )
     endif()
 endif()
 
     set(kritaui_LIB_SRCS
         ${kritaui_LIB_SRCS}
         kis_animation_frame_cache.cpp
         kis_animation_cache_populator.cpp
         KisAsyncAnimationRendererBase.cpp
         KisAsyncAnimationCacheRenderer.cpp
         KisAsyncAnimationFramesSavingRenderer.cpp
         dialogs/KisAsyncAnimationRenderDialogBase.cpp
         dialogs/KisAsyncAnimationCacheRenderDialog.cpp
         dialogs/KisAsyncAnimationFramesSaveDialog.cpp
         canvas/kis_animation_player.cpp
         kis_animation_importer.cpp
         KisSyncedAudioPlayback.cpp
         KisFrameDataSerializer.cpp
         KisFrameCacheStore.cpp
         KisFrameCacheSwapper.cpp
         KisAbstractFrameCacheSwapper.cpp
         KisInMemoryFrameCacheSwapper.cpp
 
         input/wintab/drawpile_tablettester/tablettester.cpp
         input/wintab/drawpile_tablettester/tablettest.cpp
     )
 
 if (UNIX)
     set(kritaui_LIB_SRCS
         ${kritaui_LIB_SRCS}
         qtlockedfile/qtlockedfile_unix.cpp
         )
 endif()
 
 if(APPLE)
     set(kritaui_LIB_SRCS
         ${kritaui_LIB_SRCS}
         osx.mm
     )
 endif()
 
 ki18n_wrap_ui(kritaui_LIB_SRCS
     widgets/KoFillConfigWidget.ui
     widgets/KoStrokeConfigWidget.ui
     widgets/KisDitherWidget.ui
     forms/wdgdlgpngimport.ui
     forms/wdgfullscreensettings.ui
     forms/wdgautogradient.ui
     forms/wdggeneralsettings.ui
     forms/wdgperformancesettings.ui
     forms/wdggenerators.ui
     forms/wdgbookmarkedconfigurationseditor.ui
     forms/wdgapplyprofile.ui
     forms/wdgcustompattern.ui
     forms/wdglayerproperties.ui
     forms/wdgcolorsettings.ui
     forms/wdgtabletsettings.ui
     forms/wdgcolorspaceselector.ui
     forms/wdgcolorspaceselectoradvanced.ui
     forms/wdgdisplaysettings.ui
     forms/kis_previewwidgetbase.ui
     forms/kis_matrix_widget.ui
     forms/wdgselectionoptions.ui
     forms/wdggeometryoptions.ui
     forms/wdgnewimage.ui
     forms/wdgimageproperties.ui
     forms/wdgmaskfromselection.ui
     forms/wdgmasksource.ui
     forms/wdgfilterdialog.ui
     forms/wdgmetadatamergestrategychooser.ui
     forms/wdgpaintoppresets.ui
     forms/wdgpaintopsettings.ui
     forms/wdgdlggeneratorlayer.ui
     forms/wdgdlgfilelayer.ui
     forms/wdgfilterselector.ui
     forms/wdgfilternodecreation.ui
     forms/wdgmultipliersdoublesliderspinbox.ui
     forms/wdgnodequerypatheditor.ui
     forms/wdgpresetselectorstrip.ui
     forms/wdgsavebrushpreset.ui
     forms/wdgpreseticonlibrary.ui
     forms/wdgdlgblacklistcleanup.ui
     forms/wdgrectangleconstraints.ui
     forms/wdgimportimagesequence.ui
     forms/wdgstrokeselectionproperties.ui
     forms/KisDetailsPaneBase.ui
     forms/KisOpenPaneBase.ui
     forms/wdgstopgradienteditor.ui
     forms/wdgsessionmanager.ui
     forms/wdgnewwindowlayout.ui
     forms/KisWelcomePage.ui
     forms/WdgDlgPaletteEditor.ui
     forms/KisNewsPage.ui
     forms/wdgGamutMaskToolbar.ui
     forms/wdgchangeclonesource.ui
 
     brushhud/kis_dlg_brush_hud_config.ui
     dialogs/kis_delayed_save_dialog.ui
     input/config/kis_input_configuration_page.ui
     input/config/kis_edit_profiles_dialog.ui
     input/config/kis_input_configuration_page_item.ui
     input/config/kis_mouse_input_editor.ui
     input/config/kis_wheel_input_editor.ui
     input/config/kis_key_input_editor.ui
 
     layerstyles/wdgBevelAndEmboss.ui
     layerstyles/wdgblendingoptions.ui
     layerstyles/WdgColorOverlay.ui
     layerstyles/wdgContour.ui
     layerstyles/wdgdropshadow.ui
     layerstyles/WdgGradientOverlay.ui
     layerstyles/wdgInnerGlow.ui
     layerstyles/wdglayerstyles.ui
     layerstyles/WdgPatternOverlay.ui
     layerstyles/WdgSatin.ui
     layerstyles/WdgStroke.ui
     layerstyles/wdgstylesselector.ui
     layerstyles/wdgTexture.ui
     layerstyles/wdgKisLayerStyleAngleSelector.ui
 
     wdgsplash.ui
     input/wintab/kis_screen_size_choice_dialog.ui
     input/wintab/drawpile_tablettester/tablettest.ui
 
 )
 
 if(WIN32)
     if(USE_QT_TABLET_WINDOWS)
         ki18n_wrap_ui(kritaui_LIB_SRCS
             dialogs/KisDlgCustomTabletResolution.ui
         )
     else()
         ki18n_wrap_ui(kritaui_LIB_SRCS
             input/wintab/kis_screen_size_choice_dialog.ui
         )
     endif()
 endif()
 
 
 add_library(kritaui SHARED ${kritaui_HEADERS_MOC} ${kritaui_LIB_SRCS} )
 generate_export_header(kritaui BASE_NAME kritaui)
 
 target_link_libraries(kritaui KF5::CoreAddons KF5::Completion KF5::I18n KF5::ItemViews Qt5::Network
                       kritaimpex kritacolor kritaimage kritalibbrush kritawidgets kritawidgetutils ${PNG_LIBRARIES} LibExiv2::LibExiv2
 )
 
 if (ANDROID)
     target_link_libraries(kritaui GLESv3)
     target_link_libraries(kritaui Qt5::Gui)
 endif()
 
 if (HAVE_QT_MULTIMEDIA)
     target_link_libraries(kritaui Qt5::Multimedia)
 endif()
 
 if (NOT WIN32 AND NOT APPLE AND NOT ANDROID)
   target_link_libraries(kritaui ${X11_X11_LIB}
                                 ${X11_Xinput_LIB}
                                 ${XCB_LIBRARIES})
 endif()
 
 if(APPLE)
     target_link_libraries(kritaui ${FOUNDATION_LIBRARY})
     target_link_libraries(kritaui ${APPKIT_LIBRARY})
 endif ()
 
 
 target_link_libraries(kritaui ${OPENEXR_LIBRARIES})
 
 # Add VSync disable workaround
 if(NOT WIN32 AND NOT APPLE AND NOT ANDROID)
     target_link_libraries(kritaui ${CMAKE_DL_LIBS} Qt5::X11Extras)
 endif()
 
 if(X11_FOUND)
     target_link_libraries(kritaui Qt5::X11Extras ${X11_LIBRARIES})
 endif()
 
 target_include_directories(kritaui
     PUBLIC
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/canvas>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/flake>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/ora>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/tool>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/utils>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/widgets>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/input/wintab>
 )
 
 set_target_properties(kritaui
     PROPERTIES VERSION ${GENERIC_KRITA_LIB_VERSION} SOVERSION ${GENERIC_KRITA_LIB_SOVERSION}
 )
 install(TARGETS kritaui  ${INSTALL_TARGETS_DEFAULT_ARGS})
 
 
 if (APPLE)
     install(FILES osx.stylesheet DESTINATION ${DATA_INSTALL_DIR}/krita)
 endif ()
diff --git a/libs/ui/KisApplication.cpp b/libs/ui/KisApplication.cpp
index de80400a1f..0bde153a0f 100644
--- a/libs/ui/KisApplication.cpp
+++ b/libs/ui/KisApplication.cpp
@@ -1,873 +1,873 @@
 /*
  * Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
  * Copyright (C) 2012 Boudewijn Rempt <boud@valdyas.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "KisApplication.h"
 
 #include <stdlib.h>
 #ifdef Q_OS_WIN
 #include <windows.h>
 #include <tchar.h>
 #endif
 
 #ifdef Q_OS_MACOS
 #include "osx.h"
 #endif
 
 #include <QStandardPaths>
 #include <QDesktopWidget>
 #include <QDir>
 #include <QFile>
 #include <QLocale>
 #include <QMessageBox>
 #include <QProcessEnvironment>
 #include <QStringList>
 #include <QStyle>
 #include <QStyleFactory>
 #include <QSysInfo>
 #include <QTimer>
 #include <QWidget>
 
 #include <klocalizedstring.h>
 #include <kdesktopfile.h>
 #include <kconfig.h>
 #include <kconfiggroup.h>
 
 #include <KoColorSpaceRegistry.h>
 #include <KoPluginLoader.h>
 #include <KoShapeRegistry.h>
 #include <KoDpi.h>
 #include "KoConfig.h"
 #include <resources/KoHashGeneratorProvider.h>
 #include <KoResourcePaths.h>
 #include <KisMimeDatabase.h>
 #include "thememanager.h"
 #include "KisPrintJob.h"
 #include "KisDocument.h"
 #include "KisMainWindow.h"
 #include "KisAutoSaveRecoveryDialog.h"
 #include "KisPart.h"
 #include <kis_icon.h>
 #include "kis_md5_generator.h"
 #include "kis_splash_screen.h"
 #include "kis_config.h"
 #include "flake/kis_shape_selection.h"
 #include <filter/kis_filter.h>
 #include <filter/kis_filter_registry.h>
 #include <filter/kis_filter_configuration.h>
 #include <generator/kis_generator_registry.h>
 #include <generator/kis_generator.h>
 #include <brushengine/kis_paintop_registry.h>
 #include <kis_meta_data_io_backend.h>
 #include "kisexiv2/kis_exiv2.h"
 #include "KisApplicationArguments.h"
 #include <kis_debug.h>
 #include "kis_action_registry.h"
 #include <kis_brush_server.h>
 #include <KisResourceServerProvider.h>
 #include <KoResourceServerProvider.h>
 #include "kis_image_barrier_locker.h"
 #include "opengl/kis_opengl.h"
 #include "kis_spin_box_unit_manager.h"
 #include "kis_document_aware_spin_box_unit_manager.h"
 #include "KisViewManager.h"
 #include "kis_workspace_resource.h"
 
 #include <KritaVersionWrapper.h>
 #include <dialogs/KisSessionManagerDialog.h>
 
 #include "widgets/KisScreenColorPicker.h"
 #include "KisDlgInternalColorSelector.h"
 
 #include <dialogs/KisAsyncAnimationFramesSaveDialog.h>
 #include <kis_image_animation_interface.h>
 
 namespace {
 const QTime appStartTime(QTime::currentTime());
 }
 
 class KisApplication::Private
 {
 public:
     Private() {}
     QPointer<KisSplashScreen> splashScreen;
     KisAutoSaveRecoveryDialog *autosaveDialog {0};
     QPointer<KisMainWindow> mainWindow; // The first mainwindow we create on startup
     bool batchRun {false};
 
 };
 
 class KisApplication::ResetStarting
 {
 public:
     ResetStarting(KisSplashScreen *splash, int fileCount)
         : m_splash(splash)
         , m_fileCount(fileCount)
     {
     }
 
     ~ResetStarting()  {
 
         if (m_splash) {
             m_splash->hide();
         }
     }
 
     QPointer<KisSplashScreen> m_splash;
     int m_fileCount;
 };
 
 
 KisApplication::KisApplication(const QString &key, int &argc, char **argv)
     : QtSingleApplication(key, argc, argv)
     , d(new Private)
 {
 #ifdef Q_OS_MACOS
     setMouseCoalescingEnabled(false);
 #endif
 
     QCoreApplication::addLibraryPath(QCoreApplication::applicationDirPath());
 
     setApplicationDisplayName("Krita");
     setApplicationName("krita");
     // Note: Qt docs suggest we set this, but if we do, we get resource paths of the form of krita/krita, which is weird.
     //    setOrganizationName("krita");
     setOrganizationDomain("krita.org");
 
     QString version = KritaVersionWrapper::versionString(true);
     setApplicationVersion(version);
-    setWindowIcon(KisIconUtils::loadIcon("calligrakrita"));
+    setWindowIcon(KisIconUtils::loadIcon("krita"));
 
     if (qgetenv("KRITA_NO_STYLE_OVERRIDE").isEmpty()) {
         QStringList styles = QStringList() /*<< "breeze"*/ << "fusion" << "plastique";
         if (!styles.contains(style()->objectName().toLower())) {
             Q_FOREACH (const QString & style, styles) {
                 if (!setStyle(style)) {
                     qDebug() << "No" << style << "available.";
                 }
                 else {
                     qDebug() << "Set style" << style;
                     break;
                 }
             }
         }
     }
     else {
         qDebug() << "Style override disabled, using" << style()->objectName();
     }
 
     KisOpenGL::initialize();
 }
 
 #if defined(Q_OS_WIN) && defined(ENV32BIT)
 typedef BOOL (WINAPI *LPFN_ISWOW64PROCESS) (HANDLE, PBOOL);
 
 LPFN_ISWOW64PROCESS fnIsWow64Process;
 
 BOOL isWow64()
 {
     BOOL bIsWow64 = FALSE;
 
     //IsWow64Process is not available on all supported versions of Windows.
     //Use GetModuleHandle to get a handle to the DLL that contains the function
     //and GetProcAddress to get a pointer to the function if available.
 
     fnIsWow64Process = (LPFN_ISWOW64PROCESS) GetProcAddress(
                 GetModuleHandle(TEXT("kernel32")),"IsWow64Process");
 
     if(0 != fnIsWow64Process)
     {
         if (!fnIsWow64Process(GetCurrentProcess(),&bIsWow64))
         {
             //handle error
         }
     }
     return bIsWow64;
 }
 #endif
 
 void KisApplication::initializeGlobals(const KisApplicationArguments &args)
 {
     int dpiX = args.dpiX();
     int dpiY = args.dpiY();
     if (dpiX > 0 && dpiY > 0) {
         KoDpi::setDPI(dpiX, dpiY);
     }
 }
 
 void KisApplication::addResourceTypes()
 {
     //    qDebug() << "addResourceTypes();";
     // All Krita's resource types
     KoResourcePaths::addResourceType("markers", "data", "/styles/");
     KoResourcePaths::addResourceType("kis_pics", "data", "/pics/");
     KoResourcePaths::addResourceType("kis_images", "data", "/images/");
     KoResourcePaths::addResourceType("metadata_schema", "data", "/metadata/schemas/");
     KoResourcePaths::addResourceType("kis_brushes", "data", "/brushes/");
     KoResourcePaths::addResourceType("kis_taskset", "data", "/taskset/");
     KoResourcePaths::addResourceType("kis_taskset", "data", "/taskset/");
     KoResourcePaths::addResourceType("gmic_definitions", "data", "/gmic/");
     KoResourcePaths::addResourceType("kis_resourcebundles", "data", "/bundles/");
     KoResourcePaths::addResourceType("kis_defaultpresets", "data", "/defaultpresets/");
     KoResourcePaths::addResourceType("kis_paintoppresets", "data", "/paintoppresets/");
     KoResourcePaths::addResourceType("kis_workspaces", "data", "/workspaces/");
     KoResourcePaths::addResourceType("kis_windowlayouts", "data", "/windowlayouts/");
     KoResourcePaths::addResourceType("kis_sessions", "data", "/sessions/");
     KoResourcePaths::addResourceType("psd_layer_style_collections", "data", "/asl");
     KoResourcePaths::addResourceType("ko_patterns", "data", "/patterns/", true);
     KoResourcePaths::addResourceType("ko_gradients", "data", "/gradients/");
     KoResourcePaths::addResourceType("ko_gradients", "data", "/gradients/", true);
     KoResourcePaths::addResourceType("ko_palettes", "data", "/palettes/", true);
     KoResourcePaths::addResourceType("kis_shortcuts", "data", "/shortcuts/");
     KoResourcePaths::addResourceType("kis_actions", "data", "/actions");
     KoResourcePaths::addResourceType("icc_profiles", "data", "/color/icc");
     KoResourcePaths::addResourceType("icc_profiles", "data", "/profiles/");
     KoResourcePaths::addResourceType("ko_effects", "data", "/effects/");
     KoResourcePaths::addResourceType("tags", "data", "/tags/");
     KoResourcePaths::addResourceType("templates", "data", "/templates");
     KoResourcePaths::addResourceType("pythonscripts", "data", "/pykrita");
     KoResourcePaths::addResourceType("symbols", "data", "/symbols");
     KoResourcePaths::addResourceType("preset_icons", "data", "/preset_icons");
     KoResourcePaths::addResourceType("ko_gamutmasks", "data", "/gamutmasks/", true);
 
     //    // Extra directories to look for create resources. (Does anyone actually use that anymore?)
     //    KoResourcePaths::addResourceDir("ko_gradients", "/usr/share/create/gradients/gimp");
     //    KoResourcePaths::addResourceDir("ko_gradients", QDir::homePath() + QString("/.create/gradients/gimp"));
     //    KoResourcePaths::addResourceDir("ko_patterns", "/usr/share/create/patterns/gimp");
     //    KoResourcePaths::addResourceDir("ko_patterns", QDir::homePath() + QString("/.create/patterns/gimp"));
     //    KoResourcePaths::addResourceDir("kis_brushes", "/usr/share/create/brushes/gimp");
     //    KoResourcePaths::addResourceDir("kis_brushes", QDir::homePath() + QString("/.create/brushes/gimp"));
     //    KoResourcePaths::addResourceDir("ko_palettes", "/usr/share/create/swatches");
     //    KoResourcePaths::addResourceDir("ko_palettes", QDir::homePath() + QString("/.create/swatches"));
 
     // Make directories for all resources we can save, and tags
     QDir d;
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/tags/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/asl/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/bundles/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/brushes/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/gradients/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/paintoppresets/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/palettes/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/patterns/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/taskset/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/workspaces/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/input/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/pykrita/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/symbols/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/color-schemes/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/preset_icons/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/preset_icons/tool_icons/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/preset_icons/emblem_icons/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/gamutmasks/");
 }
 
 void KisApplication::loadResources()
 {
     //    qDebug() << "loadResources();";
 
     setSplashScreenLoadingText(i18n("Loading Resources..."));
     processEvents();
     KoResourceServerProvider::instance();
 
     setSplashScreenLoadingText(i18n("Loading Brush Presets..."));
     processEvents();
     KisResourceServerProvider::instance();
 
     setSplashScreenLoadingText(i18n("Loading Brushes..."));
     processEvents();
     KisBrushServer::instance()->brushServer();
 
     setSplashScreenLoadingText(i18n("Loading Bundles..."));
     processEvents();
     KisResourceBundleServerProvider::instance();
 }
 
 void KisApplication::loadResourceTags()
 {
     //    qDebug() << "loadResourceTags()";
 
     KoResourceServerProvider::instance()->patternServer()->loadTags();
     KoResourceServerProvider::instance()->gradientServer()->loadTags();
     KoResourceServerProvider::instance()->paletteServer()->loadTags();
     KoResourceServerProvider::instance()->svgSymbolCollectionServer()->loadTags();
     KisBrushServer::instance()->brushServer()->loadTags();
     KisResourceServerProvider::instance()->workspaceServer()->loadTags();
     KisResourceServerProvider::instance()->layerStyleCollectionServer()->loadTags();
     KisResourceBundleServerProvider::instance()->resourceBundleServer()->loadTags();
     KisResourceServerProvider::instance()->paintOpPresetServer()->loadTags();
 
     KisResourceServerProvider::instance()->paintOpPresetServer()->clearOldSystemTags();
 }
 
 void KisApplication::loadPlugins()
 {
     //    qDebug() << "loadPlugins();";
 
     KoShapeRegistry* r = KoShapeRegistry::instance();
     r->add(new KisShapeSelectionFactory());
 
     KisActionRegistry::instance();
     KisFilterRegistry::instance();
     KisGeneratorRegistry::instance();
     KisPaintOpRegistry::instance();
     KoColorSpaceRegistry::instance();
 }
 
 void KisApplication::loadGuiPlugins()
 {
     //    qDebug() << "loadGuiPlugins();";
     // Load the krita-specific tools
     setSplashScreenLoadingText(i18n("Loading Plugins for Krita/Tool..."));
     processEvents();
     //    qDebug() << "loading tools";
     KoPluginLoader::instance()->load(QString::fromLatin1("Krita/Tool"),
                                      QString::fromLatin1("[X-Krita-Version] == 28"));
 
 
     // Load dockers
     setSplashScreenLoadingText(i18n("Loading Plugins for Krita/Dock..."));
     processEvents();
     //    qDebug() << "loading dockers";
     KoPluginLoader::instance()->load(QString::fromLatin1("Krita/Dock"),
                                      QString::fromLatin1("[X-Krita-Version] == 28"));
 
     // XXX_EXIV: make the exiv io backends real plugins
     setSplashScreenLoadingText(i18n("Loading Plugins Exiv/IO..."));
     processEvents();
     //    qDebug() << "loading exiv2";
     KisExiv2::initialize();
 }
 
 bool KisApplication::start(const KisApplicationArguments &args)
 {
     KisConfig cfg(false);
 
 #if defined(Q_OS_WIN)
 #ifdef ENV32BIT
 
     if (isWow64() && !cfg.readEntry("WarnedAbout32Bits", false)) {
         QMessageBox::information(0,
                                  i18nc("@title:window", "Krita: Warning"),
                                  i18n("You are running a 32 bits build on a 64 bits Windows.\n"
                                       "This is not recommended.\n"
                                       "Please download and install the x64 build instead."));
         cfg.writeEntry("WarnedAbout32Bits", true);
 
     }
 #endif
 #endif
 
     QString opengl = cfg.canvasState();
     if (opengl == "OPENGL_NOT_TRIED" ) {
         cfg.setCanvasState("TRY_OPENGL");
     }
     else if (opengl != "OPENGL_SUCCESS" && opengl != "TRY_OPENGL") {
         cfg.setCanvasState("OPENGL_FAILED");
     }
 
     setSplashScreenLoadingText(i18n("Initializing Globals"));
     processEvents();
     initializeGlobals(args);
 
     const bool doNewImage = args.doNewImage();
     const bool doTemplate = args.doTemplate();
     const bool exportAs = args.exportAs();
     const bool exportSequence = args.exportSequence();
     const QString exportFileName = args.exportFileName();
 
     d->batchRun = (exportAs || exportSequence || !exportFileName.isEmpty());
     const bool needsMainWindow = (!exportAs && !exportSequence);
     // only show the mainWindow when no command-line mode option is passed
     bool showmainWindow = (!exportAs && !exportSequence); // would be !batchRun;
 
     const bool showSplashScreen = !d->batchRun && qEnvironmentVariableIsEmpty("NOSPLASH");
     if (showSplashScreen && d->splashScreen) {
         d->splashScreen->show();
         d->splashScreen->repaint();
         processEvents();
     }
 
     KoHashGeneratorProvider::instance()->setGenerator("MD5", new KisMD5Generator());
 
     KConfigGroup group(KSharedConfig::openConfig(), "theme");
     Digikam::ThemeManager themeManager;
     themeManager.setCurrentTheme(group.readEntry("Theme", "Krita dark"));
 
     ResetStarting resetStarting(d->splashScreen, args.filenames().count()); // remove the splash when done
     Q_UNUSED(resetStarting);
 
     // Make sure we can save resources and tags
     setSplashScreenLoadingText(i18n("Adding resource types"));
     processEvents();
     addResourceTypes();
 
     // Load the plugins
     loadPlugins();
 
     // Load all resources
     loadResources();
 
     // Load all the tags
     loadResourceTags();
 
     // Load the gui plugins
     loadGuiPlugins();
 
     KisPart *kisPart = KisPart::instance();
     if (needsMainWindow) {
         // show a mainWindow asap, if we want that
         setSplashScreenLoadingText(i18n("Loading Main Window..."));
         processEvents();
 
 
         bool sessionNeeded = true;
         auto sessionMode = cfg.sessionOnStartup();
 
         if (!args.session().isEmpty()) {
             sessionNeeded = !kisPart->restoreSession(args.session());
         } else if (sessionMode == KisConfig::SOS_ShowSessionManager) {
             showmainWindow = false;
             sessionNeeded = false;
             kisPart->showSessionManager();
         } else if (sessionMode == KisConfig::SOS_PreviousSession) {
             KConfigGroup sessionCfg = KSharedConfig::openConfig()->group("session");
             const QString &sessionName = sessionCfg.readEntry("previousSession");
 
             sessionNeeded = !kisPart->restoreSession(sessionName);
         }
 
         if (sessionNeeded) {
             kisPart->startBlankSession();
         }
 
         if (!args.windowLayout().isEmpty()) {
             KoResourceServer<KisWindowLayoutResource> * rserver = KisResourceServerProvider::instance()->windowLayoutServer();
             KisWindowLayoutResource* windowLayout = rserver->resourceByName(args.windowLayout());
             if (windowLayout) {
                 windowLayout->applyLayout();
             }
         }
 
         if (showmainWindow) {
             d->mainWindow = kisPart->currentMainwindow();
 
             if (!args.workspace().isEmpty()) {
                 KoResourceServer<KisWorkspaceResource> * rserver = KisResourceServerProvider::instance()->workspaceServer();
                 KisWorkspaceResource* workspace = rserver->resourceByName(args.workspace());
                 if (workspace) {
                     d->mainWindow->restoreWorkspace(workspace);
                 }
             }
 
             if (args.canvasOnly()) {
                 d->mainWindow->viewManager()->switchCanvasOnly(true);
             }
 
             if (args.fullScreen()) {
                 d->mainWindow->showFullScreen();
             }
         } else {
             d->mainWindow = kisPart->createMainWindow();
         }
     }
     short int numberOfOpenDocuments = 0; // number of documents open
 
     // Check for autosave files that can be restored, if we're not running a batchrun (test)
     if (!d->batchRun) {
         checkAutosaveFiles();
     }
 
     setSplashScreenLoadingText(QString()); // done loading, so clear out label
     processEvents();
 
     //configure the unit manager
     KisSpinBoxUnitManagerFactory::setDefaultUnitManagerBuilder(new KisDocumentAwareSpinBoxUnitManagerBuilder());
     connect(this, &KisApplication::aboutToQuit, &KisSpinBoxUnitManagerFactory::clearUnitManagerBuilder); //ensure the builder is destroyed when the application leave.
     //the new syntax slot syntax allow to connect to a non q_object static method.
 
 
     // Create a new image, if needed
     if (doNewImage) {
         KisDocument *doc = args.image();
         if (doc) {
             kisPart->addDocument(doc);
             d->mainWindow->addViewAndNotifyLoadingCompleted(doc);
         }
     }
 
     // Get the command line arguments which we have to parse
     int argsCount = args.filenames().count();
     if (argsCount > 0) {
         // Loop through arguments
         for (int argNumber = 0; argNumber < argsCount; argNumber++) {
             QString fileName = args.filenames().at(argNumber);
             // are we just trying to open a template?
             if (doTemplate) {
                 // called in mix with batch options? ignore and silently skip
                 if (d->batchRun) {
                     continue;
                 }
                 if (createNewDocFromTemplate(fileName, d->mainWindow)) {
                     ++numberOfOpenDocuments;
                 }
                 // now try to load
             }
             else {
                 if (exportAs) {
                     QString outputMimetype = KisMimeDatabase::mimeTypeForFile(exportFileName, false);
                     if (outputMimetype == "application/octetstream") {
                         dbgKrita << i18n("Mimetype not found, try using the -mimetype option") << endl;
                         return false;
                     }
 
                     KisDocument *doc = kisPart->createDocument();
                     doc->setFileBatchMode(d->batchRun);
                     bool result = doc->openUrl(QUrl::fromLocalFile(fileName));
 
                     if (!result) {
                         errKrita << "Could not load " << fileName << ":" << doc->errorMessage();
                         QTimer::singleShot(0, this, SLOT(quit()));
                         return false;
                     }
 
                     if (exportFileName.isEmpty()) {
                         errKrita << "Export destination is not specified for" << fileName << "Please specify export destination with --export-filename option";
                         QTimer::singleShot(0, this, SLOT(quit()));
                         return false;
                     }
 
                     qApp->processEvents(); // For vector layers to be updated
 
                     doc->setFileBatchMode(true);
                     if (!doc->exportDocumentSync(QUrl::fromLocalFile(exportFileName), outputMimetype.toLatin1())) {
                         errKrita << "Could not export " << fileName << "to" << exportFileName << ":" << doc->errorMessage();
                     }
                     QTimer::singleShot(0, this, SLOT(quit()));
                     return true;
                 }
                 else if (exportSequence) {
                     KisDocument *doc = kisPart->createDocument();
                     doc->setFileBatchMode(d->batchRun);
                     doc->openUrl(QUrl::fromLocalFile(fileName));
                     qApp->processEvents(); // For vector layers to be updated
                     
                     if (!doc->image()->animationInterface()->hasAnimation()) {
                         errKrita << "This file has no animation." << endl;
                         QTimer::singleShot(0, this, SLOT(quit()));
                         return false;
                     }
 
                     doc->setFileBatchMode(true);
                     int sequenceStart = 0;
 
                     KisAsyncAnimationFramesSaveDialog exporter(doc->image(),
                                                doc->image()->animationInterface()->fullClipRange(),
                                                exportFileName,
                                                sequenceStart,
                                                0);
                     exporter.setBatchMode(d->batchRun);
                     KisAsyncAnimationFramesSaveDialog::Result result =
                         exporter.regenerateRange(0);
                     if (result == KisAsyncAnimationFramesSaveDialog::RenderFailed) {
                         errKrita << i18n("Failed to render animation frames!") << endl;
                     }
                     QTimer::singleShot(0, this, SLOT(quit()));
                     return true;
                 }
                 else if (d->mainWindow) {
                     if (fileName.endsWith(".bundle")) {
                         d->mainWindow->installBundle(fileName);
                     }
                     else {
                         KisMainWindow::OpenFlags flags = d->batchRun ? KisMainWindow::BatchMode : KisMainWindow::None;
 
                         if (d->mainWindow->openDocument(QUrl::fromLocalFile(fileName), flags)) {
                             // Normal case, success
                             numberOfOpenDocuments++;
                         }
                     }
                 }
             }
         }
     }
 
     // fixes BUG:369308  - Krita crashing on splash screen when loading.
     // trying to open a file before Krita has loaded can cause it to hang and crash
     if (d->splashScreen) {
         d->splashScreen->displayLinks(true);
         d->splashScreen->displayRecentFiles(true);
     }
 
 
     // not calling this before since the program will quit there.
     return true;
 }
 
 KisApplication::~KisApplication()
 {
 }
 
 void KisApplication::setSplashScreen(QWidget *splashScreen)
 {
     d->splashScreen = qobject_cast<KisSplashScreen*>(splashScreen);
 }
 
 void KisApplication::setSplashScreenLoadingText(QString textToLoad)
 {
     if (d->splashScreen) {
         //d->splashScreen->loadingLabel->setText(textToLoad);
         d->splashScreen->setLoadingText(textToLoad);
         d->splashScreen->repaint();
     }
 }
 
 void KisApplication::hideSplashScreen()
 {
     if (d->splashScreen) {
         // hide the splashscreen to see the dialog
         d->splashScreen->hide();
     }
 }
 
 
 bool KisApplication::notify(QObject *receiver, QEvent *event)
 {
     try {
         return QApplication::notify(receiver, event);
     } catch (std::exception &e) {
         qWarning("Error %s sending event %i to object %s",
                  e.what(), event->type(), qPrintable(receiver->objectName()));
     } catch (...) {
         qWarning("Error <unknown> sending event %i to object %s",
                  event->type(), qPrintable(receiver->objectName()));
     }
     return false;
 }
 
 
 void KisApplication::remoteArguments(QByteArray message, QObject *socket)
 {
     Q_UNUSED(socket);
 
     // check if we have any mainwindow
     KisMainWindow *mw = qobject_cast<KisMainWindow*>(qApp->activeWindow());
     if (!mw) {
         mw = KisPart::instance()->mainWindows().first();
     }
 
     if (!mw) {
         return;
     }
 
     KisApplicationArguments args = KisApplicationArguments::deserialize(message);
     const bool doTemplate = args.doTemplate();
     const int argsCount = args.filenames().count();
 
     if (argsCount > 0) {
         // Loop through arguments
         for (int argNumber = 0; argNumber < argsCount; ++argNumber) {
             QString filename = args.filenames().at(argNumber);
             // are we just trying to open a template?
             if (doTemplate) {
                 createNewDocFromTemplate(filename, mw);
             }
             else if (QFile(filename).exists()) {
                 KisMainWindow::OpenFlags flags = d->batchRun ? KisMainWindow::BatchMode : KisMainWindow::None;
                 mw->openDocument(QUrl::fromLocalFile(filename), flags);
             }
         }
     }
 }
 
 void KisApplication::fileOpenRequested(const QString &url)
 {
     KisMainWindow *mainWindow = KisPart::instance()->mainWindows().first();
     if (mainWindow) {
         KisMainWindow::OpenFlags flags = d->batchRun ? KisMainWindow::BatchMode : KisMainWindow::None;
         mainWindow->openDocument(QUrl::fromLocalFile(url), flags);
     }
 }
 
 
 void KisApplication::checkAutosaveFiles()
 {
     if (d->batchRun) return;
 
 #ifdef Q_OS_WIN
     QDir dir = QDir::temp();
 #else
     QDir dir = QDir::home();
 #endif
 
     // Check for autosave files from a previous run. There can be several, and
     // we want to offer a restore for every one. Including a nice thumbnail!
 
     // Hidden autosave files
     QStringList filters = QStringList() << QString(".krita-*-*-autosave.kra");
 
     // all autosave files for our application
     QStringList autosaveFiles = dir.entryList(filters, QDir::Files | QDir::Hidden);
 
     // Visibile autosave files
     filters = QStringList() << QString("krita-*-*-autosave.kra");
     autosaveFiles += dir.entryList(filters, QDir::Files);
 
     // Allow the user to make their selection
     if (autosaveFiles.size() > 0) {
         if (d->splashScreen) {
             // hide the splashscreen to see the dialog
             d->splashScreen->hide();
         }
         d->autosaveDialog = new KisAutoSaveRecoveryDialog(autosaveFiles, activeWindow());
         QDialog::DialogCode result = (QDialog::DialogCode) d->autosaveDialog->exec();
 
         if (result == QDialog::Accepted) {
             QStringList filesToRecover = d->autosaveDialog->recoverableFiles();
             Q_FOREACH (const QString &autosaveFile, autosaveFiles) {
                 if (!filesToRecover.contains(autosaveFile)) {
                     QFile::remove(dir.absolutePath() + "/" + autosaveFile);
                 }
             }
             autosaveFiles = filesToRecover;
         } else {
             autosaveFiles.clear();
         }
 
         if (autosaveFiles.size() > 0) {
             QList<QUrl> autosaveUrls;
             Q_FOREACH (const QString &autoSaveFile, autosaveFiles) {
                 const QUrl url = QUrl::fromLocalFile(dir.absolutePath() + QLatin1Char('/') + autoSaveFile);
                 autosaveUrls << url;
             }
             if (d->mainWindow) {
                 Q_FOREACH (const QUrl &url, autosaveUrls) {
                     KisMainWindow::OpenFlags flags = d->batchRun ? KisMainWindow::BatchMode : KisMainWindow::None;
                     d->mainWindow->openDocument(url, flags | KisMainWindow::RecoveryFile);
                 }
             }
         }
         // cleanup
         delete d->autosaveDialog;
         d->autosaveDialog = nullptr;
     }
 }
 
 bool KisApplication::createNewDocFromTemplate(const QString &fileName, KisMainWindow *mainWindow)
 {
     QString templatePath;
 
     const QUrl templateUrl = QUrl::fromLocalFile(fileName);
     if (QFile::exists(fileName)) {
         templatePath = templateUrl.toLocalFile();
         dbgUI << "using full path...";
     }
     else {
         QString desktopName(fileName);
         const QString templatesResourcePath =  QStringLiteral("templates/");
 
         QStringList paths = KoResourcePaths::findAllResources("data", templatesResourcePath + "*/" + desktopName);
         if (paths.isEmpty()) {
             paths = KoResourcePaths::findAllResources("data", templatesResourcePath + desktopName);
         }
 
         if (paths.isEmpty()) {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"),
                                   i18n("No template found for: %1", desktopName));
         } else if (paths.count() > 1) {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"),
                                   i18n("Too many templates found for: %1", desktopName));
         } else {
             templatePath = paths.at(0);
         }
     }
 
     if (!templatePath.isEmpty()) {
         QUrl templateBase;
         templateBase.setPath(templatePath);
         KDesktopFile templateInfo(templatePath);
 
         QString templateName = templateInfo.readUrl();
         QUrl templateURL;
         templateURL.setPath(templateBase.adjusted(QUrl::RemoveFilename|QUrl::StripTrailingSlash).path() + '/' + templateName);
         if (templateURL.scheme().isEmpty()) {
             templateURL.setScheme("file");
         }
 
         KisMainWindow::OpenFlags batchFlags = d->batchRun ? KisMainWindow::BatchMode : KisMainWindow::None;
         if (mainWindow->openDocument(templateURL, KisMainWindow::Import | batchFlags)) {
             dbgUI << "Template loaded...";
             return true;
         }
         else {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"),
                                   i18n("Template %1 failed to load.", templateURL.toDisplayString()));
         }
     }
 
     return false;
 }
 
 void KisApplication::clearConfig()
 {
     KIS_ASSERT_RECOVER_RETURN(qApp->thread() == QThread::currentThread());
 
     KSharedConfigPtr config =  KSharedConfig::openConfig();
 
     // find user settings file
     bool createDir = false;
     QString kritarcPath = KoResourcePaths::locateLocal("config", "kritarc", createDir);
 
     QFile configFile(kritarcPath);
     if (configFile.exists()) {
         // clear file
         if (configFile.open(QFile::WriteOnly)) {
             configFile.close();
         }
         else {
             QMessageBox::warning(0,
                                  i18nc("@title:window", "Krita"),
                                  i18n("Failed to clear %1\n\n"
                                       "Please make sure no other program is using the file and try again.",
                                       kritarcPath),
                                  QMessageBox::Ok, QMessageBox::Ok);
         }
     }
 
     // reload from disk; with the user file settings cleared,
     // this should load any default configuration files shipping with the program
     config->reparseConfiguration();
     config->sync();
 }
 
 void KisApplication::askClearConfig()
 {
     Qt::KeyboardModifiers mods = QApplication::queryKeyboardModifiers();
     bool askClearConfig = (mods & Qt::ControlModifier) && (mods & Qt::ShiftModifier) && (mods & Qt::AltModifier);
 
     if (askClearConfig) {
         bool ok = QMessageBox::question(0,
                                         i18nc("@title:window", "Krita"),
                                         i18n("Do you want to clear the settings file?"),
                                         QMessageBox::Yes | QMessageBox::No, QMessageBox::No) == QMessageBox::Yes;
         if (ok) {
             clearConfig();
         }
     }
 }
diff --git a/libs/ui/KisCanvasWindow.cpp b/libs/ui/KisCanvasWindow.cpp
new file mode 100644
index 0000000000..ec33498252
--- /dev/null
+++ b/libs/ui/KisCanvasWindow.cpp
@@ -0,0 +1,57 @@
+/*
+ *  Copyright (c) 2018 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 <QHBoxLayout>
+
+#include "KisCanvasWindow.h"
+#include "KisMainWindow.h"
+
+struct KisCanvasWindow::Private {
+    KisMainWindow *mainWindow;
+
+    Private(KisMainWindow *mainWindow)
+        : mainWindow(mainWindow)
+    {}
+};
+
+KisCanvasWindow::KisCanvasWindow(KisMainWindow *mainWindow)
+    : QWidget(mainWindow)
+      , d(new Private(mainWindow))
+{
+    setWindowFlags(Qt::Window);
+
+    QLayout *layout = new QHBoxLayout(this);
+    setLayout(layout);
+}
+
+KisCanvasWindow::~KisCanvasWindow() = default;
+
+void KisCanvasWindow::closeEvent(QCloseEvent *event)
+{
+    d->mainWindow->setCanvasDetached(false);
+    QWidget::closeEvent(event);
+}
+
+QWidget * KisCanvasWindow::swapMainWidget(QWidget *newWidget)
+{
+    QWidget *oldWidget = (layout()->count() > 0) ? (layout()->takeAt(0)->widget()) : nullptr;
+    if (newWidget) {
+        layout()->addWidget(newWidget);
+    }
+    return oldWidget;
+}
diff --git a/libs/ui/canvas/kis_paintop_transformation_connector.h b/libs/ui/KisCanvasWindow.h
similarity index 56%
rename from libs/ui/canvas/kis_paintop_transformation_connector.h
rename to libs/ui/KisCanvasWindow.h
index 68c751ee0a..36897f7be1 100644
--- a/libs/ui/canvas/kis_paintop_transformation_connector.h
+++ b/libs/ui/KisCanvasWindow.h
@@ -1,43 +1,42 @@
 /*
- *  Copyright (c) 2013 Dmitry Kazakov <dimula73@gmail.com>
+ *  Copyright (c) 2018 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
+#ifndef KISCANVASWINDOW_H
+#define KISCANVASWINDOW_H
 
-#ifndef __KIS_PAINTOP_TRANSFORMATION_CONNECTOR_H
-#define __KIS_PAINTOP_TRANSFORMATION_CONNECTOR_H
+#include <QWidget>
 
-#include <QObject>
-#include <QPointer>
+class KisMainWindow;
 
-#include <kis_canvas2.h>
-
-class KisPaintopTransformationConnector : public QObject
+/**
+ * Window for the canvas (mdi) area. Used when detached canvas mode is enabled.
+ */
+class KisCanvasWindow : public QWidget
 {
-    Q_OBJECT
-public:
-    KisPaintopTransformationConnector(KisCanvas2 *canvas, QObject *parent);
-
 public:
-    void notifyTransformationChanged();
+    explicit KisCanvasWindow(KisMainWindow *mainWindow);
+    ~KisCanvasWindow() override;
 
-public Q_SLOTS:
-    void slotCanvasResourceChanged(int key, const QVariant &resource);
+    QWidget * swapMainWidget(QWidget *widget);
 
+    void closeEvent(QCloseEvent *event) override;
 private:
-    QPointer<KisCanvas2> m_canvas;
+    struct Private;
+    QScopedPointer<Private> d;
 };
 
-#endif /* __KIS_PAINTOP_TRANSFORMATION_CONNECTOR_H */
+#endif
diff --git a/libs/ui/KisDetailsPane.cpp b/libs/ui/KisDetailsPane.cpp
index 8b450772da..f4044837b5 100644
--- a/libs/ui/KisDetailsPane.cpp
+++ b/libs/ui/KisDetailsPane.cpp
@@ -1,113 +1,106 @@
 /* This file is part of the KDE project
    Copyright (C) 2005 Peter Simonsson <psn@linux.se>
 
    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 "KisDetailsPane.h"
 
 #include <QStandardItemModel>
 #include <QKeyEvent>
 
 ////////////////////////////////////
 // class KisDetailsPane
 ///////////////////////////////////
 
 struct KisDetailsPanePrivate
 {
     QStandardItemModel m_model;
 };
 
 KisDetailsPane::KisDetailsPane(QWidget* parent, const QString& header)
         : QWidget(parent),
         Ui_KisDetailsPaneBase(),
         d(new KisDetailsPanePrivate())
 {
     d->m_model.setHorizontalHeaderItem(0, new QStandardItem(header));
 
     setupUi(this);
 
-    m_previewLabel->installEventFilter(this);
     m_documentList->installEventFilter(this);
     m_documentList->setIconSize(QSize(IconExtent, IconExtent));
     m_documentList->setModel(&d->m_model);
     m_splitter->setSizes(QList<int>() << 2 << 1);
 
     changePalette();
 
     connect(m_documentList->selectionModel(), SIGNAL(currentChanged(QModelIndex,QModelIndex)),
             this, SLOT(selectionChanged(QModelIndex)));
     connect(m_documentList, SIGNAL(doubleClicked(QModelIndex)),
             this, SLOT(openFile(QModelIndex)));
     connect(m_openButton, SIGNAL(clicked()), this, SLOT(openFile()));
 }
 
 KisDetailsPane::~KisDetailsPane()
 {
     delete d;
 }
 
 bool KisDetailsPane::eventFilter(QObject* watched, QEvent* e)
 {
-    if (watched == m_previewLabel) {
-        if (e->type() == QEvent::MouseButtonDblClick) {
-            openFile();
-        }
-    }
-
     if (watched == m_documentList) {
         if ((e->type() == QEvent::Resize) && isVisible()) {
             emit splitterResized(this, m_splitter->sizes());
         }
 
         if ((e->type() == QEvent::KeyPress)) {
             QKeyEvent* keyEvent = static_cast<QKeyEvent*>(e);
 
             if (keyEvent->key() == Qt::Key_Enter || keyEvent->key() == Qt::Key_Return) {
                 openFile();
             }
         }
     }
 
     return false;
 }
 
 void KisDetailsPane::resizeSplitter(KisDetailsPane* sender, const QList<int>& sizes)
 {
     if (sender == this)
         return;
 
     m_splitter->setSizes(sizes);
 }
 
 void KisDetailsPane::openFile()
 {
     QModelIndex index = m_documentList->selectionModel()->currentIndex();
     openFile(index);
 }
 
 void KisDetailsPane::changePalette()
 {
     QPalette p = palette();
     p.setBrush(QPalette::Base, QColor(Qt::transparent));
     p.setColor(QPalette::Text, p.color(QPalette::Normal, QPalette::Foreground));
     m_detailsLabel->setPalette(p);
 }
 
 QStandardItemModel* KisDetailsPane::model() const
 {
     return &d->m_model;
 }
diff --git a/libs/ui/KisImportExportManager.cpp b/libs/ui/KisImportExportManager.cpp
index eb552c1d4f..ca9849fb4b 100644
--- a/libs/ui/KisImportExportManager.cpp
+++ b/libs/ui/KisImportExportManager.cpp
@@ -1,702 +1,702 @@
 /*
  * Copyright (C) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "KisImportExportManager.h"
 
 #include <QFile>
 #include <QLabel>
 #include <QVBoxLayout>
 #include <QList>
 #include <QApplication>
 #include <QByteArray>
 #include <QPluginLoader>
 #include <QFileInfo>
 #include <QMessageBox>
 #include <QJsonObject>
 #include <QTextBrowser>
 #include <QCheckBox>
 #include <QSaveFile>
 #include <QGroupBox>
 #include <QFuture>
 #include <QtConcurrent>
 
 #include <klocalizedstring.h>
 #include <ksqueezedtextlabel.h>
 #include <kpluginfactory.h>
 
 #include <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("@titile:window", "Open Audio"));
 
     return dialog.filename();
 }
 
 KisImportExportManager::ConversionResult KisImportExportManager::convert(KisImportExportManager::Direction direction, const QString &location, const QString& realLocation, const QString &mimeType, bool showWarnings, KisPropertiesConfigurationSP exportConfiguration, bool isAsync)
 {
     // export configuration is supported for export only
     KIS_SAFE_ASSERT_RECOVER_NOOP(direction == Export || !bool(exportConfiguration));
 
     QString typeName = mimeType;
     if (typeName.isEmpty()) {
         typeName = KisMimeDatabase::mimeTypeForFile(location, direction == KisImportExportManager::Export ? false : true);
     }
 
     QSharedPointer<KisImportExportFilter> filter;
 
     /**
      * Fetching a filter from the registry is a really expensive operation,
      * because it blocks all the threads. Cache the filter if possible.
      */
     if (direction == KisImportExportManager::Export &&
             d->cachedExportFilter &&
             d->cachedExportFilterMimeType == typeName) {
 
         filter = d->cachedExportFilter;
     } else {
 
         filter = toQShared(filterForMimeType(typeName, direction));
 
         if (direction == Export) {
             d->cachedExportFilter = filter;
             d->cachedExportFilterMimeType = typeName;
         }
     }
 
     if (!filter) {
         return 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);
 
         if (0 && !batchMode()) {
             KisAsyncActionFeedback f(i18n("Opening document..."), 0);
             result = f.runAction(std::bind(&KisImportExportManager::doImport, this, location, filter));
         } else {
             result = doImport(location, filter);
         }
     }
     else /* if (direction == Export) */ {
         if (!exportConfiguration) {
             exportConfiguration = filter->lastSavedConfiguration(from, to);
         }
 
         if (exportConfiguration) {
             fillStaticExportConfigurationProperties(exportConfiguration);
         }
 
         bool alsoAsKra = false;
         bool askUser = askUserAboutExportConfiguration(filter, exportConfiguration,
                                                        from, to,
                                                        batchMode(), showWarnings,
                                                        &alsoAsKra);
 
 
         if (!batchMode() && !askUser) {
             return 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) {
             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> Reasons:</p>"
+                + "</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> Reason:</p>";
+                warning += "</b> " + i18n("Reason:") + "</p>";
             }
             else {
-                warning += "</b> Reasons:</p>";
+                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.
 #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");
     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 759c8eb128..5dac5bdee7 100644
--- a/libs/ui/KisMainWindow.cpp
+++ b/libs/ui/KisMainWindow.cpp
@@ -1,2671 +1,2712 @@
 /* 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 <QSignalMapper>
 #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>
 
 #include <brushengine/kis_paintop_settings.h>
 #include "dialogs/kis_about_application.h"
 #include "dialogs/kis_delayed_save_dialog.h"
 #include "dialogs/kis_dlg_preferences.h"
-#include "kis_action.h"
 #include "kis_action_manager.h"
 #include "KisApplication.h"
 #include "kis_canvas2.h"
 #include "kis_canvas_controller.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_clipboard.h"
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_custom_image_widget.h"
 #include <KisDocument.h>
 #include "kis_group_layer.h"
 #include "kis_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 QSignalMapper(parent))
         , documentMapper(new QSignalMapper(parent))
     {
         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};
     QSignalMapper *windowMapper;
     QSignalMapper *documentMapper;
+    KisCanvasWindow *canvasWindow {0};
 
     QByteArray lastExportedFormat;
     QScopedPointer<KisSignalCompressorWithParam<int> > tabSwitchCompressor;
     QMutex savingEntryMutex;
 
     KConfigGroup windowStateConfig;
 
     QUuid workspaceBorrowedBy;
     KisSignalAutoConnectionsStore screenConnectionsStore;
 
     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);
 
     // 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)
 {
     if (d->activeView == view) return;
 
     if (d->activeView) {
         d->activeView->disconnect(this);
     }
 
     // register the newly created view in the input manager
     viewManager()->inputManager()->addTrackedCanvas(view->canvasBase());
 
     showView(view);
     updateCaption();
     emit restoringDone();
 
     if (d->activeView) {
         connect(d->activeView, SIGNAL(titleModified(QString,bool)), SLOT(slotDocumentTitleModified()));
         connect(d->viewManager->statusBar(), SIGNAL(memoryStatusUpdated()), this, SLOT(updateCaption()));
     }
 }
 
 void KisMainWindow::notifyChildViewDestroyed(KisView *view)
 {
     /**
      * If we are the last view of the window, Qt will not activate another tab
      * before destroying tab/window. In ths case we should clear oll 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)
 {
     if (imageView && activeView() != imageView) {
         // XXX: find a better way to initialize this!
         imageView->setViewManager(d->viewManager);
 
         imageView->canvasBase()->setFavoriteResourceManager(d->viewManager->paintOpBox()->favoriteResourcesManager());
         imageView->slotLoadingFinished();
 
         QMdiSubWindow *subwin = d->mdiArea->addSubWindow(imageView);
         imageView->setSubWindow(subwin);
         subwin->setAttribute(Qt::WA_DeleteOnClose, true);
         connect(subwin, SIGNAL(destroyed()), SLOT(updateWindowMenu()));
 
         KisConfig cfg(true);
         subwin->setOption(QMdiSubWindow::RubberBandMove, cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
         subwin->setOption(QMdiSubWindow::RubberBandResize, cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
         subwin->setWindowIcon(qApp->windowIcon());
 
         /**
          * Hack alert!
          *
          * Here we explicitly request KoToolManager to emit all the tool
          * activation signals, to reinitialize the tool options docker.
          *
          * That is needed due to a design flaw we have in the
          * initialization procedure.  The tool in the KoToolManager is
          * initialized in KisView::setViewManager() calls, which
          * happens early enough. During this call the tool manager
          * requests KoCanvasControllerWidget to emit the signal to
          * update the widgets in the tool docker. *But* at that moment
          * of time the view is not yet connected to the main window,
          * because it happens in KisViewManager::setCurrentView a bit
          * later. This fact makes the widgets updating signals be lost
          * and never reach the tool docker.
          *
          * So here we just explicitly call the tool activation stub.
          */
 
         KoToolManager::instance()->initializeCurrentToolForCanvas();
 
         if (d->mdiArea->subWindowList().size() == 1) {
             imageView->showMaximized();
         }
         else {
             imageView->show();
         }
 
         // No, no, no: do not try to call this _before_ the show() has
         // been called on the view; only when that has happened is the
         // opengl context active, and very bad things happen if we tell
         // the dockers to update themselves with a view if the opengl
         // context is not active.
         setActiveView(imageView);
 
         updateWindowMenu();
         updateCaption();
     }
 }
 
 void KisMainWindow::slotPreferences()
 {
     if (KisDlgPreferences::editPreferences()) {
         KisConfigNotifier::instance()->notifyConfigChanged();
         KisConfigNotifier::instance()->notifyPixelGridModeChanged();
         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();
+    }
+}
+
+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();
 }
 
 
 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)
 {
     showWelcomeScreen(false); // see workaround in function header
 
-    KisView *view = KisPart::instance()->createView(document, resourceManager(), actionCollection(), this);
+    KisView *view = KisPart::instance()->createView(document, d->viewManager, this);
     addView(view);
 
     emit guiLoadingFinished();
 
     return view;
 }
 
 QStringList KisMainWindow::showOpenFileDialog(bool isImporting)
 {
     KoFileDialog dialog(this, KoFileDialog::ImportFiles, "OpenDocument");
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
     dialog.setMimeTypeFilters(KisImportExportManager::supportedMimeTypes(KisImportExportManager::Import));
     dialog.setCaption(isImporting ? i18n("Import Images") : i18n("Open Images"));
 
     return dialog.filenames();
 }
 
 // Separate from openDocument to handle async loading (remote URLs)
 void KisMainWindow::slotLoadCompleted()
 {
     KisDocument *newdoc = qobject_cast<KisDocument*>(sender());
     if (newdoc && newdoc->image()) {
         addViewAndNotifyLoadingCompleted(newdoc);
 
         disconnect(newdoc, SIGNAL(completed()), this, SLOT(slotLoadCompleted()));
         disconnect(newdoc, SIGNAL(canceled(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()) {
 
             // 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)
 {
     QStringList urls = showOpenFileDialog(isImporting);
 
     if (urls.isEmpty())
         return;
 
     Q_FOREACH (const QString& url, urls) {
 
         if (!url.isEmpty()) {
             OpenFlags flags = isImporting ? Import : None;
             bool res = openDocument(QUrl::fromLocalFile(url), flags);
             if (!res) {
                 warnKrita << "Loading" << url << "failed";
             }
         }
     }
 }
 
 void KisMainWindow::slotFileOpenRecent(const QUrl &url)
 {
     (void) openDocument(QUrl::fromLocalFile(url.toLocalFile()), None);
 }
 
 void KisMainWindow::slotFileSave()
 {
     if (saveDocument(d->activeView->document(), false, false)) {
         emit documentSaved();
     }
 }
 
 void KisMainWindow::slotFileSaveAs()
 {
     if (saveDocument(d->activeView->document(), true, false)) {
         emit documentSaved();
     }
 }
 
 void KisMainWindow::slotExportFile()
 {
     if (saveDocument(d->activeView->document(), true, true)) {
         emit documentSaved();
     }
 }
 
 void KisMainWindow::slotShowSessionManager() {
     KisPart::instance()->showSessionManager();
 }
 
 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
     }
 }
 
 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 contiue to be painted in its initial "mid-screen"
          * position. It will persist here until you explicitly switch to its tab.
          */
         if (viewMode == QMdiArea::TabbedView) {
             Qt::WindowFlags oldFlags = subwin->windowFlags();
             Qt::WindowFlags flags = oldFlags;
 
             flags &= ~Qt::WindowStaysOnTopHint;
             flags &= ~Qt::WindowStaysOnBottomHint;
 
             if (flags != oldFlags) {
                 subwin->setWindowFlags(flags);
                 subwin->showMaximized();
             }
         }
 
     }
 
     KConfigGroup group( KSharedConfig::openConfig(), "theme");
     d->themeManager->setCurrentTheme(group.readEntry("Theme", "Krita dark"));
     d->actionManager()->updateGUI();
 
     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)
 {
     KisDocument *doc = qobject_cast<KisDocument*>(document);
     KisView *view = addViewAndNotifyLoadingCompleted(doc);
     d->actionManager()->updateGUI();
 
     return view;
 }
 
 void KisMainWindow::newWindow()
 {
     KisMainWindow *mainWindow = KisPart::instance()->createMainWindow();
     mainWindow->initializeGeometry();
     mainWindow->show();
 }
 
 void KisMainWindow::closeCurrentWindow()
 {
     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 = QApplication::desktop()->availableGeometry(scnum);
         // if the desktop is virtual then use virtual screen size
         if (QApplication::desktop()->isVirtualDesktop()) {
             desk = QApplication::desktop()->availableGeometry(QApplication::desktop()->screen(scnum));
         }
 
         quint32 x = desk.x();
         quint32 y = desk.y();
         quint32 w = 0;
         quint32 h = 0;
 
         // Default size -- maximize on small screens, something useful on big screens
         const int deskWidth = desk.width();
         if (deskWidth > 1024) {
             // a nice width, and slightly less than total available
             // height to 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()));
 }
 
 
 
 #include <moc_KisMainWindow.cpp>
diff --git a/libs/ui/KisMainWindow.h b/libs/ui/KisMainWindow.h
index be49b461f9..0126939d78 100644
--- a/libs/ui/KisMainWindow.h
+++ b/libs/ui/KisMainWindow.h
@@ -1,502 +1,511 @@
 /* This file is part of the KDE project
    Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
    Copyright (C) 2000-2004 David Faure <faure@kde.org>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #ifndef KIS_MAIN_WINDOW_H
 #define KIS_MAIN_WINDOW_H
 
 #include "kritaui_export.h"
 
 #include <QPointer>
 #include <QPrinter>
 #include <QUuid>
 #include <QUrl>
 
 #include <xmlgui/kxmlguiwindow.h>
 #include <KoCanvasObserverBase.h>
 #include <KoCanvasSupervisor.h>
 #include "KisView.h"
 
 class QCloseEvent;
 class QMoveEvent;
 
 struct KoPageLayout;
 class KoCanvasResourceProvider;
 
 class KisDocument;
 class KisPrintJob;
 class KoDockFactoryBase;
 class QDockWidget;
 class KisView;
 class KisViewManager;
 class KoCanvasController;
 class KisWorkspaceResource;
 
 /**
  * @brief Main window for Krita
  *
  * This class is used to represent a main window within a Krita session. Each
  * main window contains a menubar and some toolbars, and potentially several
  * views of several canvases.
  *
  */
 class KRITAUI_EXPORT KisMainWindow : public KXmlGuiWindow, public KoCanvasSupervisor
 {
     Q_OBJECT
 
 public:
     enum OpenFlag {
         None = 0,
         Import = 0x1,
         BatchMode = 0x2,
         RecoveryFile = 0x4
     };
     Q_DECLARE_FLAGS(OpenFlags, OpenFlag)
 
 public:
 
     /**
      *  Constructor.
      *
      *  Initializes a Calligra main window (with its basic GUI etc.).
      */
     explicit KisMainWindow(QUuid id = QUuid());
 
     /**
      *  Destructor.
      */
     ~KisMainWindow() override;
 
     QUuid id() const;
 
     /**
      * @brief showView shows the given view. Override this if you want to show
      * the view in a different way than by making it the central widget, for instance
      * as an QMdiSubWindow
      */
     virtual void showView(KisView *view);
 
     /**
      * @returns the currently active view
      */
     KisView *activeView() const;
 
     /**
      * Sets the maximum number of recent documents entries.
      */
     void setMaxRecentItems(uint _number);
 
     /**
      * The document opened a URL -> store into recent documents list.
      */
     void addRecentURL(const QUrl &url);
 
     /**
      * get list of URL strings for recent files
      */
     QList<QUrl> recentFilesUrls();
 
     /**
      * clears the list of the recent files
      */
     void clearRecentFiles();
 
 
     /**
      * Load the desired document and show it.
      * @param url the URL to open
      *
      * @return TRUE on success.
      */
     bool openDocument(const QUrl &url, OpenFlags flags);
 
     /**
      * Activate a view containing the document in this window, creating one if needed.
      */
     void showDocument(KisDocument *document);
 
 
     /**
      * Toggles between showing the welcome screen and the MDI area
      *
      *  hack: There seems to be a bug that prevents events happening to the MDI area if it
      *  isn't actively displayed (set in the widgetStack). This can cause things like the title bar
      *  not to update correctly Before doing any actions related to opening or creating documents,
      *  make sure to switch this first to make sure everything can communicate to the MDI area correctly
      */
     void showWelcomeScreen(bool show);
 
     /**
      * Saves the document, asking for a filename if necessary.
      *
      * @param saveas if set to TRUE the user is always prompted for a filename
      * @param silent if set to TRUE rootDocument()->setTitleModified will not be called.
      *
      * @return TRUE on success, false on error or cancel
      *         (don't display anything in this case, the error dialog box is also implemented here
      *         but restore the original URL in slotFileSaveAs)
      */
     bool saveDocument(KisDocument *document, bool saveas, bool isExporting);
 
     void setReadWrite(bool readwrite);
 
     /// Return the list of dock widgets belonging to this main window.
     QList<QDockWidget*> dockWidgets() const;
 
     QDockWidget* dockWidget(const QString &id);
 
     QList<KoCanvasObserverBase*> canvasObservers() const override;
 
     KoCanvasResourceProvider *resourceManager() const;
 
     int viewCount() const;
 
     void saveWindowState(bool restoreNormalState =false);
 
     const KConfigGroup &windowStateConfig() const;
 
     /**
      * A wrapper around restoreState
      * @param state the saved state
      * @return TRUE on success
      */
     bool restoreWorkspace(KisWorkspaceResource *workspace);
     bool restoreWorkspaceState(const QByteArray &state);
 
     static void swapWorkspaces(KisMainWindow *a, KisMainWindow *b);
 
     KisViewManager *viewManager() const;
 
     KisView *addViewAndNotifyLoadingCompleted(KisDocument *document);
 
     QStringList showOpenFileDialog(bool isImporting);
 
+    /**
+     * The top-level window used for a detached canvas.
+     */
+    QWidget *canvasWindow() const;
+    bool canvasDetached() const;
+
     /**
      * Shows if the main window is saving anything right now. If the
      * user presses Ctrl+W too fast, then the document can be close
      * before the saving is completed. I'm not sure if it is fixable
      * in any way without avoiding using porcessEvents()
      * everywhere (DK)
      *
      * Don't use it unless you have no option.
      */
     bool hackIsSaving() const;
 
     /// Copy the given file into the bundle directory.
     bool installBundle(const QString &fileName) const;
 
 Q_SIGNALS:
 
     /**
      * This signal is emitted if the document has been saved successfully.
      */
     void documentSaved();
 
     /// This signal is emitted when this windows has finished loading of a
     /// document. The document may be opened in another window in the end.
     /// In this case, the signal means there is no link between the window
     /// and the document anymore.
     void loadCompleted();
 
     /// This signal is emitted right after the docker states have been succefully restored from config
     void restoringDone();
 
     /// This signal is emitted when the color theme changes
     void themeChanged();
 
     /// This signal is emitted when the shortcut key configuration has changed
     void keyBindingsChanged();
 
     void guiLoadingFinished();
 
     /// emitted when the window is migrated among different screens
     void screenChanged();
 
 public Q_SLOTS:
 
     /**
      *  Slot for opening a new document.
      *
      *  If the current document is empty, the new document replaces it.
      *  If not, a new mainwindow will be opened for showing the document.
      */
     void slotFileNew();
 
     /**
      *  Slot for opening a saved file.
      *
      *  If the current document is empty, the opened document replaces it.
      *  If not a new mainwindow will be opened for showing the opened file.
      */
     void slotFileOpen(bool isImporting = false);
 
     /**
      *  Slot for opening a file among the recently opened files.
      *
      *  If the current document is empty, the opened document replaces it.
      *  If not a new mainwindow will be opened for showing the opened file.
      */
     void slotFileOpenRecent(const QUrl &);
 
     /**
      * @brief slotPreferences open the preferences dialog
      */
     void slotPreferences();
 
     /**
      * Update caption from document info - call when document info
      * (title in the about page) changes.
      */
     void updateCaption();
 
     /**
      *  Saves the current document with the current name.
      */
     void slotFileSave();
 
 
     void slotShowSessionManager();
 
     // XXX: disabled
     KisPrintJob* exportToPdf(QString pdfFileName = QString());
 
     /**
      * Update the option widgets to the argument ones, removing the currently set widgets.
      */
     void newOptionWidgets(KoCanvasController *controller, const QList<QPointer<QWidget> > & optionWidgetList);
 
     KisView *newView(QObject *document);
 
     void notifyChildViewDestroyed(KisView *view);
 
     /// Set the active view, this will update the undo/redo actions
     void setActiveView(KisView *view);
 
     void subWindowActivated();
 
     void windowFocused();
 
     /**
      * Reloads the recent documents list.
      */
     void reloadRecentFileList();
 
-
+    /**
+     * Detach canvas onto a separate window, or restore it back to to main window.
+     */
+    void setCanvasDetached(bool detached);
 
 private Q_SLOTS:
     /**
      * Save the list of recent files.
      */
     void saveRecentFiles();
 
     void slotLoadCompleted();
     void slotLoadCanceled(const QString &);
     void slotSaveCompleted();
     void slotSaveCanceled(const QString &);
     void forceDockTabFonts();
 
     /**
      * @internal
      */
     void slotDocumentTitleModified();
 
     /**
      *  Prints the actual document.
      */
     void slotFilePrint();
 
     /**
      *  Saves the current document with a new name.
      */
     void slotFileSaveAs();
 
     void slotFilePrintPreview();
 
     void importAnimation();
 
     /**
      * Show a dialog with author and document information.
      */
     void slotDocumentInfo();
 
     /**
      * Closes all open documents.
      */
     bool slotFileCloseAll();
 
     /**
      * @brief showAboutApplication show the about box
      */
     virtual void showAboutApplication();
 
     /**
      *  Closes the mainwindow.
      */
     void slotFileQuit();
 
     /**
      *  Configure toolbars.
      */
     void slotConfigureToolbars();
 
     /**
      *  Post toolbar config.
      * (Plug action lists back in, etc.)
      */
     void slotNewToolbarConfig();
 
     /**
      *  Shows or hides a toolbar
      */
     void slotToolbarToggled(bool toggle);
 
     /**
      * Toggle full screen on/off.
      */
     void viewFullscreen(bool fullScreen);
 
     /**
      * Reload file
      */
     void slotReloadFile();
 
 
     /**
      * File --> Import
      *
      * This will call slotFileOpen().
      */
     void slotImportFile();
 
     /**
      * File --> Export
      *
      * This will call slotFileSaveAs().
      */
     void slotExportFile();
 
     /**
      * Hide the dockers
      */
     void toggleDockersVisibility(bool visible);
 
     /**
      * Handle theme changes from theme manager
      */
     void slotThemeChanged();
 
     void undo();
     void redo();
     void updateWindowMenu();
     void setActiveSubWindow(QWidget *window);
     void configChanged();
 
     void newWindow();
     void closeCurrentWindow();
     void checkSanity();
 
     /// Quits Krita with error message from m_errorMessage.
     void showErrorAndDie();
 
     void initializeGeometry();
     void showManual();
     void switchTab(int index);
 
     void windowScreenChanged(QScreen *screen);
 
 protected:
 
     void closeEvent(QCloseEvent * e) override;
     void resizeEvent(QResizeEvent * e) override;
 
     // QWidget overrides
 
 private:
 
     friend class KisWelcomePageWidget;
     void dragMove(QDragMoveEvent *event);
     void dragLeave();
 
 private:
 
     /**
      * Add a the given view to the list of views of this mainwindow.
      * This is a private implementation. For public usage please use
      * newView() and addViewAndNotifyLoadingCompleted().
      */
     void addView(KisView *view);
 
     friend class KisPart;
 
 
     /**
      * Returns the dockwidget specified by the @p factory. If the dock widget doesn't exist yet it's created.
      * Add a "view_palette_action_menu" action to your view menu if you want to use closable dock widgets.
      * @param factory the factory used to create the dock widget if needed
      * @return the dock widget specified by @p factory (may be 0)
      */
     QDockWidget* createDockWidget(KoDockFactoryBase* factory);
 
     bool openDocumentInternal(const QUrl &url, KisMainWindow::OpenFlags flags = 0);
 
 
     /**
      * Updates the window caption based on the document info and path.
      */
     void updateCaption(const QString & caption, bool modified);
     void updateReloadFileAction(KisDocument *doc);
 
     void saveWindowSettings();
 
     QPointer<KisView> activeKisView();
 
     void applyDefaultSettings(QPrinter &printer);
 
     void createActions();
 
     void applyToolBarLayout();
 
     QByteArray borrowWorkspace(KisMainWindow *borrower);
 
 
 private:
 
     /**
      * Struct used in the list created by createCustomDocumentWidgets()
      */
     struct CustomDocumentWidgetItem {
         /// Pointer to the custom document widget
         QWidget *widget;
         /// title used in the sidebar. If left empty it will be displayed as "Custom Document"
         QString title;
         /// icon used in the sidebar. If left empty it will use the unknown icon
         QString icon;
     };
 
     class Private;
     Private * const d;
 
     QString m_errorMessage;
     bool m_dieOnError;
 
 };
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(KisMainWindow::OpenFlags)
 
 #endif
diff --git a/libs/ui/KisMultiFeedRSSModel.cpp b/libs/ui/KisMultiFeedRSSModel.cpp
index 9c058053bb..5bebd6d6e8 100644
--- a/libs/ui/KisMultiFeedRSSModel.cpp
+++ b/libs/ui/KisMultiFeedRSSModel.cpp
@@ -1,221 +1,226 @@
 /**************************************************************************
 **
 ** This file is part of Qt Creator
 **
 ** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
 **
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 **
 ** GNU Lesser General Public License Usage
 **
 ** This file may be used under the terms of the GNU Lesser General Public
 ** License version 2.1 as published by the Free Software Foundation and
 ** appearing in the file LICENSE.LGPL included in the packaging of this file.
 ** Please review the following information to ensure the GNU Lesser General
 ** Public License version 2.1 requirements will be met:
 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
 ** In addition, as a special exception, Nokia gives you certain additional
 ** rights. These rights are described in the Nokia Qt LGPL Exception
 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** Other Usage
 **
 ** Alternatively, this file may be used in accordance with the terms and
 ** conditions contained in a signed written agreement between you and Nokia.
 **
 ** If you have questions regarding the use of this file, please contact
 ** Nokia at qt-info@nokia.com.
 **
 **************************************************************************/
 
 #include "KisMultiFeedRSSModel.h"
 
 #include <QTimer>
 #include <QThread>
 #include <QXmlStreamReader>
 #include <QCoreApplication>
 #include <QLocale>
 
 #include <QNetworkRequest>
 #include <QNetworkReply>
 #include <KisNetworkAccessManager.h>
 
 QString shortenHtml(QString html)
 {
     html.replace(QLatin1String("<a"), QLatin1String("<i"));
     html.replace(QLatin1String("</a"), QLatin1String("</i"));
     uint firstParaEndXhtml = (uint) html.indexOf(QLatin1String("</p>"));
     uint firstParaEndHtml = (uint) html.indexOf(QLatin1String("<p>"), html.indexOf(QLatin1String("<p>"))+1);
     uint firstParaEndBr = (uint) html.indexOf(QLatin1String("<br"));
     uint firstParaEnd = qMin(firstParaEndXhtml, firstParaEndHtml);
     firstParaEnd = qMin(firstParaEnd, firstParaEndBr);
     return html.left(firstParaEnd);
 }
 
 class RssReader {
 public:
     RssItem parseItem() {
         RssItem item;
         item.source = requestUrl;
         item.blogIcon = blogIcon;
         item.blogName = blogName;
         while (!streamReader.atEnd()) {
             switch (streamReader.readNext()) {
             case QXmlStreamReader::StartElement:
                 if (streamReader.name() == QLatin1String("title"))
                     item.title = streamReader.readElementText();
                 else if (streamReader.name() == QLatin1String("link"))
                     item.link = streamReader.readElementText();
                 else if (streamReader.name() == QLatin1String("pubDate")) {
                     QString dateStr = streamReader.readElementText();
-                    // fixme: honor time zone!
-                    dateStr = dateStr.left(dateStr.indexOf('+')-1);
-                    item.pubDate = QLocale(QLocale::English).toDateTime(dateStr, "ddd, dd MMM yyyy HH:mm:ss");
+                    item.pubDate = QDateTime::fromString(dateStr, Qt::RFC2822Date);
                 }
+                else if (streamReader.name() == QLatin1String("category"))
+                    item.category = streamReader.readElementText();
                 else if (streamReader.name() == QLatin1String("description"))
                     item.description = streamReader.readElementText(); //shortenHtml(streamReader.readElementText());
                 break;
             case QXmlStreamReader::EndElement:
                 if (streamReader.name() == QLatin1String("item"))
                     return item;
                 break;
             default:
                 break;
 
             }
         }
         return RssItem();
     }
 
     RssItemList parse(QNetworkReply *reply) {
         QUrl source = reply->request().url();
         requestUrl = source.toString();
         streamReader.setDevice(reply);
         RssItemList list;
         while (!streamReader.atEnd()) {
             switch (streamReader.readNext()) {
             case QXmlStreamReader::StartElement:
                 if (streamReader.name() == QLatin1String("item"))
                     list.append(parseItem());
                 else if (streamReader.name() == QLatin1String("title"))
                     blogName = streamReader.readElementText();
                 else if (streamReader.name() == QLatin1String("link")) {
                     if (!streamReader.namespaceUri().isEmpty())
                         break;
                     QString favIconString(streamReader.readElementText());
                     QUrl favIconUrl(favIconString);
                     favIconUrl.setPath(QLatin1String("favicon.ico"));
                     blogIcon = favIconUrl.toString();
                     blogIcon = QString(); // XXX: fix the favicon on krita.org!
                 }
                 break;
             default:
                 break;
             }
         }
         return list;
     }
 
 private:
     QXmlStreamReader streamReader;
     QString requestUrl;
     QString blogIcon;
     QString blogName;
 };
 
 MultiFeedRssModel::MultiFeedRssModel(QObject *parent) :
     QAbstractListModel(parent),
     m_networkAccessManager(new KisNetworkAccessManager),
     m_articleCount(0)
 {
     connect(m_networkAccessManager, SIGNAL(finished(QNetworkReply*)),
             SLOT(appendFeedData(QNetworkReply*)), Qt::QueuedConnection);
 
 }
 
 
 
 MultiFeedRssModel::~MultiFeedRssModel()
 {
 }
 
 QHash<int, QByteArray> MultiFeedRssModel::roleNames() const
 {
     QHash<int, QByteArray> roleNames;
     roleNames[TitleRole] = "title";
     roleNames[DescriptionRole] = "description";
     roleNames[PubDateRole] = "pubDate";
     roleNames[LinkRole] = "link";
+    roleNames[CategoryRole] = "category";
     roleNames[BlogNameRole] = "blogName";
     roleNames[BlogIconRole] = "blogIcon";
     return roleNames;
 }
 
 void MultiFeedRssModel::addFeed(const QString& feed)
 {
     const QUrl feedUrl(feed);
     QMetaObject::invokeMethod(m_networkAccessManager, "getUrl",
                               Qt::QueuedConnection, Q_ARG(QUrl, feedUrl));
 }
 
 bool sortForPubDate(const RssItem& item1, const RssItem& item2)
 {
     return item1.pubDate > item2.pubDate;
 }
 
 void MultiFeedRssModel::appendFeedData(QNetworkReply *reply)
 {
     RssReader reader;
     m_aggregatedFeed.append(reader.parse(reply));
     std::sort(m_aggregatedFeed.begin(), m_aggregatedFeed.end(), sortForPubDate);
     setArticleCount(m_aggregatedFeed.size());
     beginResetModel();
     endResetModel();
+
+    emit feedDataChanged();
 }
 
 void MultiFeedRssModel::removeFeed(const QString &feed)
 {
     QMutableListIterator<RssItem> it(m_aggregatedFeed);
     while (it.hasNext()) {
         RssItem item = it.next();
         if (item.source == feed)
             it.remove();
     }
     setArticleCount(m_aggregatedFeed.size());
 }
 
 int MultiFeedRssModel::rowCount(const QModelIndex &) const
 {
     return m_aggregatedFeed.size();
 }
 
 QVariant MultiFeedRssModel::data(const QModelIndex &index, int role) const
 {
 
     RssItem item = m_aggregatedFeed.at(index.row());
 
     switch (role) {
     case Qt::DisplayRole:
     {
         return QString("<b><a href=\"" + item.link + "\">" + item.title + "</a></b>"
-               "<br><small>(" + item.pubDate.toString("MMMM d, yyyy") + ") "
+               "<br><small>(" + item.pubDate.toLocalTime().toString(Qt::DefaultLocaleShortDate) + ") "
                + item.description.left(90).append("...") + "</small><hr>");
     }
     case TitleRole:
         return item.title;
     case DescriptionRole:
         return item.description;
     case PubDateRole:
         return item.pubDate.toString("dd-MM-yyyy hh:mm");
     case LinkRole:
         return item.link;
+    case CategoryRole:
+        return item.category;
     case BlogNameRole:
         return item.blogName;
     case BlogIconRole:
         return item.blogIcon;
     }
 
     return QVariant();
 }
diff --git a/libs/ui/KisMultiFeedRSSModel.h b/libs/ui/KisMultiFeedRSSModel.h
index 613d9a49fc..7575013244 100644
--- a/libs/ui/KisMultiFeedRSSModel.h
+++ b/libs/ui/KisMultiFeedRSSModel.h
@@ -1,106 +1,108 @@
 /**************************************************************************
 **
 ** This file is part of Qt Creator
 **
 ** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
 **
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 **
 ** GNU Lesser General Public License Usage
 **
 ** This file may be used under the terms of the GNU Lesser General Public
 ** License version 2.1 as published by the Free Software Foundation and
 ** appearing in the file LICENSE.LGPL included in the packaging of this file.
 ** Please review the following information to ensure the GNU Lesser General
 ** Public License version 2.1 requirements will be met:
 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
 ** In addition, as a special exception, Nokia gives you certain additional
 ** rights. These rights are described in the Nokia Qt LGPL Exception
 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** Other Usage
 **
 ** Alternatively, this file may be used in accordance with the terms and
 ** conditions contained in a signed written agreement between you and Nokia.
 **
 ** If you have questions regarding the use of this file, please contact
 ** Nokia at qt-info@nokia.com.
 **
 **************************************************************************/
 
 #ifndef MULTIFEEDRSSMODEL_H
 #define MULTIFEEDRSSMODEL_H
 
 #include <QAbstractListModel>
 #include <QStringList>
 #include <QDateTime>
 
 #include <kritaui_export.h>
 
 class QThread;
 class QNetworkReply;
 class QNetworkAccessManager;
 
 struct RssItem {
     QString source;
     QString title;
     QString link;
     QString description;
+    QString category;
     QString blogName;
     QString blogIcon;
     QDateTime pubDate;
 
 };
 typedef QList<RssItem> RssItemList;
 
 class KisNetworkAccessManager;
 
 enum RssRoles { TitleRole = Qt::UserRole + 1, DescriptionRole, LinkRole,
-                PubDateRole, BlogNameRole, BlogIconRole
+                PubDateRole, CategoryRole, BlogNameRole, BlogIconRole
               };
 
 class KRITAUI_EXPORT MultiFeedRssModel : public QAbstractListModel
 {
     Q_OBJECT
     Q_PROPERTY(int articleCount READ articleCount WRITE setArticleCount NOTIFY articleCountChanged)
 public:
     explicit MultiFeedRssModel(QObject *parent = 0);
     ~MultiFeedRssModel() override;
     QHash<int, QByteArray> roleNames() const override;
     void addFeed(const QString& feed);
     void removeFeed(const QString& feed);
 
     int rowCount(const QModelIndex &parent = QModelIndex()) const override;
     QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
 
     int articleCount() const {
         return m_articleCount;
     }
 
 public Q_SLOTS:
     void setArticleCount(int arg) {
         if (m_articleCount != arg) {
             m_articleCount = arg;
             emit articleCountChanged(arg);
         }
     }
 
 Q_SIGNALS:
     void articleCountChanged(int arg);
+    void feedDataChanged();
 
 private Q_SLOTS:
     void appendFeedData(QNetworkReply *reply);
 
 private:
     QStringList m_sites;
     RssItemList m_aggregatedFeed;
     QNetworkAccessManager *m_networkAccessManager;
     QThread *m_namThread;
     int m_articleCount;
 };
 
 #endif // MULTIFEEDRSSMODEL_H
 
 
diff --git a/libs/ui/KisPaletteEditor.cpp b/libs/ui/KisPaletteEditor.cpp
index 926af79d97..41f73684bf 100644
--- a/libs/ui/KisPaletteEditor.cpp
+++ b/libs/ui/KisPaletteEditor.cpp
@@ -1,663 +1,689 @@
 /*
  *  Copyright (c) 2018 Michael Zhou <simeirxh@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 <QHash>
 #include <QString>
 #include <QScopedPointer>
 #include <QPointer>
 #include <QFormLayout>
 #include <QCheckBox>
 #include <QLineEdit>
 #include <QPushButton>
 #include <QLabel>
 #include <QSpinBox>
 #include <QComboBox>
 #include <QMessageBox>
 
 #include <KoDialog.h>
 #include <KoFileDialog.h>
 #include <KoColorSet.h>
 #include <KisSwatchGroup.h>
 #include <kis_signal_compressor.h>
 #include <KisViewManager.h>
 #include <KisDocument.h>
 #include <KoResourceServer.h>
 #include <KoResourceServerProvider.h>
 #include <KisPaletteModel.h>
 #include <kis_color_button.h>
 
 #include "KisPaletteEditor.h"
 
 struct KisPaletteEditor::PaletteInfo {
     QString name;
     QString filename;
     int columnCount;
     bool isGlobal;
     bool isReadOnly;
     QHash<QString, KisSwatchGroup> groups;
 };
 
 struct KisPaletteEditor::Private
 {
     bool isGlobalModified {false};
     bool isNameModified {false};
     bool isFilenameModified {false};
     bool isColumnCountModified {false};
     QSet<QString> modifiedGroupNames; // key is original group name
     QSet<QString> newGroupNames;
     QSet<QString> keepColorGroups;
     QSet<QString> pathsToRemove;
     QString groupBeingRenamed;
     QPointer<KisPaletteModel> model;
     QPointer<KisViewManager> view;
     PaletteInfo modified;
     QPointer<KoDialog> query;
-    KoResourceServer<KoColorSet> *rServer;
+    KoResourceServer<KoColorSet> *rServer {0};
 
     QPalette normalPalette;
     QPalette warnPalette;
 };
 
 KisPaletteEditor::KisPaletteEditor(QObject *parent)
     : QObject(parent)
     , m_d(new Private)
 {
     m_d->rServer = KoResourceServerProvider::instance()->paletteServer();
     m_d->warnPalette.setColor(QPalette::Text, Qt::red);
 }
 
 KisPaletteEditor::~KisPaletteEditor()
 { }
 
 void KisPaletteEditor::setPaletteModel(KisPaletteModel *model)
 {
     if (!model) { return; }
     m_d->model = model;
     slotPaletteChanged();
     connect(model, SIGNAL(sigPaletteChanged()), SLOT(slotPaletteChanged()));
     connect(model, SIGNAL(sigPaletteModified()), SLOT(slotSetDocumentModified()));
 }
 
 void KisPaletteEditor::setView(KisViewManager *view)
 {
     m_d->view = view;
 }
 
 void KisPaletteEditor::addPalette()
 {
     if (!m_d->view) { return; }
     if (!m_d->view->document()) { return; }
+
     KoDialog dlg;
     QFormLayout layout;
     dlg.mainWidget()->setLayout(&layout);
     QLabel lbl(i18nc("Label for line edit to set a palette name.","Name"));
     QLineEdit le(i18nc("Default name for a new palette","New Palette"));
     layout.addRow(&lbl, &le);
+
+    QLabel lbl2(i18nc("Label for line edit to set a palette filename.","File Name"));
+    QLineEdit le2(i18nc("Default file name for a new palette", "New Palette"));
+    layout.addRow(&lbl2, &le2);
+
+
+    QCheckBox chkSaveInDocument(i18n("Save Palette in the Current Document"));
+    chkSaveInDocument.setChecked(false);
+    layout.addRow(&chkSaveInDocument);
+
     if (dlg.exec() != QDialog::Accepted) { return; }
-    KoColorSet *newColorSet = new KoColorSet(newPaletteFileName(false));
+
+    KoColorSet *newColorSet = new KoColorSet(newPaletteFileName(!chkSaveInDocument.isChecked(), le2.text()));
     newColorSet->setPaletteType(KoColorSet::KPL);
-    newColorSet->setIsGlobal(false);
+    newColorSet->setIsGlobal(!chkSaveInDocument.isChecked());
     newColorSet->setIsEditable(true);
     newColorSet->setValid(true);
     newColorSet->setName(le.text());
-    m_d->rServer->addResource(newColorSet);
+
+    m_d->rServer->addResource(newColorSet, !chkSaveInDocument.isChecked());
     m_d->rServer->removeFromBlacklist(newColorSet);
 
     uploadPaletteList();
 }
 
 void KisPaletteEditor::importPalette()
 {
     KoFileDialog dialog(0, KoFileDialog::OpenFile, "Open Palette");
+
     dialog.setDefaultDir(QDir::homePath());
     dialog.setMimeTypeFilters(QStringList() << "krita/x-colorset" << "application/x-gimp-color-palette");
+
     QString filename = dialog.filename();
     if (filename.isEmpty()) { return; }
     if (duplicateExistsFilename(filename, false)) {
         QMessageBox message;
         message.setWindowTitle(i18n("Can't Import Palette"));
         message.setText(i18n("Can't import palette: there's already imported with the same filename"));
         message.exec();
         return;
     }
+
+    QMessageBox messageBox;
+    messageBox.setText(i18n("Do you want to store this palette in your current image?"));
+    messageBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
+    bool global = (messageBox.exec() == QMessageBox::Yes);
+
     KoColorSet *colorSet = new KoColorSet(filename);
     colorSet->load();
     QString name = filenameFromPath(colorSet->filename());
+
     if (duplicateExistsFilename(name, false)) {
-        colorSet->setFilename(newPaletteFileName(false));
+        colorSet->setFilename(newPaletteFileName(global));
     } else {
         colorSet->setFilename(name);
     }
-    colorSet->setIsGlobal(false);
-    m_d->rServer->addResource(colorSet);
+
+    colorSet->setIsGlobal(global);
+    m_d->rServer->addResource(colorSet, global);
     m_d->rServer->removeFromBlacklist(colorSet);
 
     uploadPaletteList();
 }
 
 void KisPaletteEditor::removePalette(KoColorSet *cs)
 {
     if (!m_d->view) { return; }
     if (!m_d->view->document()) { return; }
     if (!cs || !cs->isEditable()) {
         return;
     }
 
     if (cs->isGlobal()) {
         m_d->rServer->removeResourceAndBlacklist(cs);
         QFile::remove(cs->filename());
         return;
     }
     m_d->rServer->removeResourceFromServer(cs);
     uploadPaletteList();
 }
 
 int KisPaletteEditor::rowNumberOfGroup(const QString &oriName) const
 {
     if (!m_d->modified.groups.contains(oriName)) { return 0; }
     return m_d->modified.groups[oriName].rowCount();
 }
 
 bool KisPaletteEditor::duplicateExistsGroupName(const QString &name) const
 {
     if (name == m_d->groupBeingRenamed) { return false; }
     Q_FOREACH (const KisSwatchGroup &g, m_d->modified.groups.values()) {
         if (name == g.name()) { return true; }
     }
     return false;
 }
 
 bool KisPaletteEditor::duplicateExistsOriginalGroupName(const QString &name) const
 {
     return m_d->modified.groups.contains(name);
 }
 
 QString KisPaletteEditor::oldNameFromNewName(const QString &newName) const
 {
     Q_FOREACH (const QString &oldGroupName, m_d->modified.groups.keys()) {
         if (m_d->modified.groups[oldGroupName].name() == newName) {
             return oldGroupName;
         }
     }
     return QString();
 }
 
 void KisPaletteEditor::rename(const QString &newName)
 {
     if (newName.isEmpty()) { return; }
     m_d->isNameModified = true;
     m_d->modified.name = newName;
 }
 
 void KisPaletteEditor::changeFilename(const QString &newName)
 {
     if (newName.isEmpty()) { return; }
     m_d->isFilenameModified = true;
     m_d->pathsToRemove.insert(m_d->modified.filename);
     if (m_d->modified.isGlobal) {
         m_d->modified.filename = m_d->rServer->saveLocation() + newName;
     } else {
         m_d->modified.filename = newName;
     }
 }
 
 void KisPaletteEditor::changeColCount(int newCount)
 {
     m_d->isColumnCountModified = true;
     m_d->modified.columnCount = newCount;
 }
 
 QString KisPaletteEditor::addGroup()
 {
     KoDialog dlg;
     m_d->query = &dlg;
 
     QVBoxLayout layout(&dlg);
     dlg.mainWidget()->setLayout(&layout);
 
     QLabel lblName(i18n("Name"), &dlg);
     layout.addWidget(&lblName);
     QLineEdit leName(&dlg);
     leName.setText(newGroupName());
     connect(&leName, SIGNAL(textChanged(QString)), SLOT(slotGroupNameChanged(QString)));
     layout.addWidget(&leName);
     QLabel lblRowCount(i18n("Row count"), &dlg);
     layout.addWidget(&lblRowCount);
     QSpinBox spxRow(&dlg);
     spxRow.setValue(20);
     layout.addWidget(&spxRow);
 
     if (dlg.exec() != QDialog::Accepted) { return QString(); }
     if (duplicateExistsGroupName(leName.text())) { return QString(); }
 
     QString realName = leName.text();
     QString name = realName;
     if (duplicateExistsOriginalGroupName(name)) {
         name = newGroupName();
     }
     m_d->modified.groups[name] = KisSwatchGroup();
     KisSwatchGroup &newGroup = m_d->modified.groups[name];
     newGroup.setName(realName);
     m_d->newGroupNames.insert(name);
     newGroup.setRowCount(spxRow.value());
     return realName;
 }
 
 bool KisPaletteEditor::removeGroup(const QString &name)
 {
     KoDialog window;
     window.setWindowTitle(i18nc("@title:window", "Removing Group"));
     QFormLayout editableItems(&window);
     QCheckBox chkKeep(&window);
     window.mainWidget()->setLayout(&editableItems);
     editableItems.addRow(i18nc("Shows up when deleting a swatch group", "Keep the Colors"), &chkKeep);
     if (window.exec() != KoDialog::Accepted) { return false; }
 
     m_d->modified.groups.remove(name);
     m_d->newGroupNames.remove(name);
     if (chkKeep.isChecked()) {
         m_d->keepColorGroups.insert(name);
     }
     return true;
 }
 
 QString KisPaletteEditor::renameGroup(const QString &oldName)
 {
     if (oldName.isEmpty() || oldName == KoColorSet::GLOBAL_GROUP_NAME) { return QString(); }
 
     KoDialog dlg;
     m_d->query = &dlg;
     m_d->groupBeingRenamed = m_d->modified.groups[oldName].name();
 
     QFormLayout form(&dlg);
     dlg.mainWidget()->setLayout(&form);
 
     QLineEdit leNewName;
     connect(&leNewName, SIGNAL(textChanged(QString)), SLOT(slotGroupNameChanged(QString)));
     leNewName.setText(m_d->modified.groups[oldName].name());
 
     form.addRow(i18nc("Renaming swatch group", "New name"), &leNewName);
 
     if (dlg.exec() != KoDialog::Accepted) { return QString(); }
     if (leNewName.text().isEmpty()) { return QString(); }
     if (duplicateExistsGroupName(leNewName.text())) { return QString(); }
 
     m_d->modified.groups[oldName].setName(leNewName.text());
     m_d->modifiedGroupNames.insert(oldName);
 
     return leNewName.text();
 }
 
 void KisPaletteEditor::slotGroupNameChanged(const QString &newName)
 {
     QLineEdit *leGroupName = qobject_cast<QLineEdit*>(sender());
     if (duplicateExistsGroupName(newName) || newName == QString()) {
         leGroupName->setPalette(m_d->warnPalette);
         if (m_d->query->button(KoDialog::Ok)) {
             m_d->query->button(KoDialog::Ok)->setEnabled(false);
         }
         return;
     }
     leGroupName->setPalette(m_d->normalPalette);
     if (m_d->query->button(KoDialog::Ok)) {
         m_d->query->button(KoDialog::Ok)->setEnabled(true);
     }
 }
 
 void KisPaletteEditor::changeGroupRowCount(const QString &name, int newRowCount)
 {
     if (!m_d->modified.groups.contains(name)) { return; }
     m_d->modified.groups[name].setRowCount(newRowCount);
     m_d->modifiedGroupNames.insert(name);
 }
 
 void KisPaletteEditor::setGlobal(bool isGlobal)
 {
     m_d->isGlobalModified = true;
     m_d->modified.isGlobal = isGlobal;
 }
 
 void KisPaletteEditor::setEntry(const KoColor &color, const QModelIndex &index)
 {
     Q_ASSERT(m_d->model);
     if (!m_d->model->colorSet()->isEditable()) { return; }
     if (!m_d->view) { return; }
     if (!m_d->view->document()) { return; }
     KisSwatch c = KisSwatch(color);
     c.setId(QString::number(m_d->model->colorSet()->colorCount() + 1));
     c.setName(i18nc("Default name for a color swatch","Color %1", QString::number(m_d->model->colorSet()->colorCount()+1)));
     m_d->model->setEntry(c, index);
 }
 
 void KisPaletteEditor::slotSetDocumentModified()
 {
     m_d->view->document()->setModified(true);
 }
 
 void KisPaletteEditor::removeEntry(const QModelIndex &index)
 {
     Q_ASSERT(m_d->model);
     if (!m_d->model->colorSet()->isEditable()) { return; }
     if (!m_d->view) { return; }
     if (!m_d->view->document()) { return; }
     if (qvariant_cast<bool>(index.data(KisPaletteModel::IsGroupNameRole))) {
         removeGroup(qvariant_cast<QString>(index.data(KisPaletteModel::GroupNameRole)));
         updatePalette();
     } else {
         m_d->model->removeEntry(index, false);
     }
     if (m_d->model->colorSet()->isGlobal()) {
         m_d->model->colorSet()->save();
         return;
     }
 }
 
 void KisPaletteEditor::modifyEntry(const QModelIndex &index)
 {
     if (!m_d->model->colorSet()->isEditable()) { return; }
     if (!m_d->view) { return; }
     if (!m_d->view->document()) { return; }
 
     KoDialog dlg;
     dlg.setCaption(i18nc("@title:window", "Add a Color"));
     QFormLayout *editableItems = new QFormLayout(&dlg);
     dlg.mainWidget()->setLayout(editableItems);
 
     QString groupName = qvariant_cast<QString>(index.data(Qt::DisplayRole));
     if (qvariant_cast<bool>(index.data(KisPaletteModel::IsGroupNameRole))) {
         renameGroup(groupName);
         updatePalette();
     }
     else {
 
         QLineEdit *lnIDName = new QLineEdit(&dlg);
         QLineEdit *lnGroupName = new QLineEdit(&dlg);
         KisColorButton *bnColor = new KisColorButton(&dlg);
         QCheckBox *chkSpot = new QCheckBox(&dlg);
         chkSpot->setToolTip(i18nc("@info:tooltip", "A spot color is a color that the printer is able to print without mixing the paints it has available to it. The opposite is called a process color."));
 
         KisSwatch entry = m_d->model->getEntry(index);
 
         editableItems->addRow(i18n("ID"), lnIDName);
         editableItems->addRow(i18nc("Name for a swatch group", "Swatch group name"), lnGroupName);
         editableItems->addRow(i18n("Color"), bnColor);
         editableItems->addRow(i18n("Spot color"), chkSpot);
 
         lnGroupName->setText(entry.name());
         lnIDName->setText(entry.id());
         bnColor->setColor(entry.color());
         chkSpot->setChecked(entry.spotColor());
 
         if (dlg.exec() == KoDialog::Accepted) {
             entry.setName(lnGroupName->text());
             entry.setId(lnIDName->text());
             entry.setColor(bnColor->color());
             entry.setSpotColor(chkSpot->isChecked());
             m_d->model->setEntry(entry, index);
         }
     }
 }
 
 void KisPaletteEditor::addEntry(const KoColor &color)
 {
     Q_ASSERT(m_d->model);
     if (!m_d->view) { return; }
     if (!m_d->view->document()) { return; }
     if (!m_d->model->colorSet()->isEditable()) { return; }
     KoDialog window;
     window.setWindowTitle(i18nc("@title:window", "Add a new Colorset Entry"));
     QFormLayout editableItems(&window);
     window.mainWidget()->setLayout(&editableItems);
     QComboBox cmbGroups(&window);
     cmbGroups.addItems(m_d->model->colorSet()->getGroupNames());
     QLineEdit lnIDName(&window);
     QLineEdit lnName(&window);
     KisColorButton bnColor(&window);
     QCheckBox chkSpot(&window);
     chkSpot.setToolTip(i18nc("@info:tooltip", "A spot color is a color that the printer is able to print without mixing the paints it has available to it. The opposite is called a process color."));
     editableItems.addRow(i18n("Group"), &cmbGroups);
     editableItems.addRow(i18n("ID"), &lnIDName);
     editableItems.addRow(i18n("Name"), &lnName);
     editableItems.addRow(i18n("Color"), &bnColor);
     editableItems.addRow(i18nc("Spot color", "Spot"), &chkSpot);
     cmbGroups.setCurrentIndex(0);
     lnName.setText(i18nc("Default name for a color swatch","Color %1", QString::number(m_d->model->colorSet()->colorCount()+1)));
     lnIDName.setText(QString::number(m_d->model->colorSet()->colorCount() + 1));
     bnColor.setColor(color);
     chkSpot.setChecked(false);
 
     if (window.exec() != KoDialog::Accepted) { return; }
 
     QString groupName = cmbGroups.currentText();
 
     KisSwatch newEntry;
     newEntry.setColor(bnColor.color());
     newEntry.setName(lnName.text());
     newEntry.setId(lnIDName.text());
     newEntry.setSpotColor(chkSpot.isChecked());
     m_d->model->addEntry(newEntry, groupName);
 
     if (m_d->model->colorSet()->isGlobal()) {
         m_d->model->colorSet()->save();
         return;
     }
     m_d->modifiedGroupNames.insert(groupName);
     m_d->modified.groups[groupName].addEntry(newEntry);
 }
 
 void KisPaletteEditor::updatePalette()
 {
     Q_ASSERT(m_d->model);
     Q_ASSERT(m_d->model->colorSet());
     if (!m_d->model->colorSet()->isEditable()) { return; }
     if (!m_d->view) { return; }
     if (!m_d->view->document()) { return; }
     KoColorSet *palette = m_d->model->colorSet();
     PaletteInfo &modified = m_d->modified;
 
     if (m_d->isColumnCountModified) {
         palette->setColumnCount(modified.columnCount);
     }
     if (m_d->isNameModified) {
         palette->setName(modified.name);
     }
     if (m_d->isFilenameModified) {
         QString originalPath = palette->filename();
         palette->setFilename(modified.filename);
         if (palette->isGlobal()) {
             if (!palette->save()) {
                 palette->setFilename(newPaletteFileName(true));
                 palette->save();
             }
             QFile::remove(originalPath);
         }
     }
     if (m_d->isGlobalModified) {
         palette->setIsGlobal(modified.isGlobal);
         if (modified.isGlobal) {
             setGlobal();
         } else {
             setNonGlobal();
         }
     }
     Q_FOREACH (const QString &groupName, palette->getGroupNames()) {
         if (!modified.groups.contains(groupName)) {
             m_d->model->removeGroup(groupName, m_d->keepColorGroups.contains(groupName));
         }
     }
     m_d->keepColorGroups.clear();
     Q_FOREACH (const QString &groupName, palette->getGroupNames()) {
         if (m_d->modifiedGroupNames.contains(groupName)) {
             m_d->model->setRowNumber(groupName, modified.groups[groupName].rowCount());
             if (groupName != modified.groups[groupName].name()) {
                 m_d->model->renameGroup(groupName, modified.groups[groupName].name());
                 modified.groups[modified.groups[groupName].name()] = modified.groups[groupName];
                 modified.groups.remove(groupName);
             }
         }
     }
     m_d->modifiedGroupNames.clear();
     Q_FOREACH (const QString &newGroupName, m_d->newGroupNames) {
         m_d->model->addGroup(modified.groups[newGroupName]);
     }
     m_d->newGroupNames.clear();
 
     if (m_d->model->colorSet()->isGlobal()) {
         m_d->model->colorSet()->save();
     }
 }
 
 void KisPaletteEditor::slotPaletteChanged()
 {
     Q_ASSERT(m_d->model);
     if (!m_d->model->colorSet()) { return; }
     KoColorSet *palette = m_d->model->colorSet();
     m_d->modified.groups.clear();
     m_d->keepColorGroups.clear();
     m_d->newGroupNames.clear();
     m_d->modifiedGroupNames.clear();
 
     m_d->modified.name = palette->name();
     m_d->modified.filename = palette->filename();
     m_d->modified.columnCount = palette->columnCount();
     m_d->modified.isGlobal = palette->isGlobal();
     m_d->modified.isReadOnly = !palette->isEditable();
 
     Q_FOREACH (const QString &groupName, palette->getGroupNames()) {
         KisSwatchGroup *cs = palette->getGroup(groupName);
         m_d->modified.groups[groupName] = KisSwatchGroup(*cs);
     }
 }
 
 void KisPaletteEditor::setGlobal()
 {
     Q_ASSERT(m_d->model);
     if (!m_d->view) { return; }
     if (!m_d->view->document()) { return; }
     if (!m_d->model->colorSet()) { return; }
 
     KoColorSet *colorSet = m_d->model->colorSet();
     QString saveLocation = m_d->rServer->saveLocation();
     QString name = filenameFromPath(colorSet->filename());
 
     QFileInfo fileInfo(saveLocation + name);
 
     colorSet->setFilename(fileInfo.filePath());
     colorSet->setIsGlobal(true);
     m_d->rServer->removeFromBlacklist(colorSet);
     if (!colorSet->save()) {
         QMessageBox message;
         message.setWindowTitle(i18n("Saving palette failed"));
         message.setText(i18n("Failed to save global palette file. Please set it to non-global, or you will lose the file when you close Krita"));
         message.exec();
     }
 
     uploadPaletteList();
 }
 
 bool KisPaletteEditor::duplicateExistsFilename(const QString &filename, bool global) const
 {
     QString prefix;
     if (global) {
         prefix = m_d->rServer->saveLocation();
     }
 
     Q_FOREACH (const KoResource *r, KoResourceServerProvider::instance()->paletteServer()->resources()) {
         if (r->filename() == prefix + filename && r != m_d->model->colorSet()) {
             return true;
         }
     }
 
     return false;
 }
 
 QString KisPaletteEditor::relativePathFromSaveLocation() const
 {
     return filenameFromPath(m_d->modified.filename);
 }
 
 void KisPaletteEditor::setNonGlobal()
 {
     Q_ASSERT(m_d->model);
     if (!m_d->view) { return; }
     if (!m_d->view->document()) { return; }
     if (!m_d->model->colorSet()) { return; }
+
     KoColorSet *colorSet = m_d->model->colorSet();
     QString name = filenameFromPath(colorSet->filename());
     QFile::remove(colorSet->filename());
+
     if (duplicateExistsFilename(name, false)) {
         colorSet->setFilename(newPaletteFileName(false));
     } else {
         colorSet->setFilename(name);
     }
+
     colorSet->setIsGlobal(false);
 
     uploadPaletteList();
 }
 
-QString KisPaletteEditor::newPaletteFileName(bool isGlobal)
+QString KisPaletteEditor::newPaletteFileName(bool isGlobal, const QString &filename)
 {
     QSet<QString> nameSet;
 
     Q_FOREACH (const KoResource *r, m_d->rServer->resources()) {
         nameSet.insert(r->filename());
     }
 
     KoColorSet tmpColorSet;
-    QString result = "new_palette_";
+    QString result = (filename.isEmpty() ? "new_palette" : filename);
 
     if (isGlobal) {
         result = m_d->rServer->saveLocation() + result;
     }
 
     int i = 0;
     while (nameSet.contains(result + QString::number(i) + tmpColorSet.defaultFileExtension())) {
         i++;
     }
-    result = result + QString::number(i) + tmpColorSet.defaultFileExtension();
+    result = result + (i > 0 ? QString::number(i) : "") + tmpColorSet.defaultFileExtension();
     return result;
 }
 
 QString KisPaletteEditor::newGroupName() const
 {
     int i = 1;
     QString groupname = i18nc("Default new group name", "New Group %1", QString::number(i));
     while (m_d->modified.groups.contains(groupname)) {
         i++;
         groupname = i18nc("Default new group name", "New Group %1", QString::number(i));
     }
     return groupname;
 }
 
 void KisPaletteEditor::uploadPaletteList() const
 {
     QList<KoColorSet *> list;
     Q_FOREACH (KoResource * paletteResource, m_d->rServer->resources()) {
         KoColorSet *palette = static_cast<KoColorSet*>(paletteResource);
         Q_ASSERT(palette);
         if (!palette->isGlobal()) {
             list.append(palette);
         }
     }
     m_d->view->document()->setPaletteList(list);
 }
 
 QString KisPaletteEditor::filenameFromPath(const QString &path) const
 {
     return QDir::fromNativeSeparators(path).section('/', -1, -1);
 }
diff --git a/libs/ui/KisPaletteEditor.h b/libs/ui/KisPaletteEditor.h
index a8a8c27aa4..a073381f1c 100644
--- a/libs/ui/KisPaletteEditor.h
+++ b/libs/ui/KisPaletteEditor.h
@@ -1,146 +1,146 @@
 /*
  *  Copyright (c) 2018 Michael Zhou <simeirxh@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 KISPALETTEMANAGER_H
 #define KISPALETTEMANAGER_H
 
 #include <QObject>
 #include <QScopedPointer>
 #include <KisSwatch.h>
 
 #include <kritaui_export.h>
 
 class KoColorSet;
 class KisPaletteModel;
 class KisViewManager;
 class KisSwatchGroup;
 class KisViewManager;
 
 /**
  * @brief The PaletteEditor class
  * this class manipulates a KisPaletteModel using GUI elements and communicate
  * with KisDocument
  *
  * Changes made in this class won't be done to the palette if the palette is
  * read only (not editable, isEditable() == false)
  */
 class KRITAUI_EXPORT KisPaletteEditor : public QObject
 {
     Q_OBJECT
 public:
     struct PaletteInfo;
 
 public:
     explicit KisPaletteEditor(QObject *parent = 0);
     ~KisPaletteEditor();
 
     void setPaletteModel(KisPaletteModel *model);
     void setView(KisViewManager *view);
 
     void addPalette();
     void importPalette();
     void removePalette(KoColorSet *);
 
     /**
      * @brief rowNumberOfGroup
      * @param oriName the original name of a group at the creation of the instance
      * @return newest row number of the group
      */
     int rowNumberOfGroup(const QString &oriName) const;
     /**
      * @brief oldNameFromNewName
      * @param newName the current name of a group
      * @return the name of the group at the creation of the instance
      */
     QString oldNameFromNewName(const QString &newName) const;
     /**
      * @brief duplicateExistsFilename
      * @param filename the name of the file
      * @param global if this filename is going to be used for a global palette
      * @return true if the a palette in the resource system that has filename
      * name already exists else false
      */
     bool duplicateExistsFilename(const QString &filename, bool global) const;
     QString relativePathFromSaveLocation() const;
 
     void rename(const QString &newName);
     void changeFilename(const QString &newName);
     void changeColCount(int);
 
     /**
      * @brief addGroup
      * @return new group's name if change accepted, empty string if cancelled
      */
     QString addGroup();
     /**
      * @brief removeGroup
      * @param name original group name
      * @return true if change accepted, false if cancelled
      */
     bool removeGroup(const QString &name);
     /**
      * @brief renameGroup
      * @param oldName
      * @return new name if change accpeted, empty string if cancelled
      */
     QString renameGroup(const QString &oldName);
     void changeGroupRowCount(const QString &name, int newRowCount);
     void setGlobal(bool);
     void setReadOnly(bool);
 
     void setEntry(const KoColor &color, const QModelIndex &index);
     void removeEntry(const QModelIndex &index);
     void modifyEntry(const QModelIndex &index);
     void addEntry(const KoColor &color);
 
     bool isModified() const;
 
     /**
      * @brief getModifiedGroup
      * @param originalName name of the group at the creation of the instance
      * @return the modified group
      */
     const KisSwatchGroup &getModifiedGroup(const QString &originalName) const;
 
     /**
      * @brief updatePalette
      * MUST be called to make the changes into the resource server
      */
     void updatePalette();
 
 private Q_SLOTS:
     void slotGroupNameChanged(const QString &newName);
     void slotPaletteChanged();
     void slotSetDocumentModified();
 
 private:
-    QString newPaletteFileName(bool isGlobal);
+    QString newPaletteFileName(bool isGlobal, const QString &filename = QString());
     QString newGroupName() const;
     void setNonGlobal();
     void setGlobal();
     bool duplicateExistsGroupName(const QString &name) const;
     bool duplicateExistsOriginalGroupName(const QString &name) const;
     void uploadPaletteList() const;
     QString filenameFromPath(const QString &path) const;
 
 private:
     struct Private;
     QScopedPointer<Private> m_d;
 };
 
 #endif // KISPALETTEMANAGER_H
diff --git a/libs/ui/KisPart.cpp b/libs/ui/KisPart.cpp
index b506d669d4..9fc87b2b1c 100644
--- a/libs/ui/KisPart.cpp
+++ b/libs/ui/KisPart.cpp
@@ -1,570 +1,569 @@
 /* This file is part of the KDE project
  * Copyright (C) 1998-1999 Torben Weis       <weis@kde.org>
  * Copyright (C) 2000-2005 David Faure       <faure@kde.org>
  * Copyright (C) 2007-2008 Thorsten Zachmann <zachmann@kde.org>
  * Copyright (C) 2010-2012 Boudewijn Rempt   <boud@valdyas.org>
  * Copyright (C) 2011 Inge Wallin            <ingwa@kogmbh.com>
  * Copyright (C) 2015 Michael Abrahams       <miabraha@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "KisPart.h"
 
 #include "KoProgressProxy.h"
 #include <KoCanvasController.h>
 #include <KoCanvasControllerWidget.h>
 #include <KoColorSpaceEngine.h>
 #include <KoCanvasBase.h>
 #include <KoToolManager.h>
 #include <KoShapeControllerBase.h>
 #include <KoResourceServerProvider.h>
 #include <kis_icon.h>
 
 #include "KisApplication.h"
 #include "KisMainWindow.h"
 #include "KisDocument.h"
 #include "KisView.h"
 #include "KisViewManager.h"
 #include "KisImportExportManager.h"
 
 #include <kis_debug.h>
 #include <KoResourcePaths.h>
 #include <KoDialog.h>
 #include <kdesktopfile.h>
 #include <QMessageBox>
 #include <klocalizedstring.h>
 #include <kactioncollection.h>
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <QKeySequence>
 
 #include <QDialog>
 #include <QApplication>
 #include <QDomDocument>
 #include <QDomElement>
 #include <QGlobalStatic>
 #include <KisMimeDatabase.h>
 #include <dialogs/KisSessionManagerDialog.h>
 
 #include "kis_config.h"
 #include "kis_shape_controller.h"
 #include "KisResourceServerProvider.h"
 #include "kis_animation_cache_populator.h"
 #include "kis_idle_watcher.h"
 #include "kis_image.h"
 #include "KisOpenPane.h"
 
 #include "kis_color_manager.h"
 
 #include "kis_action.h"
 #include "kis_action_registry.h"
 #include "KisSessionResource.h"
 
 Q_GLOBAL_STATIC(KisPart, s_instance)
 
 
 class Q_DECL_HIDDEN KisPart::Private
 {
 public:
     Private(KisPart *_part)
         : part(_part)
         , idleWatcher(2500)
         , animationCachePopulator(_part)
     {
     }
 
     ~Private()
     {
     }
 
     KisPart *part;
 
     QList<QPointer<KisView> > views;
     QList<QPointer<KisMainWindow> > mainWindows;
     QList<QPointer<KisDocument> > documents;
     KActionCollection *actionCollection{0};
     KisIdleWatcher idleWatcher;
     KisAnimationCachePopulator animationCachePopulator;
 
     KisSessionResource *currentSession = nullptr;
     bool closingSession{false};
     QScopedPointer<KisSessionManagerDialog> sessionManager;
 
     bool queryCloseDocument(KisDocument *document) {
         Q_FOREACH(auto view, views) {
             if (view && view->isVisible() && view->document() == document) {
                 return view->queryClose();
             }
         }
 
         return true;
     }
 };
 
 
 KisPart* KisPart::instance()
 {
     return s_instance;
 }
 
 
 KisPart::KisPart()
     : d(new Private(this))
 {
     // Preload all the resources in the background
     Q_UNUSED(KoResourceServerProvider::instance());
     Q_UNUSED(KisResourceServerProvider::instance());
     Q_UNUSED(KisColorManager::instance());
 
     connect(this, SIGNAL(documentOpened(QString)),
             this, SLOT(updateIdleWatcherConnections()));
 
     connect(this, SIGNAL(documentClosed(QString)),
             this, SLOT(updateIdleWatcherConnections()));
 
     connect(KisActionRegistry::instance(), SIGNAL(shortcutsUpdated()),
             this, SLOT(updateShortcuts()));
     connect(&d->idleWatcher, SIGNAL(startedIdleMode()),
             &d->animationCachePopulator, SLOT(slotRequestRegeneration()));
 
 
     d->animationCachePopulator.slotRequestRegeneration();
 }
 
 KisPart::~KisPart()
 {
     while (!d->documents.isEmpty()) {
         delete d->documents.takeFirst();
     }
 
     while (!d->views.isEmpty()) {
         delete d->views.takeFirst();
     }
 
     while (!d->mainWindows.isEmpty()) {
         delete d->mainWindows.takeFirst();
     }
 
     delete d;
 }
 
 void KisPart::updateIdleWatcherConnections()
 {
     QVector<KisImageSP> images;
 
     Q_FOREACH (QPointer<KisDocument> document, documents()) {
         if (document->image()) {
             images << document->image();
         }
     }
 
     d->idleWatcher.setTrackedImages(images);
 }
 
 void KisPart::addDocument(KisDocument *document)
 {
     //dbgUI << "Adding document to part list" << document;
     Q_ASSERT(document);
     if (!d->documents.contains(document)) {
         d->documents.append(document);
         emit documentOpened('/'+objectName());
         emit sigDocumentAdded(document);
         connect(document, SIGNAL(sigSavingFinished()), SLOT(slotDocumentSaved()));
     }
 }
 
 QList<QPointer<KisDocument> > KisPart::documents() const
 {
     return d->documents;
 }
 
 KisDocument *KisPart::createDocument() const
 {
     KisDocument *doc = new KisDocument();
     return doc;
 }
 
 
 int KisPart::documentCount() const
 {
     return d->documents.size();
 }
 
 void KisPart::removeDocument(KisDocument *document)
 {
     d->documents.removeAll(document);
     emit documentClosed('/'+objectName());
     emit sigDocumentRemoved(document->url().toLocalFile());
     document->deleteLater();
 }
 
 KisMainWindow *KisPart::createMainWindow(QUuid id)
 {
     KisMainWindow *mw = new KisMainWindow(id);
     dbgUI <<"mainWindow" << (void*)mw << "added to view" << this;
     d->mainWindows.append(mw);
     emit sigWindowAdded(mw);
     return mw;
 }
 
 KisView *KisPart::createView(KisDocument *document,
-                             KoCanvasResourceProvider *resourceManager,
-                             KActionCollection *actionCollection,
+                             KisViewManager *viewManager,
                              QWidget *parent)
 {
     // If creating the canvas fails, record this and disable OpenGL next time
     KisConfig cfg(false);
     KConfigGroup grp( KSharedConfig::openConfig(), "crashprevention");
     if (grp.readEntry("CreatingCanvas", false)) {
         cfg.disableOpenGL();
     }
     if (cfg.canvasState() == "OPENGL_FAILED") {
         cfg.disableOpenGL();
     }
     grp.writeEntry("CreatingCanvas", true);
     grp.sync();
 
     QApplication::setOverrideCursor(Qt::WaitCursor);
-    KisView *view  = new KisView(document, resourceManager, actionCollection, parent);
+    KisView *view = new KisView(document,  viewManager, parent);
     QApplication::restoreOverrideCursor();
 
     // Record successful canvas creation
     grp.writeEntry("CreatingCanvas", false);
     grp.sync();
 
     addView(view);
 
     return view;
 }
 
 void KisPart::addView(KisView *view)
 {
     if (!view)
         return;
 
     if (!d->views.contains(view)) {
         d->views.append(view);
     }
 
     emit sigViewAdded(view);
 }
 
 void KisPart::removeView(KisView *view)
 {
     if (!view) return;
 
     /**
      * HACK ALERT: we check here explicitly if the document (or main
      *             window), is saving the stuff. If we close the
      *             document *before* the saving is completed, a crash
      *             will happen.
      */
     KIS_ASSERT_RECOVER_RETURN(!view->mainWindow()->hackIsSaving());
 
     emit sigViewRemoved(view);
 
     QPointer<KisDocument> doc = view->document();
     d->views.removeAll(view);
 
     if (doc) {
         bool found = false;
         Q_FOREACH (QPointer<KisView> view, d->views) {
             if (view && view->document() == doc) {
                 found = true;
                 break;
             }
         }
         if (!found) {
             removeDocument(doc);
         }
     }
 }
 
 QList<QPointer<KisView> > KisPart::views() const
 {
     return d->views;
 }
 
 int KisPart::viewCount(KisDocument *doc) const
 {
     if (!doc) {
         return d->views.count();
     }
     else {
         int count = 0;
         Q_FOREACH (QPointer<KisView> view, d->views) {
             if (view && view->isVisible() && view->document() == doc) {
                 count++;
             }
         }
         return count;
     }
 }
 
 bool KisPart::closingSession() const
 {
     return d->closingSession;
 }
 
 bool KisPart::exists()
 {
     return s_instance.exists();
 }
 
 bool KisPart::closeSession(bool keepWindows)
 {
     d->closingSession = true;
 
     Q_FOREACH(auto document, d->documents) {
         if (!d->queryCloseDocument(document.data())) {
             d->closingSession = false;
             return false;
         }
     }
 
     if (d->currentSession) {
         KisConfig kisCfg(false);
         if (kisCfg.saveSessionOnQuit(false)) {
 
             d->currentSession->storeCurrentWindows();
             d->currentSession->save();
 
             KConfigGroup cfg = KSharedConfig::openConfig()->group("session");
             cfg.writeEntry("previousSession", d->currentSession->name());
         }
 
         d->currentSession = nullptr;
     }
 
     if (!keepWindows) {
         Q_FOREACH (auto window, d->mainWindows) {
             window->close();
         }
 
         if (d->sessionManager) {
             d->sessionManager->close();
         }
     }
 
     d->closingSession = false;
     return true;
 }
 
 void KisPart::slotDocumentSaved()
 {
     KisDocument *doc = qobject_cast<KisDocument*>(sender());
     emit sigDocumentSaved(doc->url().toLocalFile());
 }
 
 void KisPart::removeMainWindow(KisMainWindow *mainWindow)
 {
     dbgUI <<"mainWindow" << (void*)mainWindow <<"removed from doc" << this;
     if (mainWindow) {
         d->mainWindows.removeAll(mainWindow);
     }
 }
 
 const QList<QPointer<KisMainWindow> > &KisPart::mainWindows() const
 {
     return d->mainWindows;
 }
 
 int KisPart::mainwindowCount() const
 {
     return d->mainWindows.count();
 }
 
 
 KisMainWindow *KisPart::currentMainwindow() const
 {
     QWidget *widget = qApp->activeWindow();
     KisMainWindow *mainWindow = qobject_cast<KisMainWindow*>(widget);
     while (!mainWindow && widget) {
         widget = widget->parentWidget();
         mainWindow = qobject_cast<KisMainWindow*>(widget);
     }
 
     if (!mainWindow && mainWindows().size() > 0) {
         mainWindow = mainWindows().first();
     }
     return mainWindow;
 
 }
 
 KisMainWindow * KisPart::windowById(QUuid id) const
 {
     Q_FOREACH(QPointer<KisMainWindow> mainWindow, d->mainWindows) {
         if (mainWindow->id() == id) {
             return mainWindow;
         }
     }
 
     return nullptr;
 }
 
 KisIdleWatcher* KisPart::idleWatcher() const
 {
     return &d->idleWatcher;
 }
 
 KisAnimationCachePopulator* KisPart::cachePopulator() const
 {
     return &d->animationCachePopulator;
 }
 
 void KisPart::openExistingFile(const QUrl &url)
 {
     // TODO: refactor out this method!
 
     KisMainWindow *mw = currentMainwindow();
     KIS_SAFE_ASSERT_RECOVER_RETURN(mw);
 
     mw->openDocument(url, KisMainWindow::None);
 }
 
 void KisPart::updateShortcuts()
 {
     // Update any non-UI actionCollections.  That includes:
     // Now update the UI actions.
     Q_FOREACH (KisMainWindow *mainWindow, d->mainWindows) {
         KActionCollection *ac = mainWindow->actionCollection();
 
         ac->updateShortcuts();
 
         // Loop through mainWindow->actionCollections() to modify tooltips
         // so that they list shortcuts at the end in parentheses
         Q_FOREACH ( QAction* action, ac->actions())
         {
             // Remove any existing suffixes from the tooltips.
             // Note this regexp starts with a space, e.g. " (Ctrl-a)"
             QString strippedTooltip = action->toolTip().remove(QRegExp("\\s\\(.*\\)"));
 
             // Now update the tooltips with the new shortcut info.
             if (action->shortcut() == QKeySequence(0))
                 action->setToolTip(strippedTooltip);
             else
                 action->setToolTip( strippedTooltip + " (" + action->shortcut().toString() + ")");
         }
     }
 }
 
 void KisPart::openTemplate(const QUrl &url)
 {
     qApp->setOverrideCursor(Qt::BusyCursor);
     KisDocument *document = createDocument();
 
     bool ok = document->loadNativeFormat(url.toLocalFile());
     document->setModified(false);
     document->undoStack()->clear();
 
     if (ok) {
         QString mimeType = KisMimeDatabase::mimeTypeForFile(url.toLocalFile());
         // in case this is a open document template remove the -template from the end
         mimeType.remove( QRegExp( "-template$" ) );
         document->setMimeTypeAfterLoading(mimeType);
         document->resetURL();
         document->setReadWrite(true);
     }
     else {
         if (document->errorMessage().isEmpty()) {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not create document from template\n%1", document->localFilePath()));
         }
         else {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not create document from template\n%1\nReason: %2", document->localFilePath(), document->errorMessage()));
         }
         delete document;
         return;
     }
     addDocument(document);
 
     KisMainWindow *mw = currentMainwindow();
     mw->addViewAndNotifyLoadingCompleted(document);
 
     KisOpenPane *pane = qobject_cast<KisOpenPane*>(sender());
     if (pane) {
         pane->hide();
         pane->deleteLater();
 
     }
 
     qApp->restoreOverrideCursor();
 }
 
 void KisPart::addRecentURLToAllMainWindows(QUrl url)
 {
     // Add to recent actions list in our mainWindows
     Q_FOREACH (KisMainWindow *mainWindow, d->mainWindows) {
         mainWindow->addRecentURL(url);
     }
 }
 
 
 void KisPart::startCustomDocument(KisDocument* doc)
 {
     addDocument(doc);
     KisMainWindow *mw = currentMainwindow();
     KisOpenPane *pane = qobject_cast<KisOpenPane*>(sender());
     if (pane) {
         pane->hide();
         pane->deleteLater();
     }
     mw->addViewAndNotifyLoadingCompleted(doc);
 
 }
 
 KisInputManager* KisPart::currentInputManager()
 {
     KisMainWindow *mw = currentMainwindow();
     KisViewManager *manager = mw ? mw->viewManager() : 0;
     return manager ? manager->inputManager() : 0;
 }
 
 void KisPart::showSessionManager()
 {
     if (d->sessionManager.isNull()) {
         d->sessionManager.reset(new KisSessionManagerDialog());
     }
 
     d->sessionManager->show();
     d->sessionManager->activateWindow();
 }
 
 void KisPart::startBlankSession()
 {
     KisMainWindow *window = createMainWindow();
     window->initializeGeometry();
     window->show();
 
 }
 
 bool KisPart::restoreSession(const QString &sessionName)
 {
     if (sessionName.isNull()) return false;
 
     KoResourceServer<KisSessionResource> * rserver = KisResourceServerProvider::instance()->sessionServer();
     auto *session = rserver->resourceByName(sessionName);
     if (!session || !session->valid()) return false;
 
     session->restore();
 
     return true;
 }
 
 void KisPart::setCurrentSession(KisSessionResource *session)
 {
     d->currentSession = session;
 }
diff --git a/libs/ui/KisPart.h b/libs/ui/KisPart.h
index 66e8ba9f7f..cd87ef398d 100644
--- a/libs/ui/KisPart.h
+++ b/libs/ui/KisPart.h
@@ -1,278 +1,275 @@
 /* This file is part of the KDE project
    Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
    Copyright (C) 2000-2005 David Faure  <faure@kde.org>
    Copyright (C) 2007 Thorsten Zachmann <zachmann@kde.org>
    Copyright (C) 2010 Boudewijn Rempt   <boud@valdyas.org>
    Copyright (C) 2015 Michael Abrahams  <miabraha@gmail.com>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #ifndef KIS_PART_H
 #define KIS_PART_H
 
 #include <QList>
 #include <QPointer>
 #include <QUrl>
 #include <QUuid>
 
 #include "kritaui_export.h"
 #include <KConfigCore/kconfiggroup.h>
 #include <KoConfig.h>
 #include <KisMainWindow.h>
 
 namespace KIO {
 }
 
 class KisAction;
 class KisDocument;
 class KisView;
 class KisDocument;
 class KisIdleWatcher;
 class KisAnimationCachePopulator;
 class KisSessionResource;
 
 /**
- * KisPart is the Great Deku Tree of Krita.
- *
- * It is a singleton class which provides the main entry point to the application.
+ * KisPart a singleton class which provides the main entry point to the application.
  * Krita supports multiple documents, multiple main windows, and multiple
  * components.  KisPart manages these resources and provides them to the rest of
  * Krita.  It manages lists of Actions and shortcuts as well.
  *
  * The terminology comes from KParts, which is a system allowing one KDE app
  * to be run from inside another, like pressing F4 inside dophin to run konsole.
  *
  * Needless to say, KisPart hasn't got much to do with KParts anymore.
  */
 class KRITAUI_EXPORT KisPart : public QObject
 {
     Q_OBJECT
 
 public:
 
     static KisPart *instance();
 
     /**
      * Constructor.
      *
      * @param parent may be another KisDocument, or anything else.
      *        Usually passed by KPluginFactory::create.
      */
     explicit KisPart();
 
     /**
      *  Destructor.
      *
      * The destructor does not delete any attached KisView objects and it does not
      * delete the attached widget as returned by widget().
      */
     ~KisPart() override;
 
     // ----------------- Document management -----------------
 
     /**
      * create an empty document. The document is not automatically registered with the part.
      */
     KisDocument *createDocument() const;
 
     /**
      * Add the specified document to the list of documents this KisPart manages.
      */
     void addDocument(KisDocument *document);
 
     /**
      * @return a list of all documents this part manages
      */
     QList<QPointer<KisDocument> > documents() const;
 
     /**
      * @return number of documents this part manages.
      */
     int documentCount() const;
 
     void removeDocument(KisDocument *document);
 
     // ----------------- MainWindow management -----------------
 
 
     /**
      * Create a new main window.
      */
     KisMainWindow *createMainWindow(QUuid id = QUuid());
 
     /**
      * Removes a main window from the list of managed windows.
      *
      * This is called by the MainWindow after it finishes its shutdown routine.
      */
     void removeMainWindow(KisMainWindow *mainWindow);
 
     /**
      * @return the list of main windows.
      */
     const QList<QPointer<KisMainWindow> >& mainWindows() const;
 
     /**
      * @return the number of shells for the main window
      */
     int mainwindowCount() const;
 
     void addRecentURLToAllMainWindows(QUrl url);
 
     /**
      * @return the currently active main window.
      */
     KisMainWindow *currentMainwindow() const;
 
     KisMainWindow *windowById(QUuid id) const;
 
     /**
      * @return the application-wide KisIdleWatcher.
      */
     KisIdleWatcher *idleWatcher() const;
 
     /**
      * @return the application-wide AnimationCachePopulator.
      */
     KisAnimationCachePopulator *cachePopulator() const;
 
 public Q_SLOTS:
 
     /**
      * This slot loads an existing file.
      * @param url the file to load
      */
     void openExistingFile(const QUrl &url);
 
     /**
      * This slot loads a template and deletes the sender.
      * @param url the template to load
      */
     void openTemplate(const QUrl &url);
 
 
     /**
      * @brief startCustomDocument adds the given document to the document list and deletes the sender()
      * @param doc
      */
     void startCustomDocument(KisDocument *doc);
 
 private Q_SLOTS:
 
     void updateIdleWatcherConnections();
 
     void updateShortcuts();
 
 Q_SIGNALS:
     /**
      * emitted when a new document is opened. (for the idle watcher)
      */
     void documentOpened(const QString &ref);
 
     /**
      * emitted when an old document is closed. (for the idle watcher)
      */
     void documentClosed(const QString &ref);
 
     // These signals are for libkis or sketch
     void sigViewAdded(KisView *view);
     void sigViewRemoved(KisView *view);
     void sigDocumentAdded(KisDocument *document);
     void sigDocumentSaved(const QString &url);
     void sigDocumentRemoved(const QString &filename);
     void sigWindowAdded(KisMainWindow *window);
 
 public:
 
     KisInputManager *currentInputManager();
 
     //------------------ View management ------------------
 
     /**
      * Create a new view for the document. The view is added to the list of
      * views, and if the document wasn't known yet, it's registered as well.
      */
     KisView *createView(KisDocument *document,
-                        KoCanvasResourceProvider *resourceManager,
-                        KActionCollection *actionCollection,
+                        KisViewManager *viewManager,
                         QWidget *parent);
 
     /**
      * Adds a view to the document. If the part doesn't know yet about
      * the document, it is registered.
      *
      * This calls KisView::updateReadWrite to tell the new view
      * whether the document is readonly or not.
      */
     void addView(KisView *view);
 
     /**
      * Removes a view of the document.
      */
     void removeView(KisView *view);
 
     /**
      * @return a list of views this document is displayed in
      */
     QList<QPointer<KisView> > views() const;
 
     /**
      * @return number of views this document is displayed in
      */
     int viewCount(KisDocument *doc) const;
 
     //------------------ Session management ------------------
 
     void showSessionManager();
 
     void startBlankSession();
 
     /**
      * Restores a saved session by name
      */
     bool restoreSession(const QString &sessionName);
 
     void setCurrentSession(KisSessionResource *session);
 
     /**
      * Attempts to save the session and close all windows.
      * This may involve asking the user to save open files.
      * @return false, if closing was cancelled by the user
      */
     bool closeSession(bool keepWindows = false);
 
     /**
      * Are we in the process of closing the application through closeSession().
      */
     bool closingSession() const;
 
     static bool exists();
 
 private Q_SLOTS:
 
     void slotDocumentSaved();
 
 private:
 
     Q_DISABLE_COPY(KisPart)
 
     class Private;
     Private *const d;
 
 };
 
 #endif
diff --git a/libs/ui/KisResourceBundle.cpp b/libs/ui/KisResourceBundle.cpp
index 00d501e2ae..fb4bc40cc3 100644
--- a/libs/ui/KisResourceBundle.cpp
+++ b/libs/ui/KisResourceBundle.cpp
@@ -1,1098 +1,1098 @@
 /*
  *  Copyright (c) 2014 Victor Lafon metabolic.ewilan@hotmail.fr
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "KisResourceBundle.h"
 #include "KisResourceBundleManifest.h"
 
 #include <KoXmlReader.h>
 #include <KoXmlWriter.h>
 #include <KoStore.h>
 #include <KoResourceServerProvider.h>
 #include <KoResourcePaths.h>
 
 #include <QScopedPointer>
 #include <QProcessEnvironment>
 #include <QDate>
 #include <QDir>
 #include <kis_debug.h>
 #include <QBuffer>
 #include <QCryptographicHash>
 #include <QByteArray>
 #include <QPainter>
 #include <QStringList>
 #include <QMessageBox>
 
 #include <resources/KoHashGeneratorProvider.h>
 #include <resources/KoHashGenerator.h>
 #include <KisResourceServerProvider.h>
 #include <kis_workspace_resource.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <kis_brush_server.h>
 
 #include <KritaVersionWrapper.h>
 
 KisResourceBundle::KisResourceBundle(QString const& fileName)
     : KoResource(fileName),
       m_bundleVersion("1")
 {
     setName(QFileInfo(fileName).completeBaseName());
     m_metadata["generator"] = "Krita (" + KritaVersionWrapper::versionString(true) + ")";
 
 }
 
 KisResourceBundle::~KisResourceBundle()
 {
 }
 
 QString KisResourceBundle::defaultFileExtension() const
 {
     return QString(".bundle");
 }
 
 bool KisResourceBundle::load()
 {
     if (filename().isEmpty()) return false;
     QScopedPointer<KoStore> resourceStore(KoStore::createStore(filename(), KoStore::Read, "application/x-krita-resourcebundle", KoStore::Zip));
 
     if (!resourceStore || resourceStore->bad()) {
         warnKrita << "Could not open store on bundle" << filename();
         m_installed = false;
         setValid(false);
         return false;
 
     } else {
 
         m_metadata.clear();
 
         bool toRecreate = false;
         if (resourceStore->open("META-INF/manifest.xml")) {
             if (!m_manifest.load(resourceStore->device())) {
                 warnKrita << "Could not open manifest for bundle" << filename();
                 return false;
             }
             resourceStore->close();
 
             Q_FOREACH (KisResourceBundleManifest::ResourceReference ref, m_manifest.files()) {
                 if (!resourceStore->open(ref.resourcePath)) {
                     warnKrita << "Bundle is broken. File" << ref.resourcePath << "is missing";
                     toRecreate = true;
                 }
                 else {
                     resourceStore->close();
                 }
             }
 
 
             if(toRecreate) {
                 warnKrita << "Due to missing files and wrong entries in the manifest, " << filename() << " will be recreated.";
             }
 
         } else {
             warnKrita << "Could not load META-INF/manifest.xml";
             return false;
         }
 
         bool versionFound = false;
         if (resourceStore->open("meta.xml")) {
             KoXmlDocument doc;
             if (!doc.setContent(resourceStore->device())) {
                 warnKrita << "Could not parse meta.xml for" << filename();
                 return false;
             }
             // First find the manifest:manifest node.
             KoXmlNode n = doc.firstChild();
             for (; !n.isNull(); n = n.nextSibling()) {
                 if (!n.isElement()) {
                     continue;
                 }
                 if (n.toElement().tagName() == "meta:meta") {
                     break;
                 }
             }
 
             if (n.isNull()) {
                 warnKrita << "Could not find manifest node for bundle" << filename();
                 return false;
             }
 
             const KoXmlElement  metaElement = n.toElement();
             for (n = metaElement.firstChild(); !n.isNull(); n = n.nextSibling()) {
                 if (n.isElement()) {
                     KoXmlElement e = n.toElement();
                     if (e.tagName() == "meta:generator") {
                         m_metadata.insert("generator", e.firstChild().toText().data());
                     }
                     else if (e.tagName() == "dc:author") {
                         m_metadata.insert("author", e.firstChild().toText().data());
                     }
                     else if (e.tagName() == "dc:title") {
                         m_metadata.insert("title", e.firstChild().toText().data());
                     }
                     else if (e.tagName() == "dc:description") {
                         m_metadata.insert("description", e.firstChild().toText().data());
                     }
                     else if (e.tagName() == "meta:initial-creator") {
                         m_metadata.insert("author", e.firstChild().toText().data());
                     }
                     else if (e.tagName() == "dc:creator") {
                         m_metadata.insert("author", e.firstChild().toText().data());
                     }
                     else if (e.tagName() == "meta:creation-date") {
                         m_metadata.insert("created", e.firstChild().toText().data());
                     }
                     else if (e.tagName() == "meta:dc-date") {
                         m_metadata.insert("updated", e.firstChild().toText().data());
                     }
                     else if (e.tagName() == "meta:meta-userdefined") {
                         if (e.attribute("meta:name") == "tag") {
                             m_bundletags << e.attribute("meta:value");
                         }
                         else {
                             m_metadata.insert(e.attribute("meta:name"), e.attribute("meta:value"));
                         }
                     }
                     else if(e.tagName() == "meta:bundle-version") {
                         m_metadata.insert("bundle-version", e.firstChild().toText().data());
                         versionFound = true;
                     }
                 }
             }
             resourceStore->close();
         }
         else {
             warnKrita << "Could not load meta.xml";
             return false;
         }
 
         if (resourceStore->open("preview.png")) {
             // Workaround for some OS (Debian, Ubuntu), where loading directly from the QIODevice
             // fails with "libpng error: IDAT: CRC error"
             QByteArray data = resourceStore->device()->readAll();
             QBuffer buffer(&data);
             m_thumbnail.load(&buffer, "PNG");
             resourceStore->close();
         }
         else {
             warnKrita << "Could not open preview.png";
         }
 
         /*
          * If no version is found it's an old bundle with md5 hashes to fix, or if some manifest resource entry
          * doesn't not correspond to a file the bundle is "broken", in both cases we need to recreate the bundle.
          */
         if (!versionFound) {
             m_metadata.insert("bundle-version", "1");
             warnKrita << filename() << " has an old version and possibly wrong resources md5, so it will be recreated.";
             toRecreate = true;
         }
 
         if (toRecreate) {
             recreateBundle(resourceStore);
         }
 
 
         m_installed = true;
         setValid(true);
         setImage(m_thumbnail);
     }
 
     return true;
 }
 
 bool KisResourceBundle::loadFromDevice(QIODevice *)
 {
     return false;
 }
 
 bool saveResourceToStore(KoResource *resource, KoStore *store, const QString &resType)
 {
     if (!resource) {
         warnKrita << "No Resource";
         return false;
     }
 
     if (!resource->valid()) {
         warnKrita << "Resource is not valid";
         return false;
     }
     if (!store || store->bad()) {
         warnKrita << "No Store or Store is Bad";
         return false;
     }
 
     QByteArray ba;
     QBuffer buf;
 
     QFileInfo fi(resource->filename());
     if (fi.exists() && fi.isReadable()) {
 
         QFile f(resource->filename());
         if (!f.open(QFile::ReadOnly)) {
             warnKrita << "Could not open resource" << resource->filename();
             return false;
         }
         ba = f.readAll();
         if (ba.size() == 0) {
             warnKrita << "Resource is empty" << resource->filename();
             return false;
         }
         f.close();
         buf.setBuffer(&ba);
     }
     else {
         warnKrita << "Could not find the resource " << resource->filename() << " or it isn't readable";
         return false;
     }
 
     if (!buf.open(QBuffer::ReadOnly)) {
         warnKrita << "Could not open buffer";
         return false;
     }
     Q_ASSERT(!store->hasFile(resType + "/" + resource->shortFilename()));
     if (!store->open(resType + "/" + resource->shortFilename())) {
         warnKrita << "Could not open file in store for resource";
         return false;
     }
 
     bool res = (store->write(buf.data()) == buf.size());
     store->close();
     return res;
 
 }
 
 bool KisResourceBundle::save()
 {
     if (filename().isEmpty()) return false;
 
-    addMeta("updated", QDate::currentDate().toString("dd/MM/yyyy"));
+    addMeta("updated", QDateTime::currentDateTime().toOffsetFromUtc(0).toString(Qt::ISODate));
 
     QDir bundleDir = KoResourcePaths::saveLocation("data", "bundles");
     bundleDir.cdUp();
 
     QScopedPointer<KoStore> store(KoStore::createStore(filename(), KoStore::Write, "application/x-krita-resourcebundle", KoStore::Zip));
 
     if (!store || store->bad()) return false;
 
     Q_FOREACH (const QString &resType, m_manifest.types()) {
 
         if (resType == "ko_gradients") {
             KoResourceServer<KoAbstractGradient>* gradientServer = KoResourceServerProvider::instance()->gradientServer();
             Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files(resType)) {
                 KoResource *res = gradientServer->resourceByMD5(ref.md5sum);
                 if (!res) res = gradientServer->resourceByFilename(QFileInfo(ref.resourcePath).fileName());
                 if (!saveResourceToStore(res, store.data(), "gradients")) {
                     if (res) {
                         warnKrita << "Could not save resource" << resType << res->name();
                     }
                     else {
                         warnKrita << "could not find resource for" << QFileInfo(ref.resourcePath).fileName();
                     }
                 }
             }
         }
         else if (resType  == "ko_patterns") {
             KoResourceServer<KoPattern>* patternServer = KoResourceServerProvider::instance()->patternServer();
             Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files(resType)) {
                 KoResource *res = patternServer->resourceByMD5(ref.md5sum);
                 if (!res) res = patternServer->resourceByFilename(QFileInfo(ref.resourcePath).fileName());
                 if (!saveResourceToStore(res, store.data(), "patterns")) {
                     if (res) {
                         warnKrita << "Could not save resource" << resType << res->name();
                     }
                     else {
                         warnKrita << "could not find resource for" << QFileInfo(ref.resourcePath).fileName();
                     }
                 }
             }
         }
         else if (resType  == "kis_brushes") {
             KisBrushResourceServer* brushServer = KisBrushServer::instance()->brushServer();
             Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files(resType)) {
                 KisBrushSP brush = brushServer->resourceByMD5(ref.md5sum);
                 if (!brush) brush = brushServer->resourceByFilename(QFileInfo(ref.resourcePath).fileName());
                 KoResource *res = brush.data();
                 if (!saveResourceToStore(res, store.data(), "brushes")) {
                     if (res) {
                         warnKrita << "Could not save resource" << resType << res->name();
                     }
                     else {
                         warnKrita << "could not find resource for" << QFileInfo(ref.resourcePath).fileName();
                     }
                 }
             }
         }
         else if (resType  == "ko_palettes") {
             KoResourceServer<KoColorSet>* paletteServer = KoResourceServerProvider::instance()->paletteServer();
             Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files(resType)) {
                 KoResource *res = paletteServer->resourceByMD5(ref.md5sum);
                 if (!res) res = paletteServer->resourceByFilename(QFileInfo(ref.resourcePath).fileName());
                 if (!saveResourceToStore(res, store.data(), "palettes")) {
                     if (res) {
                         warnKrita << "Could not save resource" << resType << res->name();
                     }
                     else {
                         warnKrita << "could not find resource for" << QFileInfo(ref.resourcePath).fileName();
                     }
                 }
             }
         }
         else if (resType  == "kis_workspaces") {
             KoResourceServer< KisWorkspaceResource >* workspaceServer = KisResourceServerProvider::instance()->workspaceServer();
             Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files(resType)) {
                 KoResource *res = workspaceServer->resourceByMD5(ref.md5sum);
                 if (!res) res = workspaceServer->resourceByFilename(QFileInfo(ref.resourcePath).fileName());
                 if (!saveResourceToStore(res, store.data(), "workspaces")) {
                     if (res) {
                         warnKrita << "Could not save resource" << resType << res->name();
                     }
                     else {
                         warnKrita << "could not find resource for" << QFileInfo(ref.resourcePath).fileName();
                     }
                 }
             }
         }
         else if (resType  == "kis_paintoppresets") {
             KisPaintOpPresetResourceServer* paintoppresetServer = KisResourceServerProvider::instance()->paintOpPresetServer();
             Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files(resType)) {
                 KisPaintOpPresetSP res = paintoppresetServer->resourceByMD5(ref.md5sum);
                 if (!res) res = paintoppresetServer->resourceByFilename(QFileInfo(ref.resourcePath).fileName());
                 if (!saveResourceToStore(res.data(), store.data(), "paintoppresets")) {
                     if (res) {
                         warnKrita << "Could not save resource" << resType << res->name();
                     }
                     else {
                         warnKrita << "could not find resource for" << QFileInfo(ref.resourcePath).fileName();
                     }
                 }
             }
         }
         else if (resType  == "ko_gamutmasks") {
             KoResourceServer<KoGamutMask>* gamutMaskServer = KoResourceServerProvider::instance()->gamutMaskServer();
             Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files(resType)) {
                 KoResource *res = gamutMaskServer->resourceByMD5(ref.md5sum);
                 if (!res) res = gamutMaskServer->resourceByFilename(QFileInfo(ref.resourcePath).fileName());
                 if (!saveResourceToStore(res, store.data(), "gamutmasks")) {
                     if (res) {
                         warnKrita << "Could not save resource" << resType << res->name();
                     }
                     else {
                         warnKrita << "could not find resource for" << QFileInfo(ref.resourcePath).fileName();
                     }
                 }
             }
         }
     }
 
     if (!m_thumbnail.isNull()) {
         QByteArray byteArray;
         QBuffer buffer(&byteArray);
         m_thumbnail.save(&buffer, "PNG");
         if (!store->open("preview.png")) warnKrita << "Could not open preview.png";
         if (store->write(byteArray) != buffer.size()) warnKrita << "Could not write preview.png";
         store->close();
     }
 
     saveManifest(store);
 
     saveMetadata(store);
 
     store->finalize();
 
     return true;
 }
 
 bool KisResourceBundle::saveToDevice(QIODevice */*dev*/) const
 {
     return false;
 }
 
 bool KisResourceBundle::install()
 {
     QStringList md5Mismatch;
     if (filename().isEmpty())  {
         warnKrita << "Cannot install bundle: no file name" << this;
         return false;
     }
     QScopedPointer<KoStore> resourceStore(KoStore::createStore(filename(), KoStore::Read, "application/x-krita-resourcebundle", KoStore::Zip));
 
     if (!resourceStore || resourceStore->bad()) {
         warnKrita << "Cannot open the resource bundle: invalid zip file?";
         return false;
     }
 
     Q_FOREACH (const QString &resType, m_manifest.types()) {
         dbgResources << "Installing resource type" << resType;
         if (resType == "gradients") {
             KoResourceServer<KoAbstractGradient>* gradientServer = KoResourceServerProvider::instance()->gradientServer();
             Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files(resType)) {
 
                 if (resourceStore->isOpen()) resourceStore->close();
 
                 dbgResources << "\tInstalling" << ref.resourcePath;
                 KoAbstractGradient *res = gradientServer->createResource(QString("bundle://%1:%2").arg(filename()).arg(ref.resourcePath));
                 if (!res) {
                     warnKrita << "Could not create resource for" << ref.resourcePath;
                     continue;
                 }
                 if (!resourceStore->open(ref.resourcePath)) {
                     warnKrita << "Failed to open" << ref.resourcePath << "from bundle" << filename();
                     continue;
                 }
                 if (!res->loadFromDevice(resourceStore->device())) {
                     warnKrita << "Failed to load" << ref.resourcePath << "from bundle" << filename();
                     continue;
                 }
                 dbgResources << "\t\tresource:" << res->name();
 
                 KoAbstractGradient *res2 = gradientServer->resourceByName(res->name());
                 if (!res2)  {//if it doesn't exist...
                     gradientServer->addResource(res, false);//add it!
 
                     if (!m_gradientsMd5Installed.contains(res->md5())) {
                         m_gradientsMd5Installed.append(res->md5());
                     }
                     if (ref.md5sum!=res->md5()) {
                         md5Mismatch.append(res->name());
                     }
 
                     Q_FOREACH (const QString &tag, ref.tagList) {
                         gradientServer->addTag(res, tag);
                     }
                     //gradientServer->addTag(res, name());
                 }
                 else {
                     //warnKrita << "Didn't install" << res->name()<<"It already exists on the server";
                 }
 
             }
         }
         else if (resType  == "patterns") {
             KoResourceServer<KoPattern>* patternServer = KoResourceServerProvider::instance()->patternServer();
             Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files(resType)) {
 
                 if (resourceStore->isOpen()) resourceStore->close();
 
                 dbgResources << "\tInstalling" << ref.resourcePath;
                 KoPattern *res = patternServer->createResource(QString("bundle://%1:%2").arg(filename()).arg(ref.resourcePath));
                 if (!res) {
                     warnKrita << "Could not create resource for" << ref.resourcePath;
                     continue;
                 }
                 if (!resourceStore->open(ref.resourcePath)) {
                     warnKrita << "Failed to open" << ref.resourcePath << "from bundle" << filename();
                     continue;
                 }
                 if (!res->loadFromDevice(resourceStore->device())) {
                     warnKrita << "Failed to load" << ref.resourcePath << "from bundle" << filename();
                     continue;
                 }
                 dbgResources << "\t\tresource:" << res->name();
 
                 KoPattern *res2 = patternServer->resourceByName(res->name());
                 if (!res2)  {//if it doesn't exist...
                     patternServer->addResource(res, false);//add it!
 
                     if (!m_patternsMd5Installed.contains(res->md5())) {
                         m_patternsMd5Installed.append(res->md5());
                     }
                     if (ref.md5sum!=res->md5()) {
                         md5Mismatch.append(res->name());
                     }
 
                     Q_FOREACH (const QString &tag, ref.tagList) {
                         patternServer->addTag(res, tag);
                     }
                     //patternServer->addTag(res, name());
                 }
 
             }
         }
         else if (resType  == "brushes") {
             KisBrushResourceServer *brushServer = KisBrushServer::instance()->brushServer();
             Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files(resType)) {
 
                 if (resourceStore->isOpen()) resourceStore->close();
 
                 dbgResources << "\tInstalling" << ref.resourcePath;
                 KisBrushSP res = brushServer->createResource(QString("bundle://%1:%2").arg(filename()).arg(ref.resourcePath));
                 if (!res) {
                     warnKrita << "Could not create resource for" << ref.resourcePath;
                     continue;
                 }
                 if (!resourceStore->open(ref.resourcePath)) {
                     warnKrita << "Failed to open" << ref.resourcePath << "from bundle" << filename();
                     continue;
                 }
                 if (!res->loadFromDevice(resourceStore->device())) {
                     warnKrita << "Failed to load" << ref.resourcePath << "from bundle" << filename();
                     continue;
                 }
                 dbgResources << "\t\tresource:" << res->name();
 
                 //find the resource on the server
                 KisBrushSP res2 = brushServer->resourceByName(res->name());
                 if (res2) {
                     res->setName(res->name()+"("+res->shortFilename()+")");
                 }
                 // file name is more important than the regular name because the
                 // it is the way how it is called up from the brushpreset settings.
                 // Therefore just adjust the resource name and only refuse to load
                 // when the filename is different.
                 res2 = brushServer->resourceByFilename(res->shortFilename());
                 if (!res2)  {//if it doesn't exist...
                     brushServer->addResource(res, false);//add it!
 
                     if (!m_brushesMd5Installed.contains(res->md5())) {
                         m_brushesMd5Installed.append(res->md5());
                     }
                     if (ref.md5sum!=res->md5()) {
                         md5Mismatch.append(res->name());
                     }
 
                     Q_FOREACH (const QString &tag, ref.tagList) {
                         brushServer->addTag(res.data(), tag);
                     }
                     //brushServer->addTag(res.data(), name());
                 }
                 else {
                     //warnKrita << "Didn't install" << res->name()<<"It already exists on the server";
                 }
             }
         }
         else if (resType  == "palettes") {
             KoResourceServer<KoColorSet>* paletteServer = KoResourceServerProvider::instance()->paletteServer();
             Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files(resType)) {
 
                 if (resourceStore->isOpen()) resourceStore->close();
 
                 dbgResources << "\tInstalling" << ref.resourcePath;
                 KoColorSet *res = paletteServer->createResource(QString("bundle://%1:%2").arg(filename()).arg(ref.resourcePath));
 
                 if (!res) {
                     warnKrita << "Could not create resource for" << ref.resourcePath;
                     continue;
                 }
                 if (!resourceStore->open(ref.resourcePath)) {
                     warnKrita << "Failed to open" << ref.resourcePath << "from bundle" << filename();
                     continue;
                 }
                 if (!res->loadFromDevice(resourceStore->device())) {
                     warnKrita << "Failed to load" << ref.resourcePath << "from bundle" << filename();
                     continue;
                 }
                 dbgResources << "\t\tresource:" << res->name();
 
                 //find the resource on the server
                 KoColorSet *res2 = paletteServer->resourceByName(res->name());
                 if (!res2)  {//if it doesn't exist...
                     paletteServer->addResource(res, false);//add it!
 
                     if (!m_palettesMd5Installed.contains(res->md5())) {
                         m_palettesMd5Installed.append(res->md5());
                     }
                     if (ref.md5sum!=res->md5()) {
                         md5Mismatch.append(res->name());
                     }
 
                     Q_FOREACH (const QString &tag, ref.tagList) {
                         paletteServer->addTag(res, tag);
                     }
                     //paletteServer->addTag(res, name());
                 }
                 else {
                     //warnKrita << "Didn't install" << res->name()<<"It already exists on the server";
                 }
             }
         }
         else if (resType  == "workspaces") {
             KoResourceServer< KisWorkspaceResource >* workspaceServer = KisResourceServerProvider::instance()->workspaceServer();
             Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files(resType)) {
 
                 if (resourceStore->isOpen()) resourceStore->close();
 
                 dbgResources << "\tInstalling" << ref.resourcePath;
                 KisWorkspaceResource *res = workspaceServer->createResource(QString("bundle://%1:%2").arg(filename()).arg(ref.resourcePath));
                 if (!res) {
                     warnKrita << "Could not create resource for" << ref.resourcePath;
                     continue;
                 }
                 if (!resourceStore->open(ref.resourcePath)) {
                     warnKrita << "Failed to open" << ref.resourcePath << "from bundle" << filename();
                     continue;
                 }
                 if (!res->loadFromDevice(resourceStore->device())) {
                     warnKrita << "Failed to load" << ref.resourcePath << "from bundle" << filename();
                     continue;
                 }
                 dbgResources << "\t\tresource:" << res->name();
 
                 //the following tries to find the resource by name.
                 KisWorkspaceResource *res2 = workspaceServer->resourceByName(res->name());
                 if (!res2)  {//if it doesn't exist...
                     workspaceServer->addResource(res, false);//add it!
 
                     if (!m_workspacesMd5Installed.contains(res->md5())) {
                         m_workspacesMd5Installed.append(res->md5());
                     }
                     if (ref.md5sum!=res->md5()) {
                         md5Mismatch.append(res->name());
                     }
 
                     Q_FOREACH (const QString &tag, ref.tagList) {
                         workspaceServer->addTag(res, tag);
                     }
                     //workspaceServer->addTag(res, name());
                 }
                 else {
                     //warnKrita << "Didn't install" << res->name()<<"It already exists on the server";
                 }
 
             }
         }
         else if (resType  == "paintoppresets") {
             KisPaintOpPresetResourceServer*  paintoppresetServer = KisResourceServerProvider::instance()->paintOpPresetServer();
             Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files(resType)) {
 
                 if (resourceStore->isOpen()) resourceStore->close();
 
                 dbgResources << "\tInstalling" << ref.resourcePath;
                 KisPaintOpPresetSP res = paintoppresetServer->createResource(QString("bundle://%1:%2").arg(filename()).arg(ref.resourcePath));
 
                 if (!res) {
                     warnKrita << "Could not create resource for" << ref.resourcePath;
                     continue;
                 }
                 if (!resourceStore->open(ref.resourcePath)) {
                     warnKrita << "Failed to open" << ref.resourcePath << "from bundle" << filename();
                     continue;
                 }
                 // Workaround for some OS (Debian, Ubuntu), where loading directly from the QIODevice
                 // fails with "libpng error: IDAT: CRC error"
                 QByteArray data = resourceStore->device()->readAll();
                 QBuffer buffer(&data);
                 if (!res->loadFromDevice(&buffer)) {
                     warnKrita << "Failed to load" << ref.resourcePath << "from bundle" << filename();
                     continue;
                 }
                 dbgResources << "\t\tresource:" << res->name() << "File:" << res->filename();
 
                 //the following tries to find the resource by name.
                 KisPaintOpPresetSP res2 = paintoppresetServer->resourceByName(res->name());
                 if (!res2)  {//if it doesn't exist...
                     paintoppresetServer->addResource(res, false);//add it!
                     if (!m_presetsMd5Installed.contains(res->md5())){
                         m_presetsMd5Installed.append(res->md5());
                     }
                     if (ref.md5sum!=res->md5()) {
                         md5Mismatch.append(res->name());
                     }
 
                     Q_FOREACH (const QString &tag, ref.tagList) {
                         paintoppresetServer->addTag(res.data(), tag);
                     }
                     //paintoppresetServer->addTag(res.data(), name());
                 }
                 else {
                     //warnKrita << "Didn't install" << res->name()<<"It already exists on the server";
                 }
 
             }
         }
         else if (resType  == "gamutmasks") {
             KoResourceServer<KoGamutMask>* gamutMaskServer = KoResourceServerProvider::instance()->gamutMaskServer();
             Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files(resType)) {
 
                 if (resourceStore->isOpen()) resourceStore->close();
 
                 dbgResources << "\tInstalling" << ref.resourcePath;
                 KoGamutMask *res = gamutMaskServer->createResource(QString("bundle://%1:%2").arg(filename()).arg(ref.resourcePath));
 
                 if (!res) {
                     warnKrita << "Could not create resource for" << ref.resourcePath;
                     continue;
                 }
                 if (!resourceStore->open(ref.resourcePath)) {
                     warnKrita << "Failed to open" << ref.resourcePath << "from bundle" << filename();
                     continue;
                 }
                 if (!res->loadFromDevice(resourceStore->device())) {
                     warnKrita << "Failed to load" << ref.resourcePath << "from bundle" << filename();
                     continue;
                 }
                 dbgResources << "\t\tresource:" << res->name();
 
                 //find the resource on the server
                 KoGamutMask *res2 = gamutMaskServer->resourceByName(res->name());
                 if (!res2)  {//if it doesn't exist...
                     gamutMaskServer->addResource(res, false);//add it!
 
                     if (!m_gamutMasksMd5Installed.contains(res->md5())) {
                         m_gamutMasksMd5Installed.append(res->md5());
                     }
                     if (ref.md5sum!=res->md5()) {
                         md5Mismatch.append(res->name());
                     }
 
                     Q_FOREACH (const QString &tag, ref.tagList) {
                         gamutMaskServer->addTag(res, tag);
                     }
                     //gamutMaskServer->addTag(res, name());
                 }
                 else {
                     //warnKrita << "Didn't install" << res->name()<<"It already exists on the server";
                 }
             }
         }
     }
     m_installed = true;
     if(!md5Mismatch.isEmpty()){
         QString message = i18n("The following resources had mismatching MD5 sums. They may have gotten corrupted, for example, during download.");
         QMessageBox bundleFeedback;
         bundleFeedback.setIcon(QMessageBox::Warning);
         Q_FOREACH (QString name, md5Mismatch) {
             message.append("\n");
             message.append(name);
         }
         bundleFeedback.setText(message);
         bundleFeedback.exec();
     }
     return true;
 }
 
 bool KisResourceBundle::uninstall()
 {
 
     m_installed = false;
     QStringList tags = getTagsList();
     tags << m_manifest.tags();
     //tags << name();
 
     KoResourceServer<KoAbstractGradient>* gradientServer = KoResourceServerProvider::instance()->gradientServer();
     //Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files("gradients")) {
     Q_FOREACH (const QByteArray md5, m_gradientsMd5Installed) {
         KoAbstractGradient *res = gradientServer->resourceByMD5(md5);
         if (res) {
             gradientServer->removeResourceFromServer(res);
         }
     }
 
     KoResourceServer<KoPattern>* patternServer = KoResourceServerProvider::instance()->patternServer();
     //Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files("patterns")) {
     Q_FOREACH (const QByteArray md5, m_patternsMd5Installed) {
         KoPattern *res = patternServer->resourceByMD5(md5);
         if (res) {
             patternServer->removeResourceFromServer(res);
         }
     }
 
     KisBrushResourceServer *brushServer = KisBrushServer::instance()->brushServer();
     //Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files("brushes")) {
     Q_FOREACH (const QByteArray md5, m_brushesMd5Installed) {
         KisBrushSP res = brushServer->resourceByMD5(md5);
         if (res) {
             brushServer->removeResourceFromServer(res);
         }
     }
 
     KoResourceServer<KoColorSet>* paletteServer = KoResourceServerProvider::instance()->paletteServer();
     //Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files("palettes")) {
     Q_FOREACH (const QByteArray md5, m_palettesMd5Installed) {
         KoColorSet *res = paletteServer->resourceByMD5(md5);
         if (res) {
             paletteServer->removeResourceFromServer(res);
         }
     }
 
     KoResourceServer< KisWorkspaceResource >* workspaceServer = KisResourceServerProvider::instance()->workspaceServer();
     //Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files("workspaces")) {
     Q_FOREACH (const QByteArray md5, m_workspacesMd5Installed) {
         KisWorkspaceResource *res = workspaceServer->resourceByMD5(md5);
         if (res) {
             workspaceServer->removeResourceFromServer(res);
         }
     }
     KisPaintOpPresetResourceServer* paintoppresetServer = KisResourceServerProvider::instance()->paintOpPresetServer();
     //Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files("paintoppresets")) {
     Q_FOREACH (const QByteArray md5, m_presetsMd5Installed) {
         KisPaintOpPresetSP res = paintoppresetServer->resourceByMD5(md5);
         if (res) {
             paintoppresetServer->removeResourceFromServer(res);
         }
     }
 
     KoResourceServer<KoGamutMask>* gamutMaskServer = KoResourceServerProvider::instance()->gamutMaskServer();
     //Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, m_manifest.files("gamutmasks")) {
     Q_FOREACH (const QByteArray md5, m_gamutMasksMd5Installed) {
         KoGamutMask *res = gamutMaskServer->resourceByMD5(md5);
         if (res) {
             gamutMaskServer->removeResourceFromServer(res);
         }
     }
 
     Q_FOREACH(const QString &tag, tags) {
         paintoppresetServer->tagCategoryRemoved(tag);
         workspaceServer->tagCategoryRemoved(tag);
         paletteServer->tagCategoryRemoved(tag);
         brushServer->tagCategoryRemoved(tag);
         patternServer->tagCategoryRemoved(tag);
         gradientServer->tagCategoryRemoved(tag);
         gamutMaskServer->tagCategoryRemoved(tag);
     }
 
 
     return true;
 }
 
 void KisResourceBundle::addMeta(const QString &type, const QString &value)
 {
     m_metadata.insert(type, value);
 }
 
 const QString KisResourceBundle::getMeta(const QString &type, const QString &defaultValue) const
 {
     if (m_metadata.contains(type)) {
         return m_metadata[type];
     }
     else {
         return defaultValue;
     }
 }
 
 void KisResourceBundle::addResource(QString fileType, QString filePath, QStringList fileTagList, const QByteArray md5sum)
 {
     m_manifest.addResource(fileType, filePath, fileTagList, md5sum);
 }
 
 QList<QString> KisResourceBundle::getTagsList()
 {
     return QList<QString>::fromSet(m_bundletags);
 }
 
 
 bool KisResourceBundle::isInstalled()
 {
     return m_installed;
 }
 
 
 QStringList KisResourceBundle::resourceTypes() const
 {
     return m_manifest.types();
 }
 
 QList<KoResource*> KisResourceBundle::resources(const QString &resType) const
 {
     QList<KisResourceBundleManifest::ResourceReference> references = m_manifest.files(resType);
 
     QList<KoResource*> ret;
     Q_FOREACH (const KisResourceBundleManifest::ResourceReference &ref, references) {
         if (resType == "gradients") {
             KoResourceServer<KoAbstractGradient>* gradientServer = KoResourceServerProvider::instance()->gradientServer();
             KoResource *res =  gradientServer->resourceByMD5(ref.md5sum);
             if (res) ret << res;
         }
         else if (resType  == "patterns") {
             KoResourceServer<KoPattern>* patternServer = KoResourceServerProvider::instance()->patternServer();
             KoResource *res =  patternServer->resourceByMD5(ref.md5sum);
             if (res) ret << res;
         }
         else if (resType  == "brushes") {
             KisBrushResourceServer *brushServer = KisBrushServer::instance()->brushServer();
             KoResource *res =  brushServer->resourceByMD5(ref.md5sum).data();
             if (res) ret << res;
         }
         else if (resType  == "palettes") {
             KoResourceServer<KoColorSet>* paletteServer = KoResourceServerProvider::instance()->paletteServer();
             KoResource *res =  paletteServer->resourceByMD5(ref.md5sum);
             if (res) ret << res;
         }
         else if (resType  == "workspaces") {
             KoResourceServer< KisWorkspaceResource >* workspaceServer = KisResourceServerProvider::instance()->workspaceServer();
             KoResource *res =  workspaceServer->resourceByMD5(ref.md5sum);
             if (res) ret << res;
         }
         else if (resType  == "paintoppresets") {
             KisPaintOpPresetResourceServer* paintoppresetServer = KisResourceServerProvider::instance()->paintOpPresetServer();
             KisPaintOpPresetSP res =  paintoppresetServer->resourceByMD5(ref.md5sum);
             if (res) ret << res.data();
         }
         else if (resType  == "gamutmasks") {
             KoResourceServer<KoGamutMask>* gamutMaskServer = KoResourceServerProvider::instance()->gamutMaskServer();
             KoResource *res =  gamutMaskServer->resourceByMD5(ref.md5sum);
             if (res) ret << res;
         }
     }
     return ret;
 }
 
 void KisResourceBundle::setThumbnail(QString filename)
 {
     if (QFileInfo(filename).exists()) {
         m_thumbnail = QImage(filename);
         m_thumbnail = m_thumbnail.scaled(256, 256, Qt::KeepAspectRatio, Qt::SmoothTransformation);
     }
     else {
         m_thumbnail = QImage(256, 256, QImage::Format_ARGB32);
         QPainter gc(&m_thumbnail);
         gc.fillRect(0, 0, 256, 256, Qt::red);
         gc.end();
     }
 
     setImage(m_thumbnail);
 }
 
 void KisResourceBundle::writeMeta(const char *metaTag, const QString &metaKey, KoXmlWriter *writer)
 {
     if (m_metadata.contains(metaKey)) {
         writer->startElement(metaTag);
         writer->addTextNode(m_metadata[metaKey].toUtf8());
         writer->endElement();
     }
 }
 
 void KisResourceBundle::writeUserDefinedMeta(const QString &metaKey, KoXmlWriter *writer)
 {
     if (m_metadata.contains(metaKey)) {
         writer->startElement("meta:meta-userdefined");
         writer->addAttribute("meta:name", metaKey);
         writer->addAttribute("meta:value", m_metadata[metaKey]);
         writer->endElement();
     }
 }
 
 void KisResourceBundle::setInstalled(bool install)
 {
     m_installed = install;
 }
 
 void KisResourceBundle::saveMetadata(QScopedPointer<KoStore> &store)
 {
     QBuffer buf;
 
     store->open("meta.xml");
     buf.open(QBuffer::WriteOnly);
 
     KoXmlWriter metaWriter(&buf);
     metaWriter.startDocument("office:document-meta");
     metaWriter.startElement("meta:meta");
 
     writeMeta("meta:generator", "generator", &metaWriter);
 
     metaWriter.startElement("meta:bundle-version");
     metaWriter.addTextNode(m_bundleVersion.toUtf8());
     metaWriter.endElement();
 
     writeMeta("dc:author", "author", &metaWriter);
     writeMeta("dc:title", "filename", &metaWriter);
     writeMeta("dc:description", "description", &metaWriter);
     writeMeta("meta:initial-creator", "author", &metaWriter);
     writeMeta("dc:creator", "author", &metaWriter);
     writeMeta("meta:creation-date", "created", &metaWriter);
     writeMeta("meta:dc-date", "updated", &metaWriter);
     writeUserDefinedMeta("email", &metaWriter);
     writeUserDefinedMeta("license", &metaWriter);
     writeUserDefinedMeta("website", &metaWriter);
     Q_FOREACH (const QString &tag, m_bundletags) {
         metaWriter.startElement("meta:meta-userdefined");
         metaWriter.addAttribute("meta:name", "tag");
         metaWriter.addAttribute("meta:value", tag);
         metaWriter.endElement();
     }
 
     metaWriter.endElement(); // meta:meta
     metaWriter.endDocument();
 
     buf.close();
     store->write(buf.data());
     store->close();
 }
 
 void KisResourceBundle::saveManifest(QScopedPointer<KoStore> &store)
 {
     store->open("META-INF/manifest.xml");
     QBuffer buf;
     buf.open(QBuffer::WriteOnly);
     m_manifest.save(&buf);
     buf.close();
     store->write(buf.data());
     store->close();
 }
 
 void KisResourceBundle::recreateBundle(QScopedPointer<KoStore> &oldStore)
 {
     // Save a copy of the unmodified bundle, so that if anything goes bad the user doesn't lose it
     QFile file(filename());
     file.copy(filename() + ".old");
 
     QString newStoreName = filename() + ".tmp";
     {
         QScopedPointer<KoStore> store(KoStore::createStore(newStoreName, KoStore::Write, "application/x-krita-resourcebundle", KoStore::Zip));
         KoHashGenerator *generator = KoHashGeneratorProvider::instance()->getGenerator("MD5");
         KisResourceBundleManifest newManifest;
 
-        addMeta("updated", QDate::currentDate().toString("dd/MM/yyyy"));
+        addMeta("updated", QDateTime::currentDateTime().toString(Qt::ISODate));
 
         Q_FOREACH (KisResourceBundleManifest::ResourceReference ref, m_manifest.files()) {
             // Wrong manifest entry found, skip it
             if(!oldStore->open(ref.resourcePath))
                 continue;
 
             store->open(ref.resourcePath);
 
             QByteArray data = oldStore->device()->readAll();
             oldStore->close();
             store->write(data);
             store->close();
             QByteArray result = generator->generateHash(data);
             newManifest.addResource(ref.fileTypeName, ref.resourcePath, ref.tagList, result);
         }
 
         m_manifest = newManifest;
 
         if (!m_thumbnail.isNull()) {
             QByteArray byteArray;
             QBuffer buffer(&byteArray);
             m_thumbnail.save(&buffer, "PNG");
             if (!store->open("preview.png")) warnKrita << "Could not open preview.png";
             if (store->write(byteArray) != buffer.size()) warnKrita << "Could not write preview.png";
             store->close();
         }
 
         saveManifest(store);
         saveMetadata(store);
 
         store->finalize();
     }
     // Remove the current bundle and then move the tmp one to be the correct one
     file.setFileName(filename());
     if (!file.remove()) {
         qWarning() << "Could not remove" << filename() << file.errorString();
     }
     QFile f(newStoreName);
     Q_ASSERT(f.exists());
     if (!f.copy(filename())) {
         qWarning() << "Could not copy the tmp file to the store" << filename() << newStoreName << QFile(newStoreName).exists() << f.errorString();
     }
 }
 
 
 int KisResourceBundle::resourceCount() const
 {
     return m_manifest.files().count();
 }
diff --git a/libs/ui/KisTemplatesPane.cpp b/libs/ui/KisTemplatesPane.cpp
index b971016f89..12de18c395 100644
--- a/libs/ui/KisTemplatesPane.cpp
+++ b/libs/ui/KisTemplatesPane.cpp
@@ -1,192 +1,189 @@
 /* This file is part of the KDE project
    Copyright (C) 2005-2006 Peter Simonsson <psn@linux.se>
 
    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 "KisTemplatesPane.h"
 
 #include "KisTemplateGroup.h"
 #include "KisTemplate.h"
 
 #include <QFileInfo>
 #include <QStandardItemModel>
 #include <QUrl>
 
 #include <kguiitem.h>
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 
 class KisTemplatesPanePrivate
 {
 public:
     KisTemplatesPanePrivate()
         : m_selected(false) {
     }
 
     bool m_selected;
     QString m_alwaysUseTemplate;
 };
 
 
 KisTemplatesPane::KisTemplatesPane(QWidget* parent, const QString& header,
                                    KisTemplateGroup *group, KisTemplate* defaultTemplate)
     : KisDetailsPane(parent,header)
     , d(new KisTemplatesPanePrivate)
 {
     setFocusProxy(m_documentList);
 
     KGuiItem openGItem(i18n("Use This Template"));
     KGuiItem::assign(m_openButton, openGItem);
     KConfigGroup cfgGrp( KSharedConfig::openConfig(), "TemplateChooserDialog");
     QString fullTemplateName = cfgGrp.readPathEntry("FullTemplateName", QString());
 
 
     d->m_alwaysUseTemplate = cfgGrp.readPathEntry("AlwaysUseTemplate", QString());
     m_alwaysUseCheckBox->setVisible(false);
     connect(m_alwaysUseCheckBox, SIGNAL(clicked()), this, SLOT(alwaysUseClicked()));
 
     QStandardItem* selectItem = 0;
     QStandardItem* rootItem = model()->invisibleRootItem();
     QStandardItem* defaultItem = 0;
 
     QFileInfo templateFileInfo(fullTemplateName);
 
     Q_FOREACH (KisTemplate* t, group->templates()) {
         if (t->isHidden())
             continue;
 
         QPixmap preview = t->loadPicture();
         QImage icon = preview.toImage();
         icon = icon.scaled(IconExtent, IconExtent, Qt::KeepAspectRatio, Qt::SmoothTransformation);
         icon = icon.convertToFormat(QImage::Format_ARGB32);
         icon = icon.copy((icon.width() - IconExtent) / 2, (icon.height() - IconExtent) / 2, IconExtent, IconExtent);
         QStandardItem* item = new QStandardItem(QPixmap::fromImage(icon), t->name());
         item->setEditable(false);
         item->setData(t->description(), Qt::UserRole);
         item->setData(t->file(), Qt::UserRole + 1);
         item->setData(preview, Qt::UserRole + 2);
         rootItem->appendRow(item);
 
 		if (templateFileInfo.exists()) {
 			if (!selectItem && (t->file() == fullTemplateName)) {
 				selectItem = item;
 			}
 		}
 		else {
 			if (!selectItem && QFileInfo(t->file()).fileName() == templateFileInfo.fileName()) {
 				selectItem = item;
 			}
 		}
 
         if (defaultTemplate && (t->file() == defaultTemplate->file())) {
             defaultItem = item;
         }
     }
 
     QModelIndex selectedIndex;
 
     if (selectItem) {
         selectedIndex = model()->indexFromItem(selectItem);
         d->m_selected = true;
     } else if (defaultItem) {
         selectedIndex = model()->indexFromItem(defaultItem);
     } else {
         selectedIndex = model()->indexFromItem(model()->item(0));
     }
 
     m_documentList->selectionModel()->select(selectedIndex, QItemSelectionModel::Select);
     m_documentList->selectionModel()->setCurrentIndex(selectedIndex, QItemSelectionModel::Select);
 }
 
 KisTemplatesPane::~KisTemplatesPane()
 {
     delete d;
 }
 
 void KisTemplatesPane::selectionChanged(const QModelIndex& index)
 {
     if (index.isValid()) {
         QStandardItem* item = model()->itemFromIndex(index);
         m_openButton->setEnabled(true);
         m_alwaysUseCheckBox->setEnabled(true);
-        m_titleLabel->setText(item->data(Qt::DisplayRole).toString());
-        m_previewLabel->setPixmap(item->data(Qt::UserRole + 2).value<QPixmap>());
+
         m_detailsLabel->setHtml(item->data(Qt::UserRole).toString());
         m_alwaysUseCheckBox->setChecked(item->data(Qt::UserRole + 1).toString() == d->m_alwaysUseTemplate);
     } else {
         m_openButton->setEnabled(false);
         m_alwaysUseCheckBox->setEnabled(false);
         m_alwaysUseCheckBox->setChecked(false);
-        m_titleLabel->clear();
-        m_previewLabel->setPixmap(QPixmap());
         m_detailsLabel->clear();
     }
 }
 
 void KisTemplatesPane::openFile()
 {
     KisDetailsPane::openFile();
 }
 
 void KisTemplatesPane::openFile(const QModelIndex& index)
 {
     if (index.isValid()) {
         QStandardItem* item = model()->itemFromIndex(index);
         KConfigGroup cfgGrp( KSharedConfig::openConfig(), "TemplateChooserDialog");
         cfgGrp.writePathEntry("FullTemplateName", item->data(Qt::UserRole + 1).toString());
         cfgGrp.writeEntry("LastReturnType", "Template");
         cfgGrp.writeEntry("AlwaysUseTemplate", d->m_alwaysUseTemplate);
         emit openUrl(QUrl::fromLocalFile(item->data(Qt::UserRole + 1).toString()));
     }
 }
 
 bool KisTemplatesPane::isSelected()
 {
     return d->m_selected;
 }
 
 void KisTemplatesPane::alwaysUseClicked()
 {
     QStandardItem* item = model()->itemFromIndex(m_documentList->selectionModel()->currentIndex());
 
     if (!m_alwaysUseCheckBox->isChecked()) {
         d->m_alwaysUseTemplate.clear();
     } else {
         d->m_alwaysUseTemplate = item->data(Qt::UserRole + 1).toString();
     }
 
     KConfigGroup cfgGrp( KSharedConfig::openConfig(), "TemplateChooserDialog");
     cfgGrp.writeEntry("AlwaysUseTemplate", d->m_alwaysUseTemplate);
     cfgGrp.sync();
     emit alwaysUseChanged(this, d->m_alwaysUseTemplate);
 }
 
 void KisTemplatesPane::changeAlwaysUseTemplate(KisTemplatesPane* sender, const QString& alwaysUse)
 {
     if (this == sender)
         return;
 
     QStandardItem* item = model()->itemFromIndex(m_documentList->selectionModel()->currentIndex());
 
     // If the old always use template is selected uncheck the checkbox
     if (item && (item->data(Qt::UserRole + 1).toString() == d->m_alwaysUseTemplate)) {
         m_alwaysUseCheckBox->setChecked(false);
     }
 
     d->m_alwaysUseTemplate = alwaysUse;
 }
 
diff --git a/libs/ui/KisView.cpp b/libs/ui/KisView.cpp
index c5d99788d4..0c63032972 100644
--- a/libs/ui/KisView.cpp
+++ b/libs/ui/KisView.cpp
@@ -1,1062 +1,1062 @@
 /*
  * Copyright (C) 2014 Boudewijn Rempt <boud@valdyas.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "KisView.h"
 
 #include "KisView_p.h"
 
 #include <KoDockFactoryBase.h>
 #include <KoDockRegistry.h>
 #include <KoDocumentInfo.h>
 #include "KoPageLayout.h"
 #include <KoToolManager.h>
 
 #include <kis_icon.h>
 
 #include <kactioncollection.h>
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 #include <kselectaction.h>
 #include <kconfiggroup.h>
 
 #include <QMenu>
 #include <QMessageBox>
 #include <QUrl>
 #include <QTemporaryFile>
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QDockWidget>
 #include <QDragEnterEvent>
 #include <QDropEvent>
 #include <QImage>
 #include <QList>
 #include <QPrintDialog>
 #include <QToolBar>
 #include <QStatusBar>
 #include <QMoveEvent>
 #include <QMdiSubWindow>
 
 #include <kis_image.h>
 #include <kis_node.h>
 
 #include <kis_group_layer.h>
 #include <kis_layer.h>
 #include <kis_mask.h>
 #include <kis_selection.h>
 
 #include "kis_canvas2.h"
 #include "kis_canvas_controller.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_config.h"
 #include "KisDocument.h"
 #include "kis_image_manager.h"
 #include "KisMainWindow.h"
 #include "kis_mimedata.h"
 #include "kis_mirror_axis.h"
 #include "kis_node_commands_adapter.h"
 #include "kis_node_manager.h"
 #include "KisPart.h"
 #include "KisPrintJob.h"
 #include "kis_shape_controller.h"
 #include "kis_tool_freehand.h"
 #include "KisViewManager.h"
 #include "kis_zoom_manager.h"
 #include "kis_statusbar.h"
 #include "kis_painting_assistants_decoration.h"
 #include "KisReferenceImagesDecoration.h"
 #include "kis_progress_widget.h"
 #include "kis_signal_compressor.h"
 #include "kis_filter_manager.h"
 #include "kis_file_layer.h"
 #include "krita_utils.h"
 #include "input/kis_input_manager.h"
 #include "KisRemoteFileFetcher.h"
 #include "kis_selection_manager.h"
 
 //static
 QString KisView::newObjectName()
 {
     static int s_viewIFNumber = 0;
     QString name; name.setNum(s_viewIFNumber++); name.prepend("view_");
     return name;
 }
 
 bool KisView::s_firstView = true;
 
 class Q_DECL_HIDDEN KisView::Private
 {
 public:
     Private(KisView *_q,
             KisDocument *document,
-            KoCanvasResourceProvider *resourceManager,
-            KActionCollection *actionCollection)
-        : actionCollection(actionCollection)
+            KisViewManager *viewManager)
+        : actionCollection(viewManager->actionCollection())
         , viewConverter()
-        , canvasController(_q, actionCollection)
-        , canvas(&viewConverter, resourceManager, _q, document->shapeController())
+        , canvasController(_q, viewManager->mainWindow(), viewManager->actionCollection())
+        , canvas(&viewConverter, viewManager->canvasResourceProvider()->resourceManager(), viewManager->mainWindow(), _q, document->shapeController())
         , zoomManager(_q, &this->viewConverter, &this->canvasController)
+        , viewManager(viewManager)
         , paintingAssistantsDecoration(new KisPaintingAssistantsDecoration(_q))
         , referenceImagesDecoration(new KisReferenceImagesDecoration(_q, document))
         , floatingMessageCompressor(100, KisSignalCompressor::POSTPONE)
     {
     }
 
     bool inOperation; //in the middle of an operation (no screen refreshing)?
 
     QPointer<KisDocument> document; // our KisDocument
     QWidget *tempActiveWidget = 0;
 
     /**
      * Signals the document has been deleted. Can't use document==0 since this
      * only happens in ~QObject, and views get deleted by ~KisDocument.
      * XXX: either provide a better justification to do things this way, or
      * rework the mechanism.
      */
     bool documentDeleted = false;
 
     KActionCollection* actionCollection;
     KisCoordinatesConverter viewConverter;
     KisCanvasController canvasController;
     KisCanvas2 canvas;
     KisZoomManager zoomManager;
     KisViewManager *viewManager = 0;
     KisNodeSP currentNode;
     KisPaintingAssistantsDecorationSP paintingAssistantsDecoration;
     KisReferenceImagesDecorationSP referenceImagesDecoration;
     bool isCurrent = false;
     bool showFloatingMessage = false;
     QPointer<KisFloatingMessage> savedFloatingMessage;
     KisSignalCompressor floatingMessageCompressor;
     QMdiSubWindow *subWindow{nullptr};
 
     bool softProofing = false;
     bool gamutCheck = false;
 
     // Hmm sorry for polluting the private class with such a big inner class.
     // At the beginning it was a little struct :)
     class StatusBarItem
     {
     public:
 
         StatusBarItem(QWidget * widget, int stretch, bool permanent)
             : m_widget(widget),
               m_stretch(stretch),
               m_permanent(permanent),
               m_connected(false),
               m_hidden(false) {}
 
         bool operator==(const StatusBarItem& rhs) {
             return m_widget == rhs.m_widget;
         }
 
         bool operator!=(const StatusBarItem& rhs) {
             return m_widget != rhs.m_widget;
         }
 
         QWidget * widget() const {
             return m_widget;
         }
 
         void ensureItemShown(QStatusBar * sb) {
             Q_ASSERT(m_widget);
             if (!m_connected) {
                 if (m_permanent)
                     sb->addPermanentWidget(m_widget, m_stretch);
                 else
                     sb->addWidget(m_widget, m_stretch);
 
                 if(!m_hidden)
                     m_widget->show();
 
                 m_connected = true;
             }
         }
         void ensureItemHidden(QStatusBar * sb) {
             if (m_connected) {
                 m_hidden = m_widget->isHidden();
                 sb->removeWidget(m_widget);
                 m_widget->hide();
                 m_connected = false;
             }
         }
     private:
         QWidget * m_widget = 0;
         int m_stretch;
         bool m_permanent;
         bool m_connected = false;
         bool m_hidden = false;
 
     };
 
 };
 
-KisView::KisView(KisDocument *document, KoCanvasResourceProvider *resourceManager, KActionCollection *actionCollection, QWidget *parent)
+KisView::KisView(KisDocument *document, KisViewManager *viewManager, QWidget *parent)
     : QWidget(parent)
-    , d(new Private(this, document, resourceManager, actionCollection))
+    , d(new Private(this, document, viewManager))
 {
     Q_ASSERT(document);
     connect(document, SIGNAL(titleModified(QString,bool)), this, SIGNAL(titleModified(QString,bool)));
     setObjectName(newObjectName());
 
     d->document = document;
 
     setFocusPolicy(Qt::StrongFocus);
 
     QStatusBar * sb = statusBar();
     if (sb) { // No statusbar in e.g. konqueror
         connect(d->document, SIGNAL(statusBarMessage(QString,int)),
                 this, SLOT(slotSavingStatusMessage(QString,int)));
         connect(d->document, SIGNAL(clearStatusBarMessage()),
                 this, SLOT(slotClearStatusText()));
     }
 
     d->canvas.setup();
 
     KisConfig cfg(false);
 
     d->canvasController.setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
     d->canvasController.setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
     d->canvasController.setVastScrolling(cfg.vastScrolling());
     d->canvasController.setCanvas(&d->canvas);
 
     d->zoomManager.setup(d->actionCollection);
 
 
     connect(&d->canvasController, SIGNAL(documentSizeChanged()), &d->zoomManager, SLOT(slotScrollAreaSizeChanged()));
     setAcceptDrops(true);
 
     connect(d->document, SIGNAL(sigLoadingFinished()), this, SLOT(slotLoadingFinished()));
     connect(d->document, SIGNAL(sigSavingFinished()), this, SLOT(slotSavingFinished()));
 
     d->canvas.addDecoration(d->referenceImagesDecoration);
     d->referenceImagesDecoration->setVisible(true);
 
     d->canvas.addDecoration(d->paintingAssistantsDecoration);
     d->paintingAssistantsDecoration->setVisible(true);
 
     d->showFloatingMessage = cfg.showCanvasMessages();
     d->zoomManager.updateScreenResolution(this);
 }
 
 KisView::~KisView()
 {
     if (d->viewManager) {
         if (d->viewManager->filterManager()->isStrokeRunning()) {
             d->viewManager->filterManager()->cancel();
         }
 
         d->viewManager->mainWindow()->notifyChildViewDestroyed(this);
     }
 
     KoToolManager::instance()->removeCanvasController(&d->canvasController);
     d->canvasController.setCanvas(0);
 
     KisPart::instance()->removeView(this);
     delete d;
 }
 
 void KisView::notifyCurrentStateChanged(bool isCurrent)
 {
     d->isCurrent = isCurrent;
 
     if (!d->isCurrent && d->savedFloatingMessage) {
         d->savedFloatingMessage->removeMessage();
     }
 
     KisInputManager *inputManager = globalInputManager();
     if (d->isCurrent) {
         inputManager->attachPriorityEventFilter(&d->canvasController);
     } else {
         inputManager->detachPriorityEventFilter(&d->canvasController);
     }
 
     /**
      * When current view is changed, currently selected node is also changed,
      * therefore we should update selection overlay mask
      */
     viewManager()->selectionManager()->selectionChanged();
 }
 
 bool KisView::isCurrent() const
 {
     return d->isCurrent;
 }
 
 void KisView::setShowFloatingMessage(bool show)
 {
     d->showFloatingMessage = show;
 }
 
 void KisView::showFloatingMessage(const QString &message, const QIcon& icon, int timeout, KisFloatingMessage::Priority priority, int alignment)
 {
     if (!d->viewManager) return;
 
     if(d->isCurrent && d->showFloatingMessage && d->viewManager->qtMainWindow()) {
         if (d->savedFloatingMessage) {
             d->savedFloatingMessage->tryOverrideMessage(message, icon, timeout, priority, alignment);
         } else {
             d->savedFloatingMessage = new KisFloatingMessage(message, this->canvasBase()->canvasWidget(), false, timeout, priority, alignment);
             d->savedFloatingMessage->setShowOverParent(true);
             d->savedFloatingMessage->setIcon(icon);
 
             connect(&d->floatingMessageCompressor, SIGNAL(timeout()), d->savedFloatingMessage, SLOT(showMessage()));
             d->floatingMessageCompressor.start();
         }
     }
 }
 
 bool KisView::canvasIsMirrored() const
 {
     return d->canvas.xAxisMirrored() || d->canvas.yAxisMirrored();
 }
 
 void KisView::setViewManager(KisViewManager *view)
 {
     d->viewManager = view;
 
     KoToolManager::instance()->addController(&d->canvasController);
     KoToolManager::instance()->registerToolActions(d->actionCollection, &d->canvasController);
     dynamic_cast<KisShapeController*>(d->document->shapeController())->setInitialShapeForCanvas(&d->canvas);
 
     if (resourceProvider()) {
         resourceProvider()->slotImageSizeChanged();
     }
 
     if (d->viewManager && d->viewManager->nodeManager()) {
         d->viewManager->nodeManager()->nodesUpdated();
     }
 
     connect(image(), SIGNAL(sigSizeChanged(QPointF,QPointF)), this, SLOT(slotImageSizeChanged(QPointF,QPointF)));
     connect(image(), SIGNAL(sigResolutionChanged(double,double)), this, SLOT(slotImageResolutionChanged()));
 
     // executed in a context of an image thread
     connect(image(), SIGNAL(sigNodeAddedAsync(KisNodeSP)),
             SLOT(slotImageNodeAdded(KisNodeSP)),
             Qt::DirectConnection);
 
     // executed in a context of the gui thread
     connect(this, SIGNAL(sigContinueAddNode(KisNodeSP)),
             SLOT(slotContinueAddNode(KisNodeSP)),
             Qt::AutoConnection);
 
     // executed in a context of an image thread
     connect(image(), SIGNAL(sigRemoveNodeAsync(KisNodeSP)),
             SLOT(slotImageNodeRemoved(KisNodeSP)),
             Qt::DirectConnection);
 
     // executed in a context of the gui thread
     connect(this, SIGNAL(sigContinueRemoveNode(KisNodeSP)),
             SLOT(slotContinueRemoveNode(KisNodeSP)),
             Qt::AutoConnection);
 
     d->viewManager->updateGUI();
 
     KoToolManager::instance()->switchToolRequested("KritaShape/KisToolBrush");
 }
 
 KisViewManager* KisView::viewManager() const
 {
     return d->viewManager;
 }
 
 void KisView::slotImageNodeAdded(KisNodeSP node)
 {
     emit sigContinueAddNode(node);
 }
 
 void KisView::slotContinueAddNode(KisNodeSP newActiveNode)
 {
     /**
      * When deleting the last layer, root node got selected. We should
      * fix it when the first layer is added back.
      *
      * Here we basically reimplement what Qt's view/model do. But
      * since they are not connected, we should do it manually.
      */
 
     if (!d->isCurrent &&
             (!d->currentNode || !d->currentNode->parent())) {
 
         d->currentNode = newActiveNode;
     }
 }
 
 
 void KisView::slotImageNodeRemoved(KisNodeSP node)
 {
     emit sigContinueRemoveNode(KritaUtils::nearestNodeAfterRemoval(node));
 }
 
 void KisView::slotContinueRemoveNode(KisNodeSP newActiveNode)
 {
     if (!d->isCurrent) {
         d->currentNode = newActiveNode;
     }
 }
 
 KoZoomController *KisView::zoomController() const
 {
     return d->zoomManager.zoomController();
 }
 
 KisZoomManager *KisView::zoomManager() const
 {
     return &d->zoomManager;
 }
 
 KisCanvasController *KisView::canvasController() const
 {
     return &d->canvasController;
 }
 
 KisCanvasResourceProvider *KisView::resourceProvider() const
 {
     if (d->viewManager) {
         return d->viewManager->canvasResourceProvider();
     }
     return 0;
 }
 
 KisInputManager* KisView::globalInputManager() const
 {
     return d->viewManager ? d->viewManager->inputManager() : 0;
 }
 
 KisCanvas2 *KisView::canvasBase() const
 {
     return &d->canvas;
 }
 
 KisImageWSP KisView::image() const
 {
     if (d->document) {
         return d->document->image();
     }
     return 0;
 }
 
 KisCoordinatesConverter *KisView::viewConverter() const
 {
     return &d->viewConverter;
 }
 
 void KisView::dragEnterEvent(QDragEnterEvent *event)
 {
     //qDebug() << "KisView::dragEnterEvent formats" << event->mimeData()->formats() << "urls" << event->mimeData()->urls() << "has images" << event->mimeData()->hasImage();
     if (event->mimeData()->hasImage()
             || event->mimeData()->hasUrls()
             || event->mimeData()->hasFormat("application/x-krita-node")) {
         event->accept();
 
         // activate view if it should accept the drop
         this->setFocus();
     } else {
         event->ignore();
     }
 }
 
 void KisView::dropEvent(QDropEvent *event)
 {
     KisImageWSP kisimage = image();
     Q_ASSERT(kisimage);
 
     QPoint cursorPos = canvasBase()->coordinatesConverter()->widgetToImage(event->pos()).toPoint();
     QRect imageBounds = kisimage->bounds();
     QPoint pasteCenter;
     bool forceRecenter;
 
     if (event->keyboardModifiers() & Qt::ShiftModifier &&
             imageBounds.contains(cursorPos)) {
 
         pasteCenter = cursorPos;
         forceRecenter = true;
     } else {
         pasteCenter = imageBounds.center();
         forceRecenter = false;
     }
 
     //qDebug() << "KisView::dropEvent() formats" << event->mimeData()->formats() << "urls" << event->mimeData()->urls() << "has images" << event->mimeData()->hasImage();
 
     if (event->mimeData()->hasFormat("application/x-krita-node") ||
             event->mimeData()->hasImage())
     {
         KisShapeController *kritaShapeController =
                 dynamic_cast<KisShapeController*>(d->document->shapeController());
 
         QList<KisNodeSP> nodes =
                 KisMimeData::loadNodes(event->mimeData(), imageBounds,
                                        pasteCenter, forceRecenter,
                                        kisimage, kritaShapeController);
 
         Q_FOREACH (KisNodeSP node, nodes) {
             if (node) {
                 KisNodeCommandsAdapter adapter(viewManager());
                 if (!viewManager()->nodeManager()->activeLayer()) {
                     adapter.addNode(node, kisimage->rootLayer() , 0);
                 } else {
                     adapter.addNode(node,
                                     viewManager()->nodeManager()->activeLayer()->parent(),
                                     viewManager()->nodeManager()->activeLayer());
                 }
             }
         }
     }
     else if (event->mimeData()->hasUrls()) {
 
         QList<QUrl> urls = event->mimeData()->urls();
         if (urls.length() > 0) {
 
             QMenu popup;
             popup.setObjectName("drop_popup");
 
             QAction *insertAsNewLayer = new QAction(i18n("Insert as New Layer"), &popup);
             QAction *insertManyLayers = new QAction(i18n("Insert Many Layers"), &popup);
 
             QAction *insertAsNewFileLayer = new QAction(i18n("Insert as New File Layer"), &popup);
             QAction *insertManyFileLayers = new QAction(i18n("Insert Many File Layers"), &popup);
 
             QAction *openInNewDocument = new QAction(i18n("Open in New Document"), &popup);
             QAction *openManyDocuments = new QAction(i18n("Open Many Documents"), &popup);
 
             QAction *insertAsReferenceImage = new QAction(i18n("Insert as Reference Image"), &popup);
             QAction *insertAsReferenceImages = new QAction(i18n("Insert as Reference Images"), &popup);
 
             QAction *cancel = new QAction(i18n("Cancel"), &popup);
 
             popup.addAction(insertAsNewLayer);
             popup.addAction(insertAsNewFileLayer);
             popup.addAction(openInNewDocument);
             popup.addAction(insertAsReferenceImage);
 
             popup.addAction(insertManyLayers);
             popup.addAction(insertManyFileLayers);
             popup.addAction(openManyDocuments);
             popup.addAction(insertAsReferenceImages);
 
             insertAsNewLayer->setEnabled(image() && urls.count() == 1);
             insertAsNewFileLayer->setEnabled(image() && urls.count() == 1);
             openInNewDocument->setEnabled(urls.count() == 1);
             insertAsReferenceImage->setEnabled(image() && urls.count() == 1);
 
             insertManyLayers->setEnabled(image() && urls.count() > 1);
             insertManyFileLayers->setEnabled(image() && urls.count() > 1);
             openManyDocuments->setEnabled(urls.count() > 1);
             insertAsReferenceImages->setEnabled(image() && urls.count() > 1);
 
             popup.addSeparator();
             popup.addAction(cancel);
 
             QAction *action = popup.exec(QCursor::pos());
             if (action != 0 && action != cancel) {
                 QTemporaryFile *tmp = 0;
                 for (QUrl url : urls) {
 
                     if (!url.isLocalFile()) {
                         // download the file and substitute the url
                         KisRemoteFileFetcher fetcher;
                         tmp = new QTemporaryFile();
                         tmp->setAutoRemove(true);
                         if (!fetcher.fetchFile(url, tmp)) {
                             qWarning() << "Fetching" << url << "failed";
                             continue;
                         }
                         url = url.fromLocalFile(tmp->fileName());
                     }
                     if (url.isLocalFile()) {
                         if (action == insertAsNewLayer || action == insertManyLayers) {
                             d->viewManager->imageManager()->importImage(url);
                             activateWindow();
                         }
                         else if (action == insertAsNewFileLayer || action == insertManyFileLayers) {
                             KisNodeCommandsAdapter adapter(viewManager());
                             KisFileLayer *fileLayer = new KisFileLayer(image(), "", url.toLocalFile(),
                                                                        KisFileLayer::None, image()->nextLayerName(), OPACITY_OPAQUE_U8);
                             adapter.addNode(fileLayer, viewManager()->activeNode()->parent(), viewManager()->activeNode());
                         }
                         else if (action == openInNewDocument || action == openManyDocuments) {
                             if (mainWindow()) {
                                 mainWindow()->openDocument(url, KisMainWindow::None);
                             }
                         }
                         else if (action == insertAsReferenceImage || action == insertAsReferenceImages) {
                             auto *reference = KisReferenceImage::fromFile(url.toLocalFile(), d->viewConverter, this);
 
                             if (reference) {
                                 reference->setPosition(d->viewConverter.imageToDocument(cursorPos));
                                 d->referenceImagesDecoration->addReferenceImage(reference);
 
                                 KoToolManager::instance()->switchToolRequested("ToolReferenceImages");
                             }
                         }
 
                     }
                     delete tmp;
                     tmp = 0;
                 }
             }
         }
     }
 }
 
 void KisView::dragMoveEvent(QDragMoveEvent *event)
 {
     //qDebug() << "KisView::dragMoveEvent";
     if (event->mimeData()->hasUrls() ||
         event->mimeData()->hasFormat("application/x-krita-node") ||
         event->mimeData()->hasFormat("application/x-qt-image")) {
 
         event->accept();
     }
 
 }
 
 KisDocument *KisView::document() const
 {
     return d->document;
 }
 
 void KisView::setDocument(KisDocument *document)
 {
     d->document->disconnect(this);
     d->document = document;
     QStatusBar *sb = statusBar();
     if (sb) { // No statusbar in e.g. konqueror
         connect(d->document, SIGNAL(statusBarMessage(QString,int)),
                 this, SLOT(slotSavingStatusMessage(QString,int)));
         connect(d->document, SIGNAL(clearStatusBarMessage()),
                 this, SLOT(slotClearStatusText()));
     }
 }
 
 void KisView::setDocumentDeleted()
 {
     d->documentDeleted = true;
 }
 
 QPrintDialog *KisView::createPrintDialog(KisPrintJob *printJob, QWidget *parent)
 {
     Q_UNUSED(parent);
     QPrintDialog *printDialog = new QPrintDialog(&printJob->printer(), this);
     printDialog->setMinMax(printJob->printer().fromPage(), printJob->printer().toPage());
     printDialog->setEnabledOptions(printJob->printDialogOptions());
     return printDialog;
 }
 
 
 KisMainWindow * KisView::mainWindow() const
 {
-    return dynamic_cast<KisMainWindow *>(window());
+    return d->viewManager->mainWindow();
 }
 
 void KisView::setSubWindow(QMdiSubWindow *subWindow)
 {
     d->subWindow = subWindow;
 }
 
 QStatusBar * KisView::statusBar() const
 {
     KisMainWindow *mw = mainWindow();
     return mw ? mw->statusBar() : 0;
 }
 
 void KisView::slotSavingStatusMessage(const QString &text, int timeout, bool isAutoSaving)
 {
     QStatusBar *sb = statusBar();
     if (sb) {
         sb->showMessage(text, timeout);
     }
 
     KisConfig cfg(true);
 
     if (!sb || sb->isHidden() ||
         (!isAutoSaving && cfg.forceShowSaveMessages()) ||
         (cfg.forceShowAutosaveMessages() && isAutoSaving)) {
 
         viewManager()->showFloatingMessage(text, QIcon());
     }
 }
 
 void KisView::slotClearStatusText()
 {
     QStatusBar *sb = statusBar();
     if (sb) {
         sb->clearMessage();
     }
 }
 
 QList<QAction*> KisView::createChangeUnitActions(bool addPixelUnit)
 {
     UnitActionGroup* unitActions = new UnitActionGroup(d->document, addPixelUnit, this);
     return unitActions->actions();
 }
 
 void KisView::closeEvent(QCloseEvent *event)
 {
     // Check whether we're the last (user visible) view
     int viewCount = KisPart::instance()->viewCount(document());
     if (viewCount > 1 || !isVisible()) {
         // there are others still, so don't bother the user
         event->accept();
         return;
     }
 
     if (queryClose()) {
         event->accept();
         return;
     }
 
     event->ignore();
 
 }
 
 bool KisView::queryClose()
 {
     if (!document())
         return true;
 
     document()->waitForSavingToComplete();
 
     if (document()->isModified()) {
         QString name;
         if (document()->documentInfo()) {
             name = document()->documentInfo()->aboutInfo("title");
         }
         if (name.isEmpty())
             name = document()->url().fileName();
 
         if (name.isEmpty())
             name = i18n("Untitled");
 
         int res = QMessageBox::warning(this,
                                        i18nc("@title:window", "Krita"),
                                        i18n("<p>The document <b>'%1'</b> has been modified.</p><p>Do you want to save it?</p>", name),
                                        QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel, QMessageBox::Yes);
 
         switch (res) {
         case QMessageBox::Yes : {
             bool isNative = (document()->mimeType() == document()->nativeFormatMimeType());
             if (!viewManager()->mainWindow()->saveDocument(document(), !isNative, false))
                 return false;
             break;
         }
         case QMessageBox::No : {
             KisImageSP image = document()->image();
             image->requestStrokeCancellation();
             viewManager()->blockUntilOperationsFinishedForced(image);
 
             document()->removeAutoSaveFiles(document()->localFilePath(), document()->isRecovered());
             document()->setModified(false);   // Now when queryClose() is called by closeEvent it won't do anything.
             break;
         }
         default : // case QMessageBox::Cancel :
             return false;
         }
     }
 
     return true;
 
 }
 
 void KisView::slotScreenChanged()
 {
     d->zoomManager.updateScreenResolution(this);
 }
 
 void KisView::slotThemeChanged(QPalette pal)
 {
     this->setPalette(pal);
     for (int i=0; i<this->children().size();i++) {
         QWidget *w = qobject_cast<QWidget*> ( this->children().at(i));
         if (w) {
             w->setPalette(pal);
         }
     }
     if (canvasBase()) {
         canvasBase()->canvasWidget()->setPalette(pal);
     }
     if (canvasController()) {
         canvasController()->setPalette(pal);
     }
 }
 
 void KisView::resetImageSizeAndScroll(bool changeCentering,
                                       const QPointF &oldImageStillPoint,
                                       const QPointF &newImageStillPoint)
 {
     const KisCoordinatesConverter *converter = d->canvas.coordinatesConverter();
 
     QPointF oldPreferredCenter = d->canvasController.preferredCenter();
 
     /**
      * Calculating the still point in old coordinates depending on the
      * parameters given
      */
 
     QPointF oldStillPoint;
 
     if (changeCentering) {
         oldStillPoint =
                 converter->imageToWidget(oldImageStillPoint) +
                 converter->documentOffset();
     } else {
         QSizeF oldDocumentSize = d->canvasController.documentSize();
         oldStillPoint = QPointF(0.5 * oldDocumentSize.width(), 0.5 * oldDocumentSize.height());
     }
 
     /**
      * Updating the document size
      */
 
     QSizeF size(image()->width() / image()->xRes(), image()->height() / image()->yRes());
     KoZoomController *zc = d->zoomManager.zoomController();
     zc->setZoom(KoZoomMode::ZOOM_CONSTANT, zc->zoomAction()->effectiveZoom());
     zc->setPageSize(size);
     zc->setDocumentSize(size, true);
 
     /**
      * Calculating the still point in new coordinates depending on the
      * parameters given
      */
 
     QPointF newStillPoint;
 
     if (changeCentering) {
         newStillPoint =
                 converter->imageToWidget(newImageStillPoint) +
                 converter->documentOffset();
     } else {
         QSizeF newDocumentSize = d->canvasController.documentSize();
         newStillPoint = QPointF(0.5 * newDocumentSize.width(), 0.5 * newDocumentSize.height());
     }
 
     d->canvasController.setPreferredCenter(oldPreferredCenter - oldStillPoint + newStillPoint);
 }
 
 void KisView::syncLastActiveNodeToDocument()
 {
     KisDocument *doc = document();
     if (doc) {
         doc->setPreActivatedNode(d->currentNode);
     }
 }
 
 void KisView::saveViewState(KisPropertiesConfiguration &config) const
 {
     config.setProperty("file", d->document->url());
     config.setProperty("window", mainWindow()->windowStateConfig().name());
 
     if (d->subWindow) {
         config.setProperty("geometry", d->subWindow->saveGeometry().toBase64());
     }
 
     config.setProperty("zoomMode", (int)zoomController()->zoomMode());
     config.setProperty("zoom", d->canvas.coordinatesConverter()->zoom());
 
     d->canvasController.saveCanvasState(config);
 }
 
 void KisView::restoreViewState(const KisPropertiesConfiguration &config)
 {
     if (d->subWindow) {
         QByteArray geometry = QByteArray::fromBase64(config.getString("geometry", "").toLatin1());
         d->subWindow->restoreGeometry(QByteArray::fromBase64(geometry));
     }
 
     qreal zoom = config.getFloat("zoom", 1.0f);
     int zoomMode = config.getInt("zoomMode", (int)KoZoomMode::ZOOM_PAGE);
     d->zoomManager.zoomController()->setZoom((KoZoomMode::Mode)zoomMode, zoom);
     d->canvasController.restoreCanvasState(config);
 }
 
 void KisView::setCurrentNode(KisNodeSP node)
 {
     d->currentNode = node;
     d->canvas.slotTrySwitchShapeManager();
 
     syncLastActiveNodeToDocument();
 }
 
 KisNodeSP KisView::currentNode() const
 {
     return d->currentNode;
 }
 
 KisLayerSP KisView::currentLayer() const
 {
     KisNodeSP node;
     KisMaskSP mask = currentMask();
     if (mask) {
         node = mask->parent();
     }
     else {
         node = d->currentNode;
     }
     return qobject_cast<KisLayer*>(node.data());
 }
 
 KisMaskSP KisView::currentMask() const
 {
     return dynamic_cast<KisMask*>(d->currentNode.data());
 }
 
 KisSelectionSP KisView::selection()
 {
     KisLayerSP layer = currentLayer();
     if (layer)
         return layer->selection(); // falls through to the global
     // selection, or 0 in the end
     if (image()) {
         return image()->globalSelection();
     }
     return 0;
 }
 
 void KisView::slotSoftProofing(bool softProofing)
 {
     d->softProofing = softProofing;
     QString message;
     if (canvasBase()->image()->colorSpace()->colorDepthId().id().contains("F"))
     {
         message = i18n("Soft Proofing doesn't work in floating point.");
         viewManager()->showFloatingMessage(message,QIcon());
         return;
     }
     if (softProofing){
         message = i18n("Soft Proofing turned on.");
     } else {
         message = i18n("Soft Proofing turned off.");
     }
     viewManager()->showFloatingMessage(message,QIcon());
     canvasBase()->slotSoftProofing(softProofing);
 }
 
 void KisView::slotGamutCheck(bool gamutCheck)
 {
     d->gamutCheck = gamutCheck;
     QString message;
     if (canvasBase()->image()->colorSpace()->colorDepthId().id().contains("F"))
     {
         message = i18n("Gamut Warnings don't work in floating point.");
         viewManager()->showFloatingMessage(message,QIcon());
         return;
     }
 
     if (gamutCheck){
         message = i18n("Gamut Warnings turned on.");
         if (!d->softProofing){
             message += "\n "+i18n("But Soft Proofing is still off.");
         }
     } else {
         message = i18n("Gamut Warnings turned off.");
     }
     viewManager()->showFloatingMessage(message,QIcon());
     canvasBase()->slotGamutCheck(gamutCheck);
 }
 
 bool KisView::softProofing()
 {
     return d->softProofing;
 }
 
 bool KisView::gamutCheck()
 {
     return d->gamutCheck;
 }
 
 void KisView::slotLoadingFinished()
 {
     if (!document()) return;
 
     /**
      * Cold-start of image size/resolution signals
      */
     slotImageResolutionChanged();
 
     if (image()->locked()) {
         // If this is the first view on the image, the image will have been locked
         // so unlock it.
         image()->blockSignals(false);
         image()->unlock();
     }
 
     canvasBase()->initializeImage();
 
     /**
      * Dirty hack alert
      */
     d->zoomManager.zoomController()->setAspectMode(true);
 
     if (viewConverter()) {
         viewConverter()->setZoomMode(KoZoomMode::ZOOM_PAGE);
     }
     connect(image(), SIGNAL(sigColorSpaceChanged(const KoColorSpace*)), this, SIGNAL(sigColorSpaceChanged(const KoColorSpace*)));
     connect(image(), SIGNAL(sigProfileChanged(const KoColorProfile*)), this, SIGNAL(sigProfileChanged(const KoColorProfile*)));
     connect(image(), SIGNAL(sigSizeChanged(QPointF,QPointF)), this, SIGNAL(sigSizeChanged(QPointF,QPointF)));
 
     KisNodeSP activeNode = document()->preActivatedNode();
 
     if (!activeNode) {
         activeNode = image()->rootLayer()->lastChild();
     }
 
     while (activeNode && !activeNode->inherits("KisLayer")) {
         activeNode = activeNode->prevSibling();
     }
 
     setCurrentNode(activeNode);
     connect(d->viewManager->mainWindow(), SIGNAL(screenChanged()), SLOT(slotScreenChanged()));
     zoomManager()->updateImageBoundsSnapping();
 }
 
 void KisView::slotSavingFinished()
 {
     if (d->viewManager && d->viewManager->mainWindow()) {
         d->viewManager->mainWindow()->updateCaption();
     }
 }
 
 KisPrintJob * KisView::createPrintJob()
 {
     return new KisPrintJob(image());
 }
 
 void KisView::slotImageResolutionChanged()
 {
     resetImageSizeAndScroll(false);
     zoomManager()->updateImageBoundsSnapping();
     zoomManager()->updateGUI();
 
     // update KoUnit value for the document
     if (resourceProvider()) {
         resourceProvider()->resourceManager()->
                 setResource(KoCanvasResourceProvider::Unit, d->canvas.unit());
     }
 }
 
 void KisView::slotImageSizeChanged(const QPointF &oldStillPoint, const QPointF &newStillPoint)
 {
     resetImageSizeAndScroll(true, oldStillPoint, newStillPoint);
     zoomManager()->updateImageBoundsSnapping();
     zoomManager()->updateGUI();
 }
 
 void KisView::closeView()
 {
     d->subWindow->close();
 }
diff --git a/libs/ui/KisView.h b/libs/ui/KisView.h
index 9f2a67421e..378b82108f 100644
--- a/libs/ui/KisView.h
+++ b/libs/ui/KisView.h
@@ -1,302 +1,302 @@
 /* This file is part of the KDE project
    Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
    Copyright (C) 2007 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.
 */
 #ifndef KIS_VIEW_H
 #define KIS_VIEW_H
 
 #include <QWidget>
 
 #include <KoColorSpace.h>
 #include <KoColorProfile.h>
 
 #include <kis_types.h>
 #include "kritaui_export.h"
 
 #include "widgets/kis_floating_message.h"
 
 class KisDocument;
 class KisMainWindow;
 class KisPrintJob;
 class KisCanvasController;
 class KisZoomManager;
 class KisCanvas2;
 class KisViewManager;
 class KisDocument;
 class KisCanvasResourceProvider;
 class KisCoordinatesConverter;
 class KisInputManager;
 
 class KoZoomController;
 class KoZoomController;
 struct KoPageLayout;
 class KoCanvasResourceProvider;
 
 // KDE classes
 class QAction;
 class KActionCollection;
 class KConfigGroup;
 
 // Qt classes
 class QDragEnterEvent;
 class QDragMoveEvent;
 class QDropEvent;
 class QPrintDialog;
 class QCloseEvent;
 class QStatusBar;
 class QMdiSubWindow;
 
 /**
  * This class is used to display a @ref KisDocument.
  *
  * Multiple views can be attached to one document at a time.
  */
 class KRITAUI_EXPORT KisView : public QWidget
 {
     Q_OBJECT
 
 public:
     /**
      * Creates a new view for the document.
      */
-    KisView(KisDocument *document, KoCanvasResourceProvider *resourceManager, KActionCollection *actionCollection, QWidget *parent = 0);
+    KisView(KisDocument *document, KisViewManager *viewManager, QWidget *parent = 0);
     ~KisView() override;
 
     // Temporary while teasing apart view and mainwindow
     void setViewManager(KisViewManager *view);
     KisViewManager *viewManager() const;
 
 public:
 
     /**
      *  Retrieves the document object of this view.
      */
     KisDocument *document() const;
 
     /**
      * Reset the view to show the given document.
      */
     void setDocument(KisDocument *document);
 
     /**
      * Tells this view that its document has got deleted (called internally)
      */
     void setDocumentDeleted();
 
     /**
      * In order to print the document represented by this view a new print job should
      * be constructed that is capable of doing the printing.
      * The default implementation returns 0, which silently cancels printing.
      */
     KisPrintJob * createPrintJob();
 
     /**
      * Create a QPrintDialog based on the @p printJob
      */
     QPrintDialog *createPrintDialog(KisPrintJob *printJob, QWidget *parent);
 
     /**
      * @return the KisMainWindow in which this view is currently.
      */
     KisMainWindow *mainWindow() const;
 
     /**
      * Tells this view which subwindow it is part of.
      */
     void setSubWindow(QMdiSubWindow *subWindow);
 
     /**
      * @return the statusbar of the KisMainWindow in which this view is currently.
      */
     QStatusBar *statusBar() const;
 
     /**
      * This adds a widget to the statusbar for this view.
      * If you use this method instead of using statusBar() directly,
      * KisView will take care of removing the items when the view GUI is deactivated
      * and readding them when it is reactivated.
      * The parameters are the same as QStatusBar::addWidget().
      */
     void addStatusBarItem(QWidget * widget, int stretch = 0, bool permanent = false);
 
     /**
      * Remove a widget from the statusbar for this view.
      */
     void removeStatusBarItem(QWidget * widget);
 
     /**
      * Return the zoomController for this view.
      */
     KoZoomController *zoomController() const;
 
     /// create a list of actions that when activated will change the unit on the document.
     QList<QAction*> createChangeUnitActions(bool addPixelUnit = false);
 
     void closeView();
 
 public:
 
     /**
      * The zoommanager handles everything action-related to zooming
      */
     KisZoomManager *zoomManager() const;
 
     /**
      * The CanvasController decorates the canvas with scrollbars
      * and knows where to start painting on the canvas widget, i.e.,
      * the document offset.
      */
     KisCanvasController *canvasController() const;
     KisCanvasResourceProvider *resourceProvider() const;
 
     /**
      * Filters events and sends them to canvas actions. Shared
      * among all the views/canvases
      *
      * NOTE: May be null while initialization!
      */
     KisInputManager* globalInputManager() const;
 
     /**
      * @return the canvas object
      */
     KisCanvas2 *canvasBase() const;
 
     /// @return the image this view is displaying
     KisImageWSP image() const;
 
 
     KisCoordinatesConverter *viewConverter() const;
 
     void resetImageSizeAndScroll(bool changeCentering,
                                  const QPointF &oldImageStillPoint = QPointF(),
                                  const QPointF &newImageStillPoint = QPointF());
 
     void setCurrentNode(KisNodeSP node);
     KisNodeSP currentNode() const;
     KisLayerSP currentLayer() const;
     KisMaskSP currentMask() const;
     /**
      * @brief softProofing
      * @return whether or not we're softproofing in this view.
      */
     bool softProofing();
     /**
      * @brief gamutCheck
      * @return whether or not we're using gamut warnings in this view.
      */
     bool gamutCheck();
 
     /// Convenience method to get at the active selection (the
     /// selection of the current layer, or, if that does not exist,
     /// the global selection.
     KisSelectionSP selection();
 
     void notifyCurrentStateChanged(bool isCurrent);
     bool isCurrent() const;
 
     void setShowFloatingMessage(bool show);
     void showFloatingMessage(const QString &message, const QIcon& icon, int timeout = 4500,
                              KisFloatingMessage::Priority priority = KisFloatingMessage::Medium,
                              int alignment = Qt::AlignCenter | Qt::TextWordWrap);
 
     bool canvasIsMirrored() const;
 
     void syncLastActiveNodeToDocument();
 
     void saveViewState(KisPropertiesConfiguration &config) const;
     void restoreViewState(const KisPropertiesConfiguration &config);
 
 public Q_SLOTS:
 
     /**
      * Display a message in the status bar (calls QStatusBar::message())
      * @todo rename to something more generic
      * @param value determines autosaving
      */
     void slotSavingStatusMessage(const QString &text, int timeout, bool isAutoSaving = false);
 
     /**
      * End of the message in the status bar (calls QStatusBar::clear())
      * @todo rename to something more generic
      */
     void slotClearStatusText();
     /**
      * @brief slotSoftProofing set whether or not we're softproofing in this view.
      * Will be setting the same in the canvas belonging to the view.
      */
     void slotSoftProofing(bool softProofing);
     /**
      * @brief slotGamutCheck set whether or not we're gamutchecking in this view.
      * Will be setting the same in the vans belonging to the view.
      */
     void slotGamutCheck(bool gamutCheck);
 
     bool queryClose();
 
     void slotScreenChanged();
 
     void slotThemeChanged(QPalette pal);
 
 private Q_SLOTS:
     void slotImageNodeAdded(KisNodeSP node);
     void slotContinueAddNode(KisNodeSP newActiveNode);
 
     void slotImageNodeRemoved(KisNodeSP node);
     void slotContinueRemoveNode(KisNodeSP newActiveNode);
 
 Q_SIGNALS:
     // From KisImage
     void sigSizeChanged(const QPointF &oldStillPoint, const QPointF &newStillPoint);
     void sigProfileChanged(const KoColorProfile *  profile);
     void sigColorSpaceChanged(const KoColorSpace*  cs);
     void titleModified(QString,bool);
 
     void sigContinueAddNode(KisNodeSP newActiveNode);
     void sigContinueRemoveNode(KisNodeSP newActiveNode);
 
 protected:
 
     // QWidget overrides
     void dragEnterEvent(QDragEnterEvent *event) override;
     void dropEvent(QDropEvent *event) override;
     void dragMoveEvent(QDragMoveEvent *event) override;
     void closeEvent(QCloseEvent *event) override;
 
     /**
      * Generate a name for this view.
      */
     QString newObjectName();
 
 public Q_SLOTS:
     void slotLoadingFinished();
     void slotSavingFinished();
     void slotImageResolutionChanged();
     void slotImageSizeChanged(const QPointF &oldStillPoint, const QPointF &newStillPoint);
 
 
 private:
 
     class Private;
     Private * const d;
 
     static bool s_firstView;
 };
 
 #endif
diff --git a/libs/ui/KisWelcomePageWidget.cpp b/libs/ui/KisWelcomePageWidget.cpp
index 9bba1b17ce..4c4ece09a9 100644
--- a/libs/ui/KisWelcomePageWidget.cpp
+++ b/libs/ui/KisWelcomePageWidget.cpp
@@ -1,341 +1,441 @@
 /* This file is part of the KDE project
  * Copyright (C) 2018 Scott Petrovic <scottpetrovic@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License 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 "KisWelcomePageWidget.h"
 #include <QDebug>
 #include <QDesktopServices>
 #include <QFileInfo>
 #include <QMimeData>
+#include <QPixmap>
+#include <QImage>
 
 #include "kis_action_manager.h"
 #include "kactioncollection.h"
 #include "kis_action.h"
 
 #include "KConfigGroup"
 #include "KSharedConfig"
 
 #include <QListWidget>
 #include <QListWidgetItem>
+
 #include "kis_icon_utils.h"
 #include "krita_utils.h"
 #include "KoStore.h"
 #include "kis_config.h"
+#include "KisDocument.h"
+#include <kis_image.h>
+#include <kis_paint_device.h>
+#include <KisPart.h>
+
 
 KisWelcomePageWidget::KisWelcomePageWidget(QWidget *parent)
     : QWidget(parent)
 {
     setupUi(this);
     recentDocumentsListView->setDragEnabled(false);
     recentDocumentsListView->viewport()->setAutoFillBackground(false);
     recentDocumentsListView->setSpacing(2);
 
     // set up URLs that go to web browser
     manualLink->setTextFormat(Qt::RichText);
     manualLink->setTextInteractionFlags(Qt::TextBrowserInteraction);
     manualLink->setOpenExternalLinks(true);
 
     gettingStartedLink->setTextFormat(Qt::RichText);
     gettingStartedLink->setTextInteractionFlags(Qt::TextBrowserInteraction);
     gettingStartedLink->setOpenExternalLinks(true);
 
     supportKritaLink->setTextFormat(Qt::RichText);
     supportKritaLink->setTextInteractionFlags(Qt::TextBrowserInteraction);
     supportKritaLink->setOpenExternalLinks(true);
 
     userCommunityLink->setTextFormat(Qt::RichText);
     userCommunityLink->setTextInteractionFlags(Qt::TextBrowserInteraction);
     userCommunityLink->setOpenExternalLinks(true);
 
 
     kritaWebsiteLink->setTextFormat(Qt::RichText);
     kritaWebsiteLink->setTextInteractionFlags(Qt::TextBrowserInteraction);
     kritaWebsiteLink->setOpenExternalLinks(true);
 
 
     sourceCodeLink->setTextFormat(Qt::RichText);
     sourceCodeLink->setTextInteractionFlags(Qt::TextBrowserInteraction);
     sourceCodeLink->setOpenExternalLinks(true);
 
     poweredByKDELink->setTextFormat(Qt::RichText);
     poweredByKDELink->setTextInteractionFlags(Qt::TextBrowserInteraction);
     poweredByKDELink->setOpenExternalLinks(true);
     kdeIcon->setIconSize(QSize(20, 20));
     kdeIcon->setIcon(KisIconUtils::loadIcon(QStringLiteral("kde")).pixmap(20));
 
 
+    versionNotificationLabel->setTextFormat(Qt::RichText);
+    versionNotificationLabel->setTextInteractionFlags(Qt::TextBrowserInteraction);
+    versionNotificationLabel->setOpenExternalLinks(true);
+
     connect(chkShowNews, SIGNAL(toggled(bool)), newsWidget, SLOT(toggleNews(bool)));
 
+    connect(newsWidget, SIGNAL(newsDataChanged()), this, SLOT(slotUpdateVersionMessage()));
+
+
     // configure the News area
     KisConfig cfg(true);
     bool m_getNews = cfg.readEntry<bool>("FetchNews", false);
     chkShowNews->setChecked(m_getNews);
 
     setAcceptDrops(true);
 
 }
 
 KisWelcomePageWidget::~KisWelcomePageWidget()
 {
 }
 
 void KisWelcomePageWidget::setMainWindow(KisMainWindow* mainWin)
 {
     if (mainWin) {
         m_mainWindow = mainWin;
 
         // set the shortcut links from actions (only if a shortcut exists)
         if ( mainWin->viewManager()->actionManager()->actionByName("file_new")->shortcut().toString() != "") {
             newFileLinkShortcut->setText(QString("(") + mainWin->viewManager()->actionManager()->actionByName("file_new")->shortcut().toString() + QString(")"));
         }
         if (mainWin->viewManager()->actionManager()->actionByName("file_open")->shortcut().toString()  != "") {
             openFileShortcut->setText(QString("(") + mainWin->viewManager()->actionManager()->actionByName("file_open")->shortcut().toString() + QString(")"));
         }
         connect(recentDocumentsListView, SIGNAL(clicked(QModelIndex)), this, SLOT(recentDocumentClicked(QModelIndex)));
         // we need the view manager to actually call actions, so don't create the connections
         // until after the view manager is set
         connect(newFileLink, SIGNAL(clicked(bool)), this, SLOT(slotNewFileClicked()));
         connect(openFileLink, SIGNAL(clicked(bool)), this, SLOT(slotOpenFileClicked()));
         connect(clearRecentFilesLink, SIGNAL(clicked(bool)), this, SLOT(slotClearRecentFiles()));
 
         slotUpdateThemeColors();
+
+        // allows RSS news items to apply analytics tracking.
+        newsWidget->setAnalyticsTracking("?" + analyticsString);
+
     }
 }
 
+bool KisWelcomePageWidget::isDevelopmentBuild()
+{
+    // dev builds contain GIT hash in it and the word git
+    // stable versions do not contain this
+    return qApp->applicationVersion().contains("git");
+}
+
 void KisWelcomePageWidget::showDropAreaIndicator(bool show)
 {
     if (!show) {
         QString dropFrameStyle = "QFrame#dropAreaIndicator { border: 0px }";
         dropFrameBorder->setStyleSheet(dropFrameStyle);
     } else {
         QColor textColor = qApp->palette().color(QPalette::Text);
         QColor backgroundColor = qApp->palette().color(QPalette::Background);
         QColor blendedColor = KritaUtils::blendColors(textColor, backgroundColor, 0.8);
 
         // QColor.name() turns it into a hex/web format
         QString dropFrameStyle = QString("QFrame#dropAreaIndicator { border: 2px dotted ").append(blendedColor.name()).append(" }") ;
         dropFrameBorder->setStyleSheet(dropFrameStyle);
     }
 }
 
 void KisWelcomePageWidget::slotUpdateThemeColors()
 {
 
-    QColor textColor = qApp->palette().color(QPalette::Text);
-    QColor backgroundColor = qApp->palette().color(QPalette::Background);
+    textColor = qApp->palette().color(QPalette::Text);
+    backgroundColor = qApp->palette().color(QPalette::Background);
 
     // make the welcome screen labels a subtle color so it doesn't clash with the main UI elements
-    QColor blendedColor = KritaUtils::blendColors(textColor, backgroundColor, 0.8);
-    QString blendedStyle = QString("color: ").append(blendedColor.name());
+    blendedColor = KritaUtils::blendColors(textColor, backgroundColor, 0.8);
+    blendedStyle = QString("color: ").append(blendedColor.name());
 
 
     // what labels to change the color...
     startTitleLabel->setStyleSheet(blendedStyle);
     recentDocumentsLabel->setStyleSheet(blendedStyle);
     helpTitleLabel->setStyleSheet(blendedStyle);
     newFileLinkShortcut->setStyleSheet(blendedStyle);
     openFileShortcut->setStyleSheet(blendedStyle);
     clearRecentFilesLink->setStyleSheet(blendedStyle);
     recentDocumentsListView->setStyleSheet(blendedStyle);
 
     newFileLink->setStyleSheet(blendedStyle);
     openFileLink->setStyleSheet(blendedStyle);
 
 
     // giving the drag area messaging a dotted border
     QString dottedBorderStyle = QString("border: 2px dotted ").append(blendedColor.name()).append("; color:").append(blendedColor.name()).append( ";");
     dragImageHereLabel->setStyleSheet(dottedBorderStyle);
 
 
     // make drop area QFrame have a dotted line
     dropFrameBorder->setObjectName("dropAreaIndicator");
     QString dropFrameStyle = QString("QFrame#dropAreaIndicator { border: 4px dotted ").append(blendedColor.name()).append("}");
     dropFrameBorder->setStyleSheet(dropFrameStyle);
 
     // only show drop area when we have a document over the empty area
     showDropAreaIndicator(false);
 
     // add icons for new and open settings to make them stand out a bit more
     openFileLink->setIconSize(QSize(30, 30));
     newFileLink->setIconSize(QSize(30, 30));
     openFileLink->setIcon(KisIconUtils::loadIcon("document-open"));
     newFileLink->setIcon(KisIconUtils::loadIcon("document-new"));
 
 
     kdeIcon->setIcon(KisIconUtils::loadIcon(QStringLiteral("kde")).pixmap(20));
 
     // HTML links seem to be a bit more stubborn with theme changes... setting inline styles to help with color change
-    userCommunityLink->setText(QString("<a style=\"color: " + blendedColor.name() + " \" href=\"https://forum.kde.org/viewforum.php?f=136\">").append(i18n("User Community")).append("</a>"));
-    gettingStartedLink->setText(QString("<a style=\"color: " + blendedColor.name() + " \" href=\"https://docs.krita.org/en/user_manual/getting_started.html\">").append(i18n("Getting Started")).append("</a>"));
-    manualLink->setText(QString("<a style=\"color: " + blendedColor.name() + " \" href=\"https://docs.krita.org/\">").append(i18n("User Manual")).append("</a>"));
-    supportKritaLink->setText(QString("<a style=\"color: " + blendedColor.name() + " \" href=\"https://krita.org/en/support-us/donations/\">").append(i18n("Support Krita")).append("</a>"));
-    kritaWebsiteLink->setText(QString("<a style=\"color: " + blendedColor.name() + " \" href=\"https://www.krita.org\">").append(i18n("Krita Website")).append("</a>"));
-    sourceCodeLink->setText(QString("<a style=\"color: " + blendedColor.name() + " \" href=\"https://phabricator.kde.org/source/krita/\">").append(i18n("Source Code")).append("</a>"));
-    poweredByKDELink->setText(QString("<a style=\"color: " + blendedColor.name() + " \" href=\"https://userbase.kde.org/What_is_KDE\">").append(i18n("Powered by KDE")).append("</a>"));
+    userCommunityLink->setText(QString("<a style=\"color: " + blendedColor.name() + " \" href=\"https://forum.kde.org/viewforum.php?f=136&" + analyticsString + "user-community" + "\">")
+                               .append(i18n("User Community")).append("</a>"));
+
+    gettingStartedLink->setText(QString("<a style=\"color: " + blendedColor.name() + " \" href=\"https://docs.krita.org/en/user_manual/getting_started.html?" + analyticsString + "getting-started" + "\">")
+                                .append(i18n("Getting Started")).append("</a>"));
+
+    manualLink->setText(QString("<a style=\"color: " + blendedColor.name() + " \" href=\"https://docs.krita.org?" + analyticsString + "documentation-site" + "\">")
+                        .append(i18n("User Manual")).append("</a>"));
+
+    supportKritaLink->setText(QString("<a style=\"color: " + blendedColor.name() + " \" href=\"https://krita.org/en/support-us/donations?" + analyticsString + "donations" + "\">")
+                              .append(i18n("Support Krita")).append("</a>"));
+
+    kritaWebsiteLink->setText(QString("<a style=\"color: " + blendedColor.name() + " \" href=\"https://www.krita.org?" + analyticsString + "marketing-site" + "\">")
+                              .append(i18n("Krita Website")).append("</a>"));
+
+    sourceCodeLink->setText(QString("<a style=\"color: " + blendedColor.name() + " \" href=\"https://invent.kde.org/kde/krita?" + analyticsString + "source-code" + "\">")
+                            .append(i18n("Source Code")).append("</a>"));
+
+    poweredByKDELink->setText(QString("<a style=\"color: " + blendedColor.name() + " \" href=\"https://userbase.kde.org/What_is_KDE?" + analyticsString + "what-is-kde" + "\">")
+                              .append(i18n("Powered by KDE")).append("</a>"));
+
+
+    slotUpdateVersionMessage(); // text set from RSS feed
+
 
     // re-populate recent files since they might have themed icons
     populateRecentDocuments();
 
 }
 
 void KisWelcomePageWidget::populateRecentDocuments()
 {
     m_recentFilesModel.clear(); // clear existing data before it gets re-populated
 
     // grab recent files data
     int numRecentFiles = m_mainWindow->recentFilesUrls().length() > 5 ? 5 : m_mainWindow->recentFilesUrls().length(); // grab at most 5
 
     for (int i = 0; i < numRecentFiles; i++ ) {
 
         QStandardItem *recentItem = new QStandardItem(1,2); // 1 row, 1 column
         recentItem->setIcon(KisIconUtils::loadIcon("document-export"));
 
         QString recentFileUrlPath = m_mainWindow->recentFilesUrls().at(i).toLocalFile();
         QString fileName = recentFileUrlPath.split("/").last();
 
         if (m_thumbnailMap.contains(recentFileUrlPath)) {
             recentItem->setIcon(m_thumbnailMap[recentFileUrlPath]);
         }
         else {
-            if (QFileInfo(recentFileUrlPath).exists()) {
-                if (recentFileUrlPath.toLower().endsWith("ora") || recentFileUrlPath.toLower().endsWith("kra")) {
+            QFileInfo fi(recentFileUrlPath);
+
+            if (fi.exists()) {
+                if (fi.suffix() == "ora" || fi.suffix() == "kra") {
 
                     QScopedPointer<KoStore> store(KoStore::createStore(recentFileUrlPath, KoStore::Read));
                     if (store) {
                         QString thumbnailpath;
                         if (store->hasFile(QString("Thumbnails/thumbnail.png"))){
                             thumbnailpath = QString("Thumbnails/thumbnail.png");
                         } else if (store->hasFile(QString("preview.png"))) {
                             thumbnailpath = QString("preview.png");
                         }
                         if (!thumbnailpath.isEmpty()) {
                             if (store->open(thumbnailpath)) {
 
                                 QByteArray bytes = store->read(store->size());
                                 store->close();
                                 QImage img;
                                 img.loadFromData(bytes);
                                 img.setDevicePixelRatio(devicePixelRatioF());
                                 recentItem->setIcon(QIcon(QPixmap::fromImage(img)));
                             }
                         }
                     }
                 }
+                else if (fi.suffix() == "tiff" || fi.suffix() == "tif") {
+                    // Workaround for a bug in Qt tiff QImageIO plugin
+                    QScopedPointer<KisDocument> doc;
+                    doc.reset(KisPart::instance()->createDocument());
+                    bool r = doc->openUrl(QUrl::fromLocalFile(recentFileUrlPath), KisDocument::DontAddToRecent);
+                    if (r) {
+                        KisPaintDeviceSP projection = doc->image()->projection();
+                        recentItem->setIcon(QIcon(QPixmap::fromImage(projection->createThumbnail(48, 48, projection->exactBounds()))));
+                    }
+                }
                 else {
                     QImage img;
                     img.setDevicePixelRatio(devicePixelRatioF());
                     img.load(recentFileUrlPath);
                     if (!img.isNull()) {
                         recentItem->setIcon(QIcon(QPixmap::fromImage(img.scaledToWidth(48))));
                     }
                 }
                 m_thumbnailMap[recentFileUrlPath] = recentItem->icon();
             }
         }
 
         // set the recent object with the data
         recentItem->setText(fileName); // what to display for the item
         recentItem->setToolTip(recentFileUrlPath);
         m_recentFilesModel.appendRow(recentItem);
     }
 
     // hide clear and Recent files title if there are none
     bool hasRecentFiles = m_mainWindow->recentFilesUrls().length() > 0;
 
     recentDocumentsLabel->setVisible(hasRecentFiles);
     clearRecentFilesLink->setVisible(hasRecentFiles);
 
     recentDocumentsListView->setIconSize(QSize(48, 48));
     recentDocumentsListView->setModel(&m_recentFilesModel);
 }
 
+void KisWelcomePageWidget::slotUpdateVersionMessage()
+{
+
+    alertIcon->setIcon(KisIconUtils::loadIcon("warning"));
+    alertIcon->setVisible(false);
+
+    // find out if we need an update...or if this is a development version
+    if (isDevelopmentBuild()) {
+        // Development build
+        QString versionLabelText = QString("<a style=\"color: " +
+                                           blendedColor.name() +
+                                           " \" href=\"https://docs.krita.org/en/untranslatable_pages/triaging_bugs.html?"
+                                           + analyticsString + "dev-build" + "\">")
+                                  .append(i18n("DEV BUILD")).append("</a>");
+
+        versionNotificationLabel->setText(versionLabelText);
+        alertIcon->setVisible(true);
+        versionNotificationLabel->setVisible(true);
+
+    } else if (newsWidget->hasUpdateAvailable()) {
+
+        // build URL for label
+        QString versionLabelText = QString("<a style=\"color: " +
+                                           blendedColor.name() +
+                                           " \" href=\"" +
+                                           newsWidget->versionLink() + "?" +
+                                           analyticsString + "version-update" + "\">")
+                           .append(i18n("New Version Available!")).append("</a>");
+
+        versionNotificationLabel->setVisible(true);
+        versionNotificationLabel->setText(versionLabelText);
+        alertIcon->setVisible(true);
+
+    } else {
+        // no message needed... exit
+        versionNotificationLabel->setVisible(false);
+        return;
+    }
+
+    if (!blendedStyle.isNull()) {
+        versionNotificationLabel->setStyleSheet(blendedStyle);
+    }
+
+}
+
 void KisWelcomePageWidget::dragEnterEvent(QDragEnterEvent *event)
 {
     //qDebug() << "dragEnterEvent formats" << event->mimeData()->formats() << "urls" << event->mimeData()->urls() << "has images" << event->mimeData()->hasImage();
     showDropAreaIndicator(true);
     if (event->mimeData()->hasUrls() ||
         event->mimeData()->hasFormat("application/x-krita-node") ||
         event->mimeData()->hasFormat("application/x-qt-image")) {
 
         event->accept();
     }
 }
 
 void KisWelcomePageWidget::dropEvent(QDropEvent *event)
 {
     //qDebug() << "KisWelcomePageWidget::dropEvent() formats" << event->mimeData()->formats() << "urls" << event->mimeData()->urls() << "has images" << event->mimeData()->hasImage();
 
     showDropAreaIndicator(false);
 
     if (event->mimeData()->hasUrls() && event->mimeData()->urls().size() > 0) {
         Q_FOREACH (const QUrl &url, event->mimeData()->urls()) {
             if (url.toLocalFile().endsWith(".bundle")) {
                 bool r = m_mainWindow->installBundle(url.toLocalFile());
                 if (!r) {
                     qWarning() << "Could not install bundle" << url.toLocalFile();
                 }
             }
             else {
                 m_mainWindow->openDocument(url, KisMainWindow::None);
             }
         }
     }
 }
 
 void KisWelcomePageWidget::dragMoveEvent(QDragMoveEvent *event)
 {
     //qDebug() << "dragMoveEvent";
     m_mainWindow->dragMoveEvent(event);
     if (event->mimeData()->hasUrls() ||
         event->mimeData()->hasFormat("application/x-krita-node") ||
         event->mimeData()->hasFormat("application/x-qt-image")) {
 
         event->accept();
     }
 
 }
 
 void KisWelcomePageWidget::dragLeaveEvent(QDragLeaveEvent */*event*/)
 {
     //qDebug() << "dragLeaveEvent";
     showDropAreaIndicator(false);
     m_mainWindow->dragLeave();
 }
 
 void KisWelcomePageWidget::recentDocumentClicked(QModelIndex index)
 {
     QString fileUrl = index.data(Qt::ToolTipRole).toString();
     m_mainWindow->openDocument(QUrl::fromLocalFile(fileUrl), KisMainWindow::None );
 }
 
 
 void KisWelcomePageWidget::slotNewFileClicked()
 {
     m_mainWindow->slotFileNew();
 }
 
 void KisWelcomePageWidget::slotOpenFileClicked()
 {
     m_mainWindow->slotFileOpen();
 }
 
 void KisWelcomePageWidget::slotClearRecentFiles()
 {
     m_mainWindow->clearRecentFiles();
     populateRecentDocuments();
 }
diff --git a/libs/ui/KisWelcomePageWidget.h b/libs/ui/KisWelcomePageWidget.h
index 9f056d01af..d115cca218 100644
--- a/libs/ui/KisWelcomePageWidget.h
+++ b/libs/ui/KisWelcomePageWidget.h
@@ -1,75 +1,94 @@
 /* This file is part of the KDE project
  * Copyright (C) 2018 Scott Petrovic <scottpetrovic@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License 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 KISWELCOMEPAGEWIDGET_H
 #define KISWELCOMEPAGEWIDGET_H
 
 #include "kritaui_export.h"
 #include "KisViewManager.h"
 #include "KisMainWindow.h"
 
 #include <QWidget>
 #include "ui_KisWelcomePage.h"
 #include <QStandardItemModel>
 
 /// A widget for displaying if no documents are open. This will display in the MDI area
 class KRITAUI_EXPORT KisWelcomePageWidget : public QWidget, public Ui::KisWelcomePage
 {
     Q_OBJECT
 
     public:
     explicit KisWelcomePageWidget(QWidget *parent);
     ~KisWelcomePageWidget() override;
 
     void setMainWindow(KisMainWindow* m_mainWindow);
 
+    bool isDevelopmentBuild();
+
 public Q_SLOTS:
     /// if a document is placed over this area, a dotted line will appear as an indicator
     /// that it is a droppable area. KisMainwindow is what triggers this
     void showDropAreaIndicator(bool show);
 
     void slotUpdateThemeColors();
 
     /// this could be called multiple times. If a recent document doesn't
     /// have a preview, an icon is used that needs to be updated
     void populateRecentDocuments();
 
+    void slotUpdateVersionMessage();
+
 protected:
 
     // QWidget overrides
     void dragEnterEvent(QDragEnterEvent * event) override;
     void dropEvent(QDropEvent * event) override;
     void dragMoveEvent(QDragMoveEvent * event) override;
     void dragLeaveEvent(QDragLeaveEvent * event) override;
 
 
 private:
     KisMainWindow *m_mainWindow;
     QStandardItemModel m_recentFilesModel;
 
     QMap<QString, QIcon> m_thumbnailMap;
 
+
+    /// help us see how many people are clicking startup screen links
+    /// you can see the results in Matomo (stats.kde.org)
+    /// this will be listed in the "Acquisition" section of Matomo
+    /// just append some text to this to associate it with an event/page
+    const QString analyticsString = "pk_campaign=startup-sceen&pk_kwd=";
+
+
+    // keeping track of link colors with theme change
+    QColor textColor;
+    QColor backgroundColor;
+    QColor blendedColor;
+    QString blendedStyle;
+
+
 private Q_SLOTS:
     void slotNewFileClicked();
     void slotOpenFileClicked();
     void slotClearRecentFiles();
     void recentDocumentClicked(QModelIndex index);
 };
 
 #endif // KISWELCOMEPAGEWIDGET_H
diff --git a/libs/ui/KisWindowLayoutResource.cpp b/libs/ui/KisWindowLayoutResource.cpp
index 1f182c59b1..2cc94b57d4 100644
--- a/libs/ui/KisWindowLayoutResource.cpp
+++ b/libs/ui/KisWindowLayoutResource.cpp
@@ -1,387 +1,450 @@
 /*
  *  Copyright (c) 2018 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 "KisWindowLayoutResource.h"
 #include "KisWindowLayoutManager.h"
 
 #include <QVector>
 #include <QList>
 #include <QFile>
 #include <QDomDocument>
 #include <QApplication>
 #include <QEventLoop>
 #include <QWindow>
 #include <QScreen>
 
 #include <KisPart.h>
 #include <KisDocument.h>
 #include <kis_dom_utils.h>
 
 static const int WINDOW_LAYOUT_VERSION = 1;
 
 struct KisWindowLayoutResource::Private
 {
+    struct WindowGeometry{
+        int screen = -1;
+        Qt::WindowStates stateFlags = Qt::WindowNoState;
+        QByteArray data;
+
+        static WindowGeometry fromWindow(const QWidget *window, QList<QScreen*> screens)
+        {
+            WindowGeometry geometry;
+            QWindow *windowHandle = window->windowHandle();
+
+            geometry.data = window->saveGeometry();
+            geometry.stateFlags = windowHandle->windowState();
+
+            int index = screens.indexOf(windowHandle->screen());
+            if (index >= 0) {
+                geometry.screen = index;
+            }
+
+            return geometry;
+        }
+
+        void forceOntoCorrectScreen(QWidget *window, QList<QScreen*> screens)
+        {
+            QWindow *windowHandle = window->windowHandle();
+
+            if (screens.indexOf(windowHandle->screen()) != screen) {
+                QScreen *qScreen = screens[screen];
+                windowHandle->setScreen(qScreen);
+                windowHandle->setPosition(qScreen->availableGeometry().topLeft());
+            }
+
+            if (stateFlags) {
+                window->setWindowState(stateFlags);
+            }
+        }
+
+        void save(QDomDocument &doc, QDomElement &elem) const
+        {
+            if (screen >= 0) {
+                elem.setAttribute("screen", screen);
+            }
+
+            if (stateFlags & Qt::WindowMaximized) {
+                elem.setAttribute("maximized", "1");
+            }
+
+            QDomElement geometry = doc.createElement("geometry");
+            geometry.appendChild(doc.createCDATASection(data.toBase64()));
+            elem.appendChild(geometry);
+        }
+
+        static WindowGeometry load(const QDomElement &element)
+        {
+            WindowGeometry geometry;
+            geometry.screen = element.attribute("screen", "-1").toInt();
+
+            if (element.attribute("maximized", "0") != "0") {
+                geometry.stateFlags |= Qt::WindowMaximized;
+            }
+
+            QDomElement dataElement = element.firstChildElement("geometry");
+            geometry.data = QByteArray::fromBase64(dataElement.text().toLatin1());
+
+            return geometry;
+        }
+    };
+
     struct Window {
         QUuid windowId;
-        QByteArray geometry;
         QByteArray windowState;
-        int screen = -1;
-        Qt::WindowStates stateFlags = Qt::WindowNoState;
+        WindowGeometry geometry;
+
+        bool canvasDetached = false;
+        WindowGeometry canvasWindowGeometry;
     };
 
     QVector<Window> windows;
     bool showImageInAllWindows;
     bool primaryWorkspaceFollowsFocus;
     QUuid primaryWindow;
 
     Private() = default;
 
     explicit Private(QVector<Window> windows)
         : windows(std::move(windows))
     {}
 
     void openNecessaryWindows(QList<QPointer<KisMainWindow>> &currentWindows) {
         auto *kisPart = KisPart::instance();
 
         Q_FOREACH(const Window &window, windows) {
             QPointer<KisMainWindow> mainWindow = kisPart->windowById(window.windowId);
 
             if (mainWindow.isNull()) {
                 mainWindow = kisPart->createMainWindow(window.windowId);
                 currentWindows.append(mainWindow);
                 mainWindow->show();
             }
         }
     }
 
     void closeUnneededWindows(QList<QPointer<KisMainWindow>> &currentWindows) {
         QVector<QPointer<KisMainWindow>> windowsToClose;
 
         Q_FOREACH(KisMainWindow *mainWindow, currentWindows) {
             bool keep = false;
             Q_FOREACH(const Window &window, windows) {
                 if (window.windowId == mainWindow->id()) {
                     keep = true;
                     break;
                 }
             }
 
             if (!keep) {
                 windowsToClose.append(mainWindow);
 
                 // Set the window hidden to prevent "show image in all windows" feature from opening new views on it
                 // while we migrate views onto the remaining windows
                 mainWindow->hide();
             }
         }
 
         migrateViewsFromClosingWindows(windowsToClose);
 
         Q_FOREACH(QPointer<KisMainWindow> mainWindow, windowsToClose) {
             mainWindow->close();
         }
     }
 
     void migrateViewsFromClosingWindows(QVector<QPointer<KisMainWindow>> &closingWindows) const
     {
         auto *kisPart = KisPart::instance();
         KisMainWindow *migrationTarget = nullptr;
 
         Q_FOREACH(KisMainWindow *mainWindow, kisPart->mainWindows()) {
             if (!closingWindows.contains(mainWindow)) {
                 migrationTarget = mainWindow;
                 break;
             }
         }
 
         if (!migrationTarget) {
             qWarning() << "Problem: window layout with no windows would leave user with zero main windows.";
             migrationTarget = closingWindows.takeLast();
             migrationTarget->show();
         }
 
         QVector<KisDocument*> visibleDocuments;
         Q_FOREACH(KisView *view, kisPart->views()) {
             KisMainWindow *window = view->mainWindow();
             if (!closingWindows.contains(window)) {
                 visibleDocuments.append(view->document());
             }
         }
 
         Q_FOREACH(KisDocument *document, kisPart->documents()) {
             if (!visibleDocuments.contains(document)) {
                 visibleDocuments.append(document);
                 migrationTarget->newView(document);
             }
         }
     }
 
 
     QList<QScreen*> getScreensInConsistentOrder() {
         QList<QScreen*> screens = QGuiApplication::screens();
 
         std::sort(screens.begin(), screens.end(), [](const QScreen *a, const QScreen *b) {
             QRect aRect = a->geometry();
             QRect bRect = b->geometry();
 
             if (aRect.y() == bRect.y()) return aRect.x() < bRect.x();
             return (aRect.y() < aRect.y());
         });
 
         return screens;
     }
 };
 
 KisWindowLayoutResource::KisWindowLayoutResource(const QString &filename)
     : KoResource(filename)
     , d(new Private)
 {}
 
 KisWindowLayoutResource::~KisWindowLayoutResource()
 {}
 
 KisWindowLayoutResource * KisWindowLayoutResource::fromCurrentWindows(
     const QString &filename, const QList<QPointer<KisMainWindow>> &mainWindows, bool showImageInAllWindows,
     bool primaryWorkspaceFollowsFocus, KisMainWindow *primaryWindow
 )
 {
     auto resource = new KisWindowLayoutResource(filename);
     resource->setWindows(mainWindows);
     resource->d->showImageInAllWindows = showImageInAllWindows;
     resource->d->primaryWorkspaceFollowsFocus = primaryWorkspaceFollowsFocus;
     resource->d->primaryWindow = primaryWindow->id();
     return resource;
 }
 
 void KisWindowLayoutResource::applyLayout()
 {
     auto *kisPart = KisPart::instance();
     auto *layoutManager= KisWindowLayoutManager::instance();
 
     layoutManager->setLastUsedLayout(this);
 
     QList<QPointer<KisMainWindow>> currentWindows = kisPart->mainWindows();
 
     if (d->windows.isEmpty()) {
         // No windows defined (e.g. fresh new session). Leave things as they are, but make sure there's at least one visible main window
         if (kisPart->mainwindowCount() == 0) {
             kisPart->createMainWindow();
         } else {
             kisPart->mainWindows().first()->show();
         }
     } else {
         d->openNecessaryWindows(currentWindows);
         d->closeUnneededWindows(currentWindows);
     }
 
     // Wait for the windows to finish opening / closing before applying saved geometry.
     // If we don't, the geometry may get reset after we apply it.
     QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
 
     Q_FOREACH(const auto &window, d->windows) {
         QPointer<KisMainWindow> mainWindow = kisPart->windowById(window.windowId);
         KIS_SAFE_ASSERT_RECOVER_BREAK(mainWindow);
 
-        mainWindow->restoreGeometry(window.geometry);
+        mainWindow->restoreGeometry(window.geometry.data);
         mainWindow->restoreWorkspaceState(window.windowState);
+
+        mainWindow->setCanvasDetached(window.canvasDetached);
+        if (window.canvasDetached) {
+            QWidget *canvasWindow = mainWindow->canvasWindow();
+            canvasWindow->restoreGeometry(window.canvasWindowGeometry.data);
+        }
     }
 
     QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
 
     QList<QScreen*> screens = d->getScreensInConsistentOrder();
     Q_FOREACH(const auto &window, d->windows) {
-        if (window.screen >= 0 && window.screen < screens.size()) {
-            QPointer<KisMainWindow> mainWindow = kisPart->windowById(window.windowId);
-            KIS_SAFE_ASSERT_RECOVER_BREAK(mainWindow);
-
-            QWindow *windowHandle = mainWindow->windowHandle();
-            if (screens.indexOf(windowHandle->screen()) != window.screen) {
-                QScreen *screen = screens[window.screen];
-                windowHandle->setScreen(screen);
-                windowHandle->setPosition(screen->availableGeometry().topLeft());
-            }
+        Private::WindowGeometry geometry = window.geometry;
+        QPointer<KisMainWindow> mainWindow = kisPart->windowById(window.windowId);
+        KIS_SAFE_ASSERT_RECOVER_BREAK(mainWindow);
 
-            if (window.stateFlags) {
-                mainWindow->setWindowState(window.stateFlags);
+        if (geometry.screen >= 0 && geometry.screen < screens.size()) {
+            geometry.forceOntoCorrectScreen(mainWindow, screens);
+        }
+        if (window.canvasDetached) {
+            Private::WindowGeometry canvasWindowGeometry = window.canvasWindowGeometry;
+            if (canvasWindowGeometry.screen >= 0 && canvasWindowGeometry.screen < screens.size()) {
+                canvasWindowGeometry.forceOntoCorrectScreen(mainWindow->canvasWindow(), screens);
             }
         }
     }
 
     layoutManager->setShowImageInAllWindowsEnabled(d->showImageInAllWindows);
     layoutManager->setPrimaryWorkspaceFollowsFocus(d->primaryWorkspaceFollowsFocus, d->primaryWindow);
 }
 
 bool KisWindowLayoutResource::save()
 {
     if (filename().isEmpty())
         return false;
 
     QFile file(filename());
     file.open(QIODevice::WriteOnly);
     bool res = saveToDevice(&file);
     file.close();
     return res;
 }
 
 bool KisWindowLayoutResource::load()
 {
     if (filename().isEmpty())
          return false;
 
     QFile file(filename());
     if (file.size() == 0) return false;
     if (!file.open(QIODevice::ReadOnly)) {
         warnKrita << "Can't open file " << filename();
         return false;
     }
 
     bool res = loadFromDevice(&file);
     file.close();
     return res;
 }
 
 bool KisWindowLayoutResource::saveToDevice(QIODevice *dev) const
 {
     QDomDocument doc;
     QDomElement root = doc.createElement("WindowLayout");
     root.setAttribute("name", name());
     root.setAttribute("version", WINDOW_LAYOUT_VERSION);
 
     saveXml(doc, root);
 
     doc.appendChild(root);
 
     QTextStream textStream(dev);
     textStream.setCodec("UTF-8");
     doc.save(textStream, 4);
 
     KoResource::saveToDevice(dev);
 
     return true;
 }
 
 bool KisWindowLayoutResource::loadFromDevice(QIODevice *dev)
 {
     QDomDocument doc;
     if (!doc.setContent(dev)) {
         return false;
     }
 
     QDomElement element = doc.documentElement();
     setName(element.attribute("name"));
 
     d->windows.clear();
 
     loadXml(element);
 
     setValid(true);
     return true;
 }
 
 void KisWindowLayoutResource::saveXml(QDomDocument &doc, QDomElement &root) const
 {
     root.setAttribute("showImageInAllWindows", (int)d->showImageInAllWindows);
     root.setAttribute("primaryWorkspaceFollowsFocus", (int)d->primaryWorkspaceFollowsFocus);
     root.setAttribute("primaryWindow", d->primaryWindow.toString());
 
     Q_FOREACH(const auto &window, d->windows) {
         QDomElement elem = doc.createElement("window");
         elem.setAttribute("id", window.windowId.toString());
 
-        if (window.screen >= 0) {
-            elem.setAttribute("screen", window.screen);
-        }
+        window.geometry.save(doc, elem);
 
-        if (window.stateFlags & Qt::WindowMaximized) {
-            elem.setAttribute("maximized", "1");
+        if (window.canvasDetached) {
+            QDomElement canvasWindowElement = doc.createElement("canvasWindow");
+            window.canvasWindowGeometry.save(doc, canvasWindowElement);
+            elem.appendChild(canvasWindowElement);
         }
 
-        QDomElement geometry = doc.createElement("geometry");
-        geometry.appendChild(doc.createCDATASection(window.geometry.toBase64()));
-        elem.appendChild(geometry);
-
         QDomElement state = doc.createElement("windowState");
         state.appendChild(doc.createCDATASection(window.windowState.toBase64()));
         elem.appendChild(state);
         root.appendChild(elem);
     }
 }
 
 void KisWindowLayoutResource::loadXml(const QDomElement &element) const
 {
     d->showImageInAllWindows = KisDomUtils::toInt(element.attribute("showImageInAllWindows", "0"));
     d->primaryWorkspaceFollowsFocus = KisDomUtils::toInt(element.attribute("primaryWorkspaceFollowsFocus", "0"));
     d->primaryWindow = element.attribute("primaryWindow");
 
     for (auto windowElement = element.firstChildElement("window");
          !windowElement.isNull();
          windowElement = windowElement.nextSiblingElement("window")) {
 
         Private::Window window;
 
         window.windowId = QUuid(windowElement.attribute("id", QUuid().toString()));
         if (window.windowId.isNull()) {
             window.windowId = QUuid::createUuid();
         }
 
-        window.screen = windowElement.attribute("screen", "-1").toInt();
+        window.geometry = Private::WindowGeometry::load(windowElement);
 
-        if (windowElement.attribute("maximized", "0") != "0") {
-            window.stateFlags |= Qt::WindowMaximized;
+        QDomElement canvasWindowElement = windowElement.firstChildElement("canvasWindow");
+        if (!canvasWindowElement.isNull()) {
+            window.canvasDetached = true;
+            window.canvasWindowGeometry = Private::WindowGeometry::load(canvasWindowElement);
         }
 
-        QDomElement geometry = windowElement.firstChildElement("geometry");
         QDomElement state = windowElement.firstChildElement("windowState");
-
-        window.geometry = QByteArray::fromBase64(geometry.text().toLatin1());
         window.windowState = QByteArray::fromBase64(state.text().toLatin1());
 
         d->windows.append(window);
     }
 }
 
 QString KisWindowLayoutResource::defaultFileExtension() const
 {
     return QString(".kwl");
 }
 
 void KisWindowLayoutResource::setWindows(const QList<QPointer<KisMainWindow>> &mainWindows)
 {
     d->windows.clear();
 
     QList<QScreen*> screens = d->getScreensInConsistentOrder();
 
     Q_FOREACH(auto window, mainWindows) {
         if (!window->isVisible()) continue;
 
         Private::Window state;
         state.windowId = window->id();
-        state.geometry = window->saveGeometry();
         state.windowState = window->saveState();
-        state.stateFlags = window->windowState();
+        state.geometry = Private::WindowGeometry::fromWindow(window, screens);
 
-        QWindow *windowHandle = window->windowHandle();
-        if (windowHandle) {
-            int index = screens.indexOf(windowHandle->screen());
-            if (index >= 0) {
-                state.screen = index;
-            }
+        state.canvasDetached = window->canvasDetached();
+        if (state.canvasDetached) {
+            state.canvasWindowGeometry = Private::WindowGeometry::fromWindow(window->canvasWindow(), screens);
         }
 
         d->windows.append(state);
     }
 }
diff --git a/libs/ui/canvas/kis_canvas2.cpp b/libs/ui/canvas/kis_canvas2.cpp
index e162943bd3..6fe29be213 100644
--- a/libs/ui/canvas/kis_canvas2.cpp
+++ b/libs/ui/canvas/kis_canvas2.cpp
@@ -1,1297 +1,1297 @@
 /* This file is part of the KDE project
  *
  * Copyright (C) 2006, 2010 Boudewijn Rempt <boud@valdyas.org>
  * Copyright (C) Lukáš Tvrdý <lukast.dev@gmail.com>, (C) 2010
  * Copyright (C) 2011 Silvio Heinrich <plassy@web.de>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA..
  */
 
 #include "kis_canvas2.h"
 
 #include <functional>
 #include <numeric>
 
 #include <QApplication>
 #include <QWidget>
 #include <QVBoxLayout>
 #include <QTime>
 #include <QLabel>
 #include <QMouseEvent>
 #include <QDesktopWidget>
 #include <QScreen>
 #include <QWindow>
 
 #include <kis_debug.h>
 
 #include <KoUnit.h>
 #include <KoShapeManager.h>
 #include <KisSelectedShapesProxy.h>
 #include <KoColorProfile.h>
 #include <KoCanvasControllerWidget.h>
 #include <KisDocument.h>
 #include <KoSelection.h>
 #include <KoShapeController.h>
 
 #include <KisUsageLogger.h>
 
 #include <kis_lod_transform.h>
 #include "kis_tool_proxy.h"
 #include "kis_coordinates_converter.h"
 #include "kis_prescaled_projection.h"
 #include "kis_image.h"
 #include "kis_image_barrier_locker.h"
 #include "kis_undo_adapter.h"
 #include "flake/kis_shape_layer.h"
 #include "kis_canvas_resource_provider.h"
 #include "KisViewManager.h"
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_abstract_canvas_widget.h"
 #include "kis_qpainter_canvas.h"
 #include "kis_group_layer.h"
 #include "flake/kis_shape_controller.h"
 #include "kis_node_manager.h"
 #include "kis_selection.h"
 #include "kis_selection_component.h"
 #include "flake/kis_shape_selection.h"
 #include "kis_selection_mask.h"
 #include "kis_image_config.h"
 #include "kis_infinity_manager.h"
 #include "kis_signal_compressor.h"
 #include "kis_display_color_converter.h"
 #include "kis_exposure_gamma_correction_interface.h"
 #include "KisView.h"
 #include "kis_canvas_controller.h"
 #include "kis_grid_config.h"
 
 #include "kis_animation_player.h"
 #include "kis_animation_frame_cache.h"
 #include "opengl/kis_opengl_canvas2.h"
 #include "opengl/kis_opengl.h"
 #include "kis_fps_decoration.h"
 
 #include "KoColorConversionTransformation.h"
 #include "KisProofingConfiguration.h"
 
 #include <kis_favorite_resource_manager.h>
 #include <kis_popup_palette.h>
 
 #include "input/kis_input_manager.h"
 #include "kis_painting_assistants_decoration.h"
 
 #include "kis_canvas_updates_compressor.h"
 #include "KoZoomController.h"
 
 #include <KisStrokeSpeedMonitor.h>
 #include "opengl/kis_opengl_canvas_debugger.h"
 
 #include "kis_algebra_2d.h"
 #include "kis_image_signal_router.h"
 
 #include "KisSnapPixelStrategy.h"
 
 
 class Q_DECL_HIDDEN KisCanvas2::KisCanvas2Private
 {
 
 public:
 
     KisCanvas2Private(KoCanvasBase *parent, KisCoordinatesConverter* coordConverter, QPointer<KisView> view, KoCanvasResourceProvider* resourceManager)
         : coordinatesConverter(coordConverter)
         , view(view)
         , shapeManager(parent)
         , selectedShapesProxy(&shapeManager)
         , toolProxy(parent)
         , displayColorConverter(resourceManager, view)
         , regionOfInterestUpdateCompressor(100, KisSignalCompressor::FIRST_INACTIVE)
     {
     }
 
     KisCoordinatesConverter *coordinatesConverter;
     QPointer<KisView>view;
     KisAbstractCanvasWidget *canvasWidget = 0;
     KoShapeManager shapeManager;
     KisSelectedShapesProxy selectedShapesProxy;
     bool currentCanvasIsOpenGL;
     int openGLFilterMode;
     KisToolProxy toolProxy;
     KisPrescaledProjectionSP prescaledProjection;
     bool vastScrolling;
 
     KisSignalCompressor canvasUpdateCompressor;
     QRect savedUpdateRect;
 
     QBitArray channelFlags;
     KisProofingConfigurationSP proofingConfig;
     bool softProofing = false;
     bool gamutCheck = false;
     bool proofingConfigUpdated = false;
 
     KisPopupPalette *popupPalette = 0;
     KisDisplayColorConverter displayColorConverter;
 
     KisCanvasUpdatesCompressor projectionUpdatesCompressor;
     KisAnimationPlayer *animationPlayer;
     KisAnimationFrameCacheSP frameCache;
     bool lodAllowedInImage = false;
     bool bootstrapLodBlocked;
     QPointer<KoShapeManager> currentlyActiveShapeManager;
     KisInputActionGroupsMask inputActionGroupsMask = AllActionGroup;
 
     KisSignalCompressor frameRenderStartCompressor;
 
     KisSignalCompressor regionOfInterestUpdateCompressor;
     QRect regionOfInterest;
 
     QRect renderingLimit;
     int isBatchUpdateActive = 0;
 
     bool effectiveLodAllowedInImage() {
         return lodAllowedInImage && !bootstrapLodBlocked;
     }
 
     void setActiveShapeManager(KoShapeManager *shapeManager);
 };
 
 namespace {
 KoShapeManager* fetchShapeManagerFromNode(KisNodeSP node)
 {
     KoShapeManager *shapeManager = 0;
     KisSelectionSP selection;
 
     if (KisLayer *layer = dynamic_cast<KisLayer*>(node.data())) {
         KisShapeLayer *shapeLayer = dynamic_cast<KisShapeLayer*>(layer);
         if (shapeLayer) {
             shapeManager = shapeLayer->shapeManager();
 
         }
     } else if (KisSelectionMask *mask = dynamic_cast<KisSelectionMask*>(node.data())) {
         selection = mask->selection();
     }
 
     if (!shapeManager && selection && selection->hasShapeSelection()) {
         KisShapeSelection *shapeSelection = dynamic_cast<KisShapeSelection*>(selection->shapeSelection());
         KIS_ASSERT_RECOVER_RETURN_VALUE(shapeSelection, 0);
 
         shapeManager = shapeSelection->shapeManager();
     }
 
     return shapeManager;
 }
 }
 
-KisCanvas2::KisCanvas2(KisCoordinatesConverter *coordConverter, KoCanvasResourceProvider *resourceManager, KisView *view, KoShapeControllerBase *sc)
+KisCanvas2::KisCanvas2(KisCoordinatesConverter *coordConverter, KoCanvasResourceProvider *resourceManager, KisMainWindow *mainWindow, KisView *view, KoShapeControllerBase *sc)
     : KoCanvasBase(sc, resourceManager)
     , m_d(new KisCanvas2Private(this, coordConverter, view, resourceManager))
 {
     /**
      * While loading LoD should be blocked. Only when GUI has finished
      * loading and zoom level settled down, LoD is given a green
      * light.
      */
     m_d->bootstrapLodBlocked = true;
-    connect(view->mainWindow(), SIGNAL(guiLoadingFinished()), SLOT(bootstrapFinished()));
-    connect(view->mainWindow(), SIGNAL(screenChanged()), SLOT(slotConfigChanged()));
+    connect(mainWindow, SIGNAL(guiLoadingFinished()), SLOT(bootstrapFinished()));
+    connect(mainWindow, SIGNAL(screenChanged()), SLOT(slotConfigChanged()));
 
     KisImageConfig config(false);
 
     m_d->canvasUpdateCompressor.setDelay(1000 / config.fpsLimit());
     m_d->canvasUpdateCompressor.setMode(KisSignalCompressor::FIRST_ACTIVE);
 
     m_d->frameRenderStartCompressor.setDelay(1000 / config.fpsLimit());
     m_d->frameRenderStartCompressor.setMode(KisSignalCompressor::FIRST_ACTIVE);
     snapGuide()->overrideSnapStrategy(KoSnapGuide::PixelSnapping, new KisSnapPixelStrategy());
 }
 
 void KisCanvas2::setup()
 {
     // a bit of duplication from slotConfigChanged()
     KisConfig cfg(true);
     m_d->vastScrolling = cfg.vastScrolling();
     m_d->lodAllowedInImage = cfg.levelOfDetailEnabled();
 
     createCanvas(cfg.useOpenGL());
 
     setLodAllowedInCanvas(m_d->lodAllowedInImage);
     m_d->animationPlayer = new KisAnimationPlayer(this);
     connect(m_d->view->canvasController()->proxyObject, SIGNAL(moveDocumentOffset(QPoint)), SLOT(documentOffsetMoved(QPoint)));
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
 
     /**
      * We switch the shape manager every time vector layer or
      * shape selection is activated. Flake does not expect this
      * and connects all the signals of the global shape manager
      * to the clients in the constructor. To workaround this we
      * forward the signals of local shape managers stored in the
      * vector layers to the signals of global shape manager. So the
      * sequence of signal deliveries is the following:
      *
      * shapeLayer.m_d.canvas.m_shapeManager.selection() ->
      * shapeLayer ->
      * shapeController ->
      * globalShapeManager.selection()
      */
 
     KisShapeController *kritaShapeController = static_cast<KisShapeController*>(shapeController()->documentBase());
     connect(kritaShapeController, SIGNAL(selectionChanged()),
             this, SLOT(slotSelectionChanged()));
     connect(kritaShapeController, SIGNAL(selectionContentChanged()),
             selectedShapesProxy(), SIGNAL(selectionContentChanged()));
     connect(kritaShapeController, SIGNAL(currentLayerChanged(const KoShapeLayer*)),
             selectedShapesProxy(), SIGNAL(currentLayerChanged(const KoShapeLayer*)));
 
     connect(&m_d->canvasUpdateCompressor, SIGNAL(timeout()), SLOT(slotDoCanvasUpdate()));
 
     connect(this, SIGNAL(sigCanvasCacheUpdated()), &m_d->frameRenderStartCompressor, SLOT(start()));
     connect(&m_d->frameRenderStartCompressor, SIGNAL(timeout()), SLOT(updateCanvasProjection()));
 
     connect(this, SIGNAL(sigContinueResizeImage(qint32,qint32)), SLOT(finishResizingImage(qint32,qint32)));
 
     connect(&m_d->regionOfInterestUpdateCompressor, SIGNAL(timeout()), SLOT(slotUpdateRegionOfInterest()));
 
     connect(m_d->view->document(), SIGNAL(sigReferenceImagesChanged()), this, SLOT(slotReferenceImagesChanged()));
 
     initializeFpsDecoration();
 }
 
 void KisCanvas2::initializeFpsDecoration()
 {
     KisConfig cfg(true);
 
     const bool shouldShowDebugOverlay =
         (canvasIsOpenGL() && cfg.enableOpenGLFramerateLogging()) ||
         cfg.enableBrushSpeedLogging();
 
     if (shouldShowDebugOverlay && !decoration(KisFpsDecoration::idTag)) {
         addDecoration(new KisFpsDecoration(imageView()));
 
         if (cfg.enableBrushSpeedLogging()) {
             connect(KisStrokeSpeedMonitor::instance(), SIGNAL(sigStatsUpdated()), this, SLOT(updateCanvas()));
         }
     } else if (!shouldShowDebugOverlay && decoration(KisFpsDecoration::idTag)) {
         m_d->canvasWidget->removeDecoration(KisFpsDecoration::idTag);
         disconnect(KisStrokeSpeedMonitor::instance(), SIGNAL(sigStatsUpdated()), this, SLOT(updateCanvas()));
     }
 }
 
 KisCanvas2::~KisCanvas2()
 {
     if (m_d->animationPlayer->isPlaying()) {
         m_d->animationPlayer->forcedStopOnExit();
     }
     delete m_d;
 }
 
 void KisCanvas2::setCanvasWidget(KisAbstractCanvasWidget *widget)
 {
     if (m_d->popupPalette) {
         m_d->popupPalette->setParent(widget->widget());
     }
 
     if (m_d->canvasWidget != 0) {
         widget->setDecorations(m_d->canvasWidget->decorations());
 
         // Redundant check for the constructor case, see below
         if(viewManager() != 0)
             viewManager()->inputManager()->removeTrackedCanvas(this);
     }
 
     m_d->canvasWidget = widget;
 
     // Either tmp was null or we are being called by KisCanvas2 constructor that is called by KisView
     // constructor, so the view manager still doesn't exists.
     if(m_d->canvasWidget != 0 && viewManager() != 0)
         viewManager()->inputManager()->addTrackedCanvas(this);
 
     if (!m_d->canvasWidget->decoration(INFINITY_DECORATION_ID)) {
         KisInfinityManager *manager = new KisInfinityManager(m_d->view, this);
         manager->setVisible(true);
         m_d->canvasWidget->addDecoration(manager);
     }
 
     widget->widget()->setAutoFillBackground(false);
     widget->widget()->setAttribute(Qt::WA_OpaquePaintEvent);
     widget->widget()->setMouseTracking(true);
     widget->widget()->setAcceptDrops(true);
 
     KoCanvasControllerWidget *controller = dynamic_cast<KoCanvasControllerWidget*>(canvasController());
     if (controller && controller->canvas() == this) {
         controller->changeCanvasWidget(widget->widget());
     }
 }
 
 bool KisCanvas2::canvasIsOpenGL() const
 {
     return m_d->currentCanvasIsOpenGL;
 }
 
 KisOpenGL::FilterMode KisCanvas2::openGLFilterMode() const
 {
     return KisOpenGL::FilterMode(m_d->openGLFilterMode);
 }
 
 void KisCanvas2::gridSize(QPointF *offset, QSizeF *spacing) const
 {
     QTransform transform = coordinatesConverter()->imageToDocumentTransform();
 
     const QPoint intSpacing = m_d->view->document()->gridConfig().spacing();
     const QPoint intOffset = m_d->view->document()->gridConfig().offset();
 
     QPointF size = transform.map(QPointF(intSpacing));
     spacing->rwidth() = size.x();
     spacing->rheight() = size.y();
 
     *offset = transform.map(QPointF(intOffset));
 }
 
 bool KisCanvas2::snapToGrid() const
 {
     return m_d->view->document()->gridConfig().snapToGrid();
 }
 
 qreal KisCanvas2::rotationAngle() const
 {
     return m_d->coordinatesConverter->rotationAngle();
 }
 
 bool KisCanvas2::xAxisMirrored() const
 {
     return m_d->coordinatesConverter->xAxisMirrored();
 }
 
 bool KisCanvas2::yAxisMirrored() const
 {
     return m_d->coordinatesConverter->yAxisMirrored();
 }
 
 void KisCanvas2::channelSelectionChanged()
 {
     KisImageSP image = this->image();
     m_d->channelFlags = image->rootLayer()->channelFlags();
 
     m_d->view->viewManager()->blockUntilOperationsFinishedForced(image);
 
     image->barrierLock();
     m_d->canvasWidget->channelSelectionChanged(m_d->channelFlags);
     startUpdateInPatches(image->bounds());
     image->unlock();
 }
 
 void KisCanvas2::addCommand(KUndo2Command *command)
 {
     // This method exists to support flake-related operations
     m_d->view->document()->addCommand(command);
 }
 
 void KisCanvas2::KisCanvas2Private::setActiveShapeManager(KoShapeManager *shapeManager)
 {
     if (shapeManager != currentlyActiveShapeManager) {
         currentlyActiveShapeManager = shapeManager;
         selectedShapesProxy.setShapeManager(shapeManager);
     }
 }
 
 KoShapeManager* KisCanvas2::shapeManager() const
 {
     KoShapeManager *localShapeManager = this->localShapeManager();
 
     // sanity check for consistency of the local shape manager
     KIS_SAFE_ASSERT_RECOVER (localShapeManager == m_d->currentlyActiveShapeManager) {
         localShapeManager = globalShapeManager();
     }
 
     return localShapeManager ? localShapeManager : globalShapeManager();
 }
 
 KoSelectedShapesProxy* KisCanvas2::selectedShapesProxy() const
 {
     return &m_d->selectedShapesProxy;
 }
 
 KoShapeManager* KisCanvas2::globalShapeManager() const
 {
     return &m_d->shapeManager;
 }
 
 KoShapeManager *KisCanvas2::localShapeManager() const
 {
     KisNodeSP node = m_d->view->currentNode();
     KoShapeManager *localShapeManager = fetchShapeManagerFromNode(node);
 
     if (localShapeManager != m_d->currentlyActiveShapeManager) {
         m_d->setActiveShapeManager(localShapeManager);
     }
 
     return localShapeManager;
 }
 
 void KisCanvas2::updateInputMethodInfo()
 {
     // TODO call (the protected) QWidget::updateMicroFocus() on the proper canvas widget...
 }
 
 const KisCoordinatesConverter* KisCanvas2::coordinatesConverter() const
 {
     return m_d->coordinatesConverter;
 }
 
 KoViewConverter* KisCanvas2::viewConverter() const
 {
     return m_d->coordinatesConverter;
 }
 
 KisInputManager* KisCanvas2::globalInputManager() const
 {
     return m_d->view->globalInputManager();
 }
 
 KisInputActionGroupsMask KisCanvas2::inputActionGroupsMask() const
 {
     return m_d->inputActionGroupsMask;
 }
 
 void KisCanvas2::setInputActionGroupsMask(KisInputActionGroupsMask mask)
 {
     m_d->inputActionGroupsMask = mask;
 }
 
 QWidget* KisCanvas2::canvasWidget()
 {
     return m_d->canvasWidget->widget();
 }
 
 const QWidget* KisCanvas2::canvasWidget() const
 {
     return m_d->canvasWidget->widget();
 }
 
 
 KoUnit KisCanvas2::unit() const
 {
     KoUnit unit(KoUnit::Pixel);
 
     KisImageWSP image = m_d->view->image();
     if (image) {
         if (!qFuzzyCompare(image->xRes(), image->yRes())) {
             warnKrita << "WARNING: resolution of the image is anisotropic"
                        << ppVar(image->xRes())
                        << ppVar(image->yRes());
         }
 
         const qreal resolution = image->xRes();
         unit.setFactor(resolution);
     }
 
     return unit;
 }
 
 KoToolProxy * KisCanvas2::toolProxy() const
 {
     return &m_d->toolProxy;
 }
 
 void KisCanvas2::createQPainterCanvas()
 {
     m_d->currentCanvasIsOpenGL = false;
 
     KisQPainterCanvas * canvasWidget = new KisQPainterCanvas(this, m_d->coordinatesConverter, m_d->view);
     m_d->prescaledProjection = new KisPrescaledProjection();
     m_d->prescaledProjection->setCoordinatesConverter(m_d->coordinatesConverter);
     m_d->prescaledProjection->setMonitorProfile(m_d->displayColorConverter.monitorProfile(),
                                                 m_d->displayColorConverter.renderingIntent(),
                                                 m_d->displayColorConverter.conversionFlags());
     m_d->prescaledProjection->setDisplayFilter(m_d->displayColorConverter.displayFilter());
     canvasWidget->setPrescaledProjection(m_d->prescaledProjection);
     setCanvasWidget(canvasWidget);
 }
 
 void KisCanvas2::createOpenGLCanvas()
 {
     KisConfig cfg(true);
     m_d->openGLFilterMode = cfg.openGLFilteringMode();
     m_d->currentCanvasIsOpenGL = true;
 
     KisOpenGLCanvas2 *canvasWidget = new KisOpenGLCanvas2(this, m_d->coordinatesConverter, 0, m_d->view->image(), &m_d->displayColorConverter);
     m_d->frameCache = KisAnimationFrameCache::getFrameCache(canvasWidget->openGLImageTextures());
 
     setCanvasWidget(canvasWidget);
 }
 
 void KisCanvas2::createCanvas(bool useOpenGL)
 {
     // deinitialize previous canvas structures
     m_d->prescaledProjection = 0;
     m_d->frameCache = 0;
 
     KisConfig cfg(true);
     QDesktopWidget dw;
     const KoColorProfile *profile = cfg.displayProfile(dw.screenNumber(imageView()));
     m_d->displayColorConverter.notifyOpenGLCanvasIsActive(useOpenGL && KisOpenGL::hasOpenGL());
     m_d->displayColorConverter.setMonitorProfile(profile);
 
     if (useOpenGL && !KisOpenGL::hasOpenGL()) {
         warnKrita << "Tried to create OpenGL widget when system doesn't have OpenGL\n";
         useOpenGL = false;
     }
 
     m_d->displayColorConverter.notifyOpenGLCanvasIsActive(useOpenGL);
 
     if (useOpenGL) {
         createOpenGLCanvas();
         if (cfg.canvasState() == "OPENGL_FAILED") {
             // Creating the opengl canvas failed, fall back
             warnKrita << "OpenGL Canvas initialization returned OPENGL_FAILED. Falling back to QPainter.";
             m_d->displayColorConverter.notifyOpenGLCanvasIsActive(false);
             createQPainterCanvas();
         }
     } else {
         createQPainterCanvas();
     }
 
     if (m_d->popupPalette) {
         m_d->popupPalette->setParent(m_d->canvasWidget->widget());
     }
 
 }
 
 void KisCanvas2::initializeImage()
 {
     KisImageSP image = m_d->view->image();
 
     m_d->displayColorConverter.setImageColorSpace(image->colorSpace());
     m_d->coordinatesConverter->setImage(image);
     m_d->toolProxy.initializeImage(image);
 
     connect(image, SIGNAL(sigImageUpdated(QRect)), SLOT(startUpdateCanvasProjection(QRect)), Qt::DirectConnection);
     connect(image->signalRouter(), SIGNAL(sigNotifyBatchUpdateStarted()), SLOT(slotBeginUpdatesBatch()), Qt::DirectConnection);
     connect(image->signalRouter(), SIGNAL(sigNotifyBatchUpdateEnded()), SLOT(slotEndUpdatesBatch()), Qt::DirectConnection);
     connect(image->signalRouter(), SIGNAL(sigRequestLodPlanesSyncBlocked(bool)), SLOT(slotSetLodUpdatesBlocked(bool)), Qt::DirectConnection);
 
     connect(image, SIGNAL(sigProofingConfigChanged()), SLOT(slotChangeProofingConfig()));
     connect(image, SIGNAL(sigSizeChanged(QPointF,QPointF)), SLOT(startResizingImage()), Qt::DirectConnection);
     connect(image->undoAdapter(), SIGNAL(selectionChanged()), SLOT(slotTrySwitchShapeManager()));
 
     connect(image, SIGNAL(sigColorSpaceChanged(const KoColorSpace*)), SLOT(slotImageColorSpaceChanged()));
     connect(image, SIGNAL(sigProfileChanged(const KoColorProfile*)), SLOT(slotImageColorSpaceChanged()));
 
     connectCurrentCanvas();
 }
 
 void KisCanvas2::connectCurrentCanvas()
 {
     KisImageWSP image = m_d->view->image();
 
     if (!m_d->currentCanvasIsOpenGL) {
         Q_ASSERT(m_d->prescaledProjection);
         m_d->prescaledProjection->setImage(image);
     }
 
     startResizingImage();
     setLodAllowedInCanvas(m_d->lodAllowedInImage);
 
     emit sigCanvasEngineChanged();
 }
 
 void KisCanvas2::resetCanvas(bool useOpenGL)
 {
     // we cannot reset the canvas before it's created, but this method might be called,
     // for instance when setting the monitor profile.
     if (!m_d->canvasWidget) {
         return;
     }
     KisConfig cfg(true);
     bool needReset = (m_d->currentCanvasIsOpenGL != useOpenGL) ||
         (m_d->currentCanvasIsOpenGL &&
          m_d->openGLFilterMode != cfg.openGLFilteringMode());
 
     if (needReset) {
         createCanvas(useOpenGL);
         connectCurrentCanvas();
         notifyZoomChanged();
     }
     updateCanvasWidgetImpl();
 }
 
 void KisCanvas2::startUpdateInPatches(const QRect &imageRect)
 {
     /**
      * We don't do patched loading for openGL canvas, becasue it loads
      * the tiles, which are bascially "patches". Therefore, big chunks
      * of memory are never allocated.
      */
     if (m_d->currentCanvasIsOpenGL) {
         startUpdateCanvasProjection(imageRect);
     } else {
         KisImageConfig imageConfig(true);
         int patchWidth = imageConfig.updatePatchWidth();
         int patchHeight = imageConfig.updatePatchHeight();
 
         for (int y = 0; y < imageRect.height(); y += patchHeight) {
             for (int x = 0; x < imageRect.width(); x += patchWidth) {
                 QRect patchRect(x, y, patchWidth, patchHeight);
                 startUpdateCanvasProjection(patchRect);
             }
         }
     }
 }
 
 void KisCanvas2::setDisplayFilter(QSharedPointer<KisDisplayFilter> displayFilter)
 {
     m_d->displayColorConverter.setDisplayFilter(displayFilter);
     KisImageSP image = this->image();
 
     m_d->view->viewManager()->blockUntilOperationsFinishedForced(image);
 
     image->barrierLock();
     m_d->canvasWidget->setDisplayFilter(displayFilter);
     image->unlock();
 }
 
 QSharedPointer<KisDisplayFilter> KisCanvas2::displayFilter() const
 {
     return m_d->displayColorConverter.displayFilter();
 }
 
 void KisCanvas2::slotImageColorSpaceChanged()
 {
     KisImageSP image = this->image();
 
     m_d->view->viewManager()->blockUntilOperationsFinishedForced(image);
 
     m_d->displayColorConverter.setImageColorSpace(image->colorSpace());
 
     image->barrierLock();
     m_d->canvasWidget->notifyImageColorSpaceChanged(image->colorSpace());
     image->unlock();
 }
 
 KisDisplayColorConverter* KisCanvas2::displayColorConverter() const
 {
     return &m_d->displayColorConverter;
 }
 
 KisExposureGammaCorrectionInterface* KisCanvas2::exposureGammaCorrectionInterface() const
 {
     QSharedPointer<KisDisplayFilter> displayFilter = m_d->displayColorConverter.displayFilter();
 
     return displayFilter ?
         displayFilter->correctionInterface() :
         KisDumbExposureGammaCorrectionInterface::instance();
 }
 
 void KisCanvas2::setProofingOptions(bool softProof, bool gamutCheck)
 {
     m_d->proofingConfig = this->image()->proofingConfiguration();
     if (!m_d->proofingConfig) {
         KisImageConfig cfg(false);
         m_d->proofingConfig = cfg.defaultProofingconfiguration();
     }
     KoColorConversionTransformation::ConversionFlags conversionFlags = m_d->proofingConfig->conversionFlags;
 #if QT_VERSION >= 0x050700
 
     if (this->image()->colorSpace()->colorDepthId().id().contains("U")) {
         conversionFlags.setFlag(KoColorConversionTransformation::SoftProofing, softProof);
         if (softProof) {
             conversionFlags.setFlag(KoColorConversionTransformation::GamutCheck, gamutCheck);
         }
     }
 #else
     if (this->image()->colorSpace()->colorDepthId().id().contains("U")) {
         conversionFlags |= KoColorConversionTransformation::SoftProofing;
     } else {
         conversionFlags = conversionFlags & ~KoColorConversionTransformation::SoftProofing;
     }
     if (gamutCheck && softProof && this->image()->colorSpace()->colorDepthId().id().contains("U")) {
         conversionFlags |= KoColorConversionTransformation::GamutCheck;
     } else {
         conversionFlags = conversionFlags & ~KoColorConversionTransformation::GamutCheck;
     }
 #endif
     m_d->proofingConfig->conversionFlags = conversionFlags;
 
     m_d->proofingConfigUpdated = true;
     startUpdateInPatches(this->image()->bounds());
 
 }
 
 void KisCanvas2::slotSoftProofing(bool softProofing)
 {
     m_d->softProofing = softProofing;
     setProofingOptions(m_d->softProofing, m_d->gamutCheck);
 }
 
 void KisCanvas2::slotGamutCheck(bool gamutCheck)
 {
     m_d->gamutCheck = gamutCheck;
     setProofingOptions(m_d->softProofing, m_d->gamutCheck);
 }
 
 void KisCanvas2::slotChangeProofingConfig()
 {
     setProofingOptions(m_d->softProofing, m_d->gamutCheck);
 }
 
 void KisCanvas2::setProofingConfigUpdated(bool updated)
 {
     m_d->proofingConfigUpdated = updated;
 }
 
 bool KisCanvas2::proofingConfigUpdated()
 {
     return m_d->proofingConfigUpdated;
 }
 
 KisProofingConfigurationSP KisCanvas2::proofingConfiguration() const
 {
     if (!m_d->proofingConfig) {
         m_d->proofingConfig = this->image()->proofingConfiguration();
         if (!m_d->proofingConfig) {
             m_d->proofingConfig = KisImageConfig(true).defaultProofingconfiguration();
         }
     }
     return m_d->proofingConfig;
 }
 
 void KisCanvas2::startResizingImage()
 {
     KisImageWSP image = this->image();
     qint32 w = image->width();
     qint32 h = image->height();
 
     emit sigContinueResizeImage(w, h);
 
     QRect imageBounds(0, 0, w, h);
     startUpdateInPatches(imageBounds);
 }
 
 void KisCanvas2::finishResizingImage(qint32 w, qint32 h)
 {
     m_d->canvasWidget->finishResizingImage(w, h);
 }
 
 void KisCanvas2::startUpdateCanvasProjection(const QRect & rc)
 {
     KisUpdateInfoSP info = m_d->canvasWidget->startUpdateCanvasProjection(rc, m_d->channelFlags);
     if (m_d->projectionUpdatesCompressor.putUpdateInfo(info)) {
         emit sigCanvasCacheUpdated();
     }
 }
 
 void KisCanvas2::updateCanvasProjection()
 {
     auto tryIssueCanvasUpdates = [this](const QRect &vRect) {
         if (!m_d->isBatchUpdateActive) {
             // TODO: Implement info->dirtyViewportRect() for KisOpenGLCanvas2 to avoid updating whole canvas
             if (m_d->currentCanvasIsOpenGL) {
                 m_d->savedUpdateRect = QRect();
 
                 // we already had a compression in frameRenderStartCompressor, so force the update directly
                 slotDoCanvasUpdate();
             } else if (/* !m_d->currentCanvasIsOpenGL && */ !vRect.isEmpty()) {
                 m_d->savedUpdateRect = m_d->coordinatesConverter->viewportToWidget(vRect).toAlignedRect();
 
                 // we already had a compression in frameRenderStartCompressor, so force the update directly
                 slotDoCanvasUpdate();
             }
         }
     };
 
     auto uploadData = [this, tryIssueCanvasUpdates](const QVector<KisUpdateInfoSP> &infoObjects) {
         QVector<QRect> viewportRects = m_d->canvasWidget->updateCanvasProjection(infoObjects);
         const QRect vRect = std::accumulate(viewportRects.constBegin(), viewportRects.constEnd(),
                                             QRect(), std::bit_or<QRect>());
 
         tryIssueCanvasUpdates(vRect);
     };
 
     bool shouldExplicitlyIssueUpdates = false;
 
     QVector<KisUpdateInfoSP> infoObjects;
     KisUpdateInfoList originalInfoObjects;
     m_d->projectionUpdatesCompressor.takeUpdateInfo(originalInfoObjects);
 
     for (auto it = originalInfoObjects.constBegin();
          it != originalInfoObjects.constEnd();
          ++it) {
 
         KisUpdateInfoSP info = *it;
 
         const KisMarkerUpdateInfo *batchInfo = dynamic_cast<const KisMarkerUpdateInfo*>(info.data());
         if (batchInfo) {
             if (!infoObjects.isEmpty()) {
                 uploadData(infoObjects);
                 infoObjects.clear();
             }
 
             if (batchInfo->type() == KisMarkerUpdateInfo::StartBatch) {
                 m_d->isBatchUpdateActive++;
             } else if (batchInfo->type() == KisMarkerUpdateInfo::EndBatch) {
                 m_d->isBatchUpdateActive--;
                 KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->isBatchUpdateActive >= 0);
                 if (m_d->isBatchUpdateActive == 0) {
                     shouldExplicitlyIssueUpdates = true;
                 }
             } else if (batchInfo->type() == KisMarkerUpdateInfo::BlockLodUpdates) {
                 m_d->canvasWidget->setLodResetInProgress(true);
             } else if (batchInfo->type() == KisMarkerUpdateInfo::UnblockLodUpdates) {
                 m_d->canvasWidget->setLodResetInProgress(false);
                 shouldExplicitlyIssueUpdates = true;
             }
         } else {
             infoObjects << info;
         }
     }
 
     if (!infoObjects.isEmpty()) {
         uploadData(infoObjects);
     } else if (shouldExplicitlyIssueUpdates) {
         tryIssueCanvasUpdates(m_d->coordinatesConverter->imageRectInImagePixels());
     }
 }
 
 void KisCanvas2::slotBeginUpdatesBatch()
 {
     KisUpdateInfoSP info =
         new KisMarkerUpdateInfo(KisMarkerUpdateInfo::StartBatch,
                                       m_d->coordinatesConverter->imageRectInImagePixels());
     m_d->projectionUpdatesCompressor.putUpdateInfo(info);
     emit sigCanvasCacheUpdated();
 }
 
 void KisCanvas2::slotEndUpdatesBatch()
 {
     KisUpdateInfoSP info =
         new KisMarkerUpdateInfo(KisMarkerUpdateInfo::EndBatch,
                                       m_d->coordinatesConverter->imageRectInImagePixels());
     m_d->projectionUpdatesCompressor.putUpdateInfo(info);
     emit sigCanvasCacheUpdated();
 }
 
 void KisCanvas2::slotSetLodUpdatesBlocked(bool value)
 {
     KisUpdateInfoSP info =
         new KisMarkerUpdateInfo(value ?
                                 KisMarkerUpdateInfo::BlockLodUpdates :
                                 KisMarkerUpdateInfo::UnblockLodUpdates,
                                 m_d->coordinatesConverter->imageRectInImagePixels());
     m_d->projectionUpdatesCompressor.putUpdateInfo(info);
     emit sigCanvasCacheUpdated();
 }
 
 void KisCanvas2::slotDoCanvasUpdate()
 {
     /**
      * WARNING: in isBusy() we access openGL functions without making the painting
      * context current. We hope that currently active context will be Qt's one,
      * which is shared with our own.
      */
     if (m_d->canvasWidget->isBusy()) {
         // just restarting the timer
         updateCanvasWidgetImpl(m_d->savedUpdateRect);
         return;
     }
 
     if (m_d->savedUpdateRect.isEmpty()) {
         m_d->canvasWidget->widget()->update();
         emit updateCanvasRequested(m_d->canvasWidget->widget()->rect());
     } else {
         emit updateCanvasRequested(m_d->savedUpdateRect);
         m_d->canvasWidget->widget()->update(m_d->savedUpdateRect);
     }
 
     m_d->savedUpdateRect = QRect();
 }
 
 void KisCanvas2::updateCanvasWidgetImpl(const QRect &rc)
 {
     if (!m_d->canvasUpdateCompressor.isActive() ||
         !m_d->savedUpdateRect.isEmpty()) {
         m_d->savedUpdateRect |= rc;
     }
     m_d->canvasUpdateCompressor.start();
 }
 
 void KisCanvas2::updateCanvas()
 {
     updateCanvasWidgetImpl();
 }
 
 void KisCanvas2::updateCanvas(const QRectF& documentRect)
 {
     if (m_d->currentCanvasIsOpenGL && m_d->canvasWidget->decorations().size() > 0) {
         updateCanvasWidgetImpl();
     }
     else {
         // updateCanvas is called from tools, never from the projection
         // updates, so no need to prescale!
         QRect widgetRect = m_d->coordinatesConverter->documentToWidget(documentRect).toAlignedRect();
         widgetRect.adjust(-2, -2, 2, 2);
         if (!widgetRect.isEmpty()) {
             updateCanvasWidgetImpl(widgetRect);
         }
     }
 }
 
 void KisCanvas2::disconnectCanvasObserver(QObject *object)
 {
     KoCanvasBase::disconnectCanvasObserver(object);
     m_d->view->disconnect(object);
 }
 
 void KisCanvas2::notifyZoomChanged()
 {
     if (!m_d->currentCanvasIsOpenGL) {
         Q_ASSERT(m_d->prescaledProjection);
         m_d->prescaledProjection->notifyZoomChanged();
     }
 
     notifyLevelOfDetailChange();
     updateCanvas(); // update the canvas, because that isn't done when zooming using KoZoomAction
 
     m_d->regionOfInterestUpdateCompressor.start();
 }
 
 QRect KisCanvas2::regionOfInterest() const
 {
     return m_d->regionOfInterest;
 }
 
 void KisCanvas2::slotUpdateRegionOfInterest()
 {
     const QRect oldRegionOfInterest = m_d->regionOfInterest;
 
     const qreal ratio = 0.25;
     const QRect proposedRoi = KisAlgebra2D::blowRect(m_d->coordinatesConverter->widgetRectInImagePixels(), ratio).toAlignedRect();
 
     const QRect imageRect = m_d->coordinatesConverter->imageRectInImagePixels();
 
     m_d->regionOfInterest = imageRect.contains(proposedRoi) ? proposedRoi : imageRect;
 
     if (m_d->regionOfInterest != oldRegionOfInterest) {
         emit sigRegionOfInterestChanged(m_d->regionOfInterest);
     }
 }
 
 void KisCanvas2::slotReferenceImagesChanged()
 {
     canvasController()->resetScrollBars();
 }
 
 void KisCanvas2::setRenderingLimit(const QRect &rc)
 {
     m_d->renderingLimit = rc;
 }
 
 QRect KisCanvas2::renderingLimit() const
 {
     return m_d->renderingLimit;
 }
 
 void KisCanvas2::slotTrySwitchShapeManager()
 {
     KisNodeSP node = m_d->view->currentNode();
 
     QPointer<KoShapeManager> newManager;
     newManager = fetchShapeManagerFromNode(node);
 
     m_d->setActiveShapeManager(newManager);
 }
 
 void KisCanvas2::notifyLevelOfDetailChange()
 {
     if (!m_d->effectiveLodAllowedInImage()) return;
 
     const qreal effectiveZoom = m_d->coordinatesConverter->effectiveZoom();
 
     KisConfig cfg(true);
     const int maxLod = cfg.numMipmapLevels();
 
     const int lod = KisLodTransform::scaleToLod(effectiveZoom, maxLod);
 
     if (m_d->effectiveLodAllowedInImage()) {
         KisImageSP image = this->image();
         image->setDesiredLevelOfDetail(lod);
     }
 }
 
 const KoColorProfile *  KisCanvas2::monitorProfile()
 {
     return m_d->displayColorConverter.monitorProfile();
 }
 
 KisViewManager* KisCanvas2::viewManager() const
 {
     if (m_d->view) {
         return m_d->view->viewManager();
     }
     return 0;
 }
 
 QPointer<KisView>KisCanvas2::imageView() const
 {
     return m_d->view;
 }
 
 KisImageWSP KisCanvas2::image() const
 {
     return m_d->view->image();
 
 }
 
 KisImageWSP KisCanvas2::currentImage() const
 {
     return m_d->view->image();
 }
 
 void KisCanvas2::documentOffsetMoved(const QPoint &documentOffset)
 {
     QPointF offsetBefore = m_d->coordinatesConverter->imageRectInViewportPixels().topLeft();
 
     // The given offset is in widget logical pixels. In order to prevent fuzzy
     // canvas rendering at 100% pixel-perfect zoom level when devicePixelRatio
     // is not integral, we adjusts the offset to map to whole device pixels.
     //
     // FIXME: This is a temporary hack for fixing the canvas under fractional
     //        DPI scaling before a new coordinate system is introduced.
     QPointF offsetAdjusted = m_d->coordinatesConverter->snapToDevicePixel(documentOffset);
 
     m_d->coordinatesConverter->setDocumentOffset(offsetAdjusted);
     QPointF offsetAfter = m_d->coordinatesConverter->imageRectInViewportPixels().topLeft();
 
     QPointF moveOffset = offsetAfter - offsetBefore;
 
     if (!m_d->currentCanvasIsOpenGL)
         m_d->prescaledProjection->viewportMoved(moveOffset);
 
     emit documentOffsetUpdateFinished();
 
     updateCanvas();
 
     m_d->regionOfInterestUpdateCompressor.start();
 }
 
 void KisCanvas2::slotConfigChanged()
 {
     KisConfig cfg(true);
     m_d->vastScrolling = cfg.vastScrolling();
 
     resetCanvas(cfg.useOpenGL());
 
     // HACK: Sometimes screenNumber(this->canvasWidget()) is not able to get the
     //       proper screenNumber when moving the window across screens. Using
     //       the coordinates should be able to work around this.
     // FIXME: We should change to associate the display profiles with the screen
     //        model and serial number instead. See https://bugs.kde.org/show_bug.cgi?id=407498
     QScreen *canvasScreen = this->canvasWidget()->window()->windowHandle()->screen();
     QPoint canvasScreenCenter = canvasScreen->geometry().center();
     int canvasScreenNumber = QApplication::desktop()->screenNumber(canvasScreenCenter);
     if (canvasScreenNumber == -1) {
         // Fall back to the old way of getting the screenNumber
         canvasScreenNumber = QApplication::desktop()->screenNumber(this->canvasWidget());
     }
     if (canvasScreenNumber != -1) {
         setDisplayProfile(cfg.displayProfile(canvasScreenNumber));
     } else {
         warnUI << "Failed to get screenNumber for updating display profile.";
     }
 
     initializeFpsDecoration();
 }
 
 void KisCanvas2::refetchDataFromImage()
 {
     KisImageSP image = this->image();
     KisImageBarrierLocker l(image);
     startUpdateInPatches(image->bounds());
 }
 
 void KisCanvas2::setDisplayProfile(const KoColorProfile *monitorProfile)
 {
     if (m_d->displayColorConverter.monitorProfile() == monitorProfile) return;
 
     m_d->displayColorConverter.setMonitorProfile(monitorProfile);
 
     {
         KisImageSP image = this->image();
         KisImageBarrierLocker l(image);
         m_d->canvasWidget->setDisplayColorConverter(&m_d->displayColorConverter);
     }
 
     refetchDataFromImage();
 }
 
 void KisCanvas2::addDecoration(KisCanvasDecorationSP deco)
 {
     m_d->canvasWidget->addDecoration(deco);
 }
 
 KisCanvasDecorationSP KisCanvas2::decoration(const QString& id) const
 {
     return m_d->canvasWidget->decoration(id);
 }
 
 
 QPoint KisCanvas2::documentOrigin() const
 {
     /**
      * In Krita we don't use document origin anymore.
      * All the centering when needed (vastScrolling < 0.5) is done
      * automatically by the KisCoordinatesConverter.
      */
 
     return QPoint();
 }
 
 QPoint KisCanvas2::documentOffset() const
 {
     return m_d->coordinatesConverter->documentOffset();
 }
 
 void KisCanvas2::setFavoriteResourceManager(KisFavoriteResourceManager* favoriteResourceManager)
 {
     m_d->popupPalette = new KisPopupPalette(viewManager(), m_d->coordinatesConverter, favoriteResourceManager, displayColorConverter()->displayRendererInterface(),
                                             m_d->view->resourceProvider(), m_d->canvasWidget->widget());
     connect(m_d->popupPalette, SIGNAL(zoomLevelChanged(int)), this, SLOT(slotPopupPaletteRequestedZoomChange(int)));
     connect(m_d->popupPalette, SIGNAL(sigUpdateCanvas()), this, SLOT(updateCanvas()));
     connect(m_d->view->mainWindow(), SIGNAL(themeChanged()), m_d->popupPalette, SLOT(slotUpdateIcons()));
 
     m_d->popupPalette->showPopupPalette(false);
 }
 
 void KisCanvas2::slotPopupPaletteRequestedZoomChange(int zoom ) {
     m_d->view->viewManager()->zoomController()->setZoom(KoZoomMode::ZOOM_CONSTANT, (qreal)(zoom/100.0)); // 1.0 is 100% zoom
     notifyZoomChanged();
 }
 
 void KisCanvas2::setCursor(const QCursor &cursor)
 {
     canvasWidget()->setCursor(cursor);
 }
 
 KisAnimationFrameCacheSP KisCanvas2::frameCache() const
 {
     return m_d->frameCache;
 }
 
 KisAnimationPlayer *KisCanvas2::animationPlayer() const
 {
     return m_d->animationPlayer;
 }
 
 void KisCanvas2::slotSelectionChanged()
 {
     KisShapeLayer* shapeLayer = dynamic_cast<KisShapeLayer*>(viewManager()->activeLayer().data());
     if (!shapeLayer) {
         return;
     }
     m_d->shapeManager.selection()->deselectAll();
     Q_FOREACH (KoShape* shape, shapeLayer->shapeManager()->selection()->selectedShapes()) {
         m_d->shapeManager.selection()->select(shape);
     }
 }
 
 bool KisCanvas2::isPopupPaletteVisible() const
 {
     if (!m_d->popupPalette) {
         return false;
     }
     return m_d->popupPalette->isVisible();
 }
 
 
 void KisCanvas2::setWrapAroundViewingMode(bool value)
 {
     KisCanvasDecorationSP infinityDecoration =
         m_d->canvasWidget->decoration(INFINITY_DECORATION_ID);
 
     if (infinityDecoration) {
         infinityDecoration->setVisible(!value);
     }
 
     m_d->canvasWidget->setWrapAroundViewingMode(value);
 }
 
 bool KisCanvas2::wrapAroundViewingMode() const
 {
     KisCanvasDecorationSP infinityDecoration =
         m_d->canvasWidget->decoration(INFINITY_DECORATION_ID);
 
     if (infinityDecoration) {
         return !(infinityDecoration->visible());
     }
     return false;
 }
 
 void KisCanvas2::bootstrapFinished()
 {
     if (!m_d->bootstrapLodBlocked) return;
 
     m_d->bootstrapLodBlocked = false;
     setLodAllowedInCanvas(m_d->lodAllowedInImage);
 }
 
 void KisCanvas2::setLodAllowedInCanvas(bool value)
 {
     if (!KisOpenGL::supportsLoD()) {
         qWarning() << "WARNING: Level of Detail functionality is available only with openGL + GLSL 1.3 support";
     }
 
     m_d->lodAllowedInImage =
         value &&
         m_d->currentCanvasIsOpenGL &&
         KisOpenGL::supportsLoD() &&
         (m_d->openGLFilterMode == KisOpenGL::TrilinearFilterMode ||
          m_d->openGLFilterMode == KisOpenGL::HighQualityFiltering);
 
     KisImageSP image = this->image();
 
     if (m_d->effectiveLodAllowedInImage() != !image->levelOfDetailBlocked()) {
         image->setLevelOfDetailBlocked(!m_d->effectiveLodAllowedInImage());
     }
 
     notifyLevelOfDetailChange();
 
     KisConfig cfg(false);
     cfg.setLevelOfDetailEnabled(m_d->lodAllowedInImage);
 
     KisUsageLogger::log(QString("Instant Preview Setting: %1").arg(m_d->lodAllowedInImage));
 }
 
 bool KisCanvas2::lodAllowedInCanvas() const
 {
     return m_d->lodAllowedInImage;
 }
 
 void KisCanvas2::slotShowPopupPalette(const QPoint &p)
 {
     if (!m_d->popupPalette) {
         return;
     }
 
     m_d->popupPalette->showPopupPalette(p);
 }
 
 KisPaintingAssistantsDecorationSP KisCanvas2::paintingAssistantsDecoration() const
 {
     KisCanvasDecorationSP deco = decoration("paintingAssistantsDecoration");
     return qobject_cast<KisPaintingAssistantsDecoration*>(deco.data());
 }
 
 KisReferenceImagesDecorationSP KisCanvas2::referenceImagesDecoration() const
 {
     KisCanvasDecorationSP deco = decoration("referenceImagesDecoration");
     return qobject_cast<KisReferenceImagesDecoration*>(deco.data());
 }
diff --git a/libs/ui/canvas/kis_canvas2.h b/libs/ui/canvas/kis_canvas2.h
index c2fa2b4b0e..e057c038dc 100644
--- a/libs/ui/canvas/kis_canvas2.h
+++ b/libs/ui/canvas/kis_canvas2.h
@@ -1,352 +1,352 @@
 /* This file is part of the KDE project
  * Copyright (C) 2006, 2010 Boudewijn Rempt <boud@valdyas.org>
  * 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.
  */
 
 #ifndef KIS_CANVAS_H
 #define KIS_CANVAS_H
 
 #include <QObject>
 #include <QWidget>
 #include <QSize>
 #include <QString>
 
 #include <KoConfig.h>
 #include <KoColorConversionTransformation.h>
 #include <KoCanvasBase.h>
 #include <kritaui_export.h>
 #include <kis_types.h>
 #include <KoPointerEvent.h>
 
 #include "opengl/kis_opengl.h"
 
 #include "kis_ui_types.h"
 #include "kis_coordinates_converter.h"
 #include "kis_canvas_decoration.h"
 #include "kis_painting_assistants_decoration.h"
 #include "input/KisInputActionGroup.h"
 #include "KisReferenceImagesDecoration.h"
 
 class KoToolProxy;
 class KoColorProfile;
 
 
 class KisViewManager;
 class KisFavoriteResourceManager;
 class KisDisplayFilter;
 class KisDisplayColorConverter;
 struct KisExposureGammaCorrectionInterface;
 class KisView;
 class KisInputManager;
 class KisAnimationPlayer;
 class KisShapeController;
 class KisCoordinatesConverter;
 class KoViewConverter;
 class KisAbstractCanvasWidget;
 
 /**
  * KisCanvas2 is not an actual widget class, but rather an adapter for
  * the widget it contains, which may be either a QPainter based
  * canvas, or an OpenGL based canvas: that are the real widgets.
  */
 class KRITAUI_EXPORT KisCanvas2 : public KoCanvasBase, public KisInputActionGroupsMaskInterface
 {
 
     Q_OBJECT
 
 public:
 
     /**
      * Create a new canvas. The canvas manages a widget that will do
      * the actual painting: the canvas itself is not a widget.
      *
      * @param viewConverter the viewconverter for converting between
      *                       window and document coordinates.
      */
-    KisCanvas2(KisCoordinatesConverter *coordConverter, KoCanvasResourceProvider *resourceManager, KisView *view, KoShapeControllerBase *sc);
+    KisCanvas2(KisCoordinatesConverter *coordConverter, KoCanvasResourceProvider *resourceManager, KisMainWindow *mainWindow, KisView *view, KoShapeControllerBase *sc);
 
     ~KisCanvas2() override;
 
     void notifyZoomChanged();
 
     void disconnectCanvasObserver(QObject *object) override;
 
 public: // KoCanvasBase implementation
 
     bool canvasIsOpenGL() const override;
 
     KisOpenGL::FilterMode openGLFilterMode() const;
 
     void gridSize(QPointF *offset, QSizeF *spacing) const override;
 
     bool snapToGrid() const override;
 
     // This method only exists to support flake-related operations
     void addCommand(KUndo2Command *command) override;
 
     QPoint documentOrigin() const override;
     QPoint documentOffset() const;
 
     /**
      * Return the right shape manager for the current layer. That is
      * to say, if the current layer is a vector layer, return the shape
      * layer's canvas' shapemanager, else the shapemanager associated
      * with the global krita canvas.
      */
     KoShapeManager * shapeManager() const override;
 
     /**
      * Since shapeManager() may change, we need a persistent object where we can
      * connect to and thack the selection. See more comments in KoCanvasBase.
      */
     KoSelectedShapesProxy *selectedShapesProxy() const override;
 
     /**
      * Return the shape manager associated with this canvas
      */
     KoShapeManager *globalShapeManager() const;
 
     /**
      * Return shape manager associated with the currently active node.
      * If current node has no internal shape manager, return null.
      */
     KoShapeManager *localShapeManager() const;
 
 
     void updateCanvas(const QRectF& rc) override;
 
     void updateInputMethodInfo() override;
 
     const KisCoordinatesConverter* coordinatesConverter() const;
     KoViewConverter *viewConverter() const override;
 
     QWidget* canvasWidget() override;
 
     const QWidget* canvasWidget() const override;
 
     KoUnit unit() const override;
 
     KoToolProxy* toolProxy() const override;
 
     const KoColorProfile* monitorProfile();
 
     // FIXME:
     // Temporary! Either get the current layer and image from the
     // resource provider, or use this, which gets them from the
     // current shape selection.
     KisImageWSP currentImage() const;
 
     /**
      * Filters events and sends them to canvas actions. Shared
      * among all the views/canvases
      *
      * NOTE: May be null while initialization!
      */
     KisInputManager* globalInputManager() const;
 
     /**
      * Return the mask of currently available input action groups
      * Note: Override from KisInputActionGroupsMaskInterface
      */
     KisInputActionGroupsMask inputActionGroupsMask() const override;
 
     /**
      * Set the mask of currently available action groups
      * Note: Override from KisInputActionGroupsMaskInterface
      */
     void setInputActionGroupsMask(KisInputActionGroupsMask mask) override;
 
     KisPaintingAssistantsDecorationSP paintingAssistantsDecoration() const;
     KisReferenceImagesDecorationSP referenceImagesDecoration() const;
 
 public: // KisCanvas2 methods
 
     KisImageWSP image() const;
     KisViewManager* viewManager() const;
     QPointer<KisView> imageView() const;
 
     /// @return true if the canvas image should be displayed in vertically mirrored mode
     void addDecoration(KisCanvasDecorationSP deco);
     KisCanvasDecorationSP decoration(const QString& id) const;
 
     void setDisplayFilter(QSharedPointer<KisDisplayFilter> displayFilter);
     QSharedPointer<KisDisplayFilter> displayFilter() const;
 
     KisDisplayColorConverter *displayColorConverter() const;
     KisExposureGammaCorrectionInterface* exposureGammaCorrectionInterface() const;
 
     /**
      * @brief setProofingOptions
      * set the options for softproofing, without affecting the proofing options as stored inside the image.
      */
     void setProofingOptions(bool softProof, bool gamutCheck);
     KisProofingConfigurationSP proofingConfiguration() const;
 
     /**
      * @brief setProofingConfigUpdated This function is to set whether the proofing config is updated,
      * this is needed for determining whether or not to generate a new proofing transform.
      * @param updated whether it's updated. Just set it to false in normal usage.
      */
     void setProofingConfigUpdated(bool updated);
 
     /**
      * @brief proofingConfigUpdated ask the canvas whether or not it updated the proofing config.
      * @return whether or not the proofing config is updated, if so, a new proofing transform needs to be made
      * in KisOpenGL canvas.
      */
     bool proofingConfigUpdated();
 
     void setCursor(const QCursor &cursor) override;
     KisAnimationFrameCacheSP frameCache() const;
     KisAnimationPlayer *animationPlayer() const;
     void refetchDataFromImage();
 
     /**
      * @return area of the image (in image coordinates) that is visible on the canvas
      * with a small margin selected by the user
      */
     QRect regionOfInterest() const;
 
     /**
      * Set artificial limit outside which the image will not be rendered
      * \p rc is measured in image pixels
      */
     void setRenderingLimit(const QRect &rc);
 
     /**
      * @return aftificial limit outside which the image will not be rendered
      */
     QRect renderingLimit() const;
 
 Q_SIGNALS:
     void sigCanvasEngineChanged();
 
     void sigCanvasCacheUpdated();
     void sigContinueResizeImage(qint32 w, qint32 h);
 
     void documentOffsetUpdateFinished();
 
     // emitted whenever the canvas widget thinks sketch should update
     void updateCanvasRequested(const QRect &rc);
 
     void sigRegionOfInterestChanged(const QRect &roi);
 
 public Q_SLOTS:
 
     /// Update the entire canvas area
     void updateCanvas();
 
     void startResizingImage();
     void finishResizingImage(qint32 w, qint32 h);
 
     /// canvas rotation in degrees
     qreal rotationAngle() const;
     /// Bools indicating canvasmirroring.
     bool xAxisMirrored() const;
     bool yAxisMirrored() const;
     void slotSoftProofing(bool softProofing);
     void slotGamutCheck(bool gamutCheck);
     void slotChangeProofingConfig();
     void slotPopupPaletteRequestedZoomChange(int zoom);
 
     void channelSelectionChanged();
 
     void startUpdateInPatches(const QRect &imageRect);
 
     void slotTrySwitchShapeManager();
 
     /**
      * Called whenever the configuration settings change.
      */
     void slotConfigChanged();
 
 
 private Q_SLOTS:
 
     /// The image projection has changed, now start an update
     /// of the canvas representation.
     void startUpdateCanvasProjection(const QRect & rc);
     void updateCanvasProjection();
 
     void slotBeginUpdatesBatch();
     void slotEndUpdatesBatch();
     void slotSetLodUpdatesBlocked(bool value);
 
     /**
      * Called whenever the view widget needs to show a different part of
      * the document
      *
      * @param documentOffset the offset in widget pixels
      */
     void documentOffsetMoved(const QPoint &documentOffset);
 
     void slotSelectionChanged();
 
     void slotDoCanvasUpdate();
 
     void bootstrapFinished();
 
     void slotUpdateRegionOfInterest();
 
     void slotReferenceImagesChanged();
 
     void slotImageColorSpaceChanged();
 public:
 
     bool isPopupPaletteVisible() const;
     void slotShowPopupPalette(const QPoint& = QPoint(0,0));
 
     // interface for KisCanvasController only
     void setWrapAroundViewingMode(bool value);
     bool wrapAroundViewingMode() const;
 
     void setLodAllowedInCanvas(bool value);
     bool lodAllowedInCanvas() const;
 
     void initializeImage();
 
     void setFavoriteResourceManager(KisFavoriteResourceManager* favoriteResourceManager);
 
 private:
     Q_DISABLE_COPY(KisCanvas2)
 
     void connectCurrentCanvas();
     void createCanvas(bool useOpenGL);
     void createQPainterCanvas();
     void createOpenGLCanvas();
     void updateCanvasWidgetImpl(const QRect &rc = QRect());
     void setCanvasWidget(KisAbstractCanvasWidget *widget);
     void resetCanvas(bool useOpenGL);
     void setDisplayProfile(const KoColorProfile *profile);
 
     void notifyLevelOfDetailChange();
 
     // Completes construction of canvas.
     // To be called by KisView in its constructor, once it has been setup enough
     // (to be defined what that means) for things KisCanvas2 expects from KisView
     // TODO: see to avoid that
     void setup();
 
     void initializeFpsDecoration();
 
 private:
     friend class KisView; // calls setup()
     class KisCanvas2Private;
     KisCanvas2Private * const m_d;
 };
 
 #endif
diff --git a/libs/ui/canvas/kis_canvas_controller.cpp b/libs/ui/canvas/kis_canvas_controller.cpp
index 2ab25dec3b..8e5b209c97 100644
--- a/libs/ui/canvas/kis_canvas_controller.cpp
+++ b/libs/ui/canvas/kis_canvas_controller.cpp
@@ -1,398 +1,386 @@
 /*
  *  Copyright (c) 2010 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_canvas_controller.h"
 
 #include <QMouseEvent>
 #include <QScrollBar>
 #include <QTabletEvent>
 
 #include <klocalizedstring.h>
 #include <kactioncollection.h>
 #include "kis_canvas_decoration.h"
-#include "kis_paintop_transformation_connector.h"
 #include "kis_coordinates_converter.h"
 #include "kis_canvas2.h"
 #include "opengl/kis_opengl_canvas2.h"
 #include "KisDocument.h"
 #include "kis_image.h"
 #include "KisViewManager.h"
 #include "KisView.h"
 #include "krita_utils.h"
 #include "kis_config.h"
 #include "kis_signal_compressor_with_param.h"
 #include "kis_config_notifier.h"
 
 static const int gRulersUpdateDelay = 80 /* ms */;
 
 struct KisCanvasController::Private {
     Private(KisCanvasController *qq)
-        : q(qq),
-          paintOpTransformationConnector(0)
+        : q(qq)
     {
         using namespace std::placeholders;
 
         std::function<void (QPoint)> callback(
             std::bind(&KisCanvasController::Private::emitPointerPositionChangedSignals, this, _1));
 
         mousePositionCompressor.reset(
             new KisSignalCompressorWithParam<QPoint>(
                 gRulersUpdateDelay,
                 callback,
                 KisSignalCompressor::FIRST_ACTIVE));
     }
 
     QPointer<KisView> view;
     KisCoordinatesConverter *coordinatesConverter;
     KisCanvasController *q;
-    KisPaintopTransformationConnector *paintOpTransformationConnector;
     QScopedPointer<KisSignalCompressorWithParam<QPoint> > mousePositionCompressor;
 
     void emitPointerPositionChangedSignals(QPoint pointerPos);
     void updateDocumentSizeAfterTransform();
     void showRotationValueOnCanvas();
     void showMirrorStateOnCanvas();
 };
 
 void KisCanvasController::Private::emitPointerPositionChangedSignals(QPoint pointerPos)
 {
     if (!coordinatesConverter) return;
 
     QPointF documentPos = coordinatesConverter->widgetToDocument(pointerPos);
 
     q->proxyObject->emitDocumentMousePositionChanged(documentPos);
     q->proxyObject->emitCanvasMousePositionChanged(pointerPos);
 }
 
 void KisCanvasController::Private::updateDocumentSizeAfterTransform()
 {
     // round the size of the area to the nearest integer instead of getting aligned rect
     QSize widgetSize = coordinatesConverter->imageRectInWidgetPixels().toRect().size();
     q->updateDocumentSize(widgetSize, true);
 
     KisCanvas2 *kritaCanvas = dynamic_cast<KisCanvas2*>(q->canvas());
     Q_ASSERT(kritaCanvas);
 
     kritaCanvas->notifyZoomChanged();
 }
 
 
-KisCanvasController::KisCanvasController(QPointer<KisView>parent, KActionCollection * actionCollection)
-    : KoCanvasControllerWidget(actionCollection, parent),
+KisCanvasController::KisCanvasController(QPointer<KisView>parent, KoCanvasSupervisor *observerProvider, KActionCollection * actionCollection)
+    : KoCanvasControllerWidget(actionCollection, observerProvider, parent),
       m_d(new Private(this))
 {
     m_d->view = parent;
 }
 
 KisCanvasController::~KisCanvasController()
 {
     delete m_d;
 }
 
 void KisCanvasController::setCanvas(KoCanvasBase *canvas)
 {
     if (canvas) {
         KisCanvas2 *kritaCanvas = dynamic_cast<KisCanvas2*>(canvas);
         KIS_SAFE_ASSERT_RECOVER_RETURN(kritaCanvas);
 
         m_d->coordinatesConverter =
             const_cast<KisCoordinatesConverter*>(kritaCanvas->coordinatesConverter());
-
-        m_d->paintOpTransformationConnector =
-            new KisPaintopTransformationConnector(kritaCanvas, this);
     } else {
         m_d->coordinatesConverter = 0;
-
-        delete m_d->paintOpTransformationConnector;
-        m_d->paintOpTransformationConnector = 0;
     }
 
     KoCanvasControllerWidget::setCanvas(canvas);
 }
 
 void KisCanvasController::activate()
 {
     KoCanvasControllerWidget::activate();
 }
 
 QPointF KisCanvasController::currentCursorPosition() const
 {
     KoCanvasBase *canvas = m_d->view->canvasBase();
     QWidget *canvasWidget = canvas->canvasWidget();
     const QPointF cursorPosWidget = canvasWidget->mapFromGlobal(QCursor::pos());
 
     return m_d->coordinatesConverter->widgetToDocument(cursorPosWidget);
 }
 
 void KisCanvasController::keyPressEvent(QKeyEvent *event)
 {
     /**
      * Dirty Hack Alert:
      * Do not call the KoCanvasControllerWidget::keyPressEvent()
      * to avoid activation of Pan and Default tool activation shortcuts
      */
     Q_UNUSED(event);
 }
 
 void KisCanvasController::wheelEvent(QWheelEvent *event)
 {
     /**
      * Dirty Hack Alert:
      * Do not call the KoCanvasControllerWidget::wheelEvent()
      * to disable the default behavior of KoCanvasControllerWidget and QAbstractScrollArea
      */
     Q_UNUSED(event);
 }
 
 bool KisCanvasController::eventFilter(QObject *watched, QEvent *event)
 {
     KoCanvasBase *canvas = this->canvas();
     if (!canvas || !canvas->canvasWidget() || canvas->canvasWidget() != watched) return false;
 
     if (event->type() == QEvent::MouseMove) {
         QMouseEvent *mevent = static_cast<QMouseEvent*>(event);
         m_d->mousePositionCompressor->start(mevent->pos());
     } else if (event->type() == QEvent::TabletMove) {
         QTabletEvent *tevent = static_cast<QTabletEvent*>(event);
         m_d->mousePositionCompressor->start(tevent->pos());
     } else if (event->type() == QEvent::FocusIn) {
         m_d->view->syncLastActiveNodeToDocument();
     }
 
     return false;
 }
 
 void KisCanvasController::updateDocumentSize(const QSizeF &sz, bool recalculateCenter)
 {
     KoCanvasControllerWidget::updateDocumentSize(sz, recalculateCenter);
 
     emit documentSizeChanged();
 }
 
 void KisCanvasController::Private::showMirrorStateOnCanvas()
 {
     bool isXMirrored = coordinatesConverter->xAxisMirrored();
 
     view->viewManager()->
         showFloatingMessage(
             i18nc("floating message about mirroring",
                   "Horizontal mirroring: %1 ", isXMirrored ? i18n("ON") : i18n("OFF")),
             QIcon(), 500, KisFloatingMessage::Low);
 }
 
 void KisCanvasController::mirrorCanvas(bool enable)
 {
     QPoint newOffset = m_d->coordinatesConverter->mirror(m_d->coordinatesConverter->widgetCenterPoint(), enable, false);
     m_d->updateDocumentSizeAfterTransform();
     setScrollBarValue(newOffset);
-    m_d->paintOpTransformationConnector->notifyTransformationChanged();
     m_d->showMirrorStateOnCanvas();
 }
 
 void KisCanvasController::Private::showRotationValueOnCanvas()
 {
     qreal rotationAngle = coordinatesConverter->rotationAngle();
     view->viewManager()->
         showFloatingMessage(
             i18nc("floating message about rotation", "Rotation: %1° ",
                   KritaUtils::prettyFormatReal(rotationAngle)),
             QIcon(), 500, KisFloatingMessage::Low, Qt::AlignCenter);
 }
 
 void KisCanvasController::rotateCanvas(qreal angle, const QPointF &center)
 {
     QPoint newOffset = m_d->coordinatesConverter->rotate(center, angle);
     m_d->updateDocumentSizeAfterTransform();
     setScrollBarValue(newOffset);
-    m_d->paintOpTransformationConnector->notifyTransformationChanged();
     m_d->showRotationValueOnCanvas();
 }
 
 void KisCanvasController::rotateCanvas(qreal angle)
 {
     rotateCanvas(angle, m_d->coordinatesConverter->widgetCenterPoint());
 }
 
 void KisCanvasController::rotateCanvasRight15()
 {
     rotateCanvas(15.0);
 }
 
 void KisCanvasController::rotateCanvasLeft15()
 {
     rotateCanvas(-15.0);
 }
 
 qreal KisCanvasController::rotation() const
 {
     return m_d->coordinatesConverter->rotationAngle();
 }
 
 void KisCanvasController::resetCanvasRotation()
 {
     QPoint newOffset = m_d->coordinatesConverter->resetRotation(m_d->coordinatesConverter->widgetCenterPoint());
     m_d->updateDocumentSizeAfterTransform();
     setScrollBarValue(newOffset);
-    m_d->paintOpTransformationConnector->notifyTransformationChanged();
     m_d->showRotationValueOnCanvas();
 }
 
 void KisCanvasController::slotToggleWrapAroundMode(bool value)
 {
     KisCanvas2 *kritaCanvas = dynamic_cast<KisCanvas2*>(canvas());
     Q_ASSERT(kritaCanvas);
 
     if (!canvas()->canvasIsOpenGL() && value) {
         m_d->view->viewManager()->showFloatingMessage(i18n("You are activating wrap-around mode, but have not enabled OpenGL.\n"
                                                           "To visualize wrap-around mode, enable OpenGL."), QIcon());
     }
     kritaCanvas->setWrapAroundViewingMode(value);
     kritaCanvas->image()->setWrapAroundModePermitted(value);
 }
 
 bool KisCanvasController::wrapAroundMode() const
 {
     KisCanvas2 *kritaCanvas = dynamic_cast<KisCanvas2*>(canvas());
     Q_ASSERT(kritaCanvas);
 
     return kritaCanvas->wrapAroundViewingMode();
 }
 
 void KisCanvasController::slotTogglePixelGrid(bool value)
 {
     KisConfig cfg(false);
     cfg.enablePixelGrid(value);
 
     KisConfigNotifier::instance()->notifyPixelGridModeChanged();
 }
 
 void KisCanvasController::slotToggleLevelOfDetailMode(bool value)
 {
     KisCanvas2 *kritaCanvas = dynamic_cast<KisCanvas2*>(canvas());
     Q_ASSERT(kritaCanvas);
 
     kritaCanvas->setLodAllowedInCanvas(value);
 
     bool result = levelOfDetailMode();
 
     if (!value || result) {
         m_d->view->viewManager()->showFloatingMessage(
             i18n("Instant Preview Mode: %1", result ?
                  i18n("ON") : i18n("OFF")),
             QIcon(), 500, KisFloatingMessage::Low);
     } else {
         QString reason;
 
         if (!kritaCanvas->canvasIsOpenGL()) {
             reason = i18n("Instant Preview is only supported with OpenGL activated");
         }
         else if (kritaCanvas->openGLFilterMode() == KisOpenGL::BilinearFilterMode ||
                    kritaCanvas->openGLFilterMode() == KisOpenGL::NearestFilterMode) {
             QString filteringMode =
                 kritaCanvas->openGLFilterMode() == KisOpenGL::BilinearFilterMode ?
                 i18n("Bilinear") : i18n("Nearest Neighbour");
             reason = i18n("Instant Preview is supported\n in Trilinear or High Quality filtering modes.\nCurrent mode is %1", filteringMode);
         }
 
         m_d->view->viewManager()->showFloatingMessage(
             i18n("Failed activating Instant Preview mode!\n\n%1", reason),
             QIcon(), 5000, KisFloatingMessage::Low);
     }
 
 
 }
 
 bool KisCanvasController::levelOfDetailMode() const
 {
     KisCanvas2 *kritaCanvas = dynamic_cast<KisCanvas2*>(canvas());
     Q_ASSERT(kritaCanvas);
 
     return kritaCanvas->lodAllowedInCanvas();
 }
 
 void KisCanvasController::saveCanvasState(KisPropertiesConfiguration &config) const
 {
     const QPointF &center = preferredCenter();
     config.setProperty("panX", center.x());
     config.setProperty("panY", center.y());
 
     config.setProperty("rotation", rotation());
     config.setProperty("mirror", m_d->coordinatesConverter->xAxisMirrored());
     config.setProperty("wrapAround", wrapAroundMode());
     config.setProperty("enableInstantPreview", levelOfDetailMode());
 }
 
 void KisCanvasController::restoreCanvasState(const KisPropertiesConfiguration &config)
 {
     KisCanvas2 *kritaCanvas = dynamic_cast<KisCanvas2*>(canvas());
     Q_ASSERT(kritaCanvas);
 
     mirrorCanvas(config.getBool("mirror", false));
     rotateCanvas(config.getFloat("rotation", 0.0f));
 
     const QPointF &center = preferredCenter();
     float panX = config.getFloat("panX", center.x());
     float panY = config.getFloat("panY", center.y());
     setPreferredCenter(QPointF(panX, panY));
 
     slotToggleWrapAroundMode(config.getBool("wrapAround", false));
     kritaCanvas->setLodAllowedInCanvas(config.getBool("enableInstantPreview", false));
 }
 
 void KisCanvasController::resetScrollBars()
 {
     // The scrollbar value always points at the top-left corner of the
     // bit of image we paint.
 
     KisDocument *doc = m_d->view->document();
     if (!doc) return;
 
     QRectF documentBounds = doc->documentBounds();
     QRectF viewRect = m_d->coordinatesConverter->imageToWidget(documentBounds);
 
     // Cancel out any existing pan
     const QRectF imageBounds = m_d->view->image()->bounds();
     const QRectF imageBB = m_d->coordinatesConverter->imageToWidget(imageBounds);
     QPointF pan = imageBB.topLeft();
     viewRect.translate(-pan);
 
     int drawH = viewport()->height();
     int drawW = viewport()->width();
 
     qreal horizontalReserve = vastScrollingFactor() * drawW;
     qreal verticalReserve = vastScrollingFactor() * drawH;
 
     qreal xMin = viewRect.left() - horizontalReserve;
     qreal yMin = viewRect.top() - verticalReserve;
 
     qreal xMax = viewRect.right() - drawW + horizontalReserve;
     qreal yMax = viewRect.bottom() - drawH + verticalReserve;
 
     QScrollBar *hScroll = horizontalScrollBar();
     QScrollBar *vScroll = verticalScrollBar();
 
     hScroll->setRange(static_cast<int>(xMin), static_cast<int>(xMax));
     vScroll->setRange(static_cast<int>(yMin), static_cast<int>(yMax));
 
     int fontHeight = QFontMetrics(font()).height();
 
     vScroll->setPageStep(drawH);
     vScroll->setSingleStep(fontHeight);
     hScroll->setPageStep(drawW);
     hScroll->setSingleStep(fontHeight);
 }
diff --git a/libs/ui/canvas/kis_canvas_controller.h b/libs/ui/canvas/kis_canvas_controller.h
index c1226313be..756c6bf59d 100644
--- a/libs/ui/canvas/kis_canvas_controller.h
+++ b/libs/ui/canvas/kis_canvas_controller.h
@@ -1,77 +1,78 @@
 /*
  *  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_CANVAS_CONTROLLER_H
 #define KIS_CANVAS_CONTROLLER_H
 
 #include <KoCanvasControllerWidget.h>
+#include <libs/flake/KoCanvasSupervisor.h>
 
 #include "kritaui_export.h"
 #include "kis_types.h"
 
 class KConfigGroup;
 class KisView;
 
 class KRITAUI_EXPORT KisCanvasController : public KoCanvasControllerWidget
 {
     Q_OBJECT
 
 public:
-    KisCanvasController(QPointer<KisView>parent, KActionCollection * actionCollection);
+    KisCanvasController(QPointer<KisView>parent, KoCanvasSupervisor *observerProvider, KActionCollection * actionCollection);
     ~KisCanvasController() override;
 
     void setCanvas(KoCanvasBase *canvas) override;
     void keyPressEvent(QKeyEvent *event) override;
     void wheelEvent(QWheelEvent *event) override;
     bool eventFilter(QObject *watched, QEvent *event) override;
     void updateDocumentSize(const QSizeF &sz, bool recalculateCenter) override;
     void activate() override;
 
     QPointF currentCursorPosition() const override;
 
 public:
     using KoCanvasController::documentSize;
     bool wrapAroundMode() const;
     bool levelOfDetailMode() const;
 
     void saveCanvasState(KisPropertiesConfiguration &config) const;
     void restoreCanvasState(const KisPropertiesConfiguration &config);
 
     void resetScrollBars() override;
 
 public Q_SLOTS:
     void mirrorCanvas(bool enable);
     void rotateCanvas(qreal angle, const QPointF &center);
     void rotateCanvas(qreal angle);
     void rotateCanvasRight15();
     void rotateCanvasLeft15();
     qreal rotation() const;
     void resetCanvasRotation();
     void slotToggleWrapAroundMode(bool value);
     void slotTogglePixelGrid(bool value);
     void slotToggleLevelOfDetailMode(bool value);
 
 Q_SIGNALS:
     void documentSizeChanged();
 
 private:
     struct Private;
     Private * const m_d;
 };
 
 #endif /* KIS_CANVAS_CONTROLLER_H */
diff --git a/libs/ui/canvas/kis_canvas_updates_compressor.cpp b/libs/ui/canvas/kis_canvas_updates_compressor.cpp
index e5e2769a49..8d6b5d3c97 100644
--- a/libs/ui/canvas/kis_canvas_updates_compressor.cpp
+++ b/libs/ui/canvas/kis_canvas_updates_compressor.cpp
@@ -1,56 +1,59 @@
 /*
  *  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_canvas_updates_compressor.h"
 
 bool KisCanvasUpdatesCompressor::putUpdateInfo(KisUpdateInfoSP info)
 {
     const int levelOfDetail = info->levelOfDetail();
     const QRect newUpdateRect = info->dirtyImageRect();
     if (newUpdateRect.isEmpty()) return false;
 
     QMutexLocker l(&m_mutex);
-    KisUpdateInfoList::iterator it = m_updatesList.begin();
-
-    while (it != m_updatesList.end()) {
-        if (levelOfDetail == (*it)->levelOfDetail() &&
-            newUpdateRect.contains((*it)->dirtyImageRect())) {
-
-            /**
-             * We should always remove the overridden update and put 'info' to the end
-             * of the queue. Otherwise, the updates will become reordered and the canvas
-             * may have tiles artifacts with "outdated" data
-             */
-            it = m_updatesList.erase(it);
-        } else {
-            ++it;
+
+    if (info->canBeCompressed()) {
+        KisUpdateInfoList::iterator it = m_updatesList.begin();
+        while (it != m_updatesList.end()) {
+            if ((*it)->canBeCompressed() &&
+                levelOfDetail == (*it)->levelOfDetail() &&
+                newUpdateRect.contains((*it)->dirtyImageRect())) {
+
+                /**
+                 * We should always remove the overridden update and put 'info' to the end
+                 * of the queue. Otherwise, the updates will become reordered and the canvas
+                 * may have tiles artifacts with "outdated" data
+                 */
+                it = m_updatesList.erase(it);
+            } else {
+                ++it;
+            }
         }
     }
 
     m_updatesList.append(info);
 
     return m_updatesList.size() <= 1;
 }
 
 void KisCanvasUpdatesCompressor::takeUpdateInfo(KisUpdateInfoList &list)
 {
     KIS_SAFE_ASSERT_RECOVER(list.isEmpty()) { list.clear(); }
 
     QMutexLocker l(&m_mutex);
     m_updatesList.swap(list);
 }
diff --git a/libs/ui/canvas/kis_coordinates_converter.cpp b/libs/ui/canvas/kis_coordinates_converter.cpp
index 9470fd866b..19cc69db31 100644
--- a/libs/ui/canvas/kis_coordinates_converter.cpp
+++ b/libs/ui/canvas/kis_coordinates_converter.cpp
@@ -1,486 +1,490 @@
 /*
  *  Copyright (c) 2010 Dmitry Kazakov <dimula73@gmail.com>
  *  Copyright (c) 2011 Silvio Heinrich <plassy@web.de>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include <cmath>
 
 #include "kis_coordinates_converter.h"
 
 #include <QtMath>
 #include <QTransform>
 #include <KoViewConverter.h>
 
 #include <kis_config.h>
 #include <kis_image.h>
 
 
 struct KisCoordinatesConverter::Private {
     Private():
         isXAxisMirrored(false),
         isYAxisMirrored(false),
         rotationAngle(0.0),
         devicePixelRatio(1.0)
     {
     }
 
     KisImageWSP image;
 
     bool isXAxisMirrored;
     bool isYAxisMirrored;
     qreal rotationAngle;
     QSizeF canvasWidgetSize;
     qreal devicePixelRatio;
     QPointF documentOffset;
 
     QTransform flakeToWidget;
     QTransform imageToDocument;
     QTransform documentToFlake;
     QTransform widgetToViewport;
 };
 
 /**
  * When vastScrolling value is less than 0.5 it is possible
  * that the whole scrolling area (viewport) will be smaller than
  * the size of the widget. In such cases the image should be
  * centered in the widget. Previously we used a special parameter
  * documentOrigin for this purpose, now the value for this
  * centering is calculated dynamically, helping the offset to
  * center the image inside the widget
  *
  * Note that the correction is null when the size of the document
  * plus vast scrolling reserve is larger than the widget. This
  * is always true for vastScrolling parameter > 0.5.
  */
 
 QPointF KisCoordinatesConverter::centeringCorrection() const
 {
     KisConfig cfg(true);
 
     QSize documentSize = imageRectInWidgetPixels().toAlignedRect().size();
     QPointF dPoint(documentSize.width(), documentSize.height());
     QPointF wPoint(m_d->canvasWidgetSize.width(), m_d->canvasWidgetSize.height());
 
     QPointF minOffset = -cfg.vastScrolling() * wPoint;
     QPointF maxOffset = dPoint - wPoint + cfg.vastScrolling() * wPoint;
 
     QPointF range = maxOffset - minOffset;
 
     range.rx() = qMin(range.x(), (qreal)0.0);
     range.ry() = qMin(range.y(), (qreal)0.0);
 
     range /= 2;
 
     return -range;
 }
 
 /**
  * The document offset and the position of the top left corner of the
  * image must always coincide, that is why we need to correct them to
  * and fro.
  *
  * When we change zoom level, the calculation of the new offset is
  * done by KoCanvasControllerWidget, that is why we just passively fix
  * the flakeToWidget transform to conform the offset and wait until
  * the canvas controller will recenter us.
  *
  * But when we do our own transformations of the canvas, like rotation
  * and mirroring, we cannot rely on the centering of the canvas
  * controller and we do it ourselves. Then we just set new offset and
  * return its value to be set in the canvas controller explicitly.
  */
 
 void KisCoordinatesConverter::correctOffsetToTransformation()
 {
     m_d->documentOffset = snapToDevicePixel(-(imageRectInWidgetPixels().topLeft() -
           centeringCorrection()));
 }
 
 void KisCoordinatesConverter::correctTransformationToOffset()
 {
     QPointF topLeft = imageRectInWidgetPixels().topLeft();
     QPointF diff = (-topLeft) - m_d->documentOffset;
     diff += centeringCorrection();
     m_d->flakeToWidget *= QTransform::fromTranslate(diff.x(), diff.y());
 }
 
 void KisCoordinatesConverter::recalculateTransformations()
 {
     if(!m_d->image) return;
 
     m_d->imageToDocument = QTransform::fromScale(1 / m_d->image->xRes(),
                                                  1 / m_d->image->yRes());
 
     qreal zoomX, zoomY;
     KoZoomHandler::zoom(&zoomX, &zoomY);
     m_d->documentToFlake = QTransform::fromScale(zoomX, zoomY);
 
     correctTransformationToOffset();
 
     QRectF irect = imageRectInWidgetPixels();
     QRectF wrect = QRectF(QPoint(0,0), m_d->canvasWidgetSize);
     QRectF rrect = irect & wrect;
 
     QTransform reversedTransform = flakeToWidgetTransform().inverted();
     QRectF     canvasBounds      = reversedTransform.mapRect(rrect);
     QPointF    offset            = canvasBounds.topLeft();
 
     m_d->widgetToViewport = reversedTransform * QTransform::fromTranslate(-offset.x(), -offset.y());
 }
 
 
 KisCoordinatesConverter::KisCoordinatesConverter()
     : m_d(new Private) { }
 
 KisCoordinatesConverter::~KisCoordinatesConverter()
 {
     delete m_d;
 }
 
+QSizeF KisCoordinatesConverter::getCanvasWidgetSize() const
+{
+    return m_d->canvasWidgetSize;
+}
+
 void KisCoordinatesConverter::setCanvasWidgetSize(QSizeF size)
 {
     m_d->canvasWidgetSize = size;
     recalculateTransformations();
 }
 
 void KisCoordinatesConverter::setDevicePixelRatio(qreal value)
 {
     m_d->devicePixelRatio = value;
 }
 
 void KisCoordinatesConverter::setImage(KisImageWSP image)
 {
     m_d->image = image;
     recalculateTransformations();
 }
 
 void KisCoordinatesConverter::setDocumentOffset(const QPointF& offset)
 {
     QPointF diff = m_d->documentOffset - offset;
 
     m_d->documentOffset = offset;
     m_d->flakeToWidget *= QTransform::fromTranslate(diff.x(), diff.y());
     recalculateTransformations();
 }
 
 qreal KisCoordinatesConverter::devicePixelRatio() const
 {
     return m_d->devicePixelRatio;
 }
 
 QPoint KisCoordinatesConverter::documentOffset() const
 {
     return QPoint(int(m_d->documentOffset.x()), int(m_d->documentOffset.y()));
 }
 
 qreal KisCoordinatesConverter::rotationAngle() const
 {
     return m_d->rotationAngle;
 }
 
 void KisCoordinatesConverter::setZoom(qreal zoom)
 {
     KoZoomHandler::setZoom(zoom);
     recalculateTransformations();
 }
 
 qreal KisCoordinatesConverter::effectiveZoom() const
 {
     qreal scaleX, scaleY;
     this->imageScale(&scaleX, &scaleY);
 
     if (scaleX != scaleY) {
         qWarning() << "WARNING: Zoom is not isotropic!"  << ppVar(scaleX) << ppVar(scaleY) << ppVar(qFuzzyCompare(scaleX, scaleY));
     }
 
     // zoom by average of x and y
     return 0.5 * (scaleX + scaleY);
 }
 
 QPoint KisCoordinatesConverter::rotate(QPointF center, qreal angle)
 {
     QTransform rot;
     rot.rotate(angle);
 
     m_d->flakeToWidget *= QTransform::fromTranslate(-center.x(),-center.y());
     m_d->flakeToWidget *= rot;
     m_d->flakeToWidget *= QTransform::fromTranslate(center.x(), center.y());
     m_d->rotationAngle = std::fmod(m_d->rotationAngle + angle, 360.0);
 
     correctOffsetToTransformation();
     recalculateTransformations();
 
     return m_d->documentOffset.toPoint();
 }
 
 QPoint KisCoordinatesConverter::mirror(QPointF center, bool mirrorXAxis, bool mirrorYAxis)
 {
     bool keepOrientation = false; // XXX: Keep here for now, maybe some day we can restore the parameter again.
 
     bool       doXMirroring = m_d->isXAxisMirrored ^ mirrorXAxis;
     bool       doYMirroring = m_d->isYAxisMirrored ^ mirrorYAxis;
     qreal      scaleX       = doXMirroring ? -1.0 : 1.0;
     qreal      scaleY       = doYMirroring ? -1.0 : 1.0;
     QTransform mirror       = QTransform::fromScale(scaleX, scaleY);
 
     QTransform rot;
     rot.rotate(m_d->rotationAngle);
 
     m_d->flakeToWidget *= QTransform::fromTranslate(-center.x(),-center.y());
 
     if (keepOrientation) {
         m_d->flakeToWidget *= rot.inverted();
     }
 
     m_d->flakeToWidget *= mirror;
 
     if (keepOrientation) {
         m_d->flakeToWidget *= rot;
     }
 
     m_d->flakeToWidget *= QTransform::fromTranslate(center.x(),center.y());
 
 
     if (!keepOrientation && (doXMirroring ^ doYMirroring)) {
         m_d->rotationAngle = -m_d->rotationAngle;
     }
 
     m_d->isXAxisMirrored = mirrorXAxis;
     m_d->isYAxisMirrored = mirrorYAxis;
 
     correctOffsetToTransformation();
     recalculateTransformations();
 
     return m_d->documentOffset.toPoint();
 }
 
 bool KisCoordinatesConverter::xAxisMirrored() const
 {
     return m_d->isXAxisMirrored;
 }
 
 bool KisCoordinatesConverter::yAxisMirrored() const
 {
     return m_d->isYAxisMirrored;
 }
 
 QPoint KisCoordinatesConverter::resetRotation(QPointF center)
 {
     QTransform rot;
     rot.rotate(-m_d->rotationAngle);
 
     m_d->flakeToWidget *= QTransform::fromTranslate(-center.x(), -center.y());
     m_d->flakeToWidget *= rot;
     m_d->flakeToWidget *= QTransform::fromTranslate(center.x(), center.y());
     m_d->rotationAngle = 0.0;
 
     correctOffsetToTransformation();
     recalculateTransformations();
 
     return m_d->documentOffset.toPoint();
 }
 
-QTransform KisCoordinatesConverter::imageToWidgetTransform() const{
+QTransform KisCoordinatesConverter::imageToWidgetTransform() const {
     return m_d->imageToDocument * m_d->documentToFlake * m_d->flakeToWidget;
 }
 
 QTransform KisCoordinatesConverter::imageToDocumentTransform() const {
     return m_d->imageToDocument;
 }
 
 QTransform KisCoordinatesConverter::documentToFlakeTransform() const {
     return m_d->documentToFlake;
 }
 
 QTransform KisCoordinatesConverter::flakeToWidgetTransform() const {
     return m_d->flakeToWidget;
 }
 
-QTransform KisCoordinatesConverter::documentToWidgetTransform() const
-{
+QTransform KisCoordinatesConverter::documentToWidgetTransform() const {
     return m_d->documentToFlake * m_d->flakeToWidget;
 }
 
 QTransform KisCoordinatesConverter::viewportToWidgetTransform() const {
     return m_d->widgetToViewport.inverted();
 }
 
 QTransform KisCoordinatesConverter::imageToViewportTransform() const {
     return m_d->imageToDocument * m_d->documentToFlake * m_d->flakeToWidget * m_d->widgetToViewport;
 }
 
 void KisCoordinatesConverter::getQPainterCheckersInfo(QTransform *transform,
                                                       QPointF *brushOrigin,
                                                       QPolygonF *polygon,
                                                       const bool scrollCheckers) const
 {
     /**
      * Qt has different rounding for QPainter::drawRect/drawImage.
      * The image is rounded mathematically, while rect in aligned
      * to the next integer. That causes transparent line appear on
      * the canvas.
      *
      * See: https://bugreports.qt.nokia.com/browse/QTBUG-22827
      */
 
     QRectF imageRect = imageRectInViewportPixels();
     imageRect.adjust(0,0,-0.5,-0.5);
 
     if (scrollCheckers) {
         *transform = viewportToWidgetTransform();
         *polygon = imageRect;
         *brushOrigin = imageToViewport(QPointF(0,0));
     }
     else {
         *transform = QTransform();
         *polygon = viewportToWidgetTransform().map(imageRect);
         *brushOrigin = QPoint(0,0);
     }
 }
 
 void KisCoordinatesConverter::getOpenGLCheckersInfo(const QRectF &viewportRect,
                                                     QTransform *textureTransform,
                                                     QTransform *modelTransform,
                                                     QRectF *textureRect,
                                                     QRectF *modelRect,
                                                     const bool scrollCheckers) const
 {
     if(scrollCheckers) {
         *textureTransform = QTransform();
         *textureRect = QRectF(0, 0, viewportRect.width(),viewportRect.height());
     }
     else {
         *textureTransform = viewportToWidgetTransform();
         *textureRect = viewportRect;
     }
 
     *modelTransform = viewportToWidgetTransform();
     *modelRect = viewportRect;
 }
 
 QPointF KisCoordinatesConverter::imageCenterInWidgetPixel() const
 {
     if(!m_d->image)
         return QPointF();
 
     QPolygonF poly = imageToWidget(QPolygon(m_d->image->bounds()));
     return (poly[0] + poly[1] + poly[2] + poly[3]) / 4.0;
 }
 
 
 // these functions return a bounding rect if the canvas is rotated
 
 QRectF KisCoordinatesConverter::imageRectInWidgetPixels() const
 {
     if(!m_d->image) return QRectF();
     return imageToWidget(m_d->image->bounds());
 }
 
 QRectF KisCoordinatesConverter::imageRectInViewportPixels() const
 {
     if(!m_d->image) return QRectF();
     return imageToViewport(m_d->image->bounds());
 }
 
 QRect KisCoordinatesConverter::imageRectInImagePixels() const
 {
     if(!m_d->image) return QRect();
     return m_d->image->bounds();
 }
 
 QRectF KisCoordinatesConverter::imageRectInDocumentPixels() const
 {
     if(!m_d->image) return QRectF();
     return imageToDocument(m_d->image->bounds());
 }
 
 QSizeF KisCoordinatesConverter::imageSizeInFlakePixels() const
 {
     if(!m_d->image) return QSizeF();
 
     qreal scaleX, scaleY;
     imageScale(&scaleX, &scaleY);
     QSize imageSize = m_d->image->size();
 
     return QSizeF(imageSize.width() * scaleX, imageSize.height() * scaleY);
 }
 
 QRectF KisCoordinatesConverter::widgetRectInFlakePixels() const
 {
     return widgetToFlake(QRectF(QPoint(0,0), m_d->canvasWidgetSize));
 }
 
 QRectF KisCoordinatesConverter::widgetRectInImagePixels() const
 {
     return widgetToImage(QRectF(QPoint(0,0), m_d->canvasWidgetSize));
 }
 
 QPointF KisCoordinatesConverter::flakeCenterPoint() const
 {
     QRectF widgetRect = widgetRectInFlakePixels();
     return QPointF(widgetRect.left() + widgetRect.width() / 2,
                    widgetRect.top() + widgetRect.height() / 2);
 }
 
 QPointF KisCoordinatesConverter::widgetCenterPoint() const
 {
     return QPointF(m_d->canvasWidgetSize.width() / 2.0, m_d->canvasWidgetSize.height() / 2.0);
 }
 
 void KisCoordinatesConverter::imageScale(qreal *scaleX, qreal *scaleY) const
 {
     if(!m_d->image) {
         *scaleX = 1.0;
         *scaleY = 1.0;
         return;
     }
 
     // get the x and y zoom level of the canvas
     qreal zoomX, zoomY;
     KoZoomHandler::zoom(&zoomX, &zoomY);
 
     // Get the KisImage resolution
     qreal resX = m_d->image->xRes();
     qreal resY = m_d->image->yRes();
 
     // Compute the scale factors
     *scaleX = zoomX / resX;
     *scaleY = zoomY / resY;
 }
 
 void KisCoordinatesConverter::imagePhysicalScale(qreal *scaleX, qreal *scaleY) const
 {
     imageScale(scaleX, scaleY);
     *scaleX *= m_d->devicePixelRatio;
     *scaleY *= m_d->devicePixelRatio;
 }
 
 /**
  * @brief Adjust a given pair of coordinates to the nearest device pixel
  *        according to the value of `devicePixelRatio`.
  * @param point a point in logical pixel space
  * @return The point in logical pixel space but adjusted to the nearest device
  *         pixel
  */
 
 QPointF KisCoordinatesConverter::snapToDevicePixel(const QPointF &point) const
 {
     QPoint devicePixel = (point * m_d->devicePixelRatio).toPoint();
     // These adjusted coords will be in logical pixel but is aligned in device
     // pixel space for pixel-perfect rendering.
     return QPointF(devicePixel) / m_d->devicePixelRatio;
 }
diff --git a/libs/ui/canvas/kis_coordinates_converter.h b/libs/ui/canvas/kis_coordinates_converter.h
index 7d86f540e0..27be4283ac 100644
--- a/libs/ui/canvas/kis_coordinates_converter.h
+++ b/libs/ui/canvas/kis_coordinates_converter.h
@@ -1,169 +1,171 @@
 /*
  *  Copyright (c) 2010 Dmitry Kazakov <dimula73@gmail.com>
  *  Copyright (c) 2011 Silvio Heinrich <plassy@web.de>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_COORDINATES_CONVERTER_H
 #define KIS_COORDINATES_CONVERTER_H
 
 #include <QTransform>
 #include <KoZoomHandler.h>
 
 #include "kritaui_export.h"
 #include "kis_types.h"
 
 #define EPSILON 1e-6
 
 #define SCALE_LESS_THAN(scX, scY, value)                        \
     (scX < (value) - EPSILON && scY < (value) - EPSILON)
 #define SCALE_MORE_OR_EQUAL_TO(scX, scY, value)                 \
     (scX > (value) - EPSILON && scY > (value) - EPSILON)
 
 namespace _Private
 {
     template<class T> struct Traits
     {
         typedef T Result;
         static T map(const QTransform& transform, const T& obj)  { return transform.map(obj); }
     };
 
     template<> struct Traits<QRectF>
     {
         typedef QRectF Result;
         static QRectF map(const QTransform& transform, const QRectF& rc)  { return transform.mapRect(rc); }
     };
 
     template<> struct Traits<QRect>:    public Traits<QRectF>    { };
     template<> struct Traits<QPoint>:   public Traits<QPointF>   { };
     template<> struct Traits<QPolygon>: public Traits<QPolygonF> { };
     template<> struct Traits<QLine>:    public Traits<QLineF>    { };
 }
 
 class KRITAUI_EXPORT KisCoordinatesConverter: public KoZoomHandler
 {
 public:
     KisCoordinatesConverter();
     ~KisCoordinatesConverter() override;
 
+    QSizeF getCanvasWidgetSize() const;
+
     void setCanvasWidgetSize(QSizeF size);
     void setDevicePixelRatio(qreal value);
     void setImage(KisImageWSP image);
     void setDocumentOffset(const QPointF &offset);
 
     qreal devicePixelRatio() const;
     QPoint documentOffset() const;
     qreal rotationAngle() const;
 
     QPoint rotate(QPointF center, qreal angle);
     QPoint mirror(QPointF center, bool mirrorXAxis, bool mirrorYAxis);
     bool xAxisMirrored() const;
     bool yAxisMirrored() const;
     QPoint resetRotation(QPointF center);
 
     void setZoom(qreal zoom) override;
 
     /**
      * A composition of to scale methods: zoom level + image resolution
      */
     qreal effectiveZoom() const;
 
     template<class T> typename _Private::Traits<T>::Result
     imageToViewport(const T& obj) const { return _Private::Traits<T>::map(imageToViewportTransform(), obj); }
     template<class T> typename _Private::Traits<T>::Result
     viewportToImage(const T& obj) const { return _Private::Traits<T>::map(imageToViewportTransform().inverted(), obj); }
 
     template<class T> typename _Private::Traits<T>::Result
     flakeToWidget(const T& obj) const { return _Private::Traits<T>::map(flakeToWidgetTransform(), obj); }
     template<class T> typename _Private::Traits<T>::Result
     widgetToFlake(const T& obj) const { return _Private::Traits<T>::map(flakeToWidgetTransform().inverted(), obj); }
 
     template<class T> typename _Private::Traits<T>::Result
     widgetToViewport(const T& obj) const { return _Private::Traits<T>::map(viewportToWidgetTransform().inverted(), obj); }
     template<class T> typename _Private::Traits<T>::Result
     viewportToWidget(const T& obj) const { return _Private::Traits<T>::map(viewportToWidgetTransform(), obj); }
 
     template<class T> typename _Private::Traits<T>::Result
     documentToWidget(const T& obj) const { return _Private::Traits<T>::map(documentToWidgetTransform(), obj); }
     template<class T> typename _Private::Traits<T>::Result
     widgetToDocument(const T& obj) const { return _Private::Traits<T>::map(documentToWidgetTransform().inverted(), obj); }
 
     template<class T> typename _Private::Traits<T>::Result
     imageToDocument(const T& obj) const { return _Private::Traits<T>::map(imageToDocumentTransform(), obj); }
     template<class T> typename _Private::Traits<T>::Result
     documentToImage(const T& obj) const { return _Private::Traits<T>::map(imageToDocumentTransform().inverted(), obj); }
 
     template<class T> typename _Private::Traits<T>::Result
     documentToFlake(const T& obj) const { return _Private::Traits<T>::map(documentToFlakeTransform(), obj); }
     template<class T> typename _Private::Traits<T>::Result
     flakeToDocument(const T& obj) const { return _Private::Traits<T>::map(documentToFlakeTransform().inverted(), obj); }
 
     template<class T> typename _Private::Traits<T>::Result
     imageToWidget(const T& obj) const { return _Private::Traits<T>::map(imageToWidgetTransform(), obj); }
     template<class T> typename _Private::Traits<T>::Result
     widgetToImage(const T& obj) const { return _Private::Traits<T>::map(imageToWidgetTransform().inverted(), obj); }
 
     QTransform imageToWidgetTransform() const;
     QTransform imageToDocumentTransform() const;
     QTransform documentToFlakeTransform() const;
     QTransform imageToViewportTransform() const;
     QTransform viewportToWidgetTransform() const;
     QTransform flakeToWidgetTransform() const;
     QTransform documentToWidgetTransform() const;
 
     void getQPainterCheckersInfo(QTransform *transform,
                                  QPointF *brushOrigin,
                                  QPolygonF *poligon,
                                  const bool scrollCheckers) const;
 
     void getOpenGLCheckersInfo(const QRectF &viewportRect,
                                QTransform *textureTransform,
                                QTransform *modelTransform,
                                QRectF *textureRect,
                                QRectF *modelRect,
                                const bool scrollCheckers) const;
 
     QPointF imageCenterInWidgetPixel() const;
     QRectF imageRectInWidgetPixels() const;
     QRectF imageRectInViewportPixels() const;
     QSizeF imageSizeInFlakePixels() const;
     QRectF widgetRectInFlakePixels() const;
     QRectF widgetRectInImagePixels() const;
     QRect imageRectInImagePixels() const;
     QRectF imageRectInDocumentPixels() const;
 
     QPointF flakeCenterPoint() const;
     QPointF widgetCenterPoint() const;
 
     void imageScale(qreal *scaleX, qreal *scaleY) const;
     void imagePhysicalScale(qreal *scaleX, qreal *scaleY) const;
 
     QPointF snapToDevicePixel(const QPointF &point) const;
 
 private:
     friend class KisZoomAndPanTest;
 
     QPointF centeringCorrection() const;
     void correctOffsetToTransformation();
     void correctTransformationToOffset();
     void recalculateTransformations();
 
 private:
     struct Private;
     Private * const m_d;
 };
 
 #endif /* KIS_COORDINATES_CONVERTER_H */
diff --git a/libs/ui/canvas/kis_paintop_transformation_connector.cpp b/libs/ui/canvas/kis_paintop_transformation_connector.cpp
deleted file mode 100644
index bf93986495..0000000000
--- a/libs/ui/canvas/kis_paintop_transformation_connector.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- *  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_paintop_transformation_connector.h"
-
-#include "kis_canvas_resource_provider.h"
-#include "kis_canvas2.h"
-#include "kis_coordinates_converter.h"
-#include "brushengine/kis_paintop_preset.h"
-#include "brushengine/kis_paintop_settings.h"
-
-
-KisPaintopTransformationConnector::KisPaintopTransformationConnector(KisCanvas2 *canvas, QObject *parent)
-    : QObject(parent),
-      m_canvas(canvas)
-{
-    connect(m_canvas->resourceManager(),
-            SIGNAL(canvasResourceChanged(int,QVariant)),
-            SLOT(slotCanvasResourceChanged(int,QVariant)));
-}
-
-void KisPaintopTransformationConnector::notifyTransformationChanged()
-{
-    KisPaintOpPresetSP preset =
-        m_canvas->resourceManager()->
-        resource(KisCanvasResourceProvider::CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
-
-    if (preset) {
-        const KisCoordinatesConverter *converter = m_canvas->coordinatesConverter();
-        preset->settings()->setCanvasRotation(converter->rotationAngle());
-        preset->settings()->setCanvasMirroring(converter->xAxisMirrored(),
-                                               converter->yAxisMirrored());
-    }
-}
-
-void KisPaintopTransformationConnector::slotCanvasResourceChanged(int key, const QVariant &resource)
-{
-    Q_UNUSED(resource);
-
-    if (key == KisCanvasResourceProvider::CurrentPaintOpPreset) {
-        notifyTransformationChanged();
-    }
-}
diff --git a/libs/ui/canvas/kis_update_info.cpp b/libs/ui/canvas/kis_update_info.cpp
index 11a23b0669..af5b3797d2 100644
--- a/libs/ui/canvas/kis_update_info.cpp
+++ b/libs/ui/canvas/kis_update_info.cpp
@@ -1,121 +1,131 @@
 /*
  *  Copyright (c) 2010, Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "kis_update_info.h"
 
 /**
  * The connection in KisCanvas2 uses queued signals
  * with an argument of KisNodeSP type, so we should
  * register it beforehand
  */
 struct KisUpdateInfoSPStaticRegistrar {
     KisUpdateInfoSPStaticRegistrar() {
         qRegisterMetaType<KisUpdateInfoSP>("KisUpdateInfoSP");
     }
 };
 static KisUpdateInfoSPStaticRegistrar __registrar;
 
 KisUpdateInfo::KisUpdateInfo()
 {
 }
 
 KisUpdateInfo::~KisUpdateInfo()
 {
 }
 
 QRect KisUpdateInfo::dirtyViewportRect()
 {
     return QRect();
 }
 
+bool KisUpdateInfo::canBeCompressed() const
+{
+    return true;
+}
+
 QRect KisPPUpdateInfo::dirtyViewportRect() {
     return viewportRect.toAlignedRect();
 }
 
 QRect KisPPUpdateInfo::dirtyImageRect() const {
     return dirtyImageRectVar;
 }
 
 int KisPPUpdateInfo::levelOfDetail() const
 {
     return 0;
 }
 
 KisOpenGLUpdateInfo::KisOpenGLUpdateInfo()
     : m_levelOfDetail(0)
 {
 }
 
 QRect KisOpenGLUpdateInfo::dirtyViewportRect() {
     qFatal("Not implemented yet!");
     return QRect();
 }
 
 void KisOpenGLUpdateInfo::assignDirtyImageRect(const QRect &rect)
 {
     m_dirtyImageRect = rect;
 }
 
 void KisOpenGLUpdateInfo::assignLevelOfDetail(int lod)
 {
     m_levelOfDetail = lod;
 }
 
 QRect KisOpenGLUpdateInfo::dirtyImageRect() const
 {
     return m_dirtyImageRect;
 }
 
 int KisOpenGLUpdateInfo::levelOfDetail() const
 {
     return m_levelOfDetail;
 }
 
 bool KisOpenGLUpdateInfo::tryMergeWith(const KisOpenGLUpdateInfo &rhs)
 {
     if (m_levelOfDetail != rhs.m_levelOfDetail) return false;
 
     // TODO: that makes the algorithm of updates compressor incorrect!
     m_dirtyImageRect |= rhs.m_dirtyImageRect;
 
     tileList.append(rhs.tileList);
 
     return true;
 }
 
 KisMarkerUpdateInfo::KisMarkerUpdateInfo(KisMarkerUpdateInfo::Type type, const QRect &dirtyImageRect)
     : m_type(type),
       m_dirtyImageRect(dirtyImageRect)
 {
 }
 
 KisMarkerUpdateInfo::Type KisMarkerUpdateInfo::type() const
 {
     return m_type;
 }
 
 QRect KisMarkerUpdateInfo::dirtyImageRect() const
 {
     return m_dirtyImageRect;
 }
 
 int KisMarkerUpdateInfo::levelOfDetail() const
 {
     // return invalid level of detail to avoid merging the update info
     // with other updates
     return -1 - (int)m_type;
 }
+
+bool KisMarkerUpdateInfo::canBeCompressed() const
+{
+    return false;
+}
diff --git a/libs/ui/canvas/kis_update_info.h b/libs/ui/canvas/kis_update_info.h
index 62d29966b5..2b76e1d34b 100644
--- a/libs/ui/canvas/kis_update_info.h
+++ b/libs/ui/canvas/kis_update_info.h
@@ -1,168 +1,170 @@
 /*
  *  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_UPDATE_INFO_H_
 #define KIS_UPDATE_INFO_H_
 
 #include <QPainter>
 
 #include "kis_image_patch.h"
 #include "kis_shared.h"
 #include "kritaui_export.h"
 #include "opengl/kis_texture_tile_update_info.h"
 
 #include "kis_ui_types.h"
 
 class KRITAUI_EXPORT KisUpdateInfo : public KisShared
 {
 public:
     KisUpdateInfo();
     virtual ~KisUpdateInfo();
 
     virtual QRect dirtyViewportRect();
     virtual QRect dirtyImageRect() const = 0;
     virtual int levelOfDetail() const = 0;
+    virtual bool canBeCompressed() const;
 };
 
 Q_DECLARE_METATYPE(KisUpdateInfoSP)
 
 
 struct ConversionOptions {
     ConversionOptions() : m_needsConversion(false) {}
     ConversionOptions(const KoColorSpace *destinationColorSpace,
                       KoColorConversionTransformation::Intent renderingIntent,
                       KoColorConversionTransformation::ConversionFlags conversionFlags)
         : m_needsConversion(true),
           m_destinationColorSpace(destinationColorSpace),
           m_renderingIntent(renderingIntent),
           m_conversionFlags(conversionFlags)
     {
     }
 
 
     bool m_needsConversion;
     const KoColorSpace *m_destinationColorSpace = 0;
     KoColorConversionTransformation::Intent m_renderingIntent;
     KoColorConversionTransformation::ConversionFlags m_conversionFlags;
 };
 
 class KisOpenGLUpdateInfo;
 typedef KisSharedPtr<KisOpenGLUpdateInfo> KisOpenGLUpdateInfoSP;
 
 class KisOpenGLUpdateInfo : public KisUpdateInfo
 {
 public:
     KisOpenGLUpdateInfo();
 
     KisTextureTileUpdateInfoSPList tileList;
 
     QRect dirtyViewportRect() override;
     QRect dirtyImageRect() const override;
 
     void assignDirtyImageRect(const QRect &rect);
     void assignLevelOfDetail(int lod);
 
     int levelOfDetail() const override;
 
     bool tryMergeWith(const KisOpenGLUpdateInfo& rhs);
 
 private:
     QRect m_dirtyImageRect;
     int m_levelOfDetail;
 };
 
 
 class KisPPUpdateInfo : public KisUpdateInfo
 {
 public:
     enum TransferType {
         DIRECT,
         PATCH
     };
 
     QRect dirtyViewportRect() override;
     QRect dirtyImageRect() const override;
     int levelOfDetail() const override;
 
     /**
      * The rect that was reported by KisImage as dirty
      */
     QRect dirtyImageRectVar;
 
     /**
      * Rect of KisImage corresponding to @ref viewportRect .
      * It is cropped and aligned corresponding to the canvas.
      */
     QRect imageRect;
 
     /**
      * Rect of canvas widget corresponding to @ref imageRect
      */
     QRectF viewportRect;
 
     qreal scaleX;
     qreal scaleY;
 
     /**
      * Defines the way the source image is painted onto
      * prescaled QImage
      */
     TransferType transfer;
 
     /**
      * Render hints for painting the direct painting/patch painting
      */
     QPainter::RenderHints renderHints;
 
     /**
      * The number of additional pixels those should be added
      * to the patch
      */
     qint32 borderWidth;
 
     /**
      * Used for temporary storage of KisImage's data
      * by KisProjectionCache
      */
     KisImagePatch patch;
 };
 
 class KisMarkerUpdateInfo : public KisUpdateInfo
 {
 public:
     enum Type {
         StartBatch = 0,
         EndBatch,
         BlockLodUpdates,
         UnblockLodUpdates,
     };
 
 public:
     KisMarkerUpdateInfo(Type type, const QRect &dirtyImageRect);
 
     Type type() const;
 
     QRect dirtyImageRect() const override;
     int levelOfDetail() const override;
+    bool canBeCompressed() const override;
 
 private:
     Type m_type;
     QRect m_dirtyImageRect;
 };
 
 #endif /* KIS_UPDATE_INFO_H_ */
diff --git a/libs/ui/dialogs/kis_about_application.cpp b/libs/ui/dialogs/kis_about_application.cpp
index 456c0fec9a..5b518c1dd8 100644
--- a/libs/ui/dialogs/kis_about_application.cpp
+++ b/libs/ui/dialogs/kis_about_application.cpp
@@ -1,214 +1,214 @@
 /*
  *  Copyright (c) 2014 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "kis_about_application.h"
 
 #include <kis_debug.h>
 
 #include <QStandardPaths>
 #include <QTabWidget>
 #include <QLabel>
 #include <QTextEdit>
 #include <QTextBrowser>
 #include <QString>
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 #include <QPushButton>
 #include <QDate>
 #include <QApplication>
 #include <QFile>
 #include <QDesktopServices>
 
 #include <klocalizedstring.h>
 
 #include "../../krita/data/splash/splash_screen.xpm"
 #include "../../krita/data/splash/splash_holidays.xpm"
 #include "../../krita/data/splash/splash_screen_x2.xpm"
 #include "../../krita/data/splash/splash_holidays_x2.xpm"
 
 #include "kis_splash_screen.h"
 
 KisAboutApplication::KisAboutApplication(QWidget *parent)
     : QDialog(parent)
 {
     setWindowTitle(i18n("About Krita"));
 
     QVBoxLayout *vlayout = new QVBoxLayout(this);
     vlayout->setMargin(0);
     QTabWidget *wdgTab = new QTabWidget;
     vlayout->addWidget(wdgTab);
     KisSplashScreen *splash = 0;
 
     QDate currentDate = QDate::currentDate();
     if (currentDate > QDate(currentDate.year(), 12, 4) ||
             currentDate < QDate(currentDate.year(), 1, 9)) {
         splash = new KisSplashScreen(qApp->applicationVersion(), QPixmap(splash_holidays_xpm), QPixmap(splash_holidays_x2_xpm));
     }
     else {
         splash = new KisSplashScreen(qApp->applicationVersion(), QPixmap(splash_screen_xpm), QPixmap(splash_screen_x2_xpm));
     }
 
     splash->setWindowFlags(Qt::Widget);
     splash->displayLinks(true);
     splash->setFixedSize(splash->sizeHint());
 
     wdgTab->addTab(splash, i18n("About"));
     setMinimumSize(wdgTab->sizeHint());
 
 
     QTextEdit *lblAuthors = new QTextEdit();
     lblAuthors->setReadOnly(true);
 
     QString authors = i18n("<html>"
                           "<head/>"
                           "<body>"
                           "<h1 align=\"center\">Created By</h1></p>"
                           "<p>");
 
     QFile fileDevelopers(":/developers.txt");
     Q_ASSERT(fileDevelopers.exists());
     fileDevelopers.open(QIODevice::ReadOnly);
 
     Q_FOREACH (const QByteArray &author, fileDevelopers.readAll().split('\n')) {
         authors.append(QString::fromUtf8(author));
         authors.append(", ");
     }
     authors.chop(2);
     authors.append(".</p></body></html>");
     lblAuthors->setText(authors);
-    wdgTab->addTab(lblAuthors, i18n("Authors"));
+    wdgTab->addTab(lblAuthors, i18nc("Heading for the list of Krita authors/developers", "Authors"));
 
     QTextEdit *lblKickstarter = new QTextEdit();
     lblKickstarter->setReadOnly(true);
 
     QString backers = i18n("<html>"
                           "<head/>"
                           "<body>"
                           "<h1 align=\"center\">Backed By</h1>"
                           "<p>");
 
     QFile fileBackers(":/backers.txt");
     Q_ASSERT(fileBackers.exists());
     fileBackers.open(QIODevice::ReadOnly | QIODevice::Text);
     QTextStream backersText(&fileBackers);
     backersText.setCodec("UTF-8");
     backers.append(backersText.readAll().replace("\n", ", "));
     backers.chop(2);
     backers.append(i18n(".</p><p><i>Thanks! You were all <b>awesome</b>!</i></p></body></html>"));
     lblKickstarter->setText(backers);
     wdgTab->addTab(lblKickstarter, i18n("Backers"));
 
 
 
     QTextEdit *lblCredits = new QTextEdit();
     lblCredits->setReadOnly(true);
     QString credits = i18n("<html>"
                           "<head/>"
                           "<body>"
                           "<h1 align=\"center\">Thanks To</h1>"
                           "<p>");
 
     QFile fileCredits(":/credits.txt");
     Q_ASSERT(fileCredits.exists());
     fileCredits.open(QIODevice::ReadOnly);
 
     Q_FOREACH (const QString &credit, QString::fromUtf8(fileCredits.readAll()).split('\n', QString::SkipEmptyParts)) {
         if (credit.contains(":")) {
             QList<QString> creditSplit = credit.split(':');
             credits.append(creditSplit.at(0));
             credits.append(" (<i>" + creditSplit.at(1) + "</i>)");
             credits.append(", ");
         }
     }
     credits.chop(2);
     credits.append(i18n(".</p><p><i>For supporting Krita development with advice, icons, brush sets and more.</i></p></body></html>"));
 
     lblCredits->setText(credits);
     wdgTab->addTab(lblCredits, i18n("Also Thanks To"));
 
     QTextEdit *lblLicense = new QTextEdit();
     lblLicense->setReadOnly(true);
     QString license = i18n("<html>"
                            "<head/>"
                            "<body>"
                            "<h1 align=\"center\"><b>Your Rights</b></h1>"
                            "<p>Krita is released under the GNU General Public License (version 3 or any later version).</p>"
                            "<p>This license grants people a number of freedoms:</p>"
                            "<ul>"
                            "<li>You are free to use Krita, for any purpose</li>"
                            "<li>You are free to distribute Krita</li>"
                            "<li>You can study how Krita works and change it</li>"
                            "<li>You can distribute changed versions of Krita</li>"
                            "</ul>"
                            "<p>The Krita Foundation and its projects on krita.org are <b>committed</b> to preserving Krita as free software.</p>"
                            "<h1 align=\"center\">Your artwork</h1>"
                            "<p>What you create with Krita is your sole property. All your artwork is free for you to use as you like.</p>"
                            "<p>That means that Krita can be used commercially, for any purpose. There are no restrictions whatsoever.</p>"
                            "<p>Krita’s GNU GPL license guarantees you this freedom. Nobody is ever permitted to take it away, in contrast "
                            "to trial or educational versions of commercial software that will forbid your work in commercial situations.</p>"
                            "<br/><hr/><pre>");
 
     QFile licenseFile(":/LICENSE");
     Q_ASSERT(licenseFile.exists());
     licenseFile.open(QIODevice::ReadOnly);
     QByteArray ba = licenseFile.readAll();
     license.append(QString::fromUtf8(ba));
     license.append("</pre></body></html>");
     lblLicense->setText(license);
 
     wdgTab->addTab(lblLicense, i18n("License"));
 
     QTextBrowser *lblThirdParty = new QTextBrowser();
     lblThirdParty->setOpenExternalLinks(true);
     QFile thirdPartyFile(":/libraries.txt");
     if (thirdPartyFile.open(QIODevice::ReadOnly)) {
         ba = thirdPartyFile.readAll();
 
         QString thirdPartyHtml = i18n("<html>"
                                       "<head/>"
                                       "<body>"
                                       "<h1 align=\"center\"><b>Third-party Libraries used by Krita</b></h1>"
                                       "<p>Krita is built on the following free software libraries:</p><p><ul>");
 
 
         Q_FOREACH(const QString &lib, QString::fromUtf8(ba).split('\n')) {
             if (!lib.startsWith("#")) {
                 QStringList parts = lib.split(',');
                 if (parts.size() >= 3) {
                     thirdPartyHtml.append(QString("<li><a href=\"%2\">%1</a>: %3</li>").arg(parts[0], parts[1], parts[2]));
                 }
             }
         }
         thirdPartyHtml.append("<ul></p></body></html>");
         lblThirdParty->setText(thirdPartyHtml);
     }
     wdgTab->addTab(lblThirdParty, i18n("Third-party libraries"));
 
 
     QPushButton *bnClose = new QPushButton(i18n("Close"));
     connect(bnClose, SIGNAL(clicked()), SLOT(close()));
 
     QHBoxLayout *hlayout = new QHBoxLayout;
     hlayout->setMargin(10);
     hlayout->addStretch(10);
     hlayout->addWidget(bnClose);
 
 
 
     vlayout->addLayout(hlayout);
 
 }
diff --git a/libs/ui/dialogs/kis_dlg_filter.cpp b/libs/ui/dialogs/kis_dlg_filter.cpp
index 21b861bbdd..c8294b07f8 100644
--- a/libs/ui/dialogs/kis_dlg_filter.cpp
+++ b/libs/ui/dialogs/kis_dlg_filter.cpp
@@ -1,249 +1,250 @@
 /*
  *  Copyright (c) 2007 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2008 Boudewijn Rempt <boud@valdysa.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "kis_dlg_filter.h"
 
 
 
 #include <KoResourcePaths.h>
 #include <QPushButton>
 #include <filter/kis_filter.h>
 #include <filter/kis_filter_configuration.h>
 #include <kis_filter_mask.h>
 #include <kis_node.h>
 #include <kis_layer.h>
 #include <kis_paint_layer.h>
 #include <KisViewManager.h>
 #include <kis_config.h>
 
 #include "kis_selection.h"
 #include "kis_node_commands_adapter.h"
 #include "kis_filter_manager.h"
 #include "ui_wdgfilterdialog.h"
 #include "kis_canvas2.h"
 
 
 struct KisDlgFilter::Private {
     Private(KisFilterManager *_filterManager, KisViewManager *_view)
             : currentFilter(0)
             , resizeCount(0)
             , view(_view)
             , filterManager(_filterManager)
             , blockModifyingActionsGuard(new KisInputActionGroupsMaskGuard(view->canvasBase(), ViewTransformActionGroup))
     {
     }
 
     KisFilterSP currentFilter;
     Ui_FilterDialog uiFilterDialog;
     KisNodeSP node;
     int resizeCount;
     KisViewManager *view;
     KisFilterManager *filterManager;
 
     // a special guard object that blocks all the painting input actions while the
     // dialog is open
     QScopedPointer<KisInputActionGroupsMaskGuard> blockModifyingActionsGuard;
 };
 
 KisDlgFilter::KisDlgFilter(KisViewManager *view, KisNodeSP node, KisFilterManager *filterManager, QWidget *parent) :
         QDialog(parent),
         d(new Private(filterManager, view))
 {
     setModal(false);
 
     d->uiFilterDialog.setupUi(this);
     d->node = node;
 
     d->uiFilterDialog.filterSelection->setView(view);
     d->uiFilterDialog.filterSelection->showFilterGallery(KisConfig(true).showFilterGallery());
 
     d->uiFilterDialog.pushButtonCreateMaskEffect->show();
     connect(d->uiFilterDialog.pushButtonCreateMaskEffect, SIGNAL(pressed()), SLOT(createMask()));
     connect(d->uiFilterDialog.pushButtonCreateMaskEffect,SIGNAL(pressed()),SLOT(close()));
 
     d->uiFilterDialog.filterGalleryToggle->setChecked(d->uiFilterDialog.filterSelection->isFilterGalleryVisible());
     d->uiFilterDialog.filterGalleryToggle->setIcon(QPixmap(":/pics/sidebaricon.png"));
     d->uiFilterDialog.filterGalleryToggle->setMaximumWidth(d->uiFilterDialog.filterGalleryToggle->height());
     connect(d->uiFilterDialog.filterSelection, SIGNAL(sigFilterGalleryToggled(bool)), d->uiFilterDialog.filterGalleryToggle, SLOT(setChecked(bool)));
     connect(d->uiFilterDialog.filterGalleryToggle, SIGNAL(toggled(bool)), d->uiFilterDialog.filterSelection, SLOT(showFilterGallery(bool)));
     connect(d->uiFilterDialog.filterSelection, SIGNAL(sigSizeChanged()), this, SLOT(slotFilterWidgetSizeChanged()));
 
     if (node->inherits("KisMask")) {
         d->uiFilterDialog.pushButtonCreateMaskEffect->setVisible(false);
     }
 
     d->uiFilterDialog.filterSelection->setPaintDevice(true, d->node->original());
 
     connect(d->uiFilterDialog.buttonBox, SIGNAL(accepted()), SLOT(accept()));
     connect(d->uiFilterDialog.buttonBox, SIGNAL(rejected()), SLOT(reject()));
     connect(d->uiFilterDialog.checkBoxPreview, SIGNAL(toggled(bool)), SLOT(enablePreviewToggled(bool)));
 
     connect(d->uiFilterDialog.filterSelection, SIGNAL(configurationChanged()), SLOT(filterSelectionChanged()));
 
     connect(this, SIGNAL(accepted()), SLOT(slotOnAccept()));
     connect(this, SIGNAL(rejected()), SLOT(slotOnReject()));
 
     KConfigGroup group( KSharedConfig::openConfig(), "filterdialog");
     d->uiFilterDialog.checkBoxPreview->setChecked(group.readEntry("showPreview", true));
 
     restoreGeometry(KisConfig(true).readEntry("filterdialog/geometry", QByteArray()));
 
 }
 
 KisDlgFilter::~KisDlgFilter()
 {
     KisConfig(false).writeEntry("filterdialog/geometry", saveGeometry());
     delete d;
 }
 
 void KisDlgFilter::setFilter(KisFilterSP f)
 {
     Q_ASSERT(f);
     setDialogTitle(f);
     d->uiFilterDialog.filterSelection->setFilter(f);
     d->uiFilterDialog.pushButtonCreateMaskEffect->setEnabled(f->supportsAdjustmentLayers());
     d->currentFilter = f;
     updatePreview();
 }
 
 void KisDlgFilter::setDialogTitle(KisFilterSP filter)
 {
     setWindowTitle(filter.isNull() ? i18nc("@title:window", "Filter") : i18nc("@title:window", "Filter: %1", filter->name()));
 }
 
 void KisDlgFilter::startApplyingFilter(KisFilterConfigurationSP config)
 {
     if (!d->uiFilterDialog.filterSelection->configuration()) return;
 
     if (d->node->inherits("KisPaintLayer")) {
         config->setChannelFlags(qobject_cast<KisPaintLayer*>(d->node.data())->channelLockFlags());
     }
 
     d->filterManager->apply(config);
 }
 
 void KisDlgFilter::updatePreview()
 {
     KisFilterConfigurationSP config = d->uiFilterDialog.filterSelection->configuration();
     if (!config) return;
 
     bool maskCreationAllowed = !d->currentFilter || d->currentFilter->configurationAllowedForMask(config);
     d->uiFilterDialog.pushButtonCreateMaskEffect->setEnabled(maskCreationAllowed);
 
     if (d->uiFilterDialog.checkBoxPreview->isChecked()) {
         KisFilterConfigurationSP config(d->uiFilterDialog.filterSelection->configuration());
         startApplyingFilter(config);
     }
 
     d->uiFilterDialog.buttonBox->button(QDialogButtonBox::Ok)->setEnabled(true);
 }
 
 void KisDlgFilter::adjustSize()
 {
     QWidget::adjustSize();
 }
 
 void KisDlgFilter::slotFilterWidgetSizeChanged()
 {
     QMetaObject::invokeMethod(this, "adjustSize", Qt::QueuedConnection);
 }
 
 void KisDlgFilter::slotOnAccept()
 {
     if (!d->filterManager->isStrokeRunning()) {
         KisFilterConfigurationSP config(d->uiFilterDialog.filterSelection->configuration());
         startApplyingFilter(config);
     }
 
     d->filterManager->finish();
 
     d->uiFilterDialog.buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
 
     KisConfig(false).setShowFilterGallery(d->uiFilterDialog.filterSelection->isFilterGalleryVisible());
 }
 
 void KisDlgFilter::slotOnReject()
 {
     if (d->filterManager->isStrokeRunning()) {
         d->filterManager->cancel();
     }
 
     KisConfig(false).setShowFilterGallery(d->uiFilterDialog.filterSelection->isFilterGalleryVisible());
 }
 
 void KisDlgFilter::createMask()
 {
     if (d->node->inherits("KisMask")) return;
 
     if (d->filterManager->isStrokeRunning()) {
         d->filterManager->cancel();
     }
 
     KisLayer *layer = qobject_cast<KisLayer*>(d->node.data());
     KisFilterMaskSP mask = new KisFilterMask();
     mask->setName(d->currentFilter->name());
     mask->initSelection(d->view->selection(), layer);
     mask->setFilter(d->uiFilterDialog.filterSelection->configuration());
 
     Q_ASSERT(layer->allowAsChild(mask));
 
     KisNodeCommandsAdapter adapter(d->view);
     adapter.addNode(mask, layer, layer->lastChild());
 }
 
 void KisDlgFilter::enablePreviewToggled(bool state)
 {
     if (state) {
         updatePreview();
     } else if (d->filterManager->isStrokeRunning()) {
         d->filterManager->cancel();
     }
 
     KConfigGroup group( KSharedConfig::openConfig(), "filterdialog");
     group.writeEntry("showPreview", d->uiFilterDialog.checkBoxPreview->isChecked());
 
     group.config()->sync();
 }
 
 void KisDlgFilter::filterSelectionChanged()
 {
     KisFilterSP filter = d->uiFilterDialog.filterSelection->currentFilter();
     setDialogTitle(filter);
+    d->currentFilter = filter;
     d->uiFilterDialog.pushButtonCreateMaskEffect->setEnabled(filter.isNull() ? false : filter->supportsAdjustmentLayers());
     updatePreview();
 }
 
 
 void KisDlgFilter::resizeEvent(QResizeEvent* event)
 {
     QDialog::resizeEvent(event);
 
 //    // Workaround, after the initialisation don't center the dialog anymore
 //    if(d->resizeCount < 2) {
 //        QWidget* canvas = d->view->canvas();
 //        QRect rect(canvas->mapToGlobal(canvas->geometry().topLeft()), size());
 //        int deltaX = (canvas->geometry().width() - geometry().width())/2;
 //        int deltaY = (canvas->geometry().height() - geometry().height())/2;
 //        rect.translate(deltaX, deltaY);
 //        setGeometry(rect);
 
 //        d->resizeCount++;
 //    }
 }
diff --git a/libs/ui/dialogs/kis_dlg_layer_properties.cc b/libs/ui/dialogs/kis_dlg_layer_properties.cc
index 5068943461..dff0b5a460 100644
--- a/libs/ui/dialogs/kis_dlg_layer_properties.cc
+++ b/libs/ui/dialogs/kis_dlg_layer_properties.cc
@@ -1,309 +1,309 @@
 /*
  *  Copyright (c) 2005 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2011 José Luis Vergara <pentalis@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_dlg_layer_properties.h"
 #include <limits.h>
 
 #include <QLabel>
 #include <QLayout>
 #include <QString>
 #include <QGroupBox>
 #include <QVBoxLayout>
 
 #include <klocalizedstring.h>
 
 #include <KoColorSpace.h>
 
 #include "KisViewManager.h"
 #include <kis_debug.h>
 #include <kis_global.h>
 
 #include "widgets/kis_cmb_composite.h"
 #include "KoColorProfile.h"
 #include "kis_multinode_property.h"
 #include "kis_layer_utils.h"
 #include "kis_image.h"
 #include "kis_layer_properties_icons.h"
 #include "kis_signal_compressor.h"
 #include "commands_new/kis_saved_commands.h"
 #include "kis_post_execution_undo_adapter.h"
 
 
 struct KisDlgLayerProperties::Private
 {
     Private() : updatesCompressor(500, KisSignalCompressor::POSTPONE) {}
 
     KisNodeList nodes;
     const KoColorSpace *colorSpace;
     KisViewManager *view;
     WdgLayerProperties *page;
 
     QSharedPointer<KisMultinodeCompositeOpProperty> compositeOpProperty;
     QSharedPointer<KisMultinodeOpacityProperty> opacityProperty;
     QSharedPointer<KisMultinodeNameProperty> nameProperty;
     QSharedPointer<KisMultinodeColorLabelProperty> colorLabelProperty;
 
     QList<KisMultinodePropertyInterfaceSP> layerProperties;
     QList<QPointer<QCheckBox> > layerPropCheckboxes;
 
     QList<KisMultinodePropertyInterfaceSP> channelFlagsProps;
     QList<QPointer<QCheckBox> > channelFlagsCheckboxes;
 
     KisSignalCompressor updatesCompressor;
 
     QList<KisMultinodePropertyInterfaceSP> allProperties() const {
         QList<KisMultinodePropertyInterfaceSP> props;
         props << compositeOpProperty;
         props << opacityProperty;
         props << nameProperty;
         props << layerProperties;
         props << channelFlagsProps;
         props << colorLabelProperty;
         return props;
     }
 };
 
 KisDlgLayerProperties::KisDlgLayerProperties(KisNodeList nodes, KisViewManager *view, QWidget *parent, const char *name, Qt::WindowFlags f)
     : KoDialog(parent)
     , d(new Private())
 {
     nodes = KisLayerUtils::sortMergableNodes(view->image()->root(), nodes);
     d->nodes = nodes;
 
     Q_UNUSED(f);
     setCaption(i18n("Layer Properties"));
     setButtons(Ok | Cancel);
     setDefaultButton(Ok);
     setModal(false);
 
     setObjectName(name);
     d->page = new WdgLayerProperties(this);
     setMainWidget(d->page);
     d->view = view;
     d->colorSpace = d->nodes.first()->colorSpace();
 
     d->page->editName->setFocus();
     d->nameProperty.reset(new KisMultinodeNameProperty(nodes));
     d->nameProperty->connectIgnoreCheckBox(d->page->chkName);
     d->nameProperty->connectAutoEnableWidget(d->page->editName);
     d->nameProperty->connectValueChangedSignal(this, SLOT(slotNameValueChangedInternally()));
     connect(d->page->editName, SIGNAL(textChanged(QString)), SLOT(slotNameValueChangedExternally()));
 
     d->page->intOpacity->setRange(0, 100);
-    d->page->intOpacity->setSuffix("%");
+    d->page->intOpacity->setSuffix(i18n("%"));
     d->opacityProperty.reset(new KisMultinodeOpacityProperty(nodes));
     d->opacityProperty->connectIgnoreCheckBox(d->page->chkOpacity);
     d->opacityProperty->connectAutoEnableWidget(d->page->intOpacity);
     d->opacityProperty->connectValueChangedSignal(this, SLOT(slotOpacityValueChangedInternally()));
     d->opacityProperty->connectValueChangedSignal(&d->updatesCompressor, SLOT(start()));
     connect(d->page->intOpacity, SIGNAL(valueChanged(int)), SLOT(slotOpacityValueChangedExternally()));
 
     d->compositeOpProperty.reset(new KisMultinodeCompositeOpProperty(nodes));
     d->compositeOpProperty->connectIgnoreCheckBox(d->page->chkCompositeOp);
     d->compositeOpProperty->connectAutoEnableWidget(d->page->cmbComposite);
     d->compositeOpProperty->connectValueChangedSignal(this, SLOT(slotCompositeOpValueChangedInternally()));
     d->compositeOpProperty->connectValueChangedSignal(&d->updatesCompressor, SLOT(start()));
     connect(d->page->cmbComposite, SIGNAL(currentIndexChanged(int)), SLOT(slotCompositeOpValueChangedExternally()));
 
     d->page->colorLabelSelector->setFocusPolicy(Qt::StrongFocus);
     d->colorLabelProperty.reset(new KisMultinodeColorLabelProperty(nodes));
     d->colorLabelProperty->connectIgnoreCheckBox(d->page->chkColorLabel);
     d->colorLabelProperty->connectAutoEnableWidget(d->page->colorLabelSelector);
     d->colorLabelProperty->connectValueChangedSignal(this, SLOT(slotColorLabelValueChangedInternally()));
     d->colorLabelProperty->connectValueChangedSignal(&d->updatesCompressor, SLOT(start()));
     connect(d->page->colorLabelSelector, SIGNAL(currentIndexChanged(int)), SLOT(slotColorLabelValueChangedExternally()));
 
     if (!KisLayerUtils::checkNodesDiffer<const KoColorSpace*>(d->nodes, [](KisNodeSP node) { return node->colorSpace(); })) {
 
         d->page->lblColorSpace->setText(d->colorSpace->name());
         if (const KoColorProfile* profile = d->colorSpace->profile()) {
             d->page->lblProfile->setText(profile->name());
         }
 
         QRect bounds = d->nodes.first()->exactBounds();
         d->page->lblDimensions->setText(i18nc("layer dimensions", "(%1, %2), (%3, %4)",
                                         bounds.x(),
                                         bounds.y(),
                                         bounds.width(),
                                         bounds.height()));
 
         ChannelFlagAdapter::PropertyList props = ChannelFlagAdapter::adaptersList(nodes);
         if (!props.isEmpty()) {
             QVBoxLayout *vbox = new QVBoxLayout;
             Q_FOREACH (const ChannelFlagAdapter::Property &prop, props) {
                 QCheckBox *chk = new QCheckBox(prop.name, this);
                 vbox->addWidget(chk);
 
                 KisMultinodePropertyInterface *multiprop =
                     new KisMultinodeProperty<ChannelFlagAdapter>(
                         nodes,
                         ChannelFlagAdapter(prop));
 
                 multiprop->connectIgnoreCheckBox(chk);
                 multiprop->connectValueChangedSignal(this, SLOT(slotFlagsValueChangedInternally()));
                 multiprop->connectValueChangedSignal(&d->updatesCompressor, SLOT(start()));
 
                 d->channelFlagsCheckboxes << chk;
                 d->channelFlagsProps << toQShared(multiprop);
             }
 
             d->page->grpActiveChannels->setLayout(vbox);
         } else {
             d->page->grpActiveChannels->setVisible(false);
             d->page->lineActiveChannels->setVisible(false);
         }
     } else {
         d->page->grpActiveChannels->setVisible(false);
         d->page->lineActiveChannels->setVisible(false);
         d->page->cmbComposite->setEnabled(false);
         d->page->chkCompositeOp->setEnabled(false);
         d->page->lblDimensions->setText(i18n("*varies*"));
         d->page->lblColorSpace->setText(i18n("*varies*"));
         d->page->lblProfile->setText(i18n("*varies*"));
     }
 
     {
         QVBoxLayout *vbox = new QVBoxLayout;
 
         KisBaseNode::PropertyList props = LayerPropertyAdapter::adaptersList(nodes);
         Q_FOREACH (const KisBaseNode::Property &prop, props) {
             QCheckBox *chk = new QCheckBox(prop.name, this);
             chk->setIcon(prop.onIcon);
             vbox->addWidget(chk);
 
             KisMultinodePropertyInterface *multiprop =
                 new KisMultinodeProperty<LayerPropertyAdapter>(
                     nodes,
                     LayerPropertyAdapter(prop.name));
 
             multiprop->connectIgnoreCheckBox(chk);
             multiprop->connectValueChangedSignal(this, SLOT(slotPropertyValueChangedInternally()));
             multiprop->connectValueChangedSignal(&d->updatesCompressor, SLOT(start()));
 
             d->layerPropCheckboxes << chk;
             d->layerProperties << toQShared(multiprop);
         }
 
         d->page->grpProperties->setLayout(vbox);
     }
 
     connect(&d->updatesCompressor, SIGNAL(timeout()), SLOT(updatePreview()));
 }
 
 KisDlgLayerProperties::~KisDlgLayerProperties()
 {
     if (result() == QDialog::Accepted) {
         if (d->updatesCompressor.isActive()) {
             d->updatesCompressor.stop();
             updatePreview();
         }
 
         KisPostExecutionUndoAdapter *adapter =
             d->view->image()->postExecutionUndoAdapter();
         KisSavedMacroCommand *macro = adapter->createMacro(kundo2_i18n("Change Layer Properties"));
         macro->addCommand(toQShared(new KisLayerUtils::KisSimpleUpdateCommand(d->nodes, false)));
         Q_FOREACH(auto prop, d->allProperties()) {
             if (!prop->isIgnored()) {
                 macro->addCommand(toQShared(prop->createPostExecutionUndoCommand()));
             }
         }
         macro->addCommand(toQShared(new KisLayerUtils::KisSimpleUpdateCommand(d->nodes, true)));
         adapter->addMacro(macro);
     }
     else /* if (result() == QDialog::Rejected) */ {
         Q_FOREACH(auto prop, d->allProperties()) {
             prop->setIgnored(true);
         }
         updatePreview();
     }
 }
 
 void KisDlgLayerProperties::slotCompositeOpValueChangedInternally()
 {
     d->page->cmbComposite->validate(d->colorSpace);
     d->page->cmbComposite->selectCompositeOp(KoID(d->compositeOpProperty->value()));
     d->page->cmbComposite->setEnabled(!d->compositeOpProperty->isIgnored());
 }
 
 void KisDlgLayerProperties::slotCompositeOpValueChangedExternally()
 {
     if (d->compositeOpProperty->isIgnored()) return;
     d->compositeOpProperty->setValue(d->page->cmbComposite->selectedCompositeOp().id());
 }
 
 void KisDlgLayerProperties::slotColorLabelValueChangedInternally()
 {
     d->page->colorLabelSelector->setCurrentIndex(d->colorLabelProperty->value());
     d->page->colorLabelSelector->setEnabled(!d->colorLabelProperty->isIgnored());
 }
 
 void KisDlgLayerProperties::slotColorLabelValueChangedExternally()
 {
     if (d->colorLabelProperty->isIgnored()) return;
     d->colorLabelProperty->setValue(d->page->colorLabelSelector->currentIndex());
 }
 
 void KisDlgLayerProperties::slotOpacityValueChangedInternally()
 {
     d->page->intOpacity->setValue(d->opacityProperty->value());
     d->page->intOpacity->setEnabled(!d->opacityProperty->isIgnored());
 }
 
 void KisDlgLayerProperties::slotOpacityValueChangedExternally()
 {
     if (d->opacityProperty->isIgnored()) return;
     d->opacityProperty->setValue(d->page->intOpacity->value());
 }
 
 void KisDlgLayerProperties::slotNameValueChangedInternally()
 {
     if (d->page->editName->text() != d->nameProperty->value()) {
         d->page->editName->setText(d->nameProperty->value());
     }
 
     d->page->editName->setEnabled(!d->nameProperty->isIgnored());
 }
 
 void KisDlgLayerProperties::slotNameValueChangedExternally()
 {
     if (d->nameProperty->isIgnored()) return;
 
     if (d->page->editName->text() != d->nameProperty->value()) {
         d->nameProperty->setValue(d->page->editName->text());
     }
 }
 
 void KisDlgLayerProperties::slotPropertyValueChangedInternally()
 {
     Q_FOREACH (KisMultinodePropertyInterfaceSP prop, d->channelFlagsProps) {
         prop->rereadCurrentValue();
     }
 }
 
 void KisDlgLayerProperties::slotFlagsValueChangedInternally()
 {
     Q_FOREACH (KisMultinodePropertyInterfaceSP prop, d->layerProperties) {
         prop->rereadCurrentValue();
     }
 }
 
 void KisDlgLayerProperties::updatePreview()
 {
     KisLayerUtils::KisSimpleUpdateCommand::updateNodes(d->nodes);
 }
diff --git a/libs/ui/dialogs/kis_dlg_preferences.cc b/libs/ui/dialogs/kis_dlg_preferences.cc
index 59ffffe6ca..136118d028 100644
--- a/libs/ui/dialogs/kis_dlg_preferences.cc
+++ b/libs/ui/dialogs/kis_dlg_preferences.cc
@@ -1,1743 +1,1753 @@
 /*
  *  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 <QGroupBox>
 #include <QMdiArea>
 #include <QMessageBox>
 #include <QDesktopWidget>
 #include <QFileDialog>
 #include <QFormLayout>
 #include <QSettings>
 
 #include <KisDocument.h>
 #include <KoColorProfile.h>
 #include <KisApplication.h>
 #include <KoFileDialog.h>
 #include <KisPart.h>
 #include <KoColorSpaceEngine.h>
 #include <kis_icon.h>
 #include <KoConfig.h>
 #include "KoID.h"
 #include <KoConfigAuthorPage.h>
 #include <KoVBox.h>
 
 #include <klocalizedstring.h>
 #include <kformat.h>
 #include <kundo2stack.h>
 #include <KoResourcePaths.h>
 #include "kis_action_registry.h"
 #include <kis_image.h>
 #include <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 < QApplication::desktop()->screenCount(); ++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::desktop()->screenCount(); ++i) {
         if (m_monitorProfileWidgets[i]->contains(cfg.monitorProfile(i))) {
             m_monitorProfileWidgets[i]->setCurrent(cfg.monitorProfile(i));
         }
     }
 
     m_page->chkBlackpoint->setChecked(cfg.useBlackPointCompensation());
     m_page->chkAllowLCMSOptimization->setChecked(cfg.allowLCMSOptimization());
     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::desktop()->screenCount(); ++i) {
         if (m_monitorProfileWidgets[i]->contains(cfg.monitorProfile(i))) {
             m_monitorProfileWidgets[i]->setCurrent(cfg.monitorProfile(i));
         }
     }
 
 }
 
 void ColorSettingsTab::toggleAllowMonitorProfileSelection(bool useSystemProfile)
 {
     KisConfig cfg(true);
 
     if (useSystemProfile) {
         QStringList devices = KisColorManager::instance()->devices();
         if (devices.size() == QApplication::desktop()->screenCount()) {
             for(int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
                 m_monitorProfileWidgets[i]->clear();
                 QString monitorForScreen = cfg.monitorForScreen(i, devices[i]);
                 Q_FOREACH (const QString &device, devices) {
                     m_monitorProfileLabels[i]->setText(i18nc("The display/screen we got from Qt", "Screen %1:", i + 1));
                     m_monitorProfileWidgets[i]->addSqueezedItem(KisColorManager::instance()->deviceName(device), device);
                     if (devices[i] == monitorForScreen) {
                         m_monitorProfileWidgets[i]->setCurrentIndex(i);
                     }
                 }
             }
         }
     }
     else {
         refillMonitorProfiles(KoID("RGBA"));
 
         for(int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
             if (m_monitorProfileWidgets[i]->contains(cfg.monitorProfile(i))) {
                 m_monitorProfileWidgets[i]->setCurrent(cfg.monitorProfile(i));
             }
         }
     }
 }
 
 void ColorSettingsTab::setDefault()
 {
     m_page->cmbWorkingColorSpace->setCurrent("RGBA");
 
     refillMonitorProfiles(KoID("RGBA"));
 
     KisConfig cfg(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::desktop()->screenCount(); ++i) {
         m_monitorProfileWidgets[i]->clear();
     }
 
     QMap<QString, const KoColorProfile *>  profileList;
     Q_FOREACH(const KoColorProfile *profile, KoColorSpaceRegistry::instance()->profilesFor(colorSpaceId.id())) {
         profileList[profile->name()] = profile;
     }
 
     Q_FOREACH (const KoColorProfile *profile, profileList.values()) {
         //qDebug() << "Profile" << profile->name() << profile->isSuitableForDisplay() << csf->defaultProfile();
         if (profile->isSuitableForDisplay()) {
             for (int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
                 m_monitorProfileWidgets[i]->addSqueezedItem(profile->name());
             }
         }
     }
 
     for (int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
         m_monitorProfileLabels[i]->setText(i18nc("The number of the screen", "Screen %1:", i + 1));
         m_monitorProfileWidgets[i]->setCurrent(KoColorSpaceRegistry::instance()->defaultProfileForColorSpace(colorSpaceId.id()));
     }
 }
 
 
 //---------------------------------------------------------------------------------------------------
 
 void TabletSettingsTab::setDefault()
 {
     KisCubicCurve curve;
     curve.fromString(DEFAULT_CURVE_STRING);
     m_page->pressureCurve->setCurve(curve);
 
     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()));
     sync3->slotParentValueChanged();
     m_syncs << sync3;
 
     sliderSwapSize->setSuffix(i18n(" GiB"));
     sliderSwapSize->setRange(1, 64);
     intSwapSize->setRange(1, 64);
 
 
     KisAcyclicSignalConnector *swapSizeConnector = new KisAcyclicSignalConnector(this);
 
     swapSizeConnector->connectForwardInt(sliderSwapSize, SIGNAL(valueChanged(int)),
                                          intSwapSize, SLOT(setValue(int)));
 
     swapSizeConnector->connectBackwardInt(intSwapSize, SIGNAL(valueChanged(int)),
                                           sliderSwapSize, SLOT(setValue(int)));
 
     lblSwapFileLocation->setText(cfg.swapDir());
     connect(bnSwapFile, SIGNAL(clicked()), SLOT(selectSwapDir()));
 
     sliderThreadsLimit->setRange(1, QThread::idealThreadCount());
     sliderFrameClonesLimit->setRange(1, QThread::idealThreadCount());
     sliderFpsLimit->setRange(20, 100);
     sliderFpsLimit->setSuffix(i18n(" fps"));
 
     connect(sliderThreadsLimit, SIGNAL(valueChanged(int)), SLOT(slotThreadsLimitChanged(int)));
     connect(sliderFrameClonesLimit, SIGNAL(valueChanged(int)), SLOT(slotFrameClonesLimitChanged(int)));
 
     intCachedFramesSizeLimit->setRange(1, 10000);
     intCachedFramesSizeLimit->setSuffix(i18n(" px"));
     intCachedFramesSizeLimit->setSingleStep(1);
     intCachedFramesSizeLimit->setPageStep(1000);
 
     intRegionOfInterestMargin->setRange(1, 100);
     intRegionOfInterestMargin->setSuffix(i18n(" %"));
     intRegionOfInterestMargin->setSingleStep(1);
     intRegionOfInterestMargin->setPageStep(10);
 
     connect(chkCachedFramesSizeLimit, SIGNAL(toggled(bool)), intCachedFramesSizeLimit, SLOT(setEnabled(bool)));
     connect(chkUseRegionOfInterest, SIGNAL(toggled(bool)), intRegionOfInterestMargin, SLOT(setEnabled(bool)));
 
 #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);
 #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::Tree);
+    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();
-    Q_FOREACH (KisAbstractPreferenceSetFactory *preferenceSetFactory, preferenceSetRegistry->values()) {
+    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::slotDefault()
 {
     if (currentPage()->objectName() == "general") {
         m_general->setDefault();
     }
     else if (currentPage()->objectName() == "shortcuts") {
         m_shortcutSettings->setDefault();
     }
     else if (currentPage()->objectName() == "display") {
         m_displaySettings->setDefault();
     }
     else if (currentPage()->objectName() == "colormanagement") {
         m_colorSettings->setDefault();
     }
     else if (currentPage()->objectName() == "performance") {
         m_performanceSettings->load(true);
     }
     else if (currentPage()->objectName() == "tablet") {
         m_tabletSettings->setDefault();
     }
     else if (currentPage()->objectName() == "canvasonly") {
         m_fullscreenSettings->setDefault();
     }
     else if (currentPage()->objectName() == "canvasinput") {
         m_inputConfiguration->setDefaults();
     }
 }
 
 bool KisDlgPreferences::editPreferences()
 {
     KisDlgPreferences* dialog;
 
     dialog = new KisDlgPreferences();
     bool baccept = (dialog->exec() == Accepted);
     if (baccept) {
         // General settings
         KisConfig cfg(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());
 
         KConfigGroup group = KSharedConfig::openConfig()->group("File Dialogs");
         group.writeEntry("DontUseNativeFileDialog", !dialog->m_general->m_chkNativeFileDialog->isChecked());
 
         cfg.writeEntry<int>("maximumBrushSize", dialog->m_general->intMaxBrushSize->value());
 
         cfg.writeEntry<int>("mdi_viewmode", dialog->m_general->mdiMode());
         cfg.setMDIBackgroundColor(dialog->m_general->m_mdiColor->color().toXML());
         cfg.setMDIBackgroundImage(dialog->m_general->m_backgroundimage->text());
         cfg.setAutoSaveInterval(dialog->m_general->autoSaveInterval());
         cfg.writeEntry("autosavefileshidden", dialog->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.setShowCanvasMessages(dialog->m_general->showCanvasMessages());
         cfg.setCompressKra(dialog->m_general->compressKra());
         cfg.setUseZip64(dialog->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());
 #ifdef HAVE_HIGH_DPI_SCALE_FACTOR_ROUNDING_POLICY
         kritarc.setValue("EnableHiDPIFractionalScaling", dialog->m_general->m_chkHiDPIFractionalScaling->isChecked());
 #endif
         kritarc.setValue("EnableSingleApplication", dialog->m_general->m_chkSingleApplication->isChecked());
         kritarc.setValue("LogUsage", dialog->m_general->chkUsageLogging->isChecked());
 
         cfg.setToolOptionsInDocker(dialog->m_general->toolOptionsInDocker());
 
         cfg.writeEntry<bool>("useCreamyAlphaDarken", (bool)!dialog->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.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());
 
         // Color settings
         cfg.setUseSystemMonitorProfile(dialog->m_colorSettings->m_page->chkUseSystemMonitorProfile->isChecked());
         for (int i = 0; i < QApplication::desktop()->screenCount(); ++i) {
             if (dialog->m_colorSettings->m_page->chkUseSystemMonitorProfile->isChecked()) {
                 int currentIndex = dialog->m_colorSettings->m_monitorProfileWidgets[i]->currentIndex();
                 QString monitorid = dialog->m_colorSettings->m_monitorProfileWidgets[i]->itemData(currentIndex).toString();
                 cfg.setMonitorForScreen(i, monitorid);
             }
             else {
                 cfg.setMonitorProfile(i,
                                       dialog->m_colorSettings->m_monitorProfileWidgets[i]->currentUnsqueezedText(),
                                       dialog->m_colorSettings->m_page->chkUseSystemMonitorProfile->isChecked());
             }
         }
         cfg.setWorkingColorSpace(dialog->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());
 
         // Tablet settings
         cfg.setPressureTabletCurve( dialog->m_tabletSettings->m_page->pressureCurve->curve().toString() );
         cfg.setUseRightMiddleTabletButtonWorkaround(
             dialog->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());
         }
 #endif
 
         dialog->m_performanceSettings->save();
 
         if (!cfg.useOpenGL() && dialog->m_displaySettings->grpOpenGL->isChecked())
             cfg.setCanvasState("TRY_OPENGL");
 
         if (dialog->m_displaySettings->grpOpenGL->isChecked()) {
             KisOpenGL::OpenGLRenderer renderer = static_cast<KisOpenGL::OpenGLRenderer>(
                     dialog->m_displaySettings->cmbPreferredRenderer->itemData(
                             dialog->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());
         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.setHideDockersFullscreen(dialog->m_fullscreenSettings->chkDockers->checkState());
         cfg.setHideMenuFullscreen(dialog->m_fullscreenSettings->chkMenu->checkState());
         cfg.setHideScrollbarsFullscreen(dialog->m_fullscreenSettings->chkScrollbars->checkState());
         cfg.setHideStatusbarFullscreen(dialog->m_fullscreenSettings->chkStatusbar->checkState());
         cfg.setHideTitlebarFullscreen(dialog->m_fullscreenSettings->chkTitlebar->checkState());
         cfg.setHideToolbarFullscreen(dialog->m_fullscreenSettings->chkToolbar->checkState());
 
         cfg.setCursorMainColor(dialog->m_general->cursorColorBtutton->color().toQColor());
         cfg.setPixelGridColor(dialog->m_displaySettings->pixelGridColorButton->color().toQColor());
         cfg.setPixelGridDrawingThreshold(dialog->m_displaySettings->pixelGridDrawingThresholdBox->value() / 100);
 
         dialog->m_authorPage->apply();
 
     }
     delete dialog;
     return baccept;
 }
 
diff --git a/libs/ui/forms/KisDetailsPaneBase.ui b/libs/ui/forms/KisDetailsPaneBase.ui
index 27e490890b..64f0089451 100644
--- a/libs/ui/forms/KisDetailsPaneBase.ui
+++ b/libs/ui/forms/KisDetailsPaneBase.ui
@@ -1,182 +1,172 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>KisDetailsPaneBase</class>
  <widget class="QWidget" name="KisDetailsPaneBase">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>598</width>
-    <height>556</height>
+    <width>395</width>
+    <height>383</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string comment="KDE::DoNotExtract">DetailsPaneBase</string>
   </property>
   <layout class="QGridLayout">
-   <property name="margin">
+   <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 row="0" column="0" colspan="2">
     <widget class="QSplitter" name="m_splitter">
      <property name="orientation">
-      <enum>Qt::Horizontal</enum>
+      <enum>Qt::Vertical</enum>
      </property>
      <widget class="QTreeView" name="m_documentList">
       <property name="sizePolicy">
-       <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+       <sizepolicy hsizetype="Minimum" vsizetype="MinimumExpanding">
         <horstretch>1</horstretch>
         <verstretch>0</verstretch>
        </sizepolicy>
       </property>
       <property name="rootIsDecorated">
        <bool>false</bool>
       </property>
       <property name="itemsExpandable">
        <bool>false</bool>
       </property>
      </widget>
      <widget class="QWidget" name="layoutWidget">
       <layout class="QGridLayout">
-       <item row="0" column="0" colspan="3">
-        <widget class="QLabel" name="m_previewLabel">
-         <property name="text">
-          <string/>
-         </property>
-         <property name="alignment">
-          <set>Qt::AlignCenter</set>
-         </property>
-        </widget>
-       </item>
-       <item row="1" column="0" colspan="3">
-        <widget class="QLabel" name="m_titleLabel">
-         <property name="font">
-          <font>
-           <family>Sans Serif</family>
-           <pointsize>9</pointsize>
-           <weight>75</weight>
-           <italic>false</italic>
-           <bold>true</bold>
-           <underline>false</underline>
-           <strikeout>false</strikeout>
-          </font>
+       <item row="0" column="2">
+        <spacer>
+         <property name="orientation">
+          <enum>Qt::Horizontal</enum>
          </property>
-         <property name="text">
-          <string/>
+         <property name="sizeType">
+          <enum>QSizePolicy::Expanding</enum>
          </property>
-         <property name="alignment">
-          <set>Qt::AlignCenter</set>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>10</width>
+           <height>10</height>
+          </size>
          </property>
-        </widget>
+        </spacer>
        </item>
-       <item row="2" column="0">
+       <item row="4" column="1">
         <spacer>
          <property name="orientation">
           <enum>Qt::Horizontal</enum>
          </property>
          <property name="sizeType">
           <enum>QSizePolicy::Expanding</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
-           <width>81</width>
-           <height>23</height>
+           <width>461</width>
+           <height>26</height>
           </size>
          </property>
         </spacer>
        </item>
-       <item row="2" column="1">
-        <widget class="QCheckBox" name="m_alwaysUseCheckBox">
+       <item row="3" column="0" colspan="3">
+        <widget class="QTextBrowser" name="m_detailsLabel">
+         <property name="sizePolicy">
+          <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+           <horstretch>0</horstretch>
+           <verstretch>0</verstretch>
+          </sizepolicy>
+         </property>
+         <property name="frameShape">
+          <enum>QFrame::NoFrame</enum>
+         </property>
+        </widget>
+       </item>
+       <item row="4" column="2">
+        <widget class="QPushButton" name="m_openButton">
          <property name="enabled">
           <bool>false</bool>
          </property>
-         <property name="toolTip">
-          <string>Always use this template at application start up</string>
-         </property>
          <property name="text">
-          <string>Always use this template</string>
+          <string/>
+         </property>
+         <property name="autoDefault">
+          <bool>true</bool>
+         </property>
+         <property name="default">
+          <bool>true</bool>
          </property>
         </widget>
        </item>
-       <item row="2" column="2">
+       <item row="0" column="0">
         <spacer>
          <property name="orientation">
           <enum>Qt::Horizontal</enum>
          </property>
          <property name="sizeType">
           <enum>QSizePolicy::Expanding</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
-           <width>81</width>
-           <height>23</height>
+           <width>10</width>
+           <height>10</height>
           </size>
          </property>
         </spacer>
        </item>
-       <item row="4" column="0" colspan="3">
+       <item row="2" column="0" colspan="3">
         <widget class="Line" name="line1">
          <property name="frameShape">
           <enum>QFrame::HLine</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Sunken</enum>
          </property>
          <property name="orientation">
           <enum>Qt::Horizontal</enum>
          </property>
         </widget>
        </item>
-       <item row="5" column="0" colspan="3">
-        <widget class="QTextBrowser" name="m_detailsLabel">
-         <property name="frameShape">
-          <enum>QFrame::NoFrame</enum>
-         </property>
-        </widget>
-       </item>
-       <item row="6" column="1">
-        <spacer>
-         <property name="orientation">
-          <enum>Qt::Horizontal</enum>
-         </property>
-         <property name="sizeType">
-          <enum>QSizePolicy::Expanding</enum>
-         </property>
-         <property name="sizeHint" stdset="0">
-          <size>
-           <width>461</width>
-           <height>26</height>
-          </size>
-         </property>
-        </spacer>
-       </item>
-       <item row="6" column="2">
-        <widget class="QPushButton" name="m_openButton">
+       <item row="0" column="1">
+        <widget class="QCheckBox" name="m_alwaysUseCheckBox">
          <property name="enabled">
           <bool>false</bool>
          </property>
-         <property name="text">
-          <string/>
+         <property name="sizePolicy">
+          <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+           <horstretch>0</horstretch>
+           <verstretch>0</verstretch>
+          </sizepolicy>
          </property>
-         <property name="autoDefault">
-          <bool>true</bool>
+         <property name="toolTip">
+          <string>Always use this template at application start up</string>
          </property>
-         <property name="default">
-          <bool>true</bool>
+         <property name="text">
+          <string>Always use this template</string>
          </property>
         </widget>
        </item>
       </layout>
      </widget>
     </widget>
    </item>
   </layout>
  </widget>
  <tabstops>
   <tabstop>m_documentList</tabstop>
   <tabstop>m_alwaysUseCheckBox</tabstop>
   <tabstop>m_detailsLabel</tabstop>
  </tabstops>
  <resources/>
  <connections/>
 </ui>
diff --git a/libs/ui/forms/KisWelcomePage.ui b/libs/ui/forms/KisWelcomePage.ui
index f47f9f1060..16ea785892 100644
--- a/libs/ui/forms/KisWelcomePage.ui
+++ b/libs/ui/forms/KisWelcomePage.ui
@@ -1,770 +1,851 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>KisWelcomePage</class>
  <widget class="QWidget" name="KisWelcomePage">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>858</width>
-    <height>493</height>
+    <width>788</width>
+    <height>476</height>
    </rect>
   </property>
   <property name="sizePolicy">
    <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
     <horstretch>0</horstretch>
     <verstretch>0</verstretch>
    </sizepolicy>
   </property>
   <property name="autoFillBackground">
    <bool>false</bool>
   </property>
-  <layout class="QVBoxLayout" name="verticalLayout_4">
+  <layout class="QHBoxLayout" name="horizontalLayout_14">
    <item>
     <widget class="QFrame" name="dropFrameBorder">
      <property name="frameShape">
       <enum>QFrame::Box</enum>
      </property>
      <property name="frameShadow">
       <enum>QFrame::Plain</enum>
      </property>
      <property name="lineWidth">
       <number>4</number>
      </property>
      <property name="midLineWidth">
       <number>0</number>
      </property>
      <layout class="QGridLayout" name="gridLayout">
       <item row="1" column="2">
        <layout class="QVBoxLayout" name="verticalLayout">
         <property name="spacing">
          <number>5</number>
         </property>
         <property name="leftMargin">
          <number>0</number>
         </property>
         <property name="topMargin">
          <number>0</number>
         </property>
         <property name="rightMargin">
          <number>30</number>
         </property>
         <property name="bottomMargin">
          <number>0</number>
         </property>
         <item>
          <widget class="QLabel" name="helpTitleLabel">
           <property name="font">
            <font>
             <pointsize>18</pointsize>
            </font>
           </property>
           <property name="text">
            <string>Community</string>
           </property>
           <property name="margin">
            <number>0</number>
           </property>
          </widget>
         </item>
         <item>
          <layout class="QHBoxLayout" name="horizontalLayout_7">
           <property name="spacing">
            <number>0</number>
           </property>
           <item>
            <widget class="QLabel" name="manualLink">
             <property name="font">
              <font>
               <underline>true</underline>
              </font>
             </property>
             <property name="text">
              <string>User Manual</string>
             </property>
            </widget>
           </item>
           <item>
            <spacer name="horizontalSpacer_7">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
             <property name="sizeType">
              <enum>QSizePolicy::Expanding</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>40</width>
               <height>5</height>
              </size>
             </property>
            </spacer>
           </item>
          </layout>
         </item>
         <item>
          <layout class="QHBoxLayout" name="horizontalLayout_3">
           <property name="spacing">
            <number>0</number>
           </property>
           <item>
            <widget class="QLabel" name="gettingStartedLink">
             <property name="font">
              <font>
               <underline>true</underline>
              </font>
             </property>
             <property name="text">
              <string>Getting Started</string>
             </property>
            </widget>
           </item>
           <item>
            <spacer name="horizontalSpacer_4">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>40</width>
               <height>5</height>
              </size>
             </property>
            </spacer>
           </item>
          </layout>
         </item>
         <item>
          <layout class="QHBoxLayout" name="horizontalLayout_4">
           <item>
            <widget class="QLabel" name="supportKritaLink">
             <property name="font">
              <font>
               <underline>true</underline>
              </font>
             </property>
             <property name="text">
              <string>Support Krita</string>
             </property>
            </widget>
           </item>
           <item>
            <spacer name="horizontalSpacer_3">
             <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>
          <layout class="QHBoxLayout" name="horizontalLayout_5">
           <item>
            <widget class="QLabel" name="userCommunityLink">
             <property name="font">
              <font>
               <underline>true</underline>
              </font>
             </property>
             <property name="text">
              <string>User Community</string>
             </property>
            </widget>
           </item>
           <item>
            <spacer name="horizontalSpacer_5">
             <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>
          <layout class="QHBoxLayout" name="horizontalLayout_6">
           <item>
            <widget class="QLabel" name="kritaWebsiteLink">
             <property name="font">
              <font>
               <underline>true</underline>
              </font>
             </property>
             <property name="text">
              <string>Krita Website</string>
             </property>
            </widget>
           </item>
           <item>
            <spacer name="horizontalSpacer_6">
             <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>
          <layout class="QHBoxLayout" name="horizontalLayout_8">
           <property name="spacing">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <item>
            <widget class="QLabel" name="sourceCodeLink">
             <property name="font">
              <font>
               <underline>true</underline>
              </font>
             </property>
             <property name="text">
              <string>Source Code</string>
             </property>
            </widget>
           </item>
           <item>
            <spacer name="horizontalSpacer_8">
             <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>
          <layout class="QHBoxLayout" name="horizontalLayout_11">
           <property name="bottomMargin">
            <number>20</number>
           </property>
           <item>
            <widget class="QPushButton" name="kdeIcon">
             <property name="minimumSize">
              <size>
               <width>20</width>
               <height>20</height>
              </size>
             </property>
             <property name="maximumSize">
              <size>
               <width>20</width>
               <height>20</height>
              </size>
             </property>
             <property name="text">
              <string/>
             </property>
             <property name="flat">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QLabel" name="poweredByKDELink">
             <property name="font">
              <font>
               <underline>true</underline>
              </font>
             </property>
             <property name="text">
              <string>Powered by KDE</string>
             </property>
            </widget>
           </item>
           <item>
            <spacer name="horizontalSpacer_13">
             <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>
          <layout class="QHBoxLayout" name="horizontalLayout_9">
           <item>
            <widget class="QLabel" name="dragImageHereLabel">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Preferred" vsizetype="MinimumExpanding">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="frameShape">
              <enum>QFrame::Box</enum>
             </property>
             <property name="lineWidth">
              <number>2</number>
             </property>
             <property name="text">
              <string>Drag Image in window to open</string>
             </property>
             <property name="alignment">
              <set>Qt::AlignCenter</set>
             </property>
             <property name="wordWrap">
              <bool>true</bool>
             </property>
             <property name="margin">
              <number>30</number>
             </property>
            </widget>
           </item>
           <item>
            <spacer name="horizontalSpacer_10">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>40</width>
               <height>20</height>
              </size>
             </property>
            </spacer>
           </item>
          </layout>
         </item>
         <item>
          <spacer name="verticalSpacer">
           <property name="orientation">
            <enum>Qt::Vertical</enum>
           </property>
           <property name="sizeHint" stdset="0">
            <size>
             <width>20</width>
             <height>20</height>
            </size>
           </property>
          </spacer>
         </item>
        </layout>
       </item>
       <item row="1" column="4">
        <spacer name="horizontalSpacer_9">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>5</width>
           <height>5</height>
          </size>
         </property>
        </spacer>
       </item>
       <item row="2" column="1">
        <spacer name="verticalSpacer_2">
         <property name="orientation">
          <enum>Qt::Vertical</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>5</width>
           <height>5</height>
          </size>
         </property>
        </spacer>
       </item>
       <item row="0" column="2">
        <spacer name="verticalSpacer_3">
         <property name="orientation">
          <enum>Qt::Vertical</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>5</width>
           <height>5</height>
          </size>
         </property>
        </spacer>
       </item>
       <item row="1" column="0">
        <spacer name="horizontalSpacer_11">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>5</width>
           <height>5</height>
          </size>
         </property>
        </spacer>
       </item>
       <item row="1" column="1">
        <layout class="QVBoxLayout" name="verticalLayout_2">
         <property name="spacing">
          <number>5</number>
         </property>
         <property name="topMargin">
          <number>0</number>
         </property>
         <property name="rightMargin">
          <number>20</number>
         </property>
         <item>
-         <widget class="QLabel" name="startTitleLabel">
-          <property name="font">
-           <font>
-            <pointsize>18</pointsize>
-           </font>
-          </property>
-          <property name="text">
-           <string>Start</string>
-          </property>
-         </widget>
+         <layout class="QHBoxLayout" name="horizontalLayout_13">
+          <item>
+           <widget class="QLabel" name="startTitleLabel">
+            <property name="sizePolicy">
+             <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+              <horstretch>0</horstretch>
+              <verstretch>0</verstretch>
+             </sizepolicy>
+            </property>
+            <property name="minimumSize">
+             <size>
+              <width>70</width>
+              <height>0</height>
+             </size>
+            </property>
+            <property name="font">
+             <font>
+              <pointsize>18</pointsize>
+             </font>
+            </property>
+            <property name="text">
+             <string>Start</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QPushButton" name="alertIcon">
+            <property name="sizePolicy">
+             <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+              <horstretch>0</horstretch>
+              <verstretch>0</verstretch>
+             </sizepolicy>
+            </property>
+            <property name="maximumSize">
+             <size>
+              <width>16</width>
+              <height>16</height>
+             </size>
+            </property>
+            <property name="text">
+             <string/>
+            </property>
+            <property name="iconSize">
+             <size>
+              <width>16</width>
+              <height>16</height>
+             </size>
+            </property>
+            <property name="flat">
+             <bool>true</bool>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QLabel" name="versionNotificationLabel">
+            <property name="sizePolicy">
+             <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+              <horstretch>0</horstretch>
+              <verstretch>0</verstretch>
+             </sizepolicy>
+            </property>
+            <property name="font">
+             <font>
+              <underline>true</underline>
+             </font>
+            </property>
+            <property name="text">
+             <string>Krita X.X.X Update Available</string>
+            </property>
+            <property name="indent">
+             <number>2</number>
+            </property>
+            <property name="openExternalLinks">
+             <bool>false</bool>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <spacer name="horizontalSpacer_14">
+            <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>
          <layout class="QHBoxLayout" name="horizontalLayout">
           <property name="spacing">
            <number>0</number>
           </property>
           <item>
            <widget class="QPushButton" name="newFileLink">
             <property name="font">
              <font>
               <underline>true</underline>
              </font>
             </property>
             <property name="focusPolicy">
              <enum>Qt::NoFocus</enum>
             </property>
             <property name="text">
              <string>New File</string>
             </property>
             <property name="checkable">
              <bool>false</bool>
             </property>
             <property name="flat">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QLabel" name="newFileLinkShortcut">
             <property name="minimumSize">
              <size>
               <width>20</width>
               <height>0</height>
              </size>
             </property>
             <property name="font">
              <font>
               <underline>false</underline>
              </font>
             </property>
             <property name="text">
              <string/>
             </property>
            </widget>
           </item>
           <item>
            <spacer name="horizontalSpacer">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>40</width>
               <height>20</height>
              </size>
             </property>
            </spacer>
           </item>
          </layout>
         </item>
         <item>
          <layout class="QHBoxLayout" name="horizontalLayout_2">
           <property name="spacing">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>30</number>
           </property>
           <item>
            <widget class="QPushButton" name="openFileLink">
             <property name="font">
              <font>
               <underline>true</underline>
              </font>
             </property>
             <property name="focusPolicy">
              <enum>Qt::NoFocus</enum>
             </property>
             <property name="text">
              <string>Open File</string>
             </property>
             <property name="checkable">
              <bool>false</bool>
             </property>
             <property name="flat">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QLabel" name="openFileShortcut">
             <property name="minimumSize">
              <size>
               <width>20</width>
               <height>0</height>
              </size>
             </property>
             <property name="font">
              <font>
               <underline>false</underline>
              </font>
             </property>
             <property name="text">
              <string/>
             </property>
            </widget>
           </item>
           <item>
            <spacer name="horizontalSpacer_2">
             <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>
          <layout class="QHBoxLayout" name="horizontalLayout_10">
           <item>
            <widget class="QLabel" name="recentDocumentsLabel">
             <property name="font">
              <font>
               <pointsize>18</pointsize>
              </font>
             </property>
             <property name="text">
              <string>Recent Documents</string>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QPushButton" name="clearRecentFilesLink">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="font">
              <font>
               <underline>true</underline>
              </font>
             </property>
             <property name="focusPolicy">
              <enum>Qt::NoFocus</enum>
             </property>
             <property name="text">
              <string>Clear</string>
             </property>
             <property name="checkable">
              <bool>false</bool>
             </property>
             <property name="flat">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item>
            <spacer name="horizontalSpacer_12">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>5</width>
               <height>20</height>
              </size>
             </property>
            </spacer>
           </item>
          </layout>
         </item>
         <item>
          <widget class="QListView" name="recentDocumentsListView">
           <property name="sizePolicy">
            <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="minimumSize">
            <size>
             <width>300</width>
             <height>250</height>
            </size>
           </property>
           <property name="font">
            <font>
             <underline>true</underline>
             <kerning>false</kerning>
            </font>
           </property>
           <property name="focusPolicy">
            <enum>Qt::NoFocus</enum>
           </property>
           <property name="autoFillBackground">
            <bool>false</bool>
           </property>
           <property name="frameShape">
            <enum>QFrame::NoFrame</enum>
           </property>
           <property name="frameShadow">
            <enum>QFrame::Plain</enum>
           </property>
           <property name="lineWidth">
            <number>0</number>
           </property>
           <property name="autoScroll">
            <bool>false</bool>
           </property>
           <property name="showDropIndicator" stdset="0">
            <bool>false</bool>
           </property>
           <property name="selectionBehavior">
            <enum>QAbstractItemView::SelectItems</enum>
           </property>
           <property name="movement">
            <enum>QListView::Snap</enum>
           </property>
           <property name="resizeMode">
            <enum>QListView::Fixed</enum>
           </property>
           <property name="spacing">
            <number>0</number>
           </property>
           <property name="viewMode">
            <enum>QListView::ListMode</enum>
           </property>
           <property name="uniformItemSizes">
            <bool>true</bool>
           </property>
           <property name="wordWrap">
            <bool>false</bool>
           </property>
          </widget>
         </item>
         <item>
          <spacer name="verticalSpacer_4">
           <property name="orientation">
            <enum>Qt::Vertical</enum>
           </property>
           <property name="sizeHint" stdset="0">
            <size>
             <width>5</width>
             <height>5</height>
            </size>
           </property>
          </spacer>
         </item>
        </layout>
       </item>
       <item row="1" column="3">
        <layout class="QVBoxLayout" name="verticalLayout_3">
         <item>
          <layout class="QHBoxLayout" name="horizontalLayout_12">
           <item>
            <widget class="QLabel" name="helpTitleLabel_2">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="font">
              <font>
               <pointsize>18</pointsize>
              </font>
             </property>
             <property name="text">
              <string>News</string>
             </property>
             <property name="margin">
              <number>0</number>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QCheckBox" name="chkShowNews">
             <property name="enabled">
              <bool>true</bool>
             </property>
             <property name="sizePolicy">
              <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="toolTip">
              <string>Show news about Krita: this needs internet to retrieve information from the krita.org website</string>
             </property>
             <property name="text">
-             <string>Enabled</string>
+             <string>Check for updates</string>
             </property>
            </widget>
           </item>
          </layout>
         </item>
         <item>
          <widget class="KisNewsWidget" name="newsWidget" native="true"/>
         </item>
        </layout>
       </item>
      </layout>
     </widget>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KisNewsWidget</class>
    <extends>QWidget</extends>
    <header>widgets/KisNewsWidget.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/libs/ui/forms/wdgcolorspaceselector.ui b/libs/ui/forms/wdgcolorspaceselector.ui
index 4658d6696c..350e2c9d53 100644
--- a/libs/ui/forms/wdgcolorspaceselector.ui
+++ b/libs/ui/forms/wdgcolorspaceselector.ui
@@ -1,119 +1,134 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgColorSpaceSelector</class>
  <widget class="QWidget" name="WdgColorSpaceSelector">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>411</width>
-    <height>74</height>
+    <width>276</width>
+    <height>151</height>
    </rect>
   </property>
+  <property name="sizePolicy">
+   <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
+    <horstretch>0</horstretch>
+    <verstretch>0</verstretch>
+   </sizepolicy>
+  </property>
+  <property name="minimumSize">
+   <size>
+    <width>0</width>
+    <height>0</height>
+   </size>
+  </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout">
      <item>
       <widget class="QLabel" name="lblColorSpaces">
        <property name="text">
         <string>&amp;Model:</string>
        </property>
        <property name="buddy">
         <cstring>cmbColorModels</cstring>
        </property>
       </widget>
      </item>
      <item>
       <widget class="KisCmbIDList" name="cmbColorModels">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
       </widget>
      </item>
+    </layout>
+   </item>
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout_3">
      <item>
       <widget class="QLabel" name="lblColorModels">
        <property name="text">
         <string>Depth:</string>
        </property>
        <property name="buddy">
         <cstring>cmbColorModels</cstring>
        </property>
       </widget>
      </item>
      <item>
       <widget class="KisCmbIDList" name="cmbColorDepth">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
       </widget>
      </item>
-     <item>
-      <widget class="QPushButton" name="bnAdvanced">
-       <property name="text">
-        <string>Color Space Browser</string>
-       </property>
-      </widget>
-     </item>
     </layout>
    </item>
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout_2">
      <item>
       <widget class="QLabel" name="lblProfiles">
        <property name="text">
         <string>Profi&amp;le:</string>
        </property>
        <property name="buddy">
         <cstring>cmbProfile</cstring>
        </property>
       </widget>
      </item>
      <item>
       <widget class="KisSqueezedComboBox" name="cmbProfile">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QPushButton" name="bnInstallProfile">
        <property name="toolTip">
         <string>Install a new profile from a file</string>
        </property>
        <property name="whatsThis">
         <string>Install a new profile from a file.</string>
        </property>
        <property name="text">
         <string/>
        </property>
       </widget>
      </item>
     </layout>
    </item>
+   <item>
+    <widget class="QPushButton" name="bnAdvanced">
+     <property name="text">
+      <string>Color Space Browser</string>
+     </property>
+    </widget>
+   </item>
   </layout>
-  <zorder>lblColorSpaces</zorder>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KisCmbIDList</class>
    <extends>QComboBox</extends>
    <header>widgets/kis_cmb_idlist.h</header>
   </customwidget>
   <customwidget>
    <class>KisSqueezedComboBox</class>
    <extends>QComboBox</extends>
    <header>KisSqueezedComboBox.h</header>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/libs/ui/forms/wdgdisplaysettings.ui b/libs/ui/forms/wdgdisplaysettings.ui
index 98488f3c91..23622759f6 100644
--- a/libs/ui/forms/wdgdisplaysettings.ui
+++ b/libs/ui/forms/wdgdisplaysettings.ui
@@ -1,552 +1,639 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgDisplaySettings</class>
  <widget class="QWidget" name="WdgDisplaySettings">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>598</width>
-    <height>595</height>
+    <width>617</width>
+    <height>373</height>
    </rect>
   </property>
   <property name="sizePolicy">
    <sizepolicy hsizetype="MinimumExpanding" vsizetype="MinimumExpanding">
     <horstretch>0</horstretch>
     <verstretch>0</verstretch>
    </sizepolicy>
   </property>
   <property name="windowTitle">
    <string>Display</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <property name="spacing">
     <number>15</number>
    </property>
    <item>
-    <widget class="QGroupBox" name="grpOpenGL">
-     <property name="sizePolicy">
-      <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
-       <horstretch>0</horstretch>
-       <verstretch>0</verstretch>
-      </sizepolicy>
-     </property>
-     <property name="title">
-      <string>Canvas &amp;Graphics Acceleration</string>
-     </property>
-     <property name="checkable">
-      <bool>true</bool>
+    <widget class="QTabWidget" name="tabWidget">
+     <property name="currentIndex">
+      <number>0</number>
      </property>
-     <layout class="QGridLayout">
-      <item row="4" column="1">
-       <widget class="QCheckBox" name="chkDisableVsync">
-        <property name="sizePolicy">
-         <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
-          <horstretch>0</horstretch>
-          <verstretch>0</verstretch>
-         </sizepolicy>
-        </property>
-        <property name="toolTip">
-         <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Try to disable vsync for Krita. This makes painting more responsive. Uncheck only when experiencing crashes with some GPU/driver combinations.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
-        </property>
-        <property name="text">
-         <string>Disable vsync (needs restart)</string>
-        </property>
-        <property name="checked">
-         <bool>true</bool>
-        </property>
-       </widget>
-      </item>
-      <item row="3" column="1">
-       <widget class="QCheckBox" name="chkUseTextureBuffer">
-        <property name="sizePolicy">
-         <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
-          <horstretch>0</horstretch>
-          <verstretch>0</verstretch>
-         </sizepolicy>
-        </property>
-        <property name="toolTip">
-         <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Use Texture Buffering. This can be faster on some GPU/Driver combinations (like Intel) or broken on some others (like AMD/Radeon).&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
-        </property>
-        <property name="text">
-         <string>Use texture buffer</string>
-        </property>
-       </widget>
-      </item>
-      <item row="2" column="0">
-       <widget class="QLabel" name="label">
-        <property name="sizePolicy">
-         <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
-          <horstretch>0</horstretch>
-          <verstretch>0</verstretch>
-         </sizepolicy>
-        </property>
-        <property name="text">
-         <string>Scaling Mode:</string>
-        </property>
-        <property name="alignment">
-         <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
-        </property>
-       </widget>
-      </item>
-      <item row="2" column="1">
-       <widget class="QComboBox" name="cmbFilterMode">
-        <property name="sizePolicy">
-         <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
-          <horstretch>0</horstretch>
-          <verstretch>0</verstretch>
-         </sizepolicy>
-        </property>
-        <property name="currentIndex">
-         <number>0</number>
-        </property>
-        <item>
-         <property name="text">
-          <string>Nearest Neighbour</string>
-         </property>
-        </item>
-        <item>
-         <property name="text">
-          <string>Bilinear Filtering</string>
+     <widget class="QWidget" name="tab">
+      <attribute name="title">
+       <string>Canvas Acceleration</string>
+      </attribute>
+      <layout class="QGridLayout" name="gridLayout">
+       <item row="0" column="0">
+        <widget class="QGroupBox" name="grpOpenGL">
+         <property name="sizePolicy">
+          <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+           <horstretch>0</horstretch>
+           <verstretch>0</verstretch>
+          </sizepolicy>
          </property>
-        </item>
-        <item>
-         <property name="text">
-          <string>Trilinear Filtering</string>
+         <property name="title">
+          <string>Canvas &amp;Graphics Acceleration</string>
          </property>
-        </item>
-        <item>
-         <property name="text">
-          <string>High Quality Filtering</string>
+         <property name="checkable">
+          <bool>true</bool>
          </property>
-        </item>
-       </widget>
-      </item>
-      <item row="1" column="1">
-       <widget class="QComboBox" name="cmbPreferredRenderer">
-        <property name="sizePolicy">
-         <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
-          <horstretch>0</horstretch>
-          <verstretch>0</verstretch>
-         </sizepolicy>
-        </property>
-       </widget>
-      </item>
-      <item row="5" column="0" colspan="2">
-       <widget class="QLabel" name="lblOpenGLWarnings">
-        <property name="text">
-         <string notr="true">OpenGL Warnings</string>
-        </property>
-        <property name="textFormat">
-         <enum>Qt::RichText</enum>
-        </property>
-        <property name="wordWrap">
-         <bool>true</bool>
-        </property>
-       </widget>
-      </item>
-      <item row="1" column="0">
-       <widget class="QLabel" name="lblPreferredRenderer">
-        <property name="sizePolicy">
-         <sizepolicy hsizetype="Fixed" vsizetype="Minimum">
-          <horstretch>0</horstretch>
-          <verstretch>0</verstretch>
-         </sizepolicy>
-        </property>
-        <property name="text">
-         <string>Preferred Renderer (needs restart):</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="lblCurrentRenderer">
-        <property name="text">
-         <string>Unknown</string>
-        </property>
-       </widget>
-      </item>
-      <item row="0" column="0">
-       <widget class="QLabel" name="label_6">
-        <property name="text">
-         <string>Current Renderer:</string>
-        </property>
-       </widget>
-      </item>
-     </layout>
-    </widget>
-   </item>
-   <item>
-    <widget class="QGroupBox" name="grpHDRSettings">
-     <property name="title">
-      <string>HDR</string>
-     </property>
-     <property name="checked">
-      <bool>false</bool>
-     </property>
-     <layout class="QFormLayout" name="formLayout">
-      <item row="0" column="0">
-       <widget class="QLabel" name="label_7">
-        <property name="text">
-         <string>Display Format:</string>
-        </property>
-       </widget>
-      </item>
-      <item row="0" column="1">
-       <widget class="QLabel" name="lblCurrentDisplayFormat">
-        <property name="text">
-         <string>Current Display Format</string>
-        </property>
-       </widget>
-      </item>
-      <item row="1" column="0">
-       <widget class="QLabel" name="label_5">
-        <property name="text">
-         <string>Current Output Format:</string>
-        </property>
-       </widget>
-      </item>
-      <item row="1" column="1">
-       <widget class="QLabel" name="lblCurrentRootSurfaceFormat">
-        <property name="text">
-         <string>Current Surface Value</string>
-        </property>
-       </widget>
-      </item>
-      <item row="2" column="0">
-       <widget class="QLabel" name="label_9">
-        <property name="text">
-         <string>Preferred Output Format:</string>
-        </property>
-       </widget>
-      </item>
-      <item row="2" column="1">
-       <widget class="QComboBox" name="cmbPreferedRootSurfaceFormat"/>
-      </item>
-      <item row="3" column="0" colspan="2">
-       <widget class="QLabel" name="lblHDRWarning">
-        <property name="text">
-         <string>HDR Warning..................................</string>
-        </property>
-       </widget>
-      </item>
-     </layout>
-    </widget>
-   </item>
-   <item>
-    <layout class="QGridLayout" name="options2GridLayout">
-     <property name="topMargin">
-      <number>15</number>
-     </property>
-     <property name="verticalSpacing">
-      <number>7</number>
-     </property>
-     <item row="0" column="2">
-      <layout class="QHBoxLayout" name="horizontalLayout">
-       <item>
-        <widget class="QLabel" name="lblCheckSize">
-         <property name="text">
-          <string>Si&amp;ze:</string>
-         </property>
-         <property name="alignment">
-          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+         <layout class="QGridLayout">
+          <item row="2" column="1">
+           <widget class="QComboBox" name="cmbFilterMode">
+            <property name="sizePolicy">
+             <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+              <horstretch>0</horstretch>
+              <verstretch>0</verstretch>
+             </sizepolicy>
+            </property>
+            <property name="currentIndex">
+             <number>0</number>
+            </property>
+            <item>
+             <property name="text">
+              <string>Nearest Neighbour</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Bilinear Filtering</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>Trilinear Filtering</string>
+             </property>
+            </item>
+            <item>
+             <property name="text">
+              <string>High Quality Filtering</string>
+             </property>
+            </item>
+           </widget>
+          </item>
+          <item row="0" column="0">
+           <widget class="QLabel" name="label_6">
+            <property name="text">
+             <string>Current Renderer:</string>
+            </property>
+           </widget>
+          </item>
+          <item row="4" column="1">
+           <widget class="QCheckBox" name="chkDisableVsync">
+            <property name="sizePolicy">
+             <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+              <horstretch>0</horstretch>
+              <verstretch>0</verstretch>
+             </sizepolicy>
+            </property>
+            <property name="toolTip">
+             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Try to disable vsync for Krita. This makes painting more responsive. Uncheck only when experiencing crashes with some GPU/driver combinations.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+            </property>
+            <property name="text">
+             <string>Disable vsync (needs restart)</string>
+            </property>
+            <property name="checked">
+             <bool>true</bool>
+            </property>
+           </widget>
+          </item>
+          <item row="3" column="1">
+           <widget class="QCheckBox" name="chkUseTextureBuffer">
+            <property name="sizePolicy">
+             <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+              <horstretch>0</horstretch>
+              <verstretch>0</verstretch>
+             </sizepolicy>
+            </property>
+            <property name="toolTip">
+             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Use Texture Buffering. This can be faster on some GPU/Driver combinations (like Intel) or broken on some others (like AMD/Radeon).&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+            </property>
+            <property name="text">
+             <string>Use texture buffer</string>
+            </property>
+           </widget>
+          </item>
+          <item row="1" column="1">
+           <widget class="QComboBox" name="cmbPreferredRenderer">
+            <property name="sizePolicy">
+             <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+              <horstretch>0</horstretch>
+              <verstretch>0</verstretch>
+             </sizepolicy>
+            </property>
+           </widget>
+          </item>
+          <item row="5" column="0" colspan="2">
+           <widget class="QLabel" name="lblOpenGLWarnings">
+            <property name="text">
+             <string notr="true">OpenGL Warnings</string>
+            </property>
+            <property name="textFormat">
+             <enum>Qt::RichText</enum>
+            </property>
+            <property name="wordWrap">
+             <bool>true</bool>
+            </property>
+           </widget>
+          </item>
+          <item row="1" column="0">
+           <widget class="QLabel" name="lblPreferredRenderer">
+            <property name="sizePolicy">
+             <sizepolicy hsizetype="Fixed" vsizetype="Minimum">
+              <horstretch>0</horstretch>
+              <verstretch>0</verstretch>
+             </sizepolicy>
+            </property>
+            <property name="text">
+             <string>Preferred Renderer (needs restart):</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="lblCurrentRenderer">
+            <property name="text">
+             <string>Unknown</string>
+            </property>
+           </widget>
+          </item>
+          <item row="2" column="0">
+           <widget class="QLabel" name="label">
+            <property name="sizePolicy">
+             <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
+              <horstretch>0</horstretch>
+              <verstretch>0</verstretch>
+             </sizepolicy>
+            </property>
+            <property name="text">
+             <string>Scaling Mode:</string>
+            </property>
+            <property name="alignment">
+             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+            </property>
+           </widget>
+          </item>
+          <item row="6" column="0" colspan="2">
+           <spacer name="verticalSpacer_3">
+            <property name="orientation">
+             <enum>Qt::Vertical</enum>
+            </property>
+            <property name="sizeHint" stdset="0">
+             <size>
+              <width>20</width>
+              <height>40</height>
+             </size>
+            </property>
+           </spacer>
+          </item>
+         </layout>
+        </widget>
+       </item>
+      </layout>
+     </widget>
+     <widget class="QWidget" name="tab_2">
+      <attribute name="title">
+       <string>HDR Settings</string>
+      </attribute>
+      <layout class="QGridLayout" name="gridLayout_3">
+       <item row="0" column="0">
+        <widget class="QGroupBox" name="grpHDRSettings">
+         <property name="title">
+          <string/>
          </property>
-         <property name="buddy">
-          <cstring>intCheckSize</cstring>
+         <property name="checked">
+          <bool>false</bool>
          </property>
+         <layout class="QGridLayout" name="gridLayout_2">
+          <item row="1" column="0">
+           <widget class="QLabel" name="label_5">
+            <property name="text">
+             <string>Current Output Format:</string>
+            </property>
+           </widget>
+          </item>
+          <item row="1" column="1">
+           <widget class="QLabel" name="lblCurrentRootSurfaceFormat">
+            <property name="text">
+             <string>Current Surface Value</string>
+            </property>
+           </widget>
+          </item>
+          <item row="0" column="1">
+           <widget class="QLabel" name="lblCurrentDisplayFormat">
+            <property name="text">
+             <string>Current Display Format</string>
+            </property>
+           </widget>
+          </item>
+          <item row="2" column="0">
+           <widget class="QLabel" name="label_9">
+            <property name="text">
+             <string>Preferred Output Format:</string>
+            </property>
+           </widget>
+          </item>
+          <item row="3" column="0" colspan="2">
+           <widget class="QLabel" name="lblHDRWarning">
+            <property name="text">
+             <string>HDR Warning..................................</string>
+            </property>
+           </widget>
+          </item>
+          <item row="0" column="0">
+           <widget class="QLabel" name="label_7">
+            <property name="text">
+             <string>Display Format:</string>
+            </property>
+           </widget>
+          </item>
+          <item row="2" column="1">
+           <widget class="QComboBox" name="cmbPreferedRootSurfaceFormat"/>
+          </item>
+          <item row="4" column="0">
+           <spacer name="verticalSpacer_2">
+            <property name="orientation">
+             <enum>Qt::Vertical</enum>
+            </property>
+            <property name="sizeHint" stdset="0">
+             <size>
+              <width>20</width>
+              <height>40</height>
+             </size>
+            </property>
+           </spacer>
+          </item>
+         </layout>
         </widget>
        </item>
-       <item>
-        <widget class="KisIntParseSpinBox" name="intCheckSize">
-         <property name="suffix">
-          <string> px</string>
-         </property>
-         <property name="maximum">
-          <number>256</number>
+      </layout>
+     </widget>
+     <widget class="QWidget" name="tab_3">
+      <attribute name="title">
+       <string>Grid Settings</string>
+      </attribute>
+      <layout class="QGridLayout" name="gridLayout_4">
+       <item row="0" column="0">
+        <layout class="QGridLayout" name="options2GridLayout">
+         <property name="topMargin">
+          <number>15</number>
          </property>
-         <property name="value">
-          <number>32</number>
+         <property name="verticalSpacing">
+          <number>7</number>
          </property>
-        </widget>
+         <item row="0" column="2">
+          <layout class="QHBoxLayout" name="horizontalLayout">
+           <item>
+            <widget class="QLabel" name="lblCheckSize">
+             <property name="text">
+              <string>Si&amp;ze:</string>
+             </property>
+             <property name="alignment">
+              <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+             </property>
+             <property name="buddy">
+              <cstring>intCheckSize</cstring>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="KisIntParseSpinBox" name="intCheckSize">
+             <property name="suffix">
+              <string> px</string>
+             </property>
+             <property name="maximum">
+              <number>256</number>
+             </property>
+             <property name="value">
+              <number>32</number>
+             </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="4" column="2">
+          <layout class="QHBoxLayout" name="horizontalLayout_2">
+           <item>
+            <widget class="QLabel" name="gridThresholdLabel">
+             <property name="text">
+              <string>Start showing at:</string>
+             </property>
+             <property name="alignment">
+              <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QDoubleSpinBox" name="pixelGridDrawingThresholdBox">
+             <property name="sizePolicy">
+              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+               <horstretch>0</horstretch>
+               <verstretch>0</verstretch>
+              </sizepolicy>
+             </property>
+             <property name="suffix">
+              <string>%</string>
+             </property>
+             <property name="maximum">
+              <double>9999.000000000000000</double>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <spacer name="horizontalSpacer_2">
+             <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="2" column="2">
+          <layout class="QHBoxLayout" name="horizontalLayout_3">
+           <item>
+            <widget class="QLabel" name="label_3">
+             <property name="text">
+              <string>Opacity:</string>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="KisDoubleSliderSpinBox" name="sldSelectionOverlayOpacity" native="true">
+             <property name="sizePolicy">
+              <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">
+               <horstretch>0</horstretch>
+               <verstretch>0</verstretch>
+              </sizepolicy>
+             </property>
+             <property name="minimumSize">
+              <size>
+               <width>50</width>
+               <height>20</height>
+              </size>
+             </property>
+            </widget>
+           </item>
+          </layout>
+         </item>
+         <item row="2" column="1">
+          <widget class="KisColorButton" name="btnSelectionOverlayColor">
+           <property name="text">
+            <string/>
+           </property>
+          </widget>
+         </item>
+         <item row="4" column="0">
+          <widget class="QLabel" name="lblCanvasBorderColor_2">
+           <property name="text">
+            <string>Pixel Grid:</string>
+           </property>
+           <property name="alignment">
+            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+           </property>
+          </widget>
+         </item>
+         <item row="2" column="0">
+          <widget class="QLabel" name="label_2">
+           <property name="sizePolicy">
+            <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
+             <horstretch>0</horstretch>
+             <verstretch>0</verstretch>
+            </sizepolicy>
+           </property>
+           <property name="text">
+            <string>Selection Overlay:</string>
+           </property>
+           <property name="alignment">
+            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+           </property>
+          </widget>
+         </item>
+         <item row="0" column="0">
+          <widget class="QLabel" name="label_4">
+           <property name="sizePolicy">
+            <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
+             <horstretch>0</horstretch>
+             <verstretch>0</verstretch>
+            </sizepolicy>
+           </property>
+           <property name="text">
+            <string>Transparency Checkerboard:</string>
+           </property>
+           <property name="alignment">
+            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+           </property>
+          </widget>
+         </item>
+         <item row="4" column="1">
+          <widget class="KisColorButton" name="pixelGridColorButton">
+           <property name="text">
+            <string/>
+           </property>
+          </widget>
+         </item>
+         <item row="0" column="1">
+          <layout class="QHBoxLayout" name="horizontalLayout_4">
+           <item>
+            <widget class="KisColorButton" name="colorChecks2"/>
+           </item>
+           <item>
+            <widget class="KisColorButton" name="colorChecks1"/>
+           </item>
+          </layout>
+         </item>
+         <item row="1" column="0">
+          <widget class="QLabel" name="lblCanvasBorderColor">
+           <property name="text">
+            <string>Canvas Border Color:</string>
+           </property>
+           <property name="alignment">
+            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+           </property>
+          </widget>
+         </item>
+         <item row="1" column="1">
+          <widget class="KisColorButton" name="canvasBorder">
+           <property name="sizePolicy">
+            <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
+             <horstretch>0</horstretch>
+             <verstretch>0</verstretch>
+            </sizepolicy>
+           </property>
+          </widget>
+         </item>
+        </layout>
        </item>
-       <item>
-        <spacer name="horizontalSpacer">
+       <item row="1" column="0">
+        <spacer name="verticalSpacer_4">
          <property name="orientation">
-          <enum>Qt::Horizontal</enum>
+          <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
-           <width>40</width>
-           <height>20</height>
+           <width>20</width>
+           <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
-     </item>
-     <item row="4" column="2">
-      <layout class="QHBoxLayout" name="horizontalLayout_2">
-       <item>
-        <widget class="QLabel" name="gridThresholdLabel">
-         <property name="text">
-          <string>Start showing at:</string>
-         </property>
-         <property name="alignment">
-          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
-         </property>
-        </widget>
-       </item>
-       <item>
-        <widget class="QDoubleSpinBox" name="pixelGridDrawingThresholdBox">
-         <property name="sizePolicy">
-          <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
-           <horstretch>0</horstretch>
-           <verstretch>0</verstretch>
-          </sizepolicy>
+     </widget>
+     <widget class="QWidget" name="tab_4">
+      <attribute name="title">
+       <string>Miscellaneous</string>
+      </attribute>
+      <layout class="QGridLayout" name="gridLayout_5">
+       <item row="0" column="0">
+        <layout class="QGridLayout" name="checkboxesLayout">
+         <property name="topMargin">
+          <number>20</number>
          </property>
-         <property name="suffix">
-          <string>%</string>
+         <property name="horizontalSpacing">
+          <number>0</number>
          </property>
-         <property name="maximum">
-          <double>9999.000000000000000</double>
+         <property name="verticalSpacing">
+          <number>10</number>
          </property>
-        </widget>
+         <item row="0" column="0">
+          <widget class="QCheckBox" name="hideScrollbars">
+           <property name="text">
+            <string>Hide Window Scrollbars</string>
+           </property>
+           <property name="checked">
+            <bool>false</bool>
+           </property>
+          </widget>
+         </item>
+         <item row="2" column="0">
+          <widget class="QCheckBox" name="chkHidePopups">
+           <property name="text">
+            <string>Hide layer thumbnail popup</string>
+           </property>
+          </widget>
+         </item>
+         <item row="1" column="0">
+          <widget class="QCheckBox" name="chkCurveAntialiasing">
+           <property name="text">
+            <string>Enable curve anti-aliasing</string>
+           </property>
+          </widget>
+         </item>
+         <item row="0" column="1">
+          <widget class="QCheckBox" name="chkChannelsAsColor">
+           <property name="text">
+            <string>Color channels in color</string>
+           </property>
+           <property name="checked">
+            <bool>false</bool>
+           </property>
+          </widget>
+         </item>
+         <item row="1" column="1">
+          <widget class="QCheckBox" name="chkSelectionOutlineAntialiasing">
+           <property name="text">
+            <string>Enable selection outline anti-aliasing</string>
+           </property>
+          </widget>
+         </item>
+         <item row="2" column="1">
+          <widget class="QCheckBox" name="chkMoving">
+           <property name="toolTip">
+            <string>If checked, the checkers will move when scrolling the canvas.</string>
+           </property>
+           <property name="whatsThis">
+            <string>Determines whether the checks will stay put or whether they will scroll together with the canvas</string>
+           </property>
+           <property name="text">
+            <string>&amp;Move checkers when scrolling</string>
+           </property>
+           <property name="checked">
+            <bool>true</bool>
+           </property>
+          </widget>
+         </item>
+        </layout>
        </item>
-       <item>
-        <spacer name="horizontalSpacer_2">
+       <item row="1" column="0">
+        <spacer name="verticalSpacer_5">
          <property name="orientation">
-          <enum>Qt::Horizontal</enum>
+          <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
-           <width>40</width>
-           <height>20</height>
+           <width>20</width>
+           <height>341</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
-     </item>
-     <item row="2" column="2">
-      <layout class="QHBoxLayout" name="horizontalLayout_3">
-       <item>
-        <widget class="QLabel" name="label_3">
-         <property name="text">
-          <string>Opacity:</string>
-         </property>
-        </widget>
-       </item>
-       <item>
-        <widget class="KisDoubleSliderSpinBox" name="sldSelectionOverlayOpacity" native="true">
-         <property name="sizePolicy">
-          <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">
-           <horstretch>0</horstretch>
-           <verstretch>0</verstretch>
-          </sizepolicy>
-         </property>
-         <property name="minimumSize">
-          <size>
-           <width>50</width>
-           <height>20</height>
-          </size>
-         </property>
-        </widget>
-       </item>
-      </layout>
-     </item>
-     <item row="2" column="1">
-      <widget class="KisColorButton" name="btnSelectionOverlayColor">
-       <property name="text">
-        <string/>
-       </property>
-      </widget>
-     </item>
-     <item row="4" column="0">
-      <widget class="QLabel" name="lblCanvasBorderColor_2">
-       <property name="text">
-        <string>Pixel Grid:</string>
-       </property>
-       <property name="alignment">
-        <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
-       </property>
-      </widget>
-     </item>
-     <item row="2" column="0">
-      <widget class="QLabel" name="label_2">
-       <property name="sizePolicy">
-        <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
-         <horstretch>0</horstretch>
-         <verstretch>0</verstretch>
-        </sizepolicy>
-       </property>
-       <property name="text">
-        <string>Selection Overlay:</string>
-       </property>
-       <property name="alignment">
-        <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
-       </property>
-      </widget>
-     </item>
-     <item row="0" column="0">
-      <widget class="QLabel" name="label_4">
-       <property name="sizePolicy">
-        <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
-         <horstretch>0</horstretch>
-         <verstretch>0</verstretch>
-        </sizepolicy>
-       </property>
-       <property name="text">
-        <string>Transparency Checkerboard:</string>
-       </property>
-       <property name="alignment">
-        <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
-       </property>
-      </widget>
-     </item>
-     <item row="4" column="1">
-      <widget class="KisColorButton" name="pixelGridColorButton">
-       <property name="text">
-        <string/>
-       </property>
-      </widget>
-     </item>
-     <item row="0" column="1">
-      <layout class="QHBoxLayout" name="horizontalLayout_4">
-       <item>
-        <widget class="KisColorButton" name="colorChecks2"/>
-       </item>
-       <item>
-        <widget class="KisColorButton" name="colorChecks1"/>
-       </item>
-      </layout>
-     </item>
-     <item row="1" column="0">
-      <widget class="QLabel" name="lblCanvasBorderColor">
-       <property name="text">
-        <string>Canvas Border Color:</string>
-       </property>
-       <property name="alignment">
-        <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
-       </property>
-      </widget>
-     </item>
-     <item row="1" column="1">
-      <widget class="KisColorButton" name="canvasBorder">
-       <property name="sizePolicy">
-        <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
-         <horstretch>0</horstretch>
-         <verstretch>0</verstretch>
-        </sizepolicy>
-       </property>
-      </widget>
-     </item>
-    </layout>
-   </item>
-   <item>
-    <layout class="QGridLayout" name="checkboxesLayout">
-     <property name="topMargin">
-      <number>20</number>
-     </property>
-     <property name="horizontalSpacing">
-      <number>0</number>
-     </property>
-     <property name="verticalSpacing">
-      <number>10</number>
-     </property>
-     <item row="0" column="0">
-      <widget class="QCheckBox" name="hideScrollbars">
-       <property name="text">
-        <string>Hide Window Scrollbars</string>
-       </property>
-       <property name="checked">
-        <bool>false</bool>
-       </property>
-      </widget>
-     </item>
-     <item row="2" column="0">
-      <widget class="QCheckBox" name="chkHidePopups">
-       <property name="text">
-        <string>Hide layer thumbnail popup</string>
-       </property>
-      </widget>
-     </item>
-     <item row="1" column="0">
-      <widget class="QCheckBox" name="chkCurveAntialiasing">
-       <property name="text">
-        <string>Enable curve anti-aliasing</string>
-       </property>
-      </widget>
-     </item>
-     <item row="0" column="1">
-      <widget class="QCheckBox" name="chkChannelsAsColor">
-       <property name="text">
-        <string>Color channels in color</string>
-       </property>
-       <property name="checked">
-        <bool>false</bool>
-       </property>
-      </widget>
-     </item>
-     <item row="1" column="1">
-      <widget class="QCheckBox" name="chkSelectionOutlineAntialiasing">
-       <property name="text">
-        <string>Enable selection outline anti-aliasing</string>
-       </property>
-      </widget>
-     </item>
-     <item row="2" column="1">
-      <widget class="QCheckBox" name="chkMoving">
-       <property name="toolTip">
-        <string>If checked, the checkers will move when scrolling the canvas.</string>
-       </property>
-       <property name="whatsThis">
-        <string>Determines whether the checks will stay put or whether they will scroll together with the canvas</string>
-       </property>
-       <property name="text">
-        <string>&amp;Move checkers when scrolling</string>
-       </property>
-       <property name="checked">
-        <bool>true</bool>
-       </property>
-      </widget>
-     </item>
-    </layout>
+     </widget>
+    </widget>
    </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>
  <customwidgets>
   <customwidget>
    <class>KisIntParseSpinBox</class>
    <extends>QSpinBox</extends>
    <header>kis_int_parse_spin_box.h</header>
   </customwidget>
   <customwidget>
    <class>KisColorButton</class>
    <extends>QPushButton</extends>
    <header>kis_color_button.h</header>
   </customwidget>
   <customwidget>
    <class>KisDoubleSliderSpinBox</class>
    <extends>QWidget</extends>
    <header>kis_slider_spin_box.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/libs/ui/forms/wdgnewimage.ui b/libs/ui/forms/wdgnewimage.ui
index 8fb4311b32..1804a1e8be 100644
--- a/libs/ui/forms/wdgnewimage.ui
+++ b/libs/ui/forms/wdgnewimage.ui
@@ -1,685 +1,757 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgNewImage</class>
  <widget class="QWidget" name="WdgNewImage">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>600</width>
-    <height>512</height>
+    <width>450</width>
+    <height>471</height>
    </rect>
   </property>
   <property name="sizePolicy">
    <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
     <horstretch>0</horstretch>
     <verstretch>0</verstretch>
    </sizepolicy>
   </property>
   <property name="minimumSize">
    <size>
-    <width>600</width>
+    <width>450</width>
     <height>0</height>
    </size>
   </property>
   <property name="maximumSize">
    <size>
     <width>16777215</width>
     <height>16777215</height>
    </size>
   </property>
   <property name="windowTitle">
    <string>New Image</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
     <widget class="QTabWidget" name="tabWidget">
      <property name="sizePolicy">
-      <sizepolicy hsizetype="Expanding" vsizetype="Minimum">
+      <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="currentIndex">
       <number>0</number>
      </property>
      <widget class="QWidget" name="tab">
       <property name="sizePolicy">
        <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
         <horstretch>0</horstretch>
         <verstretch>0</verstretch>
        </sizepolicy>
       </property>
       <attribute name="title">
        <string>Dimensions</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_3">
-       <item row="1" column="0">
-        <widget class="QGroupBox" name="grpMode">
-         <property name="sizePolicy">
-          <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
-           <horstretch>0</horstretch>
-           <verstretch>0</verstretch>
-          </sizepolicy>
-         </property>
-         <property name="title">
-          <string>Color</string>
-         </property>
-         <layout class="QVBoxLayout">
-          <item>
-           <widget class="KisColorSpaceSelector" name="colorSpaceSelector" native="true"/>
-          </item>
-         </layout>
-        </widget>
-       </item>
        <item row="0" column="0">
         <layout class="QHBoxLayout" name="horizontalLayout_3">
          <item>
           <widget class="QGroupBox" name="grpImage">
            <property name="minimumSize">
             <size>
              <width>0</width>
              <height>140</height>
             </size>
            </property>
            <property name="maximumSize">
             <size>
              <width>16777215</width>
              <height>16777215</height>
             </size>
            </property>
            <property name="title">
             <string>Image Size</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>
            <layout class="QGridLayout" name="gridLayout">
             <item row="1" column="0">
-             <layout class="QHBoxLayout" name="horizontalLayout">
-              <item>
-               <widget class="QLabel" name="label_2">
-                <property name="text">
-                 <string>P&amp;redefined:</string>
-                </property>
-                <property name="alignment">
-                 <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
-                </property>
-                <property name="buddy">
-                 <cstring>cmbPredefined</cstring>
-                </property>
-               </widget>
-              </item>
-              <item>
-               <widget class="QComboBox" name="cmbPredefined">
-                <property name="sizePolicy">
-                 <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
-                  <horstretch>0</horstretch>
-                  <verstretch>0</verstretch>
-                 </sizepolicy>
-                </property>
-               </widget>
-              </item>
-              <item>
-               <widget class="QLabel" name="label_3">
-                <property name="text">
-                 <string>Save As:</string>
-                </property>
-               </widget>
-              </item>
-              <item>
-               <widget class="QLineEdit" name="txtPredefinedName">
-                <property name="sizePolicy">
-                 <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
-                  <horstretch>0</horstretch>
-                  <verstretch>0</verstretch>
-                 </sizepolicy>
-                </property>
-               </widget>
-              </item>
-              <item>
-               <widget class="QPushButton" name="bnSaveAsPredefined">
-                <property name="toolTip">
-                 <string>Save the current dimensions</string>
-                </property>
-                <property name="text">
-                 <string>&amp;Save</string>
-                </property>
-               </widget>
-              </item>
-             </layout>
-            </item>
-            <item row="2" column="0">
              <layout class="QHBoxLayout">
               <item>
                <layout class="QGridLayout" name="gridLayout_4">
-                <item row="0" column="3">
-                 <widget class="QToolButton" name="bnLandscape">
-                  <property name="toolTip">
-                   <string>Landscape</string>
-                  </property>
-                  <property name="text">
-                   <string>...</string>
+                <item row="2" column="2">
+                 <widget class="QComboBox" name="cmbHeightUnit"/>
+                </item>
+                <item row="0" column="1">
+                 <widget class="QComboBox" name="cmbPredefined">
+                  <property name="sizePolicy">
+                   <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+                    <horstretch>0</horstretch>
+                    <verstretch>0</verstretch>
+                   </sizepolicy>
                   </property>
-                  <property name="checkable">
-                   <bool>true</bool>
+                 </widget>
+                </item>
+                <item row="2" column="1">
+                 <widget class="KisDoubleParseSpinBox" name="doubleHeight">
+                  <property name="sizePolicy">
+                   <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+                    <horstretch>0</horstretch>
+                    <verstretch>0</verstretch>
+                   </sizepolicy>
                   </property>
-                  <property name="autoExclusive">
-                   <bool>true</bool>
+                  <property name="minimum">
+                   <double>1.000000000000000</double>
                   </property>
-                  <property name="autoRaise">
-                   <bool>true</bool>
+                  <property name="maximum">
+                   <double>100000000.000000000000000</double>
                   </property>
                  </widget>
                 </item>
-                <item row="0" column="1">
+                <item row="1" column="1">
                  <widget class="KisDoubleParseSpinBox" name="doubleWidth">
+                  <property name="sizePolicy">
+                   <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+                    <horstretch>0</horstretch>
+                    <verstretch>0</verstretch>
+                   </sizepolicy>
+                  </property>
                   <property name="decimals">
                    <number>2</number>
                   </property>
                   <property name="minimum">
                    <double>1.000000000000000</double>
                   </property>
                   <property name="maximum">
                    <double>100000000.000000000000000</double>
                   </property>
                  </widget>
                 </item>
-                <item row="1" column="0">
+                <item row="2" column="0">
                  <widget class="QLabel" name="lblHeight">
                   <property name="text">
                    <string>&amp;Height:</string>
                   </property>
                   <property name="alignment">
                    <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
                   </property>
                   <property name="buddy">
                    <cstring>doubleHeight</cstring>
                   </property>
                  </widget>
                 </item>
-                <item row="2" column="1">
+                <item row="3" column="1">
                  <widget class="KisDoubleParseSpinBox" name="doubleResolution">
+                  <property name="sizePolicy">
+                   <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+                    <horstretch>0</horstretch>
+                    <verstretch>0</verstretch>
+                   </sizepolicy>
+                  </property>
                   <property name="decimals">
                    <number>0</number>
                   </property>
                   <property name="minimum">
                    <double>1.000000000000000</double>
                   </property>
                   <property name="maximum">
                    <double>9999.000000000000000</double>
                   </property>
                  </widget>
                 </item>
-                <item row="2" column="0">
+                <item row="3" column="0">
                  <widget class="QLabel" name="lblResolution">
                   <property name="text">
                    <string>Resolution:</string>
                   </property>
+                  <property name="alignment">
+                   <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+                  </property>
                  </widget>
                 </item>
-                <item row="1" column="1">
-                 <widget class="KisDoubleParseSpinBox" name="doubleHeight">
-                  <property name="minimum">
-                   <double>1.000000000000000</double>
+                <item row="0" column="0">
+                 <widget class="QLabel" name="label_2">
+                  <property name="text">
+                   <string>P&amp;redefined:</string>
                   </property>
-                  <property name="maximum">
-                   <double>100000000.000000000000000</double>
+                  <property name="alignment">
+                   <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+                  </property>
+                  <property name="buddy">
+                   <cstring>cmbPredefined</cstring>
                   </property>
                  </widget>
                 </item>
-                <item row="0" column="2">
-                 <widget class="QComboBox" name="cmbWidthUnit"/>
-                </item>
                 <item row="1" column="2">
-                 <widget class="QComboBox" name="cmbHeightUnit"/>
-                </item>
-                <item row="2" column="2">
-                 <widget class="QLabel" name="label">
-                  <property name="toolTip">
-                   <string>pixels-per-inch</string>
-                  </property>
-                  <property name="text">
-                   <string>ppi</string>
-                  </property>
-                 </widget>
+                 <widget class="QComboBox" name="cmbWidthUnit"/>
                 </item>
-                <item row="0" column="0">
+                <item row="1" column="0">
                  <widget class="QLabel" name="lblWidth">
                   <property name="text">
                    <string>W&amp;idth:</string>
                   </property>
                   <property name="alignment">
                    <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
                   </property>
                   <property name="buddy">
                    <cstring>doubleWidth</cstring>
                   </property>
                  </widget>
                 </item>
-                <item row="0" column="4">
-                 <widget class="QToolButton" name="bnPortrait">
+                <item row="3" column="2">
+                 <widget class="QLabel" name="label">
                   <property name="toolTip">
-                   <string>Portrait</string>
+                   <string>pixels-per-inch</string>
                   </property>
                   <property name="text">
-                   <string>...</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>
+                   <string>ppi</string>
                   </property>
                  </widget>
                 </item>
+                <item row="0" column="2">
+                 <layout class="QHBoxLayout" name="horizontalLayout">
+                  <item>
+                   <spacer name="horizontalSpacer">
+                    <property name="orientation">
+                     <enum>Qt::Horizontal</enum>
+                    </property>
+                    <property name="sizeHint" stdset="0">
+                     <size>
+                      <width>5</width>
+                      <height>5</height>
+                     </size>
+                    </property>
+                   </spacer>
+                  </item>
+                  <item>
+                   <widget class="QToolButton" name="bnLandscape">
+                    <property name="toolTip">
+                     <string>Landscape</string>
+                    </property>
+                    <property name="text">
+                     <string>...</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="bnPortrait">
+                    <property name="toolTip">
+                     <string>Portrait</string>
+                    </property>
+                    <property name="text">
+                     <string>...</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>
+                 </layout>
+                </item>
                </layout>
               </item>
-              <item>
-               <layout class="QVBoxLayout" name="orientationLayout"/>
-              </item>
-              <item>
-               <spacer>
-                <property name="orientation">
-                 <enum>Qt::Horizontal</enum>
-                </property>
-                <property name="sizeType">
-                 <enum>QSizePolicy::Expanding</enum>
-                </property>
-                <property name="sizeHint" stdset="0">
-                 <size>
-                  <width>191</width>
-                  <height>61</height>
-                 </size>
-                </property>
-               </spacer>
-              </item>
              </layout>
             </item>
            </layout>
           </widget>
          </item>
          <item>
           <widget class="QGroupBox" name="grpClipboard">
            <property name="title">
             <string>Clipboard</string>
            </property>
            <layout class="QVBoxLayout" name="verticalLayout_2">
             <item>
              <widget class="QLabel" name="lblPreview">
               <property name="maximumSize">
                <size>
                 <width>75</width>
                 <height>75</height>
                </size>
               </property>
               <property name="baseSize">
                <size>
                 <width>250</width>
                 <height>250</height>
                </size>
               </property>
               <property name="frameShape">
                <enum>QFrame::StyledPanel</enum>
               </property>
               <property name="text">
                <string>TextLabel</string>
               </property>
              </widget>
             </item>
             <item>
              <spacer name="imageGroupSpacer">
               <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>
          </item>
         </layout>
        </item>
+       <item row="2" column="0">
+        <widget class="QGroupBox" name="grpMode">
+         <property name="sizePolicy">
+          <sizepolicy hsizetype="MinimumExpanding" vsizetype="Minimum">
+           <horstretch>0</horstretch>
+           <verstretch>0</verstretch>
+          </sizepolicy>
+         </property>
+         <property name="minimumSize">
+          <size>
+           <width>0</width>
+           <height>0</height>
+          </size>
+         </property>
+         <property name="title">
+          <string>Color</string>
+         </property>
+         <layout class="QVBoxLayout">
+          <item>
+           <widget class="KisColorSpaceSelector" name="colorSpaceSelector" native="true">
+            <property name="sizePolicy">
+             <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+              <horstretch>0</horstretch>
+              <verstretch>0</verstretch>
+             </sizepolicy>
+            </property>
+            <property name="minimumSize">
+             <size>
+              <width>0</width>
+              <height>0</height>
+             </size>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </widget>
+       </item>
+       <item row="1" column="0">
+        <layout class="QHBoxLayout" name="horizontalLayout_2">
+         <item>
+          <widget class="QLabel" name="label_3">
+           <property name="text">
+            <string>Save Image Size as:</string>
+           </property>
+           <property name="alignment">
+            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <widget class="QLineEdit" name="txtPredefinedName">
+           <property name="sizePolicy">
+            <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
+             <horstretch>0</horstretch>
+             <verstretch>0</verstretch>
+            </sizepolicy>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <widget class="QPushButton" name="bnSaveAsPredefined">
+           <property name="sizePolicy">
+            <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+             <horstretch>0</horstretch>
+             <verstretch>0</verstretch>
+            </sizepolicy>
+           </property>
+           <property name="toolTip">
+            <string>Save the current dimensions</string>
+           </property>
+           <property name="text">
+            <string>&amp;Save</string>
+           </property>
+          </widget>
+         </item>
+        </layout>
+       </item>
       </layout>
      </widget>
      <widget class="QWidget" name="tab_2">
       <property name="sizePolicy">
        <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
         <horstretch>0</horstretch>
         <verstretch>0</verstretch>
        </sizepolicy>
       </property>
       <attribute name="title">
        <string>Content</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_2">
        <item row="1" column="1">
         <widget class="QLabel" name="label_4">
          <property name="text">
           <string>Layers:</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
          </property>
         </widget>
        </item>
        <item row="3" column="1">
         <widget class="QLabel" name="lblOpacity">
          <property name="text">
           <string>Background Opacity:</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
          </property>
          <property name="buddy">
           <cstring>sliderOpacity</cstring>
          </property>
         </widget>
        </item>
        <item row="1" column="2">
         <widget class="KisIntParseSpinBox" name="intNumLayers">
+         <property name="sizePolicy">
+          <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+           <horstretch>0</horstretch>
+           <verstretch>0</verstretch>
+          </sizepolicy>
+         </property>
          <property name="minimumSize">
           <size>
            <width>0</width>
            <height>0</height>
           </size>
          </property>
          <property name="toolTip">
           <string>Number of layers that the image will start with, including optional background layer.</string>
          </property>
          <property name="minimum">
           <number>1</number>
          </property>
          <property name="maximum">
           <number>200</number>
          </property>
          <property name="value">
           <number>2</number>
          </property>
         </widget>
        </item>
        <item row="2" column="1">
         <widget class="QLabel" name="lblColor">
          <property name="text">
           <string>Bac&amp;kground Color:</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
          </property>
          <property name="buddy">
           <cstring>cmbColor</cstring>
          </property>
         </widget>
        </item>
        <item row="4" column="1">
         <widget class="QLabel" name="lblBackgroundStyle">
          <property name="text">
           <string>Background:</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignRight|Qt::AlignTop|Qt::AlignTrailing</set>
          </property>
         </widget>
        </item>
        <item row="5" column="1">
         <widget class="QLabel" name="lblDescription">
          <property name="text">
           <string>&amp;Description:</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignRight|Qt::AlignTop|Qt::AlignTrailing</set>
          </property>
          <property name="buddy">
           <cstring>txtDescription</cstring>
          </property>
         </widget>
        </item>
        <item row="5" column="2">
         <widget class="QTextEdit" name="txtDescription">
          <property name="sizePolicy">
-          <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+          <sizepolicy hsizetype="Preferred" vsizetype="Expanding">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="maximumSize">
           <size>
            <width>16777215</width>
            <height>100</height>
           </size>
          </property>
         </widget>
        </item>
        <item row="4" column="2">
         <layout class="QVBoxLayout" name="verticalLayout_3">
          <item>
           <widget class="QRadioButton" name="radioBackgroundAsRaster">
+           <property name="sizePolicy">
+            <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+             <horstretch>0</horstretch>
+             <verstretch>0</verstretch>
+            </sizepolicy>
+           </property>
            <property name="toolTip">
             <string>Use background color and opacity to create a background raster layer.</string>
            </property>
            <property name="text">
             <string>As &amp;raster layer</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QRadioButton" name="radioBackgroundAsProjection">
+           <property name="sizePolicy">
+            <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+             <horstretch>0</horstretch>
+             <verstretch>0</verstretch>
+            </sizepolicy>
+           </property>
            <property name="toolTip">
             <string>Use background color and opacity as the base canvas color. This can be reconfigured in `Image &gt; Properties.`</string>
            </property>
            <property name="text">
             <string>As can&amp;vas color</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QRadioButton" name="radioBackgroundAsFill">
+           <property name="sizePolicy">
+            <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+             <horstretch>0</horstretch>
+             <verstretch>0</verstretch>
+            </sizepolicy>
+           </property>
            <property name="toolTip">
             <string>Use background color and opacity to create a background fill layer. The color for this layer can be reconfigured in the layer's properties.</string>
            </property>
            <property name="text">
             <string>As fill la&amp;yer</string>
            </property>
           </widget>
          </item>
         </layout>
        </item>
        <item row="2" column="2">
         <widget class="KisColorButton" name="cmbColor">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="minimumSize">
           <size>
            <width>50</width>
            <height>0</height>
           </size>
          </property>
          <property name="toolTip">
           <string/>
          </property>
         </widget>
        </item>
        <item row="3" column="2">
         <widget class="QFrame" name="opacityPanel">
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Plain</enum>
          </property>
          <layout class="QHBoxLayout" name="_2">
           <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="KisDoubleSliderSpinBox" name="sliderOpacity" native="true"/>
           </item>
          </layout>
         </widget>
        </item>
        <item row="6" column="2">
         <spacer name="verticalSpacer_2">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
-           <height>40</height>
+           <height>20</height>
           </size>
          </property>
         </spacer>
        </item>
        <item row="0" column="1">
         <widget class="QLabel" name="lblName">
          <property name="text">
           <string>&amp;Name:</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
          </property>
          <property name="buddy">
           <cstring>txtName</cstring>
          </property>
         </widget>
        </item>
        <item row="0" column="2">
         <widget class="QLineEdit" name="txtName">
+         <property name="sizePolicy">
+          <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+           <horstretch>0</horstretch>
+           <verstretch>0</verstretch>
+          </sizepolicy>
+         </property>
          <property name="toolTip">
           <string/>
          </property>
          <property name="text">
           <string>untitled-1</string>
          </property>
         </widget>
        </item>
       </layout>
       <zorder>label_4</zorder>
       <zorder>lblBackgroundStyle</zorder>
       <zorder>txtDescription</zorder>
       <zorder>lblDescription</zorder>
       <zorder>intNumLayers</zorder>
       <zorder>opacityPanel</zorder>
       <zorder>lblColor</zorder>
       <zorder>cmbColor</zorder>
       <zorder>lblOpacity</zorder>
       <zorder>lblName</zorder>
       <zorder>txtName</zorder>
      </widget>
     </widget>
    </item>
    <item>
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeType">
       <enum>QSizePolicy::Expanding</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>10</width>
        <height>10</height>
       </size>
      </property>
     </spacer>
    </item>
    <item>
     <widget class="QLabel" name="lblDocumentInfo">
      <property name="text">
       <string>This document...</string>
      </property>
      <property name="wordWrap">
       <bool>true</bool>
      </property>
     </widget>
    </item>
    <item>
     <widget class="QDialogButtonBox" name="newDialogConfirmationButtonBox">
      <property name="standardButtons">
       <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
      </property>
     </widget>
    </item>
   </layout>
  </widget>
  <customwidgets>
-  <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>
   <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>
+  <customwidget>
+   <class>KisIntParseSpinBox</class>
+   <extends>QSpinBox</extends>
+   <header>kis_int_parse_spin_box.h</header>
+  </customwidget>
   <customwidget>
    <class>KisDoubleParseSpinBox</class>
    <extends>QDoubleSpinBox</extends>
    <header>kis_double_parse_spin_box.h</header>
   </customwidget>
  </customwidgets>
  <tabstops>
   <tabstop>tabWidget</tabstop>
-  <tabstop>cmbPredefined</tabstop>
-  <tabstop>txtPredefinedName</tabstop>
-  <tabstop>bnSaveAsPredefined</tabstop>
   <tabstop>doubleWidth</tabstop>
   <tabstop>doubleHeight</tabstop>
   <tabstop>doubleResolution</tabstop>
   <tabstop>cmbWidthUnit</tabstop>
   <tabstop>cmbHeightUnit</tabstop>
-  <tabstop>bnLandscape</tabstop>
-  <tabstop>bnPortrait</tabstop>
   <tabstop>intNumLayers</tabstop>
   <tabstop>cmbColor</tabstop>
   <tabstop>radioBackgroundAsRaster</tabstop>
   <tabstop>radioBackgroundAsProjection</tabstop>
   <tabstop>txtDescription</tabstop>
  </tabstops>
  <resources/>
  <connections/>
 </ui>
diff --git a/libs/ui/forms/wdgrectangleconstraints.ui b/libs/ui/forms/wdgrectangleconstraints.ui
index ccb9d1b86d..7c716c6f05 100644
--- a/libs/ui/forms/wdgrectangleconstraints.ui
+++ b/libs/ui/forms/wdgrectangleconstraints.ui
@@ -1,266 +1,266 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgRectangleConstraints</class>
  <widget class="QWidget" name="WdgRectangleConstraints">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>243</width>
     <height>328</height>
    </rect>
   </property>
   <property name="sizePolicy">
    <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
     <horstretch>0</horstretch>
     <verstretch>0</verstretch>
    </sizepolicy>
   </property>
   <property name="windowTitle">
    <string>Size</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
     <layout class="QGridLayout" name="gridLayout">
      <property name="leftMargin">
       <number>7</number>
      </property>
      <property name="topMargin">
       <number>7</number>
      </property>
      <property name="rightMargin">
       <number>7</number>
      </property>
      <property name="bottomMargin">
       <number>7</number>
      </property>
      <property name="spacing">
       <number>7</number>
      </property>
      <item row="1" column="3">
       <widget class="QPushButton" name="lockHeightButton">
        <property name="text">
         <string/>
        </property>
        <property name="checkable">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item row="2" column="3">
       <widget class="QPushButton" name="lockRatioButton">
        <property name="text">
         <string/>
        </property>
        <property name="checkable">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item row="0" column="3">
       <widget class="QPushButton" name="lockWidthButton">
        <property name="text">
         <string/>
        </property>
        <property name="checkable">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item row="1" column="2">
       <widget class="KisIntParseSpinBox" name="intHeight">
        <property name="sizePolicy">
         <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="toolTip">
         <string>Height</string>
        </property>
        <property name="suffix">
         <string> px</string>
        </property>
        <property name="maximum">
         <number>99999</number>
        </property>
       </widget>
      </item>
      <item row="0" column="1">
       <widget class="QLabel" name="label">
        <property name="text">
         <string>Width:</string>
        </property>
        <property name="alignment">
         <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
        </property>
       </widget>
      </item>
      <item row="2" column="2">
       <widget class="KisDoubleParseSpinBox" name="doubleRatio">
        <property name="sizePolicy">
         <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="toolTip">
         <string>Aspect ratio</string>
        </property>
        <property name="maximum">
         <double>10000.000000000000000</double>
        </property>
        <property name="singleStep">
         <double>0.100000000000000</double>
        </property>
       </widget>
      </item>
      <item row="0" column="2">
       <widget class="KisIntParseSpinBox" name="intWidth">
        <property name="sizePolicy">
         <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="toolTip">
         <string>Width</string>
        </property>
        <property name="suffix">
         <string> px</string>
        </property>
        <property name="maximum">
         <number>99999</number>
        </property>
       </widget>
      </item>
      <item row="2" column="1">
       <widget class="QLabel" name="label_3">
        <property name="text">
         <string>Ratio:</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="label_2">
        <property name="text">
         <string>Height:</string>
        </property>
        <property name="alignment">
         <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item>
     <layout class="QGridLayout" name="gridLayout_2">
      <item row="0" column="0">
       <widget class="QLabel" name="lblRoundCornersX">
        <property name="text">
         <string>Round X:</string>
        </property>
       </widget>
      </item>
      <item row="0" column="1">
       <widget class="KisIntParseSpinBox" name="intRoundCornersX">
        <property name="sizePolicy">
         <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="toolTip">
-        <string>Height</string>
+        <string>Horizontal radius of rectangle corners</string>
        </property>
        <property name="suffix">
         <string> px</string>
        </property>
        <property name="maximum">
         <number>99999</number>
        </property>
       </widget>
      </item>
      <item row="0" column="2" rowspan="2">
       <widget class="KoAspectButton" name="cornersAspectButton" native="true">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="minimumSize">
         <size>
          <width>24</width>
          <height>24</height>
         </size>
        </property>
       </widget>
      </item>
      <item row="1" column="0">
       <widget class="QLabel" name="lblRoundCornersY">
        <property name="text">
         <string>Round Y:</string>
        </property>
       </widget>
      </item>
      <item row="1" column="1">
       <widget class="KisIntParseSpinBox" name="intRoundCornersY">
        <property name="sizePolicy">
         <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="toolTip">
-        <string>Height</string>
+        <string>Vertical radius of rectangle corners</string>
        </property>
        <property name="suffix">
         <string> px</string>
        </property>
        <property name="maximum">
         <number>99999</number>
        </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>187</height>
       </size>
      </property>
     </spacer>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KisIntParseSpinBox</class>
    <extends>QSpinBox</extends>
    <header>kis_int_parse_spin_box.h</header>
   </customwidget>
   <customwidget>
    <class>KisDoubleParseSpinBox</class>
    <extends>QDoubleSpinBox</extends>
    <header>kis_double_parse_spin_box.h</header>
   </customwidget>
   <customwidget>
    <class>KoAspectButton</class>
    <extends>QWidget</extends>
    <header>KoAspectButton.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/libs/ui/input/kis_input_manager.cpp b/libs/ui/input/kis_input_manager.cpp
index e357c7633c..9362690bb3 100644
--- a/libs/ui/input/kis_input_manager.cpp
+++ b/libs/ui/input/kis_input_manager.cpp
@@ -1,829 +1,836 @@
 /* This file is part of the KDE project
  *
  *  Copyright (C) 2012 Arjen Hiemstra <ahiemstra@heimr.nl>
  *  Copyright (C) 2015 Michael Abrahams <miabraha@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_input_manager.h"
 
 #include <kis_debug.h>
 #include <QQueue>
 #include <klocalizedstring.h>
 #include <QApplication>
 #include <QTouchEvent>
 #include <QElapsedTimer>
 
 #include <KoToolManager.h>
 
 #include "kis_tool_proxy.h"
 
 #include <kis_config.h>
 #include <kis_canvas2.h>
 #include <KisViewManager.h>
 #include <kis_image.h>
 #include <kis_canvas_resource_provider.h>
 #include <kis_favorite_resource_manager.h>
 
 #include "kis_abstract_input_action.h"
 #include "kis_tool_invocation_action.h"
 #include "kis_pan_action.h"
 #include "kis_alternate_invocation_action.h"
 #include "kis_rotate_canvas_action.h"
 #include "kis_zoom_action.h"
 #include "kis_show_palette_action.h"
 #include "kis_change_primary_setting_action.h"
 
 #include "kis_shortcut_matcher.h"
 #include "kis_stroke_shortcut.h"
 #include "kis_single_action_shortcut.h"
 #include "kis_touch_shortcut.h"
 
 #include "kis_input_profile.h"
 #include "kis_input_profile_manager.h"
 #include "kis_shortcut_configuration.h"
 
 #include <input/kis_tablet_debugger.h>
 #include <kis_signal_compressor.h>
 
 #include "kis_extended_modifiers_mapper.h"
 #include "kis_input_manager_p.h"
+#include "kis_algebra_2d.h"
 
 template <typename T>
 uint qHash(QPointer<T> value) {
     return reinterpret_cast<quintptr>(value.data());
 }
 
 KisInputManager::KisInputManager(QObject *parent)
     : QObject(parent), d(new Private(this))
 {
     d->setupActions();
 
     connect(KoToolManager::instance(), SIGNAL(aboutToChangeTool(KoCanvasController*)), SLOT(slotAboutToChangeTool()));
     connect(KoToolManager::instance(), SIGNAL(changedTool(KoCanvasController*,int)), SLOT(slotToolChanged()));
     connect(&d->moveEventCompressor, SIGNAL(timeout()), SLOT(slotCompressedMoveEvent()));
 
 
     QApplication::instance()->
             installEventFilter(new Private::ProximityNotifier(d, this));
 }
 
 KisInputManager::~KisInputManager()
 {
     delete d;
 }
 
 void KisInputManager::addTrackedCanvas(KisCanvas2 *canvas)
 {
     d->canvasSwitcher.addCanvas(canvas);
 }
 
 void KisInputManager::removeTrackedCanvas(KisCanvas2 *canvas)
 {
     d->canvasSwitcher.removeCanvas(canvas);
 }
 
 void KisInputManager::toggleTabletLogger()
 {
     KisTabletDebugger::instance()->toggleDebugging();
 }
 
 void KisInputManager::attachPriorityEventFilter(QObject *filter, int priority)
 {
     Private::PriorityList::iterator begin = d->priorityEventFilter.begin();
     Private::PriorityList::iterator it = begin;
     Private::PriorityList::iterator end = d->priorityEventFilter.end();
 
     it = std::find_if(begin, end,
                       [filter] (const Private::PriorityPair &a) { return a.second == filter; });
 
     if (it != end) return;
 
     it = std::find_if(begin, end,
                       [priority] (const Private::PriorityPair &a) { return a.first > priority; });
 
     d->priorityEventFilter.insert(it, qMakePair(priority, filter));
     d->priorityEventFilterSeqNo++;
 }
 
 void KisInputManager::detachPriorityEventFilter(QObject *filter)
 {
     Private::PriorityList::iterator it = d->priorityEventFilter.begin();
     Private::PriorityList::iterator end = d->priorityEventFilter.end();
 
     it = std::find_if(it, end,
                       [filter] (const Private::PriorityPair &a) { return a.second == filter; });
 
     if (it != end) {
         d->priorityEventFilter.erase(it);
     }
 }
 
 void KisInputManager::setupAsEventFilter(QObject *receiver)
 {
     if (d->eventsReceiver) {
         d->eventsReceiver->removeEventFilter(this);
     }
 
     d->eventsReceiver = receiver;
 
     if (d->eventsReceiver) {
         d->eventsReceiver->installEventFilter(this);
     }
 }
 
 void KisInputManager::stopIgnoringEvents()
 {
     d->allowMouseEvents();
 }
 
 #if defined (__clang__)
 #pragma GCC diagnostic ignored "-Wswitch"
 #endif
 
 bool KisInputManager::eventFilter(QObject* object, QEvent* event)
 {
     if (object != d->eventsReceiver) return false;
 
     if (d->eventEater.eventFilter(object, event)) return false;
 
     if (!d->matcher.hasRunningShortcut()) {
 
         int savedPriorityEventFilterSeqNo = d->priorityEventFilterSeqNo;
 
         for (auto it = d->priorityEventFilter.begin(); it != d->priorityEventFilter.end(); /*noop*/) {
             const QPointer<QObject> &filter = it->second;
 
             if (filter.isNull()) {
                 it = d->priorityEventFilter.erase(it);
 
                 d->priorityEventFilterSeqNo++;
                 savedPriorityEventFilterSeqNo++;
                 continue;
             }
 
             if (filter->eventFilter(object, event)) return true;
 
             /**
              * If the filter removed itself from the filters list or
              * added something there, just exit the loop
              */
             if (d->priorityEventFilterSeqNo != savedPriorityEventFilterSeqNo) {
                 return true;
             }
 
             ++it;
         }
 
         // KoToolProxy needs to pre-process some events to ensure the
         // global shortcuts (not the input manager's ones) are not
         // executed, in particular, this line will accept events when the
         // tool is in text editing, preventing shortcut triggering
         if (d->toolProxy) {
             d->toolProxy->processEvent(event);
         }
     }
 
     // Continue with the actual switch statement...
     return eventFilterImpl(event);
 }
 
 // Qt's events do not have copy-ctors yes, so we should emulate them
 // See https://bugreports.qt.io/browse/QTBUG-72488
 
 template <class Event> void copyEventHack(Event *src, QScopedPointer<QEvent> &dst);
 
 template<> void copyEventHack(QMouseEvent *src, QScopedPointer<QEvent> &dst) {
     QMouseEvent *tmp = new QMouseEvent(src->type(),
                                        src->localPos(), src->windowPos(), src->screenPos(),
                                        src->button(), src->buttons(), src->modifiers(),
                                        src->source());
     tmp->setTimestamp(src->timestamp());
     dst.reset(tmp);
 }
 
 template<> void copyEventHack(QTabletEvent *src, QScopedPointer<QEvent> &dst) {
     QTabletEvent *tmp = new QTabletEvent(src->type(),
                                          src->posF(), src->globalPosF(),
                                          src->device(), src->pointerType(),
                                          src->pressure(),
                                          src->xTilt(), src->yTilt(),
                                          src->tangentialPressure(),
                                          src->rotation(),
                                          src->z(),
                                          src->modifiers(),
                                          src->uniqueId(),
                                          src->button(), src->buttons());
     tmp->setTimestamp(src->timestamp());
     dst.reset(tmp);
 }
 
 template<> void copyEventHack(QTouchEvent *src, QScopedPointer<QEvent> &dst) {
     QTouchEvent *tmp = new QTouchEvent(src->type(),
                                        src->device(),
                                        src->modifiers(),
                                        src->touchPointStates(),
                                        src->touchPoints());
     tmp->setTimestamp(src->timestamp());
     dst.reset(tmp);
 }
 
 
 template <class Event>
 bool KisInputManager::compressMoveEventCommon(Event *event)
 {
     /**
      * We construct a copy of this event object, so we must ensure it
      * has a correct type.
      */
     static_assert(std::is_same<Event, QMouseEvent>::value ||
                   std::is_same<Event, QTabletEvent>::value ||
                   std::is_same<Event, QTouchEvent>::value,
                   "event should be a mouse or a tablet event");
 
     bool retval = false;
 
     /**
      * Compress the events if the tool doesn't need high resolution input
      */
     if ((event->type() == QEvent::MouseMove ||
          event->type() == QEvent::TabletMove ||
          event->type() == QEvent::TouchUpdate) &&
             (!d->matcher.supportsHiResInputEvents() ||
              d->testingCompressBrushEvents)) {
 
         copyEventHack(event, d->compressedMoveEvent);
         d->moveEventCompressor.start();
 
         /**
          * On Linux Qt eats the rest of unneeded events if we
          * ignore the first of the chunk of tablet events. So
          * generally we should never activate this feature. Only
          * for testing purposes!
          */
         if (d->testingAcceptCompressedTabletEvents) {
             event->setAccepted(true);
         }
 
         retval = true;
     } else {
         slotCompressedMoveEvent();
         retval = d->handleCompressedTabletEvent(event);
     }
 
     return retval;
 }
 
 bool shouldResetWheelDelta(QEvent * event)
 {
     return
         event->type() == QEvent::FocusIn ||
         event->type() == QEvent::FocusOut ||
         event->type() == QEvent::MouseButtonPress ||
         event->type() == QEvent::MouseButtonRelease ||
         event->type() == QEvent::MouseButtonDblClick ||
         event->type() == QEvent::TabletPress ||
         event->type() == QEvent::TabletRelease ||
         event->type() == QEvent::Enter ||
         event->type() == QEvent::Leave ||
         event->type() == QEvent::TouchBegin ||
         event->type() == QEvent::TouchEnd ||
         event->type() == QEvent::TouchCancel ||
         event->type() == QEvent::NativeGesture;
 
 }
 
 bool KisInputManager::eventFilterImpl(QEvent * event)
 {
     bool retval = false;
 
     if (shouldResetWheelDelta(event)) {
         d->accumulatedScrollDelta = 0;
     }
 
     switch (event->type()) {
     case QEvent::MouseButtonPress:
     case QEvent::MouseButtonDblClick: {
         d->debugEvent<QMouseEvent, true>(event);
         if (d->touchHasBlockedPressEvents) break;
 
         QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
 
         if (d->tryHidePopupPalette()) {
             retval = true;
         } else {
             //Make sure the input actions know we are active.
             KisAbstractInputAction::setInputManager(this);
             retval = d->matcher.buttonPressed(mouseEvent->button(), mouseEvent);
         }
         //Reset signal compressor to prevent processing events before press late
         d->resetCompressor();
         event->setAccepted(retval);
         break;
     }
     case QEvent::MouseButtonRelease: {
         d->debugEvent<QMouseEvent, true>(event);
         if (d->touchHasBlockedPressEvents) break;
 
         QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
         retval = d->matcher.buttonReleased(mouseEvent->button(), mouseEvent);
         event->setAccepted(retval);
         break;
     }
     case QEvent::ShortcutOverride: {
         d->debugEvent<QKeyEvent, false>(event);
         QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
 
         Qt::Key key = KisExtendedModifiersMapper::workaroundShiftAltMetaHell(keyEvent);
 
         if (!keyEvent->isAutoRepeat()) {
             retval = d->matcher.keyPressed(key);
         } else {
             retval = d->matcher.autoRepeatedKeyPressed(key);
         }
 
         /**
          * Workaround for temporary switching of tools by
          * KoCanvasControllerWidget. We don't need this switch because
          * we handle it ourselves.
          */
         retval |= !d->forwardAllEventsToTool &&
                 (keyEvent->key() == Qt::Key_Space ||
                  keyEvent->key() == Qt::Key_Escape);
 
         break;
     }
     case QEvent::KeyRelease: {
         d->debugEvent<QKeyEvent, false>(event);
         QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
 
         if (!keyEvent->isAutoRepeat()) {
             Qt::Key key = KisExtendedModifiersMapper::workaroundShiftAltMetaHell(keyEvent);
             retval = d->matcher.keyReleased(key);
         }
         break;
     }
     case QEvent::MouseMove: {
         d->debugEvent<QMouseEvent, true>(event);
 
         QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
         retval = compressMoveEventCommon(mouseEvent);
 
         break;
     }
     case QEvent::Wheel: {
         d->debugEvent<QWheelEvent, false>(event);
         QWheelEvent *wheelEvent = static_cast<QWheelEvent*>(event);
 
 #ifdef Q_OS_MACOS
         // Some QT wheel events are actually touch pad pan events. From the QT docs:
         // "Wheel events are generated for both mouse wheels and trackpad scroll gestures."
 
         // We differentiate between touchpad events and real mouse wheels by inspecting the
         // event source.
 
         if (wheelEvent->source() == Qt::MouseEventSource::MouseEventSynthesizedBySystem) {
             KisAbstractInputAction::setInputManager(this);
             retval = d->matcher.wheelEvent(KisSingleActionShortcut::WheelTrackpad, wheelEvent);
             break;
         }
 #endif
 
         d->accumulatedScrollDelta += wheelEvent->delta();
         KisSingleActionShortcut::WheelAction action;
 
         /**
          * Ignore delta 0 events on OSX, since they are triggered by tablet
          * proximity when using Wacom devices.
          */
 #ifdef Q_OS_MACOS
         if(wheelEvent->delta() == 0) {
             retval = true;
             break;
         }
 #endif
 
         if (wheelEvent->orientation() == Qt::Horizontal) {
             if(wheelEvent->delta() < 0) {
                 action = KisSingleActionShortcut::WheelRight;
             }
             else {
                 action = KisSingleActionShortcut::WheelLeft;
             }
         }
         else {
             if(wheelEvent->delta() > 0) {
                 action = KisSingleActionShortcut::WheelUp;
             }
             else {
                 action = KisSingleActionShortcut::WheelDown;
             }
         }
 
-        if (qAbs(d->accumulatedScrollDelta) >= QWheelEvent::DefaultDeltasPerStep) {
+        bool wasScrolled = false;
+
+        while (qAbs(d->accumulatedScrollDelta) >= QWheelEvent::DefaultDeltasPerStep) {
             //Make sure the input actions know we are active.
             KisAbstractInputAction::setInputManager(this);
             retval = d->matcher.wheelEvent(action, wheelEvent);
-            d->accumulatedScrollDelta = 0;
+            d->accumulatedScrollDelta -= KisAlgebra2D::signPZ(d->accumulatedScrollDelta);
+            wasScrolled = true;
         }
-        else {
-            retval = true;
+
+        if (wasScrolled) {
+            d->accumulatedScrollDelta = 0;
         }
+
+        retval = !wasScrolled;
         break;
     }
     case QEvent::Enter:
         d->debugEvent<QEvent, false>(event);
         //Make sure the input actions know we are active.
         KisAbstractInputAction::setInputManager(this);
         if (!d->containsPointer) {
             d->containsPointer = true;
 
             d->allowMouseEvents();
             d->touchHasBlockedPressEvents = false;
         }
 
         d->matcher.enterEvent();
         break;
     case QEvent::Leave:
         d->debugEvent<QEvent, false>(event);
         d->containsPointer = false;
         /**
          * We won't get a TabletProximityLeave event when the tablet
          * is hovering above some other widget, so restore cursor
          * events processing right now.
          */
         d->allowMouseEvents();
         d->touchHasBlockedPressEvents = false;
 
         d->matcher.leaveEvent();
         break;
     case QEvent::FocusIn:
         d->debugEvent<QEvent, false>(event);
         KisAbstractInputAction::setInputManager(this);
 
         //Clear all state so we don't have half-matched shortcuts dangling around.
         d->matcher.reinitialize();
 
     { // Emulate pressing of the key that are already pressed
         KisExtendedModifiersMapper mapper;
 
         Qt::KeyboardModifiers modifiers = mapper.queryStandardModifiers();
         Q_FOREACH (Qt::Key key, mapper.queryExtendedModifiers()) {
             QKeyEvent kevent(QEvent::ShortcutOverride, key, modifiers);
             eventFilterImpl(&kevent);
         }
     }
 
         d->allowMouseEvents();
         break;
 
     case QEvent::FocusOut: {
         d->debugEvent<QEvent, false>(event);
         KisAbstractInputAction::setInputManager(this);
 
         QPointF currentLocalPos =
                 canvas()->canvasWidget()->mapFromGlobal(QCursor::pos());
 
         d->matcher.lostFocusEvent(currentLocalPos);
 
         break;
     }
     case QEvent::TabletPress: {
         d->debugEvent<QTabletEvent, false>(event);
         QTabletEvent *tabletEvent = static_cast<QTabletEvent*>(event);
         if (d->tryHidePopupPalette()) {
             retval = true;
         } else {
             //Make sure the input actions know we are active.
             KisAbstractInputAction::setInputManager(this);
             retval = d->matcher.buttonPressed(tabletEvent->button(), tabletEvent);
             if (!d->containsPointer) {
                 d->containsPointer = true;
                 d->touchHasBlockedPressEvents = false;
             }
         }
         event->setAccepted(true);
         retval = true;
         d->blockMouseEvents();
         //Reset signal compressor to prevent processing events before press late
         d->resetCompressor();
 
 
 #if defined Q_OS_LINUX && !defined QT_HAS_ENTER_LEAVE_PATCH
         // remove this hack when this patch is integrated:
         // https://codereview.qt-project.org/#/c/255384/
         event->setAccepted(false);
         d->eatOneMousePress();
 #elif defined Q_OS_WIN32
         /**
          * Windows is the only platform that synthesizes mouse events for
          * the tablet on OS-level, that is, even when we accept the event
          */
         d->eatOneMousePress();
 #endif
 
         break;
     }
     case QEvent::TabletMove: {
         d->debugEvent<QTabletEvent, false>(event);
 
         QTabletEvent *tabletEvent = static_cast<QTabletEvent*>(event);
         retval = compressMoveEventCommon(tabletEvent);
 
         if (d->tabletLatencyTracker) {
             d->tabletLatencyTracker->push(tabletEvent->timestamp());
         }
 
         /**
          * The flow of tablet events means the tablet is in the
          * proximity area, so activate it even when the
          * TabletEnterProximity event was missed (may happen when
          * changing focus of the window with tablet in the proximity
          * area)
          */
         d->blockMouseEvents();
 
 #if defined Q_OS_LINUX && !defined QT_HAS_ENTER_LEAVE_PATCH
         // remove this hack when this patch is integrated:
         // https://codereview.qt-project.org/#/c/255384/
         event->setAccepted(false);
 #endif
 
         break;
     }
     case QEvent::TabletRelease: {
 #ifdef Q_OS_MAC
         d->allowMouseEvents();
 #endif
         d->debugEvent<QTabletEvent, false>(event);
 
         QTabletEvent *tabletEvent = static_cast<QTabletEvent*>(event);
         retval = d->matcher.buttonReleased(tabletEvent->button(), tabletEvent);
         retval = true;
         event->setAccepted(true);
 
 #if defined Q_OS_LINUX && !defined QT_HAS_ENTER_LEAVE_PATCH
         // remove this hack when this patch is integrated:
         // https://codereview.qt-project.org/#/c/255384/
         event->setAccepted(false);
 #endif
 
         break;
     }
 
     case QEvent::TouchBegin:
     {
         if (startTouch(retval)) {
             QTouchEvent *touchEvent = static_cast<QTouchEvent *> (event);
             KisAbstractInputAction::setInputManager(this);
 
             if (!KisConfig(true).disableTouchOnCanvas()
                 && touchEvent->touchPoints().count() == 1)
             {
                 d->previousPos = touchEvent->touchPoints().at(0).pos();
                 d->buttonPressed = false;
             }
             else {
                 retval = d->matcher.touchBeginEvent(touchEvent);
             }
             event->accept();
         }
 
         // if the event isn't handled, Qt starts to send MouseEvents
         if (!KisConfig(true).disableTouchOnCanvas())
             retval = true;
         break;
     }
 
     case QEvent::TouchUpdate:
     {
         QTouchEvent *touchEvent = static_cast<QTouchEvent*>(event);
 
 #ifdef Q_OS_MAC
         int count = 0;
         Q_FOREACH (const QTouchEvent::TouchPoint &point, touchEvent->touchPoints()) {
             if (point.state() != Qt::TouchPointReleased) {
                 count++;
             }
         }
 
         if (count < 2 && touchEvent->touchPoints().length() > count) {
             d->touchHasBlockedPressEvents = false;
             retval = d->matcher.touchEndEvent(touchEvent);
         } else {
 #endif
             QPointF currentPos = touchEvent->touchPoints().at(0).pos();
             if (d->touchStrokeStarted || (!KisConfig(true).disableTouchOnCanvas()
                 && !d->touchHasBlockedPressEvents
                 && touchEvent->touchPoints().count() == 1
                 && touchEvent->touchPointStates() != Qt::TouchPointStationary
                 && (qAbs(currentPos.x() - d->previousPos.x()) > 1		// stop wobbiliness which Qt sends us
                 ||  qAbs(currentPos.y() - d->previousPos.y()) > 1)))
             {
                 d->previousPos = currentPos;
                 if (!d->buttonPressed)
                 {
                     // we start it here not in TouchBegin, because Qt::TouchPointStationary doesn't work with hpdi devices.
                     retval = d->matcher.buttonPressed(Qt::LeftButton, touchEvent);
                     d->buttonPressed = true;
                     break;
                 }
 
                 // if it is a full-fledged stroke, then ignore (currentPos.x - previousPos.x)
                 d->touchStrokeStarted = true;
                 retval = compressMoveEventCommon(touchEvent);
                 d->blockMouseEvents();
                 d->resetCompressor();
             }
             else if (!d->touchStrokeStarted){
                 KisAbstractInputAction::setInputManager(this);
 
                 retval = d->matcher.touchUpdateEvent(touchEvent);
                 d->touchHasBlockedPressEvents = retval;
             }
 #ifdef Q_OS_MACOS
         }
 #endif
         // if the event isn't handled, Qt starts to send MouseEvents
         if (!KisConfig(true).disableTouchOnCanvas())
             retval = true;
 
         event->accept();
         break;
     }
 
     case QEvent::TouchEnd:
     {
         endTouch();
         QTouchEvent *touchEvent = static_cast<QTouchEvent*>(event);
         retval = d->matcher.touchEndEvent(touchEvent);
         if (d->touchStrokeStarted)
         {
             retval = d->matcher.buttonReleased(Qt::LeftButton, touchEvent);
 
             d->previousPos = {0, 0};
             d->touchStrokeStarted = false; // stroke ended
         }
 
         // if the event isn't handled, Qt starts to send MouseEvents
         if (!KisConfig(true).disableTouchOnCanvas())
             retval = true;
 
         event->accept();
         break;
     }
 
     case QEvent::NativeGesture:
     {
         QNativeGestureEvent *gevent = static_cast<QNativeGestureEvent*>(event);
         switch (gevent->gestureType()) {
             case Qt::BeginNativeGesture:
             {
                 if (startTouch(retval)) {
                     KisAbstractInputAction::setInputManager(this);
                     retval = d->matcher.nativeGestureBeginEvent(gevent);
                     event->accept();
                 }
                 break;
             }
             case Qt::EndNativeGesture:
             {
                 endTouch();
                 retval = d->matcher.nativeGestureEndEvent(gevent);
                 event->accept();
                 break;
             }
             default:
             {
                 KisAbstractInputAction::setInputManager(this);
                 retval = d->matcher.nativeGestureEvent(gevent);
                 event->accept();
                 break;
             }
         }
         break;
     }
 
     default:
         break;
     }
 
     return !retval ? d->processUnhandledEvent(event) : true;
 }
 
 bool KisInputManager::startTouch(bool &retval)
 {
     // Touch rejection: if touch is disabled on canvas, no need to block mouse press events
     if (KisConfig(true).disableTouchOnCanvas()) {
         d->eatOneMousePress();
     }
     if (d->tryHidePopupPalette()) {
         retval = true;
         return false;
     } else {
         return true;
     }
 }
 
 void KisInputManager::endTouch()
 {
     d->touchHasBlockedPressEvents = false;
 }
 
 void KisInputManager::slotCompressedMoveEvent()
 {
     if (d->compressedMoveEvent) {
         // d->touchHasBlockedPressEvents = false;
 
         (void) d->handleCompressedTabletEvent(d->compressedMoveEvent.data());
         d->compressedMoveEvent.reset();
         //dbgInput << "Compressed move event received.";
     } else {
         //dbgInput << "Unexpected empty move event";
     }
 }
 
 KisCanvas2* KisInputManager::canvas() const
 {
     return d->canvas;
 }
 
 QPointer<KisToolProxy> KisInputManager::toolProxy() const
 {
     return d->toolProxy;
 }
 
 void KisInputManager::slotAboutToChangeTool()
 {
     QPointF currentLocalPos;
     if (canvas() && canvas()->canvasWidget()) {
         currentLocalPos = canvas()->canvasWidget()->mapFromGlobal(QCursor::pos());
     }
     d->matcher.lostFocusEvent(currentLocalPos);
 }
 
 void KisInputManager::slotToolChanged()
 {
     if (!d->canvas) return;
     KoToolManager *toolManager = KoToolManager::instance();
     KoToolBase *tool = toolManager->toolById(canvas(), toolManager->activeToolId());
     if (tool) {
         d->setMaskSyntheticEvents(tool->maskSyntheticEvents());
         if (tool->isInTextMode()) {
             d->forwardAllEventsToTool = true;
             d->matcher.suppressAllActions(true);
         } else {
             d->forwardAllEventsToTool = false;
             d->matcher.suppressAllActions(false);
         }
     }
 }
 
 
 void KisInputManager::profileChanged()
 {
     d->matcher.clearShortcuts();
 
     KisInputProfile *profile = KisInputProfileManager::instance()->currentProfile();
     if (profile) {
         const QList<KisShortcutConfiguration*> shortcuts = profile->allShortcuts();
 
         for (KisShortcutConfiguration * const shortcut : shortcuts) {
             dbgUI << "Adding shortcut" << shortcut->keys() << "for action" << shortcut->action()->name();
             switch(shortcut->type()) {
             case KisShortcutConfiguration::KeyCombinationType:
                 d->addKeyShortcut(shortcut->action(), shortcut->mode(), shortcut->keys());
                 break;
             case KisShortcutConfiguration::MouseButtonType:
                 d->addStrokeShortcut(shortcut->action(), shortcut->mode(), shortcut->keys(), shortcut->buttons());
                 break;
             case KisShortcutConfiguration::MouseWheelType:
                 d->addWheelShortcut(shortcut->action(), shortcut->mode(), shortcut->keys(), shortcut->wheel());
                 break;
             case KisShortcutConfiguration::GestureType:
                 if (!d->addNativeGestureShortcut(shortcut->action(), shortcut->mode(), shortcut->gesture())) {
                     d->addTouchShortcut(shortcut->action(), shortcut->mode(), shortcut->gesture());
                 }
                 break;
             default:
                 break;
             }
         }
     }
     else {
         dbgInput << "No Input Profile Found: canvas interaction will be impossible";
     }
 }
diff --git a/libs/ui/input/kis_input_manager_p.cpp b/libs/ui/input/kis_input_manager_p.cpp
index d14f94d011..1efb3af997 100644
--- a/libs/ui/input/kis_input_manager_p.cpp
+++ b/libs/ui/input/kis_input_manager_p.cpp
@@ -1,674 +1,676 @@
 /*
  *  Copyright (C) 2015 Michael Abrahams <miabraha@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_input_manager_p.h"
 
 #include <QMap>
 #include <QApplication>
 #include <QScopedPointer>
 #include <QtGlobal>
 
 #include "kis_input_manager.h"
 #include "kis_config.h"
 #include "kis_abstract_input_action.h"
 #include "kis_tool_invocation_action.h"
 #include "kis_stroke_shortcut.h"
 #include "kis_touch_shortcut.h"
 #include "kis_native_gesture_shortcut.h"
 #include "kis_input_profile_manager.h"
 #include "kis_extended_modifiers_mapper.h"
 
 #include "kis_zoom_and_rotate_action.h"
 
 /**
  * This hungry class EventEater encapsulates event masking logic.
  *
  * Its basic role is to kill synthetic mouseMove events sent by Xorg or Qt after
  * tablet events. Those events are sent in order to allow widgets that haven't
  * implemented tablet specific functionality to seamlessly behave as if one were
  * using a mouse. These synthetic events are *supposed* to be optional, or at
  * least come with a flag saying "This is a fake event!!" but neither of those
  * methods is trustworthy. (This is correct as of Qt 5.4 + Xorg.)
  *
  * Qt 5.4 provides no reliable way to see if a user's tablet is being hovered
  * over the pad, since it converts all tablethover events into mousemove, with
  * no option to turn this off. Moreover, sometimes the MouseButtonPress event
  * from the tapping their tablet happens BEFORE the TabletPress event. This
  * means we have to resort to a somewhat complicated logic. What makes this
  * truly a joke is that we are not guaranteed to observe TabletProximityEnter
  * events when we're using a tablet, either, you may only see an Enter event.
  *
  * Once we see tablet events heading our way, we can say pretty confidently that
  * every mouse event is fake. There are two painful cases to consider - a
  * mousePress event could arrive before the tabletPress event, or it could
  * arrive much later, e.g. after tabletRelease. The first was only seen on Linux
  * with Qt's XInput2 code, the solution was to hold onto mousePress events
  * temporarily and wait for tabletPress later, this is contained in git history
  * but is now removed. The second case is currently handled by the
  * eatOneMousePress function, which waits as long as necessary to detect and
  * block a single mouse press event.
  */
 
 static bool isMouseEventType(QEvent::Type t)
 {
     return (t == QEvent::MouseMove ||
             t == QEvent::MouseButtonPress ||
             t == QEvent::MouseButtonRelease ||
             t == QEvent::MouseButtonDblClick);
 }
 
 KisInputManager::Private::EventEater::EventEater()
 {
     KisConfig cfg(true);
     activateSecondaryButtonsWorkaround = cfg.useRightMiddleTabletButtonWorkaround();
 }
 
 bool KisInputManager::Private::EventEater::eventFilter(QObject* target, QEvent* event )
 {
     Q_UNUSED(target)
 
     auto debugEvent = [&](int i) {
         if (KisTabletDebugger::instance()->debugEnabled()) {
             QString pre = QString("[BLOCKED %1:]").arg(i);
             QMouseEvent *ev = static_cast<QMouseEvent*>(event);
             dbgTablet << KisTabletDebugger::instance()->eventToString(*ev, pre);
         }
     };
 
     auto debugTabletEvent = [&](int i) {
         if (KisTabletDebugger::instance()->debugEnabled()) {
             QString pre = QString("[BLOCKED %1:]").arg(i);
             QTabletEvent *ev = static_cast<QTabletEvent*>(event);
             dbgTablet << KisTabletDebugger::instance()->eventToString(*ev, pre);
         }
     };
 
     if (peckish && event->type() == QEvent::MouseButtonPress
         // Drop one mouse press following tabletPress or touchBegin
         && (static_cast<QMouseEvent*>(event)->button() == Qt::LeftButton)) {
         peckish = false;
         debugEvent(1);
         return true;
     }
 
     if (activateSecondaryButtonsWorkaround) {
         if (event->type() == QEvent::TabletPress ||
                 event->type() == QEvent::TabletRelease) {
 
             QTabletEvent *te = static_cast<QTabletEvent*>(event);
             if (te->button() != Qt::LeftButton) {
                 debugTabletEvent(3);
                 return true;
             }
         } else if (event->type() == QEvent::MouseButtonPress ||
                    event->type() == QEvent::MouseButtonRelease ||
                    event->type() == QEvent::MouseButtonDblClick) {
 
             QMouseEvent *me = static_cast<QMouseEvent*>(event);
             if (me->button() != Qt::LeftButton) {
                 return false;
             }
         }
     }
 
     if (isMouseEventType(event->type()) &&
                (hungry
             // On Mac, we need mouse events when the tablet is in proximity, but not pressed down
             // since tablet move events are not generated until after tablet press.
             #ifndef Q_OS_MAC
                 || (eatSyntheticEvents && static_cast<QMouseEvent*>(event)->source() != Qt::MouseEventNotSynthesized)
             #endif
                 )) {
         // Drop mouse events if enabled or event was synthetic & synthetic events are disabled
         debugEvent(2);
         return true;
     }
     return false; // All clear - let this one through!
 }
 
 
 void KisInputManager::Private::EventEater::activate()
 {
     if (!hungry && (KisTabletDebugger::instance()->debugEnabled())) {
         dbgTablet << "Start blocking mouse events";
     }
     hungry = true;
 }
 
 void KisInputManager::Private::EventEater::deactivate()
 {
     if (hungry && (KisTabletDebugger::instance()->debugEnabled())) {
         dbgTablet << "Stop blocking mouse events";
     }
     hungry = false;
 }
 
 void KisInputManager::Private::EventEater::eatOneMousePress()
 {
     // Enable on other platforms if getting full-pressure splotches
     peckish = true;
 }
 
 bool KisInputManager::Private::ignoringQtCursorEvents()
 {
     return eventEater.hungry;
 }
 
 void KisInputManager::Private::setMaskSyntheticEvents(bool value)
 {
     eventEater.eatSyntheticEvents = value;
 }
 
 KisInputManager::Private::Private(KisInputManager *qq)
     : q(qq)
     , moveEventCompressor(10 /* ms */, KisSignalCompressor::FIRST_ACTIVE)
     , priorityEventFilterSeqNo(0)
     , canvasSwitcher(this, qq)
 {
     KisConfig cfg(true);
 
 
     moveEventCompressor.setDelay(cfg.tabletEventsDelay());
     testingAcceptCompressedTabletEvents = cfg.testingAcceptCompressedTabletEvents();
     testingCompressBrushEvents = cfg.testingCompressBrushEvents();
 
     if (cfg.trackTabletEventLatency()) {
         tabletLatencyTracker = new TabletLatencyTracker();
     }
 
     matcher.setInputActionGroupsMaskCallback(
         [this] () {
             return this->canvas ? this->canvas->inputActionGroupsMask() : AllActionGroup;
         });
 }
 
 static const int InputWidgetsThreshold = 2000;
 static const int OtherWidgetsThreshold = 400;
 
 KisInputManager::Private::CanvasSwitcher::CanvasSwitcher(Private *_d, QObject *p)
     : QObject(p),
       d(_d),
       eatOneMouseStroke(false),
       focusSwitchThreshold(InputWidgetsThreshold)
 {
 }
 
 void KisInputManager::Private::CanvasSwitcher::setupFocusThreshold(QObject* object)
 {
     QWidget *widget = qobject_cast<QWidget*>(object);
     KIS_SAFE_ASSERT_RECOVER_RETURN(widget);
 
     thresholdConnections.clear();
     thresholdConnections.addConnection(&focusSwitchThreshold, SIGNAL(timeout()), widget, SLOT(setFocus()));
 }
 
 void KisInputManager::Private::CanvasSwitcher::addCanvas(KisCanvas2 *canvas)
 {
     if (!canvas) return;
 
     QObject *canvasWidget = canvas->canvasWidget();
 
     if (!canvasResolver.contains(canvasWidget)) {
         canvasResolver.insert(canvasWidget, canvas);
         d->q->setupAsEventFilter(canvasWidget);
         canvasWidget->installEventFilter(this);
 
         setupFocusThreshold(canvasWidget);
         focusSwitchThreshold.setEnabled(false);
 
         d->canvas = canvas;
         d->toolProxy = qobject_cast<KisToolProxy*>(canvas->toolProxy());
     } else {
         KIS_ASSERT_RECOVER_RETURN(d->canvas == canvas);
     }
 }
 
 void KisInputManager::Private::CanvasSwitcher::removeCanvas(KisCanvas2 *canvas)
 {
     QObject *widget = canvas->canvasWidget();
 
     canvasResolver.remove(widget);
 
     if (d->eventsReceiver == widget) {
         d->q->setupAsEventFilter(0);
     }
 
     widget->removeEventFilter(this);
 }
 
 bool isInputWidget(QWidget *w)
 {
     if (!w) return false;
 
 
     QList<QLatin1String> types;
     types << QLatin1String("QAbstractSlider");
     types << QLatin1String("QAbstractSpinBox");
     types << QLatin1String("QLineEdit");
     types << QLatin1String("QTextEdit");
     types << QLatin1String("QPlainTextEdit");
     types << QLatin1String("QComboBox");
     types << QLatin1String("QKeySequenceEdit");
 
     Q_FOREACH (const QLatin1String &type, types) {
         if (w->inherits(type.data())) {
             return true;
         }
     }
 
     return false;
 }
 
 bool KisInputManager::Private::CanvasSwitcher::eventFilter(QObject* object, QEvent* event )
 {
     if (canvasResolver.contains(object)) {
         switch (event->type()) {
         case QEvent::FocusIn: {
             QFocusEvent *fevent = static_cast<QFocusEvent*>(event);
             KisCanvas2 *canvas = canvasResolver.value(object);
 
             // only relevant canvases from the same main window should be
             // registered in the switcher
             KIS_SAFE_ASSERT_RECOVER_BREAK(canvas);
 
             if (canvas != d->canvas) {
                 eatOneMouseStroke = 2 * (fevent->reason() == Qt::MouseFocusReason);
             }
 
             d->canvas = canvas;
             d->toolProxy = qobject_cast<KisToolProxy*>(canvas->toolProxy());
 
             d->q->setupAsEventFilter(object);
 
             object->removeEventFilter(this);
             object->installEventFilter(this);
 
             setupFocusThreshold(object);
             focusSwitchThreshold.setEnabled(false);
 
             const QPoint globalPos = QCursor::pos();
             const QPoint localPos = d->canvas->canvasWidget()->mapFromGlobal(globalPos);
             QWidget *canvasWindow = d->canvas->canvasWidget()->window();
             const QPoint windowsPos = canvasWindow ? canvasWindow->mapFromGlobal(globalPos) : localPos;
 
             QEnterEvent event(localPos, windowsPos, globalPos);
             d->q->eventFilter(object, &event);
             break;
         }
         case QEvent::FocusOut: {
             focusSwitchThreshold.setEnabled(true);
             break;
         }
         case QEvent::Enter: {
             break;
         }
         case QEvent::Leave: {
             focusSwitchThreshold.stop();
             break;
         }
         case QEvent::Wheel: {
             QWidget *widget = static_cast<QWidget*>(object);
             widget->setFocus();
             break;
         }
         case QEvent::MouseButtonPress:
         case QEvent::MouseButtonRelease:
         case QEvent::TabletPress:
         case QEvent::TabletRelease:
             focusSwitchThreshold.forceDone();
 
             if (eatOneMouseStroke) {
                 eatOneMouseStroke--;
                 return true;
             }
             break;
         case QEvent::MouseButtonDblClick:
             focusSwitchThreshold.forceDone();
             if (eatOneMouseStroke) {
                 return true;
             }
             break;
         case QEvent::MouseMove:
         case QEvent::TabletMove: {
             QWidget *widget = static_cast<QWidget*>(object);
 
             if (!widget->hasFocus()) {
                 const int delay =
                     isInputWidget(QApplication::focusWidget()) ?
                     InputWidgetsThreshold : OtherWidgetsThreshold;
 
                 focusSwitchThreshold.setDelayThreshold(delay);
                 focusSwitchThreshold.start();
             }
         }
             break;
         default:
             break;
         }
     }
     return QObject::eventFilter(object, event);
 }
 
 KisInputManager::Private::ProximityNotifier::ProximityNotifier(KisInputManager::Private *_d, QObject *p)
     : QObject(p), d(_d)
 {}
 
 bool KisInputManager::Private::ProximityNotifier::eventFilter(QObject* object, QEvent* event )
 {
     /**
      * All Qt builds in range 5.7.0...5.11.X on X11 had a problem that made all
      * the tablet events be accepted by default. It meant that no mouse
      * events were synthesized, and, therefore, no Enter/Leave were generated.
      *
      * The fix for this bug has been added only in Qt 5.12.0:
      * https://codereview.qt-project.org/#/c/239918/
      *
      * To avoid this problem we should explicitly ignore all the tablet events.
      */
 #if defined Q_OS_LINUX && \
     QT_VERSION >= QT_VERSION_CHECK(5, 7, 0) && \
     QT_VERSION < QT_VERSION_CHECK(5, 12, 0)
 
     if (event->type() == QEvent::TabletMove ||
         event->type() == QEvent::TabletPress ||
         event->type() == QEvent::TabletRelease) {
 
         event->ignore();
     }
 #endif
 
     switch (event->type()) {
     case QEvent::TabletEnterProximity:
         d->debugEvent<QEvent, false>(event);
         // Tablet proximity events are unreliable AND fake mouse events do not
         // necessarily come after tablet events, so this is insufficient.
         // d->eventEater.eatOneMousePress();
 
         // Qt sends fake mouse events instead of hover events, so not very useful.
         // Don't block mouse events on tablet since tablet move events are not generated until
         // after tablet press.
 #ifndef Q_OS_MACOS
         d->blockMouseEvents();
 #endif
         break;
     case QEvent::TabletLeaveProximity:
         d->debugEvent<QEvent, false>(event);
         d->allowMouseEvents();
         break;
     default:
         break;
     }
     return QObject::eventFilter(object, event);
 }
 
 void KisInputManager::Private::addStrokeShortcut(KisAbstractInputAction* action, int index,
                                                  const QList<Qt::Key> &modifiers,
                                                  Qt::MouseButtons buttons)
 {
     KisStrokeShortcut *strokeShortcut =
         new KisStrokeShortcut(action, index);
 
     QList<Qt::MouseButton> buttonList;
     if(buttons & Qt::LeftButton) {
         buttonList << Qt::LeftButton;
     }
     if(buttons & Qt::RightButton) {
         buttonList << Qt::RightButton;
     }
     if(buttons & Qt::MidButton) {
         buttonList << Qt::MidButton;
     }
     if(buttons & Qt::XButton1) {
         buttonList << Qt::XButton1;
     }
     if(buttons & Qt::XButton2) {
         buttonList << Qt::XButton2;
     }
 
     if (buttonList.size() > 0) {
         strokeShortcut->setButtons(QSet<Qt::Key>::fromList(modifiers), QSet<Qt::MouseButton>::fromList(buttonList));
         matcher.addShortcut(strokeShortcut);
     }
     else {
         delete strokeShortcut;
     }
 }
 
 void KisInputManager::Private::addKeyShortcut(KisAbstractInputAction* action, int index,
                                               const QList<Qt::Key> &keys)
 {
     if (keys.size() == 0) return;
 
     KisSingleActionShortcut *keyShortcut =
         new KisSingleActionShortcut(action, index);
 
     //Note: Ordering is important here, Shift + V is different from V + Shift,
     //which is the reason we use the last key here since most users will enter
     //shortcuts as "Shift + V". Ideally this should not happen, but this is
     //the way the shortcut matcher is currently implemented.
     QList<Qt::Key> allKeys = keys;
     Qt::Key key = allKeys.takeLast();
     QSet<Qt::Key> modifiers = QSet<Qt::Key>::fromList(allKeys);
     keyShortcut->setKey(modifiers, key);
     matcher.addShortcut(keyShortcut);
 }
 
 void KisInputManager::Private::addWheelShortcut(KisAbstractInputAction* action, int index,
                                                 const QList<Qt::Key> &modifiers,
                                                 KisShortcutConfiguration::MouseWheelMovement wheelAction)
 {
     QScopedPointer<KisSingleActionShortcut> keyShortcut(
         new KisSingleActionShortcut(action, index));
 
     KisSingleActionShortcut::WheelAction a;
     switch(wheelAction) {
     case KisShortcutConfiguration::WheelUp:
         a = KisSingleActionShortcut::WheelUp;
         break;
     case KisShortcutConfiguration::WheelDown:
         a = KisSingleActionShortcut::WheelDown;
         break;
     case KisShortcutConfiguration::WheelLeft:
         a = KisSingleActionShortcut::WheelLeft;
         break;
     case KisShortcutConfiguration::WheelRight:
         a = KisSingleActionShortcut::WheelRight;
         break;
     case KisShortcutConfiguration::WheelTrackpad:
         a = KisSingleActionShortcut::WheelTrackpad;
         break;
     default:
         return;
     }
 
     keyShortcut->setWheel(QSet<Qt::Key>::fromList(modifiers), a);
     matcher.addShortcut(keyShortcut.take());
 }
 
 void KisInputManager::Private::addTouchShortcut(KisAbstractInputAction* action, int index, KisShortcutConfiguration::GestureAction gesture)
 {
     KisTouchShortcut *shortcut = new KisTouchShortcut(action, index, gesture);
     dbgKrita << "TouchAction:" << action->name();
     switch(gesture) {
     case KisShortcutConfiguration::RotateGesture:
     case KisShortcutConfiguration::PinchGesture:
+#ifndef Q_OS_MACOS
     case KisShortcutConfiguration::ZoomAndRotateGesture:
+#endif
         shortcut->setMinimumTouchPoints(2);
         shortcut->setMaximumTouchPoints(2);
         break;
     case KisShortcutConfiguration::PanGesture:
         shortcut->setMinimumTouchPoints(3);
         shortcut->setMaximumTouchPoints(10);
         break;
     default:
         break;
     }
     matcher.addShortcut(shortcut);
 }
 
 bool KisInputManager::Private::addNativeGestureShortcut(KisAbstractInputAction* action, int index, KisShortcutConfiguration::GestureAction gesture)
 {
     // Qt5 only implements QNativeGestureEvent for macOS
     Qt::NativeGestureType type;
     switch (gesture) {
 #ifdef Q_OS_MACOS
         case KisShortcutConfiguration::PinchGesture:
             type = Qt::ZoomNativeGesture;
             break;
         case KisShortcutConfiguration::PanGesture:
             type = Qt::PanNativeGesture;
             break;
         case KisShortcutConfiguration::RotateGesture:
             type = Qt::RotateNativeGesture;
             break;
         case KisShortcutConfiguration::SmartZoomGesture:
             type = Qt::SmartZoomNativeGesture;
             break;
 #endif
         default:
             return false;
     }
 
     KisNativeGestureShortcut *shortcut = new KisNativeGestureShortcut(action, index, type);
     matcher.addShortcut(shortcut);
     return true;
 }
 
 void KisInputManager::Private::setupActions()
 {
     QList<KisAbstractInputAction*> actions = KisInputProfileManager::instance()->actions();
     Q_FOREACH (KisAbstractInputAction *action, actions) {
         KisToolInvocationAction *toolAction =
             dynamic_cast<KisToolInvocationAction*>(action);
 
         if(toolAction) {
             defaultInputAction = toolAction;
         }
     }
 
     connect(KisInputProfileManager::instance(), SIGNAL(currentProfileChanged()), q, SLOT(profileChanged()));
     if(KisInputProfileManager::instance()->currentProfile()) {
         q->profileChanged();
     }
 }
 
 bool KisInputManager::Private::processUnhandledEvent(QEvent *event)
 {
     bool retval = false;
 
     if (forwardAllEventsToTool ||
         event->type() == QEvent::KeyPress ||
         event->type() == QEvent::KeyRelease) {
 
         defaultInputAction->processUnhandledEvent(event);
         retval = true;
     }
 
     return retval && !forwardAllEventsToTool;
 }
 
 bool KisInputManager::Private::tryHidePopupPalette()
 {
     if (canvas->isPopupPaletteVisible()) {
         canvas->slotShowPopupPalette();
         return true;
     }
     return false;
 }
 
 #ifdef HAVE_X11
 inline QPointF dividePoints(const QPointF &pt1, const QPointF &pt2) {
     return QPointF(pt1.x() / pt2.x(), pt1.y() / pt2.y());
 }
 
 inline QPointF multiplyPoints(const QPointF &pt1, const QPointF &pt2) {
     return QPointF(pt1.x() * pt2.x(), pt1.y() * pt2.y());
 }
 #endif
 
 void KisInputManager::Private::blockMouseEvents()
 {
     eventEater.activate();
 }
 
 void KisInputManager::Private::allowMouseEvents()
 {
     eventEater.deactivate();
 }
 
 void KisInputManager::Private::eatOneMousePress()
 {
     eventEater.eatOneMousePress();
 }
 
 void KisInputManager::Private::resetCompressor() {
     compressedMoveEvent.reset();
     moveEventCompressor.stop();
 }
 
 bool KisInputManager::Private::handleCompressedTabletEvent(QEvent *event)
 {
     bool retval = false;
 
     /**
      * When Krita (as an application) has no input focus, we cannot
      * handle key events. But at the same time, when the user hovers
      * Krita canvas, we should still show him the correct cursor.
      *
      * So here we just add a simple workaround to resync shortcut
      * matcher's state at least against the basic modifiers, like
      * Shift, Control and Alt.
      */
     QWidget *recievingWidget = dynamic_cast<QWidget*>(eventsReceiver);
     if (recievingWidget && !recievingWidget->hasFocus()) {
         QVector<Qt::Key> guessedKeys;
 
         KisExtendedModifiersMapper mapper;
         Qt::KeyboardModifiers modifiers = mapper.queryStandardModifiers();
         Q_FOREACH (Qt::Key key, mapper.queryExtendedModifiers()) {
             QKeyEvent kevent(QEvent::ShortcutOverride, key, modifiers);
             guessedKeys << KisExtendedModifiersMapper::workaroundShiftAltMetaHell(&kevent);
         }
 
         matcher.recoveryModifiersWithoutFocus(guessedKeys);
     }
 
     if (!matcher.pointerMoved(event) && toolProxy) {
         toolProxy->forwardHoverEvent(event);
     }
     retval = true;
     event->setAccepted(true);
 
     return retval;
 }
 
 qint64 KisInputManager::Private::TabletLatencyTracker::currentTimestamp() const
 {
     // on OS X, we need to compute the timestamp that compares correctly against the native event timestamp,
     // which seems to be the msecs since system startup. On Linux with WinTab, we produce the timestamp that
     // we compare against ourselves in QWindowSystemInterface.
 
     QElapsedTimer elapsed;
     elapsed.start();
     return elapsed.msecsSinceReference();
 }
 
 void KisInputManager::Private::TabletLatencyTracker::print(const QString &message)
 {
     dbgTablet << qUtf8Printable(message);
 }
diff --git a/libs/ui/input/kis_shortcut_matcher.cpp b/libs/ui/input/kis_shortcut_matcher.cpp
index 8510899e2d..c2a51aa8df 100644
--- a/libs/ui/input/kis_shortcut_matcher.cpp
+++ b/libs/ui/input/kis_shortcut_matcher.cpp
@@ -1,829 +1,831 @@
 /*
  *  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_shortcut_matcher.h"
 
 #include <QEvent>
 #include <QMouseEvent>
 #include <QTabletEvent>
 
 #include "kis_assert.h"
 #include "kis_abstract_input_action.h"
 #include "kis_stroke_shortcut.h"
 #include "kis_touch_shortcut.h"
 #include "kis_native_gesture_shortcut.h"
 #include "kis_config.h"
 
 //#define DEBUG_MATCHER
 
 #ifdef DEBUG_MATCHER
 #include <kis_debug.h>
 #define DEBUG_ACTION(text) qDebug() << __FUNCTION__ << "-" << text;
 #define DEBUG_SHORTCUT(text, shortcut) qDebug() << __FUNCTION__ << "-" << text << "act:" << shortcut->action()->name();
 #define DEBUG_KEY(text) qDebug() << __FUNCTION__ << "-" << text << "keys:" << m_d->keys;
 #define DEBUG_BUTTON_ACTION(text, button) qDebug() << __FUNCTION__ << "-" << text << "button:" << button << "btns:" << m_d->buttons << "keys:" << m_d->keys;
 #define DEBUG_EVENT_ACTION(text, event) if (event) {qDebug() << __FUNCTION__ << "-" << text << "type:" << event->type();}
 #else
 #define DEBUG_ACTION(text)
 #define DEBUG_KEY(text)
 #define DEBUG_SHORTCUT(text, shortcut)
 #define DEBUG_BUTTON_ACTION(text, button)
 #define DEBUG_EVENT_ACTION(text, event)
 #endif
 
 
 class Q_DECL_HIDDEN KisShortcutMatcher::Private
 {
 public:
     Private()
         : runningShortcut(0)
         , readyShortcut(0)
         , touchShortcut(0)
         , nativeGestureShortcut(0)
         , actionGroupMask([] () { return AllActionGroup; })
         , suppressAllActions(false)
         , cursorEntered(false)
         , usingTouch(false)
         , usingNativeGesture(false)
     {}
 
     ~Private()
     {
         qDeleteAll(singleActionShortcuts);
         qDeleteAll(strokeShortcuts);
         qDeleteAll(touchShortcuts);
     }
 
     QList<KisSingleActionShortcut*> singleActionShortcuts;
     QList<KisStrokeShortcut*> strokeShortcuts;
     QList<KisTouchShortcut*> touchShortcuts;
     QList<KisNativeGestureShortcut*> nativeGestureShortcuts;
 
     QSet<Qt::Key> keys; // Model of currently pressed keys
     QSet<Qt::MouseButton> buttons; // Model of currently pressed buttons
 
     KisStrokeShortcut *runningShortcut;
     KisStrokeShortcut *readyShortcut;
     QList<KisStrokeShortcut*> candidateShortcuts;
 
     KisTouchShortcut *touchShortcut;
     KisNativeGestureShortcut *nativeGestureShortcut;
 
     std::function<KisInputActionGroupsMask()> actionGroupMask;
     bool suppressAllActions;
     bool cursorEntered;
     bool usingTouch;
     bool usingNativeGesture;
 
     int recursiveCounter = 0;
     int brokenByRecursion = 0;
 
 
     struct RecursionNotifier {
         RecursionNotifier(KisShortcutMatcher *_q)
             : q(_q)
         {
             q->m_d->recursiveCounter++;
             q->m_d->brokenByRecursion++;
         }
 
         ~RecursionNotifier() {
             q->m_d->recursiveCounter--;
         }
 
         bool isInRecursion() const {
             return q->m_d->recursiveCounter > 1;
         }
 
         KisShortcutMatcher *q;
     };
 
     struct RecursionGuard {
         RecursionGuard(KisShortcutMatcher *_q)
             : q(_q)
         {
             q->m_d->brokenByRecursion = 0;
         }
 
         ~RecursionGuard() {
         }
 
         bool brokenByRecursion() const {
             return q->m_d->brokenByRecursion > 0;
         }
 
         KisShortcutMatcher *q;
     };
 
     inline bool actionsSuppressed() const {
         return (suppressAllActions || !cursorEntered)
                 && KisConfig(true).disableTouchOnCanvas();
     }
 
     inline bool actionsSuppressedIgnoreFocus() const {
         return suppressAllActions;
     }
 
     // only for touch events with touchPoints count >= 2
     inline bool isUsingTouch() const {
         return usingTouch || usingNativeGesture;
     }
 };
 
 KisShortcutMatcher::KisShortcutMatcher()
     : m_d(new Private)
 {}
 
 KisShortcutMatcher::~KisShortcutMatcher()
 {
     delete m_d;
 }
 
 bool KisShortcutMatcher::hasRunningShortcut() const
 {
     return m_d->runningShortcut;
 }
 
 void KisShortcutMatcher::addShortcut(KisSingleActionShortcut *shortcut)
 {
     m_d->singleActionShortcuts.append(shortcut);
 }
 
 void KisShortcutMatcher::addShortcut(KisStrokeShortcut *shortcut)
 {
     m_d->strokeShortcuts.append(shortcut);
 }
 
 void KisShortcutMatcher::addShortcut( KisTouchShortcut* shortcut )
 {
     m_d->touchShortcuts.append(shortcut);
 }
 
 void KisShortcutMatcher::addShortcut(KisNativeGestureShortcut *shortcut) {
     m_d->nativeGestureShortcuts.append(shortcut);
 }
 
 bool KisShortcutMatcher::supportsHiResInputEvents()
 {
     return
         m_d->runningShortcut &&
         m_d->runningShortcut->action() &&
         m_d->runningShortcut->action()->supportsHiResInputEvents();
 }
 
 bool KisShortcutMatcher::keyPressed(Qt::Key key)
 {
     Private::RecursionNotifier notifier(this);
 
     bool retval = false;
 
     if (m_d->keys.contains(key)) { DEBUG_ACTION("Peculiar, records show key was already pressed"); }
 
     if (!m_d->runningShortcut && !notifier.isInRecursion()) {
         retval =  tryRunSingleActionShortcutImpl(key, (QEvent*)0, m_d->keys);
     }
 
     m_d->keys.insert(key);
     DEBUG_KEY("Pressed");
 
     if (notifier.isInRecursion()) {
         forceDeactivateAllActions();
     } else if (!m_d->runningShortcut) {
         prepareReadyShortcuts();
         tryActivateReadyShortcut();
     }
 
     return retval;
 }
 
 bool KisShortcutMatcher::autoRepeatedKeyPressed(Qt::Key key)
 {
     Private::RecursionNotifier notifier(this);
 
 
     bool retval = false;
 
     if (!m_d->keys.contains(key)) { DEBUG_ACTION("Peculiar, autorepeated key but can't remember it was pressed"); }
 
     if (notifier.isInRecursion()) {
         forceDeactivateAllActions();
     } else if (!m_d->runningShortcut) {
         // Autorepeated key should not be included in the shortcut
         QSet<Qt::Key> filteredKeys = m_d->keys;
         filteredKeys.remove(key);
         retval = tryRunSingleActionShortcutImpl(key, (QEvent*)0, filteredKeys);
     }
 
     return retval;
 }
 
 bool KisShortcutMatcher::keyReleased(Qt::Key key)
 {
     Private::RecursionNotifier notifier(this);
 
     if (!m_d->keys.contains(key)) reset("Peculiar, key released but can't remember it was pressed");
     else m_d->keys.remove(key);
 
     if (notifier.isInRecursion()) {
         forceDeactivateAllActions();
     } else if (!m_d->runningShortcut) {
         prepareReadyShortcuts();
         tryActivateReadyShortcut();
     }
 
     return false;
 }
 
 bool KisShortcutMatcher::buttonPressed(Qt::MouseButton button, QEvent *event)
 {
     Private::RecursionNotifier notifier(this);
     DEBUG_BUTTON_ACTION("entered", button);
 
     bool retval = false;
 
     if (m_d->isUsingTouch()) {
         return retval;
     }
 
     if (m_d->buttons.contains(button)) { DEBUG_ACTION("Peculiar, button was already pressed."); }
 
     if (!m_d->runningShortcut && !notifier.isInRecursion()) {
         prepareReadyShortcuts();
         retval = tryRunReadyShortcut(button, event);
     }
 
     m_d->buttons.insert(button);
 
     if (notifier.isInRecursion()) {
         forceDeactivateAllActions();
     } else if (!m_d->runningShortcut) {
         prepareReadyShortcuts();
         tryActivateReadyShortcut();
     }
 
     return retval;
 }
 
 bool KisShortcutMatcher::buttonReleased(Qt::MouseButton button, QEvent *event)
 {
     Private::RecursionNotifier notifier(this);
     DEBUG_BUTTON_ACTION("entered", button);
 
     bool retval = false;
 
     if (m_d->isUsingTouch()) {
         return retval;
     }
 
     if (m_d->runningShortcut) {
         KIS_SAFE_ASSERT_RECOVER_NOOP(!notifier.isInRecursion());
 
         retval = tryEndRunningShortcut(button, event);
         DEBUG_BUTTON_ACTION("ended", button);
     }
 
     if (!m_d->buttons.contains(button)) reset("Peculiar, button released but we can't remember it was pressed");
     else m_d->buttons.remove(button);
 
     if (notifier.isInRecursion()) {
         forceDeactivateAllActions();
     } else if (!m_d->runningShortcut) {
         prepareReadyShortcuts();
         tryActivateReadyShortcut();
     }
 
     return retval;
 }
 
 bool KisShortcutMatcher::wheelEvent(KisSingleActionShortcut::WheelAction wheelAction, QWheelEvent *event)
 {
     Private::RecursionNotifier notifier(this);
 
 
     if (m_d->runningShortcut || m_d->isUsingTouch() || notifier.isInRecursion()) {
         DEBUG_ACTION("Wheel event canceled.");
         return false;
     }
 
     return tryRunWheelShortcut(wheelAction, event);
 }
 
 bool KisShortcutMatcher::pointerMoved(QEvent *event)
 {
     Private::RecursionNotifier notifier(this);
 
 
     if (m_d->isUsingTouch() || !m_d->runningShortcut || notifier.isInRecursion()) {
         return false;
     }
 
     m_d->runningShortcut->action()->inputEvent(event);
     return true;
 }
 
 void KisShortcutMatcher::enterEvent()
 {
     Private::RecursionNotifier notifier(this);
 
     m_d->cursorEntered = true;
 
     if (notifier.isInRecursion()) {
         forceDeactivateAllActions();
     } else if (!m_d->runningShortcut) {
         prepareReadyShortcuts();
         tryActivateReadyShortcut();
     }
 }
 
 void KisShortcutMatcher::leaveEvent()
 {
     Private::RecursionNotifier notifier(this);
 
     m_d->cursorEntered = false;
 
     if (notifier.isInRecursion()) {
         forceDeactivateAllActions();
     } else if (!m_d->runningShortcut) {
         prepareReadyShortcuts();
         tryActivateReadyShortcut();
     }
 }
 
 bool KisShortcutMatcher::touchBeginEvent( QTouchEvent* event )
 {
     Q_UNUSED(event)
 
     Private::RecursionNotifier notifier(this);
 
     return !notifier.isInRecursion();
 }
 
 bool KisShortcutMatcher::touchUpdateEvent( QTouchEvent* event )
 {
     bool retval = false;
 
     if (m_d->touchShortcut && !m_d->touchShortcut->match( event ) ) {
         retval = tryEndTouchShortcut( event );
     }
 
     if (!m_d->touchShortcut ) {
         retval = tryRunTouchShortcut( event );
     }
     else {
         m_d->touchShortcut->action()->inputEvent( event );
         retval = true;
     }
 
     return retval;
 }
 
 bool KisShortcutMatcher::touchEndEvent( QTouchEvent* event )
 {
     m_d->usingTouch = false; // we need to say we are done because qt will not send further event
 
     // we should try and end the shortcut too (it might be that there is none? (sketch))
     if (tryEndTouchShortcut(event)) {
         return true;
     }
 
     return false;
 }
 
 bool KisShortcutMatcher::nativeGestureBeginEvent(QNativeGestureEvent *event)
 {
     Q_UNUSED(event)
 
     Private::RecursionNotifier notifier(this);
 
     return !notifier.isInRecursion();
 }
 
 bool KisShortcutMatcher::nativeGestureEvent(QNativeGestureEvent *event)
 {
     bool retval = false;
     if ( !m_d->nativeGestureShortcut ) {
         retval = tryRunNativeGestureShortcut( event );
     }
     else {
         m_d->nativeGestureShortcut->action()->inputEvent( event );
         retval = true;
     }
 
     return retval;
 }
 
 bool KisShortcutMatcher::nativeGestureEndEvent(QNativeGestureEvent *event)
 {
     if ( m_d->nativeGestureShortcut && !m_d->nativeGestureShortcut->match( event ) ) {
         tryEndNativeGestureShortcut( event );
     }
     m_d->usingNativeGesture = false;
     return true;
 }
 
 Qt::MouseButtons listToFlags(const QList<Qt::MouseButton> &list) {
     Qt::MouseButtons flags;
     Q_FOREACH (Qt::MouseButton b, list) {
         flags |= b;
     }
     return flags;
 }
 
 void KisShortcutMatcher::reinitialize()
 {
     Private::RecursionNotifier notifier(this);
 
 
     reset("reinitialize");
 
     if (notifier.isInRecursion()) {
         forceDeactivateAllActions();
     } else if (!m_d->runningShortcut) {
         prepareReadyShortcuts();
         tryActivateReadyShortcut();
     }
 }
 
 void KisShortcutMatcher::recoveryModifiersWithoutFocus(const QVector<Qt::Key> &keys)
 {
     Private::RecursionNotifier notifier(this);
 
 
     Q_FOREACH (Qt::Key key, m_d->keys) {
         if (!keys.contains(key)) {
             keyReleased(key);
         }
     }
 
     Q_FOREACH (Qt::Key key, keys) {
         if (!m_d->keys.contains(key)) {
             keyPressed(key);
         }
     }
 
     if (notifier.isInRecursion()) {
         forceDeactivateAllActions();
     } else if (!m_d->runningShortcut) {
         prepareReadyShortcuts();
         tryActivateReadyShortcut();
     }
 
     DEBUG_ACTION("recoverySyncModifiers");
 }
 
 void KisShortcutMatcher::lostFocusEvent(const QPointF &localPos)
 {
+    Private::RecursionNotifier notifier(this);
+
     if (m_d->runningShortcut) {
         forceEndRunningShortcut(localPos);
     }
 }
 
 void KisShortcutMatcher::reset()
 {
     m_d->keys.clear();
     m_d->buttons.clear();
     DEBUG_ACTION("reset!");
 }
 
 
 void KisShortcutMatcher::reset(QString msg)
 {
     m_d->keys.clear();
     m_d->buttons.clear();
     Q_UNUSED(msg);
     DEBUG_ACTION(msg);
 }
 
 void KisShortcutMatcher::suppressAllActions(bool value)
 {
     m_d->suppressAllActions = value;
 }
 
 void KisShortcutMatcher::clearShortcuts()
 {
     reset("Clearing shortcuts");
     qDeleteAll(m_d->singleActionShortcuts);
     m_d->singleActionShortcuts.clear();
     qDeleteAll(m_d->strokeShortcuts);
     qDeleteAll(m_d->touchShortcuts);
     m_d->strokeShortcuts.clear();
     m_d->candidateShortcuts.clear();
     m_d->touchShortcuts.clear();
     m_d->runningShortcut = 0;
     m_d->readyShortcut = 0;
 }
 
 void KisShortcutMatcher::setInputActionGroupsMaskCallback(std::function<KisInputActionGroupsMask ()> func)
 {
     m_d->actionGroupMask = func;
 }
 
 bool KisShortcutMatcher::tryRunWheelShortcut(KisSingleActionShortcut::WheelAction wheelAction, QWheelEvent *event)
 {
     return tryRunSingleActionShortcutImpl(wheelAction, event, m_d->keys);
 }
 
 // Note: sometimes event can be zero!!
 template<typename T, typename U>
 bool KisShortcutMatcher::tryRunSingleActionShortcutImpl(T param, U *event, const QSet<Qt::Key> &keysState)
 {
     if (m_d->actionsSuppressedIgnoreFocus()) {
         DEBUG_EVENT_ACTION("Event suppressed", event)
         return false;
     }
 
     KisSingleActionShortcut *goodCandidate = 0;
 
     Q_FOREACH (KisSingleActionShortcut *s, m_d->singleActionShortcuts) {
         if(s->isAvailable(m_d->actionGroupMask()) &&
            s->match(keysState, param) &&
            (!goodCandidate || s->priority() > goodCandidate->priority())) {
 
             goodCandidate = s;
         }
     }
 
     if (goodCandidate) {
         DEBUG_EVENT_ACTION("Beginning action for event", event);
         goodCandidate->action()->begin(goodCandidate->shortcutIndex(), event);
         goodCandidate->action()->end(0);
     } else {
         DEBUG_EVENT_ACTION("Could not match a candidate for event", event)
     }
 
     return goodCandidate;
 }
 
 void KisShortcutMatcher::prepareReadyShortcuts()
 {
     m_d->candidateShortcuts.clear();
     if (m_d->actionsSuppressed()) return;
 
     Q_FOREACH (KisStrokeShortcut *s, m_d->strokeShortcuts) {
         if (s->matchReady(m_d->keys, m_d->buttons)) {
             m_d->candidateShortcuts.append(s);
         }
     }
 }
 
 bool KisShortcutMatcher::tryRunReadyShortcut( Qt::MouseButton button, QEvent* event )
 {
     KisStrokeShortcut *goodCandidate = 0;
 
     Q_FOREACH (KisStrokeShortcut *s, m_d->candidateShortcuts) {
         if (s->isAvailable(m_d->actionGroupMask()) &&
             s->matchBegin(button) &&
             (!goodCandidate || s->priority() > goodCandidate->priority())) {
 
             goodCandidate = s;
         }
     }
 
     if (goodCandidate) {
         if (m_d->readyShortcut) {
             if (m_d->readyShortcut != goodCandidate) {
                 m_d->readyShortcut->action()->deactivate(m_d->readyShortcut->shortcutIndex());
                 goodCandidate->action()->activate(goodCandidate->shortcutIndex());
             }
             m_d->readyShortcut = 0;
         } else {
             DEBUG_EVENT_ACTION("Matched *new* shortcut for event", event);
             goodCandidate->action()->activate(goodCandidate->shortcutIndex());
         }
 
         DEBUG_SHORTCUT("Starting new action", goodCandidate);
 
         {
             m_d->runningShortcut = goodCandidate;
             Private::RecursionGuard guard(this);
             goodCandidate->action()->begin(goodCandidate->shortcutIndex(), event);
 
             // the tool migh have opened some dialog, which could break our event loop
             if (guard.brokenByRecursion()) {
                 goodCandidate->action()->end(event);
                 m_d->runningShortcut = 0;
 
                 forceDeactivateAllActions();
             }
         }
     }
 
     return m_d->runningShortcut;
 }
 
 void KisShortcutMatcher::tryActivateReadyShortcut()
 {
     KisStrokeShortcut *goodCandidate = 0;
 
     Q_FOREACH (KisStrokeShortcut *s, m_d->candidateShortcuts) {
         if (!goodCandidate || s->priority() > goodCandidate->priority()) {
             goodCandidate = s;
         }
     }
 
     if (goodCandidate) {
         if (m_d->readyShortcut && m_d->readyShortcut != goodCandidate) {
             DEBUG_SHORTCUT("Deactivated previous shortcut action", m_d->readyShortcut);
             m_d->readyShortcut->action()->deactivate(m_d->readyShortcut->shortcutIndex());
             m_d->readyShortcut = 0;
         }
 
         if (!m_d->readyShortcut) {
             DEBUG_SHORTCUT("Preparing new ready action", goodCandidate);
             goodCandidate->action()->activate(goodCandidate->shortcutIndex());
             m_d->readyShortcut = goodCandidate;
         }
     } else if (m_d->readyShortcut) {
         DEBUG_SHORTCUT("Deactivating action", m_d->readyShortcut);
         m_d->readyShortcut->action()->deactivate(m_d->readyShortcut->shortcutIndex());
         m_d->readyShortcut = 0;
     }
 }
 
 bool KisShortcutMatcher::tryEndRunningShortcut( Qt::MouseButton button, QEvent* event )
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(m_d->runningShortcut, true);
     KIS_SAFE_ASSERT_RECOVER(!m_d->readyShortcut) {
         // it shouldn't have happened, running and ready shortcuts
         // at the same time should not be possible
         forceDeactivateAllActions();
     }
 
     if (m_d->runningShortcut->matchBegin(button)) {
 
         // first reset running shortcut to avoid infinite recursion via end()
         KisStrokeShortcut *runningShortcut = m_d->runningShortcut;
         m_d->runningShortcut = 0;
 
         if (runningShortcut->action()) {
             DEBUG_EVENT_ACTION("Ending running shortcut at event", event);
             KisAbstractInputAction* action = runningShortcut->action();
             int shortcutIndex = runningShortcut->shortcutIndex();
             action->end(event);
             action->deactivate(shortcutIndex);
         }
     }
 
     return !m_d->runningShortcut;
 }
 
 void KisShortcutMatcher::forceEndRunningShortcut(const QPointF &localPos)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->runningShortcut);
     KIS_SAFE_ASSERT_RECOVER(!m_d->readyShortcut) {
         // it shouldn't have happened, running and ready shortcuts
         // at the same time should not be possible
         forceDeactivateAllActions();
     }
 
     // first reset running shortcut to avoid infinite recursion via end()
     KisStrokeShortcut *runningShortcut = m_d->runningShortcut;
     m_d->runningShortcut = 0;
 
     if (runningShortcut->action()) {
         DEBUG_ACTION("Forced ending running shortcut at event");
         KisAbstractInputAction* action = runningShortcut->action();
         int shortcutIndex = runningShortcut->shortcutIndex();
 
         QMouseEvent event = runningShortcut->fakeEndEvent(localPos);
 
         action->end(&event);
         action->deactivate(shortcutIndex);
     }
 }
 
 void KisShortcutMatcher::forceDeactivateAllActions()
 {
     if (m_d->readyShortcut) {
         DEBUG_SHORTCUT("Forcefully deactivating action", m_d->readyShortcut);
         m_d->readyShortcut->action()->deactivate(m_d->readyShortcut->shortcutIndex());
         m_d->readyShortcut = 0;
     }
 }
 
 bool KisShortcutMatcher::tryRunTouchShortcut( QTouchEvent* event )
 {
     KisTouchShortcut *goodCandidate = 0;
 
     if (m_d->actionsSuppressed())
         return false;
 
     Q_FOREACH (KisTouchShortcut* shortcut, m_d->touchShortcuts) {
         if (shortcut->isAvailable(m_d->actionGroupMask()) &&
             shortcut->match( event ) &&
             (!goodCandidate || shortcut->priority() > goodCandidate->priority()) ) {
 
             goodCandidate = shortcut;
         }
     }
 
     if( goodCandidate ) {
         if( m_d->runningShortcut ) {
             QTouchEvent touchEvent(QEvent::TouchEnd,
                                    event->device(),
                                    event->modifiers(),
                                    Qt::TouchPointReleased,
                                    event->touchPoints());
             tryEndRunningShortcut(Qt::LeftButton, &touchEvent);
         }
 
         m_d->touchShortcut = goodCandidate;
         m_d->usingTouch = true;
 
         Private::RecursionGuard guard(this);
         goodCandidate->action()->activate(goodCandidate->shortcutIndex());
         goodCandidate->action()->begin(goodCandidate->shortcutIndex(), event);
 
         // the tool migh have opened some dialog, which could break our event loop
         if (guard.brokenByRecursion()) {
             goodCandidate->action()->end(event);
             m_d->touchShortcut = 0;
 
             forceDeactivateAllActions();
         }
     }
 
     return m_d->touchShortcut;
 }
 
 bool KisShortcutMatcher::tryEndTouchShortcut( QTouchEvent* event )
 {
     if(m_d->touchShortcut) {
         // first reset running shortcut to avoid infinite recursion via end()
         KisTouchShortcut *touchShortcut = m_d->touchShortcut;
 
         touchShortcut->action()->end(event);
         touchShortcut->action()->deactivate(m_d->touchShortcut->shortcutIndex());
 
         m_d->touchShortcut = 0; // empty it out now that we are done with it
 
         return true;
     }
 
     return false;
 }
 
 bool KisShortcutMatcher::tryRunNativeGestureShortcut(QNativeGestureEvent* event)
 {
     KisNativeGestureShortcut *goodCandidate = 0;
 
     if (m_d->actionsSuppressed())
         return false;
 
     Q_FOREACH (KisNativeGestureShortcut* shortcut, m_d->nativeGestureShortcuts) {
         if (shortcut->match(event) && (!goodCandidate || shortcut->priority() > goodCandidate->priority())) {
             goodCandidate = shortcut;
         }
     }
 
     if (goodCandidate) {
         m_d->nativeGestureShortcut = goodCandidate;
         m_d->usingNativeGesture = true;
 
         Private::RecursionGuard guard(this);
         goodCandidate->action()->activate(goodCandidate->shortcutIndex());
         goodCandidate->action()->begin(goodCandidate->shortcutIndex(), event);
 
         // the tool migh have opened some dialog, which could break our event loop
         if (guard.brokenByRecursion()) {
             goodCandidate->action()->end(event);
             m_d->nativeGestureShortcut = 0;
 
             forceDeactivateAllActions();
         }
     }
 
     return m_d->nativeGestureShortcut;
 }
 
 bool KisShortcutMatcher::tryEndNativeGestureShortcut(QNativeGestureEvent* event)
 {
     if (m_d->nativeGestureShortcut) {
         // first reset running shortcut to avoid infinite recursion via end()
         KisNativeGestureShortcut *nativeGestureShortcut = m_d->nativeGestureShortcut;
 
         nativeGestureShortcut->action()->end(event);
         nativeGestureShortcut->action()->deactivate(m_d->nativeGestureShortcut->shortcutIndex());
 
         m_d->nativeGestureShortcut = 0; // empty it out now that we are done with it
 
         return true;
     }
 
     return false;
 }
diff --git a/libs/ui/input/kis_tool_invocation_action.cpp b/libs/ui/input/kis_tool_invocation_action.cpp
index 092297a541..1fbce7c7ea 100644
--- a/libs/ui/input/kis_tool_invocation_action.cpp
+++ b/libs/ui/input/kis_tool_invocation_action.cpp
@@ -1,197 +1,205 @@
 /* This file is part of the KDE project
  * Copyright (C) 2012 Arjen Hiemstra <ahiemstra@heimr.nl>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_tool_invocation_action.h"
 
 #include <kis_debug.h>
 
 #include <klocalizedstring.h>
 
 #include <KoToolManager.h>
 
 #include <kis_tool_proxy.h>
 #include <kis_canvas2.h>
 #include <kis_coordinates_converter.h>
 
 #include "kis_tool.h"
 #include "kis_input_manager.h"
 #include "kis_image.h"
 
 class KisToolInvocationAction::Private
 {
 public:
     Private()
         : active(false),
           lineToolActivated(false)
     {
     }
 
     bool active;
     bool lineToolActivated;
     QPointer<KisToolProxy> activatedToolProxy;
     QPointer<KisToolProxy> runningToolProxy;
 };
 
 KisToolInvocationAction::KisToolInvocationAction()
     : KisAbstractInputAction("Tool Invocation")
     , d(new Private)
 {
     setName(i18n("Tool Invocation"));
     setDescription(i18n("The <i>Tool Invocation</i> action invokes the current tool, for example, using the brush tool, it will start painting."));
 
     QHash<QString, int> indexes;
     indexes.insert(i18n("Activate"), ActivateShortcut);
     indexes.insert(i18n("Confirm"), ConfirmShortcut);
     indexes.insert(i18n("Cancel"), CancelShortcut);
     indexes.insert(i18n("Activate Line Tool"), LineToolShortcut);
     setShortcutIndexes(indexes);
 }
 
 KisToolInvocationAction::~KisToolInvocationAction()
 {
     delete d;
 }
 
 void KisToolInvocationAction::activate(int shortcut)
 {
     Q_UNUSED(shortcut);
     if (!inputManager()) return;
 
     if (shortcut == LineToolShortcut) {
         KoToolManager::instance()->switchToolTemporaryRequested("KritaShape/KisToolLine");
         d->lineToolActivated = true;
     }
 
     d->activatedToolProxy = inputManager()->toolProxy();
     d->activatedToolProxy->activateToolAction(KisTool::Primary);
 }
 
 void KisToolInvocationAction::deactivate(int shortcut)
 {
     Q_UNUSED(shortcut);
     if (!inputManager()) return;
 
-    KIS_SAFE_ASSERT_RECOVER_NOOP(d->activatedToolProxy);
+    /**
+     * Activate call might ave come before actual input manager or tool proxy
+     * was attached. So we may end up wil null activatedToolProxy.
+     */
     if (d->activatedToolProxy) {
         d->activatedToolProxy->deactivateToolAction(KisTool::Primary);
         d->activatedToolProxy.clear();
     }
 
     if (shortcut == LineToolShortcut && d->lineToolActivated) {
         d->lineToolActivated = false;
         KoToolManager::instance()->switchBackRequested();
     }
 }
 
 int KisToolInvocationAction::priority() const
 {
     return 0;
 }
 
 bool KisToolInvocationAction::canIgnoreModifiers() const
 {
     return true;
 }
 
 void KisToolInvocationAction::begin(int shortcut, QEvent *event)
 {
     if (shortcut == ActivateShortcut || shortcut == LineToolShortcut) {
         d->runningToolProxy = inputManager()->toolProxy();
         d->active =
             d->runningToolProxy->forwardEvent(
                 KisToolProxy::BEGIN, KisTool::Primary, event, event);
     } else if (shortcut == ConfirmShortcut) {
         QKeyEvent pressEvent(QEvent::KeyPress, Qt::Key_Return, 0);
         inputManager()->toolProxy()->keyPressEvent(&pressEvent);
         QKeyEvent releaseEvent(QEvent::KeyRelease, Qt::Key_Return, 0);
         inputManager()->toolProxy()->keyReleaseEvent(&releaseEvent);
 
         /**
          * All the tools now have a KisTool::requestStrokeEnd() method,
          * so they should use this instead of direct filtering Enter key
          * press. Until all the tools support it, we just duplicate the
          * key event and the method call
          */
         inputManager()->canvas()->image()->requestStrokeEnd();
 
         /**
          * Some tools would like to distinguish automated requestStrokeEnd()
          * calls from explicit user actions. Just let them do it!
          *
          * Please note that this call should happen **after**
          * requestStrokeEnd(). Some of the tools will switch to another
          * tool on this request, and this (next) tool does not expect to
          * get requestStrokeEnd() right after switching in.
          */
         inputManager()->toolProxy()->explicitUserStrokeEndRequest();
 
     } else if (shortcut == CancelShortcut) {
         /**
          * The tools now have a KisTool::requestStrokeCancellation() method,
          * so just request it.
          */
 
         inputManager()->canvas()->image()->requestStrokeCancellation();
     }
 }
 
 void KisToolInvocationAction::end(QEvent *event)
 {
     if (d->active) {
         // It might happen that the action is still running, while the
         // canvas has been removed, which kills the toolProxy.
         KIS_SAFE_ASSERT_RECOVER_NOOP(d->runningToolProxy);
         if (d->runningToolProxy) {
             d->runningToolProxy->
                 forwardEvent(KisToolProxy::END, KisTool::Primary, event, event);
             d->runningToolProxy.clear();
         }
         d->active = false;
     }
 
     KisAbstractInputAction::end(event);
 }
 
 void KisToolInvocationAction::inputEvent(QEvent* event)
 {
     if (!d->active) return;
     if (!d->runningToolProxy) return;
 
     d->runningToolProxy->
         forwardEvent(KisToolProxy::CONTINUE, KisTool::Primary, event, event);
 }
 
 void KisToolInvocationAction::processUnhandledEvent(QEvent* event)
 {
     bool savedState = d->active;
+    KisToolProxy *savedToolProxy = d->runningToolProxy;
+    if (!d->runningToolProxy) {
+        d->runningToolProxy = inputManager()->toolProxy();
+    }
     d->active = true;
     inputEvent(event);
     d->active = savedState;
+    d->runningToolProxy = savedToolProxy;
 }
 
 bool KisToolInvocationAction::supportsHiResInputEvents() const
 {
     return inputManager()->toolProxy()->primaryActionSupportsHiResEvents();
 }
 
 bool KisToolInvocationAction::isShortcutRequired(int shortcut) const
 {
     //These really all are pretty important for basic user interaction.
     Q_UNUSED(shortcut)
     return true;
 }
diff --git a/libs/ui/input/wintab/drawpile_tablettester/tablettest.cpp b/libs/ui/input/wintab/drawpile_tablettester/tablettest.cpp
index 2b4e2cce13..aea2afe128 100644
--- a/libs/ui/input/wintab/drawpile_tablettester/tablettest.cpp
+++ b/libs/ui/input/wintab/drawpile_tablettester/tablettest.cpp
@@ -1,131 +1,136 @@
 /*
    Drawpile - a collaborative drawing program.
 
    Copyright (C) 2017 Calle Laakkonen
 
    Drawpile is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    Drawpile is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with Drawpile.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "tablettest.h"
 
 #include <QPaintEvent>
 #include <QPainter>
 
 TabletTester::TabletTester(QWidget *parent)
     : QWidget(parent), m_mouseDown(false), m_tabletDown(false)
 {
 }
 
+QSize TabletTester::sizeHint() const
+{
+    return QSize(500, 200);
+}
+
 void TabletTester::clear()
 {
     m_mousePath.clear();
     m_tabletPath.clear();
     update();
 }
 
 void TabletTester::paintEvent(QPaintEvent *e)
 {
     Q_UNUSED(e);
     const int w = width();
     const int h = height();
     QPainter p(this);
     p.fillRect(0, 0, w, h, QColor(200, 200, 200));
     p.setPen(QColor(128, 128, 128));
 
     // Draw grid
     for(int i=w/8;i<w;i+=w/8)
         p.drawLine(i, 0, i, h);
     for(int i=h/8;i<h;i+=h/8)
         p.drawLine(0, i, w, i);
 
     // Draw paths
     if(!m_mousePath.isEmpty()) {
         p.setPen(QPen(Qt::red, 3));
         p.drawPolyline(m_mousePath);
     }
     if(!m_tabletPath.isEmpty()) {
         p.setPen(QPen(Qt::blue, 2));
         p.drawPolyline(m_tabletPath);
     }
 }
 
 void TabletTester::mousePressEvent(QMouseEvent *e)
 {
     Q_EMIT eventReport(QString("Mouse press X=%1 Y=%2 B=%3").arg(e->x()).arg(e->y()).arg(e->button()));
     m_mouseDown = true;
     m_mousePath.clear();
     update();
 }
 
 void TabletTester::mouseMoveEvent(QMouseEvent *e)
 {
     Q_EMIT eventReport(QString("Mouse move X=%1 Y=%2 B=%3").arg(e->x()).arg(e->y()).arg(e->buttons()));
     m_mousePath << e->pos();
     update();
 }
 
 void TabletTester::mouseReleaseEvent(QMouseEvent *e)
 {
     Q_UNUSED(e);
     Q_EMIT eventReport(QString("Mouse release"));
     m_mouseDown = false;
 }
 
 void TabletTester::tabletEvent(QTabletEvent *e)
 {
     e->accept();
 
     QString msg;
     switch(e->device()) {
         case QTabletEvent::Stylus: msg = "Stylus"; break;
         default: msg = QString("Device(%1)").arg(e->device()); break;
     }
 
     switch(e->type()) {
         case QEvent::TabletMove:
             msg += " move";
             break;
         case QEvent::TabletPress:
             msg += " press";
             m_tabletPath.clear();
             m_tabletDown = true;
             break;
         case QEvent::TabletRelease:
             msg += " release";
             m_tabletDown = false;
             break;
         default:
             msg += QString(" event-%1").arg(e->type());
             break;
     }
 
     msg += QString(" X=%1 Y=%2 B=%3 P=%4%")
         .arg(e->posF().x(), 0, 'f', 2)
         .arg(e->posF().y(), 0, 'f', 2)
         .arg(e->buttons())
         .arg(e->pressure()*100, 0, 'f', 1)
         ;
 
     if(e->type() == QEvent::TabletMove) {
         if(m_tabletDown) {
             msg += " (DRAW)";
             m_tabletPath << e->pos();
             update();
         } else {
             msg += " (HOVER)";
         }
     }
 
     Q_EMIT eventReport(msg);
 }
diff --git a/libs/ui/input/wintab/drawpile_tablettester/tablettest.h b/libs/ui/input/wintab/drawpile_tablettester/tablettest.h
index 9ad772c72c..6d62f5d24d 100644
--- a/libs/ui/input/wintab/drawpile_tablettester/tablettest.h
+++ b/libs/ui/input/wintab/drawpile_tablettester/tablettest.h
@@ -1,51 +1,53 @@
 /*
    Drawpile - a collaborative drawing program.
 
    Copyright (C) 2017 Calle Laakkonen
 
    Drawpile is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    Drawpile is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with Drawpile.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #ifndef TABLETTEST_WIDGET_H
 #define TABLETTEST_WIDGET_H
 
 #include <QWidget>
 
 class TabletTester : public QWidget {
     Q_OBJECT
 public:
     TabletTester(QWidget *parent=nullptr);
 
 public Q_SLOTS:
     void clear();
 
 Q_SIGNALS:
     void eventReport(const QString &msg);
 
 protected:
     void paintEvent(QPaintEvent *e) override;
     void mousePressEvent(QMouseEvent *e) override;
     void mouseMoveEvent(QMouseEvent *e) override;
     void mouseReleaseEvent(QMouseEvent *e) override;
     void tabletEvent(QTabletEvent *e) override;
 
+    QSize sizeHint() const override;
+
 private:
     QPolygon m_mousePath;
     QPolygon m_tabletPath;
 
     bool m_mouseDown;
     bool m_tabletDown;
 };
 
 #endif
diff --git a/libs/ui/input/wintab/drawpile_tablettester/tablettest.ui b/libs/ui/input/wintab/drawpile_tablettester/tablettest.ui
index c9c343808e..facf76afc5 100644
--- a/libs/ui/input/wintab/drawpile_tablettester/tablettest.ui
+++ b/libs/ui/input/wintab/drawpile_tablettester/tablettest.ui
@@ -1,99 +1,106 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>TabletTest</class>
  <widget class="QWidget" name="TabletTest">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>730</width>
     <height>385</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Tablet Tester</string>
   </property>
-  <layout class="QHBoxLayout" name="horizontalLayout" stretch="1,1">
+  <layout class="QHBoxLayout" name="horizontalLayout" stretch="1,2">
    <item>
-    <widget class="TabletTester" name="tablettest"/>
+    <widget class="TabletTester" name="tablettest">
+     <property name="minimumSize">
+      <size>
+       <width>150</width>
+       <height>150</height>
+      </size>
+     </property>
+    </widget>
    </item>
    <item>
     <layout class="QVBoxLayout" name="verticalLayout">
      <item>
       <widget class="QPlainTextEdit" name="logView">
        <property name="readOnly">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QPushButton" name="pushButton">
        <property name="text">
         <string>Clear</string>
        </property>
       </widget>
      </item>
     </layout>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>TabletTester</class>
    <extends>QWidget</extends>
    <header>input/wintab/drawpile_tablettester/tablettest.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections>
   <connection>
    <sender>pushButton</sender>
    <signal>clicked()</signal>
    <receiver>logView</receiver>
    <slot>clear()</slot>
    <hints>
     <hint type="sourcelabel">
      <x>722</x>
      <y>377</y>
     </hint>
     <hint type="destinationlabel">
      <x>659</x>
      <y>84</y>
     </hint>
    </hints>
   </connection>
   <connection>
    <sender>pushButton</sender>
    <signal>clicked()</signal>
    <receiver>tablettest</receiver>
    <slot>clear()</slot>
    <hints>
     <hint type="sourcelabel">
      <x>419</x>
      <y>359</y>
     </hint>
     <hint type="destinationlabel">
      <x>142</x>
      <y>242</y>
     </hint>
    </hints>
   </connection>
   <connection>
    <sender>tablettest</sender>
    <signal>eventReport(QString)</signal>
    <receiver>logView</receiver>
    <slot>appendPlainText(QString)</slot>
    <hints>
     <hint type="sourcelabel">
      <x>287</x>
      <y>187</y>
     </hint>
     <hint type="destinationlabel">
      <x>546</x>
      <y>207</y>
     </hint>
    </hints>
   </connection>
  </connections>
 </ui>
diff --git a/libs/ui/kis_canvas_resource_provider.cpp b/libs/ui/kis_canvas_resource_provider.cpp
index 23d0d34532..3405048221 100644
--- a/libs/ui/kis_canvas_resource_provider.cpp
+++ b/libs/ui/kis_canvas_resource_provider.cpp
@@ -1,546 +1,563 @@
 /*
  *  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_canvas_resource_provider.h"
 
 #include <QImage>
 #include <QPainter>
 
 #include <KoCanvasBase.h>
 #include <KoID.h>
 #include <KoColorModelStandardIds.h>
 #include <KoColorProfile.h>
 #include <resources/KoAbstractGradient.h>
 #include <KoCompositeOpRegistry.h>
 #include <KoResourceServerProvider.h>
 #include <resources/KoStopGradient.h>
 #include <KoColorSpaceRegistry.h>
 
 #include <resources/KoPattern.h>
 #include <kis_paint_device.h>
 #include <filter/kis_filter_configuration.h>
 #include <kis_image.h>
 #include <kis_group_layer.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <brushengine/kis_paintop_settings.h>
 #include "kis_favorite_resource_manager.h"
 
 #include "kis_config.h"
 #include "KisViewManager.h"
 #include "canvas/kis_canvas2.h"
 
 KisCanvasResourceProvider::KisCanvasResourceProvider(KisViewManager * view)
     : m_view(view)
 {
     m_fGChanged = true;
     m_enablefGChange = true;    // default to true, so that colour history is working without popup palette
 }
 
 KisCanvasResourceProvider::~KisCanvasResourceProvider()
 {
     disconnect(); // in case Qt gets confused
 }
 
 KoCanvasResourceProvider* KisCanvasResourceProvider::resourceManager()
 {
     return m_resourceManager;
 }
 
 void KisCanvasResourceProvider::setResourceManager(KoCanvasResourceProvider *resourceManager)
 {
     m_resourceManager = resourceManager;
 
     QVariant v;
     v.setValue(KoColor(Qt::black, KoColorSpaceRegistry::instance()->rgb8()));
     m_resourceManager->setResource(KoCanvasResourceProvider::ForegroundColor, v);
 
     v.setValue(KoColor(Qt::white, KoColorSpaceRegistry::instance()->rgb8()));
     m_resourceManager->setResource(KoCanvasResourceProvider::BackgroundColor, v);
 
     setCurrentCompositeOp(COMPOSITE_OVER);
 
     setMirrorHorizontal(false);
     setMirrorVertical(false);
 
     m_resourceManager->setResource(HdrExposure, 0.0);
     m_resourceManager->setResource(HdrGamma, 1.0);
     m_resourceManager->setResource(EffectiveZoom, 1.0);
 
     connect(m_resourceManager, SIGNAL(canvasResourceChanged(int,QVariant)),
             this, SLOT(slotCanvasResourceChanged(int,QVariant)));
 
     m_resourceManager->setResource(KoCanvasResourceProvider::ApplicationSpeciality, KoCanvasResourceProvider::NoAdvancedText);
+
+    m_resourceManager->setResource(GamutMaskActive, false);
 }
 
 
 KoCanvasBase * KisCanvasResourceProvider::canvas() const
 {
     return m_view->canvasBase();
 }
 
 KoColor KisCanvasResourceProvider::bgColor() const
 {
     return m_resourceManager->resource(KoCanvasResourceProvider::BackgroundColor).value<KoColor>();
 }
 
 KoColor KisCanvasResourceProvider::fgColor() const
 {
     return m_resourceManager->resource(KoCanvasResourceProvider::ForegroundColor).value<KoColor>();
 }
 
 float KisCanvasResourceProvider::HDRExposure() const
 {
     return static_cast<float>(m_resourceManager->resource(HdrExposure).toDouble());
 }
 
 void KisCanvasResourceProvider::setHDRExposure(float exposure)
 {
     m_resourceManager->setResource(HdrExposure, static_cast<double>(exposure));
 }
 
 float KisCanvasResourceProvider::HDRGamma() const
 {
     return static_cast<float>(m_resourceManager->resource(HdrGamma).toDouble());
 }
 
 void KisCanvasResourceProvider::setHDRGamma(float gamma)
 {
     m_resourceManager->setResource(HdrGamma, static_cast<double>(gamma));
 }
 
 
 KoPattern * KisCanvasResourceProvider::currentPattern() const
 {
     if (m_resourceManager->hasResource(CurrentPattern)) {
         return m_resourceManager->resource(CurrentPattern).value<KoPattern*>();
     }
     else {
         return 0;
     }
 }
 
 KoAbstractGradient* KisCanvasResourceProvider::currentGradient() const
 {
     if (m_resourceManager->hasResource(CurrentGradient)) {
         return m_resourceManager->resource(CurrentGradient).value<KoAbstractGradient*>();
     }
     else {
         return 0;
     }
 }
 
 KisImageWSP KisCanvasResourceProvider::currentImage() const
 {
     return m_view->image();
 }
 
 KisNodeSP KisCanvasResourceProvider::currentNode() const
 {
     return m_view->activeNode();
 }
 
 KoGamutMask *KisCanvasResourceProvider::currentGamutMask() const
 {
     if (m_resourceManager->hasResource(CurrentGamutMask)) {
         return m_resourceManager->resource(CurrentGamutMask).value<KoGamutMask*>();
     }
     else {
         return nullptr;
     }
 }
 
+bool KisCanvasResourceProvider::gamutMaskActive() const
+{
+    return m_resourceManager->resource(GamutMaskActive).toBool();
+}
+
 KisPaintOpPresetSP KisCanvasResourceProvider::currentPreset() const
 {
     KisPaintOpPresetSP preset = m_resourceManager->resource(CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
     return preset;
 }
 
 void KisCanvasResourceProvider::setPaintOpPreset(const KisPaintOpPresetSP preset)
 {
     Q_ASSERT(preset->valid());
     Q_ASSERT(!preset->paintOp().id().isEmpty());
     Q_ASSERT(preset->settings());
     if (!preset) return;
 
     dbgUI << "setPaintOpPreset" << preset->paintOp();
 
     QVariant v;
     v.setValue(preset);
     m_resourceManager->setResource(CurrentPaintOpPreset, v);
 }
 
 KisPaintOpPresetSP KisCanvasResourceProvider::previousPreset() const
 {
     KisPaintOpPresetSP preset = m_resourceManager->resource(PreviousPaintOpPreset).value<KisPaintOpPresetSP>();
     return preset;
 }
 
 void KisCanvasResourceProvider::setPreviousPaintOpPreset(const KisPaintOpPresetSP preset)
 {
     Q_ASSERT(preset->valid());
     Q_ASSERT(!preset->paintOp().id().isEmpty());
     Q_ASSERT(preset->settings());
     if (!preset) return;
 
     dbgUI << "setPreviousPaintOpPreset" << preset->paintOp();
 
     QVariant v;
     v.setValue(preset);
     m_resourceManager->setResource(PreviousPaintOpPreset, v);
 }
 
 void KisCanvasResourceProvider::slotPatternActivated(KoResource * res)
 {
     KoPattern *pattern = dynamic_cast<KoPattern*>(res);
     QVariant v;
     v.setValue<KoPattern*>(pattern);
     m_resourceManager->setResource(CurrentPattern, v);
     emit sigPatternChanged(pattern);
 }
 
 void KisCanvasResourceProvider::slotGradientActivated(KoResource *res)
 {
 
     KoAbstractGradient * gradient = dynamic_cast<KoAbstractGradient*>(res);
     QVariant v;
     v.setValue<KoAbstractGradient*>(gradient);
     m_resourceManager->setResource(CurrentGradient, v);
     emit sigGradientChanged(gradient);
 }
 
 
 void KisCanvasResourceProvider::setBGColor(const KoColor& c)
 {
     QVariant v;
     v.setValue(c);
     m_resourceManager->setResource(KoCanvasResourceProvider::BackgroundColor, v);
     emit sigBGColorChanged(c);
 }
 
 void KisCanvasResourceProvider::setFGColor(const KoColor& c)
 {
     m_fGChanged = true;
 
     QVariant v;
     v.setValue(c);
     m_resourceManager->setResource(KoCanvasResourceProvider::ForegroundColor, v);
     emit sigFGColorChanged(c);
 }
 
 void KisCanvasResourceProvider::slotSetFGColor(const KoColor& c)
 {
     setFGColor(c);
 }
 
 void KisCanvasResourceProvider::slotSetBGColor(const KoColor& c)
 {
     setBGColor(c);
 }
 
 void KisCanvasResourceProvider::slotNodeActivated(const KisNodeSP node)
 {
     QVariant v;
     v.setValue(KisNodeWSP(node));
     m_resourceManager->setResource(CurrentKritaNode, v);
     emit sigNodeChanged(currentNode());
 }
 
 
 void KisCanvasResourceProvider::slotImageSizeChanged()
 {
     if (KisImageWSP image = m_view->image()) {
         float fw = image->width() / image->xRes();
         float fh = image->height() / image->yRes();
 
         QSizeF postscriptSize(fw, fh);
         m_resourceManager->setResource(KoCanvasResourceProvider::PageSize, postscriptSize);
     }
 }
 
 void KisCanvasResourceProvider::slotOnScreenResolutionChanged()
 {
     KisImageWSP image = m_view->image();
     KisCanvas2 *canvas = m_view->canvasBase();
 
     if(!image || !canvas) return;
 
     qreal zoomX, zoomY;
     canvas->coordinatesConverter()->zoom(&zoomX, &zoomY);
 
     qreal scaleX = zoomX / image->xRes();
     qreal scaleY = zoomY / image->yRes();
 
     emit sigOnScreenResolutionChanged(scaleX, scaleY);
 }
 
 void KisCanvasResourceProvider::slotCanvasResourceChanged(int key, const QVariant & res)
 {
     if(key == KoCanvasResourceProvider::ForegroundColor || key == KoCanvasResourceProvider::BackgroundColor) {
         KoAbstractGradient* resource = KoResourceServerProvider::instance()->gradientServer()->resources()[0];
         KoStopGradient* stopGradient = dynamic_cast<KoStopGradient*>(resource);
         if(stopGradient) {
             QList<KoGradientStop> stops;
             stops << KoGradientStop(0.0, fgColor()) << KoGradientStop(1.0,  KoColor(QColor(0, 0, 0, 0), fgColor().colorSpace()));
             stopGradient->setStops(stops);
             KoResourceServerProvider::instance()->gradientServer()->updateResource(resource);
         }
         resource = KoResourceServerProvider::instance()->gradientServer()->resources()[1];
         stopGradient = dynamic_cast<KoStopGradient*>(resource);
         if(stopGradient) {
             QList<KoGradientStop> stops;
             stops << KoGradientStop(0.0, fgColor()) << KoGradientStop(1.0, bgColor());
             stopGradient->setStops(stops);
             KoResourceServerProvider::instance()->gradientServer()->updateResource(resource);
         }
     }
     switch (key) {
     case(KoCanvasResourceProvider::ForegroundColor):
         m_fGChanged = true;
         emit sigFGColorChanged(res.value<KoColor>());
         break;
     case(KoCanvasResourceProvider::BackgroundColor):
         emit sigBGColorChanged(res.value<KoColor>());
         break;
     case(CurrentPattern):
         emit sigPatternChanged(static_cast<KoPattern *>(res.value<void *>()));
         break;
     case(CurrentGradient):
         emit sigGradientChanged(static_cast<KoAbstractGradient *>(res.value<void *>()));
         break;
     case(CurrentKritaNode) :
         emit sigNodeChanged(currentNode());
         break;
     case (Opacity):
     {
         emit sigOpacityChanged(res.toDouble());
     }
     default:
         ;
         // Do nothing
     };
 }
 
 void KisCanvasResourceProvider::setCurrentCompositeOp(const QString& compositeOp)
 {
     m_resourceManager->setResource(CurrentCompositeOp,
                                    QVariant::fromValue(compositeOp));
 }
 
 QString KisCanvasResourceProvider::currentCompositeOp() const
 {
     return m_resourceManager->resource(CurrentCompositeOp).value<QString>();
 }
 
 bool KisCanvasResourceProvider::eraserMode() const
 {
     return m_resourceManager->resource(EraserMode).toBool();
 }
 
 void KisCanvasResourceProvider::setEraserMode(bool value)
 {
     m_resourceManager->setResource(EraserMode,
                                    QVariant::fromValue(value));
 }
 
 void KisCanvasResourceProvider::slotPainting()
 {
     if (m_fGChanged && m_enablefGChange) {
         emit sigFGColorUsed(fgColor());
         m_fGChanged = false;
     }
 }
 
 void KisCanvasResourceProvider::slotGamutMaskActivated(KoGamutMask *mask)
 {
     QVariant v;
     v.setValue<KoGamutMask*>(mask);
     m_resourceManager->setResource(CurrentGamutMask, v);
+
+    m_resourceManager->setResource(GamutMaskActive, QVariant::fromValue(true));
+
     emit sigGamutMaskChanged(mask);
 }
 
 void KisCanvasResourceProvider::slotGamutMaskUnset()
 {
+    m_resourceManager->setResource(GamutMaskActive, QVariant::fromValue(false));
     m_resourceManager->clearResource(CurrentGamutMask);
     emit sigGamutMaskUnset();
 }
 
 void KisCanvasResourceProvider::slotGamutMaskPreviewUpdate()
 {
     emit sigGamutMaskPreviewUpdate();
 }
 
+void KisCanvasResourceProvider::slotGamutMaskDeactivate()
+{
+    m_resourceManager->setResource(GamutMaskActive, QVariant::fromValue(false));
+    emit sigGamutMaskDeactivated();
+}
+
 void KisCanvasResourceProvider::slotResetEnableFGChange(bool b)
 {
     m_enablefGChange = b;
 }
 
 QList<QPointer<KisAbstractPerspectiveGrid> > KisCanvasResourceProvider::perspectiveGrids() const
 {
     return m_perspectiveGrids;
 }
 
 void KisCanvasResourceProvider::addPerspectiveGrid(KisAbstractPerspectiveGrid* grid)
 {
     m_perspectiveGrids.append(grid);
 }
 
 void KisCanvasResourceProvider::removePerspectiveGrid(KisAbstractPerspectiveGrid* grid)
 {
     m_perspectiveGrids.removeOne(grid);
 }
 
 void KisCanvasResourceProvider::clearPerspectiveGrids()
 {
     m_perspectiveGrids.clear();
 }
 
 void KisCanvasResourceProvider::setMirrorHorizontal(bool mirrorHorizontal)
 {
     m_resourceManager->setResource(MirrorHorizontal, mirrorHorizontal);
     emit mirrorModeChanged();
 }
 
 bool KisCanvasResourceProvider::mirrorHorizontal() const
 {
     return m_resourceManager->resource(MirrorHorizontal).toBool();
 }
 
 void KisCanvasResourceProvider::setMirrorVertical(bool mirrorVertical)
 {
     m_resourceManager->setResource(MirrorVertical, mirrorVertical);
     emit mirrorModeChanged();
 }
 
 bool KisCanvasResourceProvider::mirrorVertical() const
 {
     return m_resourceManager->resource(MirrorVertical).toBool();
 }
 
 void KisCanvasResourceProvider::setMirrorHorizontalLock(bool isLocked)
 {
     m_resourceManager->setResource(MirrorHorizontalLock, isLocked);
     emit mirrorModeChanged();
 }
 
 bool KisCanvasResourceProvider::mirrorHorizontalLock() {
      return m_resourceManager->resource(MirrorHorizontalLock).toBool();
 }
 
 void KisCanvasResourceProvider::setMirrorVerticalLock(bool isLocked)
 {
     m_resourceManager->setResource(MirrorVerticalLock, isLocked);
     emit mirrorModeChanged();
 }
 
 
 
 bool KisCanvasResourceProvider::mirrorVerticalHideDecorations() {
      return m_resourceManager->resource(MirrorVerticalHideDecorations).toBool();
 }
 
 void KisCanvasResourceProvider::setMirrorVerticalHideDecorations(bool hide)
 {
     m_resourceManager->setResource(MirrorVerticalHideDecorations, hide);
     emit mirrorModeChanged();
 }
 
 
 bool KisCanvasResourceProvider::mirrorHorizontalHideDecorations() {
      return m_resourceManager->resource(MirrorHorizontalHideDecorations).toBool();
 }
 
 void KisCanvasResourceProvider::setMirrorHorizontalHideDecorations(bool hide)
 {
     m_resourceManager->setResource(MirrorHorizontalHideDecorations, hide);
     emit mirrorModeChanged();
 }
 
 
 bool KisCanvasResourceProvider::mirrorVerticalLock() {
      return m_resourceManager->resource(MirrorVerticalLock).toBool();
 }
 
 void KisCanvasResourceProvider::mirrorVerticalMoveCanvasToCenter() {
      emit moveMirrorVerticalCenter();
 }
 
 void KisCanvasResourceProvider::mirrorHorizontalMoveCanvasToCenter() {
      emit moveMirrorHorizontalCenter();
 }
 
 
 
 void KisCanvasResourceProvider::setOpacity(qreal opacity)
 {
     m_resourceManager->setResource(Opacity, opacity);
 }
 
 qreal KisCanvasResourceProvider::opacity() const
 {
     return m_resourceManager->resource(Opacity).toReal();
 }
 
 void KisCanvasResourceProvider::setFlow(qreal flow)
 {
     m_resourceManager->setResource(Flow, flow);
 }
 
 qreal KisCanvasResourceProvider::flow() const
 {
     return m_resourceManager->resource(Flow).toReal();
 }
 
 void KisCanvasResourceProvider::setSize(qreal size)
 {
     m_resourceManager->setResource(Size, size);
 }
 
 qreal KisCanvasResourceProvider::size() const
 {
     return m_resourceManager->resource(Size).toReal();
 }
 
 void KisCanvasResourceProvider::setGlobalAlphaLock(bool lock)
 {
     m_resourceManager->setResource(GlobalAlphaLock, lock);
 }
 
 bool KisCanvasResourceProvider::globalAlphaLock() const
 {
     return m_resourceManager->resource(GlobalAlphaLock).toBool();
 }
 
 void KisCanvasResourceProvider::setDisablePressure(bool value)
 {
     m_resourceManager->setResource(DisablePressure, value);
 }
 
 bool KisCanvasResourceProvider::disablePressure() const
 {
     return m_resourceManager->resource(DisablePressure).toBool();
 }
 
 void KisCanvasResourceProvider::notifyLoadingWorkspace(KisWorkspaceResource* workspace)
 {
     emit sigLoadingWorkspace(workspace);
 }
 
 void KisCanvasResourceProvider::notifySavingWorkspace(KisWorkspaceResource* workspace)
 {
     emit sigSavingWorkspace(workspace);
 }
 
diff --git a/libs/ui/kis_canvas_resource_provider.h b/libs/ui/kis_canvas_resource_provider.h
index 5cfb97dace..ebad9a0e18 100644
--- a/libs/ui/kis_canvas_resource_provider.h
+++ b/libs/ui/kis_canvas_resource_provider.h
@@ -1,246 +1,250 @@
 /*
  *  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_CANVAS_RESOURCE_PROVIDER_H_
 #define KIS_CANVAS_RESOURCE_PROVIDER_H_
 
 #include <QObject>
 
 #include <KoColor.h>
 #include <KoID.h>
 #include <KoCanvasResourceProvider.h>
 
 #include "kis_types.h"
 #include "kritaui_export.h"
 
 class KisWorkspaceResource;
 class KoColorProfile;
 class KoAbstractGradient;
 class KoResource;
 
 class KoCanvasBase;
 class KisViewManager;
 class KoPattern;
 class KoGamutMask;
 class KisFilterConfiguration;
 
 #include <kis_abstract_perspective_grid.h>
 
 /**
  * KisCanvasResourceProvider contains the per-window current settings that
  * influence painting, like paintop, color, gradients and so on.
  */
 class KRITAUI_EXPORT KisCanvasResourceProvider : public QObject
 {
     Q_OBJECT
 
 public:
 
     enum Resources {
         HdrExposure = KoCanvasResourceProvider::KritaStart + 1,
         CurrentPattern,
         CurrentGamutMask,
+        GamutMaskActive,
         CurrentGradient,
         CurrentDisplayProfile,
         CurrentKritaNode,
         CurrentPaintOpPreset,
         CurrentGeneratorConfiguration,
         CurrentCompositeOp,
         CurrentEffectiveCompositeOp,
         LodAvailability, ///<-user choice
         LodSizeThreshold, ///<-user choice
         LodSizeThresholdSupported, ///<-paintop property
         EffectiveLodAvailablility, ///<- a superposition of user choice, threshold and paintop traits
         EraserMode,
         MirrorHorizontal,
         MirrorVertical,
         MirrorHorizontalLock,
         MirrorVerticalLock,
         MirrorVerticalHideDecorations,
         MirrorHorizontalHideDecorations,
         Opacity,
         Flow,
         Size,
         HdrGamma,
         GlobalAlphaLock,
         DisablePressure,
         PreviousPaintOpPreset,
         EffectiveZoom ///<-Used only by painting tools for non-displaying purposes
     };
 
 
     KisCanvasResourceProvider(KisViewManager * view);
     ~KisCanvasResourceProvider() override;
 
     void setResourceManager(KoCanvasResourceProvider *resourceManager);
     KoCanvasResourceProvider* resourceManager();
 
     KoCanvasBase * canvas() const;
 
     KoColor bgColor() const;
     void setBGColor(const KoColor& c);
 
     KoColor fgColor() const;
     void setFGColor(const KoColor& c);
 
     float HDRExposure() const;
     void setHDRExposure(float exposure);
 
     float HDRGamma() const;
     void setHDRGamma(float gamma);
 
     bool eraserMode() const;
     void setEraserMode(bool value);
 
     KoPattern *currentPattern() const;
 
     KoAbstractGradient *currentGradient() const;
 
     KisImageWSP currentImage() const;
 
     KisNodeSP currentNode() const;
 
     KoGamutMask* currentGamutMask() const;
+    bool gamutMaskActive() const;
 
     KisPaintOpPresetSP currentPreset() const;
     void setPaintOpPreset(const KisPaintOpPresetSP preset);
 
     KisPaintOpPresetSP previousPreset() const;
     void setPreviousPaintOpPreset(const KisPaintOpPresetSP preset);
 
     void setCurrentCompositeOp(const QString& compositeOp);
     QString currentCompositeOp() const;
 
     QList<QPointer<KisAbstractPerspectiveGrid> > perspectiveGrids() const;
     void addPerspectiveGrid(KisAbstractPerspectiveGrid*);
     void removePerspectiveGrid(KisAbstractPerspectiveGrid*);
     void clearPerspectiveGrids();
 
     void setMirrorHorizontal(bool mirrorHorizontal);
     bool mirrorHorizontal() const;
 
     void setMirrorVertical(bool mirrorVertical);
     bool mirrorVertical() const;
 
     // options for horizontal and vertical mirror toolbar
     void setMirrorHorizontalLock(bool isLocked);
     bool mirrorHorizontalLock();
     void setMirrorVerticalLock(bool isLocked);
     bool mirrorVerticalLock();
 
     void setMirrorVerticalHideDecorations(bool hide);
     bool mirrorVerticalHideDecorations();
 
     void setMirrorHorizontalHideDecorations(bool hide);
     bool mirrorHorizontalHideDecorations();
 
     void mirrorVerticalMoveCanvasToCenter();
     void mirrorHorizontalMoveCanvasToCenter();
 
     void setOpacity(qreal opacity);
     qreal opacity() const;
 
     void setFlow(qreal opacity);
     qreal flow() const;
 
     void setSize(qreal size);
     qreal size() const;
 
     void setGlobalAlphaLock(bool lock);
     bool globalAlphaLock() const;
 
     void setDisablePressure(bool value);
     bool disablePressure() const;
 
     ///Notify that the workspace is saved and settings should be saved to it
     void notifySavingWorkspace(KisWorkspaceResource* workspace);
 
     ///Notify that the workspace is loaded and settings can be read
     void notifyLoadingWorkspace(KisWorkspaceResource* workspace);
 
 public Q_SLOTS:
 
     void slotSetFGColor(const KoColor& c);
     void slotSetBGColor(const KoColor& c);
     void slotPatternActivated(KoResource *pattern);
     void slotGradientActivated(KoResource *gradient);
     void slotNodeActivated(const KisNodeSP node);
     void slotPainting();
 
     void slotGamutMaskActivated(KoGamutMask* mask);
     void slotGamutMaskUnset();
     void slotGamutMaskPreviewUpdate();
+    void slotGamutMaskDeactivate();
 
     /**
      * Set the image size in pixels. The resource provider will store
      * the image size in postscript points.
      */
     // FIXME: this slot doesn't catch the case when image resolution is changed
     void slotImageSizeChanged();
     void slotOnScreenResolutionChanged();
 
     // This is a flag to handle a bug:
     // If pop up palette is visible and a new colour is selected, the new colour
     // will be added when the user clicks on the canvas to hide the palette
     // In general, we want to be able to store recent color if the pop up palette
     // is not visible
     void slotResetEnableFGChange(bool);
 
 private Q_SLOTS:
 
     void slotCanvasResourceChanged(int key, const QVariant & res);
 
 Q_SIGNALS:
 
     void sigFGColorChanged(const KoColor &);
     void sigBGColorChanged(const KoColor &);
     void sigGradientChanged(KoAbstractGradient *);
     void sigPatternChanged(KoPattern *);
     void sigNodeChanged(const KisNodeSP);
     void sigDisplayProfileChanged(const KoColorProfile *);
     void sigFGColorUsed(const KoColor&);
     void sigOnScreenResolutionChanged(qreal scaleX, qreal scaleY);
     void sigOpacityChanged(qreal);
     void sigSavingWorkspace(KisWorkspaceResource* workspace);
     void sigLoadingWorkspace(KisWorkspaceResource* workspace);
 
     void mirrorModeChanged();
     void moveMirrorVerticalCenter();
     void moveMirrorHorizontalCenter();
 
     void sigGamutMaskChanged(KoGamutMask* mask);
     void sigGamutMaskUnset();
     void sigGamutMaskPreviewUpdate();
+    void sigGamutMaskDeactivated();
 
 private:
 
     KisViewManager * m_view;
     KoCanvasResourceProvider *m_resourceManager;
     bool m_fGChanged;
     QList<QPointer<KisAbstractPerspectiveGrid> > m_perspectiveGrids;
 
     // This is a flag to handle a bug:
     // If pop up palette is visible and a new colour is selected, the new colour
     // will be added when the user clicks on the canvas to hide the palette
     // In general, we want to be able to store recent color if the pop up palette
     // is not visible
     bool m_enablefGChange;
 
 };
 
 #endif
diff --git a/libs/ui/kis_config.cc b/libs/ui/kis_config.cc
index 0e59bb3414..450d5d38a7 100644
--- a/libs/ui/kis_config.cc
+++ b/libs/ui/kis_config.cc
@@ -1,2157 +1,2155 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_config.h"
 
-#include <limits.h>
-
 #include <QtGlobal>
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QMutex>
 #include <QFont>
 #include <QThread>
 #include <QStringList>
 #include <QSettings>
 #include <QStandardPaths>
 
 #include <kconfig.h>
 
 #include <KisDocument.h>
 
 #include <KoColor.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorModelStandardIds.h>
 #include <KoColorProfile.h>
 
 #include <kis_debug.h>
 #include <kis_types.h>
 
 #include "kis_canvas_resource_provider.h"
 #include "kis_config_notifier.h"
 #include "kis_snap_config.h"
 
 #include <config-ocio.h>
 
 #include <kis_color_manager.h>
 #include <KisOcioConfiguration.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();
 }
 
 
 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",false));
+   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));
+   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) {
-        const KoColorProfile *profile = KoColorSpaceRegistry::instance()->createColorProfile(RGBAColorModelID.id(), Integer8BitsColorDepthID.id(), bytes);
+        profile = KoColorSpaceRegistry::instance()->createColorProfile(RGBAColorModelID.id(), Integer8BitsColorDepthID.id(), bytes);
         //dbgKrita << "\tKisConfig::getScreenProfile for screen" << screen << profile->name();
-        return profile;
-    }
-    else {
-        //dbgKrita << "\tCould not get a system monitor profile";
-        return 0;
     }
+    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
 {
     return (defaultValue ? 32 : m_cfg.readEntry("checksize", 32));
 }
 
 void KisConfig::setCheckSize(qint32 checksize) const
 {
     m_cfg.writeEntry("checksize", checksize);
 }
 
 bool KisConfig::scrollCheckers(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("scrollingcheckers", false));
 }
 
 void KisConfig::setScrollingCheckers(bool sc) const
 {
     m_cfg.writeEntry("scrollingcheckers", sc);
 }
 
 QColor KisConfig::canvasBorderColor(bool defaultValue) const
 {
     QColor color(QColor(128,128,128));
     return (defaultValue ? color : m_cfg.readEntry("canvasBorderColor", color));
 }
 
 void KisConfig::setCanvasBorderColor(const QColor& color) const
 {
     m_cfg.writeEntry("canvasBorderColor", color);
 }
 
 bool KisConfig::hideScrollbars(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("hideScrollbars", false));
 }
 
 void KisConfig::setHideScrollbars(bool value) const
 {
     m_cfg.writeEntry("hideScrollbars", value);
 }
 
 
 QColor KisConfig::checkersColor1(bool defaultValue) const
 {
     QColor col(220, 220, 220);
     return (defaultValue ? col : m_cfg.readEntry("checkerscolor", col));
 }
 
 void KisConfig::setCheckersColor1(const QColor & v) const
 {
     m_cfg.writeEntry("checkerscolor", v);
 }
 
 QColor KisConfig::checkersColor2(bool defaultValue) const
 {
     return (defaultValue ? QColor(Qt::white) : m_cfg.readEntry("checkerscolor2", QColor(Qt::white)));
 }
 
 void KisConfig::setCheckersColor2(const QColor & v) const
 {
     m_cfg.writeEntry("checkerscolor2", v);
 }
 
 bool KisConfig::antialiasCurves(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("antialiascurves", true));
 }
 
 void KisConfig::setAntialiasCurves(bool v) const
 {
     m_cfg.writeEntry("antialiascurves", v);
 }
 
 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(QColor value)
+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);
 }
 
 #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
+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();
-        return KoColor::fromXML(e, Integer16BitsColorDepthID.id());
-    } else {
+        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();
-        return KoColor::fromXML(e, Integer16BitsColorDepthID.id());
+        color =  KoColor::fromXML(e, Integer16BitsColorDepthID.id());
     }
     return color;
 
 }
diff --git a/libs/ui/kis_config.h b/libs/ui/kis_config.h
index ea2bf39dd1..ae6f6e47f5 100644
--- a/libs/ui/kis_config.h
+++ b/libs/ui/kis_config.h
@@ -1,639 +1,639 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef KIS_CONFIG_H_
 #define KIS_CONFIG_H_
 
 #include <QString>
 #include <QStringList>
 #include <QList>
 #include <QColor>
 
 #include <ksharedconfig.h>
 #include <kconfiggroup.h>
 
 #include <kis_global.h>
 #include <kis_properties_configuration.h>
 #include "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();
 
     bool disableTouchOnCanvas(bool defaultValue = false) const;
     void setDisableTouchOnCanvas(bool value) const;
 
     bool disableTouchRotation(bool defaultValue = false) const;
     void setDisableTouchRotation(bool value) const;
 
     bool useProjections(bool defaultValue = false) const;
     void setUseProjections(bool useProj) const;
 
     bool undoEnabled(bool defaultValue = false) const;
     void setUndoEnabled(bool undo) const;
 
     int undoStackLimit(bool defaultValue = false) const;
     void setUndoStackLimit(int limit) const;
 
     bool useCumulativeUndoRedo(bool defaultValue = false) const;
     void setCumulativeUndoRedo(bool value);
 
     double stackT1(bool defaultValue = false) const;
     void setStackT1(int T1);
 
     double stackT2(bool defaultValue = false) const;
     void setStackT2(int T2);
 
     int stackN(bool defaultValue = false) const;
     void setStackN(int N);
 
     qint32 defImageWidth(bool defaultValue = false) const;
     void defImageWidth(qint32 width) const;
 
     qint32 defImageHeight(bool defaultValue = false) const;
     void defImageHeight(qint32 height) const;
 
     qreal defImageResolution(bool defaultValue = false) const;
     void defImageResolution(qreal res) const;
 
     int preferredVectorImportResolutionPPI(bool defaultValue = false) const;
     void setPreferredVectorImportResolutionPPI(int value) const;
 
     /**
      * @return the id of the default color model used for creating new images.
      */
     QString defColorModel(bool defaultValue = false) const;
     /**
      * set the id of the default color model used for creating new images.
      */
     void defColorModel(const QString & model) const;
 
     /**
      * @return the id of the default color depth used for creating new images.
      */
     QString defaultColorDepth(bool defaultValue = false) const;
     /**
      * set the id of the default color depth used for creating new images.
      */
     void setDefaultColorDepth(const QString & depth) const;
 
     /**
      * @return the id of the default color profile used for creating new images.
      */
     QString defColorProfile(bool defaultValue = false) const;
     /**
      * set the id of the default color profile used for creating new images.
      */
     void defColorProfile(const QString & depth) const;
 
     CursorStyle newCursorStyle(bool defaultValue = false) const;
     void setNewCursorStyle(CursorStyle style);
 
     QColor getCursorMainColor(bool defaultValue = false) const;
     void setCursorMainColor(const QColor& v) const;
 
     OutlineStyle newOutlineStyle(bool defaultValue = false) const;
     void setNewOutlineStyle(OutlineStyle style);
 
     QRect colorPreviewRect() const;
     void setColorPreviewRect(const QRect &rect);
 
     /// get the profile the user has selected for the given screen
     QString monitorProfile(int screen) const;
     void setMonitorProfile(int screen, const QString & monitorProfile, bool override) const;
 
     QString monitorForScreen(int screen, const QString &defaultMonitor, bool defaultValue = true) const;
     void setMonitorForScreen(int screen, const QString& monitor);
 
     /// Get the actual profile to be used for the given screen, which is
     /// either the screen profile set by the color management system or
     /// the custom monitor profile set by the user, depending on the configuration
     const KoColorProfile *displayProfile(int screen) const;
 
     QString workingColorSpace(bool defaultValue = false) const;
     void setWorkingColorSpace(const QString & workingColorSpace) const;
 
     QString importProfile(bool defaultValue = false) const;
     void setImportProfile(const QString & importProfile) const;
 
     QString printerColorSpace(bool defaultValue = false) const;
     void setPrinterColorSpace(const QString & printerColorSpace) const;
 
     QString printerProfile(bool defaultValue = false) const;
     void setPrinterProfile(const QString & printerProfile) const;
 
     bool useBlackPointCompensation(bool defaultValue = false) const;
     void setUseBlackPointCompensation(bool useBlackPointCompensation) const;
 
     bool allowLCMSOptimization(bool defaultValue = false) const;
     void setAllowLCMSOptimization(bool allowLCMSOptimization);
 
     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);
 
     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(QColor value);
+    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);
 
     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_layer_manager.cc b/libs/ui/kis_layer_manager.cc
index 7fdac820ed..9d0c77bc24 100644
--- a/libs/ui/kis_layer_manager.cc
+++ b/libs/ui/kis_layer_manager.cc
@@ -1,999 +1,1005 @@
 /*
  *  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_layer_manager.h"
 
 #include <QRect>
 #include <QApplication>
 #include <QCursor>
 #include <QString>
 #include <QDialog>
 #include <QVBoxLayout>
 #include <QFileInfo>
 #include <QStandardPaths>
 
 #include <kactioncollection.h>
 #include <klocalizedstring.h>
 #include <QMessageBox>
 #include <QUrl>
 
 #include <kis_file_name_requester.h>
 #include <kis_icon.h>
 #include <KisImportExportManager.h>
 #include <KisDocument.h>
 #include <KoColorSpace.h>
 #include <KoCompositeOpRegistry.h>
 #include <KoPointerEvent.h>
 #include <KoColorProfile.h>
 #include <KoSelection.h>
 #include <KisPart.h>
 #include <KisMainWindow.h>
 
 #include <filter/kis_filter_configuration.h>
 #include <filter/kis_filter.h>
 #include <kis_filter_strategy.h>
 #include <generator/kis_generator_layer.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_image.h>
 #include <kis_layer.h>
 #include <kis_paint_device.h>
 #include <kis_selection.h>
 #include <flake/kis_shape_layer.h>
 #include <kis_undo_adapter.h>
 #include <kis_painter.h>
 #include <kis_meta_data_store.h>
 #include <kis_meta_data_merge_strategy_registry.h>
 #include <kis_psd_layer_style.h>
 #include <KisMimeDatabase.h>
 
 #include "kis_config.h"
 #include "kis_cursor.h"
 #include "dialogs/kis_dlg_adj_layer_props.h"
 #include "dialogs/kis_dlg_adjustment_layer.h"
 #include "dialogs/kis_dlg_layer_properties.h"
 #include "dialogs/kis_dlg_generator_layer.h"
 #include "dialogs/kis_dlg_file_layer.h"
 #include "dialogs/kis_dlg_layer_style.h"
 #include "dialogs/KisDlgChangeCloneSource.h"
 #include "kis_filter_manager.h"
 #include "kis_node_visitor.h"
 #include "kis_paint_layer.h"
 #include "commands/kis_image_commands.h"
 #include "commands/kis_node_commands.h"
 #include "kis_change_file_layer_command.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_selection_manager.h"
 #include "kis_statusbar.h"
 #include "KisViewManager.h"
 #include "kis_zoom_manager.h"
 #include "canvas/kis_canvas2.h"
 #include "widgets/kis_meta_data_merge_strategy_chooser_widget.h"
 #include "widgets/kis_wdg_generator.h"
 #include "kis_progress_widget.h"
 #include "kis_node_commands_adapter.h"
 #include "kis_node_manager.h"
 #include "kis_action.h"
 #include "kis_action_manager.h"
 #include "kis_raster_keyframe_channel.h"
 #include "kis_signal_compressor_with_param.h"
 #include "kis_abstract_projection_plane.h"
 #include "commands_new/kis_set_layer_style_command.h"
 #include "kis_post_execution_undo_adapter.h"
 #include "kis_selection_mask.h"
 #include "kis_layer_utils.h"
 #include "lazybrush/kis_colorize_mask.h"
 #include "kis_processing_applicator.h"
 
 #include "KisSaveGroupVisitor.h"
 
 KisLayerManager::KisLayerManager(KisViewManager * view)
     : m_view(view)
     , m_imageView(0)
     , m_imageFlatten(0)
     , m_imageMergeLayer(0)
     , m_groupLayersSave(0)
     , m_imageResizeToLayer(0)
     , m_flattenLayer(0)
     , m_rasterizeLayer(0)
     , m_commandsAdapter(new KisNodeCommandsAdapter(m_view))
     , m_layerStyle(0)
 {
 }
 
 KisLayerManager::~KisLayerManager()
 {
     delete m_commandsAdapter;
 }
 
 void KisLayerManager::setView(QPointer<KisView>view)
 {
     m_imageView = view;
 }
 
 KisLayerSP KisLayerManager::activeLayer()
 {
     if (m_imageView) {
         return m_imageView->currentLayer();
     }
     return 0;
 }
 
 KisPaintDeviceSP KisLayerManager::activeDevice()
 {
     if (activeLayer()) {
         return activeLayer()->paintDevice();
     }
     return 0;
 }
 
 void KisLayerManager::activateLayer(KisLayerSP layer)
 {
     if (m_imageView) {
         emit sigLayerActivated(layer);
         layersUpdated();
         if (layer) {
             m_view->canvasResourceProvider()->slotNodeActivated(layer.data());
         }
     }
 }
 
 
 void KisLayerManager::setup(KisActionManager* actionManager)
 {
     m_imageFlatten = actionManager->createAction("flatten_image");
     connect(m_imageFlatten, SIGNAL(triggered()), this, SLOT(flattenImage()));
 
     m_imageMergeLayer = actionManager->createAction("merge_layer");
     connect(m_imageMergeLayer, SIGNAL(triggered()), this, SLOT(mergeLayer()));
 
     m_flattenLayer = actionManager->createAction("flatten_layer");
     connect(m_flattenLayer, SIGNAL(triggered()), this, SLOT(flattenLayer()));
 
     m_rasterizeLayer = actionManager->createAction("rasterize_layer");
     connect(m_rasterizeLayer, SIGNAL(triggered()), this, SLOT(rasterizeLayer()));
 
     m_groupLayersSave = actionManager->createAction("save_groups_as_images");
     connect(m_groupLayersSave, SIGNAL(triggered()), this, SLOT(saveGroupLayers()));
 
     m_convertGroupAnimated = actionManager->createAction("convert_group_to_animated");
     connect(m_convertGroupAnimated, SIGNAL(triggered()), this, SLOT(convertGroupToAnimated()));
 
     m_imageResizeToLayer = actionManager->createAction("resizeimagetolayer");
     connect(m_imageResizeToLayer, SIGNAL(triggered()), this, SLOT(imageResizeToActiveLayer()));
 
     KisAction *action = actionManager->createAction("trim_to_image");
     connect(action, SIGNAL(triggered()), this, SLOT(trimToImage()));
 
     m_layerStyle  = actionManager->createAction("layer_style");
     connect(m_layerStyle, SIGNAL(triggered()), this, SLOT(layerStyle()));
 
 }
 
 void KisLayerManager::updateGUI()
 {
     KisImageSP image = m_view->image();
     KisLayerSP layer = activeLayer();
 
     const bool isGroupLayer = layer && layer->inherits("KisGroupLayer");
 
     m_imageMergeLayer->setText(
                 isGroupLayer ?
                     i18nc("@action:inmenu", "Merge Group") :
                     i18nc("@action:inmenu", "Merge with Layer Below"));
     m_flattenLayer->setVisible(!isGroupLayer);
 
     if (m_view->statusBar())
         m_view->statusBar()->setProfile(image);
 }
 
 void KisLayerManager::imageResizeToActiveLayer()
 {
     KisLayerSP layer;
     KisImageWSP image = m_view->image();
 
     if (image && (layer = activeLayer())) {
         QRect cropRect = layer->projection()->nonDefaultPixelArea();
         if (!cropRect.isEmpty()) {
             image->cropImage(cropRect);
         } else {
             m_view->showFloatingMessage(
                         i18nc("floating message in layer manager",
                               "Layer is empty "),
                         QIcon(), 2000, KisFloatingMessage::Low);
         }
     }
 }
 
 void KisLayerManager::trimToImage()
 {
     KisImageWSP image = m_view->image();
     if (image) {
         image->cropImage(image->bounds());
     }
 }
 
 void KisLayerManager::layerProperties()
 {
     if (!m_view) return;
     if (!m_view->document()) return;
 
     KisLayerSP layer = activeLayer();
     if (!layer) return;
 
     QList<KisNodeSP> selectedNodes = m_view->nodeManager()->selectedNodes();
     const bool multipleLayersSelected = selectedNodes.size() > 1;
 
     KisAdjustmentLayerSP adjustmentLayer = KisAdjustmentLayerSP(dynamic_cast<KisAdjustmentLayer*>(layer.data()));
     KisGeneratorLayerSP generatorLayer = KisGeneratorLayerSP(dynamic_cast<KisGeneratorLayer*>(layer.data()));
     KisFileLayerSP fileLayer = KisFileLayerSP(dynamic_cast<KisFileLayer*>(layer.data()));
 
     if (adjustmentLayer && !multipleLayersSelected) {
 
         KisPaintDeviceSP dev = adjustmentLayer->projection();
 
         KisDlgAdjLayerProps dlg(adjustmentLayer, adjustmentLayer.data(), dev, m_view, adjustmentLayer->filter().data(), adjustmentLayer->name(), i18n("Filter Layer Properties"), m_view->mainWindow(), "dlgadjlayerprops");
         dlg.resize(dlg.minimumSizeHint());
 
 
         KisFilterConfigurationSP configBefore(adjustmentLayer->filter());
         KIS_ASSERT_RECOVER_RETURN(configBefore);
         QString xmlBefore = configBefore->toXML();
 
 
         if (dlg.exec() == QDialog::Accepted) {
 
             adjustmentLayer->setName(dlg.layerName());
 
             KisFilterConfigurationSP configAfter(dlg.filterConfiguration());
             Q_ASSERT(configAfter);
             QString xmlAfter = configAfter->toXML();
 
             if(xmlBefore != xmlAfter) {
                 KisChangeFilterCmd *cmd
                         = new KisChangeFilterCmd(adjustmentLayer,
                                                  configBefore->name(),
                                                  xmlBefore,
                                                  configAfter->name(),
                                                  xmlAfter,
                                                  false);
                 // FIXME: check whether is needed
                 cmd->redo();
                 m_view->undoAdapter()->addCommand(cmd);
                 m_view->document()->setModified(true);
             }
         }
         else {
             KisFilterConfigurationSP configAfter(dlg.filterConfiguration());
             Q_ASSERT(configAfter);
             QString xmlAfter = configAfter->toXML();
 
             if(xmlBefore != xmlAfter) {
                 adjustmentLayer->setFilter(KisFilterRegistry::instance()->cloneConfiguration(configBefore.data()));
                 adjustmentLayer->setDirty();
             }
         }
     }
     else if (generatorLayer && !multipleLayersSelected) {
         KisFilterConfigurationSP configBefore(generatorLayer->filter());
         Q_ASSERT(configBefore);
         QString xmlBefore = configBefore->toXML();
 
         KisDlgGeneratorLayer *dlg = new KisDlgGeneratorLayer(generatorLayer->name(), m_view, m_view->mainWindow(), generatorLayer, configBefore);
         dlg->setCaption(i18n("Fill Layer Properties"));
         dlg->setAttribute(Qt::WA_DeleteOnClose);
 
         dlg->setConfiguration(configBefore.data());
         dlg->resize(dlg->minimumSizeHint());
 
         Qt::WindowFlags flags = dlg->windowFlags();
         dlg->setWindowFlags(flags | Qt::Tool | Qt::Dialog);
         dlg->show();
 
     }
     else if (fileLayer && !multipleLayersSelected){
         QString basePath = QFileInfo(m_view->document()->url().toLocalFile()).absolutePath();
         QString fileNameOld = fileLayer->fileName();
         KisFileLayer::ScalingMethod scalingMethodOld = fileLayer->scalingMethod();
         KisDlgFileLayer dlg(basePath, fileLayer->name(), m_view->mainWindow());
         dlg.setCaption(i18n("File Layer Properties"));
         dlg.setFileName(fileNameOld);
         dlg.setScalingMethod(scalingMethodOld);
 
         if (dlg.exec() == QDialog::Accepted) {
             const QString fileNameNew = dlg.fileName();
             KisFileLayer::ScalingMethod scalingMethodNew = dlg.scaleToImageResolution();
 
             if(fileNameNew.isEmpty()){
                 QMessageBox::critical(m_view->mainWindow(), i18nc("@title:window", "Krita"), i18n("No file name specified"));
                 return;
             }
             fileLayer->setName(dlg.layerName());
 
             if (fileNameOld!= fileNameNew || scalingMethodOld != scalingMethodNew) {
                 KisChangeFileLayerCmd *cmd
                         = new KisChangeFileLayerCmd(fileLayer,
                                                     basePath,
                                                     fileNameOld,
                                                     scalingMethodOld,
                                                     basePath,
                                                     fileNameNew,
                                                     scalingMethodNew);
                 m_view->undoAdapter()->addCommand(cmd);
             }
         }
     } else { // If layer == normal painting layer, vector layer, or group layer
         QList<KisNodeSP> selectedNodes = m_view->nodeManager()->selectedNodes();
 
         KisDlgLayerProperties *dialog = new KisDlgLayerProperties(selectedNodes, m_view);
         dialog->resize(dialog->minimumSizeHint());
         dialog->setAttribute(Qt::WA_DeleteOnClose);
         Qt::WindowFlags flags = dialog->windowFlags();
         dialog->setWindowFlags(flags | Qt::Tool | Qt::Dialog);
         dialog->show();
 
     }
 }
 
 void KisLayerManager::changeCloneSource()
 {
     QList<KisNodeSP> selectedNodes = m_view->nodeManager()->selectedNodes();
     if (selectedNodes.isEmpty()) {
         return;
     }
 
     QList<KisCloneLayerSP> cloneLayers;
     KisNodeSP node;
     Q_FOREACH (node, selectedNodes) {
         KisCloneLayerSP cloneLayer(qobject_cast<KisCloneLayer *>(node.data()));
         if (cloneLayer) {
             cloneLayers << cloneLayer;
         }
     }
 
     if (cloneLayers.isEmpty()) {
         return;
     }
 
     KisDlgChangeCloneSource *dialog = new KisDlgChangeCloneSource(cloneLayers, m_view);
     dialog->setCaption(i18n("Change Clone Layer"));
     dialog->resize(dialog->minimumSizeHint());
     dialog->setAttribute(Qt::WA_DeleteOnClose);
     Qt::WindowFlags flags = dialog->windowFlags();
     dialog->setWindowFlags(flags | Qt::Tool | Qt::Dialog);
     dialog->show();
 }
 
 void KisLayerManager::convertNodeToPaintLayer(KisNodeSP source)
 {
     KisImageWSP image = m_view->image();
     if (!image) return;
 
 
     KisLayer *srcLayer = qobject_cast<KisLayer*>(source.data());
     if (srcLayer && (srcLayer->inherits("KisGroupLayer") || srcLayer->layerStyle() || srcLayer->childCount() > 0)) {
         image->flattenLayer(srcLayer);
         return;
     }
 
 
     KisPaintDeviceSP srcDevice =
             source->paintDevice() ? source->projection() : source->original();
 
     bool putBehind = false;
     QString newCompositeOp = source->compositeOpId();
     KisColorizeMask *colorizeMask = dynamic_cast<KisColorizeMask*>(source.data());
     if (colorizeMask) {
         srcDevice = colorizeMask->coloringProjection();
         putBehind = colorizeMask->compositeOpId() == COMPOSITE_BEHIND;
         if (putBehind) {
             newCompositeOp = COMPOSITE_OVER;
         }
     }
 
     if (!srcDevice) return;
 
     KisPaintDeviceSP clone;
 
     if (*srcDevice->colorSpace() !=
             *srcDevice->compositionSourceColorSpace()) {
 
         clone = new KisPaintDevice(srcDevice->compositionSourceColorSpace());
 
         QRect rc(srcDevice->extent());
         KisPainter::copyAreaOptimized(rc.topLeft(), srcDevice, clone, rc);
 
     } else {
         clone = new KisPaintDevice(*srcDevice);
     }
 
     KisLayerSP layer = new KisPaintLayer(image,
                                          source->name(),
                                          source->opacity(),
                                          clone);
     layer->setCompositeOpId(newCompositeOp);
 
     KisNodeSP parent = source->parent();
     KisNodeSP above = source->prevSibling();
 
     while (parent && !parent->allowAsChild(layer)) {
         above = above ? above->parent() : source->parent();
         parent = above ? above->parent() : 0;
     }
 
     if (putBehind && above == source->parent()) {
         above = above->prevSibling();
     }
 
     m_commandsAdapter->beginMacro(kundo2_i18n("Convert to a Paint Layer"));
     m_commandsAdapter->removeNode(source);
     m_commandsAdapter->addNode(layer, parent, above);
     m_commandsAdapter->endMacro();
 
 }
 
 void KisLayerManager::convertGroupToAnimated()
 {
     KisGroupLayerSP group = dynamic_cast<KisGroupLayer*>(activeLayer().data());
     if (group.isNull()) return;
 
     KisPaintLayerSP animatedLayer = new KisPaintLayer(m_view->image(), group->name(), OPACITY_OPAQUE_U8);
     animatedLayer->enableAnimation();
     KisRasterKeyframeChannel *contentChannel = dynamic_cast<KisRasterKeyframeChannel*>(
                 animatedLayer->getKeyframeChannel(KisKeyframeChannel::Content.id(), true));
     KIS_ASSERT_RECOVER_RETURN(contentChannel);
 
     KisNodeSP child = group->firstChild();
     int time = 0;
     while (child) {
         contentChannel->importFrame(time, child->projection(), NULL);
         time++;
 
         child = child->nextSibling();
     }
 
     m_commandsAdapter->beginMacro(kundo2_i18n("Convert to an animated layer"));
     m_commandsAdapter->addNode(animatedLayer, group->parent(), group);
     m_commandsAdapter->removeNode(group);
     m_commandsAdapter->endMacro();
 }
 
 void KisLayerManager::convertLayerToFileLayer(KisNodeSP source)
 {
     KisImageSP image = m_view->image();
     if (!image) return;
 
     QStringList listMimeFilter = KisImportExportManager::supportedMimeTypes(KisImportExportManager::Export);
 
     KoDialog dlg;
     QWidget *page = new QWidget(&dlg);
     dlg.setMainWidget(page);
     QBoxLayout *layout = new QVBoxLayout(page);
     dlg.setWindowTitle(i18n("Save layers to..."));
     QLabel *lbl = new QLabel(i18n("Choose the location where the layer will be saved to. The new file layer will then reference this location."));
     lbl->setWordWrap(true);
     layout->addWidget(lbl);
     KisFileNameRequester *urlRequester = new KisFileNameRequester(page);
     urlRequester->setMode(KoFileDialog::SaveFile);
     urlRequester->setMimeTypeFilters(listMimeFilter);
     urlRequester->setFileName(m_view->document()->url().toLocalFile());
     if (m_view->document()->url().isLocalFile()) {
         QFileInfo location = QFileInfo(m_view->document()->url().toLocalFile()).completeBaseName();
         location.setFile(location.dir(), location.completeBaseName() + "_" + source->name() + ".png");
         urlRequester->setFileName(location.absoluteFilePath());
     }
     else {
         const QFileInfo location = QFileInfo(QStandardPaths::writableLocation(QStandardPaths::HomeLocation));
         const QString proposedFileName = QDir(location.absoluteFilePath()).absoluteFilePath(source->name() + ".png");
         urlRequester->setFileName(proposedFileName);
     }
 
     // We don't want .kra files as file layers, Krita cannot handle the load.
     QStringList mimes = KisImportExportManager::supportedMimeTypes(KisImportExportManager::Export);
     int i = mimes.indexOf(KIS_MIME_TYPE);
     if (i >= 0 && i < mimes.size()) {
         mimes.removeAt(i);
     }
     urlRequester->setMimeTypeFilters(mimes);
 
     layout->addWidget(urlRequester);
     if (!dlg.exec()) return;
 
     QString path = urlRequester->fileName();
 
     if (path.isEmpty()) return;
 
     QFileInfo f(path);
 
     QString mimeType= KisMimeDatabase::mimeTypeForFile(f.fileName());
     if (mimeType.isEmpty()) {
         mimeType = "image/png";
     }
     QScopedPointer<KisDocument> doc(KisPart::instance()->createDocument());
 
     QRect bounds = source->exactBounds();
 
     KisImageSP dst = new KisImage(doc->createUndoStore(),
                                   image->width(),
                                   image->height(),
                                   image->projection()->compositionSourceColorSpace(),
                                   source->name());
     dst->setResolution(image->xRes(), image->yRes());
     doc->setFileBatchMode(false);
     doc->setCurrentImage(dst);
     KisNodeSP node = source->clone();
     dst->addNode(node);
     dst->initialRefreshGraph();
     dst->cropImage(bounds);
     dst->waitForDone();
 
     bool r = doc->exportDocumentSync(QUrl::fromLocalFile(path), mimeType.toLatin1());
     if (!r) {
 
         qWarning() << "Converting layer to file layer. path:"<< path << "gave errors" << doc->errorMessage();
     } else {
         QString basePath = QFileInfo(m_view->document()->url().toLocalFile()).absolutePath();
         QString relativePath = QDir(basePath).relativeFilePath(path);
         KisFileLayer *fileLayer = new KisFileLayer(image, basePath, relativePath, KisFileLayer::None, source->name(), OPACITY_OPAQUE_U8);
         fileLayer->setX(bounds.x());
         fileLayer->setY(bounds.y());
         KisNodeSP dstParent = source->parent();
         KisNodeSP dstAboveThis = source->prevSibling();
         m_commandsAdapter->beginMacro(kundo2_i18n("Convert to a file layer"));
         m_commandsAdapter->removeNode(source);
         m_commandsAdapter->addNode(fileLayer, dstParent, dstAboveThis);
         m_commandsAdapter->endMacro();
     }
     doc->closeUrl(false);
 }
 
 void KisLayerManager::adjustLayerPosition(KisNodeSP node, KisNodeSP activeNode, KisNodeSP &parent, KisNodeSP &above)
 {
     Q_ASSERT(activeNode);
 
     parent = activeNode;
     above = parent->lastChild();
 
     if (parent->inherits("KisGroupLayer") && parent->collapsed()) {
         above = parent;
         parent = parent->parent();
         return;
     }
 
     while (parent &&
            (!parent->allowAsChild(node) || parent->userLocked())) {
 
         above = parent;
         parent = parent->parent();
     }
 
     if (!parent) {
         warnKrita << "KisLayerManager::adjustLayerPosition:"
                   << "No node accepted newly created node";
 
         parent = m_view->image()->root();
         above = parent->lastChild();
     }
 }
 
 void KisLayerManager::addLayerCommon(KisNodeSP activeNode, KisNodeSP layer, bool updateImage, KisProcessingApplicator *applicator)
 {
     KisNodeSP parent;
     KisNodeSP above;
     adjustLayerPosition(layer, activeNode, parent, above);
 
     KisGroupLayer *group = dynamic_cast<KisGroupLayer*>(parent.data());
     const bool parentForceUpdate = group && !group->projectionIsValid();
     updateImage |= parentForceUpdate;
 
     m_commandsAdapter->addNodeAsync(layer, parent, above, updateImage, updateImage, applicator);
 }
 
 KisLayerSP KisLayerManager::addPaintLayer(KisNodeSP activeNode)
 {
     KisImageWSP image = m_view->image();
     KisLayerSP layer = new KisPaintLayer(image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8, image->colorSpace());
     addLayerCommon(activeNode, layer, false, 0);
 
     return layer;
 }
 
 KisNodeSP KisLayerManager::addGroupLayer(KisNodeSP activeNode)
 {
     KisImageWSP image = m_view->image();
     KisGroupLayerSP group = new KisGroupLayer(image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8);
     addLayerCommon(activeNode, group, false, 0);
     return group;
 }
 
 KisNodeSP KisLayerManager::addCloneLayer(KisNodeSP activeNode)
 {
     KisImageWSP image = m_view->image();
-    KisNodeSP node = new KisCloneLayer(activeLayer(), image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8);
-    addLayerCommon(activeNode, node, true, 0);
-    return node;
+    KisNodeList selection = m_view->nodeManager()->selectedNodes();
+
+    KisNodeSP node, clonedNode;
+    Q_FOREACH (node, selection) {
+        KisNodeSP clonedNode = new KisCloneLayer(qobject_cast<KisLayer*>(node.data()), image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8);
+        addLayerCommon(activeNode, clonedNode, true, 0 );
+    }
+
+    return clonedNode;
 }
 
 KisNodeSP KisLayerManager::addShapeLayer(KisNodeSP activeNode)
 {
     if (!m_view) return 0;
     if (!m_view->document()) return 0;
 
     KisImageWSP image = m_view->image();
     KisShapeLayerSP layer = new KisShapeLayer(m_view->document()->shapeController(), image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8);
 
     addLayerCommon(activeNode, layer, false, 0);
 
     return layer;
 }
 
 KisNodeSP KisLayerManager::addAdjustmentLayer(KisNodeSP activeNode)
 {
     KisImageWSP image = m_view->image();
 
     KisSelectionSP selection = m_view->selection();
 
     KisProcessingApplicator applicator(image, 0, KisProcessingApplicator::NONE,
                                        KisImageSignalVector() << ModifiedSignal,
                                        kundo2_i18n("Add Layer"));
 
 
     KisAdjustmentLayerSP adjl = addAdjustmentLayer(activeNode, QString(), 0, selection, &applicator);
 
     KisPaintDeviceSP previewDevice = new KisPaintDevice(*adjl->original());
 
     KisDlgAdjustmentLayer dlg(adjl, adjl.data(), previewDevice, image->nextLayerName(), i18n("New Filter Layer"), m_view, qApp->activeWindow());
     dlg.resize(dlg.minimumSizeHint());
 
     // ensure that the device may be free'd by the dialog
     // when it is not needed anymore
     previewDevice = 0;
 
     if (dlg.exec() != QDialog::Accepted || adjl->filter().isNull()) {
         // XXX: add messagebox warning if there's no filter set!
         applicator.cancel();
     } else {
         adjl->setName(dlg.layerName());
         applicator.end();
     }
 
     return adjl;
 }
 
 KisAdjustmentLayerSP KisLayerManager::addAdjustmentLayer(KisNodeSP activeNode, const QString & name,
                                                          KisFilterConfigurationSP  filter,
                                                          KisSelectionSP selection,
                                                          KisProcessingApplicator *applicator)
 {
     KisImageWSP image = m_view->image();
     KisAdjustmentLayerSP layer = new KisAdjustmentLayer(image, name, filter, selection);
     addLayerCommon(activeNode, layer, true, applicator);
 
     return layer;
 }
 
 KisNodeSP KisLayerManager::addGeneratorLayer(KisNodeSP activeNode)
 {
     KisImageWSP image = m_view->image();
     QColor currentForeground = m_view->canvasResourceProvider()->fgColor().toQColor();
 
 
     KisDlgGeneratorLayer dlg(image->nextLayerName(), m_view, m_view->mainWindow(), 0, 0);
     KisFilterConfigurationSP defaultConfig = dlg.configuration();
     defaultConfig->setProperty("color", currentForeground);
     dlg.setConfiguration(defaultConfig);
 
     dlg.resize(dlg.minimumSizeHint());
     if (dlg.exec() == QDialog::Accepted) {
         KisSelectionSP selection = m_view->selection();
         KisFilterConfigurationSP  generator = dlg.configuration();
         QString name = dlg.layerName();
 
         KisNodeSP node = new KisGeneratorLayer(image, name, generator, selection);
 
         addLayerCommon(activeNode, node, true, 0);
 
         return node;
     }
     return 0;
 }
 
 void KisLayerManager::flattenImage()
 {
     KisImageSP image = m_view->image();
 
     if (!m_view->blockUntilOperationsFinished(image)) return;
 
     if (image) {
         bool doIt = true;
 
         if (image->nHiddenLayers() > 0) {
             int answer = QMessageBox::warning(m_view->mainWindow(),
                                               i18nc("@title:window", "Flatten Image"),
                                               i18n("The image contains hidden layers that will be lost. Do you want to flatten the image?"),
                                               QMessageBox::Yes | QMessageBox::No,
                                               QMessageBox::No);
 
             if (answer != QMessageBox::Yes) {
                 doIt = false;
             }
         }
 
         if (doIt) {
             image->flatten(m_view->activeNode());
         }
     }
 }
 
 inline bool isSelectionMask(KisNodeSP node) {
     return dynamic_cast<KisSelectionMask*>(node.data());
 }
 
 bool tryMergeSelectionMasks(KisNodeSP currentNode, KisImageSP image)
 {
     bool result = false;
 
     KisNodeSP prevNode = currentNode->prevSibling();
     if (isSelectionMask(currentNode) &&
             prevNode && isSelectionMask(prevNode)) {
 
         QList<KisNodeSP> mergedNodes;
         mergedNodes.append(currentNode);
         mergedNodes.append(prevNode);
 
         image->mergeMultipleLayers(mergedNodes, currentNode);
 
         result = true;
     }
 
     return result;
 }
 
 bool tryFlattenGroupLayer(KisNodeSP currentNode, KisImageSP image)
 {
     bool result = false;
 
     if (currentNode->inherits("KisGroupLayer")) {
         KisGroupLayer *layer = qobject_cast<KisGroupLayer*>(currentNode.data());
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(layer, false);
 
         image->flattenLayer(layer);
         result = true;
     }
 
     return result;
 }
 
 void KisLayerManager::mergeLayer()
 {
     KisImageSP image = m_view->image();
     if (!image) return;
 
     KisLayerSP layer = activeLayer();
     if (!layer) return;
 
     if (!m_view->blockUntilOperationsFinished(image)) return;
 
     QList<KisNodeSP> selectedNodes = m_view->nodeManager()->selectedNodes();
     if (selectedNodes.size() > 1) {
         image->mergeMultipleLayers(selectedNodes, m_view->activeNode());
     }
 
     else if (tryMergeSelectionMasks(m_view->activeNode(), image)) {
         // already done!
     } else if (tryFlattenGroupLayer(m_view->activeNode(), image)) {
         // already done!
     } else {
 
         if (!layer->prevSibling()) return;
         KisLayer *prevLayer = qobject_cast<KisLayer*>(layer->prevSibling().data());
         if (!prevLayer) return;
         if (prevLayer->userLocked()) {
             m_view->showFloatingMessage(
                         i18nc("floating message in layer manager",
                               "Layer is locked "),
                         QIcon(), 2000, KisFloatingMessage::Low);
         }
 
         else if (layer->metaData()->isEmpty() && prevLayer->metaData()->isEmpty()) {
             image->mergeDown(layer, KisMetaData::MergeStrategyRegistry::instance()->get("Drop"));
         }
         else {
             const KisMetaData::MergeStrategy* strategy = KisMetaDataMergeStrategyChooserWidget::showDialog(m_view->mainWindow());
             if (!strategy) return;
             image->mergeDown(layer, strategy);
         }
     }
 
     m_view->updateGUI();
 }
 
 void KisLayerManager::flattenLayer()
 {
     KisImageSP image = m_view->image();
     if (!image) return;
 
     KisLayerSP layer = activeLayer();
     if (!layer) return;
 
     if (!m_view->blockUntilOperationsFinished(image)) return;
 
     convertNodeToPaintLayer(layer);
     m_view->updateGUI();
 }
 
 void KisLayerManager::rasterizeLayer()
 {
     KisImageSP image = m_view->image();
     if (!image) return;
 
     KisLayerSP layer = activeLayer();
     if (!layer) return;
 
     if (!m_view->blockUntilOperationsFinished(image)) return;
 
     KisPaintLayerSP paintLayer = new KisPaintLayer(image, layer->name(), layer->opacity());
     KisPainter gc(paintLayer->paintDevice());
     QRect rc = layer->projection()->exactBounds();
     gc.bitBlt(rc.topLeft(), layer->projection(), rc);
 
     m_commandsAdapter->beginMacro(kundo2_i18n("Rasterize Layer"));
     m_commandsAdapter->addNode(paintLayer.data(), layer->parent().data(), layer.data());
 
     int childCount = layer->childCount();
     for (int i = 0; i < childCount; i++) {
         m_commandsAdapter->moveNode(layer->firstChild(), paintLayer, paintLayer->lastChild());
     }
     m_commandsAdapter->removeNode(layer);
     m_commandsAdapter->endMacro();
     updateGUI();
 }
 
 
 void KisLayerManager::layersUpdated()
 {
     KisLayerSP layer = activeLayer();
     if (!layer) return;
 
     m_view->updateGUI();
 }
 
 void KisLayerManager::saveGroupLayers()
 {
     QStringList listMimeFilter = KisImportExportManager::supportedMimeTypes(KisImportExportManager::Export);
 
     KoDialog dlg;
     QWidget *page = new QWidget(&dlg);
     dlg.setMainWidget(page);
     QBoxLayout *layout = new QVBoxLayout(page);
 
     KisFileNameRequester *urlRequester = new KisFileNameRequester(page);
     urlRequester->setMode(KoFileDialog::SaveFile);
     if (m_view->document()->url().isLocalFile()) {
         urlRequester->setStartDir(QFileInfo(m_view->document()->url().toLocalFile()).absolutePath());
     }
     urlRequester->setMimeTypeFilters(listMimeFilter);
     urlRequester->setFileName(m_view->document()->url().toLocalFile());
     layout->addWidget(urlRequester);
 
     QCheckBox *chkInvisible = new QCheckBox(i18n("Convert Invisible Groups"), page);
     chkInvisible->setChecked(false);
     layout->addWidget(chkInvisible);
     QCheckBox *chkDepth = new QCheckBox(i18n("Export Only Toplevel Groups"), page);
     chkDepth->setChecked(true);
     layout->addWidget(chkDepth);
 
     if (!dlg.exec()) return;
 
     QString path = urlRequester->fileName();
 
     if (path.isEmpty()) return;
 
     QFileInfo f(path);
 
     QString mimeType= KisMimeDatabase::mimeTypeForFile(f.fileName(), false);
     if (mimeType.isEmpty()) {
         mimeType = "image/png";
     }
     QString extension = KisMimeDatabase::suffixesForMimeType(mimeType).first();
     QString basename = f.completeBaseName();
 
     KisImageSP image = m_view->image();
     if (!image) return;
 
     KisSaveGroupVisitor v(image, chkInvisible->isChecked(), chkDepth->isChecked(), f.absolutePath(), basename, extension, mimeType);
     image->rootLayer()->accept(v);
 
 }
 
 bool KisLayerManager::activeLayerHasSelection()
 {
     return (activeLayer()->selection() != 0);
 }
 
 KisNodeSP KisLayerManager::addFileLayer(KisNodeSP activeNode)
 {
     QString basePath;
     QUrl url = m_view->document()->url();
     if (url.isLocalFile()) {
         basePath = QFileInfo(url.toLocalFile()).absolutePath();
     }
     KisImageWSP image = m_view->image();
 
     KisDlgFileLayer dlg(basePath, image->nextLayerName(), m_view->mainWindow());
     dlg.resize(dlg.minimumSizeHint());
 
     if (dlg.exec() == QDialog::Accepted) {
         QString name = dlg.layerName();
         QString fileName = dlg.fileName();
 
         if(fileName.isEmpty()){
             QMessageBox::critical(m_view->mainWindow(), i18nc("@title:window", "Krita"), i18n("No file name specified"));
             return 0;
         }
 
         KisFileLayer::ScalingMethod scalingMethod = dlg.scaleToImageResolution();
         KisNodeSP node = new KisFileLayer(image, basePath, fileName, scalingMethod, name, OPACITY_OPAQUE_U8);
         addLayerCommon(activeNode, node, true, 0);
         return node;
     }
     return 0;
 }
 
 void updateLayerStyles(KisLayerSP layer, KisDlgLayerStyle *dlg)
 {
     KisSetLayerStyleCommand::updateLayerStyle(layer, dlg->style()->clone());
 }
 
 void KisLayerManager::layerStyle()
 {
     KisImageWSP image = m_view->image();
     if (!image) return;
 
     KisLayerSP layer = activeLayer();
     if (!layer) return;
 
     if (!m_view->blockUntilOperationsFinished(image)) return;
 
     KisPSDLayerStyleSP oldStyle;
     if (layer->layerStyle()) {
         oldStyle = layer->layerStyle()->clone();
     }
     else {
         oldStyle = toQShared(new KisPSDLayerStyle());
     }
 
     KisDlgLayerStyle dlg(oldStyle->clone(), m_view->canvasResourceProvider());
 
     std::function<void ()> updateCall(std::bind(updateLayerStyles, layer, &dlg));
     SignalToFunctionProxy proxy(updateCall);
     connect(&dlg, SIGNAL(configChanged()), &proxy, SLOT(start()));
 
     if (dlg.exec() == QDialog::Accepted) {
         KisPSDLayerStyleSP newStyle = dlg.style();
 
         KUndo2CommandSP command = toQShared(
                     new KisSetLayerStyleCommand(layer, oldStyle, newStyle));
 
         image->postExecutionUndoAdapter()->addCommand(command);
     }
 }
 
diff --git a/libs/ui/kis_painting_assistant.cc b/libs/ui/kis_painting_assistant.cc
index 84b7ea6224..a093e681c7 100644
--- a/libs/ui/kis_painting_assistant.cc
+++ b/libs/ui/kis_painting_assistant.cc
@@ -1,896 +1,912 @@
 /*
  *  Copyright (c) 2008,2011 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2010 Geoffry Song <goffrie@gmail.com>
  *  Copyright (c) 2017 Scott Petrovic <scottpetrovic@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include <QXmlStreamReader>
 #include "kis_painting_assistant.h"
 #include "kis_coordinates_converter.h"
 #include "kis_debug.h"
 #include "kis_dom_utils.h"
 #include <kis_canvas2.h>
 #include "kis_tool.h"
 #include "kis_config.h"
 
 #include <KoStore.h>
 
 #include <QGlobalStatic>
 #include <QPen>
 #include <QPainter>
 #include <QPixmapCache>
 #include <QDomElement>
 #include <QDomDocument>
 
 Q_GLOBAL_STATIC(KisPaintingAssistantFactoryRegistry, s_instance)
 
 struct KisPaintingAssistantHandle::Private {
     QList<KisPaintingAssistant*> assistants;
     char handle_type;
 };
 
 KisPaintingAssistantHandle::KisPaintingAssistantHandle(double x, double y) : QPointF(x, y), d(new Private)
 {
 }
 
 KisPaintingAssistantHandle::KisPaintingAssistantHandle(QPointF p) : QPointF(p), d(new Private)
 {
 }
 
 KisPaintingAssistantHandle::KisPaintingAssistantHandle(const KisPaintingAssistantHandle& rhs)
     : QPointF(rhs)
     , KisShared()
     , d(new Private)
 {
     dbgUI << "KisPaintingAssistantHandle ctor";
 }
 
 KisPaintingAssistantHandle& KisPaintingAssistantHandle::operator=(const QPointF &  pt)
 {
     setX(pt.x());
     setY(pt.y());
     return *this;
 }
 
 void KisPaintingAssistantHandle::setType(char type)
 {
     d->handle_type = type;
 }
 
 char KisPaintingAssistantHandle::handleType() const
 {
     return d->handle_type;
 }
 
 KisPaintingAssistantHandle::~KisPaintingAssistantHandle()
 {
     Q_ASSERT(d->assistants.empty());
     delete d;
 }
 
 void KisPaintingAssistantHandle::registerAssistant(KisPaintingAssistant* assistant)
 {
     Q_ASSERT(!d->assistants.contains(assistant));
     d->assistants.append(assistant);
 }
 
 void KisPaintingAssistantHandle::unregisterAssistant(KisPaintingAssistant* assistant)
 {
     d->assistants.removeOne(assistant);
     Q_ASSERT(!d->assistants.contains(assistant));
 }
 
 bool KisPaintingAssistantHandle::containsAssistant(KisPaintingAssistant* assistant) const
 {
     return d->assistants.contains(assistant);
 }
 
 void KisPaintingAssistantHandle::mergeWith(KisPaintingAssistantHandleSP handle)
 {
     if(this->handleType()== HandleType::NORMAL || handle.data()->handleType()== HandleType::SIDE) {
         return;
     }
 
 
     Q_FOREACH (KisPaintingAssistant* assistant, handle->d->assistants) {
         if (!assistant->handles().contains(this)) {
             assistant->replaceHandle(handle, this);
         }
     }
 }
 
 void KisPaintingAssistantHandle::uncache()
 {
     Q_FOREACH (KisPaintingAssistant* assistant, d->assistants) {
         assistant->uncache();
     }
 }
 
 struct KisPaintingAssistant::Private {
     Private();
     explicit Private(const Private &rhs);
     KisPaintingAssistantHandleSP reuseOrCreateHandle(QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap, KisPaintingAssistantHandleSP origHandle, KisPaintingAssistant *q, bool registerAssistant = true);
     QList<KisPaintingAssistantHandleSP> handles, sideHandles;
     KisPaintingAssistantHandleSP topLeft, bottomLeft, topRight, bottomRight, topMiddle, bottomMiddle, rightMiddle, leftMiddle;
 
     // share everything except handles between the clones
     struct SharedData {
         QString id;
         QString name;
         bool isSnappingActive;
         bool outlineVisible;
         KisCanvas2* m_canvas = 0;
 
         QPixmapCache::Key cached;
         QRect cachedRect; // relative to boundingRect().topLeft()
 
         struct TranslationInvariantTransform {
             qreal m11, m12, m21, m22;
             TranslationInvariantTransform() { }
             TranslationInvariantTransform(const QTransform& t) : m11(t.m11()), m12(t.m12()), m21(t.m21()), m22(t.m22()) { }
             bool operator==(const TranslationInvariantTransform& b) {
                 return m11 == b.m11 && m12 == b.m12 && m21 == b.m21 && m22 == b.m22;
             }
         } cachedTransform;
 
         QColor assistantGlobalColorCache = QColor(Qt::red);     // color to paint with if a custom color is not set
 
         bool useCustomColor = false;
         QColor assistantCustomColor = KisConfig(true).defaultAssistantsColor();
     };
 
     QSharedPointer<SharedData> s;
 };
 
 KisPaintingAssistant::Private::Private()
     : s(new SharedData)
 {
 }
 
 KisPaintingAssistant::Private::Private(const Private &rhs)
     : s(rhs.s)
 {
 }
 
 KisPaintingAssistantHandleSP KisPaintingAssistant::Private::reuseOrCreateHandle(QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap, KisPaintingAssistantHandleSP origHandle, KisPaintingAssistant *q, bool registerAssistant)
 {
     KisPaintingAssistantHandleSP mappedHandle = handleMap.value(origHandle);
     if (!mappedHandle) {
         if (origHandle) {
             dbgUI << "handle not found in the map, creating a new one...";
             mappedHandle = KisPaintingAssistantHandleSP(new KisPaintingAssistantHandle(*origHandle));
             dbgUI << "done";
             mappedHandle->setType(origHandle->handleType());
             handleMap.insert(origHandle, mappedHandle);
         } else {
             dbgUI << "orig handle is null, not doing anything";
             mappedHandle = KisPaintingAssistantHandleSP();
         }
     }
     if (mappedHandle && registerAssistant) {
         mappedHandle->registerAssistant(q);
     }
     return mappedHandle;
 }
 
 bool KisPaintingAssistant::useCustomColor()
 {
     return d->s->useCustomColor;
 }
 
 void KisPaintingAssistant::setUseCustomColor(bool useCustomColor)
 {
     d->s->useCustomColor = useCustomColor;
 }
 
 void KisPaintingAssistant::setAssistantCustomColor(QColor color)
 {
     d->s->assistantCustomColor = color;
 }
 
 QColor KisPaintingAssistant::assistantCustomColor()
 {
     return d->s->assistantCustomColor;
 }
 
 void KisPaintingAssistant::setAssistantGlobalColorCache(const QColor &color)
 {
     d->s->assistantGlobalColorCache = color;
 }
 
 QColor KisPaintingAssistant::effectiveAssistantColor() const
 {
     return d->s->useCustomColor ? d->s->assistantCustomColor : d->s->assistantGlobalColorCache;
 }
 
 KisPaintingAssistant::KisPaintingAssistant(const QString& id, const QString& name) : d(new Private)
 {
     d->s->id = id;
     d->s->name = name;
     d->s->isSnappingActive = true;
     d->s->outlineVisible = true;
 }
 
 KisPaintingAssistant::KisPaintingAssistant(const KisPaintingAssistant &rhs, QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap)
     : d(new Private(*(rhs.d)))
 {
     dbgUI << "creating handles...";
     Q_FOREACH (const KisPaintingAssistantHandleSP origHandle, rhs.d->handles) {
         d->handles << d->reuseOrCreateHandle(handleMap, origHandle, this);
     }
     Q_FOREACH (const KisPaintingAssistantHandleSP origHandle, rhs.d->sideHandles) {
         d->sideHandles << d->reuseOrCreateHandle(handleMap, origHandle, this);
     }
 #define _REUSE_H(name) d->name = d->reuseOrCreateHandle(handleMap, rhs.d->name, this, /* registerAssistant = */ false)
     _REUSE_H(topLeft);
     _REUSE_H(bottomLeft);
     _REUSE_H(topRight);
     _REUSE_H(bottomRight);
     _REUSE_H(topMiddle);
     _REUSE_H(bottomMiddle);
     _REUSE_H(rightMiddle);
     _REUSE_H(leftMiddle);
 #undef _REUSE_H
     dbgUI << "done";
 }
 
 bool KisPaintingAssistant::isSnappingActive() const
 {
     return d->s->isSnappingActive;
 }
 
 void KisPaintingAssistant::setSnappingActive(bool set)
 {
     d->s->isSnappingActive = set;
 }
 
 
 void KisPaintingAssistant::drawPath(QPainter& painter, const QPainterPath &path, bool isSnappingOn)
 {
 
     QColor paintingColor = effectiveAssistantColor();
 
     if (!isSnappingOn) {
         paintingColor.setAlpha(0.2 * paintingColor.alpha());
     }
 
     painter.save();
     QPen pen_a(paintingColor, 2);
     pen_a.setCosmetic(true);
     painter.setPen(pen_a);
     painter.drawPath(path);
     painter.restore();
 }
 
 void KisPaintingAssistant::drawPreview(QPainter& painter, const QPainterPath &path)
 {
     painter.save();
     QPen pen_a(effectiveAssistantColor(), 1);
     pen_a.setStyle(Qt::SolidLine);
     pen_a.setCosmetic(true);
     painter.setPen(pen_a);
     painter.drawPath(path);
     painter.restore();
 }
 
 void KisPaintingAssistant::initHandles(QList<KisPaintingAssistantHandleSP> _handles)
 {
     Q_ASSERT(d->handles.isEmpty());
     d->handles = _handles;
     Q_FOREACH (KisPaintingAssistantHandleSP handle, _handles) {
         handle->registerAssistant(this);
     }
 }
 
 KisPaintingAssistant::~KisPaintingAssistant()
 {
     Q_FOREACH (KisPaintingAssistantHandleSP handle, d->handles) {
         handle->unregisterAssistant(this);
     }
     if(!d->sideHandles.isEmpty()) {
         Q_FOREACH (KisPaintingAssistantHandleSP handle, d->sideHandles) {
             handle->unregisterAssistant(this);
         }
     }
     delete d;
 }
 
 const QString& KisPaintingAssistant::id() const
 {
     return d->s->id;
 }
 
 const QString& KisPaintingAssistant::name() const
 {
     return d->s->name;
 }
 
 void KisPaintingAssistant::replaceHandle(KisPaintingAssistantHandleSP _handle, KisPaintingAssistantHandleSP _with)
 {
     Q_ASSERT(d->handles.contains(_handle));
     d->handles.replace(d->handles.indexOf(_handle), _with);
     Q_ASSERT(!d->handles.contains(_handle));
     _handle->unregisterAssistant(this);
     _with->registerAssistant(this);
 }
 
 void KisPaintingAssistant::addHandle(KisPaintingAssistantHandleSP handle, HandleType type)
 {
     Q_ASSERT(!d->handles.contains(handle));
     if (HandleType::SIDE == type) {
         d->sideHandles.append(handle);
     } else {
         d->handles.append(handle);
     }
 
     handle->registerAssistant(this);
     handle.data()->setType(type);
 }
 
+QPointF KisPaintingAssistant::viewportConstrainedEditorPosition(const KisCoordinatesConverter* converter, const QSize editorSize)
+{
+    QPointF editorDocumentPos = getEditorPosition();
+    QPointF editorWidgetPos = converter->documentToWidgetTransform().map(editorDocumentPos);
+    QSizeF canvasSize = converter->getCanvasWidgetSize();
+    const int padding = 16;
+
+    editorWidgetPos.rx() = qBound(0.0,
+                                  editorWidgetPos.x(),
+                                  canvasSize.width() - (editorSize.width() + padding));
+    editorWidgetPos.ry() = qBound(0.0,
+                                  editorWidgetPos.y(),
+                                  canvasSize.height() - (editorSize.height() + padding));
+
+    return converter->widgetToDocument(editorWidgetPos);
+}
 
 void KisPaintingAssistant::drawAssistant(QPainter& gc, const QRectF& updateRect, const KisCoordinatesConverter* converter, bool useCache, KisCanvas2* canvas, bool assistantVisible, bool previewVisible)
 {
     Q_UNUSED(updateRect);
 
     Q_UNUSED(previewVisible);
 
     findPerspectiveAssistantHandleLocation();
 
     if (!useCache) {
         gc.save();
         drawCache(gc, converter, assistantVisible);
         gc.restore();
         return;
     }
 
     const QRect bound = boundingRect();
     if (bound.isEmpty()) {
         return;
     }
 
     const QTransform transform = converter->documentToWidgetTransform();
     const QRect widgetBound = transform.mapRect(bound);
 
     const QRect paintRect = transform.mapRect(bound).intersected(gc.viewport());
     if (paintRect.isEmpty()) return;
 
     QPixmap cached;
     bool found = QPixmapCache::find(d->s->cached, &cached);
 
     if (!(found &&
           d->s->cachedTransform == transform &&
           d->s->cachedRect.translated(widgetBound.topLeft()).contains(paintRect))) {
 
         const QRect cacheRect = gc.viewport().adjusted(-100, -100, 100, 100).intersected(widgetBound);
         Q_ASSERT(!cacheRect.isEmpty());
 
         if (cached.isNull() || cached.size() != cacheRect.size()) {
             cached = QPixmap(cacheRect.size());
         }
 
         cached.fill(Qt::transparent);
         QPainter painter(&cached);
         painter.setRenderHint(QPainter::Antialiasing);
         painter.setWindow(cacheRect);
         drawCache(painter, converter, assistantVisible);
         painter.end();
         d->s->cachedTransform = transform;
         d->s->cachedRect = cacheRect.translated(-widgetBound.topLeft());
         d->s->cached = QPixmapCache::insert(cached);
     }
 
     gc.drawPixmap(paintRect, cached, paintRect.translated(-widgetBound.topLeft() - d->s->cachedRect.topLeft()));
 
 
     if (canvas) {
         d->s->m_canvas = canvas;
     }
 }
 
 void KisPaintingAssistant::uncache()
 {
     d->s->cached = QPixmapCache::Key();
 }
 
 QRect KisPaintingAssistant::boundingRect() const
 {
     QRectF r;
     Q_FOREACH (KisPaintingAssistantHandleSP h, handles()) {
         r = r.united(QRectF(*h, QSizeF(1,1)));
     }
     return r.adjusted(-2, -2, 2, 2).toAlignedRect();
 }
 
 bool KisPaintingAssistant::isAssistantComplete() const
 {
     return true;
 }
 
 QByteArray KisPaintingAssistant::saveXml(QMap<KisPaintingAssistantHandleSP, int> &handleMap)
 {
     QByteArray data;
     QXmlStreamWriter xml(&data);
     xml.writeStartDocument();
     xml.writeStartElement("assistant");
     xml.writeAttribute("type",d->s->id);
     xml.writeAttribute("active", QString::number(d->s->isSnappingActive));
     xml.writeAttribute("useCustomColor", QString::number(d->s->useCustomColor));
     xml.writeAttribute("customColor",  KisDomUtils::qColorToQString(d->s->assistantCustomColor));
 
 
 
     saveCustomXml(&xml); // if any specific assistants have custom XML data to save to
 
     // write individual handle data
     xml.writeStartElement("handles");
     Q_FOREACH (const KisPaintingAssistantHandleSP handle, d->handles) {
         int id = handleMap.size();
         if (!handleMap.contains(handle)){
             handleMap.insert(handle, id);
         }
         id = handleMap.value(handle);
         xml.writeStartElement("handle");
         xml.writeAttribute("id", QString::number(id));
         xml.writeAttribute("x", QString::number(double(handle->x()), 'f', 3));
         xml.writeAttribute("y", QString::number(double(handle->y()), 'f', 3));
         xml.writeEndElement();
     }
     xml.writeEndElement();
     xml.writeEndElement();
     xml.writeEndDocument();
     return data;
 }
 
 void KisPaintingAssistant::saveCustomXml(QXmlStreamWriter* xml)
 {
     Q_UNUSED(xml);
 }
 
 void KisPaintingAssistant::loadXml(KoStore* store, QMap<int, KisPaintingAssistantHandleSP> &handleMap, QString path)
 {
     int id = 0;
     double x = 0.0, y = 0.0;
     store->open(path);
     QByteArray data = store->read(store->size());
     QXmlStreamReader xml(data);
     while (!xml.atEnd()) {
         switch (xml.readNext()) {
         case QXmlStreamReader::StartElement:
             if (xml.name() == "assistant") {
 
                 QStringRef active = xml.attributes().value("active");
                 setSnappingActive( (active != "0")  );
 
                 // load custom shared assistant properties
                 if ( xml.attributes().hasAttribute("useCustomColor")) {
                     QStringRef useCustomColor = xml.attributes().value("useCustomColor");
 
                     bool usingColor = false;
                     if (useCustomColor.toString() == "1") {
                         usingColor = true;
                     }
 
 
                     setUseCustomColor(usingColor);
                 }
 
                 if ( xml.attributes().hasAttribute("customColor")) {
                     QStringRef customColor = xml.attributes().value("customColor");
                     setAssistantCustomColor( KisDomUtils::qStringToQColor(customColor.toString()) );
 
                 }
 
             }
 
             loadCustomXml(&xml);
 
             if (xml.name() == "handle") {
                 QString strId = xml.attributes().value("id").toString(),
                         strX = xml.attributes().value("x").toString(),
                         strY = xml.attributes().value("y").toString();
                 if (!strId.isEmpty() && !strX.isEmpty() && !strY.isEmpty()) {
                     id = strId.toInt();
                     x = strX.toDouble();
                     y = strY.toDouble();
                     if (!handleMap.contains(id)) {
                         handleMap.insert(id, new KisPaintingAssistantHandle(x, y));
                     }
                 }
                 addHandle(handleMap.value(id), HandleType::NORMAL);
             }
             break;
         default:
             break;
         }
     }
     store->close();
 }
 
 bool KisPaintingAssistant::loadCustomXml(QXmlStreamReader* xml)
 {
     Q_UNUSED(xml);
     return true;
 }
 
 void KisPaintingAssistant::saveXmlList(QDomDocument& doc, QDomElement& assistantsElement,int count)
 {
     if (d->s->id == "ellipse"){
         QDomElement assistantElement = doc.createElement("assistant");
         assistantElement.setAttribute("type", "ellipse");
         assistantElement.setAttribute("filename", QString("ellipse%1.assistant").arg(count));
         assistantsElement.appendChild(assistantElement);
     }
     else if (d->s->id == "spline"){
         QDomElement assistantElement = doc.createElement("assistant");
         assistantElement.setAttribute("type", "spline");
         assistantElement.setAttribute("filename", QString("spline%1.assistant").arg(count));
         assistantsElement.appendChild(assistantElement);
     }
     else if (d->s->id == "perspective"){
         QDomElement assistantElement = doc.createElement("assistant");
         assistantElement.setAttribute("type", "perspective");
         assistantElement.setAttribute("filename", QString("perspective%1.assistant").arg(count));
         assistantsElement.appendChild(assistantElement);
     }
     else if (d->s->id == "vanishing point"){
         QDomElement assistantElement = doc.createElement("assistant");
         assistantElement.setAttribute("type", "vanishing point");
         assistantElement.setAttribute("filename", QString("vanishing point%1.assistant").arg(count));
         assistantsElement.appendChild(assistantElement);
     }
     else if (d->s->id == "infinite ruler"){
         QDomElement assistantElement = doc.createElement("assistant");
         assistantElement.setAttribute("type", "infinite ruler");
         assistantElement.setAttribute("filename", QString("infinite ruler%1.assistant").arg(count));
         assistantsElement.appendChild(assistantElement);
     }
     else if (d->s->id == "parallel ruler"){
         QDomElement assistantElement = doc.createElement("assistant");
         assistantElement.setAttribute("type", "parallel ruler");
         assistantElement.setAttribute("filename", QString("parallel ruler%1.assistant").arg(count));
         assistantsElement.appendChild(assistantElement);
     }
     else if (d->s->id == "concentric ellipse"){
         QDomElement assistantElement = doc.createElement("assistant");
         assistantElement.setAttribute("type", "concentric ellipse");
         assistantElement.setAttribute("filename", QString("concentric ellipse%1.assistant").arg(count));
         assistantsElement.appendChild(assistantElement);
     }
     else if (d->s->id == "fisheye-point"){
         QDomElement assistantElement = doc.createElement("assistant");
         assistantElement.setAttribute("type", "fisheye-point");
         assistantElement.setAttribute("filename", QString("fisheye-point%1.assistant").arg(count));
         assistantsElement.appendChild(assistantElement);
     }
     else if (d->s->id == "ruler"){
         QDomElement assistantElement = doc.createElement("assistant");
         assistantElement.setAttribute("type", "ruler");
         assistantElement.setAttribute("filename", QString("ruler%1.assistant").arg(count));
         assistantsElement.appendChild(assistantElement);
     }
 }
 
 void KisPaintingAssistant::findPerspectiveAssistantHandleLocation() {
     QList<KisPaintingAssistantHandleSP> hHandlesList;
     QList<KisPaintingAssistantHandleSP> vHandlesList;
     uint vHole = 0,hHole = 0;
     KisPaintingAssistantHandleSP oppHandle;
     if (d->handles.size() == 4 && d->s->id == "perspective") {
         //get the handle opposite to the first handle
         oppHandle = oppHandleOne();
         //Sorting handles into two list, X sorted and Y sorted into hHandlesList and vHandlesList respectively.
         Q_FOREACH (const KisPaintingAssistantHandleSP handle,d->handles) {
             hHandlesList.append(handle);
             hHole = hHandlesList.size() - 1;
             vHandlesList.append(handle);
             vHole = vHandlesList.size() - 1;
             /*
              sort handles on the basis of X-coordinate
              */
             while(hHole > 0 && hHandlesList.at(hHole -1).data()->x() > handle.data()->x()) {
                 hHandlesList.swap(hHole-1, hHole);
                 hHole = hHole - 1;
             }
             /*
              sort handles on the basis of Y-coordinate
              */
             while(vHole > 0 && vHandlesList.at(vHole -1).data()->y() > handle.data()->y()) {
                 vHandlesList.swap(vHole-1, vHole);
                 vHole = vHole - 1;
             }
         }
 
         /*
          give the handles their respective positions
          */
         if(vHandlesList.at(0).data()->x() > vHandlesList.at(1).data()->x()) {
             d->topLeft = vHandlesList.at(1);
             d->topRight= vHandlesList.at(0);
         }
         else {
             d->topLeft = vHandlesList.at(0);
             d->topRight = vHandlesList.at(1);
         }
         if(vHandlesList.at(2).data()->x() > vHandlesList.at(3).data()->x()) {
             d->bottomLeft = vHandlesList.at(3);
             d->bottomRight = vHandlesList.at(2);
         }
         else {
             d->bottomLeft= vHandlesList.at(2);
             d->bottomRight = vHandlesList.at(3);
         }
 
         /*
          find if the handles that should be opposite are actually oppositely positioned
          */
         if (( (d->topLeft == d->handles.at(0).data() && d->bottomRight == oppHandle) ||
               (d->topLeft == oppHandle && d->bottomRight == d->handles.at(0).data()) ||
               (d->topRight == d->handles.at(0).data() && d->bottomLeft == oppHandle) ||
               (d->topRight == oppHandle && d->bottomLeft == d->handles.at(0).data()) ) )
         {}
         else {
             if(hHandlesList.at(0).data()->y() > hHandlesList.at(1).data()->y()) {
                 d->topLeft = hHandlesList.at(1);
                 d->bottomLeft= hHandlesList.at(0);
             }
             else {
                 d->topLeft = hHandlesList.at(0);
                 d->bottomLeft = hHandlesList.at(1);
             }
             if(hHandlesList.at(2).data()->y() > hHandlesList.at(3).data()->y()) {
                 d->topRight = hHandlesList.at(3);
                 d->bottomRight = hHandlesList.at(2);
             }
             else {
                 d->topRight= hHandlesList.at(2);
                 d->bottomRight = hHandlesList.at(3);
             }
 
         }
         /*
          Setting the middle handles as needed
          */
         if(!d->bottomMiddle && !d->topMiddle && !d->leftMiddle && !d->rightMiddle) {
             d->bottomMiddle = new KisPaintingAssistantHandle((d->bottomLeft.data()->x() + d->bottomRight.data()->x())*0.5,
                                                              (d->bottomLeft.data()->y() + d->bottomRight.data()->y())*0.5);
             d->topMiddle = new KisPaintingAssistantHandle((d->topLeft.data()->x() + d->topRight.data()->x())*0.5,
                                                           (d->topLeft.data()->y() + d->topRight.data()->y())*0.5);
             d->rightMiddle= new KisPaintingAssistantHandle((d->topRight.data()->x() + d->bottomRight.data()->x())*0.5,
                                                            (d->topRight.data()->y() + d->bottomRight.data()->y())*0.5);
             d->leftMiddle= new KisPaintingAssistantHandle((d->bottomLeft.data()->x() + d->topLeft.data()->x())*0.5,
                                                           (d->bottomLeft.data()->y() + d->topLeft.data()->y())*0.5);
             addHandle(d->rightMiddle.data(), HandleType::SIDE);
             addHandle(d->leftMiddle.data(), HandleType::SIDE);
             addHandle(d->bottomMiddle.data(), HandleType::SIDE);
             addHandle(d->topMiddle.data(), HandleType::SIDE);
         }
         else
         {
             d->bottomMiddle.data()->operator =(QPointF((d->bottomLeft.data()->x() + d->bottomRight.data()->x())*0.5,
                                                        (d->bottomLeft.data()->y() + d->bottomRight.data()->y())*0.5));
             d->topMiddle.data()->operator =(QPointF((d->topLeft.data()->x() + d->topRight.data()->x())*0.5,
                                                     (d->topLeft.data()->y() + d->topRight.data()->y())*0.5));
             d->rightMiddle.data()->operator =(QPointF((d->topRight.data()->x() + d->bottomRight.data()->x())*0.5,
                                                       (d->topRight.data()->y() + d->bottomRight.data()->y())*0.5));
             d->leftMiddle.data()->operator =(QPointF((d->bottomLeft.data()->x() + d->topLeft.data()->x())*0.5,
                                                      (d->bottomLeft.data()->y() + d->topLeft.data()->y())*0.5));
         }
 
     }
 }
 
 KisPaintingAssistantHandleSP KisPaintingAssistant::oppHandleOne()
 {
     QPointF intersection(0,0);
     if((QLineF(d->handles.at(0).data()->toPoint(),d->handles.at(1).data()->toPoint()).intersect(QLineF(d->handles.at(2).data()->toPoint(),d->handles.at(3).data()->toPoint()), &intersection) != QLineF::NoIntersection)
             && (QLineF(d->handles.at(0).data()->toPoint(),d->handles.at(1).data()->toPoint()).intersect(QLineF(d->handles.at(2).data()->toPoint(),d->handles.at(3).data()->toPoint()), &intersection) != QLineF::UnboundedIntersection))
     {
         return d->handles.at(1);
     }
     else if((QLineF(d->handles.at(0).data()->toPoint(),d->handles.at(2).data()->toPoint()).intersect(QLineF(d->handles.at(1).data()->toPoint(),d->handles.at(3).data()->toPoint()), &intersection) != QLineF::NoIntersection)
             && (QLineF(d->handles.at(0).data()->toPoint(),d->handles.at(2).data()->toPoint()).intersect(QLineF(d->handles.at(1).data()->toPoint(),d->handles.at(3).data()->toPoint()), &intersection) != QLineF::UnboundedIntersection))
     {
         return d->handles.at(2);
     }
     else
     {
         return d->handles.at(3);
     }
 }
 
 KisPaintingAssistantHandleSP KisPaintingAssistant::topLeft()
 {
     return d->topLeft;
 }
 
 const KisPaintingAssistantHandleSP KisPaintingAssistant::topLeft() const
 {
     return d->topLeft;
 }
 
 KisPaintingAssistantHandleSP KisPaintingAssistant::bottomLeft()
 {
     return d->bottomLeft;
 }
 
 const KisPaintingAssistantHandleSP KisPaintingAssistant::bottomLeft() const
 {
     return d->bottomLeft;
 }
 
 KisPaintingAssistantHandleSP KisPaintingAssistant::topRight()
 {
     return d->topRight;
 }
 
 const KisPaintingAssistantHandleSP KisPaintingAssistant::topRight() const
 {
     return d->topRight;
 }
 
 KisPaintingAssistantHandleSP KisPaintingAssistant::bottomRight()
 {
     return d->bottomRight;
 }
 
 const KisPaintingAssistantHandleSP KisPaintingAssistant::bottomRight() const
 {
     return d->bottomRight;
 }
 
 KisPaintingAssistantHandleSP KisPaintingAssistant::topMiddle()
 {
     return d->topMiddle;
 }
 
 const KisPaintingAssistantHandleSP KisPaintingAssistant::topMiddle() const
 {
     return d->topMiddle;
 }
 
 KisPaintingAssistantHandleSP KisPaintingAssistant::bottomMiddle()
 {
     return d->bottomMiddle;
 }
 
 const KisPaintingAssistantHandleSP KisPaintingAssistant::bottomMiddle() const
 {
     return d->bottomMiddle;
 }
 
 KisPaintingAssistantHandleSP KisPaintingAssistant::rightMiddle()
 {
     return d->rightMiddle;
 }
 
 const KisPaintingAssistantHandleSP KisPaintingAssistant::rightMiddle() const
 {
     return d->rightMiddle;
 }
 
 KisPaintingAssistantHandleSP KisPaintingAssistant::leftMiddle()
 {
     return d->leftMiddle;
 }
 
 const KisPaintingAssistantHandleSP KisPaintingAssistant::leftMiddle() const
 {
     return d->leftMiddle;
 }
 
 const QList<KisPaintingAssistantHandleSP>& KisPaintingAssistant::handles() const
 {
     return d->handles;
 }
 
 QList<KisPaintingAssistantHandleSP> KisPaintingAssistant::handles()
 {
     return d->handles;
 }
 
 const QList<KisPaintingAssistantHandleSP>& KisPaintingAssistant::sideHandles() const
 {
     return d->sideHandles;
 }
 
 QList<KisPaintingAssistantHandleSP> KisPaintingAssistant::sideHandles()
 {
     return d->sideHandles;
 }
 
 
 
 bool KisPaintingAssistant::areTwoPointsClose(const QPointF& pointOne, const QPointF& pointTwo)
 {
     int m_handleSize = 16;
 
     QRectF handlerect(pointTwo - QPointF(m_handleSize * 0.5, m_handleSize * 0.5), QSizeF(m_handleSize, m_handleSize));
     return handlerect.contains(pointOne);
 }
 
 KisPaintingAssistantHandleSP KisPaintingAssistant::closestCornerHandleFromPoint(QPointF point)
 {
     if (!d->s->m_canvas) {
         return 0;
     }
 
 
     if (areTwoPointsClose(point, pixelToView(topLeft()->toPoint()))) {
         return topLeft();
     } else if (areTwoPointsClose(point, pixelToView(topRight()->toPoint()))) {
         return topRight();
     } else if (areTwoPointsClose(point, pixelToView(bottomLeft()->toPoint()))) {
         return bottomLeft();
     } else if (areTwoPointsClose(point, pixelToView(bottomRight()->toPoint()))) {
         return bottomRight();
     }
     return 0;
 }
 
 
 QPointF KisPaintingAssistant::pixelToView(const QPoint pixelCoords) const
 {
     QPointF documentCoord = d->s->m_canvas->image()->pixelToDocument(pixelCoords);
     return d->s->m_canvas->viewConverter()->documentToView(documentCoord);
 }
 
 double KisPaintingAssistant::norm2(const QPointF& p)
 {
     return p.x() * p.x() + p.y() * p.y();
 }
 
 QList<KisPaintingAssistantSP> KisPaintingAssistant::cloneAssistantList(const QList<KisPaintingAssistantSP> &list)
 {
     QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> handleMap;
     QList<KisPaintingAssistantSP> clonedList;
     for (auto i = list.begin(); i != list.end(); ++i) {
         clonedList << (*i)->clone(handleMap);
     }
     return clonedList;
 }
 
 
 
 /*
  * KisPaintingAssistantFactory classes
 */
 
 KisPaintingAssistantFactory::KisPaintingAssistantFactory()
 {
 }
 
 KisPaintingAssistantFactory::~KisPaintingAssistantFactory()
 {
 }
 
 KisPaintingAssistantFactoryRegistry::KisPaintingAssistantFactoryRegistry()
 {
 }
 
 KisPaintingAssistantFactoryRegistry::~KisPaintingAssistantFactoryRegistry()
 {
     Q_FOREACH (const QString &id, keys()) {
         delete get(id);
     }
     dbgRegistry << "deleting KisPaintingAssistantFactoryRegistry ";
 }
 
 KisPaintingAssistantFactoryRegistry* KisPaintingAssistantFactoryRegistry::instance()
 {
     return s_instance;
 }
 
diff --git a/libs/ui/kis_painting_assistant.h b/libs/ui/kis_painting_assistant.h
index 741194f449..cd8e54b291 100644
--- a/libs/ui/kis_painting_assistant.h
+++ b/libs/ui/kis_painting_assistant.h
@@ -1,242 +1,238 @@
 /*
  *  Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
  *  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.
  */
 
 #ifndef _KIS_PAINTING_ASSISTANT_H_
 #define _KIS_PAINTING_ASSISTANT_H_
 
 #include <QString>
 #include <QPointF>
 #include <QRect>
 #include <QFile>
 #include <QObject>
 #include <QColor>
 #include <QXmlStreamWriter>
 #include <QMap>
 
 #include <kritaui_export.h>
 #include <kis_shared.h>
 #include <kis_types.h>
 
 class QPainter;
 class QRect;
 class QRectF;
 class KoStore;
 class KisCoordinatesConverter;
 class KisCanvas2;
 class QDomDocument;
 class QDomElement;
 
 #include <kis_shared_ptr.h>
 #include <KoGenericRegistry.h>
 
 class KisPaintingAssistantHandle;
 typedef KisSharedPtr<KisPaintingAssistantHandle> KisPaintingAssistantHandleSP;
 class KisPaintingAssistant;
 class QPainterPath;
 
 enum HandleType {
     NORMAL,
     SIDE,
     CORNER,
     VANISHING_POINT,
     ANCHOR
 };
 
 
 /**
   * Represent an handle of the assistant, used to edit the parameters
   * of an assistants. Handles can be shared between assistants.
   */
 class KRITAUI_EXPORT KisPaintingAssistantHandle : public QPointF, public KisShared
 {
     friend class KisPaintingAssistant;
 
 public:
     KisPaintingAssistantHandle(double x, double y);
     explicit KisPaintingAssistantHandle(QPointF p);
     KisPaintingAssistantHandle(const KisPaintingAssistantHandle&);
     ~KisPaintingAssistantHandle();
     void mergeWith(KisPaintingAssistantHandleSP);
     void uncache();
     KisPaintingAssistantHandle& operator=(const QPointF&);
     void setType(char type);
     char handleType() const;
 
 private:
     void registerAssistant(KisPaintingAssistant*);
     void unregisterAssistant(KisPaintingAssistant*);
     bool containsAssistant(KisPaintingAssistant*) const;
 
 private:
     struct Private;
     Private* const d;
 };
 
 /**
  * A KisPaintingAssistant is an object that assist the drawing on the canvas.
  * With this class you can implement virtual equivalent to ruler or compas.
  */
 class KRITAUI_EXPORT KisPaintingAssistant
 {
 public:
     KisPaintingAssistant(const QString& id, const QString& name);
     virtual ~KisPaintingAssistant();
     virtual KisPaintingAssistantSP clone(QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap) const = 0;
     const QString& id() const;
     const QString& name() const;
     bool isSnappingActive() const;
     void setSnappingActive(bool set);
 
 
     /**
      * Adjust the position given in parameter.
      * @param point the coordinates in point in the document reference
      * @param strokeBegin the coordinates of the beginning of the stroke
      */
     virtual QPointF adjustPosition(const QPointF& point, const QPointF& strokeBegin) = 0;
     virtual void endStroke() { }
-    virtual QPointF buttonPosition() const = 0;
+    virtual QPointF getEditorPosition() const = 0; // Returns editor widget position in document-space coordinates.
     virtual int numHandles() const = 0;
 
     void replaceHandle(KisPaintingAssistantHandleSP _handle, KisPaintingAssistantHandleSP _with);
     void addHandle(KisPaintingAssistantHandleSP handle, HandleType type);
 
-    QColor effectiveAssistantColor() const;
+    QPointF viewportConstrainedEditorPosition(const KisCoordinatesConverter* converter, const QSize editorSize);
 
-    /// should this assistant use a custom color for the display? global color will be used if this is false
+    QColor effectiveAssistantColor() const;
     bool useCustomColor();
     void setUseCustomColor(bool useCustomColor);
-
-    /// getter and setter for assistant's custom color
     void setAssistantCustomColor(QColor color);
     QColor assistantCustomColor();
-
     void setAssistantGlobalColorCache(const QColor &color);
 
-
     virtual void drawAssistant(QPainter& gc, const QRectF& updateRect, const KisCoordinatesConverter *converter, bool cached = true,KisCanvas2 *canvas=0, bool assistantVisible=true, bool previewVisible=true);
     void uncache();
     const QList<KisPaintingAssistantHandleSP>& handles() const;
     QList<KisPaintingAssistantHandleSP> handles();
     const QList<KisPaintingAssistantHandleSP>& sideHandles() const;
     QList<KisPaintingAssistantHandleSP> sideHandles();
 
     QByteArray saveXml( QMap<KisPaintingAssistantHandleSP, int> &handleMap);
     virtual void saveCustomXml(QXmlStreamWriter* xml); //in case specific assistants have custom properties (like vanishing point)
 
     void loadXml(KoStore *store, QMap<int, KisPaintingAssistantHandleSP> &handleMap, QString path);
     virtual bool loadCustomXml(QXmlStreamReader* xml);
 
     void saveXmlList(QDomDocument& doc, QDomElement& ssistantsElement, int count);
     void findPerspectiveAssistantHandleLocation();
     KisPaintingAssistantHandleSP oppHandleOne();
 
     /**
       * Get the topLeft, bottomLeft, topRight and BottomRight corners of the assistant
       * Some assistants like the perspective grid have custom logic built around certain handles
       */
     const KisPaintingAssistantHandleSP topLeft() const;
     KisPaintingAssistantHandleSP topLeft();
     const KisPaintingAssistantHandleSP topRight() const;
     KisPaintingAssistantHandleSP topRight();
     const KisPaintingAssistantHandleSP bottomLeft() const;
     KisPaintingAssistantHandleSP bottomLeft();
     const KisPaintingAssistantHandleSP bottomRight() const;
     KisPaintingAssistantHandleSP bottomRight();
     const KisPaintingAssistantHandleSP topMiddle() const;
     KisPaintingAssistantHandleSP topMiddle();
     const KisPaintingAssistantHandleSP rightMiddle() const;
     KisPaintingAssistantHandleSP rightMiddle();
     const KisPaintingAssistantHandleSP leftMiddle() const;
     KisPaintingAssistantHandleSP leftMiddle();
     const KisPaintingAssistantHandleSP bottomMiddle() const;
     KisPaintingAssistantHandleSP bottomMiddle();
 
 
     // calculates whether a point is near one of the corner points of the assistant
     // returns: a corner point from the perspective assistant if the given node is close
     // only called once in code when calculating the perspective assistant
     KisPaintingAssistantHandleSP closestCornerHandleFromPoint(QPointF point);
 
     // determines if two points are close to each other
     // only used by the nodeNearPoint function (perspective grid assistant).
     bool areTwoPointsClose(const QPointF& pointOne, const QPointF& pointTwo);
 
     /// determines if the assistant has enough handles to be considered created
     /// new assistants get in a "creation" phase where they are currently being made on the canvas
     /// it will return false if we are in the middle of creating the assistant.
     virtual bool isAssistantComplete() const;
 
 public:
     /**
      * This will render the final output. The drawCache does rendering most of the time so be sure to check that
      */
     void drawPath(QPainter& painter, const QPainterPath& path, bool drawActive=true);
     void drawPreview(QPainter& painter, const QPainterPath& path);
     static double norm2(const QPointF& p);
 
 protected:
     explicit KisPaintingAssistant(const KisPaintingAssistant &rhs, QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap);
 
     virtual QRect boundingRect() const;
 
     /// performance layer where the graphics can be drawn from a cache instead of generated every render update
     virtual void drawCache(QPainter& gc, const KisCoordinatesConverter *converter, bool assistantVisible=true) = 0;
 
     void initHandles(QList<KisPaintingAssistantHandleSP> _handles);
     QList<KisPaintingAssistantHandleSP> m_handles;
 
     QPointF pixelToView(const QPoint pixelCoords) const;
 public:
     /// clones the list of assistants
     /// the originally shared handles will still be shared
     /// the cloned assistants do not share any handle with the original assistants
     static QList<KisPaintingAssistantSP> cloneAssistantList(const QList<KisPaintingAssistantSP> &list);
 
 private:
     struct Private;
     Private* const d;
 
 };
 
 /**
  * Allow to create a painting assistant.
  */
 class KRITAUI_EXPORT KisPaintingAssistantFactory
 {
 public:
     KisPaintingAssistantFactory();
     virtual ~KisPaintingAssistantFactory();
     virtual QString id() const = 0;
     virtual QString name() const = 0;
     virtual KisPaintingAssistant* createPaintingAssistant() const = 0;
 
 };
 
 class KRITAUI_EXPORT KisPaintingAssistantFactoryRegistry : public KoGenericRegistry<KisPaintingAssistantFactory*>
 {
   public:
     KisPaintingAssistantFactoryRegistry();
     ~KisPaintingAssistantFactoryRegistry() override;
 
     static KisPaintingAssistantFactoryRegistry* instance();
 
 };
 
 #endif
diff --git a/libs/ui/kis_painting_assistants_decoration.cpp b/libs/ui/kis_painting_assistants_decoration.cpp
index dfeaca7ec0..11838e6079 100644
--- a/libs/ui/kis_painting_assistants_decoration.cpp
+++ b/libs/ui/kis_painting_assistants_decoration.cpp
@@ -1,501 +1,498 @@
 /*
  *  Copyright (c) 2009 Cyrille Berger <cberger@cberger.net>
  *  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_painting_assistants_decoration.h"
 
 #include <cfloat>
 
 #include <QList>
 #include <QPointF>
 #include <klocalizedstring.h>
 #include <kactioncollection.h>
 #include <ktoggleaction.h>
 #include "kis_debug.h"
 #include "KisDocument.h"
 #include "kis_canvas2.h"
 #include "kis_icon_utils.h"
 #include "KisViewManager.h"
 
 #include <QPainter>
 #include <QApplication>
 
 struct KisPaintingAssistantsDecoration::Private {
     Private()
         : assistantVisible(false)
         , outlineVisible(false)
         , snapOnlyOneAssistant(true)
         , firstAssistant(0)
         , aFirstStroke(false)
         , m_handleSize(14)
     {}
 
     bool assistantVisible;
     bool outlineVisible;
     bool snapOnlyOneAssistant;
     KisPaintingAssistantSP firstAssistant;
     KisPaintingAssistantSP selectedAssistant;
     bool aFirstStroke;
     bool m_isEditingAssistants = false;
     bool m_outlineVisible = false;
     int m_handleSize; // size of editor handles on assistants
 
     // move, visibility, delete icons for each assistant. These only display while the assistant tool is active
     // these icons will be covered by the kis_paintint_assistant_decoration with things like the perspective assistant
 
     AssistantEditorData toolData;
 
     QPixmap m_iconDelete = KisIconUtils::loadIcon("dialog-cancel").pixmap(toolData.deleteIconSize, toolData.deleteIconSize);
     QPixmap m_iconSnapOn = KisIconUtils::loadIcon("visible").pixmap(toolData.snapIconSize, toolData.snapIconSize);
     QPixmap m_iconSnapOff = KisIconUtils::loadIcon("novisible").pixmap(toolData.snapIconSize, toolData.snapIconSize);
     QPixmap m_iconMove = KisIconUtils::loadIcon("transform-move").pixmap(toolData.moveIconSize, toolData.moveIconSize);
 
     KisCanvas2 * m_canvas = 0;
 };
 
 
 
 KisPaintingAssistantsDecoration::KisPaintingAssistantsDecoration(QPointer<KisView> parent) :
     KisCanvasDecoration("paintingAssistantsDecoration", parent),
     d(new Private)
 {
     setAssistantVisible(true);
     setOutlineVisible(true);
     setPriority(95);
     d->snapOnlyOneAssistant = true; //turn on by default.
 }
 
 KisPaintingAssistantsDecoration::~KisPaintingAssistantsDecoration()
 {
     delete d;
 }
 
 void KisPaintingAssistantsDecoration::addAssistant(KisPaintingAssistantSP assistant)
 {
     QList<KisPaintingAssistantSP> assistants = view()->document()->assistants();
     if (assistants.contains(assistant)) return;
 
     assistants.append(assistant);
     assistant->setAssistantGlobalColorCache(view()->document()->assistantsGlobalColor());
 
     view()->document()->setAssistants(assistants);
     setVisible(!assistants.isEmpty());
     emit assistantChanged();
 }
 
 void KisPaintingAssistantsDecoration::removeAssistant(KisPaintingAssistantSP assistant)
 {
     QList<KisPaintingAssistantSP> assistants = view()->document()->assistants();
     KIS_ASSERT_RECOVER_NOOP(assistants.contains(assistant));
 
     if (assistants.removeAll(assistant)) {
         view()->document()->setAssistants(assistants);
         setVisible(!assistants.isEmpty());
         emit assistantChanged();
     }
 }
 
 void KisPaintingAssistantsDecoration::removeAll()
 {
     QList<KisPaintingAssistantSP> assistants = view()->document()->assistants();
     assistants.clear();
     view()->document()->setAssistants(assistants);
     setVisible(!assistants.isEmpty());
 
     emit assistantChanged();
 }
 
 void KisPaintingAssistantsDecoration::setAssistants(const QList<KisPaintingAssistantSP> &assistants)
 {
     Q_FOREACH (KisPaintingAssistantSP assistant, assistants) {
         assistant->setAssistantGlobalColorCache(view()->document()->assistantsGlobalColor());
     }
     view()->document()->setAssistants(assistants);
     setVisible(!assistants.isEmpty());
 
     emit assistantChanged();
 }
 
 QPointF KisPaintingAssistantsDecoration::adjustPosition(const QPointF& point, const QPointF& strokeBegin)
 {
 
     if (assistants().empty()) {
         return point;
     }
 
     if (assistants().count() == 1) {
         if(assistants().first()->isSnappingActive() == true){
             QPointF newpoint = assistants().first()->adjustPosition(point, strokeBegin);
             // check for NaN
             if (newpoint.x() != newpoint.x()) return point;
             return newpoint;
         }
     }
     QPointF best = point;
     double distance = DBL_MAX;
     //the following tries to find the closest point to stroke-begin. It checks all assistants for the closest point//
     if(!d->snapOnlyOneAssistant){
         Q_FOREACH (KisPaintingAssistantSP assistant, assistants()) {
             if(assistant->isSnappingActive() == true){//this checks if the assistant in question has it's snapping boolean turned on//
                 QPointF pt = assistant->adjustPosition(point, strokeBegin);
                 if (pt.x() != pt.x()) continue;
                 double dist = qAbs(pt.x() - point.x()) + qAbs(pt.y() - point.y());
                 if (dist < distance) {
                     best = pt;
                     distance = dist;
                 }
             }
         }
     } else if (d->aFirstStroke==false) {
         Q_FOREACH (KisPaintingAssistantSP assistant, assistants()) {
             if(assistant->isSnappingActive() == true){//this checks if the assistant in question has it's snapping boolean turned on//
                 QPointF pt = assistant->adjustPosition(point, strokeBegin);
                 if (pt.x() != pt.x()) continue;
                 double dist = qAbs(pt.x() - point.x()) + qAbs(pt.y() - point.y());
                 if (dist < distance) {
                     best = pt;
                     distance = dist;
                     d->firstAssistant = assistant;
                 }
             }
         }
     } else if(d->firstAssistant) {
         //make sure there's a first assistant to begin with.//
         QPointF newpoint = d->firstAssistant->adjustPosition(point, strokeBegin);
         // BUGFIX: 402535
         // assistants might return (NaN,NaN), must always check for that
         if (newpoint.x() == newpoint.x()) {
             // not a NaN
             best = newpoint;
         }
     } else {
         d->aFirstStroke=false;
     }
     //this is here to be compatible with the movement in the perspective tool.
     qreal dx = point.x() - strokeBegin.x(), dy = point.y() - strokeBegin.y();
     if (dx * dx + dy * dy >= 4.0) {
         // allow some movement before snapping
         d->aFirstStroke=true;
     }
     return best;
 }
 
 void KisPaintingAssistantsDecoration::endStroke()
 {
     d->aFirstStroke = false;
 
     Q_FOREACH (KisPaintingAssistantSP assistant, assistants()) {
         assistant->endStroke();
     }
 }
 
 void KisPaintingAssistantsDecoration::drawDecoration(QPainter& gc, const QRectF& updateRect, const KisCoordinatesConverter *converter,KisCanvas2* canvas)
 {    
     if(assistants().length() == 0) {
         return; // no assistants to worry about, ok to exit
     }
 
     if (!canvas) {
         dbgFile<<"canvas does not exist in painting assistant decoration, you may have passed arguments incorrectly:"<<canvas;
     } else {
         d->m_canvas = canvas;
     }
 
     // the preview functionality for assistants. do not show while editing
     if (d->m_isEditingAssistants) {
         d->m_outlineVisible = false;
     }
     else {
         d->m_outlineVisible = outlineVisibility();
     }
 
     Q_FOREACH (KisPaintingAssistantSP assistant, assistants()) {
         assistant->drawAssistant(gc, updateRect, converter, true, canvas, assistantVisibility(), d->m_outlineVisible);
 
         if (isEditingAssistants()) {
             drawHandles(assistant, gc, converter);
         }
     }
 
     // draw editor controls on top of all assistant lines (why this code is last)
     if (isEditingAssistants()) {
         Q_FOREACH (KisPaintingAssistantSP assistant, assistants()) {
             drawEditorWidget(assistant, gc, converter);
         }
      }
 }
 
 void KisPaintingAssistantsDecoration::drawHandles(KisPaintingAssistantSP assistant, QPainter& gc, const KisCoordinatesConverter *converter)
 {
         QTransform initialTransform = converter->documentToWidgetTransform();
 
         QColor colorToPaint = assistant->effectiveAssistantColor();
 
         Q_FOREACH (const KisPaintingAssistantHandleSP handle, assistant->handles()) {
 
 
             QPointF transformedHandle = initialTransform.map(*handle);
             QRectF ellipse(transformedHandle -  QPointF(handleSize() * 0.5, handleSize() * 0.5), QSizeF(handleSize(), handleSize()));
 
             QPainterPath path;
             path.addEllipse(ellipse);
 
             gc.save();
             gc.setPen(Qt::NoPen);
             gc.setBrush(colorToPaint);
             gc.drawPath(path);
             gc.restore();
         }
 
          // some assistants have side handles like the vanishing point assistant
          Q_FOREACH (const KisPaintingAssistantHandleSP handle, assistant->sideHandles()) {
              QPointF transformedHandle = initialTransform.map(*handle);
              QRectF ellipse(transformedHandle -  QPointF(handleSize() * 0.5, handleSize() * 0.5), QSizeF(handleSize(), handleSize()));
 
              QPainterPath path;
              path.addEllipse(ellipse);
 
              gc.save();
              gc.setPen(Qt::NoPen);
              gc.setBrush(colorToPaint);
              gc.drawPath(path);
              gc.restore();
          }
 }
 
 int KisPaintingAssistantsDecoration::handleSize()
 {
     return  d->m_handleSize;
 }
 
 void KisPaintingAssistantsDecoration::setHandleSize(int handleSize)
 {
     d->m_handleSize = handleSize;
 }
 
 QList<KisPaintingAssistantHandleSP> KisPaintingAssistantsDecoration::handles()
 {
     QList<KisPaintingAssistantHandleSP> hs;
     Q_FOREACH (KisPaintingAssistantSP assistant, assistants()) {
         Q_FOREACH (const KisPaintingAssistantHandleSP handle, assistant->handles()) {
             if (!hs.contains(handle)) {
                 hs.push_back(handle);
             }
         }
         Q_FOREACH (const KisPaintingAssistantHandleSP handle, assistant->sideHandles()) {
             if (!hs.contains(handle)) {
                 hs.push_back(handle);
             }
         }
     }
     return hs;
 }
 
 QList<KisPaintingAssistantSP> KisPaintingAssistantsDecoration::assistants() const
 {
     QList<KisPaintingAssistantSP> assistants = view()->document()->assistants();
     return assistants;
 }
 
 KisPaintingAssistantSP KisPaintingAssistantsDecoration::selectedAssistant()
 {
     return d->selectedAssistant;
 }
 
 void KisPaintingAssistantsDecoration::setSelectedAssistant(KisPaintingAssistantSP assistant)
 {
     d->selectedAssistant = assistant;
     emit selectedAssistantChanged();
 }
 
 void KisPaintingAssistantsDecoration::deselectAssistant()
 {
     d->selectedAssistant.clear();
 }
 
 
 void KisPaintingAssistantsDecoration::setAssistantVisible(bool set)
 {
     d->assistantVisible=set;
 }
 
 void KisPaintingAssistantsDecoration::setOutlineVisible(bool set)
 {
     d->outlineVisible=set;
 }
 
 void KisPaintingAssistantsDecoration::setOnlyOneAssistantSnap(bool assistant)
 {
     d->snapOnlyOneAssistant = assistant;
 }
 
 bool KisPaintingAssistantsDecoration::assistantVisibility()
 {
     return d->assistantVisible;
 }
 bool KisPaintingAssistantsDecoration::outlineVisibility()
 {
     return d->outlineVisible;
 }
 void KisPaintingAssistantsDecoration::uncache()
 {
     Q_FOREACH (KisPaintingAssistantSP assistant, assistants()) {
         assistant->uncache();
     }
 }
 void KisPaintingAssistantsDecoration::toggleAssistantVisible()
 {
     setAssistantVisible(!assistantVisibility());
     uncache();
 }
 
 void KisPaintingAssistantsDecoration::toggleOutlineVisible()
 {
     setOutlineVisible(!outlineVisibility());
 }
 
 QColor KisPaintingAssistantsDecoration::globalAssistantsColor()
 {
     return view()->document()->assistantsGlobalColor();
 }
 
 void KisPaintingAssistantsDecoration::setGlobalAssistantsColor(QColor color)
 {
     // view()->document() is referenced multiple times in this class
     // it is used to later store things in the KRA file when saving.
     view()->document()->setAssistantsGlobalColor(color);
 
     Q_FOREACH (KisPaintingAssistantSP assistant, assistants()) {
         assistant->setAssistantGlobalColorCache(color);
     }
 
     uncache();
 }
 
 void KisPaintingAssistantsDecoration::activateAssistantsEditor()
 {
     setVisible(true); // this turns on the decorations in general. we leave it on at this point
     d->m_isEditingAssistants = true;
     uncache(); // updates visuals when editing
 }
 
 void KisPaintingAssistantsDecoration::deactivateAssistantsEditor()
 {
     if (!d->m_canvas) {
         return;
     }
 
     d->m_isEditingAssistants = false; // some elements are hidden when we aren't editing
     uncache(); // updates visuals when not editing
 }
 
 bool KisPaintingAssistantsDecoration::isEditingAssistants()
 {
     return d->m_isEditingAssistants;
 }
 
 QPointF KisPaintingAssistantsDecoration::snapToGuide(KoPointerEvent *e, const QPointF &offset, bool useModifiers)
 {
     if (!d->m_canvas || !d->m_canvas->currentImage()) {
         return e->point;
     }
 
 
     KoSnapGuide *snapGuide = d->m_canvas->snapGuide();
     QPointF pos = snapGuide->snap(e->point, offset, useModifiers ? e->modifiers() : Qt::NoModifier);
 
     return pos;
 }
 
 QPointF KisPaintingAssistantsDecoration::snapToGuide(const QPointF& pt, const QPointF &offset)
 {
     if (!d->m_canvas) {
          return pt;
     }
 
 
     KoSnapGuide *snapGuide = d->m_canvas->snapGuide();
     QPointF pos = snapGuide->snap(pt, offset, Qt::NoModifier);
 
     return pos;
 }
 
 /*
  * functions only used internally in this class
  * we potentially could make some of these inline to speed up performance
 */
 
 void KisPaintingAssistantsDecoration::drawEditorWidget(KisPaintingAssistantSP assistant, QPainter& gc, const KisCoordinatesConverter *converter)
 {
     if (!assistant->isAssistantComplete()) {
         return;
     }
 
-    QTransform initialTransform = converter->documentToWidgetTransform();
+    AssistantEditorData toolData; // shared const data for positioning and sizing
 
-    // We are going to put all of the assistant actions below the bounds of the assistant
-    // so they are out of the way
-    // assistant->buttonPosition() gets the center X/Y position point
-    QPointF actionsPosition = initialTransform.map(assistant->buttonPosition());
+    QTransform initialTransform = converter->documentToWidgetTransform();
 
-    AssistantEditorData toolData; // shared const data for positioning and sizing
+    QPointF actionsPosition = initialTransform.map(assistant->viewportConstrainedEditorPosition(converter, toolData.boundingSize));
 
     QPointF iconMovePosition(actionsPosition + toolData.moveIconPosition);
     QPointF iconSnapPosition(actionsPosition + toolData.snapIconPosition);
     QPointF iconDeletePosition(actionsPosition + toolData.deleteIconPosition);
 
     // Background container for helpers
     QBrush backgroundColor = d->m_canvas->viewManager()->mainWindow()->palette().window();
     QPointF actionsBGRectangle(actionsPosition + QPointF(10, 10));
 
     gc.setRenderHint(QPainter::Antialiasing);
 
     QPainterPath bgPath;
-    bgPath.addRoundedRect(QRectF(actionsBGRectangle.x(), actionsBGRectangle.y(), 110, 40), 6, 6);
+    bgPath.addRoundedRect(QRectF(actionsBGRectangle.x(), actionsBGRectangle.y(), toolData.boundingSize.width(), toolData.boundingSize.height()), 6, 6);
     QPen stroke(QColor(60, 60, 60, 80), 2);
 
     // if the assistant is selected, make outline stroke fatter and use theme's highlight color
     // for better visual feedback
     if (selectedAssistant()) { // there might not be a selected assistant, so do not seg fault
-        if (assistant->buttonPosition() == selectedAssistant()->buttonPosition()) {
+        if (assistant->getEditorPosition() == selectedAssistant()->getEditorPosition()) {
             stroke.setWidth(4);
             stroke.setColor(qApp->palette().color(QPalette::Highlight));
         }
     }
 
     // draw the final result
     gc.setPen(stroke);
     gc.fillPath(bgPath, backgroundColor);
     gc.drawPath(bgPath);
 
 
     // Move Assistant Tool helper
     gc.drawPixmap(iconMovePosition, d->m_iconMove);
 
     // active toggle
     if (assistant->isSnappingActive() == true) {
         gc.drawPixmap(iconSnapPosition, d->m_iconSnapOn);
     }
     else {
         gc.drawPixmap(iconSnapPosition, d->m_iconSnapOff);
     }
 
     gc.drawPixmap(iconDeletePosition, d->m_iconDelete);
 
 
 }
diff --git a/libs/ui/kis_painting_assistants_decoration.h b/libs/ui/kis_painting_assistants_decoration.h
index 87b497eb3c..e4b5b5b08b 100644
--- a/libs/ui/kis_painting_assistants_decoration.h
+++ b/libs/ui/kis_painting_assistants_decoration.h
@@ -1,143 +1,144 @@
 /*
  *  Copyright (c) 2009 Cyrille Berger <cberger@cberger.net>
  *  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.
  */
 
 #ifndef _KIS_PAINTING_ASSISTANTS_MANAGER_H_
 #define _KIS_PAINTING_ASSISTANTS_MANAGER_H_
 
 #include <QPointF>
 #include <QColor>
 
 #include "KoPointerEvent.h"
 #include "KoSnapGuide.h"
 
 #include "canvas/kis_canvas_decoration.h"
 #include "kis_painting_assistant.h"
 #include <kritaui_export.h>
 
 class KisView;
 
 class KisPaintingAssistantsDecoration;
 typedef KisSharedPtr<KisPaintingAssistantsDecoration> KisPaintingAssistantsDecorationSP;
 
 /// data for editor widget. This is shared between the decoration and assistant tool which needs hit box information
 struct AssistantEditorData {
     const int moveIconSize = 32;
     const int deleteIconSize = 24;
     const int snapIconSize = 20;
     const QPointF moveIconPosition = QPointF(15, 15);
     const QPointF snapIconPosition = QPointF(54, 20);
     const QPointF deleteIconPosition = QPointF(83, 18);
+    const QSize boundingSize = QSize(110, 40);
 };
 
 /**
  * KisPaintingAssistantsDecoration draws the assistants stored in the document on
  * the canvas.
  * In the application flow, each canvas holds one of these classes to manage the assistants
  * There is an assistants manager, but that is higher up in the flow and makes sure each view gets one of these
  * Since this is off the canvas level, the decoration can be seen across all tools. The contents from here will be in
  * front of the kis_assistant_tool, which hold and displays the editor controls.
  *
  * Many of the events this receives such as adding and removing assistants comes from kis_assistant_tool
  */
 class KRITAUI_EXPORT KisPaintingAssistantsDecoration : public KisCanvasDecoration
 {
     Q_OBJECT
 public:
     KisPaintingAssistantsDecoration(QPointer<KisView> parent);
     ~KisPaintingAssistantsDecoration() override;
     void addAssistant(KisPaintingAssistantSP assistant);
     void removeAssistant(KisPaintingAssistantSP assistant);
     void removeAll();
     void setAssistants(const QList<KisPaintingAssistantSP> &assistants);
     QPointF adjustPosition(const QPointF& point, const QPointF& strokeBegin);
     void endStroke();
     QList<KisPaintingAssistantHandleSP> handles();
     QList<KisPaintingAssistantSP> assistants() const;
 
 
     /// getter and setter functions for what assistant is currently selected
     /// this is used to control some tool options that are specific to a assistant
     KisPaintingAssistantSP selectedAssistant();
     void setSelectedAssistant(KisPaintingAssistantSP assistant);
     void deselectAssistant();
 
 
     /// called when assistant editor is activated
     /// right now this happens when the assistants tool is selected
     void activateAssistantsEditor();
 
 
     /// called when assistant editor is deactivated
     /// right now this happens when the assistants tool is un-selected
     void deactivateAssistantsEditor();
 
     /// brings back if we are currently editing assistants or not
     /// useful for some assistants (like spline) that draw bezier curves
     bool isEditingAssistants();
 
 
     /// sets whether the main assistant is visible
     void setAssistantVisible(bool set);
 
     /// sets whether the preview is visible
     void setOutlineVisible(bool set);
 
     /// sets whether we snap to only one assistant
     void setOnlyOneAssistantSnap(bool assistant);
 
     /// returns assistant visibility
     bool assistantVisibility();
 
     /// returns preview visibility
     bool outlineVisibility();
 
     /// uncache all assistants
     void uncache();
 
     int handleSize();
     void setHandleSize(int handleSize);
 
     QColor globalAssistantsColor();
     void setGlobalAssistantsColor(QColor color);
 
 Q_SIGNALS:
     void assistantChanged();
     void selectedAssistantChanged();
 
 public Q_SLOTS:
 
     /// toggles whether the assistant is active or not
     void toggleAssistantVisible();
 
     /// toggles whether there will be a preview of the assistant result when painting
     void toggleOutlineVisible();
     QPointF snapToGuide(KoPointerEvent *e, const QPointF &offset, bool useModifiers);
     QPointF snapToGuide(const QPointF& pt, const QPointF &offset);
 
 protected:
     void drawDecoration(QPainter& gc, const QRectF& updateRect, const KisCoordinatesConverter *converter,KisCanvas2* canvas) override;
     void drawHandles(KisPaintingAssistantSP assistant, QPainter& gc, const KisCoordinatesConverter *converter);
     void drawEditorWidget(KisPaintingAssistantSP assistant, QPainter& gc, const KisCoordinatesConverter *converter);
 
 private:
     struct Private;
     Private* const d;
 };
 
 #endif
diff --git a/libs/ui/kis_paintop_box.cc b/libs/ui/kis_paintop_box.cc
index 8732fbdac6..b0de301e34 100644
--- a/libs/ui/kis_paintop_box.cc
+++ b/libs/ui/kis_paintop_box.cc
@@ -1,1373 +1,1373 @@
 /*
  *  kis_paintop_box.cc - part of KImageShop/Krayon/Krita
  *
  *  Copyright (c) 2004 Boudewijn Rempt (boud@valdyas.org)
  *  Copyright (c) 2009-2011 Sven Langkamp (sven.langkamp@gmail.com)
  *  Copyright (c) 2010 Lukáš Tvrdý <lukast.dev@gmail.com>
  *  Copyright (C) 2011 Silvio Heinrich <plassy@web.de>
  *  Copyright (C) 2011 Srikanth Tiyyagura <srikanth.tulasiram@gmail.com>
  *  Copyright (c) 2014 Mohit Goyal <mohit.bits2011@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_paintop_box.h"
 
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QToolButton>
 #include <QPixmap>
 #include <QWidgetAction>
 #include <QApplication>
 #include <QMenu>
 #include <QTime>
 
 #include <kis_debug.h>
 
 #include <kactioncollection.h>
 #include <kacceleratormanager.h>
 #include <QKeySequence>
 
 
 #include <kis_icon.h>
 #include <KoColorSpace.h>
 #include <KoCompositeOpRegistry.h>
 #include <KoResourceServerAdapter.h>
 #include <KoToolManager.h>
 #include <KoColorSpaceRegistry.h>
 
 #include <kis_paint_device.h>
 #include <brushengine/kis_paintop_registry.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <brushengine/kis_paintop_settings.h>
 #include <brushengine/kis_paintop_settings_update_proxy.h>
 #include <kis_config_widget.h>
 #include <kis_image.h>
 #include <kis_node.h>
 #include <brushengine/kis_paintop_config_widget.h>
 #include <kis_action.h>
 
 #include "kis_canvas2.h"
 #include "kis_node_manager.h"
 #include "KisViewManager.h"
 #include "kis_canvas_resource_provider.h"
 #include "KisResourceServerProvider.h"
 #include "kis_favorite_resource_manager.h"
 #include "kis_config.h"
 
 #include "kis_popup_button.h"
 #include "widgets/kis_iconwidget.h"
 #include "widgets/kis_tool_options_popup.h"
 #include "widgets/kis_paintop_presets_popup.h"
 #include "widgets/kis_paintop_presets_chooser_popup.h"
 #include "widgets/kis_workspace_chooser.h"
 #include "widgets/kis_paintop_list_widget.h"
 #include "widgets/kis_slider_spin_box.h"
 #include "widgets/kis_cmb_composite.h"
 #include "widgets/kis_widget_chooser.h"
 #include "tool/kis_tool.h"
 #include "kis_signals_blocker.h"
 #include "kis_action_manager.h"
 #include "KisHighlightedToolButton.h"
 
 typedef KoResourceServerSimpleConstruction<KisPaintOpPreset, SharedPointerStoragePolicy<KisPaintOpPresetSP> > KisPaintOpPresetResourceServer;
 typedef KoResourceServerAdapter<KisPaintOpPreset, SharedPointerStoragePolicy<KisPaintOpPresetSP> > KisPaintOpPresetResourceServerAdapter;
 
 KisPaintopBox::KisPaintopBox(KisViewManager *view, QWidget *parent, const char *name)
     : QWidget(parent)
     , m_resourceProvider(view->canvasResourceProvider())
     , m_optionWidget(0)
     , m_toolOptionsPopupButton(0)
     , m_brushEditorPopupButton(0)
     , m_presetSelectorPopupButton(0)
     , m_toolOptionsPopup(0)
     , m_viewManager(view)
     , m_previousNode(0)
     , m_currTabletToolID(KoInputDevice::invalid())
     , m_presetsEnabled(true)
     , m_blockUpdate(false)
     , m_dirtyPresetsEnabled(false)
     , m_eraserBrushSizeEnabled(false)
     , m_eraserBrushOpacityEnabled(false)
 {
     Q_ASSERT(view != 0);
 
 
     setObjectName(name);
     KisConfig cfg(true);
     m_dirtyPresetsEnabled = cfg.useDirtyPresets();
     m_eraserBrushSizeEnabled = cfg.useEraserBrushSize();
     m_eraserBrushOpacityEnabled = cfg.useEraserBrushOpacity();
 
     KAcceleratorManager::setNoAccel(this);
 
     setWindowTitle(i18n("Painter's Toolchest"));
 
     m_favoriteResourceManager = new KisFavoriteResourceManager(this);
 
 
     KConfigGroup grp =  KSharedConfig::openConfig()->group("krita").group("Toolbar BrushesAndStuff");
     int iconsize = grp.readEntry("IconSize", 32);
 
     if (!cfg.toolOptionsInDocker()) {
         m_toolOptionsPopupButton = new KisPopupButton(this);
         m_toolOptionsPopupButton->setIcon(KisIconUtils::loadIcon("configure"));
         m_toolOptionsPopupButton->setToolTip(i18n("Tool Settings"));
         m_toolOptionsPopupButton->setFixedSize(iconsize, iconsize);
     }
 
     m_brushEditorPopupButton = new KisIconWidget(this);
     m_brushEditorPopupButton->setIcon(KisIconUtils::loadIcon("paintop_settings_02"));
     m_brushEditorPopupButton->setToolTip(i18n("Edit brush settings"));
     m_brushEditorPopupButton->setFixedSize(iconsize, iconsize);
 
     m_presetSelectorPopupButton = new KisPopupButton(this);
     m_presetSelectorPopupButton->setIcon(KisIconUtils::loadIcon("paintop_settings_01"));
     m_presetSelectorPopupButton->setToolTip(i18n("Choose brush preset"));
     m_presetSelectorPopupButton->setFixedSize(iconsize, iconsize);
 
     m_eraseModeButton = new KisHighlightedToolButton(this);
     m_eraseModeButton->setFixedSize(iconsize, iconsize);
     m_eraseModeButton->setCheckable(true);
 
     m_eraseAction = m_viewManager->actionManager()->createAction("erase_action");
     m_eraseModeButton->setDefaultAction(m_eraseAction);
 
     m_reloadButton = new QToolButton(this);
     m_reloadButton->setFixedSize(iconsize, iconsize);
 
     m_reloadAction = m_viewManager->actionManager()->createAction("reload_preset_action");
     m_reloadButton->setDefaultAction(m_reloadAction);
 
     m_alphaLockButton = new KisHighlightedToolButton(this);
     m_alphaLockButton->setFixedSize(iconsize, iconsize);
     m_alphaLockButton->setCheckable(true);
 
     KisAction* alphaLockAction = m_viewManager->actionManager()->createAction("preserve_alpha");
     m_alphaLockButton->setDefaultAction(alphaLockAction);
 
     // horizontal and vertical mirror toolbar buttons
 
     // mirror tool options for the X Mirror
     QMenu *toolbarMenuXMirror = new QMenu();
 
     hideCanvasDecorationsX = m_viewManager->actionManager()->createAction("mirrorX-hideDecorations");
     toolbarMenuXMirror->addAction(hideCanvasDecorationsX);
 
     lockActionX = m_viewManager->actionManager()->createAction("mirrorX-lock");
     toolbarMenuXMirror->addAction(lockActionX);
 
     moveToCenterActionX = m_viewManager->actionManager()->createAction("mirrorX-moveToCenter");
     toolbarMenuXMirror->addAction(moveToCenterActionX);
 
 
     // mirror tool options for the Y Mirror
     QMenu *toolbarMenuYMirror = new QMenu();
 
     hideCanvasDecorationsY = m_viewManager->actionManager()->createAction("mirrorY-hideDecorations");
     toolbarMenuYMirror->addAction(hideCanvasDecorationsY);
 
 
     lockActionY = m_viewManager->actionManager()->createAction("mirrorY-lock");
     toolbarMenuYMirror->addAction(lockActionY);
 
     moveToCenterActionY = m_viewManager->actionManager()->createAction("mirrorY-moveToCenter");
     toolbarMenuYMirror->addAction(moveToCenterActionY);
 
 
 
     // create horizontal and vertical mirror buttons
 
     m_hMirrorButton = new KisHighlightedToolButton(this);
     int menuPadding = 10;
     m_hMirrorButton->setFixedSize(iconsize + menuPadding, iconsize);
     m_hMirrorButton->setCheckable(true);
     m_hMirrorAction = m_viewManager->actionManager()->createAction("hmirror_action");
     m_hMirrorButton->setDefaultAction(m_hMirrorAction);
     m_hMirrorButton->setMenu(toolbarMenuXMirror);
     m_hMirrorButton->setPopupMode(QToolButton::MenuButtonPopup);
 
     m_vMirrorButton = new KisHighlightedToolButton(this);
     m_vMirrorButton->setFixedSize(iconsize + menuPadding, iconsize);
     m_vMirrorButton->setCheckable(true);
     m_vMirrorAction = m_viewManager->actionManager()->createAction("vmirror_action");
     m_vMirrorButton->setDefaultAction(m_vMirrorAction);
     m_vMirrorButton->setMenu(toolbarMenuYMirror);
     m_vMirrorButton->setPopupMode(QToolButton::MenuButtonPopup);
 
 
     // add connections for horizontal and mirrror buttons
     connect(lockActionX, SIGNAL(toggled(bool)), this, SLOT(slotLockXMirrorToggle(bool)));
     connect(lockActionY, SIGNAL(toggled(bool)), this, SLOT(slotLockYMirrorToggle(bool)));
 
     connect(moveToCenterActionX, SIGNAL(triggered(bool)), this, SLOT(slotMoveToCenterMirrorX()));
     connect(moveToCenterActionY, SIGNAL(triggered(bool)), this, SLOT(slotMoveToCenterMirrorY()));
 
     connect(hideCanvasDecorationsX, SIGNAL(toggled(bool)), this, SLOT(slotHideDecorationMirrorX(bool)));
     connect(hideCanvasDecorationsY, SIGNAL(toggled(bool)), this, SLOT(slotHideDecorationMirrorY(bool)));
 
     const bool sliderLabels = cfg.sliderLabels();
     int sliderWidth;
 
     if (sliderLabels) {
         sliderWidth = 150 * logicalDpiX() / 96;
     }
     else {
         sliderWidth = 120 * logicalDpiX() / 96;
     }
 
     for (int i = 0; i < 3; ++i) {
         m_sliderChooser[i] = new KisWidgetChooser(i + 1);
 
         KisDoubleSliderSpinBox* slOpacity;
         KisDoubleSliderSpinBox* slFlow;
         KisDoubleSliderSpinBox* slSize;
         if (sliderLabels) {
             slOpacity = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("opacity");
             slFlow    = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("flow");
             slSize    = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("size");
-            slOpacity->setPrefix(QString("%1  ").arg(i18n("Opacity:")));
-            slFlow->setPrefix(QString("%1  ").arg(i18n("Flow:")));
-            slSize->setPrefix(QString("%1  ").arg(i18n("Size:")));
+            slOpacity->setPrefix(QString("%1 ").arg(i18n("Opacity:")));
+            slFlow->setPrefix(QString("%1 ").arg(i18n("Flow:")));
+            slSize->setPrefix(QString("%1 ").arg(i18n("Size:")));
         }
         else {
             slOpacity = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("opacity", i18n("Opacity:"));
             slFlow    = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("flow", i18n("Flow:"));
             slSize    = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("size", i18n("Size:"));
         }
 
         slOpacity->setRange(0, 100, 0);
         slOpacity->setValue(100);
         slOpacity->setSingleStep(5);
-        slOpacity->setSuffix("%");
+        slOpacity->setSuffix(i18n("%"));
         slOpacity->setMinimumWidth(qMax(sliderWidth, slOpacity->sizeHint().width()));
         slOpacity->setFixedHeight(iconsize);
         slOpacity->setBlockUpdateSignalOnDrag(true);
 
         slFlow->setRange(0, 100, 0);
         slFlow->setValue(100);
         slFlow->setSingleStep(5);
-        slFlow->setSuffix("%");
+        slFlow->setSuffix(i18n("%"));
         slFlow->setMinimumWidth(qMax(sliderWidth, slFlow->sizeHint().width()));
         slFlow->setFixedHeight(iconsize);
         slFlow->setBlockUpdateSignalOnDrag(true);
 
         slSize->setRange(0.01, cfg.readEntry("maximumBrushSize", 1000), 2);
         slSize->setValue(100);
 
         slSize->setSingleStep(1);
         slSize->setExponentRatio(3.0);
         slSize->setSuffix(i18n(" px"));
         slSize->setMinimumWidth(qMax(sliderWidth, slSize->sizeHint().width()));
         slSize->setFixedHeight(iconsize);
         slSize->setBlockUpdateSignalOnDrag(true);
 
         m_sliderChooser[i]->chooseWidget(cfg.toolbarSlider(i + 1));
     }
 
     m_cmbCompositeOp = new KisCompositeOpComboBox();
     m_cmbCompositeOp->setFixedHeight(iconsize);
     Q_FOREACH (KisAction * a, m_cmbCompositeOp->blendmodeActions()) {
         m_viewManager->actionManager()->addAction(a->text(), a);
     }
 
     m_workspaceWidget = new KisPopupButton(this);
     m_workspaceWidget->setIcon(KisIconUtils::loadIcon("view-choose"));
     m_workspaceWidget->setToolTip(i18n("Choose workspace"));
     m_workspaceWidget->setFixedSize(iconsize, iconsize);
     m_workspaceWidget->setPopupWidget(new KisWorkspaceChooser(view));
 
     QHBoxLayout* baseLayout = new QHBoxLayout(this);
     m_paintopWidget = new QWidget(this);
     baseLayout->addWidget(m_paintopWidget);
     baseLayout->setSpacing(4);
     baseLayout->setContentsMargins(0, 0, 0, 0);
 
     m_layout = new QHBoxLayout(m_paintopWidget);
     if (!cfg.toolOptionsInDocker()) {
         m_layout->addWidget(m_toolOptionsPopupButton);
     }
     m_layout->addWidget(m_brushEditorPopupButton);
     m_layout->addWidget(m_presetSelectorPopupButton);
     m_layout->setSpacing(4);
     m_layout->setContentsMargins(0, 0, 0, 0);
 
     QWidget* compositeActions = new QWidget(this);
     QHBoxLayout* compositeLayout = new QHBoxLayout(compositeActions);
     compositeLayout->addWidget(m_cmbCompositeOp);
     compositeLayout->addWidget(m_eraseModeButton);
     compositeLayout->addWidget(m_alphaLockButton);
 
     compositeLayout->setSpacing(4);
     compositeLayout->setContentsMargins(0, 0, 0, 0);
 
     compositeLayout->addWidget(m_reloadButton);
 
     QWidgetAction * action;
 
     action = new QWidgetAction(this);
     view->actionCollection()->addAction("composite_actions", action);
     action->setText(i18n("Brush composite"));
     action->setDefaultWidget(compositeActions);
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("brushslider1", action);
     view->actionCollection()->addAction("brushslider1", action);
     action->setDefaultWidget(m_sliderChooser[0]);
     connect(action, SIGNAL(triggered()), m_sliderChooser[0], SLOT(showPopupWidget()));
     connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), m_sliderChooser[0], SLOT(updateThemedIcons()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("brushslider2", action);
     view->actionCollection()->addAction("brushslider2", action);
     action->setDefaultWidget(m_sliderChooser[1]);
     connect(action, SIGNAL(triggered()), m_sliderChooser[1], SLOT(showPopupWidget()));
     connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), m_sliderChooser[1], SLOT(updateThemedIcons()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("brushslider3", action);
     view->actionCollection()->addAction("brushslider3", action);
     action->setDefaultWidget(m_sliderChooser[2]);
     connect(action, SIGNAL(triggered()), m_sliderChooser[2], SLOT(showPopupWidget()));
         connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), m_sliderChooser[2], SLOT(updateThemedIcons()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("next_favorite_preset", action);
     view->actionCollection()->addAction("next_favorite_preset", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotNextFavoritePreset()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("previous_favorite_preset", action);
     view->actionCollection()->addAction("previous_favorite_preset", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotPreviousFavoritePreset()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("previous_preset", action);
     view->actionCollection()->addAction("previous_preset", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotSwitchToPreviousPreset()));
 
     if (!cfg.toolOptionsInDocker()) {
         action = new QWidgetAction(this);
         KisActionRegistry::instance()->propertizeAction("show_tool_options", action);
         view->actionCollection()->addAction("show_tool_options", action);
         connect(action, SIGNAL(triggered()), m_toolOptionsPopupButton, SLOT(showPopupWidget()));
     }
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("show_brush_editor", action);
     view->actionCollection()->addAction("show_brush_editor", action);
     connect(action, SIGNAL(triggered()), m_brushEditorPopupButton, SLOT(showPopupWidget()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("show_brush_presets", action);
     view->actionCollection()->addAction("show_brush_presets", action);
     connect(action, SIGNAL(triggered()), m_presetSelectorPopupButton, SLOT(showPopupWidget()));
 
     QWidget* mirrorActions = new QWidget(this);
     QHBoxLayout* mirrorLayout = new QHBoxLayout(mirrorActions);
     mirrorLayout->addWidget(m_hMirrorButton);
     mirrorLayout->addWidget(m_vMirrorButton);
     mirrorLayout->setSpacing(4);
     mirrorLayout->setContentsMargins(0, 0, 0, 0);
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("mirror_actions", action);
     action->setDefaultWidget(mirrorActions);
     view->actionCollection()->addAction("mirror_actions", action);
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("workspaces", action);
     view->actionCollection()->addAction("workspaces", action);
     action->setDefaultWidget(m_workspaceWidget);
 
     if (!cfg.toolOptionsInDocker()) {
         m_toolOptionsPopup = new KisToolOptionsPopup();
         m_toolOptionsPopupButton->setPopupWidget(m_toolOptionsPopup);
         m_toolOptionsPopup->switchDetached(false);
     }
 
 
     m_savePresetWidget = new KisPresetSaveWidget(this);
 
     m_presetsPopup = new KisPaintOpPresetsPopup(m_resourceProvider, m_favoriteResourceManager, m_savePresetWidget);
     m_brushEditorPopupButton->setPopupWidget(m_presetsPopup);
     m_presetsPopup->parentWidget()->setWindowTitle(i18n("Brush Editor"));
 
 
     connect(m_presetsPopup, SIGNAL(brushEditorShown()), SLOT(slotUpdateOptionsWidgetPopup()));
     connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), m_presetsPopup, SLOT(updateThemedIcons()));
 
     m_presetsChooserPopup = new KisPaintOpPresetsChooserPopup();
     m_presetsChooserPopup->setMinimumHeight(550);
     m_presetsChooserPopup->setMinimumWidth(450);
     m_presetSelectorPopupButton->setPopupWidget(m_presetsChooserPopup);
 
     m_currCompositeOpID = KoCompositeOpRegistry::instance().getDefaultCompositeOp().id();
 
     slotNodeChanged(view->activeNode());
     // Get all the paintops
     QList<QString> keys = KisPaintOpRegistry::instance()->keys();
     QList<KisPaintOpFactory*> factoryList;
 
     Q_FOREACH (const QString & paintopId, keys) {
         factoryList.append(KisPaintOpRegistry::instance()->get(paintopId));
     }
     m_presetsPopup->setPaintOpList(factoryList);
 
     connect(m_presetsPopup       , SIGNAL(paintopActivated(QString))          , SLOT(slotSetPaintop(QString)));
     connect(m_presetsPopup       , SIGNAL(defaultPresetClicked())             , SLOT(slotSetupDefaultPreset()));
     connect(m_presetsPopup       , SIGNAL(signalResourceSelected(KoResource*)), SLOT(resourceSelected(KoResource*)));
     connect(m_presetsPopup       , SIGNAL(reloadPresetClicked())              , SLOT(slotReloadPreset()));
     connect(m_presetsPopup       , SIGNAL(dirtyPresetToggled(bool))           , SLOT(slotDirtyPresetToggled(bool)));
     connect(m_presetsPopup       , SIGNAL(eraserBrushSizeToggled(bool))       , SLOT(slotEraserBrushSizeToggled(bool)));
     connect(m_presetsPopup       , SIGNAL(eraserBrushOpacityToggled(bool))       , SLOT(slotEraserBrushOpacityToggled(bool)));
 
     connect(m_presetsPopup, SIGNAL(createPresetFromScratch(QString)), this, SLOT(slotCreatePresetFromScratch(QString)));
 
     connect(m_presetsChooserPopup, SIGNAL(resourceSelected(KoResource*))      , SLOT(resourceSelected(KoResource*)));
     connect(m_presetsChooserPopup, SIGNAL(resourceClicked(KoResource*))      , SLOT(resourceSelected(KoResource*)));
 
     connect(m_resourceProvider   , SIGNAL(sigNodeChanged(KisNodeSP))    , SLOT(slotNodeChanged(KisNodeSP)));
     connect(m_cmbCompositeOp     , SIGNAL(currentIndexChanged(int))           , SLOT(slotSetCompositeMode(int)));
     connect(m_eraseAction          , SIGNAL(toggled(bool))                    , SLOT(slotToggleEraseMode(bool)));
     connect(alphaLockAction      , SIGNAL(toggled(bool))                    , SLOT(slotToggleAlphaLockMode(bool)));
 
     m_disablePressureAction = m_viewManager->actionManager()->createAction("disable_pressure");
     connect(m_disablePressureAction  , SIGNAL(toggled(bool))                    , SLOT(slotDisablePressureMode(bool)));
     m_disablePressureAction->setChecked(true);
 
     connect(m_hMirrorAction        , SIGNAL(toggled(bool))                    , SLOT(slotHorizontalMirrorChanged(bool)));
     connect(m_vMirrorAction        , SIGNAL(toggled(bool))                    , SLOT(slotVerticalMirrorChanged(bool)));
     connect(m_reloadAction         , SIGNAL(triggered())                        , SLOT(slotReloadPreset()));
 
     connect(m_sliderChooser[0]->getWidget<KisDoubleSliderSpinBox>("opacity"), SIGNAL(valueChanged(qreal)), SLOT(slotSlider1Changed()));
     connect(m_sliderChooser[0]->getWidget<KisDoubleSliderSpinBox>("flow")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider1Changed()));
     connect(m_sliderChooser[0]->getWidget<KisDoubleSliderSpinBox>("size")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider1Changed()));
     connect(m_sliderChooser[1]->getWidget<KisDoubleSliderSpinBox>("opacity"), SIGNAL(valueChanged(qreal)), SLOT(slotSlider2Changed()));
     connect(m_sliderChooser[1]->getWidget<KisDoubleSliderSpinBox>("flow")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider2Changed()));
     connect(m_sliderChooser[1]->getWidget<KisDoubleSliderSpinBox>("size")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider2Changed()));
     connect(m_sliderChooser[2]->getWidget<KisDoubleSliderSpinBox>("opacity"), SIGNAL(valueChanged(qreal)), SLOT(slotSlider3Changed()));
     connect(m_sliderChooser[2]->getWidget<KisDoubleSliderSpinBox>("flow")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider3Changed()));
     connect(m_sliderChooser[2]->getWidget<KisDoubleSliderSpinBox>("size")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider3Changed()));
 
     //Needed to connect canvas to favorite resource manager
     connect(m_viewManager->canvasResourceProvider(), SIGNAL(sigFGColorChanged(KoColor)), SLOT(slotUnsetEraseMode()));
 
 
     connect(m_resourceProvider, SIGNAL(sigFGColorUsed(KoColor)), m_favoriteResourceManager, SLOT(slotAddRecentColor(KoColor)));
 
     connect(m_resourceProvider, SIGNAL(sigFGColorChanged(KoColor)), m_favoriteResourceManager, SLOT(slotChangeFGColorSelector(KoColor)));
     connect(m_resourceProvider, SIGNAL(sigBGColorChanged(KoColor)), m_favoriteResourceManager, SLOT(slotSetBGColor(KoColor)));
     // cold initialization
     m_favoriteResourceManager->slotChangeFGColorSelector(m_resourceProvider->fgColor());
     m_favoriteResourceManager->slotSetBGColor(m_resourceProvider->bgColor());
 
     connect(m_favoriteResourceManager, SIGNAL(sigSetFGColor(KoColor)), m_resourceProvider, SLOT(slotSetFGColor(KoColor)));
     connect(m_favoriteResourceManager, SIGNAL(sigSetBGColor(KoColor)), m_resourceProvider, SLOT(slotSetBGColor(KoColor)));
     connect(m_favoriteResourceManager, SIGNAL(sigEnableChangeColor(bool)), m_resourceProvider, SLOT(slotResetEnableFGChange(bool)));
 
     connect(view->mainWindow(), SIGNAL(themeChanged()), this, SLOT(slotUpdateSelectionIcon()));
     connect(m_resourceProvider->resourceManager(), SIGNAL(canvasResourceChanged(int,QVariant)),
             this, SLOT(slotCanvasResourceChanged(int,QVariant)));
 
     slotInputDeviceChanged(KoToolManager::instance()->currentInputDevice());
 
     KisPaintOpPresetResourceServer *rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
     m_eraserName = "eraser_circle";
     m_defaultPresetName = "basic_tip_default";
     bool foundEraser = false;
     bool foundTip = false;
     for (int i=0; i<rserver->resourceCount(); i++) {
         KisPaintOpPresetSP resource = rserver->resources().at(i);
         if (resource->name().toLower().contains("eraser_circle")) {
             m_eraserName = resource->name();
             foundEraser = true;
         } else if (foundEraser == false && (resource->name().toLower().contains("eraser") ||
                                             resource->filename().toLower().contains("eraser"))) {
             m_eraserName = resource->name();
             foundEraser = true;
         }
         if (resource->name().toLower().contains("basic_tip_default")) {
             m_defaultPresetName = resource->name();
             foundTip = true;
         } else if (foundTip == false && (resource->name().toLower().contains("default") ||
                                          resource->filename().toLower().contains("default"))) {
             m_defaultPresetName = resource->name();
             foundTip = true;
         }
     }
 }
 
 KisPaintopBox::~KisPaintopBox()
 {
     KisConfig cfg(false);
     QMapIterator<TabletToolID, TabletToolData> iter(m_tabletToolMap);
     while (iter.hasNext()) {
         iter.next();
         if ((iter.key().pointer) == QTabletEvent::Eraser) {
             cfg.writeEntry(QString("LastEraser") , iter.value().preset->name());
         }
         else {
             cfg.writeEntry(QString("LastPreset"), iter.value().preset->name());
         }
     }
     // Do not delete the widget, since it is global to the application, not owned by the view
     m_presetsPopup->setPaintOpSettingsWidget(0);
     qDeleteAll(m_paintopOptionWidgets);
     delete m_favoriteResourceManager;
 
     for (int i = 0; i < 3; ++i) {
         delete m_sliderChooser[i];
     }
 }
 
 void KisPaintopBox::restoreResource(KoResource* resource)
 {
     KisPaintOpPreset* preset = dynamic_cast<KisPaintOpPreset*>(resource);
 
     if (preset) {
         setCurrentPaintop(preset);
 
         m_presetsPopup->setPresetImage(preset->image());
         m_presetsPopup->resourceSelected(resource);
     }
 }
 
 void KisPaintopBox::newOptionWidgets(const QList<QPointer<QWidget> > &optionWidgetList)
 {
     if (m_toolOptionsPopup) {
         m_toolOptionsPopup->newOptionWidgets(optionWidgetList);
     }
 }
 
 void KisPaintopBox::resourceSelected(KoResource* resource)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_optionWidget);
 
     m_presetsPopup->setCreatingBrushFromScratch(false); // show normal UI elements when we are not creating
 
     KisPaintOpPreset* preset = dynamic_cast<KisPaintOpPreset*>(resource);
     if (preset && preset != m_resourceProvider->currentPreset()) {
         if (!preset->settings()->isLoadable())
             return;
 
         if (!m_dirtyPresetsEnabled) {
             KisSignalsBlocker blocker(m_optionWidget);
             if (!preset->load()) {
                 warnKrita << "failed to load the preset.";
             }
         }
         //qDebug() << "resourceSelected" << resource->name();
         setCurrentPaintop(preset);
 
         m_presetsPopup->setPresetImage(preset->image());
         m_presetsPopup->resourceSelected(resource);
     }
 
 
 }
 
 void KisPaintopBox::setCurrentPaintop(const KoID& paintop)
 {
     KisPaintOpPresetSP preset = activePreset(paintop);
     Q_ASSERT(preset && preset->settings());
     //qDebug() << "setCurrentPaintop();" << paintop << preset;
     setCurrentPaintop(preset);
 }
 
 void KisPaintopBox::setCurrentPaintop(KisPaintOpPresetSP preset)
 {
 
     //qDebug() << "setCurrentPaintop(); " << preset->name();
 
     if (preset == m_resourceProvider->currentPreset()) {
 
         if (preset == m_tabletToolMap[m_currTabletToolID].preset) {
             return;
         }
     }
     Q_ASSERT(preset);
     const KoID& paintop = preset->paintOp();
     m_presetConnections.clear();
 
     if (m_resourceProvider->currentPreset()) {
 
         m_resourceProvider->setPreviousPaintOpPreset(m_resourceProvider->currentPreset());
 
         if (m_optionWidget) {
             m_optionWidget->hide();
         }
 
     }
 
     if (!m_paintopOptionWidgets.contains(paintop))
         m_paintopOptionWidgets[paintop] = KisPaintOpRegistry::instance()->get(paintop.id())->createConfigWidget(this);
 
     m_optionWidget = m_paintopOptionWidgets[paintop];
 
     KisSignalsBlocker b(m_optionWidget);
 
     preset->setOptionsWidget(m_optionWidget);
 
     m_optionWidget->setImage(m_viewManager->image());
     m_optionWidget->setNode(m_viewManager->activeNode());
 
     m_presetsPopup->setPaintOpSettingsWidget(m_optionWidget);
 
     m_resourceProvider->setPaintOpPreset(preset);
 
     Q_ASSERT(m_optionWidget && m_presetSelectorPopupButton);
 
     m_presetConnections.addConnection(m_optionWidget, SIGNAL(sigConfigurationUpdated()), this, SLOT(slotGuiChangedCurrentPreset()));
     m_presetConnections.addConnection(m_optionWidget, SIGNAL(sigSaveLockedConfig(KisPropertiesConfigurationSP)), this, SLOT(slotSaveLockedOptionToPreset(KisPropertiesConfigurationSP)));
     m_presetConnections.addConnection(m_optionWidget, SIGNAL(sigDropLockedConfig(KisPropertiesConfigurationSP)), this, SLOT(slotDropLockedOption(KisPropertiesConfigurationSP)));
 
 
     // load the current brush engine icon for the brush editor toolbar button
 
     m_brushEditorPopupButton->setResource(preset.data());
     m_presetsPopup->setCurrentPaintOpId(paintop.id());
 
 
     ////qDebug() << "\tsetting the new preset for" << m_currTabletToolID.uniqueID << "to" << preset->name();
     m_paintOpPresetMap[m_resourceProvider->currentPreset()->paintOp()] = preset;
     m_tabletToolMap[m_currTabletToolID].preset = preset;
     m_tabletToolMap[m_currTabletToolID].paintOpID = preset->paintOp();
 
 
     if (m_presetsPopup->currentPaintOpId() != paintop.id()) {
         // Must change the paintop as the current one is not supported
         // by the new colorspace.
         dbgKrita << "current paintop " << paintop.name() << " was not set, not supported by colorspace";
     }
 
     m_currCompositeOpID = preset->settings()->paintOpCompositeOp();
     updateCompositeOp(m_currCompositeOpID);
 }
 
 void KisPaintopBox::slotUpdateOptionsWidgetPopup()
 {
     KisPaintOpPresetSP preset = m_resourceProvider->currentPreset();
     KIS_SAFE_ASSERT_RECOVER_RETURN(preset);
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_optionWidget);
 
     m_optionWidget->setConfigurationSafe(preset->settings());
 
     m_presetsPopup->resourceSelected(preset.data());
     m_presetsPopup->updateViewSettings();
 
     // the m_viewManager->image() is set earlier, but the reference will be missing when the stamp button is pressed
     // need to later do some research on how and when we should be using weak shared pointers (WSP) that creates this situation
     m_optionWidget->setImage(m_viewManager->image());
 }
 
 KisPaintOpPresetSP KisPaintopBox::defaultPreset(const KoID& paintOp)
 {
     QString defaultName = paintOp.id() + ".kpp";
     QString path = KoResourcePaths::findResource("kis_defaultpresets", defaultName);
 
     KisPaintOpPresetSP preset = new KisPaintOpPreset(path);
 
     if (!preset->load()) {
         preset = KisPaintOpRegistry::instance()->defaultPreset(paintOp);
     }
 
     Q_ASSERT(preset);
     Q_ASSERT(preset->valid());
 
     return preset;
 }
 
 KisPaintOpPresetSP KisPaintopBox::activePreset(const KoID& paintOp)
 {
     if (m_paintOpPresetMap[paintOp] == 0) {
         m_paintOpPresetMap[paintOp] = defaultPreset(paintOp);
     }
 
     return m_paintOpPresetMap[paintOp];
 }
 
 void KisPaintopBox::updateCompositeOp(QString compositeOpID)
 {
     if (!m_optionWidget) return;
     KisSignalsBlocker blocker(m_optionWidget);
 
     KisNodeSP node = m_resourceProvider->currentNode();
 
     if (node && node->paintDevice()) {
         if (!node->paintDevice()->colorSpace()->hasCompositeOp(compositeOpID))
             compositeOpID = KoCompositeOpRegistry::instance().getDefaultCompositeOp().id();
 
         {
             KisSignalsBlocker b1(m_cmbCompositeOp);
             m_cmbCompositeOp->selectCompositeOp(KoID(compositeOpID));
         }
         if (compositeOpID != m_currCompositeOpID) {
             m_currCompositeOpID = compositeOpID;
         }
         if (compositeOpID == COMPOSITE_ERASE || m_resourceProvider->eraserMode()) {
             m_eraseModeButton->setChecked(true);
         }
         else {
             m_eraseModeButton->setChecked(false);
         }
     }
     else if (!node) {
         KisSignalsBlocker b1(m_cmbCompositeOp);
         m_cmbCompositeOp->selectCompositeOp(KoID(compositeOpID));
         m_currCompositeOpID = compositeOpID;
 
     }
 }
 
 void KisPaintopBox::setWidgetState(int flags)
 {
     if (flags & (ENABLE_COMPOSITEOP | DISABLE_COMPOSITEOP)) {
         m_cmbCompositeOp->setEnabled(flags & ENABLE_COMPOSITEOP);
         m_eraseModeButton->setEnabled(flags & ENABLE_COMPOSITEOP);
     }
 
     if (flags & (ENABLE_PRESETS | DISABLE_PRESETS)) {
         m_presetSelectorPopupButton->setEnabled(flags & ENABLE_PRESETS);
         m_brushEditorPopupButton->setEnabled(flags & ENABLE_PRESETS);
     }
 
     for (int i = 0; i < 3; ++i) {
         if (flags & (ENABLE_OPACITY | DISABLE_OPACITY))
             m_sliderChooser[i]->getWidget("opacity")->setEnabled(flags & ENABLE_OPACITY);
 
         if (flags & (ENABLE_FLOW | DISABLE_FLOW))
             m_sliderChooser[i]->getWidget("flow")->setEnabled(flags & ENABLE_FLOW);
 
         if (flags & (ENABLE_SIZE | DISABLE_SIZE))
             m_sliderChooser[i]->getWidget("size")->setEnabled(flags & ENABLE_SIZE);
     }
 }
 
 void KisPaintopBox::setSliderValue(const QString& sliderID, qreal value)
 {
     for (int i = 0; i < 3; ++i) {
         KisDoubleSliderSpinBox* slider = m_sliderChooser[i]->getWidget<KisDoubleSliderSpinBox>(sliderID);
         KisSignalsBlocker b(slider);
 
         if (sliderID == "opacity" || sliderID == "flow") { // opacity and flows UI stored at 0-100%
             slider->setValue(value*100);
         } else {
             slider->setValue(value); // brush size
         }
 
 
     }
 }
 
 void KisPaintopBox::slotSetPaintop(const QString& paintOpId)
 {
     if (KisPaintOpRegistry::instance()->get(paintOpId) != 0) {
         KoID id(paintOpId, KisPaintOpRegistry::instance()->get(paintOpId)->name());
         //qDebug() << "slotsetpaintop" << id;
         setCurrentPaintop(id);
     }
 }
 
 void KisPaintopBox::slotInputDeviceChanged(const KoInputDevice& inputDevice)
 {
     TabletToolMap::iterator toolData = m_tabletToolMap.find(inputDevice);
 
     //qDebug() << "slotInputDeviceChanged()" << inputDevice.device() << inputDevice.uniqueTabletId();
 
     m_currTabletToolID = TabletToolID(inputDevice);
 
     if (toolData == m_tabletToolMap.end()) {
         KisConfig cfg(true);
         KisPaintOpPresetResourceServer *rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
         KisPaintOpPresetSP preset;
         if (inputDevice.pointer() == QTabletEvent::Eraser) {
             preset = rserver->resourceByName(cfg.readEntry<QString>(QString("LastEraser_%1").arg(inputDevice.uniqueTabletId()), m_eraserName));
         }
         else {
             preset = rserver->resourceByName(cfg.readEntry<QString>(QString("LastPreset_%1").arg(inputDevice.uniqueTabletId()), m_defaultPresetName));
             //if (preset)
                 //qDebug() << "found stored preset " << preset->name() << "for" << inputDevice.uniqueTabletId();
             //else
                 //qDebug() << "no preset found for" << inputDevice.uniqueTabletId();
         }
         if (!preset) {
             preset = rserver->resourceByName(m_defaultPresetName);
         }
         if (preset) {
             //qDebug() << "inputdevicechanged 1" << preset;
             setCurrentPaintop(preset);
         }
     }
     else {
         if (toolData->preset) {
             //qDebug() << "inputdevicechanged 2" << toolData->preset;
             setCurrentPaintop(toolData->preset);
         }
         else {
             //qDebug() << "inputdevicechanged 3" << toolData->paintOpID;
             setCurrentPaintop(toolData->paintOpID);
         }
     }
 }
 
 void KisPaintopBox::slotCreatePresetFromScratch(QString paintop)
 {
     //First try to select an available default preset for that engine. If it doesn't exist, then
     //manually set the engine to use a new preset.
     KoID id(paintop, KisPaintOpRegistry::instance()->get(paintop)->name());
     KisPaintOpPresetSP preset = defaultPreset(id);
 
     slotSetPaintop(paintop);  // change the paintop settings area and update the UI
 
     if (!preset) {
         m_presetsPopup->setCreatingBrushFromScratch(true); // disable UI elements while creating from scratch
         preset = m_resourceProvider->currentPreset();
     } else {
         m_resourceProvider->setPaintOpPreset(preset);
         preset->setOptionsWidget(m_optionWidget);
     }
     m_presetsPopup->resourceSelected(preset.data());  // this helps update the UI on the brush editor
 }
 
 void KisPaintopBox::slotCanvasResourceChanged(int key, const QVariant &value)
 {
     if (m_viewManager) {
         sender()->blockSignals(true);
         KisPaintOpPresetSP preset = m_viewManager->canvasResourceProvider()->resourceManager()->resource(KisCanvasResourceProvider::CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
         if (preset && m_resourceProvider->currentPreset()->name() != preset->name()) {
             QString compositeOp = preset->settings()->getString("CompositeOp");
             updateCompositeOp(compositeOp);
             resourceSelected(preset.data());
         }
 
         /**
          * Update currently selected preset in both the popup widgets
          */
         m_presetsChooserPopup->canvasResourceChanged(preset);
 
         m_presetsPopup->currentPresetChanged(preset);
 
         if (key == KisCanvasResourceProvider::CurrentCompositeOp) {
             if (m_resourceProvider->currentCompositeOp() != m_currCompositeOpID) {
                 updateCompositeOp(m_resourceProvider->currentCompositeOp());
             }
         }
 
         if (key == KisCanvasResourceProvider::Size) {
             setSliderValue("size", m_resourceProvider->size());
         }
 
         if (key == KisCanvasResourceProvider::Opacity) {
             setSliderValue("opacity", m_resourceProvider->opacity());
         }
 
         if (key == KisCanvasResourceProvider::Flow) {
             setSliderValue("flow", m_resourceProvider->flow());
         }
 
         if (key == KisCanvasResourceProvider::EraserMode) {
             m_eraseAction->setChecked(value.toBool());
         }
 
         if (key == KisCanvasResourceProvider::DisablePressure) {
             m_disablePressureAction->setChecked(value.toBool());
         }
 
         if (key == KisCanvasResourceProvider::MirrorHorizontal) {
             m_hMirrorAction->setChecked(value.toBool());
         }
 
         if (key == KisCanvasResourceProvider::MirrorVertical) {
             m_vMirrorAction->setChecked(value.toBool());
         }
 
         sender()->blockSignals(false);
     }
 }
 
 void KisPaintopBox::slotSetupDefaultPreset()
 {
     KisPaintOpPresetSP preset = defaultPreset(m_resourceProvider->currentPreset()->paintOp());
     preset->setOptionsWidget(m_optionWidget);
     m_resourceProvider->setPaintOpPreset(preset);
 
     // tell the brush editor that the resource has changed
     // so it can update everything
     m_presetsPopup->resourceSelected(preset.data());
 }
 
 void KisPaintopBox::slotNodeChanged(const KisNodeSP node)
 {
     if (m_previousNode.isValid() && m_previousNode->paintDevice())
         disconnect(m_previousNode->paintDevice().data(), SIGNAL(colorSpaceChanged(const KoColorSpace*)), this, SLOT(slotColorSpaceChanged(const KoColorSpace*)));
 
     // Reconnect colorspace change of node
     if (node && node->paintDevice()) {
         connect(node->paintDevice().data(), SIGNAL(colorSpaceChanged(const KoColorSpace*)), this, SLOT(slotColorSpaceChanged(const KoColorSpace*)));
         m_resourceProvider->setCurrentCompositeOp(m_currCompositeOpID);
         m_previousNode = node;
         slotColorSpaceChanged(node->colorSpace());
     }
 
     if (m_optionWidget) {
         m_optionWidget->setNode(node);
     }
 }
 
 void KisPaintopBox::slotColorSpaceChanged(const KoColorSpace* colorSpace)
 {
     m_cmbCompositeOp->validate(colorSpace);
 }
 
 void KisPaintopBox::slotToggleEraseMode(bool checked)
 {
     const bool oldEraserMode = m_resourceProvider->eraserMode();
     m_resourceProvider->setEraserMode(checked);
 
     if (oldEraserMode != checked && m_eraserBrushSizeEnabled) {
         const qreal currentSize = m_resourceProvider->size();
 
         KisPaintOpSettingsSP settings = m_resourceProvider->currentPreset()->settings();
 
         // remember brush size. set the eraser size to the normal brush size if not set
         if (checked) {
             settings->setSavedBrushSize(currentSize);
             if (qFuzzyIsNull(settings->savedEraserSize())) {
                 settings->setSavedEraserSize(currentSize);
             }
         } else {
             settings->setSavedEraserSize(currentSize);
             if (qFuzzyIsNull(settings->savedBrushSize())) {
                 settings->setSavedBrushSize(currentSize);
             }
         }
 
         //update value in UI (this is the main place the value is 'stored' in memory)
         qreal newSize = checked ? settings->savedEraserSize() : settings->savedBrushSize();
         m_resourceProvider->setSize(newSize);
     }
    if (oldEraserMode != checked && m_eraserBrushOpacityEnabled) {
         const qreal currentOpacity = m_resourceProvider->opacity();
 
         KisPaintOpSettingsSP settings = m_resourceProvider->currentPreset()->settings();
 
         // remember brush opacity. set the eraser opacity to the normal brush opacity if not set
         if (checked) {
             settings->setSavedBrushOpacity(currentOpacity);
             if (qFuzzyIsNull(settings->savedEraserOpacity())) {
                 settings->setSavedEraserOpacity(currentOpacity);
             }
         } else {
             settings->setSavedEraserOpacity(currentOpacity);
             if (qFuzzyIsNull(settings->savedBrushOpacity())) {
                 settings->setSavedBrushOpacity(currentOpacity);
             }
         }
 
         //update value in UI (this is the main place the value is 'stored' in memory)
         qreal newOpacity = checked ? settings->savedEraserOpacity() : settings->savedBrushOpacity();
         m_resourceProvider->setOpacity(newOpacity);
     }
 }
 
 void KisPaintopBox::slotSetCompositeMode(int index)
 {
     Q_UNUSED(index);
     QString compositeOp = m_cmbCompositeOp->selectedCompositeOp().id();
     m_resourceProvider->setCurrentCompositeOp(compositeOp);
 }
 
 void KisPaintopBox::slotHorizontalMirrorChanged(bool value)
 {
     m_resourceProvider->setMirrorHorizontal(value);
 }
 
 void KisPaintopBox::slotVerticalMirrorChanged(bool value)
 {
     m_resourceProvider->setMirrorVertical(value);
 }
 
 void KisPaintopBox::sliderChanged(int n)
 {
     if (!m_optionWidget) // widget will not exist if the are no documents open
         return;
 
 
     KisSignalsBlocker blocker(m_optionWidget);
 
     // flow and opacity are shown as 0-100% on the UI, but their data is actually 0-1. Convert those two values
     // back for further work
     qreal opacity = m_sliderChooser[n]->getWidget<KisDoubleSliderSpinBox>("opacity")->value()/100;
     qreal flow    = m_sliderChooser[n]->getWidget<KisDoubleSliderSpinBox>("flow")->value()/100;
     qreal size    = m_sliderChooser[n]->getWidget<KisDoubleSliderSpinBox>("size")->value();
 
 
     setSliderValue("opacity", opacity);
     setSliderValue("flow"   , flow);
     setSliderValue("size"   , size);
 
     if (m_presetsEnabled) {
         // IMPORTANT: set the PaintOp size before setting the other properties
         //            it won't work the other way
         // TODO: why?!
 
         m_resourceProvider->setSize(size);
         m_resourceProvider->setOpacity(opacity);
         m_resourceProvider->setFlow(flow);
 
 
         KisLockedPropertiesProxySP propertiesProxy = KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(m_resourceProvider->currentPreset()->settings());
         propertiesProxy->setProperty("OpacityValue", opacity);
         propertiesProxy->setProperty("FlowValue", flow);
         m_optionWidget->setConfigurationSafe(m_resourceProvider->currentPreset()->settings().data());
     } else {
         m_resourceProvider->setOpacity(opacity);
     }
 
     m_presetsPopup->resourceSelected(m_resourceProvider->currentPreset().data());
 }
 
 void KisPaintopBox::slotSlider1Changed()
 {
     sliderChanged(0);
 }
 
 void KisPaintopBox::slotSlider2Changed()
 {
     sliderChanged(1);
 }
 
 void KisPaintopBox::slotSlider3Changed()
 {
     sliderChanged(2);
 }
 
 void KisPaintopBox::slotToolChanged(KoCanvasController* canvas, int toolId)
 {
     Q_UNUSED(canvas);
     Q_UNUSED(toolId);
 
     if (!m_viewManager->canvasBase()) return;
 
     QString  id   = KoToolManager::instance()->activeToolId();
     KisTool* tool = dynamic_cast<KisTool*>(KoToolManager::instance()->toolById(m_viewManager->canvasBase(), id));
 
     if (tool) {
         int flags = tool->flags();
 
         if (flags & KisTool::FLAG_USES_CUSTOM_COMPOSITEOP) {
             setWidgetState(ENABLE_COMPOSITEOP | ENABLE_OPACITY);
         } else                                              {
             setWidgetState(DISABLE_COMPOSITEOP | DISABLE_OPACITY);
         }
 
         if (flags & KisTool::FLAG_USES_CUSTOM_PRESET) {
             setWidgetState(ENABLE_PRESETS);
             if (!m_resourceProvider->currentPreset()) return;
 
             // block updates of avoid some over updating of the option widget
             m_blockUpdate = true;
 
             setSliderValue("size", m_resourceProvider->size());
 
             {
                 qreal opacity = m_resourceProvider->currentPreset()->settings()->paintOpOpacity();
                 m_resourceProvider->setOpacity(opacity);
                 setSliderValue("opacity", opacity);
                 setWidgetState(ENABLE_OPACITY);
             }
 
             {
                 setSliderValue("flow", m_resourceProvider->currentPreset()->settings()->paintOpFlow());
                 setWidgetState(ENABLE_FLOW);
             }
 
             {
                 updateCompositeOp(m_resourceProvider->currentPreset()->settings()->paintOpCompositeOp());
                 setWidgetState(ENABLE_COMPOSITEOP);
             }
 
             m_blockUpdate = false;
 
             m_presetsEnabled = true;
         } else {
             setWidgetState(DISABLE_PRESETS);
             m_presetsEnabled = false;
         }
 
         if (flags & KisTool::FLAG_USES_CUSTOM_SIZE) {
             setWidgetState(ENABLE_SIZE | ENABLE_FLOW);
         } else {
             setWidgetState(DISABLE_SIZE | DISABLE_FLOW);
         }
 
     } else setWidgetState(DISABLE_ALL);
 }
 
 void KisPaintopBox::slotPreviousFavoritePreset()
 {
     if (!m_favoriteResourceManager) return;
 
     QVector<KisPaintOpPresetSP> presets = m_favoriteResourceManager->favoritePresetList();
     for (int i=0; i < presets.size(); ++i) {
         if (m_resourceProvider->currentPreset() &&
                 m_resourceProvider->currentPreset()->name() == presets[i]->name()) {
             if (i > 0) {
                 m_favoriteResourceManager->slotChangeActivePaintop(i - 1);
             } else {
                 m_favoriteResourceManager->slotChangeActivePaintop(m_favoriteResourceManager->numFavoritePresets() - 1);
             }
             //floating message should have least 2 lines, otherwise
             //preset thumbnail will be too small to distinguish
             //(because size of image on floating message depends on amount of lines in msg)
             m_viewManager->showFloatingMessage(
                 i18n("%1\nselected",
                         m_resourceProvider->currentPreset()->name()),
                 QIcon(QPixmap::fromImage(m_resourceProvider->currentPreset()->image())));
 
             return;
         }
     }
 }
 
 void KisPaintopBox::slotNextFavoritePreset()
 {
     if (!m_favoriteResourceManager) return;
 
     QVector<KisPaintOpPresetSP> presets = m_favoriteResourceManager->favoritePresetList();
     for(int i = 0; i < presets.size(); ++i) {
         if (m_resourceProvider->currentPreset()->name() == presets[i]->name()) {
             if (i < m_favoriteResourceManager->numFavoritePresets() - 1) {
                 m_favoriteResourceManager->slotChangeActivePaintop(i + 1);
             } else {
                 m_favoriteResourceManager->slotChangeActivePaintop(0);
             }
             m_viewManager->showFloatingMessage(
                 i18n("%1\nselected",
                         m_resourceProvider->currentPreset()->name()),
                 QIcon(QPixmap::fromImage(m_resourceProvider->currentPreset()->image())));
 
             return;
         }
     }
 }
 
 void KisPaintopBox::slotSwitchToPreviousPreset()
 {
     if (m_resourceProvider->previousPreset()) {
         //qDebug() << "slotSwitchToPreviousPreset();" << m_resourceProvider->previousPreset();
         setCurrentPaintop(m_resourceProvider->previousPreset());
         m_viewManager->showFloatingMessage(
                 i18n("%1\nselected",
                         m_resourceProvider->currentPreset()->name()),
             QIcon(QPixmap::fromImage(m_resourceProvider->currentPreset()->image())));
     }
 }
 
 void KisPaintopBox::slotUnsetEraseMode()
 {
     m_eraseAction->setChecked(false);
 }
 
 void KisPaintopBox::slotToggleAlphaLockMode(bool checked)
 {
     if (checked) {
         m_alphaLockButton->actions()[0]->setIcon(KisIconUtils::loadIcon("transparency-locked"));
     } else {
         m_alphaLockButton->actions()[0]->setIcon(KisIconUtils::loadIcon("transparency-unlocked"));
     }
     m_resourceProvider->setGlobalAlphaLock(checked);
 }
 
 void KisPaintopBox::slotDisablePressureMode(bool checked)
 {
     if (checked) {
         m_disablePressureAction->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure"));
     } else {
         m_disablePressureAction->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure_locked"));
     }
 
     m_resourceProvider->setDisablePressure(checked);
 }
 
 void KisPaintopBox::slotReloadPreset()
 {
     KisSignalsBlocker blocker(m_optionWidget);
 
     //Here using the name and fetching the preset from the server was the only way the load was working. Otherwise it was not loading.
     KisPaintOpPresetResourceServer * rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
     KisPaintOpPresetSP preset = rserver->resourceByName(m_resourceProvider->currentPreset()->name());
     if (preset) {
         preset->load();
     }
 
     if (m_resourceProvider->currentPreset() != preset) {
         m_resourceProvider->setPaintOpPreset(preset);
     } else {
         /**
          * HACK ALERT: here we emit a private signal from the resource manager to
          * ensure that all the subscribers of resource-changed signal got the
          * notification. That is especially important for
          * KisPaintopTransformationConnector. See bug 392622.
          */
 
         emit m_resourceProvider->resourceManager()->canvasResourceChanged(
             KisCanvasResourceProvider::CurrentPaintOpPreset,
             QVariant::fromValue(preset));
     }
 }
 void KisPaintopBox::slotGuiChangedCurrentPreset() // Called only when UI is changed and not when preset is changed
 {
     KisPaintOpPresetSP preset = m_resourceProvider->currentPreset();
 
     {
         /**
          * Here we postpone all the settings updates events until the entire writing
          * operation will be finished. As soon as it is finished, the updates will be
          * emitted happily (if there were any).
          */
 
         KisPaintOpPreset::UpdatedPostponer postponer(preset.data());
 
 
         QStringList preserveProperties;
         preserveProperties << "lodUserAllowed";
         preserveProperties << "lodSizeThreshold";
 
         // clear all the properties before dumping the stuff into the preset,
         // some of the options add the values incrementally
         // (e.g. KisPaintOpUtils::RequiredBrushFilesListTag), therefore they
         // may add up if we pass the same preset multiple times
         preset->settings()->resetSettings(preserveProperties);
 
         m_optionWidget->writeConfigurationSafe(const_cast<KisPaintOpSettings*>(preset->settings().data()));
     }
 
     // we should also update the preset strip to update the status of the "dirty" mark
     m_presetsPopup->resourceSelected(m_resourceProvider->currentPreset().data());
 
     // TODO!!!!!!!!
     //m_presetsPopup->updateViewSettings();
 }
 void KisPaintopBox::slotSaveLockedOptionToPreset(KisPropertiesConfigurationSP p)
 {
 
     QMapIterator<QString, QVariant> i(p->getProperties());
     while (i.hasNext()) {
         i.next();
         m_resourceProvider->currentPreset()->settings()->setProperty(i.key(), QVariant(i.value()));
         if (m_resourceProvider->currentPreset()->settings()->hasProperty(i.key() + "_previous")) {
             m_resourceProvider->currentPreset()->settings()->removeProperty(i.key() + "_previous");
         }
 
     }
     slotGuiChangedCurrentPreset();
 
 }
 
 void KisPaintopBox::slotDropLockedOption(KisPropertiesConfigurationSP p)
 {
     KisSignalsBlocker blocker(m_optionWidget);
     KisPaintOpPresetSP preset = m_resourceProvider->currentPreset();
 
     {
         KisPaintOpPreset::DirtyStateSaver dirtySaver(preset.data());
 
         QMapIterator<QString, QVariant> i(p->getProperties());
         while (i.hasNext()) {
             i.next();
             if (preset->settings()->hasProperty(i.key() + "_previous")) {
                 preset->settings()->setProperty(i.key(), preset->settings()->getProperty(i.key() + "_previous"));
                 preset->settings()->removeProperty(i.key() + "_previous");
             }
 
         }
     }
 
 }
 void KisPaintopBox::slotDirtyPresetToggled(bool value)
 {
     if (!value) {
         slotReloadPreset();
         m_presetsPopup->resourceSelected(m_resourceProvider->currentPreset().data());
         m_presetsPopup->updateViewSettings();
     }
     m_dirtyPresetsEnabled = value;
     KisConfig cfg(false);
     cfg.setUseDirtyPresets(m_dirtyPresetsEnabled);
 
 }
 void KisPaintopBox::slotEraserBrushSizeToggled(bool value)
 {
     m_eraserBrushSizeEnabled = value;
     KisConfig cfg(false);
     cfg.setUseEraserBrushSize(m_eraserBrushSizeEnabled);
 }
 
 void KisPaintopBox::slotEraserBrushOpacityToggled(bool value)
 {
     m_eraserBrushOpacityEnabled = value;
     KisConfig cfg(false);
     cfg.setUseEraserBrushOpacity(m_eraserBrushOpacityEnabled);
 }
 
 void KisPaintopBox::slotUpdateSelectionIcon()
 {
     m_hMirrorAction->setIcon(KisIconUtils::loadIcon("symmetry-horizontal"));
     m_vMirrorAction->setIcon(KisIconUtils::loadIcon("symmetry-vertical"));
 
     KisConfig cfg(true);
     if (!cfg.toolOptionsInDocker() && m_toolOptionsPopupButton) {
         m_toolOptionsPopupButton->setIcon(KisIconUtils::loadIcon("configure"));
     }
 
     m_presetSelectorPopupButton->setIcon(KisIconUtils::loadIcon("paintop_settings_01"));
     m_brushEditorPopupButton->setIcon(KisIconUtils::loadIcon("paintop_settings_02"));
     m_workspaceWidget->setIcon(KisIconUtils::loadIcon("view-choose"));
 
     m_eraseAction->setIcon(KisIconUtils::loadIcon("draw-eraser"));
     m_reloadAction->setIcon(KisIconUtils::loadIcon("view-refresh"));
 
     if (m_disablePressureAction->isChecked()) {
         m_disablePressureAction->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure"));
     } else {
         m_disablePressureAction->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure_locked"));
     }
 }
 
 void KisPaintopBox::slotLockXMirrorToggle(bool toggleLock) {
     m_resourceProvider->setMirrorHorizontalLock(toggleLock);
 }
 
 void KisPaintopBox::slotLockYMirrorToggle(bool toggleLock) {
     m_resourceProvider->setMirrorVerticalLock(toggleLock);
 }
 
 void KisPaintopBox::slotHideDecorationMirrorX(bool toggled) {
     m_resourceProvider->setMirrorHorizontalHideDecorations(toggled);
 }
 
 void KisPaintopBox::slotHideDecorationMirrorY(bool toggled) {
     m_resourceProvider->setMirrorVerticalHideDecorations(toggled);
 }
 
 void KisPaintopBox::slotMoveToCenterMirrorX() {
   m_resourceProvider->mirrorHorizontalMoveCanvasToCenter();
 }
 
 void KisPaintopBox::slotMoveToCenterMirrorY() {
   m_resourceProvider->mirrorVerticalMoveCanvasToCenter();
 }
diff --git a/libs/ui/kis_safe_document_loader.cpp b/libs/ui/kis_safe_document_loader.cpp
index 766f116e16..ca6223d519 100644
--- a/libs/ui/kis_safe_document_loader.cpp
+++ b/libs/ui/kis_safe_document_loader.cpp
@@ -1,274 +1,274 @@
 /*
  *  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_safe_document_loader.h"
 
 #include <QTimer>
 #include <QFileSystemWatcher>
 #include <QApplication>
 #include <QFileInfo>
 #include <QDir>
 #include <QUrl>
 
 #include <KoStore.h>
 
 #include <kis_paint_layer.h>
 #include <kis_group_layer.h>
 #include "KisDocument.h"
 #include <kis_image.h>
 #include "kis_signal_compressor.h"
 #include "KisPart.h"
 
 class FileSystemWatcherWrapper : public QObject
 {
     Q_OBJECT
 public:
     FileSystemWatcherWrapper() {
         connect(&m_watcher, SIGNAL(fileChanged(QString)), SIGNAL(fileChanged(QString)));
         connect(&m_watcher, SIGNAL(fileChanged(QString)), SLOT(slotFileChanged(QString)));
     }
 
     bool addPath(const QString &file) {
         bool result = true;
         const QString ufile = unifyFilePath(file);
 
         if (m_pathCount.contains(ufile)) {
             m_pathCount[ufile]++;
         } else {
             m_pathCount.insert(ufile, 1);
             result = m_watcher.addPath(ufile);
         }
 
         return result;
     }
 
     bool removePath(const QString &file) {
         bool result = true;
         const QString ufile = unifyFilePath(file);
 
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(m_pathCount.contains(ufile), false);
 
         if (m_pathCount[ufile] == 1) {
             m_pathCount.remove(ufile);
             result = m_watcher.removePath(ufile);
         } else {
             m_pathCount[ufile]--;
         }
         return result;
     }
 
     QStringList files() const {
         return m_watcher.files();
     }
 
 private Q_SLOTS:
     void slotFileChanged(const QString &path) {
         // re-add the file after QSaveFile optimization
         if (!m_watcher.files().contains(path) && QFileInfo(path).exists()) {
             m_watcher.addPath(path);
         }
     }
 
 Q_SIGNALS:
     void fileChanged(const QString &path);
 
 private:
     QString unifyFilePath(const QString &path) {
         return QFileInfo(path).absoluteFilePath();
     }
 
 private:
     QFileSystemWatcher m_watcher;
     QHash<QString, int> m_pathCount;
 };
 
 Q_GLOBAL_STATIC(FileSystemWatcherWrapper, s_fileSystemWatcher)
 
 
 struct KisSafeDocumentLoader::Private
 {
     Private()
         : fileChangedSignalCompressor(500 /* ms */, KisSignalCompressor::POSTPONE)
     {
     }
 
-    QScopedPointer<KisDocument>  doc;
+    QScopedPointer<KisDocument> doc;
     KisSignalCompressor fileChangedSignalCompressor;
     bool isLoading = false;
     bool fileChangedFlag = false;
     QString path;
     QString temporaryPath;
 
     qint64 initialFileSize = 0;
     QDateTime initialFileTimeStamp;
 };
 
 KisSafeDocumentLoader::KisSafeDocumentLoader(const QString &path, QObject *parent)
     : QObject(parent),
       m_d(new Private())
 {
     connect(s_fileSystemWatcher, SIGNAL(fileChanged(QString)),
             SLOT(fileChanged(QString)));
 
     connect(&m_d->fileChangedSignalCompressor, SIGNAL(timeout()),
             SLOT(fileChangedCompressed()));
 
     setPath(path);
 }
 
 KisSafeDocumentLoader::~KisSafeDocumentLoader()
 {
     if (!m_d->path.isEmpty()) {
         s_fileSystemWatcher->removePath(m_d->path);
     }
 
     delete m_d;
 }
 
 void KisSafeDocumentLoader::setPath(const QString &path)
 {
     if (path.isEmpty()) return;
 
     if (!m_d->path.isEmpty()) {
         s_fileSystemWatcher->removePath(m_d->path);
     }
 
     m_d->path = path;
     s_fileSystemWatcher->addPath(m_d->path);
 }
 
 void KisSafeDocumentLoader::reloadImage()
 {
     fileChangedCompressed(true);
 }
 
 void KisSafeDocumentLoader::fileChanged(QString path)
 {
     if (path == m_d->path) {
         if (s_fileSystemWatcher->files().contains(path) == false && QFileInfo(path).exists()) {
             //When a path is renamed it is removed, so we ought to readd it.
             s_fileSystemWatcher->addPath(path);
         }
         m_d->fileChangedFlag = true;
         m_d->fileChangedSignalCompressor.start();
     }
 }
 
 void KisSafeDocumentLoader::fileChangedCompressed(bool sync)
 {
     if (m_d->isLoading) return;
 
     QFileInfo initialFileInfo(m_d->path);
     m_d->initialFileSize = initialFileInfo.size();
     m_d->initialFileTimeStamp = initialFileInfo.lastModified();
 
     // it may happen when the file is flushed by
     // so other application
     if (!m_d->initialFileSize) return;
 
     m_d->isLoading = true;
     m_d->fileChangedFlag = false;
 
     m_d->temporaryPath =
             QDir::tempPath() + QDir::separator() +
             QString("krita_file_layer_copy_%1_%2.%3")
             .arg(QApplication::applicationPid())
             .arg(qrand())
             .arg(initialFileInfo.suffix());
 
     QFile::copy(m_d->path, m_d->temporaryPath);
 
 
     if (!sync) {
         QTimer::singleShot(100, this, SLOT(delayedLoadStart()));
     } else {
         QApplication::processEvents();
         delayedLoadStart();
     }
 }
 
 void KisSafeDocumentLoader::delayedLoadStart()
 {
     QFileInfo originalInfo(m_d->path);
     QFileInfo tempInfo(m_d->temporaryPath);
     bool successfullyLoaded = false;
 
     if (!m_d->fileChangedFlag &&
             originalInfo.size() == m_d->initialFileSize &&
             originalInfo.lastModified() == m_d->initialFileTimeStamp &&
             tempInfo.size() == m_d->initialFileSize) {
 
         m_d->doc.reset(KisPart::instance()->createDocument());
 
         if (m_d->path.toLower().endsWith("ora") || m_d->path.toLower().endsWith("kra")) {
             QScopedPointer<KoStore> store(KoStore::createStore(m_d->temporaryPath, KoStore::Read));
             if (store && !store->bad()) {
                 if (store->open(QString("mergedimage.png"))) {
                     QByteArray bytes = store->read(store->size());
                     store->close();
                     QImage mergedImage;
                     mergedImage.loadFromData(bytes);
                     Q_ASSERT(!mergedImage.isNull());
                     KisImageSP image = new KisImage(0, mergedImage.width(), mergedImage.height(), KoColorSpaceRegistry::instance()->rgb8(), "");
                     KisPaintLayerSP layer = new KisPaintLayer(image, "", OPACITY_OPAQUE_U8);
                     layer->paintDevice()->convertFromQImage(mergedImage, 0);
                     image->addNode(layer, image->rootLayer());
                     image->initialRefreshGraph();
                     m_d->doc->setCurrentImage(image);
                     successfullyLoaded = true;
                 }
                 else {
                     qWarning() << "delayedLoadStart: Could not open mergedimage.png";
                 }
             }
             else {
                 qWarning() << "delayedLoadStart: Store was bad";
             }
         }
         else {
             successfullyLoaded = m_d->doc->openUrl(QUrl::fromLocalFile(m_d->temporaryPath),
                                                    KisDocument::DontAddToRecent);
         }
     } else {
         dbgKrita << "File was modified externally. Restarting.";
         dbgKrita << ppVar(m_d->fileChangedFlag);
         dbgKrita << ppVar(m_d->initialFileSize);
         dbgKrita << ppVar(m_d->initialFileTimeStamp);
         dbgKrita << ppVar(originalInfo.size());
         dbgKrita << ppVar(originalInfo.lastModified());
         dbgKrita << ppVar(tempInfo.size());
     }
 
     QFile::remove(m_d->temporaryPath);
     m_d->isLoading = false;
 
     if (!successfullyLoaded) {
         // Restart the attempt
         m_d->fileChangedSignalCompressor.start();
     }
     else {
         KisPaintDeviceSP paintDevice = new KisPaintDevice(m_d->doc->image()->colorSpace());
         KisPaintDeviceSP projection = m_d->doc->image()->projection();
         paintDevice->makeCloneFrom(projection, projection->extent());
         emit loadingFinished(paintDevice, m_d->doc->image()->xRes(), m_d->doc->image()->yRes());
     }
 
     m_d->doc.reset();
 }
 
 #include "kis_safe_document_loader.moc"
diff --git a/libs/ui/kis_splash_screen.cpp b/libs/ui/kis_splash_screen.cpp
index 3f43388eaa..f6e9bea55b 100644
--- a/libs/ui/kis_splash_screen.cpp
+++ b/libs/ui/kis_splash_screen.cpp
@@ -1,282 +1,282 @@
 /*
  *  Copyright (c) 2014 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "kis_splash_screen.h"
 
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QPixmap>
 #include <QPainter>
 #include <QCheckBox>
 #include <kis_debug.h>
 #include <QFile>
 #include <QScreen>
 #include <QWindow>
 
 #include <KisPart.h>
 #include <KisApplication.h>
 
 #include <kis_icon.h>
 
 #include <klocalizedstring.h>
 #include <kconfig.h>
 #include <ksharedconfig.h>
 #include <kconfiggroup.h>
 #include <QIcon>
 
 KisSplashScreen::KisSplashScreen(const QString &version, const QPixmap &pixmap, const QPixmap &pixmap_x2, bool themed, QWidget *parent, Qt::WindowFlags f)
     : QWidget(parent, Qt::SplashScreen | Qt::FramelessWindowHint
 #ifdef Q_OS_LINUX
               | Qt::WindowStaysOnTopHint
 #endif
               | f),
       m_themed(themed)
 {
 
     setupUi(this);
-    setWindowIcon(KisIconUtils::loadIcon("calligrakrita"));
+    setWindowIcon(KisIconUtils::loadIcon("krita"));
 
     QImage img = pixmap.toImage();
     if (devicePixelRatioF() > 1.01) {
         img = pixmap_x2.toImage();
         img.setDevicePixelRatio(2);
     }
 
     QFont font = this->font();
     font.setPointSize(11);
     font.setBold(true);
     QFontMetrics metrics(font);
 
     QPainter p(&img);
     p.setFont(font);
     p.setRenderHint(QPainter::Antialiasing);
 
     // positioning of the text over the image (version)
     // also see setLoadingText() for positiong (loading progress text)
     int leftEdge = 475-metrics.width(version);
     int topEdge = 58+metrics.ascent();
 
     //draw shadow
     QPen pen(QColor(0, 0, 0, 80));
     p.setPen(pen);
     p.drawText(leftEdge+1, topEdge+1, version);
     //draw main text
     p.setPen(QPen(QColor(255, 255, 255, 255)));
     p.drawText(leftEdge, topEdge, version);
     p.end();
 
 
     //get this to have the loading text painted on later.
     m_splashImage = img;
     m_textTop = topEdge+metrics.height();
 
     // Maintain the aspect ratio on high DPI screens when scaling
     lblSplash->setPixmap(QPixmap::fromImage(img));
     setFixedWidth(pixmap.width());
 
     bnClose->hide();
     connect(bnClose, SIGNAL(clicked()), this, SLOT(close()));
     chkShowAtStartup->hide();
     connect(chkShowAtStartup, SIGNAL(toggled(bool)), this, SLOT(toggleShowAtStartup(bool)));
 
     KConfigGroup cfg( KSharedConfig::openConfig(), "SplashScreen");
     bool hideSplash = cfg.readEntry("HideSplashAfterStartup", false);
     chkShowAtStartup->setChecked(hideSplash);
 
     connect(lblRecent, SIGNAL(linkActivated(QString)), SLOT(linkClicked(QString)));
     connect(&m_timer, SIGNAL(timeout()), SLOT(raise()));
 
     // hide these labels by default
     displayLinks(false);
     displayRecentFiles(false);
 
     m_timer.setSingleShot(true);
     m_timer.start(10);
 }
 
 void KisSplashScreen::resizeEvent(QResizeEvent *event)
 {
     QWidget::resizeEvent(event);
     updateText();
 }
 
 void KisSplashScreen::updateText()
 {
     QString color = colorString();
 
     KConfigGroup cfg2( KSharedConfig::openConfig(), "RecentFiles");
     int i = 1;
 
     QString recent = i18n("<html>"
                           "<head/>"
                           "<body>"
                           "<p><b><span style=\" color:%1;\">Recent Files</span></b></p>", color);
 
     QString path;
     QStringList recentfiles;
 
     QFontMetrics metrics(lblRecent->font());
 
     do {
         path = cfg2.readPathEntry(QString("File%1").arg(i), QString());
         if (!path.isEmpty()) {
             QString name = cfg2.readPathEntry(QString("Name%1").arg(i), QString());
             QUrl url(path);
             if (name.isEmpty()) {
                 name = url.fileName();
             }
 
             name = metrics.elidedText(name, Qt::ElideMiddle, lblRecent->width());
 
             if (!url.isLocalFile() || QFile::exists(url.toLocalFile())) {
                 recentfiles.insert(0, QString("<p><a href=\"%1\"><span style=\"color:%3;\">%2</span></a></p>").arg(path).arg(name).arg(color));
             }
         }
 
         i++;
     } while (!path.isEmpty() || i <= 8);
 
     recent += recentfiles.join("\n");
     recent += "</body>"
         "</html>";
     lblRecent->setText(recent);
 }
 
 void KisSplashScreen::displayLinks(bool show) {
 
     if (show) {
         QString color = colorString();
         lblLinks->setTextFormat(Qt::RichText);
         lblLinks->setText(i18n("<html>"
                                "<head/>"
                                "<body>"
                                "<p><span style=\" color:%1;\"><b>Links</b></span></p>"
 
                                "<p><a href=\"https://krita.org/support-us/\"><span style=\" text-decoration: underline; color:%1;\">Support Krita</span></a></p>"
 
                                "<p><a href=\"https://docs.krita.org/en/user_manual/getting_started.html\"><span style=\" text-decoration: underline; color:%1;\">Getting Started</span></a></p>"
                                "<p><a href=\"https://docs.krita.org/\"><span style=\" text-decoration: underline; color:%1;\">Manual</span></a></p>"
                                "<p><a href=\"https://krita.org/\"><span style=\" text-decoration: underline; color:%1;\">Krita Website</span></a></p>"
                                "<p><a href=\"https://forum.kde.org/viewforum.php?f=136\"><span style=\" text-decoration: underline; color:%1;\">User Community</span></a></p>"
 
                                "<p><a href=\"https://phabricator.kde.org/source/krita/\"><span style=\" text-decoration: underline; color:%1;\">Source Code</span></a></p>"
 
                                "</body>"
                                "</html>", color));
 
         filesLayout->setContentsMargins(10,10,10,10);
         actionControlsLayout->setContentsMargins(5,5,5,5);
 
     } else {
         // eliminating margins here allows for the splash screen image to take the entire area with nothing underneath
         filesLayout->setContentsMargins(0,0,0,0);
         actionControlsLayout->setContentsMargins(0,0,0,0);
     }
 
     lblLinks->setVisible(show);
 
     updateText();
 }
 
 
 void KisSplashScreen::displayRecentFiles(bool show) {
     lblRecent->setVisible(show);
     line->setVisible(show);
 }
 
 void KisSplashScreen::setLoadingText(QString text)
 {
     QFont font = this->font();
     font.setPointSize(10);
     font.setItalic(true);
 
     QImage img = m_splashImage;
     QPainter p(&img);
     QFontMetrics metrics(font);
     p.setFont(font);
     p.setRenderHint(QPainter::Antialiasing);
 
     // position text for loading text
     int leftEdge = 475-metrics.width(text);
     int topEdge = m_textTop;
 
     //draw shadow
     QPen pen(QColor(0, 0, 0, 80));
     p.setPen(pen);
     p.drawText(leftEdge+1, topEdge+1, text);
     //draw main text
     p.setPen(QPen(QColor(255, 255, 255, 255)));
     p.drawText(leftEdge, topEdge, text);
     p.end();
     lblSplash->setPixmap(QPixmap::fromImage(img));
 }
 
 
 
 QString KisSplashScreen::colorString() const
 {
     QString color = "#FFFFFF";
     if (m_themed && qApp->palette().background().color().value() > 100) {
         color = "#000000";
     }
 
     return color;
 }
 
 
 void KisSplashScreen::repaint()
 {
     QWidget::repaint();
     qApp->sendPostedEvents();
 }
 
 void KisSplashScreen::show()
 {
     QRect r(QPoint(), sizeHint());
     resize(r.size());
     if (!this->parentWidget()) {
         this->winId(); // Force creation of native window
         if (this->windowHandle()) {
             // At least on Windows, the window may be created on a non-primary
             // screen with a different scale factor. If we don't explicitly
             // move it to the primary screen, the position will be scaled with
             // the wrong factor and the splash will be offset.
             this->windowHandle()->setScreen(QApplication::primaryScreen());
         }
     }
     move(QApplication::primaryScreen()->availableGeometry().center() - r.center());
     if (isVisible()) {
         repaint();
     }
     m_timer.setSingleShot(true);
     m_timer.start(1);
     QWidget::show();
 }
 
 void KisSplashScreen::toggleShowAtStartup(bool toggle)
 {
     KConfigGroup cfg( KSharedConfig::openConfig(), "SplashScreen");
     cfg.writeEntry("HideSplashAfterStartup", toggle);
 }
 
 void KisSplashScreen::linkClicked(const QString &link)
 {
     KisPart::instance()->openExistingFile(QUrl::fromLocalFile(link));
     if (isTopLevel()) {
         close();
     }
 }
diff --git a/libs/ui/kis_statusbar.cc b/libs/ui/kis_statusbar.cc
index 967f5cfac4..4ed3a44b08 100644
--- a/libs/ui/kis_statusbar.cc
+++ b/libs/ui/kis_statusbar.cc
@@ -1,400 +1,400 @@
 /* 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_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()));
 }
 
 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;
 
         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());
     }
 
     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(QString("%1, %2").arg(pixelPos.x()).arg(pixelPos.y()));
+    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 = QString("%1 &x %2 (%3)").arg(w).arg(h).arg(m_shortMemoryTag);
+        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(image->colorSpace()->name() + "  " + image->profile()->name());
+        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/kis_stopgradient_editor.cpp b/libs/ui/kis_stopgradient_editor.cpp
index 91acaab7a4..51867bd096 100644
--- a/libs/ui/kis_stopgradient_editor.cpp
+++ b/libs/ui/kis_stopgradient_editor.cpp
@@ -1,257 +1,257 @@
 /*
  *  Copyright (c) 2004 Cyrille Berger <cberger@cberger.net>
  *                2016 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_stopgradient_editor.h"
 #include <QPainter>
 #include <QSpinBox>
 #include <QDoubleSpinBox>
 #include <QPoint>
 #include <QMenu>
 
 #include <KoColorSpace.h>
 #include <resources/KoStopGradient.h>
 
 #include "kis_debug.h"
 
 #include <kis_icon_utils.h>
 
 /****************************** KisStopGradientEditor ******************************/
 
 KisStopGradientEditor::KisStopGradientEditor(QWidget *parent)
     : QWidget(parent),
       m_gradient(0)
 {
     setupUi(this);
 
     connect(gradientSlider, SIGNAL(sigSelectedStop(int)), this, SLOT(stopChanged(int)));
     connect(nameedit, SIGNAL(editingFinished()), this, SLOT(nameChanged()));
     connect(colorButton, SIGNAL(changed(KoColor)), SLOT(colorChanged(KoColor)));
 
     opacitySlider->setPrefix(i18n("Opacity: "));
     opacitySlider->setRange(0.0, 1.0, 2);
     connect(opacitySlider, SIGNAL(valueChanged(qreal)), this, SLOT(opacityChanged(qreal)));
 
 
-    buttonReverse->setIcon(KisIconUtils::loadIcon("view-refresh"));
+    buttonReverse->setIcon(KisIconUtils::loadIcon("transform_icons_mirror_x"));
     buttonReverse->setToolTip(i18n("Flip Gradient"));
     KisIconUtils::updateIcon(buttonReverse);
     connect(buttonReverse, SIGNAL(pressed()), SLOT(reverse()));
 
-    buttonReverseSecond->setIcon(KisIconUtils::loadIcon("view-refresh"));
+    buttonReverseSecond->setIcon(KisIconUtils::loadIcon("transform_icons_mirror_x"));
     buttonReverseSecond->setToolTip(i18n("Flip Gradient"));
     KisIconUtils::updateIcon(buttonReverseSecond);
     connect(buttonReverseSecond, SIGNAL(clicked()), SLOT(reverse()));
 
     this->setContextMenuPolicy(Qt::CustomContextMenu);
     connect(this, SIGNAL(customContextMenuRequested(const QPoint &)),
             this, SLOT(showContextMenu(const QPoint &)));
 
     setCompactMode(false);
 
     setGradient(0);
     stopChanged(-1);
 }
 
 KisStopGradientEditor::KisStopGradientEditor(KoStopGradient* gradient, QWidget *parent, const char* name, const QString& caption)
     : KisStopGradientEditor(parent)
 {
     setObjectName(name);
     setWindowTitle(caption);
     setGradient(gradient);
 }
 
 void KisStopGradientEditor::setCompactMode(bool value)
 {
     lblName->setVisible(!value);
     buttonReverse->setVisible(!value);
     nameedit->setVisible(!value);
 
     buttonReverseSecond->setVisible(value);
 }
 
 void KisStopGradientEditor::setGradient(KoStopGradient *gradient)
 {
     m_gradient = gradient;
     setEnabled(m_gradient);
 
     if (m_gradient) {
         gradientSlider->setGradientResource(m_gradient);
         nameedit->setText(gradient->name());
         stopChanged(gradientSlider->selectedStop());
     }
 
     emit sigGradientChanged();
 }
 
 void KisStopGradientEditor::notifyGlobalColorChanged(const KoColor &color)
 {
     if (colorButton->isEnabled() &&
         color != colorButton->color()) {
 
         colorButton->setColor(color);
     }
 }
 
 boost::optional<KoColor> KisStopGradientEditor::currentActiveStopColor() const
 {
     if (!colorButton->isEnabled()) return boost::none;
     return colorButton->color();
 }
 
 void KisStopGradientEditor::stopChanged(int stop)
 {
     if (!m_gradient) return;
 
     const bool hasStopSelected = stop >= 0;
 
     opacitySlider->setEnabled(hasStopSelected);
     colorButton->setEnabled(hasStopSelected);
     stopLabel->setEnabled(hasStopSelected);
 
     if (hasStopSelected) {
         KoColor color = m_gradient->stops()[stop].second;
         opacitySlider->setValue(color.opacityF());
    
         color.setOpacity(1.0);
         colorButton->setColor(color);
     }
 
     emit sigGradientChanged();
 }
 
 void KisStopGradientEditor::colorChanged(const KoColor& color)
 {
     if (!m_gradient) return;
 
     QList<KoGradientStop> stops = m_gradient->stops();
 
     int currentStop = gradientSlider->selectedStop();
     double t = stops[currentStop].first;
     
     KoColor c(color, stops[currentStop].second.colorSpace());
     c.setOpacity(stops[currentStop].second.opacityU8());
     
     stops.removeAt(currentStop);
     stops.insert(currentStop, KoGradientStop(t, c));
     
     m_gradient->setStops(stops);
     gradientSlider->update();
 
     emit sigGradientChanged();
 }
 
 void KisStopGradientEditor::opacityChanged(qreal value)
 {
     if (!m_gradient) return;
 
     QList<KoGradientStop> stops = m_gradient->stops();
 
     int currentStop = gradientSlider->selectedStop();
     double t = stops[currentStop].first;
     
     KoColor c = stops[currentStop].second;
     c.setOpacity(value);
     
     stops.removeAt(currentStop);
     stops.insert(currentStop, KoGradientStop(t, c));
     
     m_gradient->setStops(stops);
     gradientSlider->update();
 
     emit sigGradientChanged();
 }
 
 
 void KisStopGradientEditor::nameChanged()
 {
     if (!m_gradient) return;
 
     m_gradient->setName(nameedit->text());
     emit sigGradientChanged();
 }
 
 void KisStopGradientEditor::reverse()
 {
     if (!m_gradient) return;
 
     QList<KoGradientStop> stops = m_gradient->stops();
     QList<KoGradientStop> reversedStops;
     for(const KoGradientStop& stop : stops) {
         reversedStops.push_front(KoGradientStop(1 - stop.first, stop.second));
     }
     m_gradient->setStops(reversedStops);
     gradientSlider->setSelectedStop(stops.size() - 1 - gradientSlider->selectedStop());
 
     emit sigGradientChanged();
 }
 
 void KisStopGradientEditor::sortByValue( SortFlags flags = SORT_ASCENDING )
 {
     if (!m_gradient) return;
 
     bool ascending = (flags & SORT_ASCENDING) > 0;
     bool evenDistribution = (flags & EVEN_DISTRIBUTION) > 0;
 
     QList<KoGradientStop> stops = m_gradient->stops();
     const int stopCount = stops.size();
 
     QList<KoGradientStop> sortedStops;
     std::sort(stops.begin(), stops.end(), KoGradientStopValueSort());
 
     int stopIndex = 0;
     for (const KoGradientStop& stop : stops) {
         const float value = evenDistribution ? (float)stopIndex / (float)(stopCount - 1) : stop.second.toQColor().valueF();
         const float position = ascending ? value : 1.f - value;
 
         if (ascending) {
             sortedStops.push_back(KoGradientStop(position, stop.second));
         } else {
             sortedStops.push_front(KoGradientStop(position, stop.second));
         }
 
         stopIndex++;
     }
 
     m_gradient->setStops(sortedStops);
     gradientSlider->setSelectedStop(stopCount - 1);
     gradientSlider->update();
 
     emit sigGradientChanged();
 }
 
 void KisStopGradientEditor::showContextMenu(const QPoint &origin)
 {
     QMenu contextMenu(i18n("Options"), this);
 
     QAction reverseValues(i18n("Reverse Values"), this);
     connect(&reverseValues, &QAction::triggered, this, &KisStopGradientEditor::reverse);
 
     QAction sortAscendingValues(i18n("Sort by Value"), this);
     connect(&sortAscendingValues, &QAction::triggered, this, [this]{ this->sortByValue(SORT_ASCENDING); } );
     QAction sortAscendingDistributed(i18n("Sort by Value (Even Distribution)"), this);
     connect(&sortAscendingDistributed, &QAction::triggered, this, [this]{ this->sortByValue(SORT_ASCENDING | EVEN_DISTRIBUTION);} );
 
     contextMenu.addAction(&reverseValues);
     contextMenu.addSeparator();
     contextMenu.addAction(&sortAscendingValues);
     contextMenu.addAction(&sortAscendingDistributed);
 
     contextMenu.exec(mapToGlobal(origin));
 }
 
diff --git a/libs/ui/kisexiv2/kis_exif_io.cpp b/libs/ui/kisexiv2/kis_exif_io.cpp
index da86e64559..af0d53c3af 100644
--- a/libs/ui/kisexiv2/kis_exif_io.cpp
+++ b/libs/ui/kisexiv2/kis_exif_io.cpp
@@ -1,640 +1,640 @@
 /*
  *  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; 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 "kis_exif_io.h"
 
 #include <exiv2/exif.hpp>
 #include <exiv2/error.hpp>
 
 #include <qendian.h>
 #include <QIODevice>
 #include <QByteArray>
 #include <QVariant>
 #include <QDateTime>
 #include <QDate>
 #include <QTime>
 #include <QTextCodec>
 
 #include <kis_debug.h>
 
 #include "kis_exiv2.h"
 
 #include <kis_meta_data_store.h>
 #include <kis_meta_data_entry.h>
 #include <kis_meta_data_value.h>
 #include <kis_meta_data_schema.h>
 #include <kis_meta_data_schema_registry.h>
 
 struct KisExifIO::Private {
 };
 
 // ---- Exception conversion functions ---- //
 
 // convert ExifVersion and FlashpixVersion to a KisMetaData value
 KisMetaData::Value exifVersionToKMDValue(const Exiv2::Value::AutoPtr value)
 {
     const Exiv2::DataValue* dvalue = dynamic_cast<const Exiv2::DataValue*>(&*value);
     if (dvalue) {
         Q_ASSERT(dvalue);
         QByteArray array(dvalue->count(), 0);
         dvalue->copy((Exiv2::byte*)array.data());
         return KisMetaData::Value(QString(array));
     }
     else {
         Q_ASSERT(value->typeId() == Exiv2::asciiString);
         return KisMetaData::Value(QString::fromLatin1(value->toString().c_str()));
     }
 }
 
 // convert from KisMetaData value to ExifVersion and FlashpixVersion
 Exiv2::Value* kmdValueToExifVersion(const KisMetaData::Value& value)
 {
     Exiv2::DataValue* dvalue = new Exiv2::DataValue;
     QString ver = value.asVariant().toString();
     dvalue->read((const Exiv2::byte*)ver.toLatin1().constData(), ver.size());
     return dvalue;
 }
 
 // Convert an exif array of integer string to a KisMetaData array of integer
 KisMetaData::Value exifArrayToKMDIntOrderedArray(const Exiv2::Value::AutoPtr value)
 {
     QList<KisMetaData::Value> v;
     const Exiv2::DataValue* dvalue = dynamic_cast<const Exiv2::DataValue*>(&*value);
     if (dvalue) {
         QByteArray array(dvalue->count(), 0);
         dvalue->copy((Exiv2::byte*)array.data());
         for (int i = 0; i < array.size(); i++) {
             QChar c((char)array[i]);
             v.push_back(KisMetaData::Value(QString(c).toInt(0)));
         }
     } else {
         Q_ASSERT(value->typeId() == Exiv2::asciiString);
         QString str = QString::fromLatin1(value->toString().c_str());
         v.push_back(KisMetaData::Value(str.toInt()));
     }
     return KisMetaData::Value(v, KisMetaData::Value::OrderedArray);
 }
 
 // Convert a KisMetaData array of integer to an exif array of integer string
 Exiv2::Value* kmdIntOrderedArrayToExifArray(const KisMetaData::Value& value)
 {
     QList<KisMetaData::Value> v = value.asArray();
     QByteArray s;
     for (QList<KisMetaData::Value>::iterator it = v.begin();
             it != v.end(); ++it) {
         int val = it->asVariant().toInt(0);
         s += QByteArray::number(val);
     }
     return new Exiv2::DataValue((const Exiv2::byte*)s.data(), s.size());
 }
 
 QDateTime exivValueToDateTime(const Exiv2::Value::AutoPtr value)
 {
     return QDateTime::fromString(value->toString().c_str(), Qt::ISODate);
 }
 
 template<typename T>
 inline T fixEndianess(T v, Exiv2::ByteOrder order)
 {
     switch (order) {
     case Exiv2::invalidByteOrder:
         return v;
     case Exiv2::littleEndian:
         return qFromLittleEndian<T>(v);
     case Exiv2::bigEndian:
         return qFromBigEndian<T>(v);
     }
     warnKrita << "KisExifIO: unknown byte order";
     return v;
 }
 
 Exiv2::ByteOrder invertByteOrder(Exiv2::ByteOrder order)
 {
     switch (order) {
     case Exiv2::littleEndian:
         return Exiv2::bigEndian;
     case Exiv2::bigEndian:
         return Exiv2::littleEndian;
     case Exiv2::invalidByteOrder:
         warnKrita << "KisExifIO: Can't invert Exiv2::invalidByteOrder";
         return Exiv2::invalidByteOrder;
     }
     return Exiv2::invalidByteOrder;
 }
 
 
 KisMetaData::Value exifOECFToKMDOECFStructure(const Exiv2::Value::AutoPtr value, Exiv2::ByteOrder order)
 {
     QMap<QString, KisMetaData::Value> oecfStructure;
     const Exiv2::DataValue* dvalue = dynamic_cast<const Exiv2::DataValue*>(&*value);
     Q_ASSERT(dvalue);
     QByteArray array(dvalue->count(), 0);
 
     dvalue->copy((Exiv2::byte*)array.data());
     int columns = fixEndianess<quint16>((reinterpret_cast<quint16*>(array.data()))[0], order);
     int rows = fixEndianess<quint16>((reinterpret_cast<quint16*>(array.data()))[1], order);
 
     if ((columns * rows + 4) > dvalue->count()) { // Sometime byteOrder get messed up (especially if metadata got saved with kexiv2 library, or any library that doesn't save back with the same byte order as the camera)
         order = invertByteOrder(order);
         columns = fixEndianess<quint16>((reinterpret_cast<quint16*>(array.data()))[0], order);
         rows = fixEndianess<quint16>((reinterpret_cast<quint16*>(array.data()))[1], order);
         Q_ASSERT((columns * rows + 4) > dvalue->count());
     }
     oecfStructure["Columns"] = KisMetaData::Value(columns);
     oecfStructure["Rows"] = KisMetaData::Value(rows);
     int index = 4;
     QList<KisMetaData::Value> names;
     for (int i = 0; i < columns; i++) {
         int lastIndex = array.indexOf((char)0, index);
         QString name = array.mid(index, lastIndex - index);
         if (index != lastIndex) {
             index = lastIndex + 1;
             dbgMetaData << "Name [" << i << "] =" << name;
             names.append(KisMetaData::Value(name));
         } else {
             names.append(KisMetaData::Value(""));
         }
     }
 
     oecfStructure["Names"] = KisMetaData::Value(names, KisMetaData::Value::OrderedArray);
     QList<KisMetaData::Value> values;
     qint32* dataIt = reinterpret_cast<qint32*>(array.data() + index);
     for (int i = 0; i < columns; i++) {
         for (int j = 0; j < rows; j++) {
             values.append(KisMetaData::Value(KisMetaData::Rational(fixEndianess<qint32>(dataIt[0], order), fixEndianess<qint32>(dataIt[1], order))));
             dataIt += 2;
         }
     }
     oecfStructure["Values"] = KisMetaData::Value(values, KisMetaData::Value::OrderedArray);
     dbgMetaData << "OECF: " << ppVar(columns) << ppVar(rows) << ppVar(dvalue->count());
     return KisMetaData::Value(oecfStructure);
 }
 
 Exiv2::Value* kmdOECFStructureToExifOECF(const KisMetaData::Value& value)
 {
     QMap<QString, KisMetaData::Value> oecfStructure = value.asStructure();
     quint16 columns = oecfStructure["Columns"].asVariant().toInt(0);
     quint16 rows = oecfStructure["Rows"].asVariant().toInt(0);
 
     QList<KisMetaData::Value> names = oecfStructure["Names"].asArray();
     QList<KisMetaData::Value> values = oecfStructure["Values"].asArray();
     Q_ASSERT(columns*rows == values.size());
     int length = 4 + rows * columns * 8; // The 4 byte for storing rows/columns and the rows*columns*sizeof(rational)
     bool saveNames = (!names.empty() && names[0].asVariant().toString().size() > 0);
     if (saveNames) {
         for (int i = 0; i < columns; i++) {
             length += names[i].asVariant().toString().size() + 1;
         }
     }
     QByteArray array(length, 0);
     (reinterpret_cast<quint16*>(array.data()))[0] = columns;
     (reinterpret_cast<quint16*>(array.data()))[1] = rows;
     int index = 4;
     if (saveNames) {
         for (int i = 0; i < columns; i++) {
             QByteArray name = names[i].asVariant().toString().toLatin1();
             name.append((char)0);
             memcpy(array.data() + index, name.data(), name.size());
             index += name.size();
         }
     }
     qint32* dataIt = reinterpret_cast<qint32*>(array.data() + index);
     for (QList<KisMetaData::Value>::iterator it = values.begin();
             it != values.end(); ++it) {
         dataIt[0] = it->asRational().numerator;
         dataIt[1] = it->asRational().denominator;
         dataIt += 2;
     }
     return new Exiv2::DataValue((const Exiv2::byte*)array.data(), array.size());
 }
 
 KisMetaData::Value deviceSettingDescriptionExifToKMD(const Exiv2::Value::AutoPtr value)
 {
     QMap<QString, KisMetaData::Value> deviceSettingStructure;
     QByteArray array;
 
     const Exiv2::DataValue* dvalue = dynamic_cast<const Exiv2::DataValue*>(&*value);
-    if(dvalue)
-    {
+    if (dvalue) {
         array.resize(dvalue->count());
         dvalue->copy((Exiv2::byte*)array.data());
     } else {
         Q_ASSERT(value->typeId() == Exiv2::unsignedShort);
         array.resize(2 * value->count());
         value->copy((Exiv2::byte*)array.data(), Exiv2::littleEndian);
     }
     int columns = (reinterpret_cast<quint16*>(array.data()))[0];
     int rows = (reinterpret_cast<quint16*>(array.data()))[1];
     deviceSettingStructure["Columns"] = KisMetaData::Value(columns);
     deviceSettingStructure["Rows"] = KisMetaData::Value(rows);
     QList<KisMetaData::Value> settings;
     QByteArray null(2, 0);
 
     for (int index = 4; index < array.size(); )
     {
         const int lastIndex = array.indexOf(null, index);
+        if (lastIndex < 0) break; // Data is not a String, ignore
         const int numChars = (lastIndex - index) / 2; // including trailing zero
 
         QString setting = QString::fromUtf16((ushort*)(void*)( array.data() + index), numChars);
         index = lastIndex + 2;
         dbgMetaData << "Setting << " << setting;
         settings.append(KisMetaData::Value(setting));
     }
     deviceSettingStructure["Settings"] = KisMetaData::Value(settings, KisMetaData::Value::OrderedArray);
     return KisMetaData::Value(deviceSettingStructure);
 }
 
 Exiv2::Value* deviceSettingDescriptionKMDToExif(const KisMetaData::Value& value)
 {
     QMap<QString, KisMetaData::Value> deviceSettingStructure = value.asStructure();
     quint16 columns = deviceSettingStructure["Columns"].asVariant().toInt(0);
     quint16 rows = deviceSettingStructure["Rows"].asVariant().toInt(0);
 
     QTextCodec* codec = QTextCodec::codecForName("UTF-16");
 
     QList<KisMetaData::Value> settings = deviceSettingStructure["Settings"].asArray();
     QByteArray array(4, 0);
     (reinterpret_cast<quint16*>(array.data()))[0] = columns;
     (reinterpret_cast<quint16*>(array.data()))[1] = rows;
     for (int i = 0; i < settings.count(); i++) {
         QString str = settings[i].asVariant().toString();
         QByteArray setting = codec->fromUnicode(str);
         array.append(setting);
     }
     return new Exiv2::DataValue((const Exiv2::byte*)array.data(), array.size());
 }
 
 KisMetaData::Value cfaPatternExifToKMD(const Exiv2::Value::AutoPtr value, Exiv2::ByteOrder order)
 {
     QMap<QString, KisMetaData::Value> cfaPatternStructure;
     const Exiv2::DataValue* dvalue = dynamic_cast<const Exiv2::DataValue*>(&*value);
     Q_ASSERT(dvalue);
     QByteArray array(dvalue->count(), 0);
     dvalue->copy((Exiv2::byte*)array.data());
     int columns = fixEndianess<quint16>((reinterpret_cast<quint16*>(array.data()))[0], order);
     int rows = fixEndianess<quint16>((reinterpret_cast<quint16*>(array.data()))[1], order);
     if ((columns * rows + 4) != dvalue->count()) { // Sometime byteOrder get messed up (especially if metadata got saved with kexiv2 library, or any library that doesn't save back with the same byte order as the camera)
         order = invertByteOrder(order);
         columns = fixEndianess<quint16>((reinterpret_cast<quint16*>(array.data()))[0], order);
         rows = fixEndianess<quint16>((reinterpret_cast<quint16*>(array.data()))[1], order);
         Q_ASSERT((columns * rows + 4) == dvalue->count());
     }
     cfaPatternStructure["Columns"] = KisMetaData::Value(columns);
     cfaPatternStructure["Rows"] = KisMetaData::Value(rows);
     QList<KisMetaData::Value> values;
     int index = 4;
     for (int i = 0; i < columns * rows; i++) {
         values.append(KisMetaData::Value(*(array.data() + index)));
         index++;
     }
     cfaPatternStructure["Values"] = KisMetaData::Value(values, KisMetaData::Value::OrderedArray);
     dbgMetaData << "CFAPattern " << ppVar(columns) << " " << ppVar(rows) << ppVar(values.size()) << ppVar(dvalue->count());
     return KisMetaData::Value(cfaPatternStructure);
 }
 
 Exiv2::Value* cfaPatternKMDToExif(const KisMetaData::Value& value)
 {
     QMap<QString, KisMetaData::Value> cfaStructure = value.asStructure();
     quint16 columns = cfaStructure["Columns"].asVariant().toInt(0);
     quint16 rows = cfaStructure["Rows"].asVariant().toInt(0);
 
     QList<KisMetaData::Value> values = cfaStructure["Values"].asArray();
     Q_ASSERT(columns*rows == values.size());
     QByteArray array(4 + columns*rows, 0);
     (reinterpret_cast<quint16*>(array.data()))[0] = columns;
     (reinterpret_cast<quint16*>(array.data()))[1] = rows;
     for (int i = 0; i < columns * rows; i++) {
         quint8 val = values[i].asVariant().toUInt();
         *(array.data() + 4 + i) = val;
     }
     dbgMetaData << "Cfa Array " << ppVar(columns) << ppVar(rows) << ppVar(array.size());
     return new Exiv2::DataValue((const Exiv2::byte*)array.data(), array.size());
 }
 
 // Read and write Flash //
 
 KisMetaData::Value flashExifToKMD(const Exiv2::Value::AutoPtr value)
 {
     uint16_t v = value->toLong();
     QMap<QString, KisMetaData::Value> flashStructure;
     bool fired = (v & 0x01);  // bit 1 is whether flash was fired or not
     flashStructure["Fired"] = QVariant(fired);
     int ret = ((v >> 1) & 0x03);  // bit 2 and 3 are Return
     flashStructure["Return"] = QVariant(ret);
     int mode = ((v >> 3) & 0x03);  // bit 4 and 5 are Mode
     flashStructure["Mode"] = QVariant(mode);
     bool function = ((v >> 5) & 0x01);  // bit 6 if function
     flashStructure["Function"] = QVariant(function);
     bool redEye = ((v >> 6) & 0x01);  // bit 7 if function
     flashStructure["RedEyeMode"] = QVariant(redEye);
     return KisMetaData::Value(flashStructure);
 }
 
 Exiv2::Value* flashKMDToExif(const KisMetaData::Value& value)
 {
     uint16_t v = 0;
     QMap<QString, KisMetaData::Value> flashStructure = value.asStructure();
     v = flashStructure["Fired"].asVariant().toBool();
     v |= ((flashStructure["Return"].asVariant().toInt() & 0x03) << 1);
     v |= ((flashStructure["Mode"].asVariant().toInt() & 0x03) << 3);
     v |= ((flashStructure["Function"].asVariant().toInt() & 0x03) << 5);
     v |= ((flashStructure["RedEyeMode"].asVariant().toInt() & 0x03) << 6);
     return new Exiv2::ValueType<uint16_t>(v);
 }
 
 
 
 // ---- Implementation of KisExifIO ----//
 KisExifIO::KisExifIO() : d(new Private)
 {
 }
 
 KisExifIO::~KisExifIO()
 {
     delete d;
 }
 
 
 bool KisExifIO::saveTo(KisMetaData::Store* store, QIODevice* ioDevice, HeaderType headerType) const
 {
     ioDevice->open(QIODevice::WriteOnly);
     Exiv2::ExifData exifData;
     if (headerType == KisMetaData::IOBackend::JpegHeader) {
         QByteArray header(6, 0);
         header[0] = 0x45;
         header[1] = 0x78;
         header[2] = 0x69;
         header[3] = 0x66;
         header[4] = 0x00;
         header[5] = 0x00;
         ioDevice->write(header);
     }
 
     for (QHash<QString, KisMetaData::Entry>::const_iterator it = store->begin();
             it != store->end(); ++it) {
         try {
             const KisMetaData::Entry& entry = *it;
             dbgMetaData << "Trying to save: " << entry.name() << " of " << entry.schema()->prefix() << ":" << entry.schema()->uri();
             QString exivKey;
             if (entry.schema()->uri() == KisMetaData::Schema::TIFFSchemaUri) {
                 exivKey = "Exif.Image." + entry.name();
             } else if (entry.schema()->uri() == KisMetaData::Schema::EXIFSchemaUri) { // Distinguish between exif and gps
                 if (entry.name().left(3) == "GPS") {
                     exivKey = "Exif.GPS." + entry.name();
                 } else {
                     exivKey = "Exif.Photo." + entry.name();
                 }
             } else if (entry.schema()->uri() == KisMetaData::Schema::DublinCoreSchemaUri) {
                 if (entry.name() == "description") {
                     exivKey = "Exif.Image.ImageDescription";
                 } else if (entry.name() == "creator") {
                     exivKey = "Exif.Image.Artist";
                 } else if (entry.name() == "rights") {
                     exivKey = "Exif.Image.Copyright";
                 }
             } else if (entry.schema()->uri() == KisMetaData::Schema::XMPSchemaUri) {
                 if (entry.name() == "ModifyDate") {
                     exivKey = "Exif.Image.DateTime";
                 } else if (entry.name() == "CreatorTool") {
                     exivKey = "Exif.Image.Software";
                 }
             } else if (entry.schema()->uri() == KisMetaData::Schema::MakerNoteSchemaUri) {
                 if (entry.name() == "RawData") {
                     exivKey = "Exif.Photo.MakerNote";
                 }
             }
             dbgMetaData << "Saving " << entry.name() << " to " << exivKey;
             if (exivKey.isEmpty()) {
                 dbgMetaData << entry.qualifiedName() << " is unsavable to EXIF";
             } else {
                 Exiv2::ExifKey exifKey(qPrintable(exivKey));
                 Exiv2::Value* v = 0;
                 if (exivKey == "Exif.Photo.ExifVersion" || exivKey == "Exif.Photo.FlashpixVersion") {
                     v = kmdValueToExifVersion(entry.value());
                 } else if (exivKey == "Exif.Photo.FileSource") {
                     char s[] = { 0x03 };
                     v = new Exiv2::DataValue((const Exiv2::byte*)s, 1);
                 } else if (exivKey == "Exif.Photo.SceneType") {
                     char s[] = { 0x01 };
                     v = new Exiv2::DataValue((const Exiv2::byte*)s, 1);
                 } else if (exivKey == "Exif.Photo.ComponentsConfiguration") {
                     v = kmdIntOrderedArrayToExifArray(entry.value());
                 } else if (exivKey == "Exif.Image.Artist") { // load as dc:creator
                     KisMetaData::Value creator = entry.value();
                     if (entry.value().asArray().size() > 0) {
                         creator = entry.value().asArray()[0];
                     }
 #if !EXIV2_TEST_VERSION(0,21,0)
                     v = kmdValueToExivValue(creator, Exiv2::ExifTags::tagType(exifKey.tag(), exifKey.ifdId()));
 #else
                     v = kmdValueToExivValue(creator, exifKey.defaultTypeId());
 #endif
                 } else if (exivKey == "Exif.Photo.OECF") {
                     v = kmdOECFStructureToExifOECF(entry.value());
                 } else if (exivKey == "Exif.Photo.DeviceSettingDescription") {
                     v = deviceSettingDescriptionKMDToExif(entry.value());
                 } else if (exivKey == "Exif.Photo.CFAPattern") {
                     v = cfaPatternKMDToExif(entry.value());
                 } else if (exivKey == "Exif.Photo.Flash") {
                     v = flashKMDToExif(entry.value());
                 } else if (exivKey == "Exif.Photo.UserComment") {
                     Q_ASSERT(entry.value().type() == KisMetaData::Value::LangArray);
                     QMap<QString, KisMetaData::Value> langArr = entry.value().asLangArray();
                     if (langArr.contains("x-default")) {
 #if !EXIV2_TEST_VERSION(0,21,0)
                         v = kmdValueToExivValue(langArr.value("x-default"), Exiv2::ExifTags::tagType(exifKey.tag(), exifKey.ifdId()));
 #else
                         v = kmdValueToExivValue(langArr.value("x-default"), exifKey.defaultTypeId());
 #endif
                     } else if (langArr.size() > 0) {
 #if !EXIV2_TEST_VERSION(0,21,0)
                         v = kmdValueToExivValue(langArr.begin().value(), Exiv2::ExifTags::tagType(exifKey.tag(), exifKey.ifdId()));
 #else
                         v = kmdValueToExivValue(langArr.begin().value(), exifKey.defaultTypeId());
 #endif
                     }
                 } else {
                     dbgMetaData << exifKey.tag();
 #if !EXIV2_TEST_VERSION(0,21,0)
                     v = kmdValueToExivValue(entry.value(), Exiv2::ExifTags::tagType(exifKey.tag(), exifKey.ifdId()));
 #else
                     v = kmdValueToExivValue(entry.value(), exifKey.defaultTypeId());
 #endif
                 }
                 if (v && v->typeId() != Exiv2::invalidTypeId) {
                     dbgMetaData << "Saving key" << exivKey << " of KMD value" << entry.value();
                     exifData.add(exifKey, v);
                 } else {
                     dbgMetaData << "No exif value was created for" << entry.qualifiedName() << " as" << exivKey;// << " of KMD value" << entry.value();
                 }
             }
         } catch (Exiv2::AnyError& e) {
             dbgMetaData << "exiv error " << e.what();
         }
     }
 #if !EXIV2_TEST_VERSION(0,18,0)
     Exiv2::DataBuf rawData = exifData.copy();
     ioDevice->write((const char*) rawData.pData_, rawData.size_);
 #else
     Exiv2::Blob rawData;
     Exiv2::ExifParser::encode(rawData, Exiv2::littleEndian, exifData);
     ioDevice->write((const char*) &*rawData.begin(), rawData.size());
 #endif
     ioDevice->close();
     return true;
 }
 
 bool KisExifIO::canSaveAllEntries(KisMetaData::Store* /*store*/) const
 {
     return false; // It's a known fact that exif can't save all information, but TODO: write the check
 }
 
 
 bool KisExifIO::loadFrom(KisMetaData::Store* store, QIODevice* ioDevice) const
 {
     ioDevice->open(QIODevice::ReadOnly);
     if (!ioDevice->isOpen()) {
         return false;
     }
     QByteArray arr = ioDevice->readAll();
     Exiv2::ExifData exifData;
     Exiv2::ByteOrder byteOrder;
 #if !EXIV2_TEST_VERSION(0,18,0)
     exifData.load((const Exiv2::byte*)arr.data(), arr.size());
     byteOrder = exifData.byteOrder();
 #else
     try {
         byteOrder = Exiv2::ExifParser::decode(exifData, (const Exiv2::byte*)arr.data(), arr.size());
     }
     catch (const std::exception& ex) {
         warnKrita << "Received exception trying to parse exiv data" << ex.what();
         return false;
     }
     catch (...) {
         dbgKrita << "Received unknown exception trying to parse exiv data";
         return false;
     }
 #endif
     dbgMetaData << "Byte order = " << byteOrder << ppVar(Exiv2::bigEndian) << ppVar(Exiv2::littleEndian);
     dbgMetaData << "There are" << exifData.count() << " entries in the exif section";
     const KisMetaData::Schema* tiffSchema = KisMetaData::SchemaRegistry::instance()->schemaFromUri(KisMetaData::Schema::TIFFSchemaUri);
     Q_ASSERT(tiffSchema);
     const KisMetaData::Schema* exifSchema = KisMetaData::SchemaRegistry::instance()->schemaFromUri(KisMetaData::Schema::EXIFSchemaUri);
     Q_ASSERT(exifSchema);
     const KisMetaData::Schema* dcSchema = KisMetaData::SchemaRegistry::instance()->schemaFromUri(KisMetaData::Schema::DublinCoreSchemaUri);
     Q_ASSERT(dcSchema);
     const KisMetaData::Schema* xmpSchema = KisMetaData::SchemaRegistry::instance()->schemaFromUri(KisMetaData::Schema::XMPSchemaUri);
     Q_ASSERT(xmpSchema);
     for (Exiv2::ExifMetadata::const_iterator it = exifData.begin();
             it != exifData.end(); ++it) {
         if (it->key() == "Exif.Photo.StripOffsets"
                 || it->key() == "RowsPerStrip"
                 || it->key() == "StripByteCounts"
                 || it->key() == "JPEGInterchangeFormat"
                 || it->key() == "JPEGInterchangeFormatLength"
                 || it->tagName() == "0x0000" ) {
             dbgMetaData << it->key().c_str() << " is ignored";
         } else if (it->key() == "Exif.Photo.MakerNote") {
             const KisMetaData::Schema* makerNoteSchema = KisMetaData::SchemaRegistry::instance()->schemaFromUri(KisMetaData::Schema::MakerNoteSchemaUri);
             store->addEntry(KisMetaData::Entry(makerNoteSchema, "RawData", exivValueToKMDValue(it->getValue(), false)));
         } else if (it->key() == "Exif.Image.DateTime") { // load as xmp:ModifyDate
             store->addEntry(KisMetaData::Entry(xmpSchema, "ModifyDate", KisMetaData::Value(exivValueToDateTime(it->getValue()))));
         } else if (it->key() == "Exif.Image.ImageDescription") { // load as "dc:description"
             store->addEntry(KisMetaData::Entry(dcSchema, "description", exivValueToKMDValue(it->getValue(), false)));
         } else if (it->key() == "Exif.Image.Software") { // load as "xmp:CreatorTool"
             store->addEntry(KisMetaData::Entry(xmpSchema, "CreatorTool", exivValueToKMDValue(it->getValue(), false)));
         } else if (it->key() == "Exif.Image.Artist") { // load as dc:creator
             QList<KisMetaData::Value> creators;
             creators.push_back(exivValueToKMDValue(it->getValue(), false));
             store->addEntry(KisMetaData::Entry(dcSchema, "creator", KisMetaData::Value(creators, KisMetaData::Value::OrderedArray)));
         } else if (it->key() == "Exif.Image.Copyright") { // load as dc:rights
             store->addEntry(KisMetaData::Entry(dcSchema, "rights", exivValueToKMDValue(it->getValue(), false)));
         } else if (it->groupName() == "Image") {
             // Tiff tags
             QString fixedTN = it->tagName().c_str();
             if (it->key() == "Exif.Image.ExifTag") {
                 dbgMetaData << "Ignoring " << it->key().c_str();
             } else if (KisMetaData::Entry::isValidName(fixedTN)) {
                 store->addEntry(KisMetaData::Entry(tiffSchema, fixedTN, exivValueToKMDValue(it->getValue(), false))) ;
             } else {
                 dbgMetaData << "Invalid tag name: " << fixedTN;
             }
         } else if (it->groupName() == "Photo" || (it->groupName() == "GPS")) {
             // Exif tags (and GPS tags)
             KisMetaData::Value metaDataValue;
             if (it->key() == "Exif.Photo.ExifVersion" || it->key() == "Exif.Photo.FlashpixVersion") {
                 metaDataValue = exifVersionToKMDValue(it->getValue());
             } else if (it->key() == "Exif.Photo.FileSource") {
                 metaDataValue = KisMetaData::Value(3);
             } else if (it->key() == "Exif.Photo.SceneType") {
                 metaDataValue = KisMetaData::Value(1);
             } else if (it->key() == "Exif.Photo.ComponentsConfiguration") {
                 metaDataValue = exifArrayToKMDIntOrderedArray(it->getValue());
             } else if (it->key() == "Exif.Photo.OECF") {
                 metaDataValue = exifOECFToKMDOECFStructure(it->getValue(), byteOrder);
             } else if (it->key() == "Exif.Photo.DateTimeDigitized" || it->key() == "Exif.Photo.DateTimeOriginal") {
                 metaDataValue = KisMetaData::Value(exivValueToDateTime(it->getValue()));
             } else if (it->key() == "Exif.Photo.DeviceSettingDescription") {
                 metaDataValue = deviceSettingDescriptionExifToKMD(it->getValue());
             } else if (it->key() == "Exif.Photo.CFAPattern") {
                 metaDataValue = cfaPatternExifToKMD(it->getValue(), byteOrder);
             } else if (it->key() == "Exif.Photo.Flash") {
                 metaDataValue = flashExifToKMD(it->getValue());
             } else if (it->key() == "Exif.Photo.UserComment") {
                 if (it->getValue()->typeId() != Exiv2::undefined) {
                     KisMetaData::Value vUC = exivValueToKMDValue(it->getValue(), false);
                     Q_ASSERT(vUC.type() == KisMetaData::Value::Variant);
                     QVariant commentVar = vUC.asVariant();
                     QString comment;
                     if (commentVar.type() == QVariant::String) {
                         comment = commentVar.toString();
                     } else if (commentVar.type() == QVariant::ByteArray) {
                         const QByteArray commentString = commentVar.toByteArray();
                         comment = QString::fromLatin1(commentString.constData(), commentString.size());
                     } else {
                         warnKrita << "KisExifIO: Unhandled UserComment value type.";
                     }
                     KisMetaData::Value vcomment(comment);
                     vcomment.addPropertyQualifier("xml:lang", KisMetaData::Value("x-default"));
                     QList<KisMetaData::Value> alt;
                     alt.append(vcomment);
                     metaDataValue = KisMetaData::Value(alt, KisMetaData::Value::LangArray);
                 }
             } else {
                 bool forceSeq = false;
                 KisMetaData::Value::ValueType arrayType = KisMetaData::Value::UnorderedArray;
                 if (it->key() == "Exif.Photo.ISOSpeedRatings") {
                     forceSeq = true;
                     arrayType = KisMetaData::Value::OrderedArray;
                 }
                 metaDataValue = exivValueToKMDValue(it->getValue(), forceSeq, arrayType);
             }
             if (it->key() == "Exif.Photo.InteroperabilityTag" || it->key() == "Exif.Photo.0xea1d" || metaDataValue.type() == KisMetaData::Value::Invalid) { // InteroperabilityTag isn't useful for XMP, 0xea1d isn't a valid Exif tag
                 warnMetaData << "Ignoring " << it->key().c_str();
             } else {
                 store->addEntry(KisMetaData::Entry(exifSchema, it->tagName().c_str(), metaDataValue));
             }
         } else if (it->groupName() == "Thumbnail") {
             dbgMetaData << "Ignoring thumbnail tag :" << it->key().c_str();
         } else {
             dbgMetaData << "Unknown exif tag, cannot load:" << it->key().c_str();
         }
     }
     ioDevice->close();
     return true;
 }
diff --git a/libs/ui/tests/FreehandStrokeBenchmark.cpp b/libs/ui/tests/FreehandStrokeBenchmark.cpp
index 74c3c29bc4..ade91fc02b 100644
--- a/libs/ui/tests/FreehandStrokeBenchmark.cpp
+++ b/libs/ui/tests/FreehandStrokeBenchmark.cpp
@@ -1,155 +1,157 @@
 /*
  *  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 "FreehandStrokeBenchmark.h"
 
 #include <QTest>
 #include <KoCompositeOpRegistry.h>
 #include <KoColor.h>
 #include "stroke_testing_utils.h"
 #include "strokes/freehand_stroke.h"
 #include "strokes/KisFreehandStrokeInfo.h"
+#include "KisAsyncronousStrokeUpdateHelper.h"
 #include "kis_resources_snapshot.h"
 #include "kis_image.h"
 #include <brushengine/kis_paint_information.h>
 
+
 class FreehandStrokeBenchmarkTester : public utils::StrokeTester
 {
 public:
     FreehandStrokeBenchmarkTester(const QString &presetFilename)
         : StrokeTester("freehand_benchmark", QSize(5000, 5000), presetFilename)
     {
         setBaseFuzziness(3);
     }
 
     void setCpuCoresLimit(int value) {
         m_cpuCoresLimit = value;
     }
 
 protected:
     using utils::StrokeTester::initImage;
     void initImage(KisImageWSP image, KisNodeSP activeNode) override {
         Q_UNUSED(activeNode);
 
         if (m_cpuCoresLimit > 0) {
             image->setWorkingThreadsLimit(m_cpuCoresLimit);
         }
     }
 
     KisStrokeStrategy* createStroke(KisResourcesSnapshotSP resources,
                                     KisImageWSP image) override {
         Q_UNUSED(image);
 
         KisFreehandStrokeInfo *strokeInfo = new KisFreehandStrokeInfo();
 
         QScopedPointer<FreehandStrokeStrategy> stroke(
             new FreehandStrokeStrategy(resources, strokeInfo, kundo2_noi18n("Freehand Stroke")));
 
         return stroke.take();
     }
 
     void addPaintingJobs(KisImageWSP image,
                                  KisResourcesSnapshotSP resources) override
     {
         addPaintingJobs(image, resources, 0);
     }
 
     void addPaintingJobs(KisImageWSP image, KisResourcesSnapshotSP resources, int iteration) override {
         Q_UNUSED(iteration);
         Q_UNUSED(resources);
 
         for (int y = 100; y < 4900; y += 300) {
             KisPaintInformation pi1;
             KisPaintInformation pi2;
 
             pi1 = KisPaintInformation(QPointF(100, y), 0.5);
             pi2 = KisPaintInformation(QPointF(4900, y + 100), 1.0);
 
             QScopedPointer<KisStrokeJobData> data(
                 new FreehandStrokeStrategy::Data(0, pi1, pi2));
 
             image->addJob(strokeId(), data.take());
         }
 
-        image->addJob(strokeId(), new FreehandStrokeStrategy::UpdateData(true));
+        image->addJob(strokeId(), new KisAsyncronousStrokeUpdateHelper::UpdateData(true));
     }
 
 private:
     int m_cpuCoresLimit = -1;
 };
 
 void benchmarkBrush(const QString &presetName)
 {
     FreehandStrokeBenchmarkTester tester(presetName);
 
     for (int i = 1; i <= QThread::idealThreadCount(); i++) {
         tester.setCpuCoresLimit(i);
         tester.benchmark();
 
         qDebug() << qPrintable(QString("Cores: %1 Time: %2 (ms)").arg(i).arg(tester.lastStrokeTime()));
     }
 }
 
 #include <KoResourcePaths.h>
 
 void FreehandStrokeBenchmark::initTestCase()
 {
     KoResourcePaths::addResourceType("kis_brushes", "data", FILES_DATA_DIR);
 }
 
 void FreehandStrokeBenchmark::testDefaultTip()
 {
     benchmarkBrush("testing_1000px_auto_deafult.kpp");
 }
 
 void FreehandStrokeBenchmark::testSoftTip()
 {
     benchmarkBrush("testing_1000px_auto_soft.kpp");
 }
 
 void FreehandStrokeBenchmark::testGaussianTip()
 {
     benchmarkBrush("testing_1000px_auto_gaussian.kpp");
 }
 
 void FreehandStrokeBenchmark::testRectangularTip()
 {
     benchmarkBrush("testing_1000px_auto_rectangular.kpp");
 }
 
 void FreehandStrokeBenchmark::testRectGaussianTip()
 {
     benchmarkBrush("testing_1000px_auto_gaussian_rect.kpp");
 }
 
 void FreehandStrokeBenchmark::testRectSoftTip()
 {
     benchmarkBrush("testing_1000px_auto_soft_rect.kpp");
 }
 
 void FreehandStrokeBenchmark::testStampTip()
 {
     benchmarkBrush("testing_1000px_stamp_450_rotated.kpp");
 }
 
 void FreehandStrokeBenchmark::testColorsmudgeDefaultTip()
 {
     benchmarkBrush("testing_200px_colorsmudge_default.kpp");
 }
 
 QTEST_MAIN(FreehandStrokeBenchmark)
diff --git a/libs/ui/tests/KisPaintOnTransparencyMaskTest.cpp b/libs/ui/tests/KisPaintOnTransparencyMaskTest.cpp
index 6813164c0e..953e93caff 100644
--- a/libs/ui/tests/KisPaintOnTransparencyMaskTest.cpp
+++ b/libs/ui/tests/KisPaintOnTransparencyMaskTest.cpp
@@ -1,134 +1,135 @@
 #include "KisPaintOnTransparencyMaskTest.h"
 
 #include <QTest>
 #include <KoCompositeOpRegistry.h>
 #include <KoColor.h>
 #include "stroke_testing_utils.h"
 #include "strokes/freehand_stroke.h"
 #include "strokes/KisFreehandStrokeInfo.h"
+#include "KisAsyncronousStrokeUpdateHelper.h"
 #include "kis_resources_snapshot.h"
 #include "kis_image.h"
 #include <brushengine/kis_paint_information.h>
 #include "kis_transparency_mask.h"
 
 #include "kis_paint_device_debug_utils.h"
 #include "kis_tool_utils.h"
 
 #include "kis_sequential_iterator.h"
 
 class PaintOnTransparencyMaskTester : public utils::StrokeTester
 {
 public:
     PaintOnTransparencyMaskTester(const QString &presetFilename)
         : StrokeTester("freehand_benchmark", QSize(5000, 5000), presetFilename)
     {
         setBaseFuzziness(3);
     }
 
 protected:
     using utils::StrokeTester::initImage;
     void initImage(KisImageWSP image, KisNodeSP activeNode) override {
 
         activeNode->paintDevice()->fill(QRect(0,0,1024,1024), KoColor(Qt::red, image->colorSpace()));
         m_mask = new KisTransparencyMask();
         m_mask->setSelection(new KisSelection());
         m_mask->paintDevice()->clear();
         image->addNode(m_mask, activeNode);
         image->setWorkingThreadsLimit(8);
     }
 
     using utils::StrokeTester::modifyResourceManager;
     void modifyResourceManager(KoCanvasResourceProvider *manager,
                                KisImageWSP image) override {
 
         KoColor color(Qt::red, image->colorSpace());
         color.setOpacity(0.5);
 
         QVariant i;
         i.setValue(color);
         manager->setResource(KoCanvasResourceProvider::ForegroundColor, i);
     }
 
     KisStrokeStrategy* createStroke(KisResourcesSnapshotSP resources,
                                     KisImageWSP image) override {
         Q_UNUSED(image);
 
         resources->setCurrentNode(m_mask);
 
         KisFreehandStrokeInfo *strokeInfo = new KisFreehandStrokeInfo();
 
         QScopedPointer<FreehandStrokeStrategy> stroke(
             new FreehandStrokeStrategy(resources, strokeInfo, kundo2_noi18n("Freehand Stroke")));
 
         return stroke.take();
     }
 
     void addPaintingJobs(KisImageWSP image,
                                  KisResourcesSnapshotSP resources) override
     {
         addPaintingJobs(image, resources, 0);
     }
 
     void addPaintingJobs(KisImageWSP image, KisResourcesSnapshotSP resources, int iteration) override {
         Q_UNUSED(iteration);
         Q_UNUSED(resources);
 
 
         KisPaintInformation pi1;
         KisPaintInformation pi2;
 
         pi1 = KisPaintInformation(QPointF(100, 100), 1.0);
         pi2 = KisPaintInformation(QPointF(800, 800), 1.0);
 
         QScopedPointer<KisStrokeJobData> data(
                     new FreehandStrokeStrategy::Data(0, pi1, pi2));
 
         image->addJob(strokeId(), data.take());
 
-        image->addJob(strokeId(), new FreehandStrokeStrategy::UpdateData(true));
+        image->addJob(strokeId(), new KisAsyncronousStrokeUpdateHelper::UpdateData(true));
     }
 
 
     void checkDeviceIsEmpty(KisPaintDeviceSP dev, const QString &name)
     {
         const KoColorSpace *cs = dev->colorSpace();
         KisSequentialConstIterator it(dev, QRect(0,0,1024,1024));
         while (it.nextPixel()) {
             if (cs->opacityU8(it.rawDataConst()) > 0) {
                 KIS_DUMP_DEVICE_2(dev, QRect(0,0,1024,1024), "image", "dd");
                 qFatal("%s", QString("failed: %1").arg(name).toLatin1().data());
             }
         }
     }
 
     void beforeCheckingResult(KisImageWSP image, KisNodeSP activeNode) override {
         ENTER_FUNCTION() << ppVar(image) << ppVar(activeNode);
 
         KisToolUtils::clearImage(image, activeNode, 0);
         image->waitForDone();
 
         checkDeviceIsEmpty(m_mask->paintDevice(), "mask");
         checkDeviceIsEmpty(m_mask->parent()->projection(), "projection");
         checkDeviceIsEmpty(image->projection(), "image");
     }
 
 private:
     KisMaskSP m_mask;
 };
 
 #include <KoResourcePaths.h>
 
 void KisPaintOnTransparencyMaskTest::initTestCase()
 {
     KoResourcePaths::addResourceType("kis_brushes", "data", FILES_DATA_DIR);
 }
 
 void KisPaintOnTransparencyMaskTest::test()
 {
     for (int i = 0; i < 1000; i++) {
         PaintOnTransparencyMaskTester tester("testing_wet_circle.kpp");
         tester.testSimpleStrokeNoVerification();
     }
 }
 
 QTEST_MAIN(KisPaintOnTransparencyMaskTest)
diff --git a/libs/ui/tests/freehand_stroke_test.cpp b/libs/ui/tests/freehand_stroke_test.cpp
index 1ae19b8c5b..cabbf81207 100644
--- a/libs/ui/tests/freehand_stroke_test.cpp
+++ b/libs/ui/tests/freehand_stroke_test.cpp
@@ -1,189 +1,190 @@
 /*
  *  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_test.h"
 
 #include <QTest>
 #include <KoCompositeOpRegistry.h>
 #include <KoColor.h>
 #include "stroke_testing_utils.h"
 #include "strokes/freehand_stroke.h"
 #include "strokes/KisFreehandStrokeInfo.h"
+#include "KisAsyncronousStrokeUpdateHelper.h"
 #include "kis_resources_snapshot.h"
 #include "kis_image.h"
 #include "kis_painter.h"
 #include <brushengine/kis_paint_information.h>
 
 #include "kistest.h"
 
 class FreehandStrokeTester : public utils::StrokeTester
 {
 public:
     FreehandStrokeTester(const QString &presetFilename, bool useLod = false)
         : StrokeTester(useLod ? "freehand-lod" : "freehand", QSize(500, 500), presetFilename),
           m_useLod(useLod),
           m_flipLineDirection(false)
     {
         setBaseFuzziness(3);
     }
 
     void setFlipLineDirection(bool value) {
         m_flipLineDirection = value;
         setNumIterations(2);
     }
 
     void setPaintColor(const QColor &color) {
         m_paintColor.reset(new QColor(color));
     }
 
 protected:
     using utils::StrokeTester::initImage;
     void initImage(KisImageWSP image, KisNodeSP activeNode) override {
         Q_UNUSED(activeNode);
 
         if (m_useLod) {
             image->setDesiredLevelOfDetail(1);
         }
     }
 
     void beforeCheckingResult(KisImageWSP image, KisNodeSP activeNode) override {
         Q_UNUSED(image)
         Q_UNUSED(activeNode);
 
         if (m_useLod) {
             //image->testingSetLevelOfDetailsEnabled(true);
         }
     }
 
     void modifyResourceManager(KoCanvasResourceProvider *manager,
                                KisImageWSP image) override
     {
         modifyResourceManager(manager, image, 0);
     }
 
 
     void modifyResourceManager(KoCanvasResourceProvider *manager,
                                KisImageWSP image,
                                int iteration) override {
 
         if (m_paintColor && iteration > 0) {
             QVariant i;
             i.setValue(KoColor(*m_paintColor, image->colorSpace()));
             manager->setResource(KoCanvasResourceProvider::ForegroundColor, i);
         }
     }
 
     KisStrokeStrategy* createStroke(KisResourcesSnapshotSP resources,
                                     KisImageWSP image) override {
         Q_UNUSED(image);
 
         KisFreehandStrokeInfo *strokeInfo = new KisFreehandStrokeInfo();
 
         QScopedPointer<FreehandStrokeStrategy> stroke(
             new FreehandStrokeStrategy(resources, strokeInfo, kundo2_noi18n("Freehand Stroke")));
 
         return stroke.take();
     }
 
     void addPaintingJobs(KisImageWSP image,
                                  KisResourcesSnapshotSP resources) override
     {
         addPaintingJobs(image, resources, 0);
     }
 
     void addPaintingJobs(KisImageWSP image, KisResourcesSnapshotSP resources, int iteration) override {
         Q_UNUSED(resources);
 
         KisPaintInformation pi1;
         KisPaintInformation pi2;
 
         if (!iteration) {
             pi1 = KisPaintInformation(QPointF(200, 200));
             pi2 = KisPaintInformation(QPointF(300, 300));
         } else {
             pi1 = KisPaintInformation(QPointF(200, 300));
             pi2 = KisPaintInformation(QPointF(300, 200));
         }
 
         QScopedPointer<KisStrokeJobData> data(
             new FreehandStrokeStrategy::Data(0, pi1, pi2));
 
         image->addJob(strokeId(), data.take());
-        image->addJob(strokeId(), new FreehandStrokeStrategy::UpdateData(true));
+        image->addJob(strokeId(), new KisAsyncronousStrokeUpdateHelper::UpdateData(true));
     }
 
 private:
     bool m_useLod;
     bool m_flipLineDirection;
     QScopedPointer<QColor> m_paintColor;
 };
 
 void FreehandStrokeTest::testAutoBrushStroke()
 {
     FreehandStrokeTester tester("autobrush_300px.kpp");
     tester.test();
 }
 
 void FreehandStrokeTest::testHatchingStroke()
 {
     FreehandStrokeTester tester("hatching_30px.kpp");
     tester.test();
 }
 
 void FreehandStrokeTest::testColorSmudgeStroke()
 {
     FreehandStrokeTester tester("colorsmudge_predefined.kpp");
     tester.test();
 }
 
 void FreehandStrokeTest::testAutoTextured17()
 {
     FreehandStrokeTester tester("auto_textured_17.kpp");
     tester.test();
 }
 
 void FreehandStrokeTest::testAutoTextured38()
 {
     FreehandStrokeTester tester("auto_textured_38.kpp");
     tester.test();
 }
 
 void FreehandStrokeTest::testMixDullCompositioning()
 {
     FreehandStrokeTester tester("Mix_dull.kpp");
     tester.setFlipLineDirection(true);
     tester.setPaintColor(Qt::red);
     tester.test();
 }
 
 void FreehandStrokeTest::testAutoBrushStrokeLod()
 {
     FreehandStrokeTester tester("Basic_tip_default.kpp", true);
     tester.testSimpleStroke();
 }
 
 void FreehandStrokeTest::testPredefinedBrushStrokeLod()
 {
     qsrand(QTime::currentTime().msec());
 
     FreehandStrokeTester tester("testing_predefined_lod_spc13.kpp", true);
     //FreehandStrokeTester tester("testing_predefined_lod.kpp", true);
     tester.testSimpleStroke();
 }
 
 KISTEST_MAIN(FreehandStrokeTest)
diff --git a/libs/ui/tests/kis_action_manager_test.cpp b/libs/ui/tests/kis_action_manager_test.cpp
index b6e7319b98..d68c08dfe5 100644
--- a/libs/ui/tests/kis_action_manager_test.cpp
+++ b/libs/ui/tests/kis_action_manager_test.cpp
@@ -1,135 +1,135 @@
 
 /*
  *  Copyright (c) 2013 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 
 #include "kis_action_manager_test.h"
 #include <kis_debug.h>
 
 #include <KisPart.h>
 #include <KisMainWindow.h>
 #include <KisDocument.h>
 #include <KisView.h>
 #include <util.h>
 #include <kis_action.h>
 #include <kis_action_manager.h>
 #include <KisViewManager.h>
 
 #include "kis_node_manager.h"
 #include <kistest.h>
 
 void KisActionManagerTest::testUpdateGUI()
 {
     KisDocument* doc = createEmptyDocument();
     KisMainWindow* mainWindow = KisPart::instance()->createMainWindow();
-    QPointer<KisView> view = new KisView(doc, mainWindow->resourceManager(), mainWindow->actionCollection(), mainWindow);
+    QPointer<KisView> view = new KisView(doc, mainWindow->viewManager(), mainWindow);
     KisViewManager *viewManager = new KisViewManager(mainWindow, mainWindow->actionCollection());
     KisPart::instance()->addView(view);
     mainWindow->showView(view);
 
     view->setViewManager(viewManager);
     viewManager->setCurrentView(view);
 
     KisAction* action = new KisAction("dummy", this);
     action->setActivationFlags(KisAction::ACTIVE_DEVICE);
     view->viewManager()->actionManager()->addAction("dummy", action);
 
     KisAction* action2 = new KisAction("dummy", this);
     action2->setActivationFlags(KisAction::ACTIVE_SHAPE_LAYER);
     view->viewManager()->actionManager()->addAction("dummy", action2);
     
     view->viewManager()->actionManager()->updateGUI();
     QVERIFY(!action->isEnabled());
     QVERIFY(!action2->isEnabled());
 
     KisPaintLayerSP paintLayer1 = new KisPaintLayer(doc->image(), "paintlayer1", OPACITY_OPAQUE_U8);
     doc->image()->addNode(paintLayer1);
 
     viewManager->nodeManager()->slotUiActivatedNode(paintLayer1);
 
     view->viewManager()->actionManager()->updateGUI();
     QVERIFY(action->isEnabled());
     QVERIFY(!action2->isEnabled());
 }
 
 void KisActionManagerTest::testCondition()
 {
     KisDocument* doc = createEmptyDocument();
     KisMainWindow* mainWindow = KisPart::instance()->createMainWindow();
-    QPointer<KisView> view = new KisView(doc, mainWindow->resourceManager(), mainWindow->actionCollection(), mainWindow);
+    QPointer<KisView> view = new KisView(doc, mainWindow->viewManager(), mainWindow);
     KisViewManager *viewManager = new KisViewManager(mainWindow, mainWindow->actionCollection());
     KisPart::instance()->addView(view);
     mainWindow->showView(view);
 
     view->setViewManager(viewManager);
     viewManager->setCurrentView(view);
 
     KisAction* action = new KisAction("dummy", this);
     action->setActivationFlags(KisAction::ACTIVE_DEVICE);
     action->setActivationConditions(KisAction::ACTIVE_NODE_EDITABLE);
     view->viewManager()->actionManager()->addAction("dummy", action);
 
     KisPaintLayerSP paintLayer1 = new KisPaintLayer(doc->image(), "paintlayer1", OPACITY_OPAQUE_U8);
     doc->image()->addNode(paintLayer1);
 
     viewManager->nodeManager()->slotUiActivatedNode(paintLayer1);
 
     view->viewManager()->actionManager()->updateGUI();
     QVERIFY(action->isEnabled());
 
     // visible
 //     paintLayer1->setVisible(false);
 //     view->viewManager()->actionManager()->updateGUI();
 //     QVERIFY(!action->isEnabled());
 
     paintLayer1->setVisible(true);
     view->viewManager()->actionManager()->updateGUI();
     QVERIFY(action->isEnabled());
 
     // locked
     paintLayer1->setUserLocked(true);
     view->viewManager()->actionManager()->updateGUI();
     QVERIFY(!action->isEnabled());
 
     paintLayer1->setUserLocked(false);
     view->viewManager()->actionManager()->updateGUI();
     QVERIFY(action->isEnabled());
 }
 
 void KisActionManagerTest::testTakeAction()
 {
     KisDocument* doc = createEmptyDocument();
     KisMainWindow* mainWindow = KisPart::instance()->createMainWindow();
-    QPointer<KisView> view = new KisView(doc, mainWindow->resourceManager(), mainWindow->actionCollection(), mainWindow);
+    QPointer<KisView> view = new KisView(doc, mainWindow->viewManager(), mainWindow);
     KisViewManager *viewManager = new KisViewManager(mainWindow, mainWindow->actionCollection());
     KisPart::instance()->addView(view);
     mainWindow->showView(view);
 
     view->setViewManager(viewManager);
     viewManager->setCurrentView(view);
 
     KisAction* action = new KisAction("dummy", this);
     view->viewManager()->actionManager()->addAction("dummy", action);
     QVERIFY(view->viewManager()->actionManager()->actionByName("dummy") != 0);
 
     view->viewManager()->actionManager()->takeAction(action);
     QVERIFY(view->viewManager()->actionManager()->actionByName("dummy") == 0);
 }
 
 
 KISTEST_MAIN(KisActionManagerTest)
diff --git a/libs/ui/tests/kis_derived_resources_test.cpp b/libs/ui/tests/kis_derived_resources_test.cpp
index 75ca6abf65..12d339b763 100644
--- a/libs/ui/tests/kis_derived_resources_test.cpp
+++ b/libs/ui/tests/kis_derived_resources_test.cpp
@@ -1,159 +1,159 @@
 /*
  *  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_derived_resources_test.h"
 
 #include <QTest>
 #include <brushengine/kis_paintop_preset.h>
 
 #include <QApplication>
 
 #include <KoCanvasResourceProvider.h>
 
 #include "kis_canvas_resource_provider.h"
 #include <util.h>
 #include <KisMainWindow.h>
 #include <KisDocument.h>
 #include <KisPart.h>
 #include <KisView.h>
 #include <KisViewManager.h>
 #include <kis_paintop_settings.h>
 #include <KoResourcePaths.h>
 #include <kis_config.h>
 #include "testutil.h"
 #include "opengl/kis_opengl.h"
 
 
 void addResourceTypes()
 {
     // All Krita's resource types
     KoResourcePaths::addResourceType("gmic_definitions", "data", "/gmic/");
     KoResourcePaths::addResourceType("icc_profiles", "data", "/color/icc");
     KoResourcePaths::addResourceType("icc_profiles", "data", "/profiles/");
     KoResourcePaths::addResourceType("kis_actions", "data", "/actions");
     KoResourcePaths::addResourceType("kis_brushes", "data", "/brushes/");
     KoResourcePaths::addResourceType("kis_defaultpresets", "data", "/defaultpresets/");
     KoResourcePaths::addResourceType("kis_images", "data", "/images/");
     KoResourcePaths::addResourceType("kis_paintoppresets", "data", "/paintoppresets/");
     KoResourcePaths::addResourceType("kis_pics", "data", "/pics/");
     KoResourcePaths::addResourceType("kis_resourcebundles", "data", "/bundles/");
     KoResourcePaths::addResourceType("kis_shortcuts", "data", "/shortcuts/");
     KoResourcePaths::addResourceType("kis_taskset", "data", "/taskset/");
     KoResourcePaths::addResourceType("kis_taskset", "data", "/taskset/");
     KoResourcePaths::addResourceType("kis_windowlayouts", "data", "/windowlayouts/");
     KoResourcePaths::addResourceType("kis_workspaces", "data", "/workspaces/");
     KoResourcePaths::addResourceType("ko_effects", "data", "/effects/");
     KoResourcePaths::addResourceType("ko_gradients", "data", "/gradients/");
     KoResourcePaths::addResourceType("ko_palettes", "data", "/palettes/");
     KoResourcePaths::addResourceType("ko_patterns", "data", "/patterns/");
     KoResourcePaths::addResourceType("metadata_schema", "data", "/metadata/schemas/");
     KoResourcePaths::addResourceType("psd_layer_style_collections", "data", "/asl");
     KoResourcePaths::addResourceType("tags", "data", "/tags/");
 
     KisOpenGL::testingInitializeDefaultSurfaceFormat();
 
     KisConfig cfg(false);
     cfg.disableOpenGL();
 }
 
 void KisDerivedResourcesTest::test()
 {
     addResourceTypes();
 
     KisDocument* doc = createEmptyDocument();
 
 
 
     KisMainWindow* mainWindow = KisPart::instance()->createMainWindow();
-    QPointer<KisView> view = new KisView(doc, mainWindow->resourceManager(), mainWindow->actionCollection(), mainWindow);
+    QPointer<KisView> view = new KisView(doc, mainWindow->viewManager(), mainWindow);
     KisViewManager *viewManager = new KisViewManager(mainWindow, mainWindow->actionCollection());
     KoCanvasResourceProvider *manager = viewManager->canvasResourceProvider()->resourceManager();
 
     QApplication::processEvents();
 
     QString presetFileName = "autobrush_300px.kpp";
 
     QVariant i;
 
     KisPaintOpPresetSP preset;
     if (!presetFileName.isEmpty()) {
         QString fullFileName = TestUtil::fetchDataFileLazy(presetFileName);
         preset = new KisPaintOpPreset(fullFileName);
         bool presetValid = preset->load();
         Q_ASSERT(presetValid); Q_UNUSED(presetValid);
 
         i.setValue(preset);
 
     }
 
     QVERIFY(i.isValid());
 
     QSignalSpy spy(manager, SIGNAL(canvasResourceChanged(int,QVariant)));
 
     manager->setResource(KisCanvasResourceProvider::CurrentPaintOpPreset, i);
 
     QMap<int, QVariant> expectedSignals;
     expectedSignals[KisCanvasResourceProvider::CurrentPaintOpPreset] = QVariant::fromValue(preset);
     expectedSignals[KisCanvasResourceProvider::EraserMode] = false;
     expectedSignals[KisCanvasResourceProvider::LodSizeThresholdSupported] = true;
     expectedSignals[KisCanvasResourceProvider::EffectiveLodAvailablility] = true;
     expectedSignals[KisCanvasResourceProvider::LodSizeThreshold] = 100;
     expectedSignals[KisCanvasResourceProvider::LodAvailability] = true;
     expectedSignals[KisCanvasResourceProvider::Opacity] = 1.0;
     expectedSignals[KisCanvasResourceProvider::Size] = 300.0;
     expectedSignals[KisCanvasResourceProvider::Flow] = 1.0;
     expectedSignals[KisCanvasResourceProvider::CurrentEffectiveCompositeOp] = COMPOSITE_OVER;
     expectedSignals[KisCanvasResourceProvider::CurrentCompositeOp] = COMPOSITE_OVER;
 
     auto it = spy.begin();
     for (; it != spy.end(); ++it) {
         const int id = (*it)[0].toInt();
         const QVariant value = (*it)[1];
 
         if (!expectedSignals.contains(id)) {
             qDebug() << ppVar(id) << ppVar(value);
             QFAIL("Unexpected signal!");
         } else {
             if (expectedSignals[id] != value) {
                 qDebug() << ppVar(id) << ppVar(value) << ppVar(expectedSignals[id]);
                 QFAIL("Unexpected value!");
             }
         }
     }
 
     QCOMPARE(spy.size(), expectedSignals.size());
 
     spy.clear();
 
     preset->settings()->setPaintOpOpacity(0.8);
 
     QCOMPARE(spy.size(), 1);
     QCOMPARE(spy[0][0].toInt(), (int)KisCanvasResourceProvider::Opacity);
     QCOMPARE(spy[0][1].toDouble(), 0.8);
     spy.clear();
 
 
     mainWindow->hide();
     QApplication::processEvents();
 
     delete view;
     delete doc;
     delete mainWindow;
 }
 
 KISTEST_MAIN(KisDerivedResourcesTest)
diff --git a/libs/ui/tests/kis_zoom_and_pan_test.cpp b/libs/ui/tests/kis_zoom_and_pan_test.cpp
index 6690ce7522..25a16bf8c6 100644
--- a/libs/ui/tests/kis_zoom_and_pan_test.cpp
+++ b/libs/ui/tests/kis_zoom_and_pan_test.cpp
@@ -1,766 +1,766 @@
 /*
  *  Copyright (c) 2012 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_zoom_and_pan_test.h"
 
 #include <cmath>
 #include <QTest>
 
 #include <kis_filter_configuration.h>
 #include "testutil.h"
 #include "qimage_based_test.h"
 
 #include <kactioncollection.h>
 
 #include "kis_config.h"
 
 #include "KisMainWindow.h"
 #include "KoZoomController.h"
 #include "KisDocument.h"
 #include "KisPart.h"
 #include "KisViewManager.h"
 #include "KisView.h"
 #include "kis_canvas2.h"
 #include "kis_canvas_controller.h"
 #include "kis_coordinates_converter.h"
 #include "kis_filter_strategy.h"
 
 #include "kistest.h"
 
 class ZoomAndPanTester : public TestUtil::QImageBasedTest
 {
 public:
     ZoomAndPanTester()
         // we are not going to use our own QImage sets,so
         // just exploit the set of the selection manager test
         : QImageBasedTest("selection_manager_test")
     {
         m_undoStore = new KisSurrogateUndoStore();
         m_image = createImage(m_undoStore);
         m_image->initialRefreshGraph();
         QVERIFY(checkLayersInitial(m_image));
 
         m_doc = KisPart::instance()->createDocument();
 
         m_doc->setCurrentImage(m_image);
 
         m_mainWindow = KisPart::instance()->createMainWindow();
-        m_view = new KisView(m_doc, m_mainWindow->resourceManager(), m_mainWindow->actionCollection(), m_mainWindow);
+        m_view = new KisView(m_doc, m_mainWindow->viewManager(), m_mainWindow);
 
         m_image->refreshGraph();
 
         m_mainWindow->show();
     }
 
     ~ZoomAndPanTester() {
         m_image->waitForDone();
         QApplication::processEvents();
 
         delete m_mainWindow;
         delete m_doc;
 
         /**
          * The event queue may have up to 200k events
          * by the time all the tests are finished. Removing
          * all of them may last forever, so clear them after
          * every single test is finished
          */
         QApplication::removePostedEvents(0);
     }
 
     QPointer<KisView> view() {
         return m_view;
     }
 
     KisMainWindow* mainWindow() {
         return m_mainWindow;
     }
 
     KisImageWSP image() {
         return m_image;
     }
 
     KisCanvas2* canvas() {
         return m_view->canvasBase();
     }
 
     QWidget* canvasWidget() {
         return m_view->canvasBase()->canvasWidget();
     }
 
     KoZoomController* zoomController() {
         return m_view->zoomController();
     }
 
     KisCanvasController* canvasController() {
         return dynamic_cast<KisCanvasController*>(m_view->canvasController());
     }
 
     const KisCoordinatesConverter* coordinatesConverter() {
         return m_view->canvasBase()->coordinatesConverter();
     }
 
 private:
     KisSurrogateUndoStore *m_undoStore;
     KisImageSP m_image;
     KisDocument *m_doc;
     QPointer<KisView>m_view;
     KisMainWindow *m_mainWindow;
 };
 
 template<class P, class T>
 inline bool compareWithRounding(const P &pt0, const P &pt1, T tolerance)
 {
     return qAbs(pt0.x() - pt1.x()) <= tolerance &&
         qAbs(pt0.y() - pt1.y()) <= tolerance;
 }
 
 bool verifyOffset(ZoomAndPanTester &t, const QPoint &offset) {
 
     if (t.coordinatesConverter()->documentOffset() != offset) {
             dbgKrita << "########################";
             dbgKrita << "Expected Offset:" << offset;
             dbgKrita << "Actual values:";
             dbgKrita << "Offset:" << t.coordinatesConverter()->documentOffset();
             dbgKrita << "wsize:"  << t.canvasWidget()->size();
             dbgKrita << "vport:"  << t.canvasController()->viewportSize();
             dbgKrita << "pref:"  << t.canvasController()->preferredCenter();
             dbgKrita << "########################";
     }
 
     return t.coordinatesConverter()->documentOffset() == offset;
 }
 
 bool KisZoomAndPanTest::checkPan(ZoomAndPanTester &t, QPoint shift)
 {
     QPoint oldOffset = t.coordinatesConverter()->documentOffset();
     QPointF oldPrefCenter = t.canvasController()->preferredCenter();
 
     t.canvasController()->pan(shift);
 
     QPoint newOffset  = t.coordinatesConverter()->documentOffset();
     QPointF newPrefCenter = t.canvasController()->preferredCenter();
     QPointF newTopLeft = t.coordinatesConverter()->imageRectInWidgetPixels().topLeft();
 
     QPoint expectedOffset  = oldOffset + shift;
     QPointF expectedPrefCenter = oldPrefCenter + shift;
 
 
     // no tolerance accepted for pan
     bool offsetAsExpected = newOffset == expectedOffset;
 
     // rounding can happen due to the scroll bars being the main
     // source of the offset
     bool preferredCenterAsExpected =
         compareWithRounding(expectedPrefCenter, newPrefCenter, 1.0);
 
     bool topLeftAsExpected = newTopLeft.toPoint() == -newOffset;
 
     if (!offsetAsExpected ||
         !preferredCenterAsExpected ||
         !topLeftAsExpected) {
 
         dbgKrita << "***** PAN *****************";
 
         if(!offsetAsExpected) {
             dbgKrita << " ### Offset invariant broken";
         }
 
         if(!preferredCenterAsExpected) {
             dbgKrita << " ### Preferred center invariant broken";
         }
 
         if(!topLeftAsExpected) {
             dbgKrita << " ### TopLeft invariant broken";
         }
 
         dbgKrita << ppVar(expectedOffset);
         dbgKrita << ppVar(expectedPrefCenter);
         dbgKrita << ppVar(oldOffset) << ppVar(newOffset);
         dbgKrita << ppVar(oldPrefCenter) << ppVar(newPrefCenter);
         dbgKrita << ppVar(newTopLeft);
         dbgKrita << "***************************";
     }
 
     return offsetAsExpected && preferredCenterAsExpected && topLeftAsExpected;
 }
 
 bool KisZoomAndPanTest::checkInvariants(const QPointF &baseFlakePoint,
                                         const QPoint &oldOffset,
                                         const QPointF &oldPreferredCenter,
                                         qreal oldZoom,
                                         const QPoint &newOffset,
                                         const QPointF &newPreferredCenter,
                                         qreal newZoom,
                                         const QPointF &newTopLeft,
                                         const QSize &oldDocumentSize)
 {
     qreal k = newZoom / oldZoom;
 
     QPointF expectedOffset = oldOffset + (k - 1) * baseFlakePoint;
     QPointF expectedPreferredCenter = oldPreferredCenter + (k - 1) * baseFlakePoint;
 
     qreal oldPreferredCenterFractionX = 1.0 * oldPreferredCenter.x() / oldDocumentSize.width();
     qreal oldPreferredCenterFractionY = 1.0 * oldPreferredCenter.y() / oldDocumentSize.height();
 
     qreal roundingTolerance =
         qMax(qreal(1.0), qMax(oldPreferredCenterFractionX, oldPreferredCenterFractionY) / k);
 
     /**
      * In the computation of the offset two roundings happen:
      * first for the computation of oldOffset and the second
      * for the computation of newOffset. So the maximum tolerance
      * should equal 2.
      */
     bool offsetAsExpected =
         compareWithRounding(expectedOffset, QPointF(newOffset), 2 * roundingTolerance);
 
     /**
      * Rounding for the preferred center happens due to the rounding
      * of the document size while zooming. The wider the step of the
      * zooming, the bigger tolerance should be
      */
     bool preferredCenterAsExpected =
         compareWithRounding(expectedPreferredCenter, newPreferredCenter,
                             roundingTolerance);
 
     bool topLeftAsExpected = newTopLeft.toPoint() == -newOffset;
 
     if (!offsetAsExpected ||
         !preferredCenterAsExpected ||
         !topLeftAsExpected) {
 
         dbgKrita << "***** ZOOM ****************";
 
         if(!offsetAsExpected) {
             dbgKrita << " ### Offset invariant broken";
         }
 
         if(!preferredCenterAsExpected) {
             dbgKrita << " ### Preferred center invariant broken";
         }
 
         if(!topLeftAsExpected) {
             dbgKrita << " ### TopLeft invariant broken";
         }
 
         dbgKrita << ppVar(expectedOffset);
         dbgKrita << ppVar(expectedPreferredCenter);
         dbgKrita << ppVar(oldOffset) << ppVar(newOffset);
         dbgKrita << ppVar(oldPreferredCenter) << ppVar(newPreferredCenter);
         dbgKrita << ppVar(oldPreferredCenterFractionX);
         dbgKrita << ppVar(oldPreferredCenterFractionY);
         dbgKrita << ppVar(oldZoom) << ppVar(newZoom);
         dbgKrita << ppVar(baseFlakePoint);
         dbgKrita << ppVar(newTopLeft);
         dbgKrita << ppVar(roundingTolerance);
         dbgKrita << "***************************";
     }
 
     return offsetAsExpected && preferredCenterAsExpected && topLeftAsExpected;
 }
 
 bool KisZoomAndPanTest::checkZoomWithAction(ZoomAndPanTester &t, qreal newZoom, bool limitedZoom)
 {
     QPoint oldOffset = t.coordinatesConverter()->documentOffset();
     QPointF oldPrefCenter = t.canvasController()->preferredCenter();
     qreal oldZoom = t.zoomController()->zoomAction()->effectiveZoom();
     QSize oldDocumentSize = t.canvasController()->documentSize().toSize();
 
     t.zoomController()->setZoom(KoZoomMode::ZOOM_CONSTANT, newZoom);
 
     QPointF newTopLeft = t.coordinatesConverter()->imageRectInWidgetPixels().topLeft();
 
     return checkInvariants(oldPrefCenter,
                            oldOffset,
                            oldPrefCenter,
                            oldZoom,
                            t.coordinatesConverter()->documentOffset(),
                            t.canvasController()->preferredCenter(),
                            limitedZoom ? oldZoom : newZoom,
                            newTopLeft,
                            oldDocumentSize);
 }
 
 bool KisZoomAndPanTest::checkZoomWithWheel(ZoomAndPanTester &t, const QPoint &widgetPoint, qreal zoomCoeff, bool limitedZoom)
 {
     QPoint oldOffset = t.coordinatesConverter()->documentOffset();
     QPointF oldPrefCenter = t.canvasController()->preferredCenter();
     qreal oldZoom = t.zoomController()->zoomAction()->effectiveZoom();
     QSize oldDocumentSize = t.canvasController()->documentSize().toSize();
 
     t.canvasController()->zoomRelativeToPoint(widgetPoint, zoomCoeff);
 
     QPointF newTopLeft = t.coordinatesConverter()->imageRectInWidgetPixels().topLeft();
 
     return checkInvariants(oldOffset + widgetPoint,
                            oldOffset,
                            oldPrefCenter,
                            oldZoom,
                            t.coordinatesConverter()->documentOffset(),
                            t.canvasController()->preferredCenter(),
                            limitedZoom ? oldZoom : zoomCoeff * oldZoom,
                            newTopLeft,
                            oldDocumentSize);
 }
 
 void KisZoomAndPanTest::testZoom100ChangingWidgetSize()
 {
     ZoomAndPanTester t;
 
     QCOMPARE(t.image()->size(), QSize(640,441));
     QCOMPARE(t.image()->xRes(), 1.0);
     QCOMPARE(t.image()->yRes(), 1.0);
 
     t.canvasController()->resize(QSize(1000,1000));
     t.zoomController()->setZoom(KoZoomMode::ZOOM_CONSTANT, 1.0);
     t.canvasController()->setPreferredCenter(QPoint(320,220));
 
     QCOMPARE(t.canvasWidget()->size(), QSize(983,983));
     QCOMPARE(t.canvasWidget()->size(), t.canvasController()->viewportSize().toSize());
     QVERIFY(verifyOffset(t, QPoint(-171,-271)));
 
     t.canvasController()->resize(QSize(700,700));
 
     QCOMPARE(t.canvasWidget()->size(), QSize(683,683));
     QCOMPARE(t.canvasWidget()->size(), t.canvasController()->viewportSize().toSize());
     QVERIFY(verifyOffset(t, QPoint(-171,-271)));
 
     t.canvasController()->setPreferredCenter(QPoint(320,220));
 
     QVERIFY(verifyOffset(t, QPoint(-21,-121)));
 
     t.canvasController()->resize(QSize(400,400));
 
     QCOMPARE(t.canvasWidget()->size(), QSize(383,383));
     QCOMPARE(t.canvasWidget()->size(), t.canvasController()->viewportSize().toSize());
     QVERIFY(verifyOffset(t, QPoint(-21,-121)));
 
     t.canvasController()->setPreferredCenter(QPoint(320,220));
 
     QVERIFY(verifyOffset(t, QPoint(129,29)));
 
     t.canvasController()->pan(QPoint(100,100));
 
     QVERIFY(verifyOffset(t, QPoint(229,129)));
 }
 
 void KisZoomAndPanTest::initializeViewport(ZoomAndPanTester &t, bool fullscreenMode, bool rotate, bool mirror)
 {
     QCOMPARE(t.image()->size(), QSize(640,441));
     QCOMPARE(t.image()->xRes(), 1.0);
     QCOMPARE(t.image()->yRes(), 1.0);
 
     t.canvasController()->resize(QSize(500,500));
     t.zoomController()->setZoom(KoZoomMode::ZOOM_CONSTANT, 1.0);
     t.canvasController()->setPreferredCenter(QPoint(320,220));
 
     QCOMPARE(t.canvasWidget()->size(), QSize(483,483));
     QCOMPARE(t.canvasWidget()->size(), t.canvasController()->viewportSize().toSize());
     QVERIFY(verifyOffset(t, QPoint(79,-21)));
 
     if (fullscreenMode) {
         QCOMPARE(t.canvasController()->preferredCenter(), QPointF(320,220));
 
         QAction *action = t.view()->viewManager()->actionCollection()->action("view_show_canvas_only");
         action->setChecked(true);
 
         QVERIFY(verifyOffset(t, QPoint(79,-21)));
         QCOMPARE(t.canvasController()->preferredCenter(), QPointF(329,220));
 
 
         t.canvasController()->resize(QSize(483,483));
         QCOMPARE(t.canvasWidget()->size(), QSize(483,483));
         QCOMPARE(t.canvasWidget()->size(), t.canvasController()->viewportSize().toSize());
         QVERIFY(verifyOffset(t, QPoint(79,-21)));
 
 
         /**
          * FIXME: here is a small flaw in KoCanvasControllerWidget
          * We cannot set the center point explicitly, because it'll be rounded
          * up by recenterPreferred function, so real center point will be
          * different. Make the preferredCenter() return real center of the
          * image instead of the set value
          */
         QCOMPARE(t.canvasController()->preferredCenter(), QPointF(320.5,220));
     }
 
     if (rotate) {
         t.canvasController()->rotateCanvas(90);
         QVERIFY(verifyOffset(t, QPoint(-21,79)));
         QVERIFY(compareWithRounding(QPointF(220,320), t.canvasController()->preferredCenter(), 2));
         QCOMPARE(t.coordinatesConverter()->imageRectInWidgetPixels().topLeft().toPoint(), -t.coordinatesConverter()->documentOffset());
     }
 
     if (mirror) {
         t.canvasController()->mirrorCanvas(true);
         QVERIFY(verifyOffset(t, QPoint(78, -21)));
         QVERIFY(compareWithRounding(QPointF(320,220), t.canvasController()->preferredCenter(), 2));
         QCOMPARE(t.coordinatesConverter()->imageRectInWidgetPixels().topLeft().toPoint(), -t.coordinatesConverter()->documentOffset());
     }
 }
 
 void KisZoomAndPanTest::testSequentialActionZoomAndPan(bool fullscreenMode, bool rotate, bool mirror)
 {
     ZoomAndPanTester t;
     initializeViewport(t, fullscreenMode, rotate, mirror);
 
     QVERIFY(checkZoomWithAction(t, 0.5));
     QVERIFY(checkPan(t, QPoint(100,100)));
 
     QVERIFY(checkZoomWithAction(t, 0.25));
     QVERIFY(checkPan(t, QPoint(-100,-100)));
 
     QVERIFY(checkZoomWithAction(t, 0.35));
     QVERIFY(checkPan(t, QPoint(100,100)));
 
     QVERIFY(checkZoomWithAction(t, 0.45));
     QVERIFY(checkPan(t, QPoint(100,100)));
 
     QVERIFY(checkZoomWithAction(t, 0.85));
     QVERIFY(checkPan(t, QPoint(-100,-100)));
 
     QVERIFY(checkZoomWithAction(t, 2.35));
     QVERIFY(checkPan(t, QPoint(100,100)));
 }
 
 void KisZoomAndPanTest::testSequentialWheelZoomAndPan(bool fullscreenMode, bool rotate, bool mirror)
 {
     ZoomAndPanTester t;
     initializeViewport(t, fullscreenMode, rotate, mirror);
 
     QVERIFY(checkZoomWithWheel(t, QPoint(100,100), 0.5));
     QVERIFY(checkPan(t, QPoint(100,100)));
 
     QVERIFY(checkZoomWithWheel(t, QPoint(100,100), 0.5));
     QVERIFY(checkPan(t, QPoint(-100,-100)));
 
     QVERIFY(checkZoomWithWheel(t, QPoint(100,100), 1.25));
     QVERIFY(checkPan(t, QPoint(100,100)));
 
     QVERIFY(checkZoomWithWheel(t, QPoint(100,100), 1.5));
     QVERIFY(checkPan(t, QPoint(100,100)));
 
     QVERIFY(checkZoomWithWheel(t, QPoint(100,100), 2.5));
     QVERIFY(checkPan(t, QPoint(-100,-100)));
 
     // check one point which is outside the widget
     QVERIFY(checkZoomWithWheel(t, QPoint(-100,100), 2.5));
     QVERIFY(checkPan(t, QPoint(-100,-100)));
 
     QVERIFY(checkZoomWithWheel(t, QPoint(100,100), 0.5));
     QVERIFY(checkPan(t, QPoint(-100,-100)));
 }
 
 void KisZoomAndPanTest::testSequentialActionZoomAndPan()
 {
     testSequentialActionZoomAndPan(false, false, false);
 }
 
 void KisZoomAndPanTest::testSequentialActionZoomAndPanFullscreen()
 {
     testSequentialActionZoomAndPan(true, false, false);
 }
 
 void KisZoomAndPanTest::testSequentialActionZoomAndPanRotate()
 {
     testSequentialActionZoomAndPan(false, true, false);
 }
 
 void KisZoomAndPanTest::testSequentialActionZoomAndPanRotateFullscreen()
 {
     testSequentialActionZoomAndPan(true, true, false);
 }
 
 void KisZoomAndPanTest::testSequentialActionZoomAndPanMirror()
 {
     testSequentialActionZoomAndPan(false, false, true);
 }
 
 void KisZoomAndPanTest::testSequentialWheelZoomAndPan()
 {
     testSequentialWheelZoomAndPan(false, false, false);
 }
 
 void KisZoomAndPanTest::testSequentialWheelZoomAndPanFullscreen()
 {
     testSequentialWheelZoomAndPan(true, false, false);
 }
 
 void KisZoomAndPanTest::testSequentialWheelZoomAndPanRotate()
 {
     testSequentialWheelZoomAndPan(false, true, false);
 }
 
 void KisZoomAndPanTest::testSequentialWheelZoomAndPanRotateFullscreen()
 {
     testSequentialWheelZoomAndPan(true, true, false);
 }
 
 void KisZoomAndPanTest::testSequentialWheelZoomAndPanMirror()
 {
     testSequentialWheelZoomAndPan(false, false, true);
 }
 
 void KisZoomAndPanTest::testZoomOnBorderZoomLevels()
 {
     ZoomAndPanTester t;
     initializeViewport(t, false, false, false);
 
 //    QPoint widgetPoint(100,100);
 
     warnKrita << "WARNING: testZoomOnBorderZoomLevels() is disabled due to some changes in KoZoomMode::minimum/maximumZoom()";
     return;
 
     // test min zoom level
     t.zoomController()->setZoom(KoZoomMode::ZOOM_CONSTANT, KoZoomMode::minimumZoom());
     QVERIFY(checkZoomWithWheel(t, QPoint(100,100), 0.5, true));
     QVERIFY(checkZoomWithAction(t, KoZoomMode::minimumZoom() * 0.5, true));
 
     // test max zoom level
     t.zoomController()->setZoom(KoZoomMode::ZOOM_CONSTANT, KoZoomMode::maximumZoom());
     QVERIFY(checkZoomWithWheel(t, QPoint(100,100), 2.0, true));
     QVERIFY(checkZoomWithAction(t, KoZoomMode::maximumZoom() * 2.0, true));
 }
 
 inline QTransform correctionMatrix(qreal angle)
 {
     return QTransform(0,0,0,sin(M_PI * angle / 180),0,0,0,0,1);
 }
 
 bool KisZoomAndPanTest::checkRotation(ZoomAndPanTester &t, qreal angle)
 {
     // save old values
     QPoint oldOffset = t.coordinatesConverter()->documentOffset();
     QPointF oldCenteringCorrection = t.coordinatesConverter()->centeringCorrection();
     QPointF oldPreferredCenter = t.canvasController()->preferredCenter();
     QPointF oldRealCenterPoint = t.coordinatesConverter()->widgetToImage(t.coordinatesConverter()->widgetCenterPoint());
     QSize oldDocumentSize = t.canvasController()->documentSize().toSize();
 
     qreal baseAngle = t.coordinatesConverter()->rotationAngle();
     t.canvasController()->rotateCanvas(angle);
 
     // save result values
     QPoint newOffset = t.coordinatesConverter()->documentOffset();
     QPointF newCenteringCorrection = t.coordinatesConverter()->centeringCorrection();
     QPointF newPreferredCenter = t.canvasController()->preferredCenter();
     QPointF newRealCenterPoint = t.coordinatesConverter()->widgetToImage(t.coordinatesConverter()->widgetCenterPoint());
     QSize newDocumentSize = t.canvasController()->documentSize().toSize();
 
 
     // calculate theoretical preferred center
     QTransform rot;
     rot.rotate(angle);
 
     QSizeF dSize = t.coordinatesConverter()->imageSizeInFlakePixels();
     QPointF dPoint(dSize.width(), dSize.height());
 
     QPointF expectedPreferredCenter =
         (oldPreferredCenter - dPoint * correctionMatrix(baseAngle)) * rot +
          dPoint * correctionMatrix(baseAngle + angle);
 
     // calculate theoretical offset based on the real preferred center
     QPointF wPoint(t.canvasWidget()->size().width(), t.canvasWidget()->size().height());
     QPointF expectedOldOffset = oldPreferredCenter - 0.5 * wPoint;
     QPointF expectedNewOffset = newPreferredCenter - 0.5 * wPoint;
 
     bool preferredCenterAsExpected =
         compareWithRounding(expectedPreferredCenter, newPreferredCenter, 2);
     bool oldOffsetAsExpected =
         compareWithRounding(expectedOldOffset + oldCenteringCorrection, QPointF(oldOffset), 2);
     bool newOffsetAsExpected =
         compareWithRounding(expectedNewOffset + newCenteringCorrection, QPointF(newOffset), 3);
 
     qreal zoom = t.zoomController()->zoomAction()->effectiveZoom();
     bool realCenterPointAsExpected =
         compareWithRounding(oldRealCenterPoint, newRealCenterPoint, 2/zoom);
 
 
     if (!oldOffsetAsExpected ||
         !newOffsetAsExpected ||
         !preferredCenterAsExpected ||
         !realCenterPointAsExpected) {
 
         dbgKrita << "***** ROTATE **************";
 
         if(!oldOffsetAsExpected) {
             dbgKrita << " ### Old offset invariant broken";
         }
 
         if(!newOffsetAsExpected) {
             dbgKrita << " ### New offset invariant broken";
         }
 
         if(!preferredCenterAsExpected) {
             dbgKrita << " ### Preferred center invariant broken";
         }
 
         if(!realCenterPointAsExpected) {
             dbgKrita << " ### *Real* center invariant broken";
         }
 
         dbgKrita << ppVar(expectedOldOffset);
         dbgKrita << ppVar(expectedNewOffset);
         dbgKrita << ppVar(expectedPreferredCenter);
         dbgKrita << ppVar(oldOffset) << ppVar(newOffset);
         dbgKrita << ppVar(oldCenteringCorrection) << ppVar(newCenteringCorrection);
         dbgKrita << ppVar(oldPreferredCenter) << ppVar(newPreferredCenter);
         dbgKrita << ppVar(oldRealCenterPoint) << ppVar(newRealCenterPoint);
         dbgKrita << ppVar(oldDocumentSize) << ppVar(newDocumentSize);
         dbgKrita << ppVar(baseAngle) << "deg";
         dbgKrita << ppVar(angle) << "deg";
         dbgKrita << "***************************";
     }
 
     return preferredCenterAsExpected && oldOffsetAsExpected && newOffsetAsExpected && realCenterPointAsExpected;
 }
 
 void KisZoomAndPanTest::testRotation(qreal vastScrolling, qreal zoom)
 {
     KisConfig cfg(false);
     cfg.setVastScrolling(vastScrolling);
 
     ZoomAndPanTester t;
 
     QCOMPARE(t.image()->size(), QSize(640,441));
     QCOMPARE(t.image()->xRes(), 1.0);
     QCOMPARE(t.image()->yRes(), 1.0);
 
     QPointF preferredCenter = zoom * t.image()->bounds().center();
 
     t.canvasController()->resize(QSize(500,500));
     t.zoomController()->setZoom(KoZoomMode::ZOOM_CONSTANT, zoom);
     t.canvasController()->setPreferredCenter(preferredCenter.toPoint());
 
     QCOMPARE(t.canvasWidget()->size(), QSize(483,483));
     QCOMPARE(t.canvasWidget()->size(), t.canvasController()->viewportSize().toSize());
 
     QPointF realCenterPoint = t.coordinatesConverter()->widgetToImage(t.coordinatesConverter()->widgetCenterPoint());
     QPointF expectedCenterPoint = QPointF(t.image()->bounds().center());
 
     if(!compareWithRounding(realCenterPoint, expectedCenterPoint, 2/zoom)) {
         dbgKrita << "Failed to set initial center point";
         dbgKrita << ppVar(expectedCenterPoint) << ppVar(realCenterPoint);
         QFAIL("FAIL: Failed to set initial center point");
     }
 
     QVERIFY(checkRotation(t, 30));
     QVERIFY(checkRotation(t, 20));
     QVERIFY(checkRotation(t, 10));
     QVERIFY(checkRotation(t, 5));
     QVERIFY(checkRotation(t, 5));
     QVERIFY(checkRotation(t, 5));
 
     if(vastScrolling < 0.5 && zoom < 1) {
         warnKrita << "Disabling a few tests for vast scrolling ="
                    << vastScrolling << ". See comment for more";
         /**
          * We have to disable a couple of tests here for the case when
          * vastScrolling value is 0.2. The problem is that the centering
          * correction applied  to the offset in
          * KisCanvasController::rotateCanvas pollutes the preferredCenter
          * value, because KoCnvasControllerWidget has no access to this
          * correction and cannot calculate the real value of the center of
          * the image. To fix this bug the calculation of correction
          * (aka "origin") should be moved to the KoCanvasControllerWidget
          * itself which would cause quite huge changes (including the change
          * of the external interface of it). Namely, we would have to
          * *calculate* offset from the value of the scroll bars, but not
          * use their values directly:
          *
          * offset = scrollBarValue - origin
          *
          * So now we just disable these unittests and allow a couple
          * of "jumping" bugs appear in vastScrolling < 0.5 modes, which
          * is, actually, not the default case.
          */
 
     } else {
         QVERIFY(checkRotation(t, 5));
         QVERIFY(checkRotation(t, 5));
         QVERIFY(checkRotation(t, 5));
     }
 }
 
 void KisZoomAndPanTest::testRotation_VastScrolling_1_0()
 {
     testRotation(0.9, 1.0);
 }
 
 void KisZoomAndPanTest::testRotation_VastScrolling_0_5()
 {
     testRotation(0.9, 0.5);
 }
 
 void KisZoomAndPanTest::testRotation_NoVastScrolling_1_0()
 {
     testRotation(0.2, 1.0);
 }
 
 void KisZoomAndPanTest::testRotation_NoVastScrolling_0_5()
 {
     testRotation(0.2, 0.5);
 }
 
 void KisZoomAndPanTest::testImageRescaled_0_5()
 {
     ZoomAndPanTester t;
     QApplication::processEvents();
     initializeViewport(t, false, false, false);
     QApplication::processEvents();
     QVERIFY(checkPan(t, QPoint(200,200)));
     QApplication::processEvents();
 
     QPointF oldStillPoint =
         t.coordinatesConverter()->imageRectInWidgetPixels().center();
 
     KisFilterStrategy *strategy = new KisBilinearFilterStrategy();
     t.image()->scaleImage(QSize(320, 220), t.image()->xRes(), t.image()->yRes(), strategy);
     t.image()->waitForDone();
     QApplication::processEvents();
     delete strategy;
 
     QPointF newStillPoint =
         t.coordinatesConverter()->imageRectInWidgetPixels().center();
 
     QVERIFY(compareWithRounding(oldStillPoint, newStillPoint, 1.0));
 }
 
 void KisZoomAndPanTest::testImageCropped()
 {
     ZoomAndPanTester t;
     QApplication::processEvents();
     initializeViewport(t, false, false, false);
     QApplication::processEvents();
     QVERIFY(checkPan(t, QPoint(-150,-150)));
     QApplication::processEvents();
 
     QPointF oldStillPoint =
         t.coordinatesConverter()->imageToWidget(QPointF(150,150));
 
     t.image()->cropImage(QRect(100,100,100,100));
     t.image()->waitForDone();
     QApplication::processEvents();
 
     QPointF newStillPoint =
         t.coordinatesConverter()->imageToWidget(QPointF(50,50));
 
     QVERIFY(compareWithRounding(oldStillPoint, newStillPoint, 1.0));
 }
 
 KISTEST_MAIN(KisZoomAndPanTest)
diff --git a/libs/ui/tool/KisAsyncronousStrokeUpdateHelper.cpp b/libs/ui/tool/KisAsyncronousStrokeUpdateHelper.cpp
new file mode 100644
index 0000000000..2b2d5d60f7
--- /dev/null
+++ b/libs/ui/tool/KisAsyncronousStrokeUpdateHelper.cpp
@@ -0,0 +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.
+ */
+
+#include "KisAsyncronousStrokeUpdateHelper.h"
+#include "kis_image_interfaces.h"
+
+KisAsyncronousStrokeUpdateHelper::KisAsyncronousStrokeUpdateHelper()
+    : m_strokesFacade(0)
+{
+    m_updateThresholdTimer.setSingleShot(false);
+    m_updateThresholdTimer.setInterval(80 /* ms */);
+    connect(&m_updateThresholdTimer, SIGNAL(timeout()), SLOT(slotAsyncUpdateCame()));
+}
+
+KisAsyncronousStrokeUpdateHelper::~KisAsyncronousStrokeUpdateHelper()
+{
+
+}
+
+void KisAsyncronousStrokeUpdateHelper::startUpdateStream(KisStrokesFacade *strokesFacade, KisStrokeId strokeId)
+{
+    m_strokesFacade = strokesFacade;
+    m_strokeId = strokeId;
+    m_updateThresholdTimer.start();
+}
+
+void KisAsyncronousStrokeUpdateHelper::endUpdateStream()
+{
+    KIS_SAFE_ASSERT_RECOVER_RETURN(isActive());
+
+    slotAsyncUpdateCame(true);
+    cancelUpdateStream();
+}
+
+void KisAsyncronousStrokeUpdateHelper::cancelUpdateStream()
+{
+    KIS_SAFE_ASSERT_RECOVER_RETURN(isActive());
+
+    m_updateThresholdTimer.stop();
+    m_strokeId.clear();
+    m_strokesFacade = 0;
+}
+
+bool KisAsyncronousStrokeUpdateHelper::isActive() const
+{
+    return m_strokeId;
+}
+
+void KisAsyncronousStrokeUpdateHelper::setCustomUpdateDataFactory(KisAsyncronousStrokeUpdateHelper::UpdateDataFactory factory)
+{
+    m_customUpdateFactory = factory;
+}
+
+void KisAsyncronousStrokeUpdateHelper::slotAsyncUpdateCame(bool forceUpdate)
+{
+    if (!m_strokeId || !m_strokesFacade) return;
+    m_strokesFacade->addJob(m_strokeId,
+                            m_customUpdateFactory ?
+                                m_customUpdateFactory(forceUpdate) :
+                                new UpdateData(forceUpdate));
+}
diff --git a/libs/ui/tool/KisAsyncronousStrokeUpdateHelper.h b/libs/ui/tool/KisAsyncronousStrokeUpdateHelper.h
new file mode 100644
index 0000000000..7860cc792d
--- /dev/null
+++ b/libs/ui/tool/KisAsyncronousStrokeUpdateHelper.h
@@ -0,0 +1,85 @@
+/*
+ *  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 KISASYNCRONOUSSTROKEUPDATEHELPER_H
+#define KISASYNCRONOUSSTROKEUPDATEHELPER_H
+
+#include <QObject>
+#include <QTimer>
+#include "kis_types.h"
+#include "kis_stroke_job_strategy.h"
+#include "kritaui_export.h"
+
+class KisStrokesFacade;
+
+
+class KRITAUI_EXPORT KisAsyncronousStrokeUpdateHelper : public QObject
+{
+    Q_OBJECT
+public:
+    class UpdateData : public KisStrokeJobData {
+    public:
+        UpdateData(bool _forceUpdate,
+                   Sequentiality sequentiality = SEQUENTIAL,
+                   Exclusivity exclusivity = NORMAL)
+            : KisStrokeJobData(sequentiality, exclusivity),
+              forceUpdate(_forceUpdate)
+        {}
+
+        KisStrokeJobData* createLodClone(int levelOfDetail) override {
+            return new UpdateData(*this, levelOfDetail);
+        }
+
+
+    private:
+        UpdateData(const UpdateData &rhs, int levelOfDetail)
+            : KisStrokeJobData(rhs),
+              forceUpdate(rhs.forceUpdate)
+        {
+            Q_UNUSED(levelOfDetail);
+        }
+    public:
+        bool forceUpdate = false;
+    };
+
+    using UpdateDataFactory = std::function<KisStrokeJobData*(bool)>;
+
+public:
+    KisAsyncronousStrokeUpdateHelper();
+    ~KisAsyncronousStrokeUpdateHelper();
+
+    void startUpdateStream(KisStrokesFacade *strokesFacade, KisStrokeId strokeId);
+    void endUpdateStream();
+    void cancelUpdateStream();
+
+    bool isActive() const;
+
+    void setCustomUpdateDataFactory(UpdateDataFactory factory);
+
+private Q_SLOTS:
+    void slotAsyncUpdateCame(bool forceUpdate = false);
+
+private:
+    KisStrokesFacade *m_strokesFacade;
+    QTimer m_updateThresholdTimer;
+    KisStrokeId m_strokeId;
+    UpdateDataFactory m_customUpdateFactory;
+};
+
+#endif // KISASYNCRONOUSSTROKEUPDATEHELPER_H
diff --git a/libs/ui/tool/kis_figure_painting_tool_helper.cpp b/libs/ui/tool/kis_figure_painting_tool_helper.cpp
index 54a42a6121..caad575e23 100644
--- a/libs/ui/tool/kis_figure_painting_tool_helper.cpp
+++ b/libs/ui/tool/kis_figure_painting_tool_helper.cpp
@@ -1,144 +1,145 @@
 /*
  *  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_figure_painting_tool_helper.h"
 
 #include <KoCanvasResourceProvider.h>
 
 #include "kis_resources_snapshot.h"
 #include <kis_distance_information.h>
 #include "kis_image.h"
 #include "kis_painter.h"
 #include <strokes/KisFreehandStrokeInfo.h>
+#include "KisAsyncronousStrokeUpdateHelper.h"
 
 
 KisFigurePaintingToolHelper::KisFigurePaintingToolHelper(const KUndo2MagicString &name,
                                                          KisImageWSP image,
                                                          KisNodeSP currentNode,
                                                          KoCanvasResourceProvider *resourceManager,
                                                          KisPainter::StrokeStyle strokeStyle,
                                                          KisPainter::FillStyle fillStyle)
 {
     m_strokesFacade = image.data();
 
     m_resources =
         new KisResourcesSnapshot(image,
                                  currentNode,
                                  resourceManager);
 
     m_resources->setStrokeStyle(strokeStyle);
     m_resources->setFillStyle(fillStyle);
 
     KisFreehandStrokeInfo *strokeInfo = new KisFreehandStrokeInfo();
 
     KisStrokeStrategy *stroke =
         new FreehandStrokeStrategy(m_resources, strokeInfo, name);
 
     m_strokeId = m_strokesFacade->startStroke(stroke);
 }
 
 KisFigurePaintingToolHelper::~KisFigurePaintingToolHelper()
 {
     m_strokesFacade->addJob(m_strokeId,
-        new FreehandStrokeStrategy::UpdateData(true));
+        new KisAsyncronousStrokeUpdateHelper::UpdateData(true));
     m_strokesFacade->endStroke(m_strokeId);
 }
 
 void KisFigurePaintingToolHelper::paintLine(const KisPaintInformation &pi0,
                                             const KisPaintInformation &pi1)
 {
     m_strokesFacade->addJob(m_strokeId,
         new FreehandStrokeStrategy::Data(0,
                                          pi0, pi1));
 }
 
 void KisFigurePaintingToolHelper::paintPolyline(const vQPointF &points)
 {
     m_strokesFacade->addJob(m_strokeId,
         new FreehandStrokeStrategy::Data(0,
                                          FreehandStrokeStrategy::Data::POLYLINE,
                                          points));
 }
 
 void KisFigurePaintingToolHelper::paintPolygon(const vQPointF &points)
 {
     m_strokesFacade->addJob(m_strokeId,
         new FreehandStrokeStrategy::Data(0,
                                          FreehandStrokeStrategy::Data::POLYGON,
                                          points));
 }
 
 void KisFigurePaintingToolHelper::paintRect(const QRectF &rect)
 {
     m_strokesFacade->addJob(m_strokeId,
         new FreehandStrokeStrategy::Data(0,
                                          FreehandStrokeStrategy::Data::RECT,
                                          rect));
 }
 
 void KisFigurePaintingToolHelper::paintEllipse(const QRectF &rect)
 {
     m_strokesFacade->addJob(m_strokeId,
         new FreehandStrokeStrategy::Data(0,
                                          FreehandStrokeStrategy::Data::ELLIPSE,
                                          rect));
 }
 
 void KisFigurePaintingToolHelper::paintPainterPath(const QPainterPath &path)
 {
     m_strokesFacade->addJob(m_strokeId,
         new FreehandStrokeStrategy::Data(0,
                                          FreehandStrokeStrategy::Data::PAINTER_PATH,
                                          path));
 }
 
 void KisFigurePaintingToolHelper::setFGColorOverride(const KoColor &color)
 {
     m_resources->setFGColorOverride(color);
 }
 
 void KisFigurePaintingToolHelper::setBGColorOverride(const KoColor &color)
 {
     m_resources->setBGColorOverride(color);
 }
 
 void KisFigurePaintingToolHelper::setSelectionOverride(KisSelectionSP m_selection)
 {
     m_resources->setSelectionOverride(m_selection);
 }
 
 void KisFigurePaintingToolHelper::setBrush(const KisPaintOpPresetSP &brush)
 {
     m_resources->setBrush(brush);
 }
 
 void KisFigurePaintingToolHelper::paintPainterPathQPen(const QPainterPath path, const QPen &pen, const KoColor &color)
 {
     m_strokesFacade->addJob(m_strokeId,
         new FreehandStrokeStrategy::Data(0,
                                          FreehandStrokeStrategy::Data::QPAINTER_PATH,
                                          path, pen, color));
 }
 
 void KisFigurePaintingToolHelper::paintPainterPathQPenFill(const QPainterPath path, const QPen &pen, const KoColor &color)
 {
     m_strokesFacade->addJob(m_strokeId,
         new FreehandStrokeStrategy::Data(0,
                                          FreehandStrokeStrategy::Data::QPAINTER_PATH_FILL,
                                          path, pen, color));
 }
diff --git a/libs/ui/tool/kis_painting_information_builder.cpp b/libs/ui/tool/kis_painting_information_builder.cpp
index e52259105f..b005a4a67b 100644
--- a/libs/ui/tool/kis_painting_information_builder.cpp
+++ b/libs/ui/tool/kis_painting_information_builder.cpp
@@ -1,198 +1,259 @@
 /*
  *  Copyright (c) 2011 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_painting_information_builder.h"
 
 #include <KoPointerEvent.h>
 
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 
 #include "kis_cubic_curve.h"
 #include "kis_speed_smoother.h"
 
 #include <KoCanvasResourceProvider.h>
 #include "kis_canvas_resource_provider.h"
 
 
 /***********************************************************************/
 /*           KisPaintingInformationBuilder                             */
 /***********************************************************************/
 
 
 const int KisPaintingInformationBuilder::LEVEL_OF_PRESSURE_RESOLUTION = 1024;
 
 
 KisPaintingInformationBuilder::KisPaintingInformationBuilder()
     : m_speedSmoother(new KisSpeedSmoother()),
       m_pressureDisabled(false)
 {
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()),
             SLOT(updateSettings()));
 
     updateSettings();
 }
 
 KisPaintingInformationBuilder::~KisPaintingInformationBuilder()
 {
 
 }
 
 void KisPaintingInformationBuilder::updateSettings()
 {
     KisConfig cfg(true);
     KisCubicCurve curve;
     curve.fromString(cfg.pressureTabletCurve());
     m_pressureSamples = curve.floatTransfer(LEVEL_OF_PRESSURE_RESOLUTION + 1);
 }
 
 KisPaintInformation KisPaintingInformationBuilder::startStroke(KoPointerEvent *event,
                                                                int timeElapsed,
                                                                const KoCanvasResourceProvider *manager)
 {
     if (manager) {
         m_pressureDisabled = manager->resource(KisCanvasResourceProvider::DisablePressure).toBool();
     }
 
     m_startPoint = event->point;
     return createPaintingInformation(event, timeElapsed);
 
 }
 
 KisPaintInformation KisPaintingInformationBuilder::continueStroke(KoPointerEvent *event,
                                                                   int timeElapsed)
 {
     return createPaintingInformation(event, timeElapsed);
 }
 
 QPointF KisPaintingInformationBuilder::adjustDocumentPoint(const QPointF &point, const QPointF &/*startPoint*/)
 {
     return point;
 }
 
 QPointF KisPaintingInformationBuilder::documentToImage(const QPointF &point)
 {
     return point;
 }
 
 QPointF KisPaintingInformationBuilder::imageToView(const QPointF &point)
 {
     return point;
 }
 
 qreal KisPaintingInformationBuilder::calculatePerspective(const QPointF &documentPoint)
 {
     Q_UNUSED(documentPoint);
     return 1.0;
 }
 
+qreal KisPaintingInformationBuilder::canvasRotation() const
+{
+    return 0;
+}
+
+bool KisPaintingInformationBuilder::canvasMirroredX() const
+{
+    return false;
+}
+
+bool KisPaintingInformationBuilder::canvasMirroredY() const
+{
+    return false;
+}
 
 KisPaintInformation KisPaintingInformationBuilder::createPaintingInformation(KoPointerEvent *event,
                                                                              int timeElapsed)
 {
 
     QPointF adjusted = adjustDocumentPoint(event->point, m_startPoint);
     QPointF imagePoint = documentToImage(adjusted);
     qreal perspective = calculatePerspective(adjusted);
     qreal speed = m_speedSmoother->getNextSpeed(imageToView(imagePoint));
 
-    return KisPaintInformation(imagePoint,
+    KisPaintInformation pi(imagePoint,
                                !m_pressureDisabled ? 1.0 : pressureToCurve(event->pressure()),
                                event->xTilt(), event->yTilt(),
                                event->rotation(),
                                event->tangentialPressure(),
                                perspective,
                                timeElapsed,
                                speed);
+
+    pi.setCanvasRotation(canvasRotation());
+    pi.setCanvasMirroredH(canvasMirroredX());
+    pi.setCanvasMirroredV(canvasMirroredY());
+
+    return pi;
 }
 
 KisPaintInformation KisPaintingInformationBuilder::hover(const QPointF &imagePoint,
                                                          const KoPointerEvent *event)
 {
     qreal perspective = calculatePerspective(imagePoint);
     qreal speed = m_speedSmoother->getNextSpeed(imageToView(imagePoint));
 
     if (event) {
         return KisPaintInformation::createHoveringModeInfo(imagePoint,
                                                            PRESSURE_DEFAULT,
                                                            event->xTilt(), event->yTilt(),
                                                            event->rotation(),
                                                            event->tangentialPressure(),
                                                            perspective,
-                                                           speed);
+                                                           speed,
+                                                           canvasRotation(),
+                                                           canvasMirroredX(),
+                                                           canvasMirroredY());
     } else {
-        return KisPaintInformation::createHoveringModeInfo(imagePoint);
+        KisPaintInformation pi = KisPaintInformation::createHoveringModeInfo(imagePoint);
+        pi.setCanvasRotation(canvasRotation());
+        pi.setCanvasMirroredH(canvasMirroredX());
+        pi.setCanvasMirroredV(canvasMirroredY());
+        return pi;
     }
 }
 
 qreal KisPaintingInformationBuilder::pressureToCurve(qreal pressure)
 {
     return KisCubicCurve::interpolateLinear(pressure, m_pressureSamples);
 }
 
 /***********************************************************************/
 /*           KisConverterPaintingInformationBuilder                        */
 /***********************************************************************/
 
 #include "kis_coordinates_converter.h"
 
 KisConverterPaintingInformationBuilder::KisConverterPaintingInformationBuilder(const KisCoordinatesConverter *converter)
     : m_converter(converter)
 {
 }
 
 QPointF KisConverterPaintingInformationBuilder::documentToImage(const QPointF &point)
 {
     return m_converter->documentToImage(point);
 }
 
 QPointF KisConverterPaintingInformationBuilder::imageToView(const QPointF &point)
 {
     return m_converter->documentToWidget(point);
 }
 
+qreal KisConverterPaintingInformationBuilder::canvasRotation() const
+{
+    return m_converter->rotationAngle();
+}
+
+bool KisConverterPaintingInformationBuilder::canvasMirroredX() const
+{
+    return m_converter->xAxisMirrored();
+}
+
+bool KisConverterPaintingInformationBuilder::canvasMirroredY() const
+{
+    return m_converter->yAxisMirrored();
+}
+
 /***********************************************************************/
-/*           KisToolFreehandPaintingInformationBuilder                        */
+/*           KisToolFreehandPaintingInformationBuilder                 */
 /***********************************************************************/
 
 #include "kis_tool_freehand.h"
+#include "kis_canvas2.h"
 
 KisToolFreehandPaintingInformationBuilder::KisToolFreehandPaintingInformationBuilder(KisToolFreehand *tool)
     : m_tool(tool)
 {
 }
 
 QPointF KisToolFreehandPaintingInformationBuilder::documentToImage(const QPointF &point)
 {
     return m_tool->convertToPixelCoord(point);
 }
 
 QPointF KisToolFreehandPaintingInformationBuilder::imageToView(const QPointF &point)
 {
     return m_tool->pixelToView(point);
 }
 
 QPointF KisToolFreehandPaintingInformationBuilder::adjustDocumentPoint(const QPointF &point, const QPointF &startPoint)
 {
     return m_tool->adjustPosition(point, startPoint);
 }
 
 qreal KisToolFreehandPaintingInformationBuilder::calculatePerspective(const QPointF &documentPoint)
 {
     return m_tool->calculatePerspective(documentPoint);
 }
+
+qreal KisToolFreehandPaintingInformationBuilder::canvasRotation() const
+{
+    KisCanvas2 *canvas = dynamic_cast<KisCanvas2*>(m_tool->canvas());
+    return canvas->coordinatesConverter()->rotationAngle();
+}
+
+bool KisToolFreehandPaintingInformationBuilder::canvasMirroredX() const
+{
+    KisCanvas2 *canvas = dynamic_cast<KisCanvas2*>(m_tool->canvas());
+    return canvas->coordinatesConverter()->xAxisMirrored();
+}
+
+bool KisToolFreehandPaintingInformationBuilder::canvasMirroredY() const
+{
+    KisCanvas2 *canvas = dynamic_cast<KisCanvas2*>(m_tool->canvas());
+    return canvas->coordinatesConverter()->yAxisMirrored();
+}
diff --git a/libs/ui/tool/kis_painting_information_builder.h b/libs/ui/tool/kis_painting_information_builder.h
index 42e9820a9d..c5c2e77651 100644
--- a/libs/ui/tool/kis_painting_information_builder.h
+++ b/libs/ui/tool/kis_painting_information_builder.h
@@ -1,112 +1,124 @@
 /*
  *  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_PAINTING_INFORMATION_BUILDER_H
 #define __KIS_PAINTING_INFORMATION_BUILDER_H
 
 #include <QObject>
 #include <QVector>
 
 #include "kis_types.h"
 #include "kritaui_export.h"
 #include <brushengine/kis_paint_information.h>
 
 class KoPointerEvent;
 class KisToolFreehand;
 class KisCoordinatesConverter;
 class KisSpeedSmoother;
 class KoCanvasResourceProvider;
 
 class KRITAUI_EXPORT KisPaintingInformationBuilder : public QObject
 {
     Q_OBJECT
 
 public:
     KisPaintingInformationBuilder();
     ~KisPaintingInformationBuilder() override;
 
     KisPaintInformation startStroke(KoPointerEvent *event, int timeElapsed, const KoCanvasResourceProvider *manager);
 
     KisPaintInformation continueStroke(KoPointerEvent *event,
                                        int timeElapsed);
 
     KisPaintInformation hover(const QPointF &imagePoint,
                               const KoPointerEvent *event);
 
     qreal pressureToCurve(qreal pressure);
 
 protected Q_SLOTS:
     void updateSettings();
 
 protected:
     virtual QPointF adjustDocumentPoint(const QPointF &point, const QPointF &startPoint);
     virtual QPointF documentToImage(const QPointF &point);
     virtual QPointF imageToView(const QPointF &point);
     virtual qreal calculatePerspective(const QPointF &documentPoint);
 
+    virtual qreal canvasRotation() const;
+    virtual bool canvasMirroredX() const;
+    virtual bool canvasMirroredY() const;
+
 private:
 
     KisPaintInformation createPaintingInformation(KoPointerEvent *event,
                                                   int timeElapsed);
 
     /**
      * Defines how many discrete samples are stored in a precomputed array
      * of different pressures.
      */
     static const int LEVEL_OF_PRESSURE_RESOLUTION;
 
 private:
     QVector<qreal> m_pressureSamples;
     QPointF m_startPoint;
     QScopedPointer<KisSpeedSmoother> m_speedSmoother;
     bool m_pressureDisabled;
 };
 
 class KRITAUI_EXPORT KisConverterPaintingInformationBuilder : public KisPaintingInformationBuilder
 {
     Q_OBJECT
 
 public:
     KisConverterPaintingInformationBuilder(const KisCoordinatesConverter *converter);
 
 protected:
     QPointF documentToImage(const QPointF &point) override;
     QPointF imageToView(const QPointF &point) override;
 
+    qreal canvasRotation() const override;
+    bool canvasMirroredX() const override;
+    bool canvasMirroredY() const override;
+
 private:
     const KisCoordinatesConverter *m_converter;
 };
 
 class KRITAUI_EXPORT KisToolFreehandPaintingInformationBuilder : public KisPaintingInformationBuilder
 {
     Q_OBJECT
 
 public:
     KisToolFreehandPaintingInformationBuilder(KisToolFreehand *tool);
 
 protected:
     QPointF documentToImage(const QPointF &point) override;
     QPointF imageToView(const QPointF &point) override;
     QPointF adjustDocumentPoint(const QPointF &point, const QPointF &startPoint) override;
     qreal calculatePerspective(const QPointF &documentPoint) override;
 
+    qreal canvasRotation() const override;
+    bool canvasMirroredX() const override;
+    bool canvasMirroredY() const override;
+
 private:
     KisToolFreehand *m_tool;
 };
 
 #endif /* __KIS_PAINTING_INFORMATION_BUILDER_H */
diff --git a/libs/ui/tool/kis_tool.cc b/libs/ui/tool/kis_tool.cc
index c1d8640d2e..e834a18d79 100644
--- a/libs/ui/tool/kis_tool.cc
+++ b/libs/ui/tool/kis_tool.cc
@@ -1,676 +1,668 @@
 /*
  *  Copyright (c) 2006, 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.h"
 #include <QCursor>
 #include <QLabel>
 #include <QWidget>
 #include <QPolygonF>
 #include <QTransform>
 
 #include <klocalizedstring.h>
 #include <QAction>
 #include <kactioncollection.h>
 
 #include <kis_icon.h>
 #include <KoConfig.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColor.h>
 #include <KoCanvasBase.h>
 #include <KoCanvasController.h>
 #include <KoToolBase.h>
 #include <KoID.h>
 #include <KoPointerEvent.h>
 #include <KoViewConverter.h>
 #include <KoSelection.h>
 #include <resources/KoAbstractGradient.h>
 #include <KoSnapGuide.h>
 
 #include <KisViewManager.h>
 #include "kis_node_manager.h"
 #include <kis_selection.h>
 #include <kis_image.h>
 #include <kis_group_layer.h>
 #include <kis_adjustment_layer.h>
 #include <kis_mask.h>
 #include <kis_paint_layer.h>
 #include <kis_painter.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <brushengine/kis_paintop_settings.h>
 #include <resources/KoPattern.h>
 #include <kis_floating_message.h>
 
 #include "opengl/kis_opengl_canvas2.h"
 #include "kis_canvas_resource_provider.h"
 #include "canvas/kis_canvas2.h"
 #include "kis_coordinates_converter.h"
 #include "filter/kis_filter_configuration.h"
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_cursor.h"
 #include <kis_selection_mask.h>
 #include "kis_resources_snapshot.h"
 #include <KisView.h>
 #include "kis_action_registry.h"
 #include "kis_tool_utils.h"
 
 
 struct Q_DECL_HIDDEN KisTool::Private {
     QCursor cursor; // the cursor that should be shown on tool activation.
 
     // From the canvas resources
     KoPattern* currentPattern{0};
     KoAbstractGradient* currentGradient{0};
     KoColor currentFgColor;
     KoColor currentBgColor;
     float currentExposure{1.0};
     KisFilterConfigurationSP currentGenerator;
     QWidget* optionWidget{0};
     ToolMode m_mode{HOVER_MODE};
     bool m_isActive{false};
 };
 
 KisTool::KisTool(KoCanvasBase * canvas, const QCursor & cursor)
     : KoToolBase(canvas)
     , d(new Private)
 {
     d->cursor = cursor;
 
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(resetCursorStyle()));
     connect(this, SIGNAL(isActiveChanged(bool)), SLOT(resetCursorStyle()));
 }
 
 KisTool::~KisTool()
 {
     delete d;
 }
 
 void KisTool::activate(ToolActivation activation, const QSet<KoShape*> &shapes)
 {
     KoToolBase::activate(activation, shapes);
 
     resetCursorStyle();
 
     if (!canvas()) return;
     if (!canvas()->resourceManager()) return;
 
 
     d->currentFgColor = canvas()->resourceManager()->resource(KoCanvasResourceProvider::ForegroundColor).value<KoColor>();
     d->currentBgColor = canvas()->resourceManager()->resource(KoCanvasResourceProvider::BackgroundColor).value<KoColor>();
 
     if (canvas()->resourceManager()->hasResource(KisCanvasResourceProvider::CurrentPattern)) {
         d->currentPattern = canvas()->resourceManager()->resource(KisCanvasResourceProvider::CurrentPattern).value<KoPattern*>();
     }
 
     if (canvas()->resourceManager()->hasResource(KisCanvasResourceProvider::CurrentGradient)) {
         d->currentGradient = canvas()->resourceManager()->resource(KisCanvasResourceProvider::CurrentGradient).value<KoAbstractGradient*>();
     }
 
     KisPaintOpPresetSP preset = canvas()->resourceManager()->resource(KisCanvasResourceProvider::CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
     if (preset && preset->settings()) {
         preset->settings()->activate();
     }
 
     if (canvas()->resourceManager()->hasResource(KisCanvasResourceProvider::HdrExposure)) {
         d->currentExposure = static_cast<float>(canvas()->resourceManager()->resource(KisCanvasResourceProvider::HdrExposure).toDouble());
     }
 
     if (canvas()->resourceManager()->hasResource(KisCanvasResourceProvider::CurrentGeneratorConfiguration)) {
         d->currentGenerator = canvas()->resourceManager()->resource(KisCanvasResourceProvider::CurrentGeneratorConfiguration).value<KisFilterConfiguration*>();
     }
 
     d->m_isActive = true;
     emit isActiveChanged(true);
 }
 
 void KisTool::deactivate()
 {
     d->m_isActive = false;
     emit isActiveChanged(false);
 
     KoToolBase::deactivate();
 }
 
 void KisTool::canvasResourceChanged(int key, const QVariant & v)
 {
     QString formattedBrushName;
     if (key == KisCanvasResourceProvider::CurrentPaintOpPreset) {
          formattedBrushName = v.value<KisPaintOpPresetSP>()->name().replace("_", " ");
     }
 
     switch (key) {
     case(KoCanvasResourceProvider::ForegroundColor):
         d->currentFgColor = v.value<KoColor>();
         break;
     case(KoCanvasResourceProvider::BackgroundColor):
         d->currentBgColor = v.value<KoColor>();
         break;
     case(KisCanvasResourceProvider::CurrentPattern):
         d->currentPattern = v.value<KoPattern*>();
         break;
     case(KisCanvasResourceProvider::CurrentGradient):
         d->currentGradient = static_cast<KoAbstractGradient *>(v.value<void *>());
         break;
     case(KisCanvasResourceProvider::HdrExposure):
         d->currentExposure = static_cast<float>(v.toDouble());
         break;
     case(KisCanvasResourceProvider::CurrentGeneratorConfiguration):
         d->currentGenerator = static_cast<KisFilterConfiguration*>(v.value<void *>());
         break;
     case(KisCanvasResourceProvider::CurrentPaintOpPreset):
         emit statusTextChanged(formattedBrushName);
         break;
     case(KisCanvasResourceProvider::CurrentKritaNode):
         resetCursorStyle();
         break;
     default:
         break; // Do nothing
     };
 }
 
 void KisTool::updateSettingsViews()
 {
 }
 
 QPointF KisTool::widgetCenterInWidgetPixels()
 {
     KisCanvas2 *kritaCanvas = dynamic_cast<KisCanvas2*>(canvas());
     Q_ASSERT(kritaCanvas);
 
     const KisCoordinatesConverter *converter = kritaCanvas->coordinatesConverter();
     return converter->flakeToWidget(converter->flakeCenterPoint());
 }
 
 QPointF KisTool::convertDocumentToWidget(const QPointF& pt)
 {
     KisCanvas2 *kritaCanvas = dynamic_cast<KisCanvas2*>(canvas());
     Q_ASSERT(kritaCanvas);
 
     return kritaCanvas->coordinatesConverter()->documentToWidget(pt);
 }
 
 QPointF KisTool::convertToPixelCoord(KoPointerEvent *e)
 {
     if (!image())
         return e->point;
 
     return image()->documentToPixel(e->point);
 }
 
 QPointF KisTool::convertToPixelCoord(const QPointF& pt)
 {
     if (!image())
         return pt;
 
     return image()->documentToPixel(pt);
 }
 
 QPointF KisTool::convertToPixelCoordAndSnap(KoPointerEvent *e, const QPointF &offset, bool useModifiers)
 {
     if (!image())
         return e->point;
 
     KoSnapGuide *snapGuide = canvas()->snapGuide();
     QPointF pos = snapGuide->snap(e->point, offset, useModifiers ? e->modifiers() : Qt::NoModifier);
 
     return image()->documentToPixel(pos);
 }
 
 QPointF KisTool::convertToPixelCoordAndSnap(const QPointF& pt, const QPointF &offset)
 {
     if (!image())
         return pt;
 
     KoSnapGuide *snapGuide = canvas()->snapGuide();
     QPointF pos = snapGuide->snap(pt, offset, Qt::NoModifier);
 
     return image()->documentToPixel(pos);
 }
 
 QPoint KisTool::convertToImagePixelCoordFloored(KoPointerEvent *e)
 {
     if (!image())
         return e->point.toPoint();
 
     return image()->documentToImagePixelFloored(e->point);
 }
 
 QPointF KisTool::viewToPixel(const QPointF &viewCoord) const
 {
     if (!image())
         return viewCoord;
 
     return image()->documentToPixel(canvas()->viewConverter()->viewToDocument(viewCoord));
 }
 
 QRectF KisTool::convertToPt(const QRectF &rect)
 {
     if (!image())
         return rect;
     QRectF r;
     //We add 1 in the following to the extreme coords because a pixel always has size
     r.setCoords(int(rect.left()) / image()->xRes(), int(rect.top()) / image()->yRes(),
                 int(rect.right()) / image()->xRes(), int( rect.bottom()) / image()->yRes());
     return r;
 }
 
 qreal KisTool::convertToPt(qreal value)
 {
     const qreal avgResolution = 0.5 * (image()->xRes() + image()->yRes());
     return value / avgResolution;
 }
 
 QPointF KisTool::pixelToView(const QPoint &pixelCoord) const
 {
     if (!image())
         return pixelCoord;
     QPointF documentCoord = image()->pixelToDocument(pixelCoord);
     return canvas()->viewConverter()->documentToView(documentCoord);
 }
 
 QPointF KisTool::pixelToView(const QPointF &pixelCoord) const
 {
     if (!image())
         return pixelCoord;
     QPointF documentCoord = image()->pixelToDocument(pixelCoord);
     return canvas()->viewConverter()->documentToView(documentCoord);
 }
 
 QRectF KisTool::pixelToView(const QRectF &pixelRect) const
 {
-    if (!image())
+    if (!image()) {
         return pixelRect;
+    }
     QPointF topLeft = pixelToView(pixelRect.topLeft());
     QPointF bottomRight = pixelToView(pixelRect.bottomRight());
-    return QRectF(topLeft, bottomRight);
+    return {topLeft, bottomRight};
 }
 
 QPainterPath KisTool::pixelToView(const QPainterPath &pixelPolygon) const
 {
     QTransform matrix;
     qreal zoomX, zoomY;
     canvas()->viewConverter()->zoom(&zoomX, &zoomY);
     matrix.scale(zoomX/image()->xRes(), zoomY/ image()->yRes());
     return matrix.map(pixelPolygon);
 }
 
 QPolygonF KisTool::pixelToView(const QPolygonF &pixelPath) const
 {
     QTransform matrix;
     qreal zoomX, zoomY;
     canvas()->viewConverter()->zoom(&zoomX, &zoomY);
     matrix.scale(zoomX/image()->xRes(), zoomY/ image()->yRes());
     return matrix.map(pixelPath);
 }
 
 void KisTool::updateCanvasPixelRect(const QRectF &pixelRect)
 {
     canvas()->updateCanvas(convertToPt(pixelRect));
 }
 
 void KisTool::updateCanvasViewRect(const QRectF &viewRect)
 {
     canvas()->updateCanvas(canvas()->viewConverter()->viewToDocument(viewRect));
 }
 
 KisImageWSP KisTool::image() const
 {
     // For now, krita tools only work in krita, not for a krita shape. Krita shapes are for 2.1
     KisCanvas2 * kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     if (kisCanvas) {
         return kisCanvas->currentImage();
     }
 
     return 0;
 
 }
 
 QCursor KisTool::cursor() const
 {
     return d->cursor;
 }
 
 KoPattern * KisTool::currentPattern()
 {
     return d->currentPattern;
 }
 
 KoAbstractGradient * KisTool::currentGradient()
 {
     return d->currentGradient;
 }
 
 KisPaintOpPresetSP KisTool::currentPaintOpPreset()
 {
     return canvas()->resourceManager()->resource(KisCanvasResourceProvider::CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
 }
 
 KisNodeSP KisTool::currentNode() const
 {
     KisNodeSP node = canvas()->resourceManager()->resource(KisCanvasResourceProvider::CurrentKritaNode).value<KisNodeWSP>();
     return node;
 }
 
 KisNodeList KisTool::selectedNodes() const
 {
     KisCanvas2 * kiscanvas = static_cast<KisCanvas2*>(canvas());
     KisViewManager* viewManager = kiscanvas->viewManager();
     return viewManager->nodeManager()->selectedNodes();
 }
 
 KoColor KisTool::currentFgColor()
 {
     return d->currentFgColor;
 }
 
 KoColor KisTool::currentBgColor()
 {
     return d->currentBgColor;
 }
 
 KisImageWSP KisTool::currentImage()
 {
     return image();
 }
 
 KisFilterConfigurationSP  KisTool::currentGenerator()
 {
     return d->currentGenerator;
 }
 
 void KisTool::setMode(ToolMode mode) {
     d->m_mode = mode;
 }
 
 KisTool::ToolMode KisTool::mode() const {
     return d->m_mode;
 }
 
 void KisTool::setCursor(const QCursor &cursor)
 {
     d->cursor = cursor;
 }
 
 KisTool::AlternateAction KisTool::actionToAlternateAction(ToolAction action) {
     KIS_ASSERT_RECOVER_RETURN_VALUE(action != Primary, Secondary);
     return (AlternateAction)action;
 }
 
 void KisTool::activatePrimaryAction()
 {
     resetCursorStyle();
 }
 
 void KisTool::deactivatePrimaryAction()
 {
     resetCursorStyle();
 }
 
 void KisTool::beginPrimaryAction(KoPointerEvent *event)
 {
     Q_UNUSED(event);
 }
 
 void KisTool::beginPrimaryDoubleClickAction(KoPointerEvent *event)
 {
     beginPrimaryAction(event);
 }
 
 void KisTool::continuePrimaryAction(KoPointerEvent *event)
 {
     Q_UNUSED(event);
 }
 
 void KisTool::endPrimaryAction(KoPointerEvent *event)
 {
     Q_UNUSED(event);
 }
 
 bool KisTool::primaryActionSupportsHiResEvents() const
 {
     return false;
 }
 
 void KisTool::activateAlternateAction(AlternateAction action)
 {
     Q_UNUSED(action);
 }
 
 void KisTool::deactivateAlternateAction(AlternateAction action)
 {
     Q_UNUSED(action);
 }
 
 void KisTool::beginAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     Q_UNUSED(event);
     Q_UNUSED(action);
 }
 
 void KisTool::beginAlternateDoubleClickAction(KoPointerEvent *event, AlternateAction action)
 {
     beginAlternateAction(event, action);
 }
 
 void KisTool::continueAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     Q_UNUSED(event);
     Q_UNUSED(action);
 }
 
 void KisTool::endAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     Q_UNUSED(event);
     Q_UNUSED(action);
 }
 
 void KisTool::mouseDoubleClickEvent(KoPointerEvent *event)
 {
     Q_UNUSED(event);
 }
 
 void KisTool::mouseTripleClickEvent(KoPointerEvent *event)
 {
     mouseDoubleClickEvent(event);
 }
 
 void KisTool::mousePressEvent(KoPointerEvent *event)
 {
     Q_UNUSED(event);
 }
 
 void KisTool::mouseReleaseEvent(KoPointerEvent *event)
 {
     Q_UNUSED(event);
 }
 
 void KisTool::mouseMoveEvent(KoPointerEvent *event)
 {
     Q_UNUSED(event);
 }
 
 void KisTool::deleteSelection()
 {
     KisResourcesSnapshotSP resources =
         new KisResourcesSnapshot(image(), currentNode(), this->canvas()->resourceManager());
 
     if (!blockUntilOperationsFinished()) {
         return;
     }
 
     if (!KisToolUtils::clearImage(image(), resources->currentNode(), resources->activeSelection())) {
         KoToolBase::deleteSelection();
     }
 }
 
 KisTool::NodePaintAbility KisTool::nodePaintAbility()
 {
     KisNodeSP node = currentNode();
     if (!node) {
         return NodePaintAbility::UNPAINTABLE;
     }
     if (node->inherits("KisShapeLayer")) {
         return NodePaintAbility::VECTOR;
     }
     if (node->inherits("KisCloneLayer")) {
         return NodePaintAbility::CLONE;
     }
     if (node->paintDevice()) {
         return NodePaintAbility::PAINT;
     }
 
     return NodePaintAbility::UNPAINTABLE;
 }
 
 QWidget* KisTool::createOptionWidget()
 {
     d->optionWidget = new QLabel(i18n("No options"));
     d->optionWidget->setObjectName("SpecialSpacer");
     return d->optionWidget;
 }
 
 #define NEAR_VAL -1000.0
 #define FAR_VAL 1000.0
 #define PROGRAM_VERTEX_ATTRIBUTE 0
 
 void KisTool::paintToolOutline(QPainter* painter, const QPainterPath &path)
 {
     KisOpenGLCanvas2 *canvasWidget = dynamic_cast<KisOpenGLCanvas2 *>(canvas()->canvasWidget());
     if (canvasWidget)  {
         painter->beginNativePainting();
         canvasWidget->paintToolOutline(path);
         painter->endNativePainting();
     }
     else {
         painter->save();
         painter->setCompositionMode(QPainter::RasterOp_SourceXorDestination);
         painter->setPen(QColor(128, 255, 128));
         painter->drawPath(path);
         painter->restore();
     }
 }
 
 void KisTool::resetCursorStyle()
 {
     useCursor(d->cursor);
 }
 
 bool KisTool::overrideCursorIfNotEditable()
 {
     // override cursor for canvas iff this tool is active
     // and we can't paint on the active layer
     if (isActive()) {
         KisNodeSP node = currentNode();
         if (node && !node->isEditable()) {
             canvas()->setCursor(Qt::ForbiddenCursor);
             return true;
         }
     }
     return false;
 }
 
 bool KisTool::blockUntilOperationsFinished()
 {
-    // we cannot show any dialogs in the tool's code,
-    // it can make KisShortcutsMatcher crazy
-    image()->waitForDone();
-    return true;
-
-//    KisCanvas2 * kiscanvas = static_cast<KisCanvas2*>(canvas());
-//    KisViewManager* viewManager = kiscanvas->viewManager();
-//    return viewManager->blockUntilOperationsFinished(image());
+    KisCanvas2 * kiscanvas = static_cast<KisCanvas2*>(canvas());
+    KisViewManager* viewManager = kiscanvas->viewManager();
+    return viewManager->blockUntilOperationsFinished(image());
 }
 
 void KisTool::blockUntilOperationsFinishedForced()
 {
-    // we cannot show any dialogs in the tool's code,
-    // it can make KisShortcutsMatcher crazy
-    image()->waitForDone();
-
-//    KisCanvas2 * kiscanvas = static_cast<KisCanvas2*>(canvas());
-//    KisViewManager* viewManager = kiscanvas->viewManager();
-//    viewManager->blockUntilOperationsFinishedForced(image());
+    KisCanvas2 * kiscanvas = static_cast<KisCanvas2*>(canvas());
+    KisViewManager* viewManager = kiscanvas->viewManager();
+    viewManager->blockUntilOperationsFinishedForced(image());
 }
 
 bool KisTool::isActive() const
 {
     return d->m_isActive;
 }
 
 bool KisTool::nodeEditable()
 {
     KisNodeSP node = currentNode();
     if (!node) {
         return false;
     }
 
     bool blockedNoIndirectPainting = false;
 
     const bool presetUsesIndirectPainting =
         !currentPaintOpPreset()->settings()->paintIncremental();
 
     if (!presetUsesIndirectPainting) {
         const KisIndirectPaintingSupport *indirectPaintingLayer =
                 dynamic_cast<const KisIndirectPaintingSupport*>(node.data());
         if (indirectPaintingLayer) {
             blockedNoIndirectPainting = !indirectPaintingLayer->supportsNonIndirectPainting();
         }
     }
 
     bool nodeEditable = node->isEditable() && !blockedNoIndirectPainting;
 
     if (!nodeEditable) {
         KisCanvas2 * kiscanvas = static_cast<KisCanvas2*>(canvas());
         QString message;
         if (!node->visible() && node->userLocked()) {
             message = i18n("Layer is locked and invisible.");
         } else if (node->userLocked()) {
             message = i18n("Layer is locked.");
         } else if(!node->visible()) {
             message = i18n("Layer is invisible.");
         } else if (blockedNoIndirectPainting) {
             message = i18n("Layer can be painted in Wash Mode only.");
         } else {
             message = i18n("Group not editable.");
         }
         kiscanvas->viewManager()->showFloatingMessage(message, KisIconUtils::loadIcon("object-locked"));
     }
     return nodeEditable;
 }
 
 bool KisTool::selectionEditable()
 {
     KisCanvas2 * kisCanvas = static_cast<KisCanvas2*>(canvas());
     KisViewManager * view = kisCanvas->viewManager();
 
     bool editable = view->selectionEditable();
     if (!editable) {
         KisCanvas2 * kiscanvas = static_cast<KisCanvas2*>(canvas());
         kiscanvas->viewManager()->showFloatingMessage(i18n("Local selection is locked."), KisIconUtils::loadIcon("object-locked"));
     }
     return editable;
 }
 
 void KisTool::listenToModifiers(bool listen)
 {
     Q_UNUSED(listen);
 }
 
 bool KisTool::listeningToModifiers()
 {
     return false;
 }
diff --git a/libs/ui/tool/kis_tool_freehand.cc b/libs/ui/tool/kis_tool_freehand.cc
index 44bfc63df7..43059f8ab1 100644
--- a/libs/ui/tool/kis_tool_freehand.cc
+++ b/libs/ui/tool/kis_tool_freehand.cc
@@ -1,461 +1,457 @@
 /*
  *  kis_tool_freehand.cc - part of Krita
  *
  *  Copyright (c) 2003-2007 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2004 Bart Coppens <kde@bartcoppens.be>
  *  Copyright (c) 2007,2008,2010 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2009 Lukáš Tvrdý <lukast.dev@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_tool_freehand.h"
 
 #include <QPainter>
 #include <QRect>
 #include <QThreadPool>
 #include <QApplication>
 #include <QDesktopWidget>
 
 #include <Eigen/Core>
 
 #include <kis_icon.h>
 #include <KoPointerEvent.h>
 #include <KoViewConverter.h>
 #include <KoCanvasController.h>
 
 //pop up palette
 #include <kis_canvas_resource_provider.h>
 
 // Krita/image
 #include <kis_layer.h>
 #include <kis_paint_layer.h>
 #include <kis_painter.h>
 #include <brushengine/kis_paintop.h>
 #include <kis_selection.h>
 #include <brushengine/kis_paintop_preset.h>
 
 
 // Krita/ui
 #include "kis_abstract_perspective_grid.h"
 #include "kis_config.h"
 #include "canvas/kis_canvas2.h"
 #include "kis_cursor.h"
 #include <KisViewManager.h>
 #include <kis_painting_assistants_decoration.h>
 #include "kis_painting_information_builder.h"
 #include "kis_tool_freehand_helper.h"
 #include "strokes/freehand_stroke.h"
 
 using namespace std::placeholders; // For _1 placeholder
 
 
 KisToolFreehand::KisToolFreehand(KoCanvasBase * canvas, const QCursor & cursor, const KUndo2MagicString &transactionText)
     : KisToolPaint(canvas, cursor),
       m_paintopBasedPickingInAction(false),
       m_brushResizeCompressor(200, std::bind(&KisToolFreehand::slotDoResizeBrush, this, _1))
 {
     m_assistant = false;
     m_magnetism = 1.0;
     m_only_one_assistant = true;
 
     setSupportOutline(true);
     setMaskSyntheticEvents(KisConfig(true).disableTouchOnCanvas()); // Disallow mouse events from finger presses unless enabled
 
     m_infoBuilder = new KisToolFreehandPaintingInformationBuilder(this);
     m_helper = new KisToolFreehandHelper(m_infoBuilder, transactionText);
 
     connect(m_helper, SIGNAL(requestExplicitUpdateOutline()), SLOT(explicitUpdateOutline()));
 }
 
 KisToolFreehand::~KisToolFreehand()
 {
     delete m_helper;
     delete m_infoBuilder;
 }
 
 void KisToolFreehand::mouseMoveEvent(KoPointerEvent *event)
 {
     KisToolPaint::mouseMoveEvent(event);
     m_helper->cursorMoved(convertToPixelCoord(event));
 }
 
 KisSmoothingOptionsSP KisToolFreehand::smoothingOptions() const
 {
     return m_helper->smoothingOptions();
 }
 
 void KisToolFreehand::resetCursorStyle()
 {
     KisConfig cfg(true);
 
     switch (cfg.newCursorStyle()) {
     case CURSOR_STYLE_NO_CURSOR:
         useCursor(KisCursor::blankCursor());
         break;
     case CURSOR_STYLE_POINTER:
         useCursor(KisCursor::arrowCursor());
         break;
     case CURSOR_STYLE_SMALL_ROUND:
         useCursor(KisCursor::roundCursor());
         break;
     case CURSOR_STYLE_CROSSHAIR:
         useCursor(KisCursor::crossCursor());
         break;
     case CURSOR_STYLE_TRIANGLE_RIGHTHANDED:
         useCursor(KisCursor::triangleRightHandedCursor());
         break;
     case CURSOR_STYLE_TRIANGLE_LEFTHANDED:
         useCursor(KisCursor::triangleLeftHandedCursor());
         break;
     case CURSOR_STYLE_BLACK_PIXEL:
         useCursor(KisCursor::pixelBlackCursor());
         break;
     case CURSOR_STYLE_WHITE_PIXEL:
         useCursor(KisCursor::pixelWhiteCursor());
         break;
     case CURSOR_STYLE_TOOLICON:
     default:
         KisToolPaint::resetCursorStyle();
         break;
     }
 }
 
 KisPaintingInformationBuilder* KisToolFreehand::paintingInformationBuilder() const
 {
     return m_infoBuilder;
 }
 
 void KisToolFreehand::resetHelper(KisToolFreehandHelper *helper)
 {
     delete m_helper;
     m_helper = helper;
 }
 
 int KisToolFreehand::flags() const
 {
     return KisTool::FLAG_USES_CUSTOM_COMPOSITEOP|KisTool::FLAG_USES_CUSTOM_PRESET
            |KisTool::FLAG_USES_CUSTOM_SIZE;
 }
 
 void KisToolFreehand::activate(ToolActivation activation, const QSet<KoShape*> &shapes)
 {
     KisToolPaint::activate(activation, shapes);
 }
 
 void KisToolFreehand::deactivate()
 {
     if (mode() == PAINT_MODE) {
         endStroke();
         setMode(KisTool::HOVER_MODE);
     }
     KisToolPaint::deactivate();
 }
 
 void KisToolFreehand::initStroke(KoPointerEvent *event)
 {
     m_helper->initPaint(event,
                         convertToPixelCoord(event),
                         canvas()->resourceManager(),
                         image(),
                         currentNode(),
                         image().data());
 }
 
 void KisToolFreehand::doStroke(KoPointerEvent *event)
 {
-    //set canvas information here?//
-    KisCanvas2 *canvas2 = dynamic_cast<KisCanvas2 *>(canvas());
-    if (canvas2) {
-        m_helper->setCanvasHorizontalMirrorState(canvas2->xAxisMirrored());
-        m_helper->setCanvasRotation(canvas2->rotationAngle());
-    }
     m_helper->paintEvent(event);
 }
 
 void KisToolFreehand::endStroke()
 {
     m_helper->endPaint();
     bool paintOpIgnoredEvent = currentPaintOpPreset()->settings()->mouseReleaseEvent();
     Q_UNUSED(paintOpIgnoredEvent);
 }
 
 bool KisToolFreehand::primaryActionSupportsHiResEvents() const
 {
     return true;
 }
 
 void KisToolFreehand::beginPrimaryAction(KoPointerEvent *event)
 {
     // FIXME: workaround for the Duplicate Op
     tryPickByPaintOp(event, PickFgImage);
 
     requestUpdateOutline(event->point, event);
 
     NodePaintAbility paintability = nodePaintAbility();
     // XXX: move this to KisTool and make it work properly for clone layers: for clone layers, the shape paint tools don't work either
     if (!nodeEditable() || paintability != PAINT) {
         if (paintability == KisToolPaint::VECTOR || paintability == KisToolPaint::CLONE){
             KisCanvas2 * kiscanvas = static_cast<KisCanvas2*>(canvas());
             QString message = i18n("The brush tool cannot paint on this layer.  Please select a paint layer or mask.");
             kiscanvas->viewManager()->showFloatingMessage(message, koIcon("object-locked"));
         }
         event->ignore();
 
         return;
     }
 
+    KIS_SAFE_ASSERT_RECOVER_RETURN(!m_helper->isRunning());
+
     setMode(KisTool::PAINT_MODE);
 
     KisCanvas2 *canvas2 = dynamic_cast<KisCanvas2 *>(canvas());
     if (canvas2) {
         canvas2->viewManager()->disableControls();
     }
 
     initStroke(event);
 }
 
 void KisToolFreehand::continuePrimaryAction(KoPointerEvent *event)
 {
     CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
 
     requestUpdateOutline(event->point, event);
 
     /**
      * Actual painting
      */
     doStroke(event);
 }
 
 void KisToolFreehand::endPrimaryAction(KoPointerEvent *event)
 {
     Q_UNUSED(event);
     CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
 
     endStroke();
 
     if (m_assistant && static_cast<KisCanvas2*>(canvas())->paintingAssistantsDecoration()) {
         static_cast<KisCanvas2*>(canvas())->paintingAssistantsDecoration()->endStroke();
     }
 
     KisCanvas2 *canvas2 = dynamic_cast<KisCanvas2 *>(canvas());
     if (canvas2) {
         canvas2->viewManager()->enableControls();
     }
 
     setMode(KisTool::HOVER_MODE);
 }
 
 bool KisToolFreehand::tryPickByPaintOp(KoPointerEvent *event, AlternateAction action)
 {
     if (action != PickFgNode && action != PickFgImage) return false;
 
     /**
      * FIXME: we need some better way to implement modifiers
      * for a paintop level. This method is used in DuplicateOp only!
      */
     QPointF pos = adjustPosition(event->point, event->point);
     qreal perspective = 1.0;
     Q_FOREACH (const QPointer<KisAbstractPerspectiveGrid> grid, static_cast<KisCanvas2*>(canvas())->viewManager()->canvasResourceProvider()->perspectiveGrids()) {
         if (grid && grid->contains(pos)) {
             perspective = grid->distance(pos);
             break;
         }
     }
     if (!currentPaintOpPreset()) {
         return false;
     }
     bool paintOpIgnoredEvent = currentPaintOpPreset()->settings()->
         mousePressEvent(KisPaintInformation(convertToPixelCoord(event->point),
                                             m_infoBuilder->pressureToCurve(event->pressure()),
                                             event->xTilt(), event->yTilt(),
                                             event->rotation(),
                                             event->tangentialPressure(),
                                             perspective, 0, 0),
                         event->modifiers(),
                         currentNode());
     // DuplicateOP during the picking of new source point (origin)
     // is the only paintop that returns "false" here
     return !paintOpIgnoredEvent;
 }
 
 void KisToolFreehand::activateAlternateAction(AlternateAction action)
 {
     if (action != ChangeSize) {
         KisToolPaint::activateAlternateAction(action);
         return;
     }
 
     useCursor(KisCursor::blankCursor());
     setOutlineEnabled(true);
 }
 
 void KisToolFreehand::deactivateAlternateAction(AlternateAction action)
 {
     if (action != ChangeSize) {
         KisToolPaint::deactivateAlternateAction(action);
         return;
     }
 
     resetCursorStyle();
     setOutlineEnabled(false);
 }
 
 void KisToolFreehand::beginAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     if (tryPickByPaintOp(event, action)) {
         m_paintopBasedPickingInAction = true;
         return;
     }
 
     if (action != ChangeSize) {
         KisToolPaint::beginAlternateAction(event, action);
         return;
     }
 
     setMode(GESTURE_MODE);
     m_initialGestureDocPoint = event->point;
     m_initialGestureGlobalPoint = QCursor::pos();
 
     m_lastDocumentPoint = event->point;
     m_lastPaintOpSize = currentPaintOpPreset()->settings()->paintOpSize();
 }
 
 void KisToolFreehand::continueAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     if (tryPickByPaintOp(event, action) || m_paintopBasedPickingInAction) return;
 
     if (action != ChangeSize) {
         KisToolPaint::continueAlternateAction(event, action);
         return;
     }
 
     QPointF lastWidgetPosition = convertDocumentToWidget(m_lastDocumentPoint);
     QPointF actualWidgetPosition = convertDocumentToWidget(event->point);
 
     QPointF offset = actualWidgetPosition - lastWidgetPosition;
 
     KisCanvas2 *canvas2 = dynamic_cast<KisCanvas2 *>(canvas());
     QRect screenRect = QApplication::desktop()->screenGeometry();
 
     qreal scaleX = 0;
     qreal scaleY = 0;
     canvas2->coordinatesConverter()->imageScale(&scaleX, &scaleY);
 
     const qreal maxBrushSize = KisConfig(true).readEntry("maximumBrushSize", 1000);
     const qreal effectiveMaxDragSize = 0.5 * screenRect.width();
     const qreal effectiveMaxBrushSize = qMin(maxBrushSize, effectiveMaxDragSize / scaleX);
 
     const qreal scaleCoeff = effectiveMaxBrushSize / effectiveMaxDragSize;
     const qreal sizeDiff = scaleCoeff * offset.x() ;
 
     if (qAbs(sizeDiff) > 0.01) {
         KisPaintOpSettingsSP settings = currentPaintOpPreset()->settings();
         const qreal newSize = qBound(0.01, m_lastPaintOpSize + sizeDiff, maxBrushSize);
 
         settings->setPaintOpSize(newSize);
         requestUpdateOutline(m_initialGestureDocPoint, 0);
         //m_brushResizeCompressor.start(newSize);
 
         m_lastDocumentPoint = event->point;
         m_lastPaintOpSize = newSize;
     }
 }
 
 void KisToolFreehand::endAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     if (tryPickByPaintOp(event, action) || m_paintopBasedPickingInAction) {
         m_paintopBasedPickingInAction = false;
         return;
     }
 
     if (action != ChangeSize) {
         KisToolPaint::endAlternateAction(event, action);
         return;
     }
 
     QCursor::setPos(m_initialGestureGlobalPoint);
     requestUpdateOutline(m_initialGestureDocPoint, 0);
 
     setMode(HOVER_MODE);
 }
 
 bool KisToolFreehand::wantsAutoScroll() const
 {
     return false;
 }
 
 void KisToolFreehand::setAssistant(bool assistant)
 {
     m_assistant = assistant;
 }
 
 void KisToolFreehand::setOnlyOneAssistantSnap(bool assistant)
 {
     m_only_one_assistant = assistant;
 }
 
 void KisToolFreehand::slotDoResizeBrush(qreal newSize)
 {
     KisPaintOpSettingsSP settings = currentPaintOpPreset()->settings();
 
     settings->setPaintOpSize(newSize);
     requestUpdateOutline(m_initialGestureDocPoint, 0);
 
 }
 
 QPointF KisToolFreehand::adjustPosition(const QPointF& point, const QPointF& strokeBegin)
 {
     if (m_assistant && static_cast<KisCanvas2*>(canvas())->paintingAssistantsDecoration()) {
         static_cast<KisCanvas2*>(canvas())->paintingAssistantsDecoration()->setOnlyOneAssistantSnap(m_only_one_assistant);
         QPointF ap = static_cast<KisCanvas2*>(canvas())->paintingAssistantsDecoration()->adjustPosition(point, strokeBegin);
         return (1.0 - m_magnetism) * point + m_magnetism * ap;
     }
     return point;
 }
 
 qreal KisToolFreehand::calculatePerspective(const QPointF &documentPoint)
 {
     qreal perspective = 1.0;
     Q_FOREACH (const QPointer<KisAbstractPerspectiveGrid> grid, static_cast<KisCanvas2*>(canvas())->viewManager()->canvasResourceProvider()->perspectiveGrids()) {
         if (grid && grid->contains(documentPoint)) {
             perspective = grid->distance(documentPoint);
             break;
         }
     }
     return perspective;
 }
 
 void KisToolFreehand::explicitUpdateOutline()
 {
     requestUpdateOutline(m_outlineDocPoint, 0);
 }
 
 QPainterPath KisToolFreehand::getOutlinePath(const QPointF &documentPos,
                                              const KoPointerEvent *event,
                                              KisPaintOpSettings::OutlineMode outlineMode)
 {
     QPointF imagePos = convertToPixelCoord(documentPos);
 
     if (currentPaintOpPreset())
         return m_helper->paintOpOutline(imagePos,
                                         event,
                                         currentPaintOpPreset()->settings(),
                                         outlineMode);
     else
         return QPainterPath();
 }
 
 
diff --git a/libs/ui/tool/kis_tool_freehand_helper.cpp b/libs/ui/tool/kis_tool_freehand_helper.cpp
index 7bcae1f1b8..d4665eeb04 100644
--- a/libs/ui/tool/kis_tool_freehand_helper.cpp
+++ b/libs/ui/tool/kis_tool_freehand_helper.cpp
@@ -1,1003 +1,964 @@
 /*
  *  Copyright (c) 2011 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_tool_freehand_helper.h"
 
 #include <QTimer>
 #include <QQueue>
 
 #include <klocalizedstring.h>
 
 #include <KoPointerEvent.h>
 #include <KoCanvasResourceProvider.h>
 
 #include "kis_algebra_2d.h"
 #include "kis_distance_information.h"
 #include "kis_painting_information_builder.h"
 #include "kis_image.h"
 #include "kis_painter.h"
 #include <brushengine/kis_paintop_preset.h>
 #include <brushengine/kis_paintop_utils.h>
 
 #include "kis_update_time_monitor.h"
 #include "kis_stabilized_events_sampler.h"
 #include "KisStabilizerDelayedPaintHelper.h"
 #include "kis_config.h"
 
 #include "kis_random_source.h"
 #include "KisPerStrokeRandomSource.h"
 
 #include "strokes/freehand_stroke.h"
 #include "strokes/KisFreehandStrokeInfo.h"
+#include "KisAsyncronousStrokeUpdateHelper.h"
 
 #include <math.h>
 
 //#define DEBUG_BEZIER_CURVES
 
 // Factor by which to scale the airbrush timer's interval, relative to the actual airbrushing rate.
 // Setting this less than 1 makes the timer-generated pseudo-events happen faster than the desired
 // airbrush rate, which can improve responsiveness.
 const qreal AIRBRUSH_INTERVAL_FACTOR = 0.5;
 
 // The amount of time, in milliseconds, to allow between updates of the spacing information. Only
 // used when spacing updates between dabs are enabled.
 const qreal SPACING_UPDATE_INTERVAL = 50.0;
 
 // The amount of time, in milliseconds, to allow between updates of the timing information. Only
 // used when airbrushing.
 const qreal TIMING_UPDATE_INTERVAL = 50.0;
 
 struct KisToolFreehandHelper::Private
 {
     KisPaintingInformationBuilder *infoBuilder;
     KisStrokesFacade *strokesFacade;
+    KisAsyncronousStrokeUpdateHelper asyncUpdateHelper;
 
     KUndo2MagicString transactionText;
 
     bool haveTangent;
     QPointF previousTangent;
 
     bool hasPaintAtLeastOnce;
 
     QTime strokeTime;
     QTimer strokeTimeoutTimer;
 
     QVector<KisFreehandStrokeInfo*> strokeInfos;
     KisResourcesSnapshotSP resources;
     KisStrokeId strokeId;
 
     KisPaintInformation previousPaintInformation;
     KisPaintInformation olderPaintInformation;
 
     KisSmoothingOptionsSP smoothingOptions;
 
     // fake random sources for hovering outline *only*
     KisRandomSourceSP fakeDabRandomSource;
     KisPerStrokeRandomSourceSP fakeStrokeRandomSource;
 
     // Timer used to generate paint updates periodically even without input events. This is only
     // used for paintops that depend on timely updates even when the cursor is not moving, e.g. for
     // airbrushing effects.
     QTimer airbrushingTimer;
 
     QList<KisPaintInformation> history;
     QList<qreal> distanceHistory;
 
     // Keeps track of past cursor positions. This is used to determine the drawing angle when
     // drawing the brush outline or starting a stroke.
     KisPaintOpUtils::PositionHistory lastCursorPos;
 
     // Stabilizer data
     bool usingStabilizer;
     QQueue<KisPaintInformation> stabilizerDeque;
     QTimer stabilizerPollTimer;
     KisStabilizedEventsSampler stabilizedSampler;
     KisStabilizerDelayedPaintHelper stabilizerDelayedPaintHelper;
 
-    QTimer asynchronousUpdatesThresholdTimer;
-
-    int canvasRotation;
-    bool canvasMirroredH;
-
     qreal effectiveSmoothnessDistance() const;
 };
 
 
 KisToolFreehandHelper::KisToolFreehandHelper(KisPaintingInformationBuilder *infoBuilder,
                                              const KUndo2MagicString &transactionText,
                                              KisSmoothingOptions *smoothingOptions)
     : m_d(new Private())
 {
     m_d->infoBuilder = infoBuilder;
     m_d->transactionText = transactionText;
     m_d->smoothingOptions = KisSmoothingOptionsSP(
                 smoothingOptions ? smoothingOptions : new KisSmoothingOptions());
-    m_d->canvasRotation = 0;
 
     m_d->fakeDabRandomSource = new KisRandomSource();
     m_d->fakeStrokeRandomSource = new KisPerStrokeRandomSource();
 
     m_d->strokeTimeoutTimer.setSingleShot(true);
     connect(&m_d->strokeTimeoutTimer, SIGNAL(timeout()), SLOT(finishStroke()));
     connect(&m_d->airbrushingTimer, SIGNAL(timeout()), SLOT(doAirbrushing()));
-    connect(&m_d->asynchronousUpdatesThresholdTimer, SIGNAL(timeout()), SLOT(doAsynchronousUpdate()));
     connect(&m_d->stabilizerPollTimer, SIGNAL(timeout()), SLOT(stabilizerPollAndPaint()));
     connect(m_d->smoothingOptions.data(), SIGNAL(sigSmoothingTypeChanged()), SLOT(slotSmoothingTypeChanged()));
 
     m_d->stabilizerDelayedPaintHelper.setPaintLineCallback(
                 [this](const KisPaintInformation &pi1, const KisPaintInformation &pi2) {
                     paintLine(pi1, pi2);
                 });
     m_d->stabilizerDelayedPaintHelper.setUpdateOutlineCallback(
                 [this]() {
                     emit requestExplicitUpdateOutline();
                 });
 }
 
 KisToolFreehandHelper::~KisToolFreehandHelper()
 {
     delete m_d;
 }
 
 void KisToolFreehandHelper::setSmoothness(KisSmoothingOptionsSP smoothingOptions)
 {
     m_d->smoothingOptions = smoothingOptions;
 }
 
 KisSmoothingOptionsSP KisToolFreehandHelper::smoothingOptions() const
 {
     return m_d->smoothingOptions;
 }
 
 QPainterPath KisToolFreehandHelper::paintOpOutline(const QPointF &savedCursorPos,
                                                    const KoPointerEvent *event,
                                                    const KisPaintOpSettingsSP globalSettings,
                                                    KisPaintOpSettings::OutlineMode mode) const
 {
     KisPaintOpSettingsSP settings = globalSettings;
     KisPaintInformation info = m_d->infoBuilder->hover(savedCursorPos, event);
     QPointF prevPoint = m_d->lastCursorPos.pushThroughHistory(savedCursorPos);
     qreal startAngle = KisAlgebra2D::directionBetweenPoints(prevPoint, savedCursorPos, 0);
-    info.setCanvasRotation(m_d->canvasRotation);
-    info.setCanvasHorizontalMirrorState( m_d->canvasMirroredH );
     KisDistanceInformation distanceInfo(prevPoint, startAngle);
 
     if (!m_d->strokeInfos.isEmpty()) {
         settings = m_d->resources->currentPaintOpPreset()->settings();
         if (m_d->stabilizerDelayedPaintHelper.running() &&
                 m_d->stabilizerDelayedPaintHelper.hasLastPaintInformation()) {
             info = m_d->stabilizerDelayedPaintHelper.lastPaintInformation();
         } else {
             info = m_d->previousPaintInformation;
         }
 
         /**
          * When LoD mode is active it may happen that the helper has
          * already started a stroke, but it painted noting, because
          * all the work is being calculated by the scaled-down LodN
          * stroke. So at first we try to fetch the data from the lodN
          * stroke ("buddy") and then check if there is at least
          * something has been painted with this distance information
          * object.
          */
         KisDistanceInformation *buddyDistance =
             m_d->strokeInfos.first()->buddyDragDistance();
 
         if (buddyDistance) {
             /**
              * Tiny hack alert: here we fetch the distance information
              * directly from the LodN stroke. Ideally, we should
              * upscale its data, but here we just override it with our
              * local copy of the coordinates.
              */
             distanceInfo = *buddyDistance;
             distanceInfo.overrideLastValues(prevPoint, startAngle);
 
         } else if (m_d->strokeInfos.first()->dragDistance->isStarted()) {
             distanceInfo = *m_d->strokeInfos.first()->dragDistance;
         }
     }
 
     KisPaintInformation::DistanceInformationRegistrar registrar =
         info.registerDistanceInformation(&distanceInfo);
 
     info.setRandomSource(m_d->fakeDabRandomSource);
     info.setPerStrokeRandomSource(m_d->fakeStrokeRandomSource);
 
     QPainterPath outline = settings->brushOutline(info, mode);
 
     if (m_d->resources &&
         m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::STABILIZER &&
         m_d->smoothingOptions->useDelayDistance()) {
 
         const qreal R = m_d->smoothingOptions->delayDistance() /
             m_d->resources->effectiveZoom();
 
         outline.addEllipse(info.pos(), R, R);
     }
 
     return outline;
 }
 
 void KisToolFreehandHelper::cursorMoved(const QPointF &cursorPos)
 {
     m_d->lastCursorPos.pushThroughHistory(cursorPos);
 }
 
 void KisToolFreehandHelper::initPaint(KoPointerEvent *event,
                                       const QPointF &pixelCoords,
                                       KoCanvasResourceProvider *resourceManager,
                                       KisImageWSP image, KisNodeSP currentNode,
                                       KisStrokesFacade *strokesFacade,
                                       KisNodeSP overrideNode,
                                       KisDefaultBoundsBaseSP bounds)
 {
     QPointF prevPoint = m_d->lastCursorPos.pushThroughHistory(pixelCoords);
     m_d->strokeTime.start();
     KisPaintInformation pi =
         m_d->infoBuilder->startStroke(event, elapsedStrokeTime(), resourceManager);
     qreal startAngle = KisAlgebra2D::directionBetweenPoints(prevPoint, pixelCoords, 0.0);
 
     initPaintImpl(startAngle,
                   pi,
                   resourceManager,
                   image,
                   currentNode,
                   strokesFacade,
                   overrideNode,
                   bounds);
 }
 
 bool KisToolFreehandHelper::isRunning() const
 {
     return m_d->strokeId;
 }
 
 void KisToolFreehandHelper::initPaintImpl(qreal startAngle,
                                           const KisPaintInformation &pi,
                                           KoCanvasResourceProvider *resourceManager,
                                           KisImageWSP image,
                                           KisNodeSP currentNode,
                                           KisStrokesFacade *strokesFacade,
                                           KisNodeSP overrideNode,
                                           KisDefaultBoundsBaseSP bounds)
 {
     m_d->strokesFacade = strokesFacade;
 
     m_d->haveTangent = false;
     m_d->previousTangent = QPointF();
 
     m_d->hasPaintAtLeastOnce = false;
 
     m_d->previousPaintInformation = pi;
 
     m_d->resources = new KisResourcesSnapshot(image,
                                               currentNode,
                                               resourceManager,
                                               bounds);
     if(overrideNode) {
         m_d->resources->setCurrentNode(overrideNode);
     }
 
     const bool airbrushing = m_d->resources->needsAirbrushing();
     const bool useSpacingUpdates = m_d->resources->needsSpacingUpdates();
 
     KisDistanceInitInfo startDistInfo(m_d->previousPaintInformation.pos(),
                                       startAngle,
                                       useSpacingUpdates ? SPACING_UPDATE_INTERVAL : LONG_TIME,
                                       airbrushing ? TIMING_UPDATE_INTERVAL : LONG_TIME,
                                       0);
     KisDistanceInformation startDist = startDistInfo.makeDistInfo();
 
     createPainters(m_d->strokeInfos,
                    startDist);
 
     KisStrokeStrategy *stroke =
         new FreehandStrokeStrategy(m_d->resources, m_d->strokeInfos, m_d->transactionText);
 
     m_d->strokeId = m_d->strokesFacade->startStroke(stroke);
 
     m_d->history.clear();
     m_d->distanceHistory.clear();
 
     if (airbrushing) {
         m_d->airbrushingTimer.setInterval(computeAirbrushTimerInterval());
         m_d->airbrushingTimer.start();
     } else if (m_d->resources->presetNeedsAsynchronousUpdates()) {
-        m_d->asynchronousUpdatesThresholdTimer.setInterval(80 /* msec */);
-        m_d->asynchronousUpdatesThresholdTimer.start();
+        m_d->asyncUpdateHelper.startUpdateStream(m_d->strokesFacade, m_d->strokeId);
     }
 
     if (m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::STABILIZER) {
         stabilizerStart(m_d->previousPaintInformation);
     }
 
     // If airbrushing, paint an initial dab immediately. This is a workaround for an issue where
     // some paintops (Dyna, Particle, Sketch) might never initialize their spacing/timing
     // information until paintAt is called.
     if (airbrushing) {
         paintAt(pi);
     }
 }
 
 void KisToolFreehandHelper::paintBezierSegment(KisPaintInformation pi1, KisPaintInformation pi2,
                                                QPointF tangent1, QPointF tangent2)
 {
     if (tangent1.isNull() || tangent2.isNull()) return;
 
     const qreal maxSanePoint = 1e6;
 
     QPointF controlTarget1;
     QPointF controlTarget2;
 
     // Shows the direction in which control points go
     QPointF controlDirection1 = pi1.pos() + tangent1;
     QPointF controlDirection2 = pi2.pos() - tangent2;
 
     // Lines in the direction of the control points
     QLineF line1(pi1.pos(), controlDirection1);
     QLineF line2(pi2.pos(), controlDirection2);
 
     // Lines to check whether the control points lay on the opposite
     // side of the line
     QLineF line3(controlDirection1, controlDirection2);
     QLineF line4(pi1.pos(), pi2.pos());
 
     QPointF intersection;
     if (line3.intersect(line4, &intersection) == QLineF::BoundedIntersection) {
         qreal controlLength = line4.length() / 2;
 
         line1.setLength(controlLength);
         line2.setLength(controlLength);
 
         controlTarget1 = line1.p2();
         controlTarget2 = line2.p2();
     } else {
         QLineF::IntersectType type = line1.intersect(line2, &intersection);
 
         if (type == QLineF::NoIntersection ||
             intersection.manhattanLength() > maxSanePoint) {
 
             intersection = 0.5 * (pi1.pos() + pi2.pos());
 //            dbgKrita << "WARNING: there is no intersection point "
 //                     << "in the basic smoothing algorithms";
         }
 
         controlTarget1 = intersection;
         controlTarget2 = intersection;
     }
 
     // shows how near to the controlTarget the value raises
     qreal coeff = 0.8;
 
     qreal velocity1 = QLineF(QPointF(), tangent1).length();
     qreal velocity2 = QLineF(QPointF(), tangent2).length();
 
     if (velocity1 == 0.0 || velocity2 == 0.0) {
         velocity1 = 1e-6;
         velocity2 = 1e-6;
         warnKrita << "WARNING: Basic Smoothing: Velocity is Zero! Please report a bug:" << ppVar(velocity1) << ppVar(velocity2);
     }
 
     qreal similarity = qMin(velocity1/velocity2, velocity2/velocity1);
 
     // the controls should not differ more than 50%
     similarity = qMax(similarity, qreal(0.5));
 
     // when the controls are symmetric, their size should be smaller
     // to avoid corner-like curves
     coeff *= 1 - qMax(qreal(0.0), similarity - qreal(0.8));
 
     Q_ASSERT(coeff > 0);
 
 
     QPointF control1;
     QPointF control2;
 
     if (velocity1 > velocity2) {
         control1 = pi1.pos() * (1.0 - coeff) + coeff * controlTarget1;
         coeff *= similarity;
         control2 = pi2.pos() * (1.0 - coeff) + coeff * controlTarget2;
     } else {
         control2 = pi2.pos() * (1.0 - coeff) + coeff * controlTarget2;
         coeff *= similarity;
         control1 = pi1.pos() * (1.0 - coeff) + coeff * controlTarget1;
     }
 
     paintBezierCurve(pi1,
                      control1,
                      control2,
                      pi2);
 }
 
 qreal KisToolFreehandHelper::Private::effectiveSmoothnessDistance() const
 {
     const qreal effectiveSmoothnessDistance =
         !smoothingOptions->useScalableDistance() ?
         smoothingOptions->smoothnessDistance() :
         smoothingOptions->smoothnessDistance() / resources->effectiveZoom();
 
     return effectiveSmoothnessDistance;
 }
 
 void KisToolFreehandHelper::paintEvent(KoPointerEvent *event)
 {
     KisPaintInformation info =
             m_d->infoBuilder->continueStroke(event,
                                              elapsedStrokeTime());
-    info.setCanvasRotation( m_d->canvasRotation );
-    info.setCanvasHorizontalMirrorState( m_d->canvasMirroredH );
-
     KisUpdateTimeMonitor::instance()->reportMouseMove(info.pos());
 
     paint(info);
 }
 
 void KisToolFreehandHelper::paint(KisPaintInformation &info)
 {
     /**
      * Smooth the coordinates out using the history and the
      * distance. This is a heavily modified version of an algo used in
      * Gimp and described in https://bugs.kde.org/show_bug.cgi?id=281267 and
      * http://www24.atwiki.jp/sigetch_2007/pages/17.html.  The main
      * differences are:
      *
      * 1) It uses 'distance' instead of 'velocity', since time
      *    measurements are too unstable in realworld environment
      *
      * 2) There is no 'Quality' parameter, since the number of samples
      *    is calculated automatically
      *
      * 3) 'Tail Aggressiveness' is used for controlling the end of the
      *    stroke
      *
      * 4) The formila is a little bit different: 'Distance' parameter
      *    stands for $3 \Sigma$
      */
     if (m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::WEIGHTED_SMOOTHING
         && m_d->smoothingOptions->smoothnessDistance() > 0.0) {
 
         { // initialize current distance
             QPointF prevPos;
 
             if (!m_d->history.isEmpty()) {
                 const KisPaintInformation &prevPi = m_d->history.last();
                 prevPos = prevPi.pos();
             } else {
                 prevPos = m_d->previousPaintInformation.pos();
             }
 
             qreal currentDistance = QVector2D(info.pos() - prevPos).length();
             m_d->distanceHistory.append(currentDistance);
         }
 
         m_d->history.append(info);
 
         qreal x = 0.0;
         qreal y = 0.0;
 
         if (m_d->history.size() > 3) {
             const qreal sigma = m_d->effectiveSmoothnessDistance() / 3.0; // '3.0' for (3 * sigma) range
 
             qreal gaussianWeight = 1 / (sqrt(2 * M_PI) * sigma);
             qreal gaussianWeight2 = sigma * sigma;
             qreal distanceSum = 0.0;
             qreal scaleSum = 0.0;
             qreal pressure = 0.0;
             qreal baseRate = 0.0;
 
             Q_ASSERT(m_d->history.size() == m_d->distanceHistory.size());
 
             for (int i = m_d->history.size() - 1; i >= 0; i--) {
                 qreal rate = 0.0;
 
                 const KisPaintInformation nextInfo = m_d->history.at(i);
                 double distance = m_d->distanceHistory.at(i);
                 Q_ASSERT(distance >= 0.0);
 
                 qreal pressureGrad = 0.0;
                 if (i < m_d->history.size() - 1) {
                     pressureGrad = nextInfo.pressure() - m_d->history.at(i + 1).pressure();
 
                     const qreal tailAgressiveness = 40.0 * m_d->smoothingOptions->tailAggressiveness();
 
                     if (pressureGrad > 0.0 ) {
                         pressureGrad *= tailAgressiveness * (1.0 - nextInfo.pressure());
                         distance += pressureGrad * 3.0 * sigma; // (3 * sigma) --- holds > 90% of the region
                     }
                 }
 
                 if (gaussianWeight2 != 0.0) {
                     distanceSum += distance;
                     rate = gaussianWeight * exp(-distanceSum * distanceSum / (2 * gaussianWeight2));
                 }
 
                 if (m_d->history.size() - i == 1) {
                     baseRate = rate;
                 } else if (baseRate / rate > 100) {
                     break;
                 }
 
                 scaleSum += rate;
                 x += rate * nextInfo.pos().x();
                 y += rate * nextInfo.pos().y();
 
                 if (m_d->smoothingOptions->smoothPressure()) {
                     pressure += rate * nextInfo.pressure();
                 }
             }
 
             if (scaleSum != 0.0) {
                 x /= scaleSum;
                 y /= scaleSum;
 
                 if (m_d->smoothingOptions->smoothPressure()) {
                     pressure /= scaleSum;
                 }
             }
 
             if ((x != 0.0 && y != 0.0) || (x == info.pos().x() && y == info.pos().y())) {
                 info.setPos(QPointF(x, y));
                 if (m_d->smoothingOptions->smoothPressure()) {
                     info.setPressure(pressure);
                 }
                 m_d->history.last() = info;
             }
         }
     }
 
     if (m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::SIMPLE_SMOOTHING
         || m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::WEIGHTED_SMOOTHING)
     {
         // Now paint between the coordinates, using the bezier curve interpolation
         if (!m_d->haveTangent) {
             m_d->haveTangent = true;
             m_d->previousTangent =
                 (info.pos() - m_d->previousPaintInformation.pos()) /
                 qMax(qreal(1.0), info.currentTime() - m_d->previousPaintInformation.currentTime());
         } else {
             QPointF newTangent = (info.pos() - m_d->olderPaintInformation.pos()) /
                 qMax(qreal(1.0), info.currentTime() - m_d->olderPaintInformation.currentTime());
 
             if (newTangent.isNull() || m_d->previousTangent.isNull())
             {
                 paintLine(m_d->previousPaintInformation, info);
             } else {
                 paintBezierSegment(m_d->olderPaintInformation, m_d->previousPaintInformation,
                                    m_d->previousTangent, newTangent);
             }
 
             m_d->previousTangent = newTangent;
         }
         m_d->olderPaintInformation = m_d->previousPaintInformation;
 
         // Enable stroke timeout only when not airbrushing.
         if (!m_d->airbrushingTimer.isActive()) {
             m_d->strokeTimeoutTimer.start(100);
         }
     }
     else if (m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::NO_SMOOTHING){
         paintLine(m_d->previousPaintInformation, info);
     }
 
     if (m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::STABILIZER) {
         m_d->stabilizedSampler.addEvent(info);
         if (m_d->stabilizerDelayedPaintHelper.running()) {
             // Paint here so we don't have to rely on the timer
             // This is just a tricky source for a relatively stable 7ms "timer"
             m_d->stabilizerDelayedPaintHelper.paintSome();
         }
     } else {
         m_d->previousPaintInformation = info;
     }
 
     if(m_d->airbrushingTimer.isActive()) {
         m_d->airbrushingTimer.start();
     }
 }
 
 void KisToolFreehandHelper::endPaint()
 {
     if (!m_d->hasPaintAtLeastOnce) {
         paintAt(m_d->previousPaintInformation);
     } else if (m_d->smoothingOptions->smoothingType() != KisSmoothingOptions::NO_SMOOTHING) {
         finishStroke();
     }
     m_d->strokeTimeoutTimer.stop();
 
     if(m_d->airbrushingTimer.isActive()) {
         m_d->airbrushingTimer.stop();
     }
 
-    if (m_d->asynchronousUpdatesThresholdTimer.isActive()) {
-        m_d->asynchronousUpdatesThresholdTimer.stop();
-    }
-
     if (m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::STABILIZER) {
         stabilizerEnd();
     }
 
+    if (m_d->asyncUpdateHelper.isActive()) {
+        m_d->asyncUpdateHelper.endUpdateStream();
+    }
+
     /**
      * There might be some timer events still pending, so
      * we should cancel them. Use this flag for the purpose.
      * Please note that we are not in MT here, so no mutex
      * is needed
      */
     m_d->strokeInfos.clear();
 
-    // last update to complete rendering if there is still something pending
-    doAsynchronousUpdate(true);
-
     m_d->strokesFacade->endStroke(m_d->strokeId);
     m_d->strokeId.clear();
 }
 
 void KisToolFreehandHelper::cancelPaint()
 {
     if (!m_d->strokeId) return;
 
     m_d->strokeTimeoutTimer.stop();
 
     if (m_d->airbrushingTimer.isActive()) {
         m_d->airbrushingTimer.stop();
     }
 
-    if (m_d->asynchronousUpdatesThresholdTimer.isActive()) {
-        m_d->asynchronousUpdatesThresholdTimer.stop();
+    if (m_d->asyncUpdateHelper.isActive()) {
+        m_d->asyncUpdateHelper.cancelUpdateStream();
     }
 
     if (m_d->stabilizerPollTimer.isActive()) {
         m_d->stabilizerPollTimer.stop();
     }
 
     if (m_d->stabilizerDelayedPaintHelper.running()) {
         m_d->stabilizerDelayedPaintHelper.cancel();
     }
 
     // see a comment in endPaint()
     m_d->strokeInfos.clear();
 
     m_d->strokesFacade->cancelStroke(m_d->strokeId);
     m_d->strokeId.clear();
 
 }
 
 int KisToolFreehandHelper::elapsedStrokeTime() const
 {
     return m_d->strokeTime.elapsed();
 }
 
 void KisToolFreehandHelper::stabilizerStart(KisPaintInformation firstPaintInfo)
 {
     m_d->usingStabilizer = true;
     // FIXME: Ugly hack, this is no a "distance" in any way
     int sampleSize = qRound(m_d->effectiveSmoothnessDistance());
     sampleSize = qMax(3, sampleSize);
 
     // Fill the deque with the current value repeated until filling the sample
     m_d->stabilizerDeque.clear();
     for (int i = sampleSize; i > 0; i--) {
         m_d->stabilizerDeque.enqueue(firstPaintInfo);
     }
 
     // Poll and draw regularly
     KisConfig cfg(true);
     int stabilizerSampleSize = cfg.stabilizerSampleSize();
     m_d->stabilizerPollTimer.setInterval(stabilizerSampleSize);
     m_d->stabilizerPollTimer.start();
 
     bool delayedPaintEnabled = cfg.stabilizerDelayedPaint();
     if (delayedPaintEnabled) {
         m_d->stabilizerDelayedPaintHelper.start(firstPaintInfo);
     }
 
     m_d->stabilizedSampler.clear();
     m_d->stabilizedSampler.addEvent(firstPaintInfo);
 }
 
 KisPaintInformation
 KisToolFreehandHelper::getStabilizedPaintInfo(const QQueue<KisPaintInformation> &queue,
                                               const KisPaintInformation &lastPaintInfo)
 {
     KisPaintInformation result(lastPaintInfo.pos(),
                                lastPaintInfo.pressure(),
                                lastPaintInfo.xTilt(),
                                lastPaintInfo.yTilt(),
                                lastPaintInfo.rotation(),
                                lastPaintInfo.tangentialPressure(),
                                lastPaintInfo.perspective(),
                                elapsedStrokeTime(),
                                lastPaintInfo.drawingSpeed());
 
     if (queue.size() > 1) {
         QQueue<KisPaintInformation>::const_iterator it = queue.constBegin();
         QQueue<KisPaintInformation>::const_iterator end = queue.constEnd();
 
         /**
          * The first point is going to be overridden by lastPaintInfo, skip it.
          */
         it++;
         int i = 2;
 
         if (m_d->smoothingOptions->stabilizeSensors()) {
             while (it != end) {
                 qreal k = qreal(i - 1) / i; // coeff for uniform averaging
                 result.KisPaintInformation::mixOtherWithoutTime(k, *it);
                 it++;
                 i++;
             }
         } else{
             while (it != end) {
                 qreal k = qreal(i - 1) / i; // coeff for uniform averaging
                 result.KisPaintInformation::mixOtherOnlyPosition(k, *it);
                 it++;
                 i++;
             }
         }
     }
 
     return result;
 }
 
 void KisToolFreehandHelper::stabilizerPollAndPaint()
 {
     KisStabilizedEventsSampler::iterator it;
     KisStabilizedEventsSampler::iterator end;
     std::tie(it, end) = m_d->stabilizedSampler.range();
     QVector<KisPaintInformation> delayedPaintTodoItems;
 
     for (; it != end; ++it) {
         KisPaintInformation sampledInfo = *it;
 
         bool canPaint = true;
 
         if (m_d->smoothingOptions->useDelayDistance()) {
             const qreal R = m_d->smoothingOptions->delayDistance() /
                     m_d->resources->effectiveZoom();
 
             QPointF diff = sampledInfo.pos() - m_d->previousPaintInformation.pos();
             qreal dx = sqrt(pow2(diff.x()) + pow2(diff.y()));
 
             if (!(dx > R)) {
                 if (m_d->resources->needsAirbrushing()) {
                     sampledInfo.setPos(m_d->previousPaintInformation.pos());
                 }
                 else {
                     canPaint = false;
                 }
             }
         }
 
         if (canPaint) {
             KisPaintInformation newInfo = getStabilizedPaintInfo(m_d->stabilizerDeque, sampledInfo);
 
             if (m_d->stabilizerDelayedPaintHelper.running()) {
                 delayedPaintTodoItems.append(newInfo);
             } else {
                 paintLine(m_d->previousPaintInformation, newInfo);
             }
             m_d->previousPaintInformation = newInfo;
 
             // Push the new entry through the queue
             m_d->stabilizerDeque.dequeue();
             m_d->stabilizerDeque.enqueue(sampledInfo);
         } else if (m_d->stabilizerDeque.head().pos() != m_d->previousPaintInformation.pos()) {
 
             QQueue<KisPaintInformation>::iterator it = m_d->stabilizerDeque.begin();
             QQueue<KisPaintInformation>::iterator end = m_d->stabilizerDeque.end();
 
             while (it != end) {
                 *it = m_d->previousPaintInformation;
                 ++it;
             }
         }
     }
 
     m_d->stabilizedSampler.clear();
 
     if (m_d->stabilizerDelayedPaintHelper.running()) {
         m_d->stabilizerDelayedPaintHelper.update(delayedPaintTodoItems);
     } else {
         emit requestExplicitUpdateOutline();
     }
 }
 
 void KisToolFreehandHelper::stabilizerEnd()
 {
     // Stop the timer
     m_d->stabilizerPollTimer.stop();
 
     // Finish the line
     if (m_d->smoothingOptions->finishStabilizedCurve()) {
         // Process all the existing events first
         stabilizerPollAndPaint();
 
         // Draw the finish line with pending events and a time override
         m_d->stabilizedSampler.addFinishingEvent(m_d->stabilizerDeque.size());
         stabilizerPollAndPaint();
     }
 
     if (m_d->stabilizerDelayedPaintHelper.running()) {
         m_d->stabilizerDelayedPaintHelper.end();
     }
     m_d->usingStabilizer = false;
 }
 
 void KisToolFreehandHelper::slotSmoothingTypeChanged()
 {
     if (!isRunning()) {
         return;
     }
     KisSmoothingOptions::SmoothingType currentSmoothingType =
             m_d->smoothingOptions->smoothingType();
     if (m_d->usingStabilizer
             && (currentSmoothingType != KisSmoothingOptions::STABILIZER)) {
         stabilizerEnd();
     } else if (!m_d->usingStabilizer
             && (currentSmoothingType == KisSmoothingOptions::STABILIZER)) {
         stabilizerStart(m_d->previousPaintInformation);
     }
 }
 
 void KisToolFreehandHelper::finishStroke()
 {
     if (m_d->haveTangent) {
         m_d->haveTangent = false;
 
         QPointF newTangent = (m_d->previousPaintInformation.pos() - m_d->olderPaintInformation.pos()) /
             (m_d->previousPaintInformation.currentTime() - m_d->olderPaintInformation.currentTime());
 
         paintBezierSegment(m_d->olderPaintInformation,
                            m_d->previousPaintInformation,
                            m_d->previousTangent,
                            newTangent);
     }
 }
 
 void KisToolFreehandHelper::doAirbrushing()
 {
     // Check that the stroke hasn't ended.
     if (!m_d->strokeInfos.isEmpty()) {
 
         // Add a new painting update at a point identical to the previous one, except for the time
         // and speed information.
         const KisPaintInformation &prevPaint = m_d->previousPaintInformation;
         KisPaintInformation nextPaint(prevPaint.pos(),
                                       prevPaint.pressure(),
                                       prevPaint.xTilt(),
                                       prevPaint.yTilt(),
                                       prevPaint.rotation(),
                                       prevPaint.tangentialPressure(),
                                       prevPaint.perspective(),
                                       elapsedStrokeTime(),
                                       0.0);
         paint(nextPaint);
     }
 }
 
-void KisToolFreehandHelper::doAsynchronousUpdate(bool forceUpdate)
-{
-    m_d->strokesFacade->addJob(m_d->strokeId,
-                               new FreehandStrokeStrategy::UpdateData(forceUpdate));
-}
-
 int KisToolFreehandHelper::computeAirbrushTimerInterval() const
 {
     qreal realInterval = m_d->resources->airbrushingInterval() * AIRBRUSH_INTERVAL_FACTOR;
     return qMax(1, qFloor(realInterval));
 }
 
 void KisToolFreehandHelper::paintAt(int strokeInfoId,
                                     const KisPaintInformation &pi)
 {
     m_d->hasPaintAtLeastOnce = true;
     m_d->strokesFacade->addJob(m_d->strokeId,
                                new FreehandStrokeStrategy::Data(strokeInfoId, pi));
 
 }
 
 void KisToolFreehandHelper::paintLine(int strokeInfoId,
                                       const KisPaintInformation &pi1,
                                       const KisPaintInformation &pi2)
 {
     m_d->hasPaintAtLeastOnce = true;
     m_d->strokesFacade->addJob(m_d->strokeId,
                                new FreehandStrokeStrategy::Data(strokeInfoId, pi1, pi2));
 
 }
 
 void KisToolFreehandHelper::paintBezierCurve(int strokeInfoId,
                                              const KisPaintInformation &pi1,
                                              const QPointF &control1,
                                              const QPointF &control2,
                                              const KisPaintInformation &pi2)
 {
 #ifdef DEBUG_BEZIER_CURVES
     KisPaintInformation tpi1;
     KisPaintInformation tpi2;
 
     tpi1 = pi1;
     tpi2 = pi2;
 
     tpi1.setPressure(0.3);
     tpi2.setPressure(0.3);
 
     paintLine(tpi1, tpi2);
 
     tpi1.setPressure(0.6);
     tpi2.setPressure(0.3);
 
     tpi1.setPos(pi1.pos());
     tpi2.setPos(control1);
     paintLine(tpi1, tpi2);
 
     tpi1.setPos(pi2.pos());
     tpi2.setPos(control2);
     paintLine(tpi1, tpi2);
 #endif
 
     m_d->hasPaintAtLeastOnce = true;
     m_d->strokesFacade->addJob(m_d->strokeId,
                                new FreehandStrokeStrategy::Data(strokeInfoId,
                                                                 pi1, control1, control2, pi2));
 
 }
 
 void KisToolFreehandHelper::createPainters(QVector<KisFreehandStrokeInfo*> &strokeInfos,
                                            const KisDistanceInformation &startDist)
 {
     strokeInfos << new KisFreehandStrokeInfo(startDist);
 }
 
 void KisToolFreehandHelper::paintAt(const KisPaintInformation &pi)
 {
     paintAt(0, pi);
 }
 
 void KisToolFreehandHelper::paintLine(const KisPaintInformation &pi1,
                                       const KisPaintInformation &pi2)
 {
     paintLine(0, pi1, pi2);
 }
 
 void KisToolFreehandHelper::paintBezierCurve(const KisPaintInformation &pi1,
                                              const QPointF &control1,
                                              const QPointF &control2,
                                              const KisPaintInformation &pi2)
 {
     paintBezierCurve(0, pi1, control1, control2, pi2);
 }
-
-int KisToolFreehandHelper::canvasRotation()
-{
-    return m_d->canvasRotation;
-}
-
-void KisToolFreehandHelper::setCanvasRotation(int rotation)
-{
-   m_d->canvasRotation = rotation;
-}
-bool KisToolFreehandHelper::canvasMirroredH()
-{
-    return m_d->canvasMirroredH;
-}
-
-void KisToolFreehandHelper::setCanvasHorizontalMirrorState(bool mirrored)
-{
-   m_d->canvasMirroredH = mirrored;
-}
diff --git a/libs/ui/tool/kis_tool_freehand_helper.h b/libs/ui/tool/kis_tool_freehand_helper.h
index 39c3c56b9d..0800801b65 100644
--- a/libs/ui/tool/kis_tool_freehand_helper.h
+++ b/libs/ui/tool/kis_tool_freehand_helper.h
@@ -1,166 +1,162 @@
 /*
  *  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_TOOL_FREEHAND_HELPER_H
 #define __KIS_TOOL_FREEHAND_HELPER_H
 
 #include <QObject>
 #include <QVector>
 
 #include "kis_types.h"
 #include "kritaui_export.h"
 #include <brushengine/kis_paint_information.h>
 #include "kis_default_bounds.h"
 #include <brushengine/kis_paintop_settings.h>
 #include "kis_smoothing_options.h"
 #include "kundo2magicstring.h"
 
 
 class KoPointerEvent;
 class KoCanvasResourceProvider;
 class KisPaintingInformationBuilder;
 class KisStrokesFacade;
 class KisPostExecutionUndoAdapter;
 class KisPaintOp;
 class KisFreehandStrokeInfo;
 
 
 class KRITAUI_EXPORT KisToolFreehandHelper : public QObject
 {
     Q_OBJECT
 
 public:
 
     KisToolFreehandHelper(KisPaintingInformationBuilder *infoBuilder,
                           const KUndo2MagicString &transactionText = KUndo2MagicString(),
                           KisSmoothingOptions *smoothingOptions = 0);
     ~KisToolFreehandHelper() override;
 
     void setSmoothness(KisSmoothingOptionsSP smoothingOptions);
     KisSmoothingOptionsSP smoothingOptions() const;
 
     bool isRunning() const;
 
     void cursorMoved(const QPointF &cursorPos);
 
     /**
      * @param event The event
      * @param pixelCoords The position of the KoPointerEvent, in pixel coordinates.
      * @param resourceManager The canvas resource manager
      * @param image The image
      * @param currentNode The current node
      * @param strokesFacade The strokes facade
      * @param overrideNode The override node
      * @param bounds The bounds
      */
     void initPaint(KoPointerEvent *event,
                    const QPointF &pixelCoords,
                    KoCanvasResourceProvider *resourceManager,
                    KisImageWSP image,
                    KisNodeSP currentNode,
                    KisStrokesFacade *strokesFacade,
                    KisNodeSP overrideNode = 0,
                    KisDefaultBoundsBaseSP bounds = 0);
     void paintEvent(KoPointerEvent *event);
     void endPaint();
 
     QPainterPath paintOpOutline(const QPointF &savedCursorPos,
                                 const KoPointerEvent *event,
                                 const KisPaintOpSettingsSP globalSettings,
                                 KisPaintOpSettings::OutlineMode mode) const;
-    int canvasRotation();
-    void setCanvasRotation(int rotation = 0);
-    bool canvasMirroredH();
-    void setCanvasHorizontalMirrorState (bool mirrored = false);
+
 Q_SIGNALS:
     /**
      * The signal is emitted when the outline should be updated
      * explicitly by the tool. Used by Stabilizer option, because it
      * paints on internal timer events instead of the on every paint()
      * event
      */
     void requestExplicitUpdateOutline();
 
 protected:
     void cancelPaint();
     int elapsedStrokeTime() const;
 
     void initPaintImpl(qreal startAngle,
                        const KisPaintInformation &pi,
                        KoCanvasResourceProvider *resourceManager,
                        KisImageWSP image,
                        KisNodeSP node,
                        KisStrokesFacade *strokesFacade,
                        KisNodeSP overrideNode = 0,
                        KisDefaultBoundsBaseSP bounds = 0);
 
 protected:
 
     virtual void createPainters(QVector<KisFreehandStrokeInfo*> &strokeInfos,
                                 const KisDistanceInformation &startDist);
 
     // lo-level methods for painting primitives
 
     void paintAt(int strokeInfoId, const KisPaintInformation &pi);
 
     void paintLine(int strokeInfoId,
                    const KisPaintInformation &pi1,
                    const KisPaintInformation &pi2);
 
     void paintBezierCurve(int strokeInfoId,
                           const KisPaintInformation &pi1,
                           const QPointF &control1,
                           const QPointF &control2,
                           const KisPaintInformation &pi2);
 
     // hi-level methods for painting primitives
 
     virtual void paintAt(const KisPaintInformation &pi);
 
     virtual void paintLine(const KisPaintInformation &pi1,
                            const KisPaintInformation &pi2);
 
     virtual void paintBezierCurve(const KisPaintInformation &pi1,
                                   const QPointF &control1,
                                   const QPointF &control2,
                                   const KisPaintInformation &pi2);
 
 private:
     void paint(KisPaintInformation &info);
     void paintBezierSegment(KisPaintInformation pi1, KisPaintInformation pi2,
                                                    QPointF tangent1, QPointF tangent2);
 
     void stabilizerStart(KisPaintInformation firstPaintInfo);
     void stabilizerEnd();
     KisPaintInformation getStabilizedPaintInfo(const QQueue<KisPaintInformation> &queue,
                                                const KisPaintInformation &lastPaintInfo);
     int computeAirbrushTimerInterval() const;
 
 private Q_SLOTS:
     void finishStroke();
     void doAirbrushing();
-    void doAsynchronousUpdate(bool forceUpdate = false);
     void stabilizerPollAndPaint();
     void slotSmoothingTypeChanged();
 
 private:
     struct Private;
     Private * const m_d;
 };
 
 #endif /* __KIS_TOOL_FREEHAND_HELPER_H */
diff --git a/libs/ui/tool/kis_tool_multihand_helper.cpp b/libs/ui/tool/kis_tool_multihand_helper.cpp
index f34368f99f..b99c713be0 100644
--- a/libs/ui/tool/kis_tool_multihand_helper.cpp
+++ b/libs/ui/tool/kis_tool_multihand_helper.cpp
@@ -1,154 +1,134 @@
 /*
  *  Copyright (c) 2011 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_tool_multihand_helper.h"
 
 #include <QTransform>
 
 #include "kis_painter.h"
 #include <strokes/KisFreehandStrokeInfo.h>
+#include "kis_algebra_2d.h"
 
 struct KisToolMultihandHelper::Private
 {
     QVector<QTransform> transformations;
 };
 
 KisToolMultihandHelper::KisToolMultihandHelper(KisPaintingInformationBuilder *infoBuilder,
                                                const KUndo2MagicString &transactionText)
     : KisToolFreehandHelper(infoBuilder, transactionText)
     , d(new Private)
 {
 }
 
 KisToolMultihandHelper::~KisToolMultihandHelper()
 {
     delete d;
 }
 
 void KisToolMultihandHelper::setupTransformations(const QVector<QTransform> &transformations)
 {
     d->transformations = transformations;
 }
 
 void KisToolMultihandHelper::createPainters(QVector<KisFreehandStrokeInfo*> &strokeInfos,
                                             const KisDistanceInformation &startDist)
 {
     for (int i = 0; i < d->transformations.size(); i++) {
         const QTransform &transform = d->transformations[i];
         KisDistanceInitInfo __startDistInfo(transform.map(startDist.lastPosition()),
                                             startDist.lastDrawingAngle(),
                                             startDist.getSpacingInterval(),
                                             startDist.getTimingUpdateInterval(),
                                             0);
 
         KisDistanceInformation __startDist = __startDistInfo.makeDistInfo();
         strokeInfos << new KisFreehandStrokeInfo(__startDist);
     }
 }
 
+void adjustPointInformationRotation(KisPaintInformation &pi, const QTransform &t)
+{
+    KisAlgebra2D::DecomposedMatix d(t);
+
+    qreal rotation = d.angle;
+    const bool mirrorX = KisAlgebra2D::signPZ(d.scaleX) < 0;
+    const bool mirrorY = KisAlgebra2D::signPZ(d.scaleY) < 0;
+
+    pi.setCanvasMirroredH(pi.canvasMirroredH() ^ mirrorX);
+    pi.setCanvasMirroredV(pi.canvasMirroredV() ^ mirrorY);
+
+    if (pi.canvasMirroredH()!= pi.canvasMirroredV()) {
+        rotation = normalizeAngleDegrees(360.0 - rotation);
+    }
+
+    pi.setCanvasRotation(normalizeAngleDegrees(pi.canvasRotation() - rotation));
+}
+
+
 void KisToolMultihandHelper::paintAt(const KisPaintInformation &pi)
 {
     for (int i = 0; i < d->transformations.size(); i++) {
         const QTransform &transform = d->transformations[i];
-
         KisPaintInformation __pi = pi;
-        QLineF rotateme(QPointF (0.0,0.0), QPointF (10.0,10.0));
-        rotateme.setAngle(__pi.canvasRotation());
-        QLineF rotated = transform.map(rotateme);
-
         __pi.setPos(transform.map(__pi.pos()));
-        __pi.setCanvasRotation(rotated.angle());
-
-        if (__pi.canvasMirroredH()) {
-            __pi.setCanvasRotation(180-__pi.canvasRotation());
-            __pi.setCanvasRotation(__pi.canvasRotation()+180);
-        }
-
+        adjustPointInformationRotation(__pi, transform);
         paintAt(i, __pi);
     }
 }
 
 void KisToolMultihandHelper::paintLine(const KisPaintInformation &pi1,
                                        const KisPaintInformation &pi2)
 {
     for (int i = 0; i < d->transformations.size(); i++) {
         const QTransform &transform = d->transformations[i];
 
         KisPaintInformation __pi1 = pi1;
         KisPaintInformation __pi2 = pi2;
         __pi1.setPos(transform.map(__pi1.pos()));
         __pi2.setPos(transform.map(__pi2.pos()));
 
-        QLineF rotateme(QPointF (0.0,0.0), QPointF (10.0,10.0));
-        rotateme.setAngle(__pi1.canvasRotation());
-        QLineF rotated = transform.map(rotateme);
-        __pi1.setCanvasRotation(rotated.angle());
-
-        rotateme.setAngle(__pi2.canvasRotation());
-        rotated = transform.map(rotateme);
-        __pi2.setCanvasRotation(rotated.angle());
-
-        //check mirroring
-        if (__pi2.canvasMirroredH()) {
-            __pi1.setCanvasRotation(180-__pi1.canvasRotation());
-            __pi1.setCanvasRotation(__pi1.canvasRotation()+180);
-            __pi2.setCanvasRotation(180-__pi2.canvasRotation());
-            __pi2.setCanvasRotation(__pi2.canvasRotation()+180);
-        }
-
+        adjustPointInformationRotation(__pi1, transform);
+        adjustPointInformationRotation(__pi2, transform);
 
         paintLine(i, __pi1, __pi2);
     }
 }
 
 void KisToolMultihandHelper::paintBezierCurve(const KisPaintInformation &pi1,
                                               const QPointF &control1,
                                               const QPointF &control2,
                                               const KisPaintInformation &pi2)
 {
     for (int i = 0; i < d->transformations.size(); i++) {
         const QTransform &transform = d->transformations[i];
 
         KisPaintInformation __pi1 = pi1;
         KisPaintInformation __pi2 = pi2;
         __pi1.setPos(transform.map(__pi1.pos()));
         __pi2.setPos(transform.map(__pi2.pos()));
 
-        QLineF rotateme(QPointF (0.0,0.0), QPointF (10.0,10.0));
-        rotateme.setAngle(__pi1.canvasRotation());
-        QLineF rotated = transform.map(rotateme);
-        __pi1.setCanvasRotation(rotated.angle());
-
-        rotateme.setAngle(__pi2.canvasRotation());
-        rotated = transform.map(rotateme);
-        __pi2.setCanvasRotation(rotated.angle());
-
-        if (__pi2.canvasMirroredH()) {
-            __pi1.setCanvasRotation(180-__pi1.canvasRotation());
-            __pi1.setCanvasRotation(__pi1.canvasRotation()+180);
-            __pi2.setCanvasRotation(180-__pi2.canvasRotation());
-            __pi2.setCanvasRotation(__pi2.canvasRotation()+180);
-        }
-
+        adjustPointInformationRotation(__pi1, transform);
+        adjustPointInformationRotation(__pi2, transform);
 
         QPointF __control1 = transform.map(control1);
         QPointF __control2 = transform.map(control2);
 
         paintBezierCurve(i, __pi1, __control1, __control2, __pi2);
     }
 }
diff --git a/libs/ui/tool/kis_tool_shape.cc b/libs/ui/tool/kis_tool_shape.cc
index 1180bdaa37..bd0b72ee9e 100644
--- a/libs/ui/tool/kis_tool_shape.cc
+++ b/libs/ui/tool/kis_tool_shape.cc
@@ -1,257 +1,257 @@
 /*
  *  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_tool_shape.h"
 
 #include <QWidget>
 #include <QLayout>
 #include <QComboBox>
 #include <QLabel>
 #include <QGridLayout>
 
 #include <KoUnit.h>
 #include <KoShape.h>
 #include <KoGradientBackground.h>
 #include <KoCanvasBase.h>
 #include <KoShapeController.h>
 #include <KoColorBackground.h>
 #include <KoPatternBackground.h>
 #include <KoShapeStroke.h>
 #include <KoDocumentResourceManager.h>
 #include <KoPathShape.h>
 
 #include <klocalizedstring.h>
 #include <ksharedconfig.h>
 
 #include <kis_debug.h>
 #include <kis_canvas_resource_provider.h>
 #include <brushengine/kis_paintop_registry.h>
 #include <kis_paint_layer.h>
 #include <kis_paint_device.h>
 #include "kis_figure_painting_tool_helper.h"
 #include <kis_node_query_path.h>
 
 #include <KoSelectedShapesProxy.h>
 #include <KoSelection.h>
 #include <commands/KoKeepShapesSelectedCommand.h>
 #include "kis_selection_mask.h"
 #include "kis_shape_selection.h"
 #include "kis_processing_applicator.h"
 
 
 KisToolShape::KisToolShape(KoCanvasBase * canvas, const QCursor & cursor)
         : KisToolPaint(canvas, cursor)
 {
     m_shapeOptionsWidget = 0;
 }
 
 KisToolShape::~KisToolShape()
 {
     // in case the widget hasn't been shown
     if (m_shapeOptionsWidget && !m_shapeOptionsWidget->parent()) {
         delete m_shapeOptionsWidget;
     }
 }
 
 void KisToolShape::activate(ToolActivation toolActivation, const QSet<KoShape*> &shapes)
 {
     KisToolPaint::activate(toolActivation, shapes);
     m_configGroup =  KSharedConfig::openConfig()->group(toolId());
 }
 
 
 int KisToolShape::flags() const
 {
     return KisTool::FLAG_USES_CUSTOM_COMPOSITEOP|KisTool::FLAG_USES_CUSTOM_PRESET
            |KisTool::FLAG_USES_CUSTOM_SIZE;
 }
 
 QWidget * KisToolShape::createOptionWidget()
 {
     m_shapeOptionsWidget = new WdgGeometryOptions(0);
 
     m_shapeOptionsWidget->cmbOutline->setCurrentIndex(KisPainter::StrokeStyleBrush);
 
     //connect two combo box event. Inherited classes can call the slots to make appropriate changes
     connect(m_shapeOptionsWidget->cmbOutline, SIGNAL(currentIndexChanged(int)), this, SLOT(outlineSettingChanged(int)));
     connect(m_shapeOptionsWidget->cmbFill, SIGNAL(currentIndexChanged(int)), this, SLOT(fillSettingChanged(int)));
 
     m_shapeOptionsWidget->cmbOutline->setCurrentIndex(m_configGroup.readEntry("outlineType", 0));
     m_shapeOptionsWidget->cmbFill->setCurrentIndex(m_configGroup.readEntry("fillType", 0));
 
     //if both settings are empty, force the outline to brush so the tool will work when first activated
     if (  m_shapeOptionsWidget->cmbFill->currentIndex() == 0 &&
           m_shapeOptionsWidget->cmbOutline->currentIndex() == 0)
     {
         m_shapeOptionsWidget->cmbOutline->setCurrentIndex(1); // brush
     }
 
     return m_shapeOptionsWidget;
 }
 
 void KisToolShape::outlineSettingChanged(int value)
 {
     m_configGroup.writeEntry("outlineType", value);
 }
 
 void KisToolShape::fillSettingChanged(int value)
 {
     m_configGroup.writeEntry("fillType", value);
 }
 
 KisPainter::FillStyle KisToolShape::fillStyle(void)
 {
     if (m_shapeOptionsWidget) {
         return static_cast<KisPainter::FillStyle>(m_shapeOptionsWidget->cmbFill->currentIndex());
     } else {
         return KisPainter::FillStyleNone;
     }
 }
 
 KisPainter::StrokeStyle KisToolShape::strokeStyle(void)
 {
     if (m_shapeOptionsWidget) {
         return static_cast<KisPainter::StrokeStyle>(m_shapeOptionsWidget->cmbOutline->currentIndex());
     } else {
         return KisPainter::StrokeStyleNone;
     }
 }
 
 qreal KisToolShape::currentStrokeWidth() const
 {
     const qreal sizeInPx =
         canvas()->resourceManager()->resource(KisCanvasResourceProvider::Size).toReal();
 
     return canvas()->unit().fromUserValue(sizeInPx);
 }
 
 KisToolShape::ShapeAddInfo KisToolShape::shouldAddShape(KisNodeSP currentNode) const
 {
     ShapeAddInfo info;
 
     if (currentNode->inherits("KisShapeLayer")) {
         info.shouldAddShape = true;
     } else if (KisSelectionMask *mask = dynamic_cast<KisSelectionMask*>(currentNode.data())) {
         if (mask->selection()->hasShapeSelection()) {
             info.shouldAddShape = true;
             info.shouldAddSelectionShape = true;
         }
     }
 
     return info;
 }
 
 void KisToolShape::ShapeAddInfo::markAsSelectionShapeIfNeeded(KoShape *shape) const
 {
     if (this->shouldAddSelectionShape) {
         shape->setUserData(new KisShapeSelectionMarker());
     }
 }
 
 void KisToolShape::addShape(KoShape* shape)
 {
     KoImageCollection* imageCollection = canvas()->shapeController()->resourceManager()->imageCollection();
     switch(fillStyle()) {
         case KisPainter::FillStyleForegroundColor:
             shape->setBackground(QSharedPointer<KoColorBackground>(new KoColorBackground(currentFgColor().toQColor())));
             break;
         case KisPainter::FillStyleBackgroundColor:
             shape->setBackground(QSharedPointer<KoColorBackground>(new KoColorBackground(currentBgColor().toQColor())));
             break;
         case KisPainter::FillStylePattern:
             if (imageCollection) {
                 QSharedPointer<KoPatternBackground> fill(new KoPatternBackground(imageCollection));
                 if (currentPattern()) {
                     fill->setPattern(currentPattern()->pattern());
                     shape->setBackground(fill);
                 }
             } else {
                 shape->setBackground(QSharedPointer<KoShapeBackground>(0));
             }
             break;
         case KisPainter::FillStyleGradient:
             {
                 QLinearGradient *gradient = new QLinearGradient(QPointF(0, 0), QPointF(1, 1));
                 gradient->setCoordinateMode(QGradient::ObjectBoundingMode);
                 gradient->setStops(currentGradient()->toQGradient()->stops());
                 QSharedPointer<KoGradientBackground>  gradientFill(new KoGradientBackground(gradient));
                 shape->setBackground(gradientFill);
             }
             break;
         case KisPainter::FillStyleNone:
         default:
             shape->setBackground(QSharedPointer<KoShapeBackground>(0));
             break;
     }
 
     switch (strokeStyle()) {
     case KisPainter::StrokeStyleNone:
         shape->setStroke(KoShapeStrokeModelSP());
         break;
     case KisPainter::StrokeStyleBrush: {
         KoShapeStrokeSP stroke(new KoShapeStroke());
         stroke->setLineWidth(currentStrokeWidth());
         stroke->setColor(canvas()->resourceManager()->foregroundColor().toQColor());
         shape->setStroke(stroke);
         break;
     }
     }
 
     KUndo2Command *parentCommand = new KUndo2Command();
 
     KoSelection *selection = canvas()->selectedShapesProxy()->selection();
     const QList<KoShape*> oldSelectedShapes = selection->selectedShapes();
 
     // reset selection on the newly added shape :)
     // TODO: think about moving this into controller->addShape?
     new KoKeepShapesSelectedCommand(oldSelectedShapes, {shape}, canvas()->selectedShapesProxy(), false, parentCommand);
     KUndo2Command *cmd = canvas()->shapeController()->addShape(shape, 0, parentCommand);
     parentCommand->setText(cmd->text());
     new KoKeepShapesSelectedCommand(oldSelectedShapes, {shape}, canvas()->selectedShapesProxy(), true, parentCommand);
 
-    KisProcessingApplicator::runSingleCommandStroke(image(), cmd);
+    KisProcessingApplicator::runSingleCommandStroke(image(), cmd, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
 }
 
 void KisToolShape::addPathShape(KoPathShape* pathShape, const KUndo2MagicString& name)
 {
     KisNodeSP node = currentNode();
     if (!node) {
         return;
     }
 
     // Compute the outline
     KisImageSP image = this->image();
     QTransform matrix;
     matrix.scale(image->xRes(), image->yRes());
     matrix.translate(pathShape->position().x(), pathShape->position().y());
     QPainterPath mapedOutline = matrix.map(pathShape->outline());
 
     if (node->hasEditablePaintDevice()) {
         KisFigurePaintingToolHelper helper(name,
                                            image,
                                            node,
                                            canvas()->resourceManager(),
                                            strokeStyle(),
                                            fillStyle());
         helper.paintPainterPath(mapedOutline);
     } else if (node->inherits("KisShapeLayer")) {
         pathShape->normalize();
         addShape(pathShape);
 
     }
 }
diff --git a/libs/ui/tool/strokes/freehand_stroke.cpp b/libs/ui/tool/strokes/freehand_stroke.cpp
index 735b0b5e65..25fd09c670 100644
--- a/libs/ui/tool/strokes/freehand_stroke.cpp
+++ b/libs/ui/tool/strokes/freehand_stroke.cpp
@@ -1,348 +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,
                                     resources, strokeInfo),
       m_d(new Private(resources))
 {
     init();
 }
 
 FreehandStrokeStrategy::FreehandStrokeStrategy(KisResourcesSnapshotSP resources,
                                                QVector<KisFreehandStrokeInfo*> strokeInfos,
                                                const KUndo2MagicString &name)
     : KisPainterBasedStrokeStrategy("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 (UpdateData *d = dynamic_cast<UpdateData*>(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/freehand_stroke.h b/libs/ui/tool/strokes/freehand_stroke.h
index 8e51346846..4e688cff9b 100644
--- a/libs/ui/tool/strokes/freehand_stroke.h
+++ b/libs/ui/tool/strokes/freehand_stroke.h
@@ -1,237 +1,214 @@
 /*
  *  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 __FREEHAND_STROKE_H
 #define __FREEHAND_STROKE_H
 
 #include "kritaui_export.h"
 #include "kis_types.h"
 #include "kis_node.h"
 #include "kis_painter_based_stroke_strategy.h"
 #include <kis_distance_information.h>
 #include <brushengine/kis_paint_information.h>
 #include "kis_lod_transform.h"
 #include "KoColor.h"
 
 
 
 class KRITAUI_EXPORT FreehandStrokeStrategy : public KisPainterBasedStrokeStrategy
 {
 public:
     class Data : public KisStrokeJobData {
     public:
         enum DabType {
             POINT,
             LINE,
             CURVE,
             POLYLINE,
             POLYGON,
             RECT,
             ELLIPSE,
             PAINTER_PATH,
             QPAINTER_PATH,
             QPAINTER_PATH_FILL
         };
 
         Data(int _strokeInfoId,
              const KisPaintInformation &_pi)
             : KisStrokeJobData(KisStrokeJobData::UNIQUELY_CONCURRENT),
               strokeInfoId(_strokeInfoId),
               type(POINT), pi1(_pi)
         {}
 
         Data(int _strokeInfoId,
              const KisPaintInformation &_pi1,
              const KisPaintInformation &_pi2)
             : KisStrokeJobData(KisStrokeJobData::UNIQUELY_CONCURRENT),
               strokeInfoId(_strokeInfoId),
               type(LINE), pi1(_pi1), pi2(_pi2)
         {}
 
         Data(int _strokeInfoId,
              const KisPaintInformation &_pi1,
              const QPointF &_control1,
              const QPointF &_control2,
              const KisPaintInformation &_pi2)
             : KisStrokeJobData(KisStrokeJobData::UNIQUELY_CONCURRENT),
               strokeInfoId(_strokeInfoId),
               type(CURVE), pi1(_pi1), pi2(_pi2),
               control1(_control1), control2(_control2)
         {}
 
         Data(int _strokeInfoId,
              DabType _type,
              const vQPointF &_points)
             : KisStrokeJobData(KisStrokeJobData::UNIQUELY_CONCURRENT),
               strokeInfoId(_strokeInfoId),
             type(_type), points(_points)
         {}
 
         Data(int _strokeInfoId,
              DabType _type,
              const QRectF &_rect)
             : KisStrokeJobData(KisStrokeJobData::UNIQUELY_CONCURRENT),
               strokeInfoId(_strokeInfoId),
             type(_type), rect(_rect)
         {}
 
         Data(int _strokeInfoId,
              DabType _type,
              const QPainterPath &_path)
             : KisStrokeJobData(KisStrokeJobData::UNIQUELY_CONCURRENT),
               strokeInfoId(_strokeInfoId),
             type(_type), path(_path)
         {}
 
         Data(int _strokeInfoId,
              DabType _type,
              const QPainterPath &_path,
              const QPen &_pen, const KoColor &_customColor)
             : KisStrokeJobData(KisStrokeJobData::UNIQUELY_CONCURRENT),
               strokeInfoId(_strokeInfoId),
             type(_type), path(_path),
             pen(_pen), customColor(_customColor)
         {}
 
         KisStrokeJobData* createLodClone(int levelOfDetail) override {
             return new Data(*this, levelOfDetail);
         }
 
     private:
         Data(const Data &rhs, int levelOfDetail)
             : KisStrokeJobData(rhs),
               strokeInfoId(rhs.strokeInfoId),
               type(rhs.type)
         {
             KisLodTransform t(levelOfDetail);
 
             switch(type) {
             case Data::POINT:
                 pi1 = t.map(rhs.pi1);
                 break;
             case Data::LINE:
                 pi1 = t.map(rhs.pi1);
                 pi2 = t.map(rhs.pi2);
                 break;
             case Data::CURVE:
                 pi1 = t.map(rhs.pi1);
                 pi2 = t.map(rhs.pi2);
                 control1 = t.map(rhs.control1);
                 control2 = t.map(rhs.control2);
                 break;
             case Data::POLYLINE:
                 points = t.map(rhs.points);
                 break;
             case Data::POLYGON:
                 points = t.map(rhs.points);
                 break;
             case Data::RECT:
                 rect = t.map(rhs.rect);
                 break;
             case Data::ELLIPSE:
                 rect = t.map(rhs.rect);
                 break;
             case Data::PAINTER_PATH:
                 path = t.map(rhs.path);
                 break;
             case Data::QPAINTER_PATH:
                 path = t.map(rhs.path);
                 pen = rhs.pen;
                 break;
             case Data::QPAINTER_PATH_FILL:
                 path = t.map(rhs.path);
                 pen = rhs.pen;
                 customColor = rhs.customColor;
                 break;
             };
         }
     public:
         int strokeInfoId;
 
         DabType type;
         KisPaintInformation pi1;
         KisPaintInformation pi2;
         QPointF control1;
         QPointF control2;
 
         vQPointF points;
         QRectF rect;
         QPainterPath path;
         QPen pen;
         KoColor customColor;
     };
 
-    class UpdateData : public KisStrokeJobData {
-    public:
-        UpdateData(bool _forceUpdate)
-            : KisStrokeJobData(KisStrokeJobData::SEQUENTIAL),
-              forceUpdate(_forceUpdate)
-        {}
-
-
-        KisStrokeJobData* createLodClone(int levelOfDetail) override {
-            return new UpdateData(*this, levelOfDetail);
-        }
-
-    private:
-        UpdateData(const UpdateData &rhs, int levelOfDetail)
-            : KisStrokeJobData(rhs),
-              forceUpdate(rhs.forceUpdate)
-        {
-            Q_UNUSED(levelOfDetail);
-        }
-    public:
-        bool forceUpdate = false;
-    };
-
 public:
     FreehandStrokeStrategy(KisResourcesSnapshotSP resources,
                            KisFreehandStrokeInfo *strokeInfo,
                            const KUndo2MagicString &name);
 
     FreehandStrokeStrategy(KisResourcesSnapshotSP resources,
                            QVector<KisFreehandStrokeInfo*> strokeInfos,
                            const KUndo2MagicString &name);
 
     ~FreehandStrokeStrategy() override;
 
     void initStrokeCallback() override;
     void finishStrokeCallback() override;
 
     void doStrokeCallback(KisStrokeJobData *data) override;
 
     KisStrokeStrategy* createLodClone(int levelOfDetail) override;
 
     void notifyUserStartedStroke() override;
     void notifyUserEndedStroke() override;
 
 protected:
     FreehandStrokeStrategy(const FreehandStrokeStrategy &rhs, int levelOfDetail);
 
 private:
     void init();
 
     void tryDoUpdate(bool forceEnd = false);
     void issueSetDirtySignals();
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 #endif /* __FREEHAND_STROKE_H */
diff --git a/libs/ui/tool/strokes/move_stroke_strategy.cpp b/libs/ui/tool/strokes/move_stroke_strategy.cpp
index 79b3da1841..d174ff4b53 100644
--- a/libs/ui/tool/strokes/move_stroke_strategy.cpp
+++ b/libs/ui/tool/strokes/move_stroke_strategy.cpp
@@ -1,246 +1,280 @@
 /*
  *  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"
 
 
 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()
 {
     QRect handlesRect;
 
     Q_FOREACH(KisNodeSP node, m_nodes) {
         saveInitialNodeOffsets(node);
         handlesRect |= node->exactBounds();
     }
 
     KisStrokeStrategyUndoCommandBased::initStrokeCallback();
 
     emit sigHandlesRectCalculated(handlesRect);
+    m_updateTimer.start();
 }
 
 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()) {
-        // FIXME: make cancel job exclusive instead
-        m_updatesFacade->blockUpdates();
-        moveAndUpdate(QPoint());
-        m_updatesFacade->unblockUpdates();
+        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) {
-        moveAndUpdate(d->offset);
-
+    if (!m_nodes.isEmpty() && d) {
         /**
          * NOTE: we do not care about threading here, because
          * all our jobs are declared sequential
          */
         m_finalOffset = d->offset;
-    }
-    else {
+        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::moveAndUpdate(QPoint offset)
+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, offset);
+        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/tool/strokes/move_stroke_strategy.h b/libs/ui/tool/strokes/move_stroke_strategy.h
index 2fb09bdd3b..8a82aa0432 100644
--- a/libs/ui/tool/strokes/move_stroke_strategy.h
+++ b/libs/ui/tool/strokes/move_stroke_strategy.h
@@ -1,97 +1,111 @@
 /*
  *  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 __MOVE_STROKE_STRATEGY_H
 #define __MOVE_STROKE_STRATEGY_H
 
 #include <QHash>
 #include <QObject>
 
 #include "kritaui_export.h"
 #include "kis_stroke_strategy_undo_command_based.h"
 #include "kis_types.h"
 #include "kis_lod_transform.h"
+#include <QElapsedTimer>
+#include "KisAsyncronousStrokeUpdateHelper.h"
 
 
 class KisUpdatesFacade;
 class KisPostExecutionUndoAdapter;
 
 
 class KRITAUI_EXPORT MoveStrokeStrategy : public QObject, public KisStrokeStrategyUndoCommandBased
 {
     Q_OBJECT
 public:
     class Data : public KisStrokeJobData {
     public:
         Data(QPoint _offset)
-            : KisStrokeJobData(SEQUENTIAL, EXCLUSIVE),
+            : KisStrokeJobData(SEQUENTIAL, NORMAL),
               offset(_offset)
         {
         }
 
         KisStrokeJobData* createLodClone(int levelOfDetail) override {
             return new Data(*this, levelOfDetail);
         }
 
         QPoint offset;
 
     private:
         Data(const Data &rhs, int levelOfDetail)
             : KisStrokeJobData(rhs)
         {
             KisLodTransform t(levelOfDetail);
             offset = t.map(rhs.offset);
         }
     };
 
+    struct BarrierUpdateData : public KisAsyncronousStrokeUpdateHelper::UpdateData
+    {
+        BarrierUpdateData(bool forceUpdate)
+            : KisAsyncronousStrokeUpdateHelper::UpdateData(forceUpdate, BARRIER, EXCLUSIVE)
+        {}
+    };
+
 public:
     MoveStrokeStrategy(KisNodeList nodes, KisUpdatesFacade *updatesFacade,
                        KisStrokeUndoFacade *undoFacade);
 
     void initStrokeCallback() override;
     void finishStrokeCallback() override;
     void cancelStrokeCallback() override;
     void doStrokeCallback(KisStrokeJobData *data) override;
 
     KisStrokeStrategy* createLodClone(int levelOfDetail) override;
 
 Q_SIGNALS:
     void sigHandlesRectCalculated(const QRect &handlesRect);
 
 private:
     MoveStrokeStrategy(const MoveStrokeStrategy &rhs);
     void setUndoEnabled(bool value);
     void setUpdatesEnabled(bool value);
 private:
-    void moveAndUpdate(QPoint offset);
     QRect moveNode(KisNodeSP node, QPoint offset);
     void addMoveCommands(KisNodeSP node, KUndo2Command *parent);
     void saveInitialNodeOffsets(KisNodeSP node);
+    void doCanvasUpdate(bool forceUpdate = false);
+    void tryPostUpdateJob(bool forceUpdate);
 
 private:
     KisNodeList m_nodes;
     QSet<KisNodeSP> m_blacklistedNodes;
     KisUpdatesFacade *m_updatesFacade;
     QPoint m_finalOffset;
     QRect m_dirtyRect;
     QHash<KisNodeSP, QRect> m_dirtyRects;
     bool m_updatesEnabled;
     QHash<KisNodeSP, QPoint> m_initialNodeOffsets;
+
+    QElapsedTimer m_updateTimer;
+    bool m_hasPostponedJob = false;
+    const int m_updateInterval = 30;
 };
 
 #endif /* __MOVE_STROKE_STRATEGY_H */
diff --git a/libs/ui/widgets/KisGamutMaskToolbar.cpp b/libs/ui/widgets/KisGamutMaskToolbar.cpp
index 6c007584cc..2a1851f773 100644
--- a/libs/ui/widgets/KisGamutMaskToolbar.cpp
+++ b/libs/ui/widgets/KisGamutMaskToolbar.cpp
@@ -1,116 +1,144 @@
 /*
  *  Copyright (c) 2018 Anna Medonosova <anna.medonosova@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 <QWidget>
 #include "KisGamutMaskToolbar.h"
 #include <kis_icon_utils.h>
 #include <kis_canvas_resource_provider.h>
+#include <kis_signals_blocker.h>
 
 KisGamutMaskToolbar::KisGamutMaskToolbar(QWidget* parent) : QWidget(parent)
   , m_selectedMask(nullptr)
+  , m_selfUpdate(false)
 {
     m_ui = new Ui_wdgGamutMaskToolbar();
     m_ui->setupUi(this);
 
     m_iconMaskOff = KisIconUtils::loadIcon("gamut-mask-off");
     m_iconMaskOn = KisIconUtils::loadIcon("gamut-mask-on");
 
     m_textNoMask = i18n("Select a mask in \"Gamut Masks\" docker");
     m_textMaskDisabled = i18n("Mask is disabled");
 
     m_ui->bnToggleMask->setChecked(false);
     m_ui->bnToggleMask->setIcon(m_iconMaskOff);
 
     m_ui->rotationSlider->setRange(0, 360);
     m_ui->rotationSlider->setPrefix(i18n("Rotation: "));
     m_ui->rotationSlider->setSuffix("°");
     m_ui->rotationSlider->setFastSliderStep(30); // TODO: test for usability
     m_ui->rotationSlider->hide();
 
     // gamut mask connections
     connect(m_ui->bnToggleMask, SIGNAL(toggled(bool)), SLOT(slotGamutMaskToggle(bool)));
     connect(m_ui->rotationSlider, SIGNAL(valueChanged(int)), SLOT(slotGamutMaskRotate(int)));
 }
 
 void KisGamutMaskToolbar::connectMaskSignals(KisCanvasResourceProvider* resourceProvider)
 {
     connect(resourceProvider, SIGNAL(sigGamutMaskChanged(KoGamutMask*)),
             this, SLOT(slotGamutMaskSet(KoGamutMask*)), Qt::UniqueConnection);
 
     connect(resourceProvider, SIGNAL(sigGamutMaskUnset()),
             this, SLOT(slotGamutMaskUnset()), Qt::UniqueConnection);
 
     connect(this, SIGNAL(sigGamutMaskChanged(KoGamutMask*)),
             resourceProvider, SLOT(slotGamutMaskActivated(KoGamutMask*)), Qt::UniqueConnection);
+
+    connect(this, SIGNAL(sigGamutMaskDeactivated()),
+            resourceProvider, SLOT(slotGamutMaskDeactivate()), Qt::UniqueConnection);
+
+    connect(resourceProvider, SIGNAL(sigGamutMaskDeactivated()),
+            this, SLOT(slotGamutMaskDeactivate()), Qt::UniqueConnection);
 }
 
 void KisGamutMaskToolbar::slotGamutMaskSet(KoGamutMask *mask)
 {
     if (!mask) {
         return;
     }
 
+    if (m_selfUpdate) {
+        return;
+    }
+
     m_selectedMask = mask;
 
     if (m_selectedMask) {
         slotGamutMaskToggle(true);
     } else {
         slotGamutMaskToggle(false);
     }
 }
 
 void KisGamutMaskToolbar::slotGamutMaskUnset()
 {
     m_ui->rotationSlider->hide();
     m_ui->labelMaskName->show();
     m_ui->labelMaskName->setText(m_textNoMask);
 }
 
+void KisGamutMaskToolbar::slotGamutMaskDeactivate()
+{
+    if (m_selfUpdate) {
+        return;
+    }
+
+    slotGamutMaskToggle(false);
+}
+
 void KisGamutMaskToolbar::slotGamutMaskToggle(bool state)
 {
     bool b = (!m_selectedMask) ? false : state;
 
     m_ui->bnToggleMask->setChecked(b);
 
     if (b == true) {
         m_ui->bnToggleMask->setIcon(m_iconMaskOn);
         m_ui->labelMaskName->hide();
         m_ui->rotationSlider->show();
 
         m_ui->rotationSlider->blockSignals(true);
         m_ui->rotationSlider->setValue(m_selectedMask->rotation());
         m_ui->rotationSlider->blockSignals(false);
+
+        m_selfUpdate = true;
+        emit sigGamutMaskChanged(m_selectedMask);
+        m_selfUpdate = false;
+
     } else {
         m_ui->bnToggleMask->setIcon(m_iconMaskOff);
         m_ui->rotationSlider->hide();
         m_ui->labelMaskName->show();
         m_ui->labelMaskName->setText(m_textMaskDisabled);
-    }
 
-    emit sigGamutMaskToggle(state);
+        m_selfUpdate = true;
+        emit sigGamutMaskDeactivated();
+        m_selfUpdate = false;
+    }
 }
 
 void KisGamutMaskToolbar::slotGamutMaskRotate(int angle)
 {
     if (!m_selectedMask) {
         return;
     }
 
     m_selectedMask->setRotation(angle);
     emit sigGamutMaskChanged(m_selectedMask);
 }
diff --git a/libs/ui/widgets/KisGamutMaskToolbar.h b/libs/ui/widgets/KisGamutMaskToolbar.h
index c61792aa33..941d7794c2 100644
--- a/libs/ui/widgets/KisGamutMaskToolbar.h
+++ b/libs/ui/widgets/KisGamutMaskToolbar.h
@@ -1,62 +1,65 @@
 /*
  *  Copyright (c) 2018 Anna Medonosova <anna.medonosova@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 KISGAMUTMASKTOOLBAR_H
 #define KISGAMUTMASKTOOLBAR_H
 
 #include <QWidget>
 #include <QIcon>
 
 #include <resources/KoGamutMask.h>
 #include "kritaui_export.h"
 
 #include "ui_wdgGamutMaskToolbar.h"
 
 class KisCanvasResourceProvider;
 
 class KRITAUI_EXPORT KisGamutMaskToolbar : public QWidget
 {
     Q_OBJECT
 public:
     KisGamutMaskToolbar(QWidget* parent = nullptr);
     void connectMaskSignals(KisCanvasResourceProvider* resourceProvider);
 
 Q_SIGNALS:
-    void sigGamutMaskToggle(bool state);
     void sigGamutMaskChanged(KoGamutMask*);
+    void sigGamutMaskDeactivated();
 
 public Q_SLOTS:
     void slotGamutMaskSet(KoGamutMask* mask);
     void slotGamutMaskUnset();
+    void slotGamutMaskDeactivate();
 
 private Q_SLOTS:
     void slotGamutMaskToggle(bool state);
     void slotGamutMaskRotate(int angle);
 
 private:
     Ui_wdgGamutMaskToolbar* m_ui;
     KoGamutMask* m_selectedMask;
 
     QIcon m_iconMaskOff;
     QIcon m_iconMaskOn;
 
     QString m_textNoMask;
     QString m_textMaskDisabled;
+
+    bool m_selfUpdate;
 };
 
 #endif // KISGAMUTMASKTOOLBAR_H
diff --git a/libs/ui/widgets/KisNewsWidget.cpp b/libs/ui/widgets/KisNewsWidget.cpp
index 268834d311..273a05f973 100644
--- a/libs/ui/widgets/KisNewsWidget.cpp
+++ b/libs/ui/widgets/KisNewsWidget.cpp
@@ -1,111 +1,223 @@
 /*
  * Copyright (c) 2018 boud <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 "KisNewsWidget.h"
 
 #include <QDesktopServices>
 #include <QUrl>
 #include <QPainter>
 #include <QStyleOptionViewItem>
 #include <QModelIndex>
 #include <QTextDocument>
 #include <QAbstractTextDocumentLayout>
 
 #include "kis_config.h"
 #include "KisMultiFeedRSSModel.h"
+#include "QRegularExpression"
 
 
 KisNewsDelegate::KisNewsDelegate(QObject *parent)
     : QStyledItemDelegate(parent)
 {
 }
 
 void KisNewsDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     painter->save();
 
     QStyleOptionViewItem optionCopy = option;
     initStyleOption(&optionCopy, index);
 
     QStyle *style = optionCopy.widget? optionCopy.widget->style() : QApplication::style();
 
     QTextDocument doc;
     doc.setHtml(optionCopy.text);
     doc.setDocumentMargin(10);
 
     /// Painting item without text
     optionCopy.text = QString();
     style->drawControl(QStyle::CE_ItemViewItem, &optionCopy, painter);
 
     QAbstractTextDocumentLayout::PaintContext ctx;
 
     // Highlighting text if item is selected
     if (optionCopy.state & QStyle::State_Selected) {
         ctx.palette.setColor(QPalette::Text, optionCopy.palette.color(QPalette::Active, QPalette::HighlightedText));
     }
 
     painter->translate(optionCopy.rect.left(), optionCopy.rect.top());
     QRect clip(0, 0, optionCopy.rect.width(), optionCopy.rect.height());
     doc.setPageSize(clip.size());
     doc.drawContents(painter, clip);
     painter->restore();
 }
 
 QSize KisNewsDelegate::sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     QStyleOptionViewItem optionCopy = option;
     initStyleOption(&optionCopy, index);
 
     QTextDocument doc;
     doc.setHtml(optionCopy.text);
     doc.setTextWidth(optionCopy.rect.width());
     return QSize(doc.idealWidth(), doc.size().height());
 }
 
 KisNewsWidget::KisNewsWidget(QWidget *parent)
     : QWidget(parent)
 {
     setupUi(this);
     m_rssModel = new MultiFeedRssModel(this);
+    connect(m_rssModel, SIGNAL(feedDataChanged()), this, SLOT(rssDataChanged()));
+
 
     setCursor(Qt::PointingHandCursor);
 
     listNews->setModel(m_rssModel);
     listNews->setItemDelegate(new KisNewsDelegate(listNews));
     connect(listNews, SIGNAL(clicked(QModelIndex)), this, SLOT(itemSelected(QModelIndex)));
 }
 
+void KisNewsWidget::setAnalyticsTracking(QString text)
+{
+    analyticsTrackingParameters = text;
+}
+
+bool KisNewsWidget::hasUpdateAvailable()
+{
+    return needsVersionUpdate;
+}
+
+QString KisNewsWidget::versionNumber()
+{
+    return newVersionNumber;
+}
+
+QString KisNewsWidget::versionLink()
+{
+    return newVersionLink;
+}
+
 void KisNewsWidget::toggleNews(bool toggle)
 {
     KisConfig cfg(false);
     cfg.writeEntry<bool>("FetchNews", toggle);
 
     if (toggle) {
         m_rssModel->addFeed(QLatin1String("https://krita.org/en/feed/"));
     }
     else {
         m_rssModel->removeFeed(QLatin1String("https://krita.org/en/feed/"));
     }
 }
 
 void KisNewsWidget::itemSelected(const QModelIndex &idx)
 {
     if (idx.isValid()) {
         QString link = idx.data(RssRoles::LinkRole).toString();
-        QDesktopServices::openUrl(QUrl(link));
+
+        // append query string for analytics tracking if we set it
+        if (analyticsTrackingParameters != "") {
+
+            // use title in analytics query string
+            QString linkTitle = idx.data(RssRoles::TitleRole).toString();
+            linkTitle = linkTitle.simplified(); // trims and makes 1 white space
+            linkTitle = linkTitle.replace(" ", "");
+
+            analyticsTrackingParameters = analyticsTrackingParameters.append(linkTitle);
+            QDesktopServices::openUrl(QUrl(link.append(analyticsTrackingParameters)));
+
+        } else {
+            QDesktopServices::openUrl(QUrl(link));
+        }
+
+
     }
 }
+
+void KisNewsWidget::rssDataChanged()
+{
+
+    // grab the latest release post and URL for reference later
+    // if we need to update
+    for (int i = 0; i < m_rssModel->rowCount(); i++)
+    {
+       const QModelIndex &idx = m_rssModel->index(i);
+
+       if (idx.isValid()) {
+
+           // only use official release announcements to get version number
+           if ( idx.data(RssRoles::CategoryRole).toString() !=  "Official Release") {
+               continue;
+           }
+
+           QString linkTitle = idx.data(RssRoles::TitleRole).toString();
+
+           // regex to capture version number
+           QRegularExpression versionRegex("\\d\\.\\d\\.?\\d?\\.?\\d");
+           QRegularExpressionMatch matched = versionRegex.match(linkTitle);
+
+           // only take the top match for release version since that is the newest
+           if (matched.hasMatch()) {
+               newVersionNumber = matched.captured(0);
+               newVersionLink = idx.data(RssRoles::LinkRole).toString();
+               break;
+           }
+
+       }
+    }
+
+    // see if we need to update our version, or we are on a dev version
+    calculateVersionUpdateStatus();
+
+    emit newsDataChanged();
+}
+
+void KisNewsWidget::calculateVersionUpdateStatus()
+{
+    // do version compare to see if there is a new version available
+    // also check to see if we are on a dev version (newer than newest release)
+    QStringList currentVersionParts = qApp->applicationVersion().split(".");
+    QStringList onlineReleaseAnnouncement = newVersionNumber.split(".");
+
+    // is the major version different?
+    if (onlineReleaseAnnouncement[0] > currentVersionParts[0] ) {
+        needsVersionUpdate = true; // we are a major version behind
+        return;
+    }
+
+    // major versions are the same, so check minor versions
+     if (onlineReleaseAnnouncement[1] > currentVersionParts[1] ) {
+         needsVersionUpdate = true; // we are a minor version behind
+         return;
+     }
+
+     // minor versions are the same, so maybe bugfix version is different
+     // sometimes we don't communicate this, implictly make 0 if it doesn't exist
+     if (onlineReleaseAnnouncement[2].isNull()) {
+         onlineReleaseAnnouncement[2] = "0";
+     }
+     if (currentVersionParts[2].isNull()) {
+         currentVersionParts[2] = "0";
+     }
+
+     if (onlineReleaseAnnouncement[2] > currentVersionParts[2] ) {
+         needsVersionUpdate = true; // we are a bugfix version behind
+         return;
+     }
+
+}
diff --git a/libs/ui/widgets/KisNewsWidget.h b/libs/ui/widgets/KisNewsWidget.h
index 4dda2f4512..7acfa7239d 100644
--- a/libs/ui/widgets/KisNewsWidget.h
+++ b/libs/ui/widgets/KisNewsWidget.h
@@ -1,57 +1,75 @@
 /*
  * Copyright (c) 2018 boud <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 KISNEWSWIDGET_H
 #define KISNEWSWIDGET_H
 
 #include <QWidget>
 #include <QListView>
 #include <QStyledItemDelegate>
 
 #include <ui_KisNewsPage.h>
 
 class MultiFeedRssModel;
 
 class KisNewsDelegate : public QStyledItemDelegate
 {
     Q_OBJECT
 public:
     KisNewsDelegate(QObject *parent = 0);
     void paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const override;
     QSize sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const override;
 };
 
 /**
  * @brief The KisNewsWidget class shows the latest news from Krita.org
  */
 class KisNewsWidget : public QWidget, public Ui::KisNewsPage
 {
     Q_OBJECT
 public:
     explicit KisNewsWidget(QWidget *parent = nullptr);
 
+    void setAnalyticsTracking(QString text);
 
+    bool hasUpdateAvailable();
+    QString versionNumber();
+    QString versionLink();
+
+Q_SIGNALS:
+    void newsDataChanged();
 
 private Q_SLOTS:
     void toggleNews(bool toggle);
     void itemSelected(const QModelIndex &idx);
+    void rssDataChanged();
 private:
     bool m_getNews {false};
     MultiFeedRssModel *m_rssModel {0};
+    QString analyticsTrackingParameters;
+
+    /// for new Krita version notification
+    QString newVersionNumber;
+    QString newVersionLink;
+
+    // version checking logic tells us we need to update our Krita
+    void calculateVersionUpdateStatus();
+    bool needsVersionUpdate = false;
+
 };
 
 #endif // KISNEWSWIDGET_H
diff --git a/libs/ui/widgets/kis_curve_widget.cpp b/libs/ui/widgets/kis_curve_widget.cpp
index ae6592771c..623d11a572 100644
--- a/libs/ui/widgets/kis_curve_widget.cpp
+++ b/libs/ui/widgets/kis_curve_widget.cpp
@@ -1,535 +1,535 @@
 /*
  *  Copyright (c) 2005 C. Boemann <cbo@boemann.dk>
  *  Copyright (c) 2009 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 
 // C++ includes.
 
 #include <cmath>
 #include <cstdlib>
 
 // Qt includes.
 
 #include <QPixmap>
 #include <QPainter>
 #include <QPoint>
 #include <QPen>
 #include <QEvent>
 #include <QRect>
 #include <QFont>
 #include <QFontMetrics>
 #include <QMouseEvent>
 #include <QKeyEvent>
 #include <QPaintEvent>
 #include <QList>
 #include <QApplication>
 
 #include <QSpinBox>
 
 // KDE includes.
 
 #include <kis_debug.h>
 #include <kis_config.h>
 #include <klocalizedstring.h>
 
 // Local includes.
 
 #include "widgets/kis_curve_widget.h"
 
 
 #define bounds(x,a,b) (x<a ? a : (x>b ? b :x))
 #define MOUSE_AWAY_THRES 15
 #define POINT_AREA       1E-4
 #define CURVE_AREA       1E-4
 
 #include "kis_curve_widget_p.h"
 
 KisCurveWidget::KisCurveWidget(QWidget *parent, Qt::WindowFlags f)
         : QWidget(parent, f), d(new KisCurveWidget::Private(this))
 {
     setObjectName("KisCurveWidget");
     d->m_grab_point_index = -1;
     d->m_readOnlyMode   = false;
     d->m_guideVisible   = false;
     d->m_pixmapDirty = true;
     d->m_pixmapCache = 0;
     d->setState(ST_NORMAL);
 
     d->m_intIn = 0;
     d->m_intOut = 0;
 
     setMouseTracking(true);
     setAutoFillBackground(false);
     setAttribute(Qt::WA_OpaquePaintEvent);
     setMinimumSize(150, 50);
     setMaximumSize(250, 250);
 
     d->setCurveModified();
 
     setFocusPolicy(Qt::StrongFocus);
 }
 
 KisCurveWidget::~KisCurveWidget()
 {
     delete d->m_pixmapCache;
     delete d;
 }
 
 void KisCurveWidget::setupInOutControls(QSpinBox *in, QSpinBox *out, int inMin, int inMax, int outMin, int outMax)
 {
     d->m_intIn = in;
     d->m_intOut = out;
 
     if (!d->m_intIn || !d->m_intOut)
         return;
 
     d->m_inMin = inMin;
     d->m_inMax = inMax;
     d->m_outMin = outMin;
     d->m_outMax = outMax;
 
     int realInMin = qMin(inMin, inMax); // tilt elevation has range (90, 0), which QSpinBox can't handle
     int realInMax = qMax(inMin, inMax);
 
     d->m_intIn->setRange(realInMin, realInMax);
     d->m_intOut->setRange(d->m_outMin, d->m_outMax);
 
     connect(d->m_intIn, SIGNAL(valueChanged(int)), this, SLOT(inOutChanged(int)), Qt::UniqueConnection);
     connect(d->m_intOut, SIGNAL(valueChanged(int)), this, SLOT(inOutChanged(int)), Qt::UniqueConnection);
 
     d->syncIOControls();
 
 }
 void KisCurveWidget::dropInOutControls()
 {
     if (!d->m_intIn || !d->m_intOut)
         return;
 
     disconnect(d->m_intIn, SIGNAL(valueChanged(int)), this, SLOT(inOutChanged(int)));
     disconnect(d->m_intOut, SIGNAL(valueChanged(int)), this, SLOT(inOutChanged(int)));
 
     d->m_intIn = d->m_intOut = 0;
 
 }
 
 void KisCurveWidget::inOutChanged(int)
 {
     QPointF pt;
 
     Q_ASSERT(d->m_grab_point_index >= 0);
 
     pt.setX(d->io2sp(d->m_intIn->value(), d->m_inMin, d->m_inMax));
     pt.setY(d->io2sp(d->m_intOut->value(), d->m_outMin, d->m_outMax));
 
     bool newPoint = false;
     if (d->jumpOverExistingPoints(pt, d->m_grab_point_index)) {
         newPoint = true;
 
         d->m_curve.setPoint(d->m_grab_point_index, pt);
         d->m_grab_point_index = d->m_curve.points().indexOf(pt);
         emit pointSelectedChanged();
     } else {
         pt = d->m_curve.points()[d->m_grab_point_index];
     }
 
     if (!newPoint) {
         // if there is a new Point, no point in rewriting values in spinboxes
 
         d->m_intIn->blockSignals(true);
         d->m_intOut->blockSignals(true);
 
         d->m_intIn->setValue(d->sp2io(pt.x(), d->m_inMin, d->m_inMax));
         d->m_intOut->setValue(d->sp2io(pt.y(), d->m_outMin, d->m_outMax));
 
         d->m_intIn->blockSignals(false);
         d->m_intOut->blockSignals(false);
     }
 
     d->setCurveModified(false);
 }
 
 
 void KisCurveWidget::reset(void)
 {
     d->m_grab_point_index = -1;
     emit pointSelectedChanged();
     d->m_guideVisible = false;
 
     //remove total - 2 points.
     while (d->m_curve.points().count() - 2 ) {
         d->m_curve.removePoint(d->m_curve.points().count() - 2);
     }
 
     d->setCurveModified();
 }
 
 void KisCurveWidget::setCurveGuide(const QColor & color)
 {
     d->m_guideVisible = true;
     d->m_colorGuide   = color;
 
 }
 
 void KisCurveWidget::setPixmap(const QPixmap & pix)
 {
     d->m_pix = pix;
     d->m_pixmapDirty = true;
     d->setCurveRepaint();
 }
 
 QPixmap KisCurveWidget::getPixmap()
 {
     return d->m_pix;
 }
 
 void KisCurveWidget::setBasePixmap(const QPixmap &pix)
 {
     d->m_pixmapBase = pix;
 }
 
 QPixmap KisCurveWidget::getBasePixmap()
 {
     return d->m_pixmapBase;
 }
 
 bool KisCurveWidget::pointSelected() const
 {
     return d->m_grab_point_index > 0 && d->m_grab_point_index < d->m_curve.points().count() - 1;
 }
 
 void KisCurveWidget::keyPressEvent(QKeyEvent *e)
 {
     if (e->key() == Qt::Key_Delete || e->key() == Qt::Key_Backspace) {
         if (d->m_grab_point_index > 0 && d->m_grab_point_index < d->m_curve.points().count() - 1) {
             //x() find closest point to get focus afterwards
             double grab_point_x = d->m_curve.points()[d->m_grab_point_index].x();
 
             int left_of_grab_point_index = d->m_grab_point_index - 1;
             int right_of_grab_point_index = d->m_grab_point_index + 1;
             int new_grab_point_index;
 
             if (fabs(d->m_curve.points()[left_of_grab_point_index].x() - grab_point_x) <
                     fabs(d->m_curve.points()[right_of_grab_point_index].x() - grab_point_x)) {
                 new_grab_point_index = left_of_grab_point_index;
             } else {
                 new_grab_point_index = d->m_grab_point_index;
             }
             d->m_curve.removePoint(d->m_grab_point_index);
             d->m_grab_point_index = new_grab_point_index;
             emit pointSelectedChanged();
             setCursor(Qt::ArrowCursor);
             d->setState(ST_NORMAL);
         }
         e->accept();
         d->setCurveModified();
     } else if (e->key() == Qt::Key_Escape && d->state() != ST_NORMAL) {
         d->m_curve.setPoint(d->m_grab_point_index, QPointF(d->m_grabOriginalX, d->m_grabOriginalY) );
         setCursor(Qt::ArrowCursor);
         d->setState(ST_NORMAL);
 
         e->accept();
         d->setCurveModified();
     } else if ((e->key() == Qt::Key_A || e->key() == Qt::Key_Insert) && d->state() == ST_NORMAL) {
         /* FIXME: Lets user choose the hotkeys */
         addPointInTheMiddle();
         e->accept();
     } else
         QWidget::keyPressEvent(e);
 }
 
 void KisCurveWidget::addPointInTheMiddle()
 {
     QPointF pt(0.5, d->m_curve.value(0.5));
 
     if (!d->jumpOverExistingPoints(pt, -1))
         return;
 
     d->m_grab_point_index = d->m_curve.addPoint(pt);
     emit pointSelectedChanged();
 
     if (d->m_intIn)
         d->m_intIn->setFocus(Qt::TabFocusReason);
     d->setCurveModified();
 }
 
 void KisCurveWidget::resizeEvent(QResizeEvent *e)
 {
     d->m_pixmapDirty = true;
     QWidget::resizeEvent(e);
 }
 
 void KisCurveWidget::paintEvent(QPaintEvent *)
 {
     int    wWidth = width() - 1;
     int    wHeight = height() - 1;
 
 
     QPainter p(this);
 
     // Antialiasing is not a good idea here, because
     // the grid will drift one pixel to any side due to rounding of int
     // FIXME: let's user tell the last word (in config)
     //p.setRenderHint(QPainter::Antialiasing);
      QPalette appPalette = QApplication::palette();
      p.fillRect(rect(), appPalette.color(QPalette::Base)); // clear out previous paint call results
 
      // make the entire widget grayed out if it is disabled
      if (!this->isEnabled()) {
         p.setOpacity(0.2);
      }
 
 
 
     //  draw background
     if (!d->m_pix.isNull()) {
         if (d->m_pixmapDirty || !d->m_pixmapCache) {
             delete d->m_pixmapCache;
             d->m_pixmapCache = new QPixmap(width(), height());
             QPainter cachePainter(d->m_pixmapCache);
 
             cachePainter.scale(1.0*width() / d->m_pix.width(), 1.0*height() / d->m_pix.height());
             cachePainter.drawPixmap(0, 0, d->m_pix);
             d->m_pixmapDirty = false;
         }
         p.drawPixmap(0, 0, *d->m_pixmapCache);
     }
 
     d->drawGrid(p, wWidth, wHeight);
 
     KisConfig cfg(true);
     if (cfg.antialiasCurves()) {
         p.setRenderHint(QPainter::Antialiasing);
     }
 
     // Draw curve.
     double curY;
     double normalizedX;
     int x;
 
     QPolygonF poly;
 
     p.setPen(QPen(appPalette.color(QPalette::Text), 2, Qt::SolidLine));
     for (x = 0 ; x < wWidth ; x++) {
         normalizedX = double(x) / wWidth;
         curY = wHeight - d->m_curve.value(normalizedX) * wHeight;
 
         /**
          * Keep in mind that QLineF rounds doubles
          * to ints mathematically, not just rounds down
          * like in C
          */
         poly.append(QPointF(x, curY));
     }
     poly.append(QPointF(x, wHeight - d->m_curve.value(1.0) * wHeight));
     p.drawPolyline(poly);
 
     QPainterPath fillCurvePath;
     QPolygonF fillPoly = poly;
     fillPoly.append(QPoint(rect().width(), rect().height()));
     fillPoly.append(QPointF(0,rect().height()));
 
     // add a couple points to the edges so it fills in below always
 
     QColor fillColor = appPalette.color(QPalette::Text);
     fillColor.setAlphaF(0.2);
 
     fillCurvePath.addPolygon(fillPoly);
     p.fillPath(fillCurvePath, fillColor);
 
 
 
     // Drawing curve handles.
     double curveX;
     double curveY;
     if (!d->m_readOnlyMode) {
         for (int i = 0; i < d->m_curve.points().count(); ++i) {
             curveX = d->m_curve.points().at(i).x();
             curveY = d->m_curve.points().at(i).y();
 
             int handleSize = 12; // how big should control points be (diamater size)
 
             if (i == d->m_grab_point_index) {
                 // active point is slightly more "bold"
                 p.setPen(QPen(appPalette.color(QPalette::Text), 4, Qt::SolidLine));
                 p.drawEllipse(QRectF(curveX * wWidth - (handleSize*0.5),
                                      wHeight - (handleSize*0.5) - curveY * wHeight,
                                      handleSize,
                                      handleSize));
             } else {
                 p.setPen(QPen(appPalette.color(QPalette::Text), 2, Qt::SolidLine));
                 p.drawEllipse(QRectF(curveX * wWidth - (handleSize*0.5),
                                      wHeight - (handleSize*0.5) - curveY * wHeight,
                                      handleSize,
                                      handleSize));
             }
         }
     }
 
     // add border around widget to help contain everything
     QPainterPath widgetBoundsPath;
     widgetBoundsPath.addRect(rect());
     p.strokePath(widgetBoundsPath, appPalette.color(QPalette::Text));
 
 
     p.setOpacity(1.0); // reset to 1.0 in case we were drawing a disabled widget before
 }
 
 void KisCurveWidget::mousePressEvent(QMouseEvent * e)
 {
     if (d->m_readOnlyMode) return;
 
     if (e->button() != Qt::LeftButton)
         return;
 
     double x = e->pos().x() / (double)(width() - 1);
     double y = 1.0 - e->pos().y() / (double)(height() - 1);
 
 
 
     int closest_point_index = d->nearestPointInRange(QPointF(x, y), width(), height());
     if (closest_point_index < 0) {
         QPointF newPoint(x, y);
         if (!d->jumpOverExistingPoints(newPoint, -1))
             return;
         d->m_grab_point_index = d->m_curve.addPoint(newPoint);
         emit pointSelectedChanged();
     } else {
         d->m_grab_point_index = closest_point_index;
         emit pointSelectedChanged();
     }
 
     d->m_grabOriginalX = d->m_curve.points()[d->m_grab_point_index].x();
     d->m_grabOriginalY = d->m_curve.points()[d->m_grab_point_index].y();
     d->m_grabOffsetX = d->m_curve.points()[d->m_grab_point_index].x() - x;
     d->m_grabOffsetY = d->m_curve.points()[d->m_grab_point_index].y() - y;
     d->m_curve.setPoint(d->m_grab_point_index, QPointF(x + d->m_grabOffsetX, y + d->m_grabOffsetY));
 
     d->m_draggedAwayPointIndex = -1;
     d->setState(ST_DRAG);
 
 
     d->setCurveModified();
 }
 
 
 void KisCurveWidget::mouseReleaseEvent(QMouseEvent *e)
 {
     if (d->m_readOnlyMode) return;
 
     if (e->button() != Qt::LeftButton)
         return;
 
     setCursor(Qt::ArrowCursor);
     d->setState(ST_NORMAL);
 
     d->setCurveModified();
 }
 
 
 void KisCurveWidget::mouseMoveEvent(QMouseEvent * e)
 {
     if (d->m_readOnlyMode) return;
 
     double x = e->pos().x() / (double)(width() - 1);
     double y = 1.0 - e->pos().y() / (double)(height() - 1);
 
     if (d->state() == ST_NORMAL) { // If no point is selected set the cursor shape if on top
         int nearestPointIndex = d->nearestPointInRange(QPointF(x, y), width(), height());
 
         if (nearestPointIndex < 0)
             setCursor(Qt::ArrowCursor);
         else
             setCursor(Qt::CrossCursor);
     } else { // Else, drag the selected point
         bool crossedHoriz = e->pos().x() - width() > MOUSE_AWAY_THRES ||
                             e->pos().x() < -MOUSE_AWAY_THRES;
         bool crossedVert =  e->pos().y() - height() > MOUSE_AWAY_THRES ||
                             e->pos().y() < -MOUSE_AWAY_THRES;
 
         bool removePoint = (crossedHoriz || crossedVert);
 
         if (!removePoint && d->m_draggedAwayPointIndex >= 0) {
             // point is no longer dragged away so reinsert it
             QPointF newPoint(d->m_draggedAwayPoint);
             d->m_grab_point_index = d->m_curve.addPoint(newPoint);
             d->m_draggedAwayPointIndex = -1;
         }
 
         if (removePoint &&
                 (d->m_draggedAwayPointIndex >= 0))
             return;
 
 
         setCursor(Qt::CrossCursor);
 
         x += d->m_grabOffsetX;
         y += d->m_grabOffsetY;
 
         double leftX;
         double rightX;
         if (d->m_grab_point_index == 0) {
             leftX = 0.0;
             if (d->m_curve.points().count() > 1)
                 rightX = d->m_curve.points()[d->m_grab_point_index + 1].x() - POINT_AREA;
             else
                 rightX = 1.0;
         } else if (d->m_grab_point_index == d->m_curve.points().count() - 1) {
             leftX = d->m_curve.points()[d->m_grab_point_index - 1].x() + POINT_AREA;
             rightX = 1.0;
         } else {
             Q_ASSERT(d->m_grab_point_index > 0 && d->m_grab_point_index < d->m_curve.points().count() - 1);
 
             // the 1E-4 addition so we can grab the dot later.
             leftX = d->m_curve.points()[d->m_grab_point_index - 1].x() + POINT_AREA;
             rightX = d->m_curve.points()[d->m_grab_point_index + 1].x() - POINT_AREA;
         }
 
         x = bounds(x, leftX, rightX);
         y = bounds(y, 0., 1.);
 
         d->m_curve.setPoint(d->m_grab_point_index, QPointF(x, y));
 
         if (removePoint && d->m_curve.points().count() > 2) {
             d->m_draggedAwayPoint = d->m_curve.points()[d->m_grab_point_index];
             d->m_draggedAwayPointIndex = d->m_grab_point_index;
             d->m_curve.removePoint(d->m_grab_point_index);
             d->m_grab_point_index = bounds(d->m_grab_point_index, 0, d->m_curve.points().count() - 1);
             emit pointSelectedChanged();
         }
 
         d->setCurveModified();
     }
 }
 
 KisCubicCurve KisCurveWidget::curve()
 {
     return d->m_curve;
 }
 
 void KisCurveWidget::setCurve(KisCubicCurve inlist)
 {
     d->m_curve = inlist;
     d->m_grab_point_index = qBound(0, d->m_grab_point_index, d->m_curve.points().count() - 1);
-    emit pointSelectedChanged();
     d->setCurveModified();
+    emit pointSelectedChanged();
 }
 
 void KisCurveWidget::leaveEvent(QEvent *)
 {
 }
 
diff --git a/libs/ui/widgets/kis_custom_image_widget.cc b/libs/ui/widgets/kis_custom_image_widget.cc
index 497788e5d2..6655a54cf8 100644
--- a/libs/ui/widgets/kis_custom_image_widget.cc
+++ b/libs/ui/widgets/kis_custom_image_widget.cc
@@ -1,521 +1,521 @@
 /* This file is part of the Calligra project
  * Copyright (C) 2005 Thomas Zander <zander@kde.org>
  * Copyright (C) 2005 C. Boemann <cbo@boemann.dk>
  * Copyright (C) 2007 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "widgets/kis_custom_image_widget.h"
 
 #include <QMimeData>
 #include <QPushButton>
 #include <QSlider>
 #include <QComboBox>
 #include <QRect>
 #include <QApplication>
 #include <QClipboard>
 #include <QDesktopWidget>
 #include <QDialogButtonBox>
 #include <QFile>
 #include <QSpacerItem>
 
 #include <QMessageBox>
 #include <KoResourcePaths.h>
 
 #include <KFormat>
 
 #include <kis_debug.h>
 
 #include <kis_icon.h>
 #include <KoCompositeOp.h>
 #include <KoColorProfile.h>
 #include <KoColorSpace.h>
 #include <KoID.h>
 #include <KoColor.h>
 #include <KoUnit.h>
 #include <KoColorModelStandardIds.h>
 
 #include <kis_fill_painter.h>
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <kis_group_layer.h>
 #include <kis_paint_layer.h>
 #include <kis_paint_device.h>
 #include <kis_painter.h>
 
 #include "kis_config.h"
 #include "KisPart.h"
 #include "kis_clipboard.h"
 #include "KisDocument.h"
 #include "widgets/kis_cmb_idlist.h"
 #include <KisSqueezedComboBox.h>
 
 
 KisCustomImageWidget::KisCustomImageWidget(QWidget* parent, qint32 defWidth, qint32 defHeight, double resolution, const QString& defColorModel, const QString& defColorDepth, const QString& defColorProfile, const QString& imageName)
     : WdgNewImage(parent)
 {
     setObjectName("KisCustomImageWidget");
     m_openPane = qobject_cast<KisOpenPane*>(parent);
     Q_ASSERT(m_openPane);
 
     txtName->setText(imageName);
     m_widthUnit = KoUnit(KoUnit::Pixel, resolution);
     doubleWidth->setValue(defWidth);
     doubleWidth->setDecimals(0);
     m_width = m_widthUnit.fromUserValue(defWidth);
     cmbWidthUnit->addItems(KoUnit::listOfUnitNameForUi(KoUnit::ListAll));
     cmbWidthUnit->setCurrentIndex(m_widthUnit.indexInListForUi(KoUnit::ListAll));
 
     m_heightUnit = KoUnit(KoUnit::Pixel, resolution);
     doubleHeight->setValue(defHeight);
     doubleHeight->setDecimals(0);
     m_height = m_heightUnit.fromUserValue(defHeight);
     cmbHeightUnit->addItems(KoUnit::listOfUnitNameForUi(KoUnit::ListAll));
     cmbHeightUnit->setCurrentIndex(m_heightUnit.indexInListForUi(KoUnit::ListAll));
 
     doubleResolution->setValue(72.0 * resolution);
     doubleResolution->setDecimals(0);
 
     imageGroupSpacer->changeSize(0, 0, QSizePolicy::Fixed, QSizePolicy::Fixed);
     grpClipboard->hide();
 
     sliderOpacity->setRange(0, 100, 0);
     sliderOpacity->setValue(100);
-    sliderOpacity->setSuffix("%");
+    sliderOpacity->setSuffix(i18n("%"));
 
     connect(cmbPredefined, SIGNAL(activated(int)), SLOT(predefinedClicked(int)));
     connect(doubleResolution, SIGNAL(valueChanged(double)),
             this, SLOT(resolutionChanged(double)));
     connect(cmbWidthUnit, SIGNAL(activated(int)),
             this, SLOT(widthUnitChanged(int)));
     connect(doubleWidth, SIGNAL(valueChanged(double)),
             this, SLOT(widthChanged(double)));
     connect(cmbHeightUnit, SIGNAL(activated(int)),
             this, SLOT(heightUnitChanged(int)));
     connect(doubleHeight, SIGNAL(valueChanged(double)),
             this, SLOT(heightChanged(double)));
 
 
     // Create image
     newDialogConfirmationButtonBox->button(QDialogButtonBox::Ok)->setText(i18n("&Create"));
     connect(newDialogConfirmationButtonBox, SIGNAL(accepted()), this, SLOT(createImage()));
 
 
     // Cancel Create image button
     connect(newDialogConfirmationButtonBox, SIGNAL(rejected()), this->parentWidget(), SLOT(close()));
     connect(newDialogConfirmationButtonBox, SIGNAL(rejected()), this->parentWidget(), SLOT(deleteLater()));
 
 
 
     bnPortrait->setIcon(KisIconUtils::loadIcon("portrait"));
     connect(bnPortrait, SIGNAL(clicked()), SLOT(setPortrait()));
     connect(bnLandscape, SIGNAL(clicked()), SLOT(setLandscape()));
     bnLandscape->setIcon(KisIconUtils::loadIcon("landscape"));
 
     connect(doubleWidth, SIGNAL(valueChanged(double)), this, SLOT(switchPortraitLandscape()));
     connect(doubleHeight, SIGNAL(valueChanged(double)), this, SLOT(switchPortraitLandscape()));
     connect(bnSaveAsPredefined, SIGNAL(clicked()), this, SLOT(saveAsPredefined()));
 
     colorSpaceSelector->setCurrentColorModel(KoID(defColorModel));
     colorSpaceSelector->setCurrentColorDepth(KoID(defColorDepth));
     colorSpaceSelector->setCurrentProfile(defColorProfile);
     connect(colorSpaceSelector, SIGNAL(colorSpaceChanged(const KoColorSpace*)), this, SLOT(changeDocumentInfoLabel()));
 
     //connect(chkFromClipboard,SIGNAL(stateChanged(int)),this,SLOT(clipboardDataChanged()));
     connect(QApplication::clipboard(), SIGNAL(dataChanged()), this, SLOT(clipboardDataChanged()));
     connect(QApplication::clipboard(), SIGNAL(selectionChanged()), this, SLOT(clipboardDataChanged()));
     connect(QApplication::clipboard(), SIGNAL(changed(QClipboard::Mode)), this, SLOT(clipboardDataChanged()));
 
     connect(colorSpaceSelector, SIGNAL(selectionChanged(bool)), newDialogConfirmationButtonBox->button(QDialogButtonBox::Ok), SLOT(setEnabled(bool)));
 
 
     KisConfig cfg(true);
     intNumLayers->setValue(cfg.numDefaultLayers());
     KoColor bcol(KoColorSpaceRegistry::instance()->rgb8());
     bcol.fromQColor(cfg.defaultBackgroundColor());
     cmbColor->setColor(bcol);
     setBackgroundOpacity(cfg.defaultBackgroundOpacity());
 
     KisConfig::BackgroundStyle bgStyle = cfg.defaultBackgroundStyle();
 
     if (bgStyle == KisConfig::RASTER_LAYER) {
       radioBackgroundAsRaster->setChecked(true);
     } else if (bgStyle == KisConfig::FILL_LAYER) {
       radioBackgroundAsFill->setChecked(true);
     } else {
       radioBackgroundAsProjection->setChecked(true);
     }
 
     fillPredefined();
     switchPortraitLandscape();
 
     // this makes the portrait and landscape buttons more
     // obvious what is selected by changing the highlight color
     QPalette p = QApplication::palette();
     QPalette palette_highlight(p );
     QColor c = p.color(QPalette::Highlight);
     palette_highlight.setColor(QPalette::Button, c);
     bnLandscape->setPalette(palette_highlight);
     bnPortrait->setPalette(palette_highlight);
     changeDocumentInfoLabel();
 }
 
 void KisCustomImageWidget::showEvent(QShowEvent *)
 {
     fillPredefined();
     newDialogConfirmationButtonBox->button(QDialogButtonBox::Ok)->setFocus();
     newDialogConfirmationButtonBox->button(QDialogButtonBox::Ok)->setEnabled(true);
 }
 
 KisCustomImageWidget::~KisCustomImageWidget()
 {
     m_predefined.clear();
 }
 
 void KisCustomImageWidget::resolutionChanged(double res)
 {
     if (m_widthUnit.type() == KoUnit::Pixel) {
         m_widthUnit.setFactor(res / 72.0);
         m_width = m_widthUnit.fromUserValue(doubleWidth->value());
     }
 
     if (m_heightUnit.type() == KoUnit::Pixel) {
         m_heightUnit.setFactor(res / 72.0);
         m_height = m_heightUnit.fromUserValue(doubleHeight->value());
     }
     changeDocumentInfoLabel();
 }
 
 
 void KisCustomImageWidget::widthUnitChanged(int index)
 {
     doubleWidth->blockSignals(true);
 
     m_widthUnit = KoUnit::fromListForUi(index, KoUnit::ListAll);
     if (m_widthUnit.type() == KoUnit::Pixel) {
         doubleWidth->setDecimals(0);
         m_widthUnit.setFactor(doubleResolution->value() / 72.0);
     } else {
         doubleWidth->setDecimals(2);
     }
 
     doubleWidth->setValue(m_widthUnit.toUserValuePrecise(m_width));
 
     doubleWidth->blockSignals(false);
     changeDocumentInfoLabel();
 }
 
 void KisCustomImageWidget::widthChanged(double value)
 {
     m_width = m_widthUnit.fromUserValue(value);
     changeDocumentInfoLabel();
 }
 
 void KisCustomImageWidget::heightUnitChanged(int index)
 {
     doubleHeight->blockSignals(true);
 
     m_heightUnit = KoUnit::fromListForUi(index, KoUnit::ListAll);
     if (m_heightUnit.type() == KoUnit::Pixel) {
         doubleHeight->setDecimals(0);
         m_heightUnit.setFactor(doubleResolution->value() / 72.0);
     } else {
         doubleHeight->setDecimals(2);
     }
 
     doubleHeight->setValue(m_heightUnit.toUserValuePrecise(m_height));
 
     doubleHeight->blockSignals(false);
     changeDocumentInfoLabel();
 }
 
 void KisCustomImageWidget::heightChanged(double value)
 {
     m_height = m_heightUnit.fromUserValue(value);
     changeDocumentInfoLabel();
 }
 
 void KisCustomImageWidget::createImage()
 {
     newDialogConfirmationButtonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
     KisDocument *doc = createNewImage();
     if (doc) {
         doc->setModified(false);
         emit m_openPane->documentSelected(doc);
     }
 }
 
 KisDocument* KisCustomImageWidget::createNewImage()
 {
     const KoColorSpace * cs = colorSpaceSelector->currentColorSpace();
 
     if (cs->colorModelId() == RGBAColorModelID &&
         cs->colorDepthId() == Integer8BitsColorDepthID) {
 
         const KoColorProfile *profile = cs->profile();
 
         if (profile->name().contains("linear") ||
             profile->name().contains("scRGB") ||
             profile->info().contains("linear") ||
             profile->info().contains("scRGB")) {
 
             int result =
                 QMessageBox::warning(this,
                                      i18nc("@title:window", "Krita"),
                                      i18n("Linear gamma RGB color spaces are not supposed to be used "
                                           "in 8-bit integer modes. It is suggested to use 16-bit integer "
                                           "or any floating point colorspace for linear profiles.\n\n"
                                           "Press \"Ok\" to create a 8-bit integer linear RGB color space "
                                           "or \"Cancel\" to return to the settings dialog."),
                                      QMessageBox::Ok | QMessageBox::Cancel, QMessageBox::Cancel);
 
             if (result == QMessageBox::Cancel) {
                 dbgKrita << "Model RGB8" << "NOT SUPPORTED";
                 dbgKrita << ppVar(cs->name());
                 dbgKrita << ppVar(cs->profile()->name());
                 dbgKrita << ppVar(cs->profile()->info());
                 return 0;
             }
         }
     }
     KisDocument *doc = static_cast<KisDocument*>(KisPart::instance()->createDocument());
 
     qint32 width, height;
     double resolution;
     resolution = doubleResolution->value() / 72.0;  // internal resolution is in pixels per pt
 
     width = static_cast<qint32>(0.5  + KoUnit(KoUnit::Pixel, resolution).toUserValuePrecise(m_width));
     height = static_cast<qint32>(0.5 + KoUnit(KoUnit::Pixel, resolution).toUserValuePrecise(m_height));
 
     QColor qc = cmbColor->color().toQColor();
     qc.setAlpha(backgroundOpacity());
     KoColor bgColor(qc, cs);
 
     KisConfig::BackgroundStyle bgStyle = KisConfig::CANVAS_COLOR;
     if( radioBackgroundAsRaster->isChecked() ){
         bgStyle = KisConfig::RASTER_LAYER;
     } else if( radioBackgroundAsFill->isChecked() ){
         bgStyle = KisConfig::FILL_LAYER;
     }
 
     doc->newImage(txtName->text(), width, height, cs, bgColor, bgStyle, intNumLayers->value(), txtDescription->toPlainText(), resolution);
 
     KisConfig cfg(true);
     cfg.setNumDefaultLayers(intNumLayers->value());
     cfg.setDefaultBackgroundOpacity(backgroundOpacity());
     cfg.setDefaultBackgroundColor(cmbColor->color().toQColor());
     cfg.setDefaultBackgroundStyle(bgStyle);
 
     return doc;
 }
 
 void KisCustomImageWidget::setNumberOfLayers(int layers)
 {
     intNumLayers->setValue(layers);
 }
 
 quint8 KisCustomImageWidget::backgroundOpacity() const
 {
     qint32 opacity = sliderOpacity->value();
 
     if (!opacity)
         return 0;
 
     return (opacity * 255) / 100;
 }
 
 void KisCustomImageWidget::setBackgroundOpacity(quint8 value) {
   sliderOpacity->setValue((value * 100) / 255);
 }
 
 void KisCustomImageWidget::clipboardDataChanged()
 {
 }
 
 void KisCustomImageWidget::fillPredefined()
 {
     cmbPredefined->clear();
     m_predefined.clear();
 
     cmbPredefined->addItem("");
 
     QStringList definitions = KoResourcePaths::findAllResources("data", "predefined_image_sizes/*.predefinedimage", KoResourcePaths::Recursive);
     definitions.sort();
 
     if (!definitions.empty()) {
 
         Q_FOREACH (const QString &definition, definitions) {
             QFile f(definition);
             f.open(QIODevice::ReadOnly);
             if (f.exists()) {
                 QString xml = QString::fromUtf8(f.readAll());
                 KisPropertiesConfigurationSP predefined = new KisPropertiesConfiguration;
                 predefined->fromXML(xml);
                 if (predefined->hasProperty("name")
                         && predefined->hasProperty("width")
                         && predefined->hasProperty("height")
                         && predefined->hasProperty("resolution")
                         && predefined->hasProperty("x-unit")
                         && predefined->hasProperty("y-unit")) {
                     m_predefined << predefined;
                     cmbPredefined->addItem(predefined->getString("name"));
                 }
             }
         }
     }
 
     cmbPredefined->setCurrentIndex(0);
 
 }
 
 
 void KisCustomImageWidget::predefinedClicked(int index)
 {
     if (index < 1 || index > m_predefined.size()) return;
 
     KisPropertiesConfigurationSP predefined = m_predefined[index - 1];
     txtPredefinedName->setText(predefined->getString("name"));
     doubleResolution->setValue(predefined->getDouble("resolution"));
     cmbWidthUnit->setCurrentIndex(predefined->getInt("x-unit"));
     cmbHeightUnit->setCurrentIndex(predefined->getInt("y-unit"));
 
     widthUnitChanged(cmbWidthUnit->currentIndex());
     heightUnitChanged(cmbHeightUnit->currentIndex());
 
     doubleWidth->setValue(predefined->getDouble("width"));
     doubleHeight->setValue(predefined->getDouble("height"));
     changeDocumentInfoLabel();
 
 }
 
 void KisCustomImageWidget::saveAsPredefined()
 {
     QString fileName = txtPredefinedName->text();
     if (fileName.isEmpty()) {
         return;
     }
     QString saveLocation = KoResourcePaths::saveLocation("data", "predefined_image_sizes/", true);
     QFile f(saveLocation + '/' + fileName.replace(' ', '_').replace('(', '_').replace(')', '_').replace(':', '_') + ".predefinedimage");
 
     f.open(QIODevice::WriteOnly | QIODevice::Truncate);
     KisPropertiesConfigurationSP predefined = new KisPropertiesConfiguration();
     predefined->setProperty("name", txtPredefinedName->text());
     predefined->setProperty("width", doubleWidth->value());
     predefined->setProperty("height", doubleHeight->value());
     predefined->setProperty("resolution", doubleResolution->value());
     predefined->setProperty("x-unit", cmbWidthUnit->currentIndex());
     predefined->setProperty("y-unit", cmbHeightUnit->currentIndex());
 
     QString xml = predefined->toXML();
 
     f.write(xml.toUtf8());
     f.flush();
     f.close();
 
     int i = 0;
     bool found = false;
     Q_FOREACH (KisPropertiesConfigurationSP pr, m_predefined) {
         if (pr->getString("name") == txtPredefinedName->text()) {
             found = true;
             break;
         }
         ++i;
     }
     if (found) {
         m_predefined[i] = predefined;
     }
     else {
         m_predefined.append(predefined);
         cmbPredefined->addItem(txtPredefinedName->text());
     }
 
 }
 
 void KisCustomImageWidget::setLandscape()
 {
     if (doubleWidth->value() < doubleHeight->value()) {
         switchWidthHeight();
     }
 }
 
 void KisCustomImageWidget::setPortrait()
 {
     if (doubleWidth->value() > doubleHeight->value()) {
         switchWidthHeight();
     }
 }
 
 void KisCustomImageWidget::switchWidthHeight()
 {
     double width = doubleWidth->value();
     double height = doubleHeight->value();
 
     doubleHeight->clearFocus();
     doubleWidth->clearFocus();
 
     doubleHeight->blockSignals(true);
     doubleWidth->blockSignals(true);
     cmbWidthUnit->blockSignals(true);
     cmbHeightUnit->blockSignals(true);
 
     doubleWidth->setValue(height);
     doubleHeight->setValue(width);
     cmbWidthUnit->setCurrentIndex(m_heightUnit.indexInListForUi(KoUnit::ListAll));
     cmbHeightUnit->setCurrentIndex(m_widthUnit.indexInListForUi(KoUnit::ListAll));
 
     doubleHeight->blockSignals(false);
     doubleWidth->blockSignals(false);
     cmbWidthUnit->blockSignals(false);
     cmbHeightUnit->blockSignals(false);
     switchPortraitLandscape();
 
     widthChanged(doubleWidth->value());
     heightChanged(doubleHeight->value());
     changeDocumentInfoLabel();
 }
 
 void KisCustomImageWidget::switchPortraitLandscape()
 {
     if(doubleWidth->value() > doubleHeight->value())
         bnLandscape->setChecked(true);
     else
         bnPortrait->setChecked(true);
 }
 
 void KisCustomImageWidget::changeDocumentInfoLabel()
 {
 
     qint64 width, height;
     double resolution;
     resolution = doubleResolution->value() / 72.0;  // internal resolution is in pixels per pt
 
     width = static_cast<qint64>(0.5  + KoUnit(KoUnit::Pixel, resolution).toUserValuePrecise(m_width));
     height = static_cast<qint64>(0.5 + KoUnit(KoUnit::Pixel, resolution).toUserValuePrecise(m_height));
 
     qint64 layerSize = width * height;
     const KoColorSpace *cs = colorSpaceSelector->currentColorSpace();
     int bitSize = 8 * cs->pixelSize(); //pixelsize is in bytes.
     layerSize = layerSize * cs->pixelSize();
     QString text = i18nc("arg1: width. arg2: height. arg3: colorspace name. arg4: size of a channel in bits. arg5: image size",
                          "This document will be %1 pixels by %2 pixels in %3, which means the pixel size is %4 bit. A single paint layer will thus take up %5 of RAM.",
                          width,
                          height,
                          cs->name(),
                          bitSize,
                          KFormat().formatByteSize(layerSize));
     lblDocumentInfo->setText(text);
 }
 
diff --git a/libs/ui/widgets/kis_floating_message.cpp b/libs/ui/widgets/kis_floating_message.cpp
index c18a18862b..4dbe9ba964 100644
--- a/libs/ui/widgets/kis_floating_message.cpp
+++ b/libs/ui/widgets/kis_floating_message.cpp
@@ -1,340 +1,340 @@
 /*
  *  This file is part of KimageShop^WKrayon^WKrita
  *
  *  Copyright (c) 2012 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2004 Christian Muehlhaeuser <chris@chris.de>
  *  Copyright (c) 2004-2006 Seb Ruiz <ruiz@kde.org>
  *  Copyright (c) 2004,2005 Max Howell <max.howell@methylblue.com>
  *  Copyright (c) 2005 Gabor Lehel <illissius@gmail.com>
  *  Copyright (c) 2008,2009 Mark Kretschmann <kretschmann@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.
  */
 #include "kis_floating_message.h"
 
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QMouseEvent>
 #include <QPainter>
 #include <QTimer>
 #include <QRegExp>
 
 #include <kis_icon.h>
 #include <kis_debug.h>
 #include "kis_global.h"
 
 
 /* Code copied from kshadowengine.cpp
  *
  * Copyright (C) 2003 Laur Ivan <laurivan@eircom.net>
  *
  * Many thanks to:
  *  - Bernardo Hung <deciare@gta.igs.net> for the enhanced shadow
  *    algorithm (currently used)
  *  - Tim Jansen <tim@tjansen.de> for the API updates and fixes.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License version 2 as published by the Free Software Foundation.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 namespace ShadowEngine
 {
     // Not sure, doesn't work above 10
     static const int    MULTIPLICATION_FACTOR = 3;
     // Multiplication factor for pixels directly above, under, or next to the text
     static const double AXIS_FACTOR = 2.0;
     // Multiplication factor for pixels diagonal to the text
     static const double DIAGONAL_FACTOR = 0.1;
     // Self explanatory
     static const int    MAX_OPACITY = 200;
 
     double decay( QImage&, int, int );
 
     QImage makeShadow( const QPixmap& textPixmap, const QColor &bgColor )
     {
         const int w   = textPixmap.width();
         const int h   = textPixmap.height();
         const int bgr = bgColor.red();
         const int bgg = bgColor.green();
         const int bgb = bgColor.blue();
 
         int alphaShadow;
 
         // This is the source pixmap
         QImage img = textPixmap.toImage();
 
         QImage result( w, h, QImage::Format_ARGB32 );
         result.fill( 0 ); // fill with black
 
         static const int M = 5;
         for( int i = M; i < w - M; i++) {
             for( int j = M; j < h - M; j++ )
             {
                 alphaShadow = (int) decay( img, i, j );
 
                 result.setPixel( i,j, qRgba( bgr, bgg , bgb, qMin( MAX_OPACITY, alphaShadow ) ) );
             }
         }
 
         return result;
     }
 
     double decay( QImage& source, int i, int j )
     {
         double alphaShadow;
         alphaShadow =(qGray(source.pixel(i-1,j-1)) * DIAGONAL_FACTOR +
                 qGray(source.pixel(i-1,j  )) * AXIS_FACTOR +
                 qGray(source.pixel(i-1,j+1)) * DIAGONAL_FACTOR +
                 qGray(source.pixel(i  ,j-1)) * AXIS_FACTOR +
                 0                         +
                 qGray(source.pixel(i  ,j+1)) * AXIS_FACTOR +
                 qGray(source.pixel(i+1,j-1)) * DIAGONAL_FACTOR +
                 qGray(source.pixel(i+1,j  )) * AXIS_FACTOR +
                 qGray(source.pixel(i+1,j+1)) * DIAGONAL_FACTOR) / MULTIPLICATION_FACTOR;
 
         return alphaShadow;
     }
 }
 
 #define OSD_WINDOW_OPACITY 0.74
 
 KisFloatingMessage::KisFloatingMessage(const QString &message, QWidget *parent, bool showOverParent, int timeout, Priority priority, int alignment)
     : QWidget(parent)
     , m_message(message)
     , m_showOverParent(showOverParent)
     , m_timeout(timeout)
     , m_priority(priority)
     , m_alignment(alignment)
     , widgetQueuedForDeletion(false)
 {
-    m_icon = KisIconUtils::loadIcon("calligrakrita").pixmap(256, 256).toImage();
+    m_icon = KisIconUtils::loadIcon("krita").pixmap(256, 256).toImage();
 
     setWindowFlags(Qt::FramelessWindowHint | Qt::ToolTip);
     setFocusPolicy(Qt::NoFocus);
     setAttribute(Qt::WA_ShowWithoutActivating);
 
     setFont(QFont("sans-serif"));
 
     m_timer.setSingleShot( true );
     connect(&m_timer, SIGNAL(timeout()), SLOT(startFade()));
     connect(this, SIGNAL(destroyed()), SLOT(widgetDeleted()));
 }
 
 void KisFloatingMessage::tryOverrideMessage(const QString message,
                                             const QIcon& icon,
                                             int timeout,
                                             KisFloatingMessage::Priority priority,
                                             int alignment)
 {
     if ((int)priority > (int)m_priority) return;
 
     m_message = message;
     setIcon(icon);
     m_timeout = timeout;
     m_priority = priority;
     m_alignment = alignment;
     showMessage();
     update();
 }
 
 void KisFloatingMessage::showMessage()
 {
     if (widgetQueuedForDeletion) return;
 
     setGeometry(determineMetrics(fontMetrics().width('x')));
     setWindowOpacity(OSD_WINDOW_OPACITY);
 
     QWidget::setVisible(true);
     m_timer.start(m_timeout);
 }
 
 void KisFloatingMessage::setShowOverParent(bool show)
 {
     m_showOverParent = show;
 }
 
 void KisFloatingMessage::setIcon(const QIcon& icon)
 {
     m_icon = icon.pixmap(256, 256).toImage();
 }
 
 const int MARGIN = 20;
 
 QRect KisFloatingMessage::determineMetrics( const int M )
 {
     m_m = M;
 
     const QSize minImageSize = m_icon.size().boundedTo(QSize(100, 100));
 
     // determine a sensible maximum size, don't cover the whole desktop or cross the screen
     const QSize margin( (M + MARGIN) * 2, (M + MARGIN) * 2); //margins
     const QSize image = m_icon.isNull() ? QSize(0, 0) : minImageSize;
     const QSize max = QApplication::desktop()->availableGeometry(parentWidget()).size() - margin;
 
     // If we don't do that, the boundingRect() might not be suitable for drawText() (Qt issue N67674)
     m_message.replace(QRegExp( " +\n"), "\n");
     // remove consecutive line breaks
     m_message.replace(QRegExp( "\n+"), "\n");
 
     // The osd cannot be larger than the screen
     QRect rect = fontMetrics().boundingRect(0, 0, max.width() - image.width(), max.height(),
            m_alignment, m_message);
 
     if (!m_icon.isNull()) {
         const int availableWidth = max.width() - rect.width() - M; //WILL be >= (minImageSize.width() - M)
 
         m_scaledIcon = QPixmap::fromImage(m_icon.scaled(qMin(availableWidth, m_icon.width()),
                                                         qMin( rect.height(), m_icon.height()),
                                                         Qt::KeepAspectRatio, Qt::SmoothTransformation));
 
         const int widthIncludingImage = rect.width() + m_scaledIcon.width() + M; //margin between text + image
         rect.setWidth( widthIncludingImage );
     }
 
     // expand in all directions by 2*M
     //
     // take care with this rect, because it must be *bigger*
     // than the rect we paint the message in
     rect = kisGrowRect(rect, 2 * M);
 
 
 
     const QSize newSize = rect.size();
     QRect screen = QApplication::desktop()->screenGeometry(parentWidget());
 
     QPoint newPos(MARGIN, MARGIN);
 
     if (parentWidget() && m_showOverParent) {
         screen = parentWidget()->geometry();
         screen.setTopLeft(parentWidget()->mapToGlobal(QPoint(MARGIN, MARGIN + 50)));
         newPos = screen.topLeft();
     }
     else {
         // move to the right
         newPos.rx() = screen.width() - MARGIN - newSize.width();
 
         //ensure we don't dip below the screen
         if (newPos.y() + newSize.height() > screen.height() - MARGIN) {
             newPos.ry() = screen.height() - MARGIN - newSize.height();
         }
         // correct for screen position
         newPos += screen.topLeft();
 
         if (parentWidget()) {
             // Move a bit to the left as there could be a scrollbar
             newPos.setX(newPos.x() - MARGIN);
         }
     }
 
     QRect rc(newPos, rect.size());
 
     return rc;
 }
 
 void KisFloatingMessage::paintEvent( QPaintEvent *e )
 {
     const int& M = m_m;
 
     QPoint point;
     QRect rect(point, size());
     rect.adjust(0, 0, -1, -1);
 
     QPainter p(this);
     p.setRenderHints( QPainter::Antialiasing | QPainter::TextAntialiasing | QPainter::SmoothPixmapTransform | QPainter::HighQualityAntialiasing );
     p.setClipRect(e->rect());
 
     //QPixmap background = The::svgHandler()->renderSvgWithDividers( "service_list_item", width(), height(), "service_list_item" );
     //p.drawPixmap( 0, 0, background );
 
     p.setPen(Qt::white);
     rect.adjust(M, M, -M, -M);
 
     if (!m_icon.isNull()) {
         QRect r(rect);
         r.setTop((size().height() - m_scaledIcon.height() ) / 2);
         r.setSize(m_scaledIcon.size());
         p.drawPixmap(r.topLeft(), m_scaledIcon);
         rect.setLeft(rect.left() + m_scaledIcon.width() + M);
     }
 
     int graphicsHeight = 0;
 
     rect.setBottom(rect.bottom() - graphicsHeight);
 
     // Draw "shadow" text effect (black outline)
     QPixmap pixmap( rect.size() + QSize( 10, 10 ) );
     pixmap.fill( Qt::black );
 
     QPainter p2(&pixmap);
     p2.setFont(font());
     p2.setPen(Qt::white);
     p2.setBrush(Qt::white);
     p2.drawText(QRect( QPoint( 5, 5 ), rect.size() ), m_alignment, m_message);
     p2.end();
 
     QColor shadowColor;
     {
         int h, s, v;
         palette().color( QPalette::Normal, QPalette::Foreground ).getHsv( &h, &s, &v );
         shadowColor = v > 128 ? Qt::black : Qt::white;
     }
     p.drawImage(rect.topLeft() - QPoint(5, 5), ShadowEngine::makeShadow(pixmap, shadowColor));
 
     p.setPen( palette().color(QPalette::Active, QPalette::WindowText ));
     p.drawText(rect, m_alignment, m_message);
 }
 
 void KisFloatingMessage::startFade()
 {
     m_fadeTimeLine.setDuration(250);
     m_fadeTimeLine.setCurveShape(QTimeLine::EaseInCurve);
     m_fadeTimeLine.setLoopCount(1);
     m_fadeTimeLine.setFrameRange(0, 0);
     m_fadeTimeLine.setFrameRange(0, 10);
     connect(&m_fadeTimeLine, SIGNAL(finished()), SLOT(removeMessage()));
     connect(&m_fadeTimeLine, SIGNAL(frameChanged(int)), SLOT(updateOpacity(int)));
     m_fadeTimeLine.start();
 }
 
 void KisFloatingMessage::removeMessage()
 {
     m_timer.stop();
     m_fadeTimeLine.stop();
     widgetQueuedForDeletion = true;
 
     hide();
     deleteLater();
 }
 
 void KisFloatingMessage::updateOpacity(int /*value*/)
 {
     setWindowOpacity(OSD_WINDOW_OPACITY - 0.1);
 }
 
 void KisFloatingMessage::widgetDeleted()
 {
     widgetQueuedForDeletion = false;
 }
diff --git a/libs/ui/widgets/kis_paintop_presets_chooser_popup.cpp b/libs/ui/widgets/kis_paintop_presets_chooser_popup.cpp
index 16f345f313..beba8024af 100644
--- a/libs/ui/widgets/kis_paintop_presets_chooser_popup.cpp
+++ b/libs/ui/widgets/kis_paintop_presets_chooser_popup.cpp
@@ -1,165 +1,165 @@
 /* This file is part of the KDE project
  * Copyright (c) 2010 Sven Langkamp <sven.langkamp@gmail.com>
  * Copyright 2011 Srikanth Tiyyagura <srikanth.tulasiram@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "kis_paintop_presets_chooser_popup.h"
 
 #include <QToolButton>
 #include <QCompleter>
 #include <QMenu>
 #include <QWidgetAction>
 #include <QSlider>
 
 #include <resources/KoResource.h>
 #include <KoResourceItemChooser.h>
 
 #include <ui_wdgpaintoppresets.h>
 #include <kis_config.h>
 #include <KisResourceServerProvider.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <kis_icon.h>
 #include <brushengine/kis_paintop_settings.h>
 
 struct KisPaintOpPresetsChooserPopup::Private
 {
 public:
     Ui_WdgPaintOpPresets uiWdgPaintOpPresets;
     bool firstShown;
     QToolButton *viewModeButton;
 };
 
 KisPaintOpPresetsChooserPopup::KisPaintOpPresetsChooserPopup(QWidget * parent)
     : QWidget(parent)
     , m_d(new Private())
 {
     m_d->uiWdgPaintOpPresets.setupUi(this);
     QMenu* menu = new QMenu(this);
     menu->setStyleSheet("margin: 6px");
 
-    menu->addSection(i18n("Display"));
+    menu->addSection(i18nc("@title Which elements to display (e.g., thumbnails or details)", "Display"));
 
     QActionGroup *actionGroup = new QActionGroup(this);
 
     KisPresetChooser::ViewMode mode = (KisPresetChooser::ViewMode)KisConfig(true).presetChooserViewMode();
 
     QAction* action = menu->addAction(KisIconUtils::loadIcon("view-preview"), i18n("Thumbnails"), this, SLOT(slotThumbnailMode()));
     action->setCheckable(true);
     action->setChecked(mode == KisPresetChooser::THUMBNAIL);
     action->setActionGroup(actionGroup);
 
     action = menu->addAction(KisIconUtils::loadIcon("view-list-details"), i18n("Details"), this, SLOT(slotDetailMode()));
     action->setCheckable(true);
     action->setChecked(mode == KisPresetChooser::DETAIL);
     action->setActionGroup(actionGroup);
 
     // add widget slider to control icon size
     QSlider* iconSizeSlider = new QSlider(this);
     iconSizeSlider->setOrientation(Qt::Horizontal);
     iconSizeSlider->setRange(30, 80);
     iconSizeSlider->setValue(m_d->uiWdgPaintOpPresets.wdgPresetChooser->iconSize());
     iconSizeSlider->setMinimumHeight(20);
     iconSizeSlider->setMinimumWidth(40);
     iconSizeSlider->setTickInterval(10);
 
 
     QWidgetAction *sliderAction= new QWidgetAction(this);
     sliderAction->setDefaultWidget(iconSizeSlider);
 
     menu->addSection(i18n("Icon Size"));
     menu->addAction(sliderAction);
 
 
 
     // setting the view mode
     m_d->uiWdgPaintOpPresets.wdgPresetChooser->setViewMode(mode);
     m_d->uiWdgPaintOpPresets.wdgPresetChooser->showTaggingBar(true);
 
     m_d->uiWdgPaintOpPresets.wdgPresetChooser->itemChooser()->setViewModeButtonVisible(true);
     m_d->viewModeButton = m_d->uiWdgPaintOpPresets.wdgPresetChooser->itemChooser()->viewModeButton();
     m_d->viewModeButton->setMenu(menu);
     m_d->viewModeButton->setIcon(KisIconUtils::loadIcon("configure"));
 
 
     connect(m_d->uiWdgPaintOpPresets.wdgPresetChooser, SIGNAL(resourceSelected(KoResource*)),
             this, SIGNAL(resourceSelected(KoResource*)));
     connect(m_d->uiWdgPaintOpPresets.wdgPresetChooser, SIGNAL(resourceClicked(KoResource*)),
             this, SIGNAL(resourceClicked(KoResource*))) ;
 
 
     connect (iconSizeSlider, SIGNAL(sliderMoved(int)),
              m_d->uiWdgPaintOpPresets.wdgPresetChooser, SLOT(setIconSize(int)));
     connect( iconSizeSlider, SIGNAL(sliderReleased()),
              m_d->uiWdgPaintOpPresets.wdgPresetChooser, SLOT(saveIconSize()));
 
 
     m_d->firstShown = true;
 
 }
 
 KisPaintOpPresetsChooserPopup::~KisPaintOpPresetsChooserPopup()
 {
     delete m_d;
 }
 
 void KisPaintOpPresetsChooserPopup::slotThumbnailMode()
 {
     KisConfig(false).setPresetChooserViewMode(KisPresetChooser::THUMBNAIL);
     m_d->uiWdgPaintOpPresets.wdgPresetChooser->setViewMode(KisPresetChooser::THUMBNAIL);
 }
 
 void KisPaintOpPresetsChooserPopup::slotDetailMode()
 {
     KisConfig(false).setPresetChooserViewMode(KisPresetChooser::DETAIL);
     m_d->uiWdgPaintOpPresets.wdgPresetChooser->setViewMode(KisPresetChooser::DETAIL);
 }
 
 void KisPaintOpPresetsChooserPopup::paintEvent(QPaintEvent* event)
 {
     QWidget::paintEvent(event);
     //Workaround to get the column and row size right
     if(m_d->firstShown) {
         m_d->uiWdgPaintOpPresets.wdgPresetChooser->updateViewSettings();
         m_d->firstShown = false;
     }
 }
 
 void KisPaintOpPresetsChooserPopup::showButtons(bool show)
 {
     m_d->uiWdgPaintOpPresets.wdgPresetChooser->showButtons(show);
 }
 
 void KisPaintOpPresetsChooserPopup::canvasResourceChanged(KisPaintOpPresetSP  preset)
 {
     if (preset) {
         blockSignals(true);
         m_d->uiWdgPaintOpPresets.wdgPresetChooser->setCurrentResource(preset.data());
         blockSignals(false);
     }
     m_d->uiWdgPaintOpPresets.wdgPresetChooser->updateViewSettings();
 }
 
 void KisPaintOpPresetsChooserPopup::slotThemeChanged()
 {
     m_d->viewModeButton->setIcon(KisIconUtils::loadIcon("configure"));
 }
 
 void KisPaintOpPresetsChooserPopup::updateViewSettings()
 {
    m_d->uiWdgPaintOpPresets.wdgPresetChooser->updateViewSettings();
 }
diff --git a/libs/ui/widgets/kis_paintop_presets_popup.cpp b/libs/ui/widgets/kis_paintop_presets_popup.cpp
index 59679a93c0..f73d1d260b 100644
--- a/libs/ui/widgets/kis_paintop_presets_popup.cpp
+++ b/libs/ui/widgets/kis_paintop_presets_popup.cpp
@@ -1,850 +1,850 @@
 /* This file is part of the KDE project
  * Copyright (C) 2008 Boudewijn Rempt <boud@valdyas.org>
  * Copyright (C) 2010 Lukáš Tvrdý <lukast.dev@gmail.com>
  * Copyright (C) 2011 Silvio Heinrich <plassy@web.de>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "widgets/kis_paintop_presets_popup.h"
 
 #include <QList>
 #include <QComboBox>
 #include <QHBoxLayout>
 #include <QToolButton>
 #include <QGridLayout>
 #include <QFont>
 #include <QMenu>
 #include <QAction>
 #include <QShowEvent>
 #include <QFontDatabase>
 #include <QWidgetAction>
 #include <QDesktopWidget>
 
 #include <kconfig.h>
 #include <klocalizedstring.h>
 
 #include <KoDockRegistry.h>
 
 #include <kis_icon.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <brushengine/kis_paintop_config_widget.h>
 #include <kis_canvas_resource_provider.h>
 #include <widgets/kis_preset_chooser.h>
 #include <widgets/kis_preset_selector_strip.h>
 
 #include <ui_wdgpaintopsettings.h>
 #include <kis_node.h>
 #include "kis_config.h"
 
 #include "KisResourceServerProvider.h"
 #include "kis_lod_availability_widget.h"
 
 #include "kis_signal_auto_connection.h"
 #include <kis_paintop_settings_update_proxy.h>
 
 // ones from brush engine selector
 #include <brushengine/kis_paintop_factory.h>
 #include <kis_preset_live_preview_view.h>
 
 struct KisPaintOpPresetsPopup::Private
 {
 
 public:
 
     Ui_WdgPaintOpSettings uiWdgPaintOpPresetSettings;
     QGridLayout *layout;
     KisPaintOpConfigWidget *settingsWidget;
     QFont smallFont;
     KisCanvasResourceProvider *resourceProvider;
     KisFavoriteResourceManager *favoriteResManager;
 
     bool detached;
     bool ignoreHideEvents;
     bool isCreatingBrushFromScratch = false;
     QSize minimumSettingsWidgetSize;
     QRect detachedGeometry;
 
     KisSignalAutoConnectionsStore widgetConnections;
 };
 
 KisPaintOpPresetsPopup::KisPaintOpPresetsPopup(KisCanvasResourceProvider * resourceProvider,
                                                KisFavoriteResourceManager* favoriteResourceManager,
                                                KisPresetSaveWidget* savePresetWidget,
                                                QWidget * parent)
     : QWidget(parent)
     , m_d(new Private())
 {
     setObjectName("KisPaintOpPresetsPopup");
     setFont(KoDockRegistry::dockFont());
 
     current_paintOpId = "";
 
     m_d->resourceProvider = resourceProvider;
     m_d->favoriteResManager = favoriteResourceManager;
 
     m_d->uiWdgPaintOpPresetSettings.setupUi(this);
 
     m_d->layout = new QGridLayout(m_d->uiWdgPaintOpPresetSettings.frmOptionWidgetContainer);
     m_d->layout->setSizeConstraint(QLayout::SetFixedSize);
 
     m_d->uiWdgPaintOpPresetSettings.scratchPad->setupScratchPad(resourceProvider, Qt::white);
     m_d->uiWdgPaintOpPresetSettings.scratchPad->setCutoutOverlayRect(QRect(25, 25, 200, 200));
 
 
 
     m_d->uiWdgPaintOpPresetSettings.dirtyPresetIndicatorButton->setToolTip(i18n("The settings for this preset have changed from their default."));
 
 
     m_d->uiWdgPaintOpPresetSettings.showPresetsButton->setToolTip(i18n("Toggle showing presets"));
 
     m_d->uiWdgPaintOpPresetSettings.showScratchpadButton->setToolTip(i18n("Toggle showing scratchpad"));
 
     m_d->uiWdgPaintOpPresetSettings.reloadPresetButton->setToolTip(i18n("Reload the brush preset"));
     m_d->uiWdgPaintOpPresetSettings.renameBrushPresetButton->setToolTip(i18n("Rename the brush preset"));
 
 
     // creating a new preset from scratch. Part of the brush presets area
     // the menu options will get filled up later when we are generating all available paintops
     // in the filter drop-down
     newPresetBrushEnginesMenu = new QMenu();
 
     // overwrite existing preset and saving a new preset use the same dialog
     saveDialog = savePresetWidget;
     saveDialog->scratchPadSetup(resourceProvider);
     saveDialog->setFavoriteResourceManager(m_d->favoriteResManager); // this is needed when saving the preset
     saveDialog->hide();
 
     // the area on the brush editor for renaming the brush. make sure edit fields are hidden by default
     toggleBrushRenameUIActive(false);
 
 
     // DETAIL and THUMBNAIL view changer
     QMenu* menu = new QMenu(this);
 
     menu->setStyleSheet("margin: 6px");
-    menu->addSection(i18n("Display"));
+    menu->addSection(i18nc("@title Which elements to display (e.g., thumbnails or details)", "Display"));
 
     QActionGroup *actionGroup = new QActionGroup(this);
 
     KisPresetChooser::ViewMode mode = (KisPresetChooser::ViewMode)KisConfig(true).presetChooserViewMode();
 
     QAction* action = menu->addAction(KisIconUtils::loadIcon("view-preview"), i18n("Thumbnails"), m_d->uiWdgPaintOpPresetSettings.presetWidget, SLOT(slotThumbnailMode()));
     action->setCheckable(true);
     action->setChecked(mode == KisPresetChooser::THUMBNAIL);
     action->setActionGroup(actionGroup);
 
     action = menu->addAction(KisIconUtils::loadIcon("view-list-details"), i18n("Details"), m_d->uiWdgPaintOpPresetSettings.presetWidget, SLOT(slotDetailMode()));
     action->setCheckable(true);
     action->setChecked(mode == KisPresetChooser::DETAIL);
     action->setActionGroup(actionGroup);
 
 
     // add horizontal slider for the icon size
     QSlider* iconSizeSlider = new QSlider(this);
     iconSizeSlider->setOrientation(Qt::Horizontal);
     iconSizeSlider->setRange(30, 80);
     iconSizeSlider->setValue(m_d->uiWdgPaintOpPresetSettings.presetWidget->iconSize());
     iconSizeSlider->setMinimumHeight(20);
     iconSizeSlider->setMinimumWidth(40);
     iconSizeSlider->setTickInterval(10);
 
 
     QWidgetAction *sliderAction= new QWidgetAction(this);
     sliderAction->setDefaultWidget(iconSizeSlider);
 
     menu->addSection(i18n("Icon Size"));
     menu->addAction(sliderAction);
 
 
     // configure the button and assign menu
     m_d->uiWdgPaintOpPresetSettings.presetChangeViewToolButton->setMenu(menu);
 
     m_d->uiWdgPaintOpPresetSettings.presetChangeViewToolButton->setPopupMode(QToolButton::InstantPopup);
 
 
     // loading preset from scratch option
     m_d->uiWdgPaintOpPresetSettings.newPresetEngineButton->setPopupMode(QToolButton::InstantPopup);
 
 
     // show/hide buttons
 
     KisConfig cfg(true);
 
     m_d->uiWdgPaintOpPresetSettings.showScratchpadButton->setCheckable(true);
     m_d->uiWdgPaintOpPresetSettings.showScratchpadButton->setChecked(cfg.scratchpadVisible());
 
     if (cfg.scratchpadVisible()) {
         slotSwitchScratchpad(true); // show scratchpad
     } else {
         slotSwitchScratchpad(false);
     }
 
     m_d->uiWdgPaintOpPresetSettings.showPresetsButton->setCheckable(true);
     m_d->uiWdgPaintOpPresetSettings.showPresetsButton->setChecked(false);
     slotSwitchShowPresets(false); // hide presets by default
 
 
     // Connections
     connect(m_d->uiWdgPaintOpPresetSettings.paintPresetIcon, SIGNAL(clicked()),
             m_d->uiWdgPaintOpPresetSettings.scratchPad, SLOT(paintPresetImage()));
 
     connect(saveDialog, SIGNAL(resourceSelected(KoResource*)), this, SLOT(resourceSelected(KoResource*)));
 
     connect (m_d->uiWdgPaintOpPresetSettings.renameBrushPresetButton, SIGNAL(clicked(bool)),
              this, SLOT(slotRenameBrushActivated()));
 
     connect (m_d->uiWdgPaintOpPresetSettings.cancelBrushNameUpdateButton, SIGNAL(clicked(bool)),
              this, SLOT(slotRenameBrushDeactivated()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.updateBrushNameButton, SIGNAL(clicked(bool)),
             this, SLOT(slotSaveRenameCurrentBrush()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.renameBrushNameTextField, SIGNAL(returnPressed()),
             SLOT(slotSaveRenameCurrentBrush()));
 
     connect(iconSizeSlider, SIGNAL(sliderMoved(int)),
             m_d->uiWdgPaintOpPresetSettings.presetWidget, SLOT(slotSetIconSize(int)));
 
     connect(iconSizeSlider, SIGNAL(sliderReleased()),
             m_d->uiWdgPaintOpPresetSettings.presetWidget, SLOT(slotSaveIconSize()));
 
 
     connect(m_d->uiWdgPaintOpPresetSettings.showScratchpadButton, SIGNAL(clicked(bool)),
             this, SLOT(slotSwitchScratchpad(bool)));
 
 
     connect(m_d->uiWdgPaintOpPresetSettings.showPresetsButton, SIGNAL(clicked(bool)), this, SLOT(slotSwitchShowPresets(bool)));
 
     connect(m_d->uiWdgPaintOpPresetSettings.eraseScratchPad, SIGNAL(clicked()),
             m_d->uiWdgPaintOpPresetSettings.scratchPad, SLOT(fillDefault()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.fillLayer, SIGNAL(clicked()),
             m_d->uiWdgPaintOpPresetSettings.scratchPad, SLOT(fillLayer()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.fillGradient, SIGNAL(clicked()),
             m_d->uiWdgPaintOpPresetSettings.scratchPad, SLOT(fillGradient()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.fillSolid, SIGNAL(clicked()),
             m_d->uiWdgPaintOpPresetSettings.scratchPad, SLOT(fillBackground()));
 
 
     m_d->settingsWidget = 0;
     setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed));
 
     connect(m_d->uiWdgPaintOpPresetSettings.saveBrushPresetButton, SIGNAL(clicked()),
             this, SLOT(slotSaveBrushPreset()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.saveNewBrushPresetButton, SIGNAL(clicked()),
             this, SLOT(slotSaveNewBrushPreset()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.reloadPresetButton, SIGNAL(clicked()),
             this, SIGNAL(reloadPresetClicked()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.dirtyPresetCheckBox, SIGNAL(toggled(bool)),
             this, SIGNAL(dirtyPresetToggled(bool)));
 
     connect(m_d->uiWdgPaintOpPresetSettings.eraserBrushSizeCheckBox, SIGNAL(toggled(bool)),
             this, SIGNAL(eraserBrushSizeToggled(bool)));
 
     connect(m_d->uiWdgPaintOpPresetSettings.eraserBrushOpacityCheckBox, SIGNAL(toggled(bool)),
             this, SIGNAL(eraserBrushOpacityToggled(bool)));
 
 
     // preset widget connections
     connect(m_d->uiWdgPaintOpPresetSettings.presetWidget->smallPresetChooser, SIGNAL(resourceSelected(KoResource*)),
             this, SIGNAL(signalResourceSelected(KoResource*)));
 
     connect(m_d->uiWdgPaintOpPresetSettings.reloadPresetButton, SIGNAL(clicked()),
             m_d->uiWdgPaintOpPresetSettings.presetWidget->smallPresetChooser, SLOT(updateViewSettings()));
 
 
 
     connect(m_d->uiWdgPaintOpPresetSettings.reloadPresetButton, SIGNAL(clicked()), SLOT(slotUpdatePresetSettings()));
 
     m_d->detached = false;
     m_d->ignoreHideEvents = false;
     m_d->minimumSettingsWidgetSize = QSize(0, 0);
 
     m_d->detachedGeometry = QRect(100, 100, 0, 0);
     m_d->uiWdgPaintOpPresetSettings.dirtyPresetCheckBox->setChecked(cfg.useDirtyPresets());
     m_d->uiWdgPaintOpPresetSettings.eraserBrushSizeCheckBox->setChecked(cfg.useEraserBrushSize());
     m_d->uiWdgPaintOpPresetSettings.eraserBrushOpacityCheckBox->setChecked(cfg.useEraserBrushOpacity());
 
     m_d->uiWdgPaintOpPresetSettings.wdgLodAvailability->setCanvasResourceManager(resourceProvider->resourceManager());
 
     connect(resourceProvider->resourceManager(),
             SIGNAL(canvasResourceChanged(int,QVariant)),
             SLOT(slotResourceChanged(int,QVariant)));
 
     connect(m_d->uiWdgPaintOpPresetSettings.wdgLodAvailability,
             SIGNAL(sigUserChangedLodAvailability(bool)),
             SLOT(slotLodAvailabilityChanged(bool)));
 
     connect(m_d->uiWdgPaintOpPresetSettings.wdgLodAvailability,
             SIGNAL(sigUserChangedLodThreshold(qreal)),
             SLOT(slotLodThresholdChanged(qreal)));
 
     slotResourceChanged(KisCanvasResourceProvider::LodAvailability,
                         resourceProvider->resourceManager()->
                         resource(KisCanvasResourceProvider::LodAvailability));
 
     slotResourceChanged(KisCanvasResourceProvider::LodSizeThreshold,
                         resourceProvider->resourceManager()->
                         resource(KisCanvasResourceProvider::LodSizeThreshold));
 
     connect(m_d->uiWdgPaintOpPresetSettings.brushEgineComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(slotUpdatePaintOpFilter()));
 
 
     connect(m_d->uiWdgPaintOpPresetSettings.bnBlacklistPreset, SIGNAL(clicked()), this, SLOT(slotBlackListCurrentPreset()));
 
     updateThemedIcons();
 
     // setup things like the scene construct images, layers, etc that is a one-time thing
     m_d->uiWdgPaintOpPresetSettings.liveBrushPreviewView->setup();
 
 }
 
 void KisPaintOpPresetsPopup::slotBlackListCurrentPreset()
 {
     KisPaintOpPresetResourceServer * rServer = KisResourceServerProvider::instance()->paintOpPresetServer();
     KisPaintOpPresetSP curPreset = m_d->resourceProvider->currentPreset();
 
     if (rServer->resourceByName(curPreset->name())) {
         rServer->removeResourceAndBlacklist(curPreset);
     }
 }
 
 
 void KisPaintOpPresetsPopup::slotRenameBrushActivated()
 {
     toggleBrushRenameUIActive(true);
 }
 
 void KisPaintOpPresetsPopup::slotRenameBrushDeactivated()
 {
     toggleBrushRenameUIActive(false);
 }
 
 void KisPaintOpPresetsPopup::toggleBrushRenameUIActive(bool isRenaming)
 {
     // This function doesn't really do anything except get the UI in a state to rename a brush preset
     m_d->uiWdgPaintOpPresetSettings.renameBrushNameTextField->setVisible(isRenaming);
     m_d->uiWdgPaintOpPresetSettings.updateBrushNameButton->setVisible(isRenaming);
     m_d->uiWdgPaintOpPresetSettings.cancelBrushNameUpdateButton->setVisible(isRenaming);
 
 
     // hide these below areas while renaming
     m_d->uiWdgPaintOpPresetSettings.currentBrushNameLabel->setVisible(!isRenaming);
     m_d->uiWdgPaintOpPresetSettings.renameBrushPresetButton->setVisible(!isRenaming);
     m_d->uiWdgPaintOpPresetSettings.saveBrushPresetButton->setEnabled(!isRenaming);
     m_d->uiWdgPaintOpPresetSettings.saveBrushPresetButton->setVisible(!isRenaming);
     m_d->uiWdgPaintOpPresetSettings.saveNewBrushPresetButton->setEnabled(!isRenaming);
     m_d->uiWdgPaintOpPresetSettings.saveNewBrushPresetButton->setVisible(!isRenaming);
 
     // if the presets area is shown, only then can you show/hide the load default brush
     // need to think about weird state when you are in the middle of renaming a brush
     // what happens if you try to change presets. maybe we should auto-hide (or disable)
     // the presets area in this case
     if (m_d->uiWdgPaintOpPresetSettings.presetWidget->isVisible()) {
         m_d->uiWdgPaintOpPresetSettings.newPresetEngineButton->setVisible(!isRenaming);
         m_d->uiWdgPaintOpPresetSettings.bnBlacklistPreset->setVisible(!isRenaming);
     }
 
 }
 
 void KisPaintOpPresetsPopup::slotSaveRenameCurrentBrush()
 {
     // if you are renaming a brush, that is different than updating the settings
     // make sure we are in a clean state before renaming. This logic might change,
     // but that is what we are going with for now
     emit reloadPresetClicked();
 
 
     m_d->favoriteResManager->setBlockUpdates(true);
 
     // get a reference to the existing (and new) file name and path that we are working with
     KisPaintOpPresetSP curPreset = m_d->resourceProvider->currentPreset();
 
     if (!curPreset)
         return;
 
     KisPaintOpPresetResourceServer * rServer = KisResourceServerProvider::instance()->paintOpPresetServer();
     QString saveLocation = rServer->saveLocation();
 
     QString originalPresetName = curPreset->name();
     QString renamedPresetName = m_d->uiWdgPaintOpPresetSettings.renameBrushNameTextField->text();
     QString originalPresetPathAndFile = saveLocation + originalPresetName + curPreset->defaultFileExtension();
     QString renamedPresetPathAndFile = saveLocation + renamedPresetName + curPreset->defaultFileExtension();
 
 
     // create a new brush preset with the name specified and add to resource provider
     KisPaintOpPresetSP newPreset = curPreset->clone();
     newPreset->setFilename(renamedPresetPathAndFile); // this also contains the path
     newPreset->setName(renamedPresetName);
     newPreset->setImage(curPreset->image()); // use existing thumbnail (might not need to do this)
     newPreset->setDirty(false);
     newPreset->setValid(true);
     rServer->addResource(newPreset);
 
     resourceSelected(newPreset.data()); // refresh and select our freshly renamed resource
 
 
     // Now blacklist the original file
     if (rServer->resourceByName(originalPresetName)) {
         rServer->removeResourceAndBlacklist(curPreset);
     }
 
     m_d->favoriteResManager->setBlockUpdates(false);
 
     toggleBrushRenameUIActive(false); // this returns the UI to its original state after saving
 
     slotUpdatePresetSettings(); // update visibility of dirty preset and icon
 }
 
 void KisPaintOpPresetsPopup::slotResourceChanged(int key, const QVariant &value)
 {
     if (key == KisCanvasResourceProvider::LodAvailability) {
         m_d->uiWdgPaintOpPresetSettings.wdgLodAvailability->slotUserChangedLodAvailability(value.toBool());
     } else if (key == KisCanvasResourceProvider::LodSizeThreshold) {
         m_d->uiWdgPaintOpPresetSettings.wdgLodAvailability->slotUserChangedLodThreshold(value.toDouble());
     } else if (key == KisCanvasResourceProvider::Size) {
         m_d->uiWdgPaintOpPresetSettings.wdgLodAvailability->slotUserChangedSize(value.toDouble());
     }
 }
 
 void KisPaintOpPresetsPopup::slotLodAvailabilityChanged(bool value)
 {
     m_d->resourceProvider->resourceManager()->setResource(KisCanvasResourceProvider::LodAvailability, QVariant(value));
 }
 
 void KisPaintOpPresetsPopup::slotLodThresholdChanged(qreal value)
 {
     m_d->resourceProvider->resourceManager()->setResource(KisCanvasResourceProvider::LodSizeThreshold, QVariant(value));
 }
 
 KisPaintOpPresetsPopup::~KisPaintOpPresetsPopup()
 {
     if (m_d->settingsWidget) {
         m_d->layout->removeWidget(m_d->settingsWidget);
         m_d->settingsWidget->hide();
         m_d->settingsWidget->setParent(0);
         m_d->settingsWidget = 0;
     }
     delete m_d;
     delete newPresetBrushEnginesMenu;
 }
 
 void KisPaintOpPresetsPopup::setPaintOpSettingsWidget(QWidget * widget)
 {
     if (m_d->settingsWidget) {
         m_d->layout->removeWidget(m_d->settingsWidget);
         m_d->uiWdgPaintOpPresetSettings.frmOptionWidgetContainer->updateGeometry();
     }
     m_d->layout->update();
     updateGeometry();
 
     m_d->widgetConnections.clear();
     m_d->settingsWidget = 0;
 
     if (widget) {
 
         m_d->settingsWidget = dynamic_cast<KisPaintOpConfigWidget*>(widget);
         KIS_ASSERT_RECOVER_RETURN(m_d->settingsWidget);
 
         KisConfig cfg(true);
         if (m_d->settingsWidget->supportScratchBox() && cfg.scratchpadVisible()) {
             slotSwitchScratchpad(true);
         } else {
             slotSwitchScratchpad(false);
         }
 
         m_d->widgetConnections.addConnection(m_d->settingsWidget, SIGNAL(sigConfigurationItemChanged()),
                                              this, SLOT(slotUpdateLodAvailability()));
 
         widget->setFont(m_d->smallFont);
 
         QSize hint = widget->sizeHint();
         m_d->minimumSettingsWidgetSize = QSize(qMax(hint.width(), m_d->minimumSettingsWidgetSize.width()),
                                                qMax(hint.height(), m_d->minimumSettingsWidgetSize.height()));
         widget->setMinimumSize(m_d->minimumSettingsWidgetSize);
         m_d->layout->addWidget(widget);
 
         // hook up connections that will monitor if our preset is dirty or not. Show a notification if it is
         if (m_d->resourceProvider && m_d->resourceProvider->currentPreset() ) {
 
             KisPaintOpPresetSP preset = m_d->resourceProvider->currentPreset();
             m_d->widgetConnections.addConnection(preset->updateProxy(), SIGNAL(sigSettingsChanged()),
                                                  this, SLOT(slotUpdatePresetSettings()));
         }
 
         m_d->layout->update();
         widget->show();
 
     }
     slotUpdateLodAvailability();
 }
 
 void KisPaintOpPresetsPopup::slotUpdateLodAvailability()
 {
     if (!m_d->settingsWidget) return;
 
     KisPaintopLodLimitations l = m_d->settingsWidget->lodLimitations();
     m_d->uiWdgPaintOpPresetSettings.wdgLodAvailability->setLimitations(l);
 }
 
 QImage KisPaintOpPresetsPopup::cutOutOverlay()
 {
     return m_d->uiWdgPaintOpPresetSettings.scratchPad->cutoutOverlay();
 }
 
 void KisPaintOpPresetsPopup::contextMenuEvent(QContextMenuEvent *e)
 {
     Q_UNUSED(e);
 }
 
 void KisPaintOpPresetsPopup::switchDetached(bool show)
 {
     if (parentWidget()) {
 
         m_d->detached = !m_d->detached;
 
         if (m_d->detached) {
             m_d->ignoreHideEvents = true;
 
             if (show) {
                 parentWidget()->show();
             }
             m_d->ignoreHideEvents = false;
 
         }
         else {
             parentWidget()->hide();
         }
 
         KisConfig cfg(false);
         cfg.setPaintopPopupDetached(m_d->detached);
     }
 }
 
 void KisPaintOpPresetsPopup::setCreatingBrushFromScratch(bool enabled)
 {
     m_d->isCreatingBrushFromScratch = enabled;
 }
 
 void KisPaintOpPresetsPopup::resourceSelected(KoResource* resource)
 {
     // this gets called every time the brush editor window is opened
     // TODO: this gets called multiple times whenever the preset is changed in the presets area
     // the connections probably need to be thought about with this a bit more to keep things in sync
 
     m_d->uiWdgPaintOpPresetSettings.presetWidget->smallPresetChooser->setCurrentResource(resource);
 
     // find the display name of the brush engine and append it to the selected preset display
     QString currentBrushEngineName;
     QPixmap currentBrushEngineIcon = QPixmap(26, 26);
     currentBrushEngineIcon.fill(Qt::transparent);
     for(int i=0; i < sortedBrushEnginesList.length(); i++) {
         if (sortedBrushEnginesList.at(i).id == currentPaintOpId() ) {
             currentBrushEngineName = sortedBrushEnginesList.at(i).name;
             currentBrushEngineIcon = sortedBrushEnginesList.at(i).icon.pixmap(26, 26);
         }
     }
 
     // brush names have underscores as part of the file name (to help with building). We don't really need underscores
     // when viewing the names, so replace them with spaces
     QString formattedBrushName = resource->name().replace("_", " ");
 
     m_d->uiWdgPaintOpPresetSettings.currentBrushNameLabel->setText(formattedBrushName);
     m_d->uiWdgPaintOpPresetSettings.currentBrushEngineLabel->setText(i18nc("%1 is the name of a brush engine", "%1 Engine", currentBrushEngineName));
     m_d->uiWdgPaintOpPresetSettings.currentBrushEngineIcon->setPixmap(currentBrushEngineIcon);
     m_d->uiWdgPaintOpPresetSettings.renameBrushNameTextField->setText(resource->name()); // use file name
 
     // get the preset image and pop it into the thumbnail area on the top of the brush editor
     m_d->uiWdgPaintOpPresetSettings.presetThumbnailicon->setPixmap(QPixmap::fromImage(resource->image().scaled(55, 55, Qt::KeepAspectRatio, Qt::SmoothTransformation)));
 
     toggleBrushRenameUIActive(false); // reset the UI state of renaming a brush if we are changing brush presets
     slotUpdatePresetSettings(); // check to see if the dirty preset icon needs to be shown
 }
 
 bool variantLessThan(const KisPaintOpInfo v1, const KisPaintOpInfo v2)
 {
     return v1.priority < v2.priority;
 }
 
 void KisPaintOpPresetsPopup::setPaintOpList(const QList< KisPaintOpFactory* >& list)
 {
     m_d->uiWdgPaintOpPresetSettings.brushEgineComboBox->clear(); // reset combobox list just in case
 
 
     // create a new list so we can sort it and populate the brush engine combo box
     sortedBrushEnginesList.clear(); // just in case this function is called again, don't keep adding to the list
 
     for(int i=0; i < list.length(); i++) {
         KisPaintOpInfo paintOpInfo;
         paintOpInfo.id = list.at(i)->id();
         paintOpInfo.name = list.at(i)->name();
         paintOpInfo.icon = list.at(i)->icon();
         paintOpInfo.priority = list.at(i)->priority();
 
         sortedBrushEnginesList.append(paintOpInfo);
     }
 
     std::stable_sort(sortedBrushEnginesList.begin(), sortedBrushEnginesList.end(), variantLessThan );
 
     // add an "All" option at the front to show all presets
     QPixmap emptyPixmap = QPixmap(22,22);
     emptyPixmap.fill(Qt::transparent);
 
     // if we create a new brush from scratch, we need a full list of paintops to choose from
     // we don't want "All", so populate the list before that is added
     newPresetBrushEnginesMenu->actions().clear(); // clean out list in case we run this again
     newBrushEngineOptions.clear();
 
     for (int j = 0; j < sortedBrushEnginesList.length(); j++) {
         KisAction * newEngineAction = static_cast<KisAction*>( newPresetBrushEnginesMenu->addAction(sortedBrushEnginesList[j].name));
         newEngineAction->setObjectName(sortedBrushEnginesList[j].id); // we need the ID for changing the paintop when action triggered
         newEngineAction->setIcon(sortedBrushEnginesList[j].icon);
         newBrushEngineOptions.append(newEngineAction);
         connect(newEngineAction, SIGNAL(triggered()), this, SLOT(slotCreateNewBrushPresetEngine()));
     }
     m_d->uiWdgPaintOpPresetSettings.newPresetEngineButton->setMenu(newPresetBrushEnginesMenu);
 
     // fill the list into the brush combo box
     sortedBrushEnginesList.push_front(KisPaintOpInfo(QString("all_options"), i18n("All"), QString(""), QIcon(emptyPixmap), 0 ));
     for (int m = 0; m < sortedBrushEnginesList.length(); m++) {
         m_d->uiWdgPaintOpPresetSettings.brushEgineComboBox->addItem(sortedBrushEnginesList[m].icon, sortedBrushEnginesList[m].name, QVariant(sortedBrushEnginesList[m].id));
     }
 }
 
 
 void KisPaintOpPresetsPopup::setCurrentPaintOpId(const QString& paintOpId)
 {
     current_paintOpId = paintOpId;
 }
 
 
 QString KisPaintOpPresetsPopup::currentPaintOpId() {
     return current_paintOpId;
 }
 
 void KisPaintOpPresetsPopup::setPresetImage(const QImage& image)
 {
     m_d->uiWdgPaintOpPresetSettings.scratchPad->setPresetImage(image);
     saveDialog->brushPresetThumbnailWidget->setPresetImage(image);
 }
 
 void KisPaintOpPresetsPopup::hideEvent(QHideEvent *event)
 {
     if (m_d->ignoreHideEvents) {
         return;
     }
     if (m_d->detached) {
         m_d->detachedGeometry = window()->geometry();
     }
     QWidget::hideEvent(event);
 }
 
 void KisPaintOpPresetsPopup::showEvent(QShowEvent *)
 {
     if (m_d->detached) {
         window()->setGeometry(m_d->detachedGeometry);
     }
 
     emit brushEditorShown();
 }
 
 void KisPaintOpPresetsPopup::resizeEvent(QResizeEvent* event)
 {
     QWidget::resizeEvent(event);
     if (parentWidget()) {
         // Make sure resizing doesn't push this widget out of the screen
         QRect screenRect = QApplication::desktop()->availableGeometry(this);
         QRect newPositionRect = kisEnsureInRect(parentWidget()->geometry(), screenRect);
         parentWidget()->setGeometry(newPositionRect);
     }
 }
 
 bool KisPaintOpPresetsPopup::detached() const
 {
     return m_d->detached;
 }
 
 void KisPaintOpPresetsPopup::slotSwitchScratchpad(bool visible)
 {
     // hide all the internal controls except the toggle button
     m_d->uiWdgPaintOpPresetSettings.scratchPad->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.paintPresetIcon->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.fillGradient->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.fillLayer->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.fillSolid->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.eraseScratchPad->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.scratchpadSidebarLabel->setVisible(visible);
 
     if (visible) {
         m_d->uiWdgPaintOpPresetSettings.showScratchpadButton->setIcon(KisIconUtils::loadIcon("arrow-left"));
     } else {
         m_d->uiWdgPaintOpPresetSettings.showScratchpadButton->setIcon(KisIconUtils::loadIcon("arrow-right"));
     }
 
     KisConfig cfg(false);
     cfg.setScratchpadVisible(visible);
 }
 
 void KisPaintOpPresetsPopup::slotSwitchShowEditor(bool visible) {
     m_d->uiWdgPaintOpPresetSettings.brushEditorSettingsControls->setVisible(visible);
 }
 
 void KisPaintOpPresetsPopup::slotSwitchShowPresets(bool visible) {
 
     m_d->uiWdgPaintOpPresetSettings.presetWidget->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.presetChangeViewToolButton->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.brushEgineComboBox->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.engineFilterLabel->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.presetsSidebarLabel->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.newPresetEngineButton->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.bnBlacklistPreset->setVisible(visible);
 
     // we only want a spacer to work when the toggle icon is present. Otherwise the list of presets will shrink
     // which is something we don't want
     if (visible) {
         m_d->uiWdgPaintOpPresetSettings.presetsSpacer->changeSize(0,0, QSizePolicy::Ignored,QSizePolicy::Ignored);
         m_d->uiWdgPaintOpPresetSettings.showPresetsButton->setIcon(KisIconUtils::loadIcon("arrow-right"));
     } else {
         m_d->uiWdgPaintOpPresetSettings.presetsSpacer->changeSize(0,0, QSizePolicy::MinimumExpanding,QSizePolicy::MinimumExpanding);
         m_d->uiWdgPaintOpPresetSettings.showPresetsButton->setIcon(KisIconUtils::loadIcon("arrow-left"));
     }
 
 }
 
 void KisPaintOpPresetsPopup::slotUpdatePaintOpFilter() {
     QVariant userData = m_d->uiWdgPaintOpPresetSettings.brushEgineComboBox->currentData(); // grab paintOpID from data
     QString filterPaintOpId = userData.toString();
 
     if (filterPaintOpId == "all_options") {
         filterPaintOpId = "";
     }
     m_d->uiWdgPaintOpPresetSettings.presetWidget->setPresetFilter(filterPaintOpId);
 }
 
 void KisPaintOpPresetsPopup::slotSaveBrushPreset() {
     // here we are assuming that people want to keep their existing preset icon. We will just update the
     // settings and save a new copy with the same name.
     // there is a dialog with save options, but we don't need to show it in this situation
 
     saveDialog->useNewBrushDialog(false); // this mostly just makes sure we keep the existing brush preset name when saving
     saveDialog->loadExistingThumbnail(); // This makes sure we use the existing preset icon when updating the existing brush preset
     saveDialog->savePreset();
 
     // refresh the view settings so the brush doesn't appear dirty
     slotUpdatePresetSettings();
 }
 
 void KisPaintOpPresetsPopup::slotSaveNewBrushPreset() {
     saveDialog->useNewBrushDialog(true);
     saveDialog->saveScratchPadThumbnailArea(m_d->uiWdgPaintOpPresetSettings.scratchPad->cutoutOverlay());
     saveDialog->showDialog();
 }
 
 void KisPaintOpPresetsPopup::slotCreateNewBrushPresetEngine()
 {
     emit createPresetFromScratch(sender()->objectName());
 }
 
 void KisPaintOpPresetsPopup::updateViewSettings()
 {
     m_d->uiWdgPaintOpPresetSettings.presetWidget->smallPresetChooser->updateViewSettings();
 }
 
 void KisPaintOpPresetsPopup::currentPresetChanged(KisPaintOpPresetSP preset)
 {
     if (preset) {
         m_d->uiWdgPaintOpPresetSettings.presetWidget->smallPresetChooser->setCurrentResource(preset.data());
         setCurrentPaintOpId(preset->paintOp().id());
     }
 }
 
 void KisPaintOpPresetsPopup::updateThemedIcons()
 {
     m_d->uiWdgPaintOpPresetSettings.paintPresetIcon->setIcon(KisIconUtils::loadIcon("krita_tool_freehand"));
     m_d->uiWdgPaintOpPresetSettings.fillLayer->setIcon(KisIconUtils::loadIcon("document-new"));
     m_d->uiWdgPaintOpPresetSettings.fillLayer->hide();
     m_d->uiWdgPaintOpPresetSettings.fillGradient->setIcon(KisIconUtils::loadIcon("krita_tool_gradient"));
     m_d->uiWdgPaintOpPresetSettings.fillSolid->setIcon(KisIconUtils::loadIcon("krita_tool_color_fill"));
     m_d->uiWdgPaintOpPresetSettings.eraseScratchPad->setIcon(KisIconUtils::loadIcon("edit-delete"));
 
     m_d->uiWdgPaintOpPresetSettings.newPresetEngineButton->setIcon(KisIconUtils::loadIcon("addlayer"));
     m_d->uiWdgPaintOpPresetSettings.bnBlacklistPreset->setIcon(KisIconUtils::loadIcon("deletelayer"));
     m_d->uiWdgPaintOpPresetSettings.reloadPresetButton->setIcon(KisIconUtils::loadIcon("updateColorize")); // refresh icon
     m_d->uiWdgPaintOpPresetSettings.renameBrushPresetButton->setIcon(KisIconUtils::loadIcon("dirty-preset")); // edit icon
     m_d->uiWdgPaintOpPresetSettings.dirtyPresetIndicatorButton->setIcon(KisIconUtils::loadIcon("warning"));
 
     m_d->uiWdgPaintOpPresetSettings.newPresetEngineButton->setIcon(KisIconUtils::loadIcon("addlayer"));
     m_d->uiWdgPaintOpPresetSettings.bnBlacklistPreset->setIcon(KisIconUtils::loadIcon("deletelayer"));
     m_d->uiWdgPaintOpPresetSettings.presetChangeViewToolButton->setIcon(KisIconUtils::loadIcon("configure"));
 
     // if we cannot see the "Preset label", we know it is not visible
     // maybe this can also be stored in the config like the scratchpad?
     if (m_d->uiWdgPaintOpPresetSettings.presetsSidebarLabel->isVisible()) {
         m_d->uiWdgPaintOpPresetSettings.presetsSpacer->changeSize(0,0, QSizePolicy::Ignored,QSizePolicy::Ignored);
         m_d->uiWdgPaintOpPresetSettings.showPresetsButton->setIcon(KisIconUtils::loadIcon("arrow-right"));
     } else {
         m_d->uiWdgPaintOpPresetSettings.presetsSpacer->changeSize(0,0, QSizePolicy::MinimumExpanding,QSizePolicy::MinimumExpanding);
         m_d->uiWdgPaintOpPresetSettings.showPresetsButton->setIcon(KisIconUtils::loadIcon("arrow-left"));
     }
 
     // we store whether the scratchpad if visible in the config.
     KisConfig cfg(true);
     if (cfg.scratchpadVisible()) {
         m_d->uiWdgPaintOpPresetSettings.showScratchpadButton->setIcon(KisIconUtils::loadIcon("arrow-left"));
     } else {
         m_d->uiWdgPaintOpPresetSettings.showScratchpadButton->setIcon(KisIconUtils::loadIcon("arrow-right"));
     }
 }
 
 void KisPaintOpPresetsPopup::slotUpdatePresetSettings()
 {
     if (!m_d->resourceProvider) {
         return;
     }
 
     if (!m_d->resourceProvider->currentPreset()) {
         return;
     }
 
     // hide options on UI if we are creating a brush preset from scratch to prevent confusion
     if (m_d->isCreatingBrushFromScratch) {
         m_d->uiWdgPaintOpPresetSettings.dirtyPresetIndicatorButton->setVisible(false);
         m_d->uiWdgPaintOpPresetSettings.reloadPresetButton->setVisible(false);
         m_d->uiWdgPaintOpPresetSettings.saveBrushPresetButton->setVisible(false);
         m_d->uiWdgPaintOpPresetSettings.renameBrushPresetButton->setVisible(false);
     } else {
         bool isPresetDirty = m_d->resourceProvider->currentPreset()->isDirty();
 
         // don't need to reload or overwrite a clean preset
         m_d->uiWdgPaintOpPresetSettings.dirtyPresetIndicatorButton->setVisible(isPresetDirty);
         m_d->uiWdgPaintOpPresetSettings.reloadPresetButton->setVisible(isPresetDirty);
         m_d->uiWdgPaintOpPresetSettings.saveBrushPresetButton->setEnabled(isPresetDirty);
         m_d->uiWdgPaintOpPresetSettings.renameBrushPresetButton->setVisible(true);
     }
 
     // update live preview area in here...
     // don't update the live preview if the widget is not visible.
     if (m_d->uiWdgPaintOpPresetSettings.liveBrushPreviewView->isVisible()) {
         m_d->uiWdgPaintOpPresetSettings.liveBrushPreviewView->setCurrentPreset(m_d->resourceProvider->currentPreset());
         m_d->uiWdgPaintOpPresetSettings.liveBrushPreviewView->updateStroke();
     }
 }
diff --git a/libs/ui/widgets/kis_preset_live_preview_view.cpp b/libs/ui/widgets/kis_preset_live_preview_view.cpp
index c1a4575d5d..9529a39996 100644
--- a/libs/ui/widgets/kis_preset_live_preview_view.cpp
+++ b/libs/ui/widgets/kis_preset_live_preview_view.cpp
@@ -1,344 +1,345 @@
 
 /*
  *  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)
 {
 
 }
 
 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::updateStroke()
 {
     paintBackground();
 
     // 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") {
 
         return;
     }
 
     setupAndPaintStroke();
 
 
     // crop the layer so a brush stroke won't go outside of the area
     m_layer->paintDevice()->crop(0,0, m_layer->image()->width(), m_layer->image()->height());
 
     QImage m_temp_image;
     m_temp_image = m_layer->paintDevice()->convertToQImage(0);
 
 
     // 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);
     }
 }
 
 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();
     proxy_preset->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 (m_currentPreset->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 (m_currentPreset->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->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);
 
 
 
     //m_brushPreviewPainter->setPaintOpPreset(proxy_preset, m_layer, m_image);
 
 
 
     // paint the stroke. The sketchbrush gets a different shape than the others to show how it works
     if (m_currentPreset->paintOp().id() == "sketchbrush"
             || m_currentPreset->paintOp().id() == "curvebrush"
             || m_currentPreset->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 FreehandStrokeStrategy::UpdateData(true));
+            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 FreehandStrokeStrategy::UpdateData(true));
+        m_image->addJob(strokeId, new KisAsyncronousStrokeUpdateHelper::UpdateData(true));
     }
     m_image->endStroke(strokeId);
     m_image->waitForDone();
 
 
     // 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);
 
 }
 
diff --git a/libs/widgets/kis_color_input.cpp b/libs/widgets/kis_color_input.cpp
index 4bbd8e02f3..3813ccfa45 100644
--- a/libs/widgets/kis_color_input.cpp
+++ b/libs/widgets/kis_color_input.cpp
@@ -1,417 +1,417 @@
 /*
  *  Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2011 Sven Langkamp <sven.langkamp@gmail.com>
  *  Copyright (c) 2015 Moritz Molch <kde@moritzmolch.de>
  *
  *  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 "kis_color_input.h"
 
 #include <KoConfig.h>
 #ifdef HAVE_OPENEXR
 #include <half.h>
 #endif
 
 #include <cmath>
 
 #include <kis_debug.h>
 
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QLineEdit>
 #include <QSpinBox>
 #include <QDoubleSpinBox>
 
 #include <klocalizedstring.h>
 
 #include <KoChannelInfo.h>
 #include <KoColor.h>
 #include <KoColorSlider.h>
 #include <KoColorSpace.h>
 
 #include "kis_double_parse_spin_box.h"
 #include "kis_int_parse_spin_box.h"
 
 KisColorInput::KisColorInput(QWidget* parent, const KoChannelInfo* channelInfo, KoColor* color, KoColorDisplayRendererInterface *displayRenderer, bool usePercentage) :
     QWidget(parent), m_channelInfo(channelInfo), m_color(color), m_displayRenderer(displayRenderer),
     m_usePercentage(usePercentage)
 {
 }
 
 void KisColorInput::init()
 {
     QHBoxLayout* m_layout = new QHBoxLayout(this);
     m_layout->setContentsMargins(0,0,0,0);
     m_layout->setSpacing(1);
 
     QLabel* m_label = new QLabel(i18n("%1:", m_channelInfo->name()), this);
     m_layout->addWidget(m_label);
 
     m_colorSlider = new KoColorSlider(Qt::Horizontal, this, m_displayRenderer);
     m_colorSlider->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
     m_layout->addWidget(m_colorSlider);
 
     QWidget* m_input = createInput();
     m_colorSlider->setFixedHeight(m_input->sizeHint().height());
     m_layout->addWidget(m_input);
 }
 
 KisIntegerColorInput::KisIntegerColorInput(QWidget* parent, const KoChannelInfo* channelInfo, KoColor* color, KoColorDisplayRendererInterface *displayRenderer, bool usePercentage) :
     KisColorInput(parent, channelInfo, color, displayRenderer, usePercentage)
 {
     init();
 }
 
 void KisIntegerColorInput::setValue(int v)
 {
     quint8* data = m_color->data() + m_channelInfo->pos();
     switch (m_channelInfo->channelValueType()) {
     case KoChannelInfo::UINT8:
         *(reinterpret_cast<quint8*>(data)) = v;
         break;
     case KoChannelInfo::UINT16:
         *(reinterpret_cast<quint16*>(data)) = v;
         break;
     case KoChannelInfo::UINT32:
         *(reinterpret_cast<quint32*>(data)) = v;
         break;
     default:
         Q_ASSERT(false);
     }
     emit(updated());
 }
 
 void KisIntegerColorInput::update()
 {
     KoColor min = *m_color;
     KoColor max = *m_color;
     quint8* data = m_color->data() + m_channelInfo->pos();
     quint8* dataMin = min.data() + m_channelInfo->pos();
     quint8* dataMax = max.data() + m_channelInfo->pos();
     m_intNumInput->blockSignals(true);
     m_colorSlider->blockSignals(true);
     switch (m_channelInfo->channelValueType()) {
     case KoChannelInfo::UINT8:
         if (m_usePercentage) {
             m_intNumInput->setMaximum(100);
             m_intNumInput->setValue(round(*(reinterpret_cast<quint8*>(data))*1.0 / 255.0 * 100.0));
         } else {
             m_intNumInput->setMaximum(0xFF);
             m_intNumInput->setValue(*(reinterpret_cast<quint8*>(data)));
         }
         m_colorSlider->setValue(*(reinterpret_cast<quint8*>(data)));
         *(reinterpret_cast<quint8*>(dataMin)) = 0x0;
         *(reinterpret_cast<quint8*>(dataMax)) = 0xFF;
         break;
     case KoChannelInfo::UINT16:
         if (m_usePercentage) {
             m_intNumInput->setMaximum(100);
             m_intNumInput->setValue(round(*(reinterpret_cast<quint16*>(data))*1.0 / 65535.0 * 100.0));
         } else {
             m_intNumInput->setMaximum(0xFFFF);
             m_intNumInput->setValue(*(reinterpret_cast<quint16*>(data)));
         }
         m_colorSlider->setValue(*(reinterpret_cast<quint16*>(data)));
         *(reinterpret_cast<quint16*>(dataMin)) = 0x0;
         *(reinterpret_cast<quint16*>(dataMax)) = 0xFFFF;
         break;
     case KoChannelInfo::UINT32:
         if (m_usePercentage) {
             m_intNumInput->setMaximum(100);
             m_intNumInput->setValue(round(*(reinterpret_cast<quint32*>(data))*1.0 / 4294967295.0 * 100.0));
         } else {
             m_intNumInput->setMaximum(0xFFFF);
             m_intNumInput->setValue(*(reinterpret_cast<quint32*>(data)));
         }
         m_colorSlider->setValue(*(reinterpret_cast<quint32*>(data)));
         *(reinterpret_cast<quint32*>(dataMin)) = 0x0;
         *(reinterpret_cast<quint32*>(dataMax)) = 0xFFFFFFFF;
         break;
     default:
         Q_ASSERT(false);
     }
     m_colorSlider->setColors(min, max);
     m_intNumInput->blockSignals(false);
     m_colorSlider->blockSignals(false);
 }
 
 QWidget* KisIntegerColorInput::createInput()
 {
     m_intNumInput = new KisIntParseSpinBox(this);
     m_intNumInput->setMinimum(0);
     m_colorSlider->setMinimum(0);
 
     if (m_usePercentage) {
-        m_intNumInput->setSuffix("%");
+        m_intNumInput->setSuffix(i18n("%"));
     } else {
         m_intNumInput->setSuffix("");
     }
 
     switch (m_channelInfo->channelValueType()) {
     case KoChannelInfo::UINT8:
         if (m_usePercentage) {
             m_intNumInput->setMaximum(100);
         } else {
             m_intNumInput->setMaximum(0xFF);
         }
         m_colorSlider->setMaximum(0xFF);
         break;
     case KoChannelInfo::UINT16:
         if (m_usePercentage) {
             m_intNumInput->setMaximum(100);
         } else {
             m_intNumInput->setMaximum(0xFFFF);
         }
         m_colorSlider->setMaximum(0xFFFF);
         break;
     case KoChannelInfo::UINT32:
         if (m_usePercentage) {
             m_intNumInput->setMaximum(100);
         } else {
             m_intNumInput->setMaximum(0xFFFFFFFF);
         }
         m_colorSlider->setMaximum(0xFFFFFFFF);
         break;
     default:
         Q_ASSERT(false);
     }
     connect(m_colorSlider, SIGNAL(valueChanged(int)), this, SLOT(onColorSliderChanged(int)));
     connect(m_intNumInput, SIGNAL(valueChanged(int)), this, SLOT(onNumInputChanged(int)));
     return m_intNumInput;
 }
 
 void KisIntegerColorInput::setPercentageWise(bool val)
 {
     m_usePercentage = val;
 
     if (m_usePercentage) {
-        m_intNumInput->setSuffix("%");
+        m_intNumInput->setSuffix(i18n("%"));
     } else {
         m_intNumInput->setSuffix("");
     }
 }
 
 void KisIntegerColorInput::onColorSliderChanged(int val)
 {
     m_intNumInput->blockSignals(true);
     if (m_usePercentage) {
         switch (m_channelInfo->channelValueType()) {
         case KoChannelInfo::UINT8:
             m_intNumInput->setValue(round((val*1.0) / 255.0 * 100.0));
             break;
         case KoChannelInfo::UINT16:
             m_intNumInput->setValue(round((val*1.0) / 65535.0 * 100.0));
             break;
         case KoChannelInfo::UINT32:
             m_intNumInput->setValue(round((val*1.0) / 4294967295.0 * 100.0));
             break;
         default:
             Q_ASSERT(false);
         }
     } else {
         m_intNumInput->setValue(val);
     }
     m_intNumInput->blockSignals(false);
     setValue(val);
 }
 
 void KisIntegerColorInput::onNumInputChanged(int val)
 {
     m_colorSlider->blockSignals(true);
     if (m_usePercentage) {
         switch (m_channelInfo->channelValueType()) {
         case KoChannelInfo::UINT8:
             m_colorSlider->setValue((val*1.0)/100.0 * 255.0);
             m_colorSlider->blockSignals(false);
             setValue((val*1.0)/100.0 * 255.0);
             break;
         case KoChannelInfo::UINT16:
             m_colorSlider->setValue((val*1.0)/100.0 * 65535.0);
             m_colorSlider->blockSignals(false);
             setValue((val*1.0)/100.0 * 65535.0);
             break;
         case KoChannelInfo::UINT32:
             m_colorSlider->setValue((val*1.0)/100.0 * 4294967295.0);
             m_colorSlider->blockSignals(false);
             setValue((val*1.0)/100.0 * 4294967295.0);
             break;
         default:
             Q_ASSERT(false);
         }
     } else {
         m_colorSlider->setValue(val);
         m_colorSlider->blockSignals(false);
         setValue(val);
     }
 }
 
 KisFloatColorInput::KisFloatColorInput(QWidget* parent, const KoChannelInfo* channelInfo, KoColor* color, KoColorDisplayRendererInterface *displayRenderer, bool usePercentage) :
     KisColorInput(parent, channelInfo, color, displayRenderer, usePercentage)
 {
     init();
 }
 
 void KisFloatColorInput::setValue(double v)
 {
     quint8* data = m_color->data() + m_channelInfo->pos();
     switch (m_channelInfo->channelValueType()) {
 #ifdef HAVE_OPENEXR
     case KoChannelInfo::FLOAT16:
         *(reinterpret_cast<half*>(data)) = v;
         break;
 #endif
     case KoChannelInfo::FLOAT32:
         *(reinterpret_cast<float*>(data)) = v;
         break;
     default:
         Q_ASSERT(false);
     }
     emit(updated());
 }
 
 QWidget* KisFloatColorInput::createInput()
 {
     m_dblNumInput = new KisDoubleParseSpinBox(this);
     m_dblNumInput->setMinimum(0);
     m_dblNumInput->setMaximum(1.0);
     connect(m_colorSlider, SIGNAL(valueChanged(int)), this, SLOT(sliderChanged(int)));
     connect(m_dblNumInput, SIGNAL(valueChanged(double)), this, SLOT(setValue(double)));
     m_dblNumInput->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Preferred);
     m_dblNumInput->setMinimumWidth(60);
     m_dblNumInput->setMaximumWidth(60);
     return m_dblNumInput;
 }
 
 void KisFloatColorInput::sliderChanged(int i)
 {
     const qreal floatRange = m_maxValue - m_minValue;
     m_dblNumInput->setValue(m_minValue + (i / 255.0) * floatRange);
 }
 
 void KisFloatColorInput::update()
 {
     KoColor min = *m_color;
     KoColor max = *m_color;
     quint8* data = m_color->data() + m_channelInfo->pos();
     quint8* dataMin = min.data() + m_channelInfo->pos();
     quint8* dataMax = max.data() + m_channelInfo->pos();
 
     qreal value = 1.0;
     m_minValue = m_displayRenderer->minVisibleFloatValue(m_channelInfo);
     m_maxValue = m_displayRenderer->maxVisibleFloatValue(m_channelInfo);
 
     switch (m_channelInfo->channelValueType()) {
 #ifdef HAVE_OPENEXR
     case KoChannelInfo::FLOAT16:
         value = *(reinterpret_cast<half*>(data));
         m_minValue = qMin(value, m_minValue);
         m_maxValue = qMax(value, m_maxValue);
         *(reinterpret_cast<half*>(dataMin)) = m_minValue;
         *(reinterpret_cast<half*>(dataMax)) = m_maxValue;
         break;
 #endif
     case KoChannelInfo::FLOAT32:
         value = *(reinterpret_cast<float*>(data));
         m_minValue = qMin(value, m_minValue);
         m_maxValue = qMax(value, m_maxValue);
         *(reinterpret_cast<float*>(dataMin)) = m_minValue;
         *(reinterpret_cast<float*>(dataMax)) = m_maxValue;
         break;
     default:
         Q_ASSERT(false);
     }
 
     m_dblNumInput->setMinimum(m_minValue);
     m_dblNumInput->setMaximum(m_maxValue);
 
     // ensure at least 3 significant digits are always shown
     int newPrecision = 2 + qMax(qreal(0.0), std::ceil(-std::log10(m_maxValue)));
     if (newPrecision != m_dblNumInput->decimals()) {
         m_dblNumInput->setDecimals(newPrecision);
         m_dblNumInput->updateGeometry();
     }
 
     m_colorSlider->setColors(min, max);
 
     const qreal floatRange = m_maxValue - m_minValue;
     m_dblNumInput->setValue(value);
     m_colorSlider->setValue((value - m_minValue) / floatRange * 255);
 }
 
 KisHexColorInput::KisHexColorInput(QWidget* parent, KoColor* color, KoColorDisplayRendererInterface *displayRenderer, bool usePercentage) :
     KisColorInput(parent, 0, color, displayRenderer, usePercentage)
 {
     QHBoxLayout* m_layout = new QHBoxLayout(this);
     m_layout->setContentsMargins(0,0,0,0);
     m_layout->setSpacing(1);
 
     QLabel* m_label = new QLabel(i18n("Color name:"), this);
     m_label->setMinimumWidth(50);
     m_layout->addWidget(m_label);
 
     QWidget* m_input = createInput();
     m_input->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Preferred);
     m_layout->addWidget(m_input);
 }
 
 void KisHexColorInput::setValue()
 {
     QString valueString = m_hexInput->text();
     valueString.remove(QChar('#'));
 
     QList<KoChannelInfo*> channels = m_color->colorSpace()->channels();
     channels = KoChannelInfo::displayOrderSorted(channels);
     Q_FOREACH (KoChannelInfo* channel, channels) {
         if (channel->channelType() == KoChannelInfo::COLOR) {
             Q_ASSERT(channel->channelValueType() == KoChannelInfo::UINT8);
             quint8* data = m_color->data() + channel->pos();
 
             int value = valueString.left(2).toInt(0, 16);
             *(reinterpret_cast<quint8*>(data)) = value;
             valueString.remove(0, 2);
         }
     }
     emit(updated());
 }
 
 void KisHexColorInput::update()
 {
     QString hexString("#");
 
     QList<KoChannelInfo*> channels = m_color->colorSpace()->channels();
     channels = KoChannelInfo::displayOrderSorted(channels);
     Q_FOREACH (KoChannelInfo* channel, channels) {
         if (channel->channelType() == KoChannelInfo::COLOR) {
             Q_ASSERT(channel->channelValueType() == KoChannelInfo::UINT8);
             quint8* data = m_color->data() + channel->pos();
             hexString.append(QString("%1").arg(*(reinterpret_cast<quint8*>(data)), 2, 16, QChar('0')));
         }
     }
     m_hexInput->setText(hexString);
 }
 
 QWidget* KisHexColorInput::createInput()
 {
     m_hexInput = new QLineEdit(this);
     m_hexInput->setAlignment(Qt::AlignRight);
 
     int digits = 2*m_color->colorSpace()->colorChannelCount();
     QString pattern = QString("#?[a-fA-F0-9]{%1,%2}").arg(digits).arg(digits);
     m_hexInput->setValidator(new QRegExpValidator(QRegExp(pattern), this));
     connect(m_hexInput, SIGNAL(editingFinished()), this, SLOT(setValue()));
     return m_hexInput;
 }
 
diff --git a/libs/widgets/tests/zoomcontroller_test.cpp b/libs/widgets/tests/zoomcontroller_test.cpp
index 921427db1a..e0bde55751 100644
--- a/libs/widgets/tests/zoomcontroller_test.cpp
+++ b/libs/widgets/tests/zoomcontroller_test.cpp
@@ -1,39 +1,39 @@
 /*
  *  Copyright (c) 2007-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 "zoomcontroller_test.h"
 
 #include <QTest>
 #include <QCoreApplication>
 
 #include <kactioncollection.h>
 #include <WidgetsDebug.h>
 
 #include "KoCanvasControllerWidget.h"
 #include "KoZoomHandler.h"
 #include "KoZoomController.h"
 
 void zoomcontroller_test::testApi()
 {
     KoZoomHandler zoomHandler;
-    KoZoomController zoomController(new KoCanvasControllerWidget(0), &zoomHandler, new KActionCollection(this));
+    KoZoomController zoomController(new KoCanvasControllerWidget(0, 0), &zoomHandler, new KActionCollection(this));
     Q_UNUSED(zoomController);
 
 }
 
 QTEST_MAIN(zoomcontroller_test)
diff --git a/libs/widgetutils/config/kstandardaction_p.h b/libs/widgetutils/config/kstandardaction_p.h
index 3c6adf4e1a..b0e67cb836 100644
--- a/libs/widgetutils/config/kstandardaction_p.h
+++ b/libs/widgetutils/config/kstandardaction_p.h
@@ -1,188 +1,188 @@
 /* This file is part of the KDE libraries
    Copyright (C) 1999,2000 Kurt Granroth <granroth@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 version 2 as published by the Free Software Foundation.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #ifndef KSTANDARDACTION_PRIVATE_H
 #define KSTANDARDACTION_PRIVATE_H
 
 #include <QAction>
 #include <QApplication>
 
 #include <klocalizedstring.h>
 #include <kstandardshortcut.h>
 
 namespace KStandardAction
 {
 
 struct KStandardActionInfo {
     StandardAction id;
     KStandardShortcut::StandardShortcut idAccel;
     const char *psName;
     const char *psLabel;
     const char *psToolTip;
     const char *psIconName;
 };
 
 static const KStandardActionInfo g_rgActionInfo[] = {
     { New,           KStandardShortcut::New, "file_new", I18N_NOOP("&New"), I18N_NOOP("Create new document"), "document-new" },
     { Open,          KStandardShortcut::Open, "file_open", I18N_NOOP("&Open..."), I18N_NOOP("Open an existing document"), "document-open" },
     { OpenRecent,    KStandardShortcut::AccelNone, "file_open_recent", I18N_NOOP("Open &Recent"), I18N_NOOP("Open a document which was recently opened"), "document-open-recent" },
     { Save,          KStandardShortcut::Save, "file_save", I18N_NOOP("&Save"), I18N_NOOP("Save document"), "document-save" },
     { SaveAs,        KStandardShortcut::SaveAs, "file_save_as", I18N_NOOP("Save &As..."), I18N_NOOP("Save document under a new name"), "document-save-as" },
     { Revert,        KStandardShortcut::Revert, "file_revert", I18N_NOOP("Re&vert"), I18N_NOOP("Revert unsaved changes made to document"), "document-revert" },
-    { Close,         KStandardShortcut::Close, "file_close", I18N_NOOP("&Close"), I18N_NOOP("Close document"), "window-close" },
+    { Close,         KStandardShortcut::Close, "file_close", I18N_NOOP("&Close"), I18N_NOOP("Close document"), "document-close" },
     { Print,         KStandardShortcut::Print, "file_print", I18N_NOOP("&Print..."), I18N_NOOP("Print document"), "document-print" },
     { PrintPreview,  KStandardShortcut::PrintPreview, "file_print_preview", I18N_NOOP("Print Previe&w"), I18N_NOOP("Show a print preview of document"), "document-print-preview" },
     { Mail,          KStandardShortcut::Mail, "file_mail", I18N_NOOP("&Mail..."), I18N_NOOP("Send document by mail"), "mail-send" },
     { Quit,          KStandardShortcut::Quit, "file_quit", I18N_NOOP("&Quit"), I18N_NOOP("Quit application"), "application-exit" },
 
     { Undo,          KStandardShortcut::Undo, "edit_undo", I18N_NOOP("&Undo"), I18N_NOOP("Undo last action"), "edit-undo" },
     { Redo,          KStandardShortcut::Redo, "edit_redo", I18N_NOOP("Re&do"), I18N_NOOP("Redo last undone action"), "edit-redo" },
     { Cut,           KStandardShortcut::Cut, "edit_cut", I18N_NOOP("Cu&t"), I18N_NOOP("Cut selection to clipboard"), "edit-cut" },
     { Copy,          KStandardShortcut::Copy, "edit_copy", I18N_NOOP("&Copy"), I18N_NOOP("Copy selection to clipboard"), "edit-copy" },
     { Paste,         KStandardShortcut::Paste, "edit_paste", I18N_NOOP("&Paste"), I18N_NOOP("Paste clipboard content"), "edit-paste" },
     { PasteText,     KStandardShortcut::Paste, "edit_paste", I18N_NOOP("&Paste"), I18N_NOOP("Paste clipboard content"), "edit-paste" },
     { Clear,         KStandardShortcut::Clear, "edit_clear", I18N_NOOP("C&lear"), 0, "edit-clear" },
     { SelectAll,     KStandardShortcut::SelectAll, "edit_select_all", I18N_NOOP("Select &All"), 0, "edit-select-all" },
     { Deselect,      KStandardShortcut::Deselect, "edit_deselect", I18N_NOOP("Dese&lect"), 0, 0 },
     { Find,          KStandardShortcut::Find, "edit_find", I18N_NOOP("&Find..."), 0, "edit-find" },
     { FindNext,      KStandardShortcut::FindNext, "edit_find_next", I18N_NOOP("Find &Next"), 0, "go-down-search" },
     { FindPrev,      KStandardShortcut::FindPrev, "edit_find_prev", I18N_NOOP("Find Pre&vious"), 0, "go-up-search" },
     { Replace,       KStandardShortcut::Replace, "edit_replace", I18N_NOOP("&Replace..."), 0, 0 },
 
     { ActualSize,    KStandardShortcut::ActualSize, "view_actual_size", I18N_NOOP("&Actual Size"), I18N_NOOP("View document at its actual size"), "zoom-original" },
     { FitToPage,     KStandardShortcut::FitToPage, "view_fit_to_page", I18N_NOOP("&Fit to Page"), I18N_NOOP("Zoom to fit page in window"), 0 },
     { FitToWidth,    KStandardShortcut::FitToWidth, "view_fit_to_width", I18N_NOOP("Fit to Page &Width"), I18N_NOOP("Zoom to fit page width in window"), 0 },
     { FitToHeight,   KStandardShortcut::FitToHeight, "view_fit_to_height", I18N_NOOP("Fit to Page &Height"), I18N_NOOP("Zoom to fit page height in window"), 0 },
     { ZoomIn,        KStandardShortcut::ZoomIn, "view_zoom_in", I18N_NOOP("Zoom &In"), 0, "zoom-in" },
     { ZoomOut,       KStandardShortcut::ZoomOut, "view_zoom_out", I18N_NOOP("Zoom &Out"), 0, "zoom-out" },
     { Zoom,          KStandardShortcut::Zoom, "view_zoom", I18N_NOOP("&Zoom..."), I18N_NOOP("Select zoom level"), 0 },
     { Redisplay,     KStandardShortcut::Reload, "view_redisplay", I18N_NOOP("&Redisplay"), I18N_NOOP("Redisplay document"), "view-refresh" },
 
     { Up,            KStandardShortcut::Up, "go_up", I18N_NOOP("&Up"), I18N_NOOP("Go up"), "go-up" },
     // The following three have special i18n() needs for sLabel
     { Back,          KStandardShortcut::Back, "go_back", 0, 0, "go-previous" },
     { Forward,       KStandardShortcut::Forward, "go_forward", 0, 0, "go-next" },
     { Home,          KStandardShortcut::Home, "go_home", 0, 0, "go-home" },
     { Prior,         KStandardShortcut::Prior, "go_previous", I18N_NOOP("&Previous Page"), I18N_NOOP("Go to previous page"), "go-previous-view-page" },
     { Next,          KStandardShortcut::Next, "go_next", I18N_NOOP("&Next Page"), I18N_NOOP("Go to next page"), "go-next-view-page" },
     { Goto,          KStandardShortcut::Goto, "go_goto", I18N_NOOP("&Go To..."), 0, 0 },
     { GotoPage,      KStandardShortcut::GotoPage, "go_goto_page", I18N_NOOP("&Go to Page..."), 0, "go-jump" },
     { GotoLine,      KStandardShortcut::GotoLine, "go_goto_line", I18N_NOOP("&Go to Line..."), 0, 0 },
     { FirstPage,     KStandardShortcut::Begin, "go_first", I18N_NOOP("&First Page"), I18N_NOOP("Go to first page"), "go-first-view-page" },
     { LastPage,      KStandardShortcut::End, "go_last", I18N_NOOP("&Last Page"), I18N_NOOP("Go to last page"), "go-last-view-page" },
     { DocumentBack,  KStandardShortcut::DocumentBack, "go_document_back", I18N_NOOP("&Back"), I18N_NOOP("Go back in document"), "go-previous" },
     { DocumentForward, KStandardShortcut::DocumentForward, "go_document_forward", I18N_NOOP("&Forward"), I18N_NOOP("Go forward in document"), "go-next" },
 
     { AddBookmark,   KStandardShortcut::AddBookmark, "bookmark_add", I18N_NOOP("&Add Bookmark"), 0, "bookmark-new" },
     { EditBookmarks, KStandardShortcut::EditBookmarks, "bookmark_edit", I18N_NOOP("&Edit Bookmarks..."), 0, "bookmarks-organize" },
 
     { Spelling,      KStandardShortcut::Spelling, "tools_spelling", I18N_NOOP("&Spelling..."), I18N_NOOP("Check spelling in document"), "tools-check-spelling" },
 
     { ShowMenubar,   KStandardShortcut::ShowMenubar, "options_show_menubar", I18N_NOOP("Show &Menubar"), I18N_NOOP("Show or hide menubar"), "show-menu" },
     { ShowToolbar,   KStandardShortcut::ShowToolbar, "options_show_toolbar", I18N_NOOP("Show &Toolbar"), I18N_NOOP("Show or hide toolbar"), 0 },
     { ShowStatusbar, KStandardShortcut::ShowStatusbar, "options_show_statusbar", I18N_NOOP("Show St&atusbar"), I18N_NOOP("Show or hide statusbar"), 0 },
     { FullScreen,    KStandardShortcut::FullScreen, "fullscreen", I18N_NOOP("F&ull Screen Mode"), 0, "view-fullscreen" },
     { SaveOptions,   KStandardShortcut::SaveOptions, "options_save_options", I18N_NOOP("&Save Settings"), 0, 0 },
     { KeyBindings,   KStandardShortcut::KeyBindings, "options_configure_keybinding", I18N_NOOP("Configure S&hortcuts..."), 0, "configure-shortcuts" },
     { Preferences,   KStandardShortcut::Preferences, "options_configure", I18N_NOOP("&Configure %1..."), 0, "configure" },
     { ConfigureToolbars, KStandardShortcut::ConfigureToolbars, "options_configure_toolbars", I18N_NOOP("Configure Tool&bars..."), 0, "configure-toolbars" },
     { ConfigureNotifications, KStandardShortcut::ConfigureNotifications, "options_configure_notifications", I18N_NOOP("Configure &Notifications..."), 0, "preferences-desktop-notification" },
 
     // the idea here is that Contents is used in menus, and Help in dialogs, so both share the same
     // shortcut
     { Help,          KStandardShortcut::Help, "help", 0, 0, "help-contents" },
     { HelpContents,  KStandardShortcut::Help, "help_contents", I18N_NOOP("%1 &Handbook"), 0, "help-contents" },
     { WhatsThis,     KStandardShortcut::WhatsThis, "help_whats_this", I18N_NOOP("What's &This?"), 0, "help-contextual" },
     { TipofDay,      KStandardShortcut::TipofDay, "help_show_tip", I18N_NOOP("Tip of the &Day"), 0, "help-hint" },
     { ReportBug,     KStandardShortcut::ReportBug, "help_report_bug", I18N_NOOP("&Report Bug..."), 0, "tools-report-bug" },
     { SwitchApplicationLanguage, KStandardShortcut::SwitchApplicationLanguage, "switch_application_language", I18N_NOOP("Switch Application &Language..."), 0, "preferences-desktop-locale" },
     { AboutApp,      KStandardShortcut::AccelNone, "help_about_app", I18N_NOOP("&About %1"), 0, 0 },
     { AboutKDE,      KStandardShortcut::AccelNone, "help_about_kde", I18N_NOOP("About &KDE"), 0, "kde" },
     { ActionNone,    KStandardShortcut::AccelNone, 0, 0, 0, 0 }
 };
 
 inline const KStandardActionInfo *infoPtr(StandardAction id)
 {
     for (uint i = 0; g_rgActionInfo[i].id != ActionNone; i++) {
         if (g_rgActionInfo[i].id == id) {
             return &g_rgActionInfo[i];
         }
     }
 
     return 0;
 }
 
 static inline QStringList internal_stdNames()
 {
     QStringList result;
 
     for (uint i = 0; g_rgActionInfo[i].id != ActionNone; i++)
         if (g_rgActionInfo[i].psLabel) {
             if (QByteArray(g_rgActionInfo[i].psLabel).contains("%1"))
                 // Prevents i18n from complaining about unsubstituted placeholder.
             {
                 result.append(i18n(g_rgActionInfo[i].psLabel, QString()));
             } else {
                 result.append(i18n(g_rgActionInfo[i].psLabel));
             }
         }
 
     return result;
 }
 
 class AutomaticAction : public QAction
 {
     Q_OBJECT
 
 public:
     AutomaticAction(const QIcon &icon, const QString &text, const QList<QKeySequence> &shortcut, const char *slot,
                     QObject *parent);
 public Q_SLOTS:
     inline void cut()
     {
         invokeEditSlot("cut");
     }
     inline void copy()
     {
         invokeEditSlot("copy");
     }
     inline void paste()
     {
         invokeEditSlot("paste");
     }
     inline void clear()
     {
         invokeEditSlot("clear");
     }
     inline void selectAll()
     {
         invokeEditSlot("selectAll");
     }
 
     void invokeEditSlot(const char *slot)
     {
         if (qApp->focusWidget()) {
             QMetaObject::invokeMethod(qApp->focusWidget(), slot);
         }
     }
 
 };
 
 }
 
 #endif
diff --git a/libs/widgetutils/kis_action_registry.cpp b/libs/widgetutils/kis_action_registry.cpp
index a8a7f3def1..5e51b78d52 100644
--- a/libs/widgetutils/kis_action_registry.cpp
+++ b/libs/widgetutils/kis_action_registry.cpp
@@ -1,417 +1,419 @@
 /*
  *  Copyright (c) 2015 Michael Abrahams <miabraha@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public 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 <QString>
 #include <QHash>
 #include <QGlobalStatic>
 #include <QFile>
 #include <QDomElement>
 #include <KSharedConfig>
 #include <klocalizedstring.h>
 #include <KisShortcutsDialog.h>
 #include <KConfigGroup>
 
 #include "kis_debug.h"
 #include "KoResourcePaths.h"
 #include "kis_icon_utils.h"
 
 #include "kis_action_registry.h"
 #include "kshortcutschemeshelper_p.h"
 
 
 namespace {
 
     /**
      * We associate several pieces of information with each shortcut. The first
      * piece of information is a QDomElement, containing the raw data from the
      * .action XML file. The second and third are QKeySequences, the first of
      * which is the default shortcut, the last of which is any custom shortcut.
      * The last two are the KActionCollection and KActionCategory used to
      * organize the shortcut editor.
      */
     struct ActionInfoItem {
         QDomElement  xmlData;
 
         QString      collectionName;
         QString      categoryName;
 
         inline QList<QKeySequence> defaultShortcuts() const {
             return m_defaultShortcuts;
         }
 
         inline void setDefaultShortcuts(const QList<QKeySequence> &value) {
             m_defaultShortcuts = value;
         }
 
         inline QList<QKeySequence> customShortcuts() const {
             return m_customShortcuts;
         }
 
         inline void setCustomShortcuts(const QList<QKeySequence> &value, bool explicitlyReset) {
             m_customShortcuts = value;
             m_explicitlyReset = explicitlyReset;
         }
 
         inline QList<QKeySequence> effectiveShortcuts() const {
             return m_customShortcuts.isEmpty() && !m_explicitlyReset ?
                 m_defaultShortcuts : m_customShortcuts;
         }
 
 
     private:
         QList<QKeySequence> m_defaultShortcuts;
         QList<QKeySequence> m_customShortcuts;
         bool m_explicitlyReset = false;
     };
 
     // Convenience macros to extract text of a child node.
     QString getChildContent(QDomElement xml, QString node) {
         return xml.firstChildElement(node).text();
     }
 
     // Use Krita debug logging categories instead of KDE's default qDebug() for
     // harmless empty strings and translations
     QString quietlyTranslate(const QString &s) {
         if (s.isEmpty()) {
             return s;
         }
         QString translatedString = i18nc("action", s.toUtf8());
         if (translatedString == s) {
             translatedString = i18n(s.toUtf8());
         }
         if (translatedString.isEmpty()) {
             dbgAction << "No translation found for" << s;
             return s;
         }
 
         return translatedString;
     }
 }
 
 
 
 class Q_DECL_HIDDEN KisActionRegistry::Private
 {
 public:
 
     Private(KisActionRegistry *_q) : q(_q) {}
 
     // This is the main place containing ActionInfoItems.
     QMap<QString, ActionInfoItem> actionInfoList;
     void loadActionFiles();
     void loadCustomShortcuts(QString filename = QStringLiteral("kritashortcutsrc"));
 
     // XXX: this adds a default item for the given name to the list of actioninfo objects!
     ActionInfoItem &actionInfo(const QString &name) {
         if (!actionInfoList.contains(name)) {
             dbgAction << "Tried to look up info for unknown action" << name;
         }
         return actionInfoList[name];
     }
 
     KisActionRegistry *q;
     QSet<QString> sanityPropertizedShortcuts;
 };
 
 
 Q_GLOBAL_STATIC(KisActionRegistry, s_instance)
 
 KisActionRegistry *KisActionRegistry::instance()
 {
     if (!s_instance.exists()) {
         dbgRegistry << "initializing KoActionRegistry";
     }
     return s_instance;
 }
 
 bool KisActionRegistry::hasAction(const QString &name) const
 {
     return d->actionInfoList.contains(name);
 }
 
 
 KisActionRegistry::KisActionRegistry()
     : d(new KisActionRegistry::Private(this))
 {
     KConfigGroup cg = KSharedConfig::openConfig()->group("Shortcut Schemes");
     QString schemeName = cg.readEntry("Current Scheme", "Default");
     loadShortcutScheme(schemeName);
     loadCustomShortcuts();
 }
 
 KisActionRegistry::ActionCategory KisActionRegistry::fetchActionCategory(const QString &name) const
 {
     if (!d->actionInfoList.contains(name)) return ActionCategory();
 
     const ActionInfoItem info = d->actionInfoList.value(name);
     return ActionCategory(info.collectionName, info.categoryName);
 }
 
 void KisActionRegistry::notifySettingsUpdated()
 {
     d->loadCustomShortcuts();
 }
 
 void KisActionRegistry::loadCustomShortcuts()
 {
     d->loadCustomShortcuts();
 }
 
 void KisActionRegistry::loadShortcutScheme(const QString &schemeName)
 {
     // Load scheme file
     if (schemeName != QStringLiteral("Default")) {
         QString schemeFileName = KShortcutSchemesHelper::schemeFileLocations().value(schemeName);
         if (schemeFileName.isEmpty()) {
             return;
         }
         KConfig schemeConfig(schemeFileName, KConfig::SimpleConfig);
         applyShortcutScheme(&schemeConfig);
     } else {
         // Apply default scheme, updating KisActionRegistry data
         applyShortcutScheme();
     }
 }
 
 QAction * KisActionRegistry::makeQAction(const QString &name, QObject *parent)
 {
     QAction * a = new QAction(parent);
     if (!d->actionInfoList.contains(name)) {
         qWarning() << "Warning: requested data for unknown action" << name;
         a->setObjectName(name);
         return a;
     }
 
     propertizeAction(name, a);
     return a;
 }
 
 void KisActionRegistry::settingsPageSaved()
 {
    // For now, custom shortcuts are dealt with by writing to file and reloading.
    loadCustomShortcuts();
 
    // Announce UI should reload current shortcuts.
    emit shortcutsUpdated();
 }
 
 
 void KisActionRegistry::applyShortcutScheme(const KConfigBase *config)
 {
     // First, update the things in KisActionRegistry
     d->actionInfoList.clear();
     d->loadActionFiles();
 
     if (config == 0) {
         // Use default shortcut scheme. Simplest just to reload everything.
         loadCustomShortcuts();
     } else {
         const auto schemeEntries = config->group(QStringLiteral("Shortcuts")).entryMap();
         // Load info item for each shortcut, reset custom shortcuts
         auto it = schemeEntries.constBegin();
         while (it != schemeEntries.end()) {
             ActionInfoItem &info = d->actionInfo(it.key());
             info.setDefaultShortcuts(QKeySequence::listFromString(it.value()));
             it++;
         }
     }
 }
 
 void KisActionRegistry::updateShortcut(const QString &name, QAction *action)
 {
     const ActionInfoItem &info = d->actionInfo(name);
     action->setShortcuts(info.effectiveShortcuts());
     action->setProperty("defaultShortcuts", qVariantFromValue(info.defaultShortcuts()));
 
     d->sanityPropertizedShortcuts.insert(name);
 }
 
 bool KisActionRegistry::sanityCheckPropertized(const QString &name)
 {
     return d->sanityPropertizedShortcuts.contains(name);
 }
 
 QList<QString> KisActionRegistry::registeredShortcutIds() const
 {
     return d->actionInfoList.keys();
 }
 
 bool KisActionRegistry::propertizeAction(const QString &name, QAction * a)
 {
     if (!d->actionInfoList.contains(name)) {
         warnAction << "No XML data found for action" << name;
         return false;
     }
 
     const ActionInfoItem info = d->actionInfo(name);
 
     QDomElement actionXml = info.xmlData;
     if (!actionXml.text().isEmpty()) {
         // i18n requires converting format from QString.
         auto getChildContent_i18n = [=](QString node){return quietlyTranslate(getChildContent(actionXml, node));};
 
         // Note: the fields in the .action documents marked for translation are determined by extractrc.
         QString icon      = getChildContent(actionXml, "icon");
         QString text      = getChildContent_i18n("text");
         QString whatsthis = getChildContent_i18n("whatsThis");
         QString toolTip   = getChildContent_i18n("toolTip");
         QString statusTip = getChildContent_i18n("statusTip");
         QString iconText  = getChildContent_i18n("iconText");
         bool isCheckable  = getChildContent(actionXml, "isCheckable") == QString("true");
 
         a->setObjectName(name); // This is helpful, should be added more places in Krita
-        a->setIcon(KisIconUtils::loadIcon(icon.toLatin1()));
+        if (!icon.isEmpty()) {
+            a->setIcon(KisIconUtils::loadIcon(icon.toLatin1()));
+        }
         a->setText(text);
         a->setObjectName(name);
         a->setWhatsThis(whatsthis);
         a->setToolTip(toolTip);
         a->setStatusTip(statusTip);
         a->setIconText(iconText);
         a->setCheckable(isCheckable);
     }
 
     updateShortcut(name, a);
     return true;
 }
 
 
 
 QString KisActionRegistry::getActionProperty(const QString &name, const QString &property)
 {
     ActionInfoItem info = d->actionInfo(name);
     QDomElement actionXml = info.xmlData;
     if (actionXml.text().isEmpty()) {
         dbgAction << "No XML data found for action" << name;
         return QString();
     }
 
     return getChildContent(actionXml, property);
 
 }
 
 
 void KisActionRegistry::Private::loadActionFiles()
 {
     QStringList actionDefinitions =
         KoResourcePaths::findAllResources("kis_actions", "*.action", KoResourcePaths::Recursive);
 
     // Extract actions all XML .action files.
     Q_FOREACH (const QString &actionDefinition, actionDefinitions)  {
         QDomDocument doc;
         QFile f(actionDefinition);
         f.open(QFile::ReadOnly);
         doc.setContent(f.readAll());
 
         QDomElement base       = doc.documentElement(); // "ActionCollection" outer group
         QString collectionName = base.attribute("name");
         QString version        = base.attribute("version");
         if (version != "2") {
             errAction << ".action XML file" << actionDefinition << "has incorrect version; skipping.";
             continue;
         }
 
         // Loop over <Actions> nodes. Each of these corresponds to a
         // KActionCategory, producing a group of actions in the shortcut dialog.
         QDomElement actions = base.firstChild().toElement();
         while (!actions.isNull()) {
 
             // <text> field
             QDomElement categoryTextNode = actions.firstChild().toElement();
             QString categoryName         = quietlyTranslate(categoryTextNode.text());
 
             // <action></action> tags
             QDomElement actionXml  = categoryTextNode.nextSiblingElement();
 
             // Loop over individual actions
             while (!actionXml.isNull()) {
                 if (actionXml.tagName() == "Action") {
                     // Read name from format <Action name="save">
                     QString name      = actionXml.attribute("name");
 
                     // Bad things
                     if (name.isEmpty()) {
                         errAction << "Unnamed action in definitions file " << actionDefinition;
                     }
 
                     else if (actionInfoList.contains(name)) {
                         qWarning() << "NOT COOL: Duplicated action name from xml data: " << name;
                     }
 
                     else {
                         ActionInfoItem info;
                         info.xmlData         = actionXml;
 
                         // Use empty list to signify no shortcut
                         QString shortcutText = getChildContent(actionXml, "shortcut");
                         if (!shortcutText.isEmpty()) {
                             info.setDefaultShortcuts(QKeySequence::listFromString(shortcutText));
                         }
 
                         info.categoryName    = categoryName;
                         info.collectionName  = collectionName;
 
                         actionInfoList.insert(name,info);
                     }
                 }
                 actionXml = actionXml.nextSiblingElement();
             }
             actions = actions.nextSiblingElement();
         }
     }
 }
 
 void KisActionRegistry::Private::loadCustomShortcuts(QString filename)
 {
     const KConfigGroup localShortcuts(KSharedConfig::openConfig(filename),
                                       QStringLiteral("Shortcuts"));
 
     if (!localShortcuts.exists()) {
         return;
     }
 
     // Distinguish between two "null" states for custom shortcuts.
     for (auto i = actionInfoList.begin(); i != actionInfoList.end(); ++i) {
         if (localShortcuts.hasKey(i.key())) {
             QString entry = localShortcuts.readEntry(i.key(), QString());
             if (entry == QStringLiteral("none")) {
                 i.value().setCustomShortcuts(QList<QKeySequence>(), true);
             } else {
                 i.value().setCustomShortcuts(QKeySequence::listFromString(entry), false);
             }
         } else {
             i.value().setCustomShortcuts(QList<QKeySequence>(), false);
         }
     }
 }
 
 KisActionRegistry::ActionCategory::ActionCategory()
 {
 }
 
 KisActionRegistry::ActionCategory::ActionCategory(const QString &_componentName, const QString &_categoryName)
     : componentName(_componentName),
       categoryName(_categoryName),
       m_isValid(true)
 {
 }
 
 bool KisActionRegistry::ActionCategory::isValid() const
 {
     return m_isValid && !categoryName.isEmpty() && !componentName.isEmpty();
 }
diff --git a/packaging/linux/flatpak/org.kde.krita-nightly.json b/packaging/linux/flatpak/org.kde.krita-nightly.json
index 41ad410c12..304487b6c1 100644
--- a/packaging/linux/flatpak/org.kde.krita-nightly.json
+++ b/packaging/linux/flatpak/org.kde.krita-nightly.json
@@ -1,355 +1,355 @@
 {
     "app-id": "org.kde.krita",
     "branch": "master",
     "runtime": "org.kde.Platform",
     "runtime-version": "5.9",
     "sdk": "org.kde.Sdk",
     "command": "krita",
-    "rename-icon": "calligrakrita",
+    "rename-icon": "krita",
     "tags": [
         "nightly"
     ],
     "desktop-file-name-prefix": "(Nightly) ",
     "finish-args": [
         "--share=ipc",
         "--socket=x11",
         "--share=network",
         "--device=dri",
         "--filesystem=home",
         "--env=PYTHONPATH=/app/lib/python3/dist-packages"
     ],
     "cleanup": [
         "/include",
         "/lib/pkgconfig",
         "/lib/cmake",
         "/share/aclocal",
         "/share/pkgconfig",
         "*.la",
         "*.cmake"
     ],
     "modules": [
         {
             "name": "boost",
             "buildsystem": "simple",
             "build-commands": [
                 "./bootstrap.sh --prefix=/app --with-libraries=system",
                 "./b2 -j `nproc` install"
             ],
             "cleanup": [
                 "*.a"
             ],
             "sources": [
                 {
                     "type": "archive",
                     "url": "https://sourceforge.net/projects/boost/files/boost/1.63.0/boost_1_63_0.tar.bz2",
                     "sha256": "beae2529f759f6b3bf3f4969a19c2e9d6f0c503edcb2de4a61d1428519fcb3b0"
                 }
             ]
         },
         {
             "name": "eigen",
             "buildsystem": "cmake-ninja",
             "builddir": true,
             "config-opts": [
                 "-DCMAKE_BUILD_TYPE=Release"
             ],
             "cleanup": [
                 "/share"
             ],
             "sources": [
                 {
                     "type": "archive",
                     "url": "https://bitbucket.org/eigen/eigen/get/3.3.4.tar.bz2",
                     "sha256": "dd254beb0bafc695d0f62ae1a222ff85b52dbaa3a16f76e781dce22d0d20a4a6"
                 }
             ]
         },
         {
             "name": "exiv2",
             "buildsystem": "cmake-ninja",
             "builddir": true,
             "config-opts": [
                 "-DCMAKE_BUILD_TYPE=Release"
             ],
             "cleanup": [
                 "/bin",
                 "*.a",
                 "/share/man"
             ],
             "sources": [
                 {
                     "type": "archive",
                     "url": "http://www.exiv2.org/builds/exiv2-0.26-trunk.tar.gz",
                     "sha256": "c75e3c4a0811bf700d92c82319373b7a825a2331c12b8b37d41eb58e4f18eafb"
                 }
             ]
         },
         {
             "name": "ilmbase",
             "config-opts": [
                 "--disable-static"
             ],
             "sources": [
                 {
                     "type": "archive",
                     "url": "https://download.savannah.nongnu.org/releases/openexr/ilmbase-2.2.1.tar.gz",
                     "sha256": "cac206e63be68136ef556c2b555df659f45098c159ce24804e9d5e9e0286609e"
                 }
             ]
         },
         {
             "name": "openexr",
             "config-opts": [
                 "--disable-static"
             ],
             "cleanup": [
                 "/bin",
                 "/share/doc"
             ],
             "sources": [
                 {
                     "type": "archive",
                     "url": "https://download.savannah.nongnu.org/releases/openexr/openexr-2.2.1.tar.gz",
                     "sha256": "8f9a5af6131583404261931d9a5c83de0a425cb4b8b25ddab2b169fbf113aecd"
                 }
             ]
         },
         {
             "name": "libraw",
             "config-opts": [
                 "--disable-static"
             ],
             "cleanup": [
                 "/bin",
                 "/share/doc"
             ],
             "sources": [
                 {
                     "type": "archive",
                     "url": "https://www.libraw.org/data/LibRaw-0.18.6.tar.gz",
                     "sha256": "e5b8acca558aa457bc9214802004320c5610d1434c2adb1f3ea367f026afa53b"
                 }
             ]
         },
         {
             "name": "fftw",
             "config-opts": [
                 "--disable-static",
                 "--enable-shared",
                 "--disable-doc",
                 "--enable-threads"
             ],
             "cleanup": [
                 "/bin",
                 "/share/man"
             ],
             "sources": [
                 {
                     "type": "archive",
                     "url": "http://www.fftw.org/fftw-3.3.7.tar.gz",
                     "sha256": "3b609b7feba5230e8f6dd8d245ddbefac324c5a6ae4186947670d9ac2cd25573"
                 }
             ]
         },
         {
             "name": "opencolorio",
             "buildsystem": "cmake",
             "builddir": true,
             "build-options": {
                 "arch": {
                     "arm": {
                         "config-opts": [
                             "-DOCIO_USE_SSE=OFF"
                         ]
                     },
                     "aarch64": {
                         "config-opts": [
                             "-DOCIO_USE_SSE=OFF"
                         ]
                     }
                 }
             },
             "config-opts": [
                 "-DCMAKE_BUILD_TYPE=Release",
                 "-DOCIO_BUILD_STATIC=OFF"
             ],
             "cleanup": [
                 "/bin"
             ],
             "sources": [
                 {
                     "type": "archive",
                     "url": "https://github.com/imageworks/OpenColorIO/archive/v1.0.9.tar.gz",
                     "sha256": "27c81e691c15753cd2b560c2ca4bd5679a60c2350eedd43c99d44ca25d65ea7f"
                 }
             ]
         },
         {
             "name": "vc",
             "skip-arches": [
                 "aarch64",
                 "arm"
             ],
             "buildsystem": "cmake-ninja",
             "builddir": true,
             "config-opts": [
                 "-DCMAKE_BUILD_TYPE=Release"
             ],
             "cleanup": [
                 "*.a"
             ],
             "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=Release"
             ],
             "sources": [
                 {
                     "type": "archive",
                     "url": "https://poppler.freedesktop.org/poppler-data-0.4.8.tar.gz",
                     "sha256": "1096a18161f263cccdc6d8a2eb5548c41ff8fcf9a3609243f1b6296abdf72872"
                 }
             ]
         },
         {
             "name": "poppler",
             "buildsystem": "cmake-ninja",
             "builddir": true,
             "config-opts": [
                 "-DCMAKE_BUILD_TYPE=Release",
                 "-DBUILD_GTK_TESTS=OFF",
                 "-DBUILD_QT5_TESTS=OFF",
                 "-DBUILD_CPP_TESTS=OFF",
                 "-DENABLE_UTILS=OFF",
                 "-DENABLE_CPP=OFF",
                 "-DENABLE_GLIB=OFF"
             ],
             "sources": [
                 {
                     "type": "archive",
                     "url": "https://poppler.freedesktop.org/poppler-0.62.0.tar.xz",
                     "sha256": "5b9a73dfd4d6f61d165ada1e4f0abd2d420494bf9d0b1c15d0db3f7b83a729c6"
                 }
             ]
         },
         {
             "name": "gsl",
             "config-opts": [
                 "--disable-static"
             ],
             "cleanup": [
                 "/bin",
                 "/share/info",
                 "/share/man"
             ],
             "sources": [
                 {
                     "type": "archive",
                     "url": "https://ftpmirror.gnu.org/gnu/gsl/gsl-2.4.tar.gz",
                     "sha256": "4d46d07b946e7b31c19bbf33dda6204d7bedc2f5462a1bae1d4013426cd1ce9b"
                 }
             ]
         },
         {
             "name": "gmic-qt",
             "buildsystem": "cmake-ninja",
             "builddir": true,
             "config-opts": [
                 "-DCMAKE_BUILD_TYPE=Release",
                 "-DGMIC_QT_HOST=krita",
                 "-DGMIC_PATH=./gmic/src"
             ],
             "sources": [
                 {
                     "type": "archive",
                     "url": "https://github.com/c-koi/gmic-qt/archive/v.218.tar.gz",
                     "sha256": "697861e5a1e024a3ccf9c96e513ec9f60f65d6e3c438ba355afcd10839b06f39"
                 },
                 {
                     "type": "file",
                     "url": "https://gmic.eu/files/source/gmic_2.1.8.tar.gz",
                     "sha256": "f22783f14cb202dec4a840733f2028f6e2c464fdd2f0166fc38943702cea6bde",
                     "dest-filename": "gmic.tar.gz"
                 },
                 {
                     "type": "shell",
                     "commands": [
                         "tar xf gmic.tar.gz",
                         "mv gmic-* gmic"
                     ]
                 }
             ],
             "post-install": [
                 "install -Dm755 gmic_krita_qt /app/bin/gmic_krita_qt"
             ]
         },
         {
             "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",
                 "make -j `nproc`",
                 "make install"
             ],
             "sources": [
                 {
                     "type": "archive",
                     "url": "https://sourceforge.net/projects/pyqt/files/sip/sip-4.19.6/sip-4.19.6.tar.gz",
                     "sha256": "9dda27ae181bea782ebc8768d29f22f85ab6e5128ee3ab21f491febad707925a"
                 }
             ]
         },
         {
             "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 `nproc`",
                 "make install"
             ],
             "sources": [
                 {
                     "type": "archive",
                     "url": "https://sourceforge.net/projects/pyqt/files/PyQt5/PyQt-5.9.2/PyQt5_gpl-5.9.2.tar.gz",
                     "sha256": "c190dac598c97b0113ca5e7a37c71c623f02d1d713088addfacac4acfa4b8394"
                 }
             ]
         },
         {
             "name": "krita",
             "buildsystem": "cmake-ninja",
             "builddir": true,
             "build-options": {
                 "env": {
                     "PYTHONPATH": "/app/lib/python3/dist-packages"
                 }
             },
             "config-opts": [
                 "-DCMAKE_BUILD_TYPE=RelWithDebInfo"
             ],
             "sources": [
                 {
                     "type": "git",
                     "url": "git://anongit.kde.org/krita.git",
                     "branch": "master"
                 }
             ]
         }
     ]
 }
diff --git a/packaging/linux/flatpak/org.kde.krita-nightly.yaml b/packaging/linux/flatpak/org.kde.krita-nightly.yaml
index e201182837..f58e14b2b1 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: calligrakrita
+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
   
   - 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 898d070b66..574e287dab 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: calligrakrita
+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
   
   - 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/linux/snap/snap/gui/krita.desktop b/packaging/linux/snap/snap/gui/krita.desktop
index 33e10f2bcd..0ed966c878 100755
--- a/packaging/linux/snap/snap/gui/krita.desktop
+++ b/packaging/linux/snap/snap/gui/krita.desktop
@@ -1,143 +1,143 @@
 [Desktop Entry]
 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
 Exec=krita %F
 GenericName=Digital Painting
 GenericName[ar]=رسم رقمي
 GenericName[bs]=Digitalno Bojenje
 GenericName[ca]=Dibuix digital
 GenericName[ca@valencia]=Dibuix digital
 GenericName[cs]=Digitální malování
 GenericName[da]=Digital tegning
 GenericName[de]=Digitales Malen
 GenericName[el]=Ψηφιακή ζωγραφική
 GenericName[en_GB]=Digital Painting
 GenericName[es]=Pintura digital
 GenericName[et]=Digitaalne joonistamine
 GenericName[eu]=Margolan digitala
 GenericName[fi]=Digitaalimaalaus
 GenericName[fr]=Peinture numérique
 GenericName[gl]=Debuxo dixital
 GenericName[hu]=Digitális festészet
 GenericName[ia]=Pintura Digital
 GenericName[is]=Stafræn málun
 GenericName[it]=Pittura digitale
 GenericName[ja]=デジタルペインティング
 GenericName[kk]=Цифрлық сурет салу
 GenericName[ko]=디지털 페인팅
 GenericName[lt]=Skaitmeninis piešimas
 GenericName[mr]=डिजिटल पेंटिंग
 GenericName[nb]=Digital maling
 GenericName[nl]=Digitaal schilderen
 GenericName[nn]=Digital teikning
 GenericName[pl]=Cyfrowe malowanie
 GenericName[pt]=Pintura Digital
 GenericName[pt_BR]=Pintura digital
 GenericName[ru]=Цифровая живопись
 GenericName[sk]=Digitálne maľovanie
 GenericName[sl]=Digitalno slikanje
 GenericName[sv]=Digital målning
 GenericName[tr]=Sayısal Boyama
 GenericName[ug]=سىفىرلىق رەسىم سىزغۇ
 GenericName[uk]=Цифрове малювання
 GenericName[x-test]=xxDigital Paintingxx
 GenericName[zh_CN]=数字绘画
 GenericName[zh_TW]=數位繪畫
 MimeType=application/x-krita;image/openraster;application/x-krita-paintoppreset;
 Comment=Pixel-based image manipulation program for the Calligra Suite
 Comment[ar]=برنامج لتعديل الصور البكسليّة لطقم «كاليغرا»
 Comment[ca]=Programa de manipulació d'imatges basades en píxels per a la Suite Calligra
 Comment[ca@valencia]=Programa de manipulació d'imatges basades en píxels per a la Suite Calligra
 Comment[de]=Pixelbasiertes Bildbearbeitungsprogramm für die Calligra-Suite
 Comment[el]=Πρόγραμμα επεξεργασίας εικόνας με βάση εικονοστοιχεία για το Calligra Stage
 Comment[en_GB]=Pixel-based image manipulation program for the Calligra Suite
 Comment[es]=Programa de manipulación de imágenes basado en píxeles para la suite Calligra
 Comment[et]=Calligra pikslipõhine pilditöötluse rakendus
 Comment[eu]=Pixel-oinarridun irudiak manipulatzeko programa Calligra-Suiterako
 Comment[fi]=Bittikarttakuvankäsittelyohjelma Calligra-toimisto-ohjelmistoon
 Comment[gl]=Programa da colección de Calligra para a manipulación de imaxes baseadas en píxeles.
 Comment[is]=Myndvinnsluforrit fyrir Calligra-forritavöndulinn
 Comment[it]=Programma di manipolazione delle immagini basato su pixel per Calligra Suite
 Comment[ko]=Calligra Suite를 위한 픽셀 기반 이미지 처리 프로그램
 Comment[nl]=Afbeeldingsbewerkingsprogramma gebaseerd op pixels voor de Calligra Suite
 Comment[nn]=Pikselbasert teikneprogram for Calligra
 Comment[pl]=Program do obróbki obrazów na poziomie pikseli dla Pakietu Calligra
 Comment[pt]='Plugin' de manipulação de imagens em pixels para o Calligra Stage
 Comment[pt_BR]=Programa de manipulação de imagens baseado em pixels para o Calligra Suite
 Comment[ru]=Программа редактирования пиксельной анимации для the Calligra Suite
 Comment[sk]=Program na manipuláciu s pixelmi pre Calligra Suite
 Comment[sv]=Bildpunktsbaserat bildbehandlingsprogram för Calligra-sviten
 Comment[tr]=Calligra Suite için Pixel tabanlı görüntü düzenleme programı
 Comment[uk]=Програма для роботи із растровими зображеннями для комплексу програм Calligra
 Comment[x-test]=xxPixel-based image manipulation program for the Calligra Suitexx
 Comment[zh_CN]=Calligra 套件的像素图像处理程序
 Comment[zh_TW]=Calligra 套件中基於像素的影像處理程式
 Type=Application
-Icon=${SNAP}/meta/gui/calligrakrita.png
+Icon=${SNAP}/meta/gui/krita.png
 Categories=Qt;KDE;Graphics;2DGraphics;RasterGraphics;
 X-KDE-NativeMimeType=application/x-krita
 X-KDE-ExtraNativeMimeTypes=
 StartupNotify=true
 X-Krita-Version=28
diff --git a/pics/createicons/icons.txt b/pics/createicons/icons.txt
index 7b128326bb..c6c8733ea8 100644
--- a/pics/createicons/icons.txt
+++ b/pics/createicons/icons.txt
@@ -1,56 +1,56 @@
 align-horizontal-center
 align-horizontal-left
 align-horizontal-right
 align-vertical-bottom
 align-vertical-center
 align-vertical-top
 application-x-krita
 application-x-wmf
 artistictext-detach-path
 artistictext-tool
-calligrakrita
+krita
 character-set
 draw-arrow-back
 draw-arrow-down
 draw-arrow-forward
 draw-arrow-up
 draw-freehand
 edit-rename
 edit-select-all
 format-indent-less
 format-indent-more
 format-justify-center
 format-justify-fill
 format-justify-left
 format-justify-right
 format-list-ordered
 format-stroke-color
 format-text-bold
 format-text-color
 format-text-direction-rtl
 format-text-italic
 format-text-strikethrough
 format-text-subscript
 format-text-superscript
 format-text-underline
 insert-text
 klipper
 list-remove
 media-floppy
 object-align-horizontal-center-calligra
 object-align-horizontal-left-calligra
 object-align-vertical-top-calligra
 object-group-calligra
 shape-choose
 snap-extension
 snap-guideline
 snap-intersection
 snap-node
 snap-orthogonal
 split
 tab-close
 tab-new
 transform-move
 trash-empty
 zoom-fit-best
 media-floppy
diff --git a/pics/icons.qrc b/pics/icons.qrc
index d2286d8893..cc31118256 100644
--- a/pics/icons.qrc
+++ b/pics/icons.qrc
@@ -1,305 +1,305 @@
 <RCC>
     <qresource prefix="/">
         <file>16_dark_align-horizontal-center.svg</file>
         <file>22_dark_align-horizontal-center.svg</file>
         <file>24_dark_align-horizontal-center.svg</file>
         <file>16_light_align-horizontal-center.svg</file>
         <file>22_light_align-horizontal-center.svg</file>
         <file>24_light_align-horizontal-center.svg</file>
         <file>16_dark_align-horizontal-left.svg</file>
         <file>22_dark_align-horizontal-left.svg</file>
         <file>24_dark_align-horizontal-left.svg</file>
         <file>16_light_align-horizontal-left.svg</file>
         <file>22_light_align-horizontal-left.svg</file>
         <file>24_light_align-horizontal-left.svg</file>
         <file>16_dark_align-horizontal-right.svg</file>
         <file>22_dark_align-horizontal-right.svg</file>
         <file>24_dark_align-horizontal-right.svg</file>
         <file>16_light_align-horizontal-right.svg</file>
         <file>22_light_align-horizontal-right.svg</file>
         <file>24_light_align-horizontal-right.svg</file>
         <file>16_dark_align-vertical-bottom.svg</file>
         <file>22_dark_align-vertical-bottom.svg</file>
         <file>24_dark_align-vertical-bottom.svg</file>
         <file>16_light_align-vertical-bottom.svg</file>
         <file>22_light_align-vertical-bottom.svg</file>
         <file>24_light_align-vertical-bottom.svg</file>
         <file>16_dark_align-vertical-center.svg</file>
         <file>22_dark_align-vertical-center.svg</file>
         <file>24_dark_align-vertical-center.svg</file>
         <file>16_light_align-vertical-center.svg</file>
         <file>22_light_align-vertical-center.svg</file>
         <file>24_light_align-vertical-center.svg</file>
         <file>16_dark_align-vertical-top.svg</file>
         <file>22_dark_align-vertical-top.svg</file>
         <file>24_dark_align-vertical-top.svg</file>
         <file>16_light_align-vertical-top.svg</file>
         <file>22_light_align-vertical-top.svg</file>
         <file>24_light_align-vertical-top.svg</file>
         <file>16_dark_application-x-krita.svg</file>
         <file>22_dark_application-x-krita.svg</file>
         <file>32_dark_application-x-krita.svg</file>
         <file>64_dark_application-x-krita.svg</file>
         <file>16_light_application-x-krita.svg</file>
         <file>22_light_application-x-krita.svg</file>
         <file>32_light_application-x-krita.svg</file>
         <file>64_light_application-x-krita.svg</file>
         <file>16_dark_application-x-wmf.svg</file>
         <file>22_dark_application-x-wmf.svg</file>
         <file>32_dark_application-x-wmf.svg</file>
         <file>64_dark_application-x-wmf.svg</file>
         <file>16_light_application-x-wmf.svg</file>
         <file>22_light_application-x-wmf.svg</file>
         <file>32_light_application-x-wmf.svg</file>
         <file>64_light_application-x-wmf.svg</file>
-        <file>calligrakrita.png</file>
+        <file>krita.png</file>
         <file>16_dark_character-set.svg</file>
         <file>22_dark_character-set.svg</file>
         <file>24_dark_character-set.svg</file>
         <file>16_light_character-set.svg</file>
         <file>22_light_character-set.svg</file>
         <file>24_light_character-set.svg</file>
         <file>16_dark_draw-arrow-back.svg</file>
         <file>22_dark_draw-arrow-back.svg</file>
         <file>24_dark_draw-arrow-back.svg</file>
         <file>16_light_draw-arrow-back.svg</file>
         <file>22_light_draw-arrow-back.svg</file>
         <file>24_light_draw-arrow-back.svg</file>
         <file>16_dark_draw-arrow-down.svg</file>
         <file>22_dark_draw-arrow-down.svg</file>
         <file>24_dark_draw-arrow-down.svg</file>
         <file>16_light_draw-arrow-down.svg</file>
         <file>22_light_draw-arrow-down.svg</file>
         <file>24_light_draw-arrow-down.svg</file>
         <file>16_dark_draw-arrow-forward.svg</file>
         <file>22_dark_draw-arrow-forward.svg</file>
         <file>24_dark_draw-arrow-forward.svg</file>
         <file>16_light_draw-arrow-forward.svg</file>
         <file>22_light_draw-arrow-forward.svg</file>
         <file>24_light_draw-arrow-forward.svg</file>
         <file>16_dark_draw-arrow-up.svg</file>
         <file>22_dark_draw-arrow-up.svg</file>
         <file>24_dark_draw-arrow-up.svg</file>
         <file>16_light_draw-arrow-up.svg</file>
         <file>22_light_draw-arrow-up.svg</file>
         <file>24_light_draw-arrow-up.svg</file>
         <file>16_dark_draw-freehand.svg</file>
         <file>22_dark_draw-freehand.svg</file>
         <file>24_dark_draw-freehand.svg</file>
         <file>16_light_draw-freehand.svg</file>
         <file>22_light_draw-freehand.svg</file>
         <file>24_light_draw-freehand.svg</file>
         <file>16_dark_edit-rename.svg</file>
         <file>22_dark_edit-rename.svg</file>
         <file>24_dark_edit-rename.svg</file>
         <file>16_light_edit-rename.svg</file>
         <file>22_light_edit-rename.svg</file>
         <file>24_light_edit-rename.svg</file>
         <file>16_dark_edit-select-all.svg</file>
         <file>22_dark_edit-select-all.svg</file>
         <file>24_dark_edit-select-all.svg</file>
         <file>16_light_edit-select-all.svg</file>
         <file>22_light_edit-select-all.svg</file>
         <file>24_light_edit-select-all.svg</file>
         <file>16_dark_format-indent-less.svg</file>
         <file>22_dark_format-indent-less.svg</file>
         <file>24_dark_format-indent-less.svg</file>
         <file>16_light_format-indent-less.svg</file>
         <file>22_light_format-indent-less.svg</file>
         <file>24_light_format-indent-less.svg</file>
         <file>16_dark_format-indent-more.svg</file>
         <file>22_dark_format-indent-more.svg</file>
         <file>24_dark_format-indent-more.svg</file>
         <file>16_light_format-indent-more.svg</file>
         <file>22_light_format-indent-more.svg</file>
         <file>24_light_format-indent-more.svg</file>
         <file>16_dark_format-justify-center.svg</file>
         <file>22_dark_format-justify-center.svg</file>
         <file>24_dark_format-justify-center.svg</file>
         <file>16_light_format-justify-center.svg</file>
         <file>22_light_format-justify-center.svg</file>
         <file>24_light_format-justify-center.svg</file>
         <file>16_dark_format-justify-fill.svg</file>
         <file>22_dark_format-justify-fill.svg</file>
         <file>24_dark_format-justify-fill.svg</file>
         <file>16_light_format-justify-fill.svg</file>
         <file>22_light_format-justify-fill.svg</file>
         <file>24_light_format-justify-fill.svg</file>
         <file>16_dark_format-justify-left.svg</file>
         <file>22_dark_format-justify-left.svg</file>
         <file>24_dark_format-justify-left.svg</file>
         <file>16_light_format-justify-left.svg</file>
         <file>22_light_format-justify-left.svg</file>
         <file>24_light_format-justify-left.svg</file>
         <file>16_dark_format-justify-right.svg</file>
         <file>22_dark_format-justify-right.svg</file>
         <file>24_dark_format-justify-right.svg</file>
         <file>16_light_format-justify-right.svg</file>
         <file>22_light_format-justify-right.svg</file>
         <file>24_light_format-justify-right.svg</file>
         <file>16_dark_format-list-ordered.svg</file>
         <file>22_dark_format-list-ordered.svg</file>
         <file>24_dark_format-list-ordered.svg</file>
         <file>16_light_format-list-ordered.svg</file>
         <file>22_light_format-list-ordered.svg</file>
         <file>24_light_format-list-ordered.svg</file>
         <file>16_dark_format-stroke-color.svg</file>
         <file>22_dark_format-stroke-color.svg</file>
         <file>24_dark_format-stroke-color.svg</file>
         <file>16_light_format-stroke-color.svg</file>
         <file>22_light_format-stroke-color.svg</file>
         <file>24_light_format-stroke-color.svg</file>
         <file>16_dark_format-text-bold.svg</file>
         <file>22_dark_format-text-bold.svg</file>
         <file>24_dark_format-text-bold.svg</file>
         <file>16_light_format-text-bold.svg</file>
         <file>22_light_format-text-bold.svg</file>
         <file>24_light_format-text-bold.svg</file>
         <file>16_dark_format-text-color.svg</file>
         <file>22_dark_format-text-color.svg</file>
         <file>24_dark_format-text-color.svg</file>
         <file>16_light_format-text-color.svg</file>
         <file>22_light_format-text-color.svg</file>
         <file>24_light_format-text-color.svg</file>
         <file>16_dark_format-text-direction-rtl.svg</file>
         <file>22_dark_format-text-direction-rtl.svg</file>
         <file>24_dark_format-text-direction-rtl.svg</file>
         <file>16_light_format-text-direction-rtl.svg</file>
         <file>22_light_format-text-direction-rtl.svg</file>
         <file>24_light_format-text-direction-rtl.svg</file>
         <file>16_dark_format-text-italic.svg</file>
         <file>22_dark_format-text-italic.svg</file>
         <file>24_dark_format-text-italic.svg</file>
         <file>16_light_format-text-italic.svg</file>
         <file>22_light_format-text-italic.svg</file>
         <file>24_light_format-text-italic.svg</file>
         <file>16_dark_format-text-strikethrough.svg</file>
         <file>22_dark_format-text-strikethrough.svg</file>
         <file>24_dark_format-text-strikethrough.svg</file>
         <file>16_light_format-text-strikethrough.svg</file>
         <file>22_light_format-text-strikethrough.svg</file>
         <file>24_light_format-text-strikethrough.svg</file>
         <file>16_dark_format-text-subscript.svg</file>
         <file>22_dark_format-text-subscript.svg</file>
         <file>24_dark_format-text-subscript.svg</file>
         <file>16_light_format-text-subscript.svg</file>
         <file>22_light_format-text-subscript.svg</file>
         <file>24_light_format-text-subscript.svg</file>
         <file>16_dark_format-text-superscript.svg</file>
         <file>22_dark_format-text-superscript.svg</file>
         <file>24_dark_format-text-superscript.svg</file>
         <file>16_light_format-text-superscript.svg</file>
         <file>22_light_format-text-superscript.svg</file>
         <file>24_light_format-text-superscript.svg</file>
         <file>16_dark_format-text-underline.svg</file>
         <file>22_dark_format-text-underline.svg</file>
         <file>24_dark_format-text-underline.svg</file>
         <file>16_light_format-text-underline.svg</file>
         <file>22_light_format-text-underline.svg</file>
         <file>24_light_format-text-underline.svg</file>
         <file>16_dark_insert-text.svg</file>
         <file>22_dark_insert-text.svg</file>
         <file>24_dark_insert-text.svg</file>
         <file>16_light_insert-text.svg</file>
         <file>22_light_insert-text.svg</file>
         <file>24_light_insert-text.svg</file>
         <file>48_dark_klipper.svg</file>
         <file>48_light_klipper.svg</file>
         <file>16_dark_list-remove.svg</file>
         <file>22_dark_list-remove.svg</file>
         <file>24_dark_list-remove.svg</file>
         <file>16_light_list-remove.svg</file>
         <file>22_light_list-remove.svg</file>
         <file>24_light_list-remove.svg</file>
         <file>16_dark_media-floppy.svg</file>
         <file>22_dark_media-floppy.svg</file>
         <file>16_light_media-floppy.svg</file>
         <file>22_light_media-floppy.svg</file>
         <file>16_dark_object-align-horizontal-center-calligra.svg</file>
         <file>22_dark_object-align-horizontal-center-calligra.svg</file>
         <file>16_light_object-align-horizontal-center-calligra.svg</file>
         <file>22_light_object-align-horizontal-center-calligra.svg</file>
         <file>16_dark_object-align-horizontal-left-calligra.svg</file>
         <file>22_dark_object-align-horizontal-left-calligra.svg</file>
         <file>16_light_object-align-horizontal-left-calligra.svg</file>
         <file>22_light_object-align-horizontal-left-calligra.svg</file>
         <file>16_dark_object-align-vertical-top-calligra.svg</file>
         <file>22_dark_object-align-vertical-top-calligra.svg</file>
         <file>16_light_object-align-vertical-top-calligra.svg</file>
         <file>22_light_object-align-vertical-top-calligra.svg</file>
         <file>16_dark_object-group-calligra.svg</file>
         <file>22_dark_object-group-calligra.svg</file>
         <file>16_light_object-group-calligra.svg</file>
         <file>22_light_object-group-calligra.svg</file>
         <file>16_dark_shape-choose.svg</file>
         <file>22_dark_shape-choose.svg</file>
         <file>16_light_shape-choose.svg</file>
         <file>22_light_shape-choose.svg</file>
         <file>16_dark_snap-extension.svg</file>
         <file>22_dark_snap-extension.svg</file>
         <file>24_dark_snap-extension.svg</file>
         <file>16_light_snap-extension.svg</file>
         <file>22_light_snap-extension.svg</file>
         <file>24_light_snap-extension.svg</file>
         <file>16_dark_snap-guideline.svg</file>
         <file>22_dark_snap-guideline.svg</file>
         <file>24_dark_snap-guideline.svg</file>
         <file>16_light_snap-guideline.svg</file>
         <file>22_light_snap-guideline.svg</file>
         <file>24_light_snap-guideline.svg</file>
         <file>16_dark_snap-intersection.svg</file>
         <file>22_dark_snap-intersection.svg</file>
         <file>24_dark_snap-intersection.svg</file>
         <file>16_light_snap-intersection.svg</file>
         <file>22_light_snap-intersection.svg</file>
         <file>24_light_snap-intersection.svg</file>
         <file>16_dark_snap-node.svg</file>
         <file>22_dark_snap-node.svg</file>
         <file>24_dark_snap-node.svg</file>
         <file>16_light_snap-node.svg</file>
         <file>22_light_snap-node.svg</file>
         <file>24_light_snap-node.svg</file>
         <file>22_dark_snap-orthogonal.svg</file>
         <file>24_dark_snap-orthogonal.svg</file>
         <file>22_light_snap-orthogonal.svg</file>
         <file>24_light_snap-orthogonal.svg</file>
         <file>16_dark_split.svg</file>
         <file>22_dark_split.svg</file>
         <file>24_dark_split.svg</file>
         <file>16_light_split.svg</file>
         <file>22_light_split.svg</file>
         <file>24_light_split.svg</file>
         <file>16_dark_tab-close.svg</file>
         <file>22_dark_tab-close.svg</file>
         <file>24_dark_tab-close.svg</file>
         <file>16_light_tab-close.svg</file>
         <file>22_light_tab-close.svg</file>
         <file>24_light_tab-close.svg</file>
         <file>16_dark_tab-new.svg</file>
         <file>22_dark_tab-new.svg</file>
         <file>24_dark_tab-new.svg</file>
         <file>16_light_tab-new.svg</file>
         <file>22_light_tab-new.svg</file>
         <file>24_light_tab-new.svg</file>
         <file>16_dark_transform-move.svg</file>
         <file>22_dark_transform-move.svg</file>
         <file>24_dark_transform-move.svg</file>
         <file>16_light_transform-move.svg</file>
         <file>22_light_transform-move.svg</file>
         <file>24_light_transform-move.svg</file>
         <file>16_dark_trash-empty.svg</file>
         <file>22_dark_trash-empty.svg</file>
         <file>24_dark_trash-empty.svg</file>
         <file>16_light_trash-empty.svg</file>
         <file>22_light_trash-empty.svg</file>
         <file>24_light_trash-empty.svg</file>
         <file>16_dark_zoom-fit-best.svg</file>
         <file>22_dark_zoom-fit-best.svg</file>
         <file>24_dark_zoom-fit-best.svg</file>
         <file>16_light_zoom-fit-best.svg</file>
         <file>22_light_zoom-fit-best.svg</file>
         <file>24_light_zoom-fit-best.svg</file>
         <file>16_dark_warning.svg</file>
         <file>16_light_warning.svg</file>
     </qresource>
 </RCC>
diff --git a/pics/calligrakrita-base.svg b/pics/krita-base.svg
similarity index 100%
rename from pics/calligrakrita-base.svg
rename to pics/krita-base.svg
diff --git a/pics/calligrakrita.png b/pics/krita.png
similarity index 100%
rename from pics/calligrakrita.png
rename to pics/krita.png
diff --git a/plugins/assistants/Assistants/ConcentricEllipseAssistant.cc b/plugins/assistants/Assistants/ConcentricEllipseAssistant.cc
index 3fd53bd449..8c14b969bf 100644
--- a/plugins/assistants/Assistants/ConcentricEllipseAssistant.cc
+++ b/plugins/assistants/Assistants/ConcentricEllipseAssistant.cc
@@ -1,208 +1,208 @@
 /*
  * 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.
  */
 
 #include "ConcentricEllipseAssistant.h"
 
 #include <klocalizedstring.h>
 #include "kis_debug.h"
 #include <QPainter>
 #include <QLinearGradient>
 #include <QTransform>
 #include <kis_canvas2.h>
 #include <kis_coordinates_converter.h>
 #include <kis_algebra_2d.h>
 
 #include <math.h>
 
 ConcentricEllipseAssistant::ConcentricEllipseAssistant()
         : KisPaintingAssistant("concentric ellipse", i18n("Concentric Ellipse assistant"))
 {
 }
 
 KisPaintingAssistantSP ConcentricEllipseAssistant::clone(QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap) const
 {
     return KisPaintingAssistantSP(new ConcentricEllipseAssistant(*this, handleMap));
 }
 
 ConcentricEllipseAssistant::ConcentricEllipseAssistant(const ConcentricEllipseAssistant &rhs, QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap)
     : KisPaintingAssistant(rhs, handleMap)
     , m_ellipse(rhs.m_ellipse)
     , m_extraEllipse(rhs.m_extraEllipse)
 {
 }
 
 QPointF ConcentricEllipseAssistant::project(const QPointF& pt, const QPointF& strokeBegin) const
 {
     Q_ASSERT(isAssistantComplete());
     m_ellipse.set(*handles()[0], *handles()[1], *handles()[2]);
 
     qreal
             dx = pt.x() - strokeBegin.x(),
             dy = pt.y() - strokeBegin.y();
         if (dx * dx + dy * dy < 4.0) {
             // allow some movement before snapping
             return strokeBegin;
         }
     //calculate ratio
     QPointF initial = m_ellipse.project(strokeBegin);
     QPointF center = m_ellipse.boundingRect().center();
     qreal Ratio = QLineF(center, strokeBegin).length() /QLineF(center, initial).length();
 
     //calculate the points of the extrapolated ellipse.
     QLineF extrapolate0 = QLineF(center, *handles()[0]);
     extrapolate0.setLength(extrapolate0.length()*Ratio);
     QLineF extrapolate1 = QLineF(center, *handles()[1]);
     extrapolate1.setLength(extrapolate1.length()*Ratio);
     QLineF extrapolate2 = QLineF(center, *handles()[2]);
     extrapolate2.setLength(extrapolate2.length()*Ratio);
 
     //set the extrapolation ellipse.
     m_extraEllipse.set(extrapolate0.p2(), extrapolate1.p2(), extrapolate2.p2());
 
     return m_extraEllipse.project(pt);
 }
 
 QPointF ConcentricEllipseAssistant::adjustPosition(const QPointF& pt, const QPointF& strokeBegin)
 {
     return project(pt, strokeBegin);
 
 }
 
 void ConcentricEllipseAssistant::drawAssistant(QPainter& gc, const QRectF& updateRect, const KisCoordinatesConverter* converter, bool cached, KisCanvas2* canvas, bool assistantVisible, bool previewVisible)
 {
     gc.save();
     gc.resetTransform();
     QPointF mousePos;
 
     if (canvas){
         //simplest, cheapest way to get the mouse-position//
         mousePos= canvas->canvasWidget()->mapFromGlobal(QCursor::pos());
     }
     else {
         //...of course, you need to have access to a canvas-widget for that.//
         mousePos = QCursor::pos();//this'll give an offset//
         dbgFile<<"canvas does not exist in the ellipse assistant, you may have passed arguments incorrectly:"<<canvas;
     }
 
     QTransform initialTransform = converter->documentToWidgetTransform();
 
     if (isSnappingActive() && previewVisible == true){
 
         if (isAssistantComplete()){
             if (m_ellipse.set(*handles()[0], *handles()[1], *handles()[2])) {
                 QPointF initial = m_ellipse.project(initialTransform.inverted().map(mousePos));
                 QPointF center = m_ellipse.boundingRect().center();
                 qreal Ratio = QLineF(center, initialTransform.inverted().map(mousePos)).length() /QLineF(center, initial).length();
                 //line from center to handle 1 * difference.
                 //set handle1 translated to
                 // valid ellipse
                 gc.setTransform(initialTransform);
                 gc.setTransform(m_ellipse.getInverse(), true);
                 QPainterPath path;
                 // Draw the ellipse
                 path.addEllipse(QPointF(0, 0), m_ellipse.semiMajor()*Ratio, m_ellipse.semiMinor()*Ratio);
                 drawPreview(gc, path);
             }
         }
     }
     gc.restore();
     KisPaintingAssistant::drawAssistant(gc, updateRect, converter, cached, canvas, assistantVisible, previewVisible);
 
 }
 
 
 void ConcentricEllipseAssistant::drawCache(QPainter& gc, const KisCoordinatesConverter *converter, bool assistantVisible)
 {
     if (assistantVisible == false || handles().size() < 2) { // 2 points means a line, so we can continue after 1 point
         return;
     }
 
     QTransform initialTransform = converter->documentToWidgetTransform();
 
     if (handles().size() == 2) {
         // just draw the axis
         gc.setTransform(initialTransform);
         QPainterPath path;
         path.moveTo(*handles()[0]);
         path.lineTo(*handles()[1]);
         drawPath(gc, path, isSnappingActive());
         return;
     }
 
     if (m_ellipse.set(*handles()[0], *handles()[1], *handles()[2])) {
         // valid ellipse
 
         gc.setTransform(initialTransform);
         gc.setTransform(m_ellipse.getInverse(), true);
         QPainterPath path;
         path.moveTo(QPointF(-m_ellipse.semiMajor(), 0)); path.lineTo(QPointF(m_ellipse.semiMajor(), 0));
         path.moveTo(QPointF(0, -m_ellipse.semiMinor())); path.lineTo(QPointF(0, m_ellipse.semiMinor()));
         // Draw the ellipse
         path.addEllipse(QPointF(0, 0), m_ellipse.semiMajor(), m_ellipse.semiMinor());
         drawPath(gc, path, isSnappingActive());
     }
 }
 
 QRect ConcentricEllipseAssistant::boundingRect() const
 {
     if (!isAssistantComplete()) {
         return KisPaintingAssistant::boundingRect();
     }
 
     if (m_ellipse.set(*handles()[0], *handles()[1], *handles()[2])) {
         return m_ellipse.boundingRect().adjusted(-2, -2, 2, 2).toAlignedRect();
     } else {
         return QRect();
     }
 }
 
-QPointF ConcentricEllipseAssistant::buttonPosition() const
+QPointF ConcentricEllipseAssistant::getEditorPosition() const
 {
     return (*handles()[0] + *handles()[1]) * 0.5;
 }
 
 bool ConcentricEllipseAssistant::isAssistantComplete() const
 {
     return handles().size() >= 3;
 }
 
 
 ConcentricEllipseAssistantFactory::ConcentricEllipseAssistantFactory()
 {
 }
 
 ConcentricEllipseAssistantFactory::~ConcentricEllipseAssistantFactory()
 {
 }
 
 QString ConcentricEllipseAssistantFactory::id() const
 {
     return "concentric ellipse";
 }
 
 QString ConcentricEllipseAssistantFactory::name() const
 {
     return i18n("Concentric Ellipse");
 }
 
 KisPaintingAssistant* ConcentricEllipseAssistantFactory::createPaintingAssistant() const
 {
     return new ConcentricEllipseAssistant;
 }
diff --git a/plugins/assistants/Assistants/ConcentricEllipseAssistant.h b/plugins/assistants/Assistants/ConcentricEllipseAssistant.h
index 55200afa59..3d972ef98c 100644
--- a/plugins/assistants/Assistants/ConcentricEllipseAssistant.h
+++ b/plugins/assistants/Assistants/ConcentricEllipseAssistant.h
@@ -1,60 +1,60 @@
 /*
  * 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 buttonPosition() const override;
+    QPointF getEditorPosition() const override;
     int numHandles() const override { return 3; }
     bool isAssistantComplete() const 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/assistants/Assistants/EllipseAssistant.cc b/plugins/assistants/Assistants/EllipseAssistant.cc
index 4431886c15..8b3b16c64c 100644
--- a/plugins/assistants/Assistants/EllipseAssistant.cc
+++ b/plugins/assistants/Assistants/EllipseAssistant.cc
@@ -1,181 +1,181 @@
 /*
  * 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.
  */
 
 #include "EllipseAssistant.h"
 
 #include <klocalizedstring.h>
 #include "kis_debug.h"
 #include <QPainter>
 #include <QLinearGradient>
 #include <QTransform>
 
 #include <kis_canvas2.h>
 #include <kis_coordinates_converter.h>
 
 #include <math.h>
 
 EllipseAssistant::EllipseAssistant()
         : KisPaintingAssistant("ellipse", i18n("Ellipse assistant"))
 {
 }
 
 EllipseAssistant::EllipseAssistant(const EllipseAssistant &rhs, QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap)
     : KisPaintingAssistant(rhs, handleMap)
     , e(rhs.e)
 {
 }
 
 KisPaintingAssistantSP EllipseAssistant::clone(QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap) const
 {
     return KisPaintingAssistantSP(new EllipseAssistant(*this, handleMap));
 }
 
 QPointF EllipseAssistant::project(const QPointF& pt) const
 {
     Q_ASSERT(isAssistantComplete());
     e.set(*handles()[0], *handles()[1], *handles()[2]);
     return e.project(pt);
 }
 
 QPointF EllipseAssistant::adjustPosition(const QPointF& pt, const QPointF& /*strokeBegin*/)
 {
     return project(pt);
 
 }
 
 void EllipseAssistant::drawAssistant(QPainter& gc, const QRectF& updateRect, const KisCoordinatesConverter* converter, bool cached, KisCanvas2* canvas, bool assistantVisible, bool previewVisible)
 {
     gc.save();
     gc.resetTransform();
     QPoint mousePos;
     
     if (canvas){
         //simplest, cheapest way to get the mouse-position//
         mousePos= canvas->canvasWidget()->mapFromGlobal(QCursor::pos());
     }
     else {
         //...of course, you need to have access to a canvas-widget for that.//
         mousePos = QCursor::pos();//this'll give an offset//
         dbgFile<<"canvas does not exist in the ellipse assistant, you may have passed arguments incorrectly:"<<canvas;
     }
 
     QTransform initialTransform = converter->documentToWidgetTransform();
 
     if (isSnappingActive() && boundingRect().contains(initialTransform.inverted().map(mousePos), false) && previewVisible==true){
 
         if (isAssistantComplete()){
             if (e.set(*handles()[0], *handles()[1], *handles()[2])) {
                 // valid ellipse
                 gc.setTransform(initialTransform);
                 gc.setTransform(e.getInverse(), true);
                 QPainterPath path;
                 //path.moveTo(QPointF(-e.semiMajor(), 0)); path.lineTo(QPointF(e.semiMajor(), 0));
                 //path.moveTo(QPointF(0, -e.semiMinor())); path.lineTo(QPointF(0, e.semiMinor()));
                 // Draw the ellipse
                 path.addEllipse(QPointF(0, 0), e.semiMajor(), e.semiMinor());
                 drawPreview(gc, path);
             }
         }
     }
     gc.restore();
     KisPaintingAssistant::drawAssistant(gc, updateRect, converter, cached, canvas, assistantVisible, previewVisible);
 
 }
 
 
 void EllipseAssistant::drawCache(QPainter& gc, const KisCoordinatesConverter *converter, bool assistantVisible)
 {
 
     if (assistantVisible == false || handles().size() < 2){
         return;
     }
 
     QTransform initialTransform = converter->documentToWidgetTransform();
 
     if (handles().size() == 2) {
         // just draw the axis
         gc.setTransform(initialTransform);
         QPainterPath path;
         path.moveTo(*handles()[0]);
         path.lineTo(*handles()[1]);
         drawPath(gc, path, isSnappingActive());
         return;
     }
     if (e.set(*handles()[0], *handles()[1], *handles()[2])) {
         // valid ellipse
 
         gc.setTransform(initialTransform);
         gc.setTransform(e.getInverse(), true);
         QPainterPath path;
         path.moveTo(QPointF(-e.semiMajor(), 0)); path.lineTo(QPointF(e.semiMajor(), 0));
         path.moveTo(QPointF(0, -e.semiMinor())); path.lineTo(QPointF(0, e.semiMinor()));
         // Draw the ellipse
         path.addEllipse(QPointF(0, 0), e.semiMajor(), e.semiMinor());
         drawPath(gc, path, isSnappingActive());
     }
 }
 
 QRect EllipseAssistant::boundingRect() const
 {
     if (!isAssistantComplete()) {
         return KisPaintingAssistant::boundingRect();
     }
 
     if (e.set(*handles()[0], *handles()[1], *handles()[2])) {
         return e.boundingRect().adjusted(-2, -2, 2, 2).toAlignedRect();
     } else {
         return QRect();
     }
 }
 
-QPointF EllipseAssistant::buttonPosition() const
+QPointF EllipseAssistant::getEditorPosition() const
 {
     return (*handles()[0] + *handles()[1]) * 0.5;
 }
 
 bool EllipseAssistant::isAssistantComplete() const
 {
     return handles().size() >= 3;
 }
 
 
 
 EllipseAssistantFactory::EllipseAssistantFactory()
 {
 }
 
 EllipseAssistantFactory::~EllipseAssistantFactory()
 {
 }
 
 QString EllipseAssistantFactory::id() const
 {
     return "ellipse";
 }
 
 QString EllipseAssistantFactory::name() const
 {
     return i18n("Ellipse");
 }
 
 KisPaintingAssistant* EllipseAssistantFactory::createPaintingAssistant() const
 {
     return new EllipseAssistant;
 }
diff --git a/plugins/assistants/Assistants/EllipseAssistant.h b/plugins/assistants/Assistants/EllipseAssistant.h
index 6e3b6b02aa..b66b206244 100644
--- a/plugins/assistants/Assistants/EllipseAssistant.h
+++ b/plugins/assistants/Assistants/EllipseAssistant.h
@@ -1,58 +1,58 @@
 /*
  * 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 _ELLIPSE_ASSISTANT_H_
 #define _ELLIPSE_ASSISTANT_H_
 
 #include "kis_painting_assistant.h"
 #include "Ellipse.h"
 #include <QObject>
 
 class EllipseAssistant : public KisPaintingAssistant
 {
 public:
     EllipseAssistant();
     KisPaintingAssistantSP clone(QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap) const override;
     QPointF adjustPosition(const QPointF& point, const QPointF& strokeBegin) override;
-    QPointF buttonPosition() const override;
+    QPointF getEditorPosition() const override;
     int numHandles() const override { return 3; }
     bool isAssistantComplete() const 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;
     explicit EllipseAssistant(const EllipseAssistant &rhs, QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap);
     mutable Ellipse e;
 };
 
 class EllipseAssistantFactory : public KisPaintingAssistantFactory
 {
 public:
     EllipseAssistantFactory();
     ~EllipseAssistantFactory() override;
     QString id() const override;
     QString name() const override;
     KisPaintingAssistant* createPaintingAssistant() const override;
 };
 
 #endif
diff --git a/plugins/assistants/Assistants/FisheyePointAssistant.cc b/plugins/assistants/Assistants/FisheyePointAssistant.cc
index 610f2664fa..8338f4b4ab 100644
--- a/plugins/assistants/Assistants/FisheyePointAssistant.cc
+++ b/plugins/assistants/Assistants/FisheyePointAssistant.cc
@@ -1,238 +1,238 @@
 /*
  * Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
  * Copyright (c) 2010 Geoffry Song <goffrie@gmail.com>
  * Copyright (c) 2014 Wolthera van Hövell tot Westerflier <griffinvalley@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.
  */
 
 #include "FisheyePointAssistant.h"
 
 #include "kis_debug.h"
 #include <klocalizedstring.h>
 
 #include <QPainter>
 #include <QLinearGradient>
 #include <QTransform>
 
 #include <kis_canvas2.h>
 #include <kis_coordinates_converter.h>
 #include <kis_algebra_2d.h>
 
 #include <math.h>
 #include <limits>
 
 FisheyePointAssistant::FisheyePointAssistant()
         : KisPaintingAssistant("fisheye-point", i18n("Fish Eye Point assistant"))
 {
 }
 
 FisheyePointAssistant::FisheyePointAssistant(const FisheyePointAssistant &rhs, QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap)
     : KisPaintingAssistant(rhs, handleMap)
     , e(rhs.e)
     , extraE(rhs.extraE)
 {
 }
 
 KisPaintingAssistantSP FisheyePointAssistant::clone(QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap) const
 {
     return KisPaintingAssistantSP(new FisheyePointAssistant(*this, handleMap));
 }
 
 QPointF FisheyePointAssistant::project(const QPointF& pt, const QPointF& strokeBegin)
 {
     const static QPointF nullPoint(std::numeric_limits<qreal>::quiet_NaN(), std::numeric_limits<qreal>::quiet_NaN());
     Q_ASSERT(isAssistantComplete());
     e.set(*handles()[0], *handles()[1], *handles()[2]);
 
     qreal
             dx = pt.x() - strokeBegin.x(),
             dy = pt.y() - strokeBegin.y();
         if (dx * dx + dy * dy < 4.0) {
             // allow some movement before snapping
             return strokeBegin;
         }
 
     //set the extrapolation ellipse.
     if (e.set(*handles()[0], *handles()[1], *handles()[2])){
         QLineF radius(*handles()[1], *handles()[0]);
         radius.setAngle(fmod(radius.angle()+180.0,360.0));
         QLineF radius2(*handles()[0], *handles()[1]);
         radius2.setAngle(fmod(radius2.angle()+180.0,360.0));
         if ( extraE.set(*handles()[0], *handles()[1],strokeBegin ) ) {
             return extraE.project(pt);
         } else if (extraE.set(radius.p1(), radius.p2(),strokeBegin)) {
             return extraE.project(pt);
         } else if (extraE.set(radius2.p1(), radius2.p2(),strokeBegin)){
             return extraE.project(pt);
         }   
     }
     
     return nullPoint;
     
 }
 
 QPointF FisheyePointAssistant::adjustPosition(const QPointF& pt, const QPointF& strokeBegin)
 {
     return project(pt, strokeBegin);
 }
 
 void FisheyePointAssistant::drawAssistant(QPainter& gc, const QRectF& updateRect, const KisCoordinatesConverter* converter, bool cached, KisCanvas2* canvas, bool assistantVisible, bool previewVisible)
 {
     gc.save();
     gc.resetTransform();
 
     QPointF mousePos(0,0);
     
     if (canvas){
         //simplest, cheapest way to get the mouse-position//
         mousePos= canvas->canvasWidget()->mapFromGlobal(QCursor::pos());
     }
     else {
         //...of course, you need to have access to a canvas-widget for that.//
         mousePos = QCursor::pos();//this'll give an offset//
         dbgFile<<"canvas does not exist in ruler, you may have passed arguments incorrectly:"<<canvas;
     }
     
     QTransform initialTransform = converter->documentToWidgetTransform();
     
     if (isSnappingActive() && previewVisible == true ) {
 
         if (isAssistantComplete()){
                 
             if (e.set(*handles()[0], *handles()[1], *handles()[2])) {
                 if (extraE.set(*handles()[0], *handles()[1], initialTransform.inverted().map(mousePos))){
                     gc.setTransform(initialTransform);
                     gc.setTransform(e.getInverse(), true);
                     QPainterPath path;
                     // Draw the ellipse
                     path.addEllipse(QPointF(0, 0), extraE.semiMajor(), extraE.semiMinor());
                     drawPreview(gc, path);
                 }
                 QLineF radius(*handles()[1], *handles()[0]);
                 radius.setAngle(fmod(radius.angle()+180.0,360.0));
                 if (extraE.set(radius.p1(), radius.p2(), initialTransform.inverted().map(mousePos))){
                     gc.setTransform(initialTransform);
                     gc.setTransform(extraE.getInverse(), true);
                     QPainterPath path;
                     // Draw the ellipse
                     path.addEllipse(QPointF(0, 0), extraE.semiMajor(), extraE.semiMinor());
                     drawPreview(gc, path);
                 }
                 QLineF radius2(*handles()[0], *handles()[1]);
                 radius2.setAngle(fmod(radius2.angle()+180.0,360.0));
                 if (extraE.set(radius2.p1(), radius2.p2(), initialTransform.inverted().map(mousePos))){
                     gc.setTransform(initialTransform);
                     gc.setTransform(extraE.getInverse(), true);
                     QPainterPath path;
                     // Draw the ellipse
                     path.addEllipse(QPointF(0, 0), extraE.semiMajor(), extraE.semiMinor());
                     drawPreview(gc, path);
                 }
                 
             }
         }
     }
     gc.restore();
     
     KisPaintingAssistant::drawAssistant(gc, updateRect, converter, cached, canvas, assistantVisible, previewVisible);
 
 }
 
 void FisheyePointAssistant::drawCache(QPainter& gc, const KisCoordinatesConverter *converter, bool assistantVisible)
 {
     if (assistantVisible == false){
         return;
     }
     
     QTransform initialTransform = converter->documentToWidgetTransform();
 
     if (handles().size() == 2) {
         // just draw the axis
         gc.setTransform(initialTransform);
         QPainterPath path;
         path.moveTo(*handles()[0]);
         path.lineTo(*handles()[1]);
         drawPath(gc, path, isSnappingActive());
         return;
     }
     if (e.set(*handles()[0], *handles()[1], *handles()[2])) {
         // valid ellipse
 
         gc.setTransform(initialTransform);
         gc.setTransform(e.getInverse(), true);
         QPainterPath path;
         //path.moveTo(QPointF(-e.semiMajor(), -e.semiMinor())); path.lineTo(QPointF(e.semiMajor(), -e.semiMinor()));
         path.moveTo(QPointF(-e.semiMajor(), -e.semiMinor())); path.lineTo(QPointF(-e.semiMajor(), e.semiMinor()));
         //path.moveTo(QPointF(-e.semiMajor(), e.semiMinor())); path.lineTo(QPointF(e.semiMajor(), e.semiMinor()));
         path.moveTo(QPointF(e.semiMajor(), -e.semiMinor())); path.lineTo(QPointF(e.semiMajor(), e.semiMinor()));
         path.moveTo(QPointF(-(e.semiMajor()*3), -e.semiMinor())); path.lineTo(QPointF(-(e.semiMajor()*3), e.semiMinor()));
         path.moveTo(QPointF((e.semiMajor()*3), -e.semiMinor())); path.lineTo(QPointF((e.semiMajor()*3), e.semiMinor()));
         path.moveTo(QPointF(-e.semiMajor(), 0)); path.lineTo(QPointF(e.semiMajor(), 0));
         //path.moveTo(QPointF(0, -e.semiMinor())); path.lineTo(QPointF(0, e.semiMinor()));
         // Draw the ellipse
         path.addEllipse(QPointF(0, 0), e.semiMajor(), e.semiMinor());
         drawPath(gc, path, isSnappingActive());
     }
     
 }
 
 QRect FisheyePointAssistant::boundingRect() const
 {
     if (!isAssistantComplete()) {
         return KisPaintingAssistant::boundingRect();
     }
 
     if (e.set(*handles()[0], *handles()[1], *handles()[2])) {
         return e.boundingRect().adjusted(-(e.semiMajor()*2), -2, (e.semiMajor()*2), 2).toAlignedRect();
     } else {
         return QRect();
     }
 }
 
-QPointF FisheyePointAssistant::buttonPosition() const
+QPointF FisheyePointAssistant::getEditorPosition() const
 {
     return (*handles()[0] + *handles()[1]) * 0.5;
 }
 
 bool FisheyePointAssistant::isAssistantComplete() const
 {
     return handles().size() >= 3;
 }
 
 
 FisheyePointAssistantFactory::FisheyePointAssistantFactory()
 {
 }
 
 FisheyePointAssistantFactory::~FisheyePointAssistantFactory()
 {
 }
 
 QString FisheyePointAssistantFactory::id() const
 {
     return "fisheye-point";
 }
 
 QString FisheyePointAssistantFactory::name() const
 {
     return i18n("Fish Eye Point");
 }
 
 KisPaintingAssistant* FisheyePointAssistantFactory::createPaintingAssistant() const
 {
     return new FisheyePointAssistant;
 }
diff --git a/plugins/assistants/Assistants/FisheyePointAssistant.h b/plugins/assistants/Assistants/FisheyePointAssistant.h
index f2a27d5a48..db661db29f 100644
--- a/plugins/assistants/Assistants/FisheyePointAssistant.h
+++ b/plugins/assistants/Assistants/FisheyePointAssistant.h
@@ -1,66 +1,66 @@
 /*
  * Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
  * Copyright (c) 2010 Geoffry Song <goffrie@gmail.com>
  * Copyright (c) 2014 Wolthera van Hövell tot Westerflier <griffinvalley@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 _FISHEYEPOINT_ASSISTANT_H_
 #define _FISHEYEPOINT_ASSISTANT_H_
 
 #include "kis_painting_assistant.h"
 #include "Ellipse.h"
 #include <QObject>
 #include <QPolygonF>
 #include <QLineF>
 #include <QTransform>
 //class FisheyePoint;
 
 class FisheyePointAssistant : public KisPaintingAssistant
 {
 public:
     FisheyePointAssistant();
     KisPaintingAssistantSP clone(QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap) const override;
     QPointF adjustPosition(const QPointF& point, const QPointF& strokeBegin) override;
     //virtual void endStroke();
-    QPointF buttonPosition() const override;
+    QPointF getEditorPosition() const override;
     int numHandles() const override { return 3; }
 
     bool isAssistantComplete() const override;
 
 protected:
     QRect boundingRect() const override;
     void drawAssistant(QPainter& gc, const QRectF& updateRect, const KisCoordinatesConverter* converter, bool  cached = true,KisCanvas2* canvas=0, 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);
     explicit FisheyePointAssistant(const FisheyePointAssistant &rhs, QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap);
     mutable Ellipse e;
     mutable Ellipse extraE;
 };
 
 class FisheyePointAssistantFactory : public KisPaintingAssistantFactory
 {
 public:
     FisheyePointAssistantFactory();
     ~FisheyePointAssistantFactory() override;
     QString id() const override;
     QString name() const override;
     KisPaintingAssistant* createPaintingAssistant() const override;
 };
 
 #endif
diff --git a/plugins/assistants/Assistants/InfiniteRulerAssistant.cc b/plugins/assistants/Assistants/InfiniteRulerAssistant.cc
index f85a188367..4fe1907137 100644
--- a/plugins/assistants/Assistants/InfiniteRulerAssistant.cc
+++ b/plugins/assistants/Assistants/InfiniteRulerAssistant.cc
@@ -1,171 +1,171 @@
 /*
  * Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
  * Copyright (c) 2010 Geoffry Song <goffrie@gmail.com>
  * Copyright (c) 2014 Wolthera van Hövell tot Westerflier <griffinvalley@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.
  */
 
 #include "InfiniteRulerAssistant.h"
 
 #include "kis_debug.h"
 #include <klocalizedstring.h>
 
 #include <QPainter>
 #include <QLinearGradient>
 #include <QTransform>
 
 #include <kis_canvas2.h>
 #include <kis_coordinates_converter.h>
 #include <kis_algebra_2d.h>
 
 #include <math.h>
 
 InfiniteRulerAssistant::InfiniteRulerAssistant()
         : KisPaintingAssistant("infinite ruler", i18n("Infinite Ruler assistant"))
 {
 }
 
 InfiniteRulerAssistant::InfiniteRulerAssistant(const InfiniteRulerAssistant &rhs, QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap)
     : KisPaintingAssistant(rhs, handleMap)
 {
 }
 
 KisPaintingAssistantSP InfiniteRulerAssistant::clone(QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap) const
 {
     return KisPaintingAssistantSP(new InfiniteRulerAssistant(*this, handleMap));
 }
 
 QPointF InfiniteRulerAssistant::project(const QPointF& pt, const QPointF& strokeBegin)
 {
     Q_ASSERT(isAssistantComplete());
     //code nicked from the perspective ruler.
     qreal
             dx = pt.x() - strokeBegin.x(),
             dy = pt.y() - strokeBegin.y();
         if (dx * dx + dy * dy < 4.0) {
             // allow some movement before snapping
             return strokeBegin;
         }
     //dbgKrita<<strokeBegin<< ", " <<*handles()[0];
     QLineF snapLine = QLineF(*handles()[0], *handles()[1]);
     
     
         dx = snapLine.dx();
         dy = snapLine.dy();
     const qreal
         dx2 = dx * dx,
         dy2 = dy * dy,
         invsqrlen = 1.0 / (dx2 + dy2);
     QPointF r(dx2 * pt.x() + dy2 * snapLine.x1() + dx * dy * (pt.y() - snapLine.y1()),
               dx2 * snapLine.y1() + dy2 * pt.y() + dx * dy * (pt.x() - snapLine.x1()));
     r *= invsqrlen;
     return r;
     //return pt;
 }
 
 QPointF InfiniteRulerAssistant::adjustPosition(const QPointF& pt, const QPointF& strokeBegin)
 {
     return project(pt, strokeBegin);
 }
 
 void InfiniteRulerAssistant::drawAssistant(QPainter& gc, const QRectF& updateRect, const KisCoordinatesConverter* converter, bool cached, KisCanvas2* canvas, bool assistantVisible, bool previewVisible)
 {
     gc.save();
     gc.resetTransform();
     QPointF mousePos(0,0);
     
     if (canvas){
         //simplest, cheapest way to get the mouse-position//
         mousePos= canvas->canvasWidget()->mapFromGlobal(QCursor::pos());
     }
     else {
         //...of course, you need to have access to a canvas-widget for that.//
         mousePos = QCursor::pos();//this'll give an offset//
         dbgFile<<"canvas does not exist in ruler, you may have passed arguments incorrectly:"<<canvas;
     }
 
 
     
     if (isAssistantComplete() && isSnappingActive() && previewVisible == true) {
         //don't draw if invalid.
         QTransform initialTransform = converter->documentToWidgetTransform();
         QLineF snapLine= QLineF(initialTransform.map(*handles()[0]), initialTransform.map(*handles()[1]));
         QRect viewport= gc.viewport();
         KisAlgebra2D::intersectLineRect(snapLine, viewport);
         QPainterPath path;
         path.moveTo(snapLine.p1());
         path.lineTo(snapLine.p2());
         drawPreview(gc, path);//and we draw the preview.
     }
     gc.restore();
     
     KisPaintingAssistant::drawAssistant(gc, updateRect, converter, cached, canvas, assistantVisible, previewVisible);
 
 }
 
 void InfiniteRulerAssistant::drawCache(QPainter& gc, const KisCoordinatesConverter *converter, bool assistantVisible)
 {
     if (assistantVisible == false || !isAssistantComplete()){
         return;
     }
 
     QTransform initialTransform = converter->documentToWidgetTransform();
 
     // Draw the line
     QPointF p1 = *handles()[0];
     QPointF p2 = *handles()[1];
 
     gc.setTransform(initialTransform);
     QPainterPath path;
     path.moveTo(p1);
     path.lineTo(p2);
     drawPath(gc, path, isSnappingActive());
     
 }
 
-QPointF InfiniteRulerAssistant::buttonPosition() const
+QPointF InfiniteRulerAssistant::getEditorPosition() const
 {
     return (*handles()[0]);
 }
 
 bool InfiniteRulerAssistant::isAssistantComplete() const
 {
     return handles().size() >= 2;
 }
 
 InfiniteRulerAssistantFactory::InfiniteRulerAssistantFactory()
 {
 }
 
 InfiniteRulerAssistantFactory::~InfiniteRulerAssistantFactory()
 {
 }
 
 QString InfiniteRulerAssistantFactory::id() const
 {
     return "infinite ruler";
 }
 
 QString InfiniteRulerAssistantFactory::name() const
 {
     return i18n("Infinite Ruler");
 }
 
 KisPaintingAssistant* InfiniteRulerAssistantFactory::createPaintingAssistant() const
 {
     return new InfiniteRulerAssistant;
 }
diff --git a/plugins/assistants/Assistants/InfiniteRulerAssistant.h b/plugins/assistants/Assistants/InfiniteRulerAssistant.h
index db639da29c..94384e2a0e 100644
--- a/plugins/assistants/Assistants/InfiniteRulerAssistant.h
+++ b/plugins/assistants/Assistants/InfiniteRulerAssistant.h
@@ -1,63 +1,63 @@
 /*
  * Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
  * Copyright (c) 2010 Geoffry Song <goffrie@gmail.com>
  * Copyright (c) 2014 Wolthera van Hövell tot Westerflier <griffinvalley@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 _INFINITERULER_ASSISTANT_H_
 #define _INFINITERULER_ASSISTANT_H_
 
 #include "kis_painting_assistant.h"
 #include <QObject>
 #include <QPolygonF>
 #include <QLineF>
 #include <QTransform>
 /* Design:
  */
 class InfiniteRuler;
 
 class InfiniteRulerAssistant : public KisPaintingAssistant
 {
 public:
     InfiniteRulerAssistant();
     KisPaintingAssistantSP clone(QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap) const override;
     QPointF adjustPosition(const QPointF& point, const QPointF& strokeBegin) override;
     //virtual void endStroke();
-    QPointF buttonPosition() const override;
+    QPointF getEditorPosition() const override;
     int numHandles() const override { return 2; }
     bool isAssistantComplete() const override;
 
 protected:
     void drawAssistant(QPainter& gc, const QRectF& updateRect, const KisCoordinatesConverter* converter, bool  cached = true,KisCanvas2* canvas=0, 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);
     explicit InfiniteRulerAssistant(const InfiniteRulerAssistant &rhs, QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap);
 };
 
 class InfiniteRulerAssistantFactory : public KisPaintingAssistantFactory
 {
 public:
     InfiniteRulerAssistantFactory();
     ~InfiniteRulerAssistantFactory() override;
     QString id() const override;
     QString name() const override;
     KisPaintingAssistant* createPaintingAssistant() const override;
 };
 
 #endif
diff --git a/plugins/assistants/Assistants/ParallelRulerAssistant.cc b/plugins/assistants/Assistants/ParallelRulerAssistant.cc
index 2d1fa2a943..2deb3d3ab2 100644
--- a/plugins/assistants/Assistants/ParallelRulerAssistant.cc
+++ b/plugins/assistants/Assistants/ParallelRulerAssistant.cc
@@ -1,178 +1,178 @@
 /*
  * Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
  * Copyright (c) 2010 Geoffry Song <goffrie@gmail.com>
  * Copyright (c) 2014 Wolthera van Hövell tot Westerflier <griffinvalley@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.
  */
 
 #include "ParallelRulerAssistant.h"
 
 #include "kis_debug.h"
 #include <klocalizedstring.h>
 
 #include <QPainter>
 #include <QLinearGradient>
 #include <QTransform>
 
 #include <kis_canvas2.h>
 #include <kis_coordinates_converter.h>
 #include <kis_algebra_2d.h>
 
 #include <math.h>
 
 ParallelRulerAssistant::ParallelRulerAssistant()
     : KisPaintingAssistant("parallel ruler", i18n("Parallel Ruler assistant"))
 {
 }
 
 KisPaintingAssistantSP ParallelRulerAssistant::clone(QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap) const
 {
     return KisPaintingAssistantSP(new ParallelRulerAssistant(*this, handleMap));
 }
 
 ParallelRulerAssistant::ParallelRulerAssistant(const ParallelRulerAssistant &rhs, QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap)
     : KisPaintingAssistant(rhs, handleMap)
 {
 }
 
 QPointF ParallelRulerAssistant::project(const QPointF& pt, const QPointF& strokeBegin)
 {
     Q_ASSERT(isAssistantComplete());
 
     //code nicked from the perspective ruler.
     qreal dx = pt.x() - strokeBegin.x();
     qreal dy = pt.y() - strokeBegin.y();
 
     if (dx * dx + dy * dy < 4.0) {
         return strokeBegin; // allow some movement before snapping
     }
 
     //dbgKrita<<strokeBegin<< ", " <<*handles()[0];
     QLineF snapLine = QLineF(*handles()[0], *handles()[1]);
     QPointF translation = (*handles()[0]-strokeBegin)*-1.0;
     snapLine = snapLine.translated(translation);
         
     dx = snapLine.dx();
     dy = snapLine.dy();
 
     const qreal
             dx2 = dx * dx,
             dy2 = dy * dy,
             invsqrlen = 1.0 / (dx2 + dy2);
     QPointF r(dx2 * pt.x() + dy2 * snapLine.x1() + dx * dy * (pt.y() - snapLine.y1()),
               dx2 * snapLine.y1() + dy2 * pt.y() + dx * dy * (pt.x() - snapLine.x1()));
     r *= invsqrlen;
     return r;
     //return pt;
 }
 
 QPointF ParallelRulerAssistant::adjustPosition(const QPointF& pt, const QPointF& strokeBegin)
 {
     return project(pt, strokeBegin);
 }
 
 void ParallelRulerAssistant::drawAssistant(QPainter& gc, const QRectF& updateRect, const KisCoordinatesConverter* converter, bool cached, KisCanvas2* canvas, bool assistantVisible, bool previewVisible)
 {
     gc.save();
     gc.resetTransform();
     QPointF mousePos(0,0);
     
     if (canvas){
         //simplest, cheapest way to get the mouse-position//
         mousePos= canvas->canvasWidget()->mapFromGlobal(QCursor::pos());
     }
     else {
         //...of course, you need to have access to a canvas-widget for that.//
         mousePos = QCursor::pos();//this'll give an offset//
         dbgFile<<"canvas does not exist in ruler, you may have passed arguments incorrectly:"<<canvas;
     }
     
     if (isAssistantComplete() && isSnappingActive() && previewVisible==true) {
         //don't draw if invalid.
         QTransform initialTransform = converter->documentToWidgetTransform();
         QLineF snapLine= QLineF(initialTransform.map(*handles()[0]), initialTransform.map(*handles()[1]));
         QPointF translation = (initialTransform.map(*handles()[0])-mousePos)*-1.0;
         snapLine= snapLine.translated(translation);
 
         QRect viewport= gc.viewport();
         KisAlgebra2D::intersectLineRect(snapLine, viewport);
         
         
         QPainterPath path;
         path.moveTo(snapLine.p1());
         path.lineTo(snapLine.p2());
         
         drawPreview(gc, path);//and we draw the preview.
     }
     gc.restore();
     
     KisPaintingAssistant::drawAssistant(gc, updateRect, converter, cached, canvas, assistantVisible, previewVisible);
 
 }
 
 void ParallelRulerAssistant::drawCache(QPainter& gc, const KisCoordinatesConverter *converter, bool assistantVisible)
 {
     if (assistantVisible == false || !isAssistantComplete()){
         return;
     }
 
     QTransform initialTransform = converter->documentToWidgetTransform();
 
     // Draw the line
     QPointF p1 = *handles()[0];
     QPointF p2 = *handles()[1];
 
     gc.setTransform(initialTransform);
     QPainterPath path;
     path.moveTo(p1);
     path.lineTo(p2);
     drawPath(gc, path, isSnappingActive());
     
 }
 
-QPointF ParallelRulerAssistant::buttonPosition() const
+QPointF ParallelRulerAssistant::getEditorPosition() const
 {
     return (*handles()[0] + *handles()[1]) * 0.5;
 }
 
 bool ParallelRulerAssistant::isAssistantComplete() const
 {
     return handles().size() >= 2;
 }
 
 ParallelRulerAssistantFactory::ParallelRulerAssistantFactory()
 {
 }
 
 ParallelRulerAssistantFactory::~ParallelRulerAssistantFactory()
 {
 }
 
 QString ParallelRulerAssistantFactory::id() const
 {
     return "parallel ruler";
 }
 
 QString ParallelRulerAssistantFactory::name() const
 {
     return i18n("Parallel Ruler");
 }
 
 KisPaintingAssistant* ParallelRulerAssistantFactory::createPaintingAssistant() const
 {
     return new ParallelRulerAssistant;
 }
diff --git a/plugins/assistants/Assistants/ParallelRulerAssistant.h b/plugins/assistants/Assistants/ParallelRulerAssistant.h
index 5c82ad7246..dec5f54c97 100644
--- a/plugins/assistants/Assistants/ParallelRulerAssistant.h
+++ b/plugins/assistants/Assistants/ParallelRulerAssistant.h
@@ -1,63 +1,63 @@
 /*
  * Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
  * Copyright (c) 2010 Geoffry Song <goffrie@gmail.com>
  * Copyright (c) 2014 Wolthera van Hövell tot Westerflier <griffinvalley@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 _PARALLELRULER_ASSISTANT_H_
 #define _PARALLELRULER_ASSISTANT_H_
 
 #include "kis_painting_assistant.h"
 #include <QObject>
 #include <QPolygonF>
 #include <QLineF>
 #include <QTransform>
 /* Design:
  */
 class ParallelRuler;
 
 class ParallelRulerAssistant : public KisPaintingAssistant
 {
 public:
     ParallelRulerAssistant();
     KisPaintingAssistantSP clone(QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap) const override;
     QPointF adjustPosition(const QPointF& point, const QPointF& strokeBegin) override;
     //virtual void endStroke();
-    QPointF buttonPosition() const override;
+    QPointF getEditorPosition() const override;
     int numHandles() const override { return 2; }
     bool isAssistantComplete() const override;
 
 protected:
     void drawAssistant(QPainter& gc, const QRectF& updateRect, const KisCoordinatesConverter* converter, bool  cached = true,KisCanvas2* canvas=0, 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);
     explicit ParallelRulerAssistant(const ParallelRulerAssistant &rhs, QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap);
 };
 
 class ParallelRulerAssistantFactory : public KisPaintingAssistantFactory
 {
 public:
     ParallelRulerAssistantFactory();
     ~ParallelRulerAssistantFactory() override;
     QString id() const override;
     QString name() const override;
     KisPaintingAssistant* createPaintingAssistant() const override;
 };
 
 #endif
diff --git a/plugins/assistants/Assistants/PerspectiveAssistant.cc b/plugins/assistants/Assistants/PerspectiveAssistant.cc
index 8e0c327e16..46007b5e3c 100644
--- a/plugins/assistants/Assistants/PerspectiveAssistant.cc
+++ b/plugins/assistants/Assistants/PerspectiveAssistant.cc
@@ -1,481 +1,481 @@
 /*
  * 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.
  */
 
 #include "PerspectiveAssistant.h"
 
 #include "kis_debug.h"
 #include <klocalizedstring.h>
 
 #include <QPainter>
 #include <QLinearGradient>
 #include <QTransform>
 
 #include <kis_canvas2.h>
 #include <kis_coordinates_converter.h>
 #include <kis_algebra_2d.h>
 
 #include <math.h>
 #include <limits>
 
 PerspectiveAssistant::PerspectiveAssistant(QObject *parent)
     : KisAbstractPerspectiveGrid(parent)
     , KisPaintingAssistant("perspective", i18n("Perspective assistant"))
 {
 }
 
 PerspectiveAssistant::PerspectiveAssistant(const PerspectiveAssistant &rhs, QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap)
     : KisAbstractPerspectiveGrid(rhs.parent())
     , KisPaintingAssistant(rhs, handleMap)
     , m_snapLine(rhs.m_snapLine)
     , m_cachedTransform(rhs.m_cachedTransform)
     , m_cachedPolygon(rhs.m_cachedPolygon)
     , m_cacheValid(rhs.m_cacheValid)
 {
     for (int i = 0; i < 4; ++i) {
         m_cachedPoints[i] = rhs.m_cachedPoints[i];
     }
 }
 
 KisPaintingAssistantSP PerspectiveAssistant::clone(QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap) const
 {
     return KisPaintingAssistantSP(new PerspectiveAssistant(*this, handleMap));
 }
 // squared distance from a point to a line
 inline qreal distsqr(const QPointF& pt, const QLineF& line)
 {
     // distance = |(p2 - p1) x (p1 - pt)| / |p2 - p1|
 
     // magnitude of (p2 - p1) x (p1 - pt)
     const qreal cross = (line.dx() * (line.y1() - pt.y()) - line.dy() * (line.x1() - pt.x()));
 
     return cross * cross / (line.dx() * line.dx() + line.dy() * line.dy());
 }
 
 QPointF PerspectiveAssistant::project(const QPointF& pt, const QPointF& strokeBegin)
 {
     const static QPointF nullPoint(std::numeric_limits<qreal>::quiet_NaN(), std::numeric_limits<qreal>::quiet_NaN());
 
     Q_ASSERT(isAssistantComplete());
 
     if (m_snapLine.isNull()) {
         QPolygonF poly;
         QTransform transform;
 
         if (!getTransform(poly, transform)) {
             return nullPoint;
         }
 
         if (!poly.containsPoint(strokeBegin, Qt::OddEvenFill)) {
             return nullPoint; // avoid problems with multiple assistants: only snap if starting in the grid
         }
 
 
         const qreal dx = pt.x() - strokeBegin.x();
         const qreal dy = pt.y() - strokeBegin.y();
 
         if (dx * dx + dy * dy < 4.0) {
             return strokeBegin; // allow some movement before snapping
         }
 
         // construct transformation
         bool invertible;
         const QTransform inverse = transform.inverted(&invertible);
         if (!invertible) {
             return nullPoint; // shouldn't happen
         }
 
 
         // figure out which direction to go
         const QPointF start = inverse.map(strokeBegin);
         const QLineF verticalLine = QLineF(strokeBegin, transform.map(start + QPointF(0, 1)));
         const QLineF horizontalLine = QLineF(strokeBegin, transform.map(start + QPointF(1, 0)));
 
         // determine whether the horizontal or vertical line is closer to the point
         m_snapLine = distsqr(pt, verticalLine) < distsqr(pt, horizontalLine) ? verticalLine : horizontalLine;
     }
 
     // snap to line
     const qreal
             dx = m_snapLine.dx(),
             dy = m_snapLine.dy(),
             dx2 = dx * dx,
             dy2 = dy * dy,
             invsqrlen = 1.0 / (dx2 + dy2);
     QPointF r(dx2 * pt.x() + dy2 * m_snapLine.x1() + dx * dy * (pt.y() - m_snapLine.y1()),
               dx2 * m_snapLine.y1() + dy2 * pt.y() + dx * dy * (pt.x() - m_snapLine.x1()));
 
     r *= invsqrlen;
     return r;
 }
 
 QPointF PerspectiveAssistant::adjustPosition(const QPointF& pt, const QPointF& strokeBegin)
 {
     return project(pt, strokeBegin);
 }
 
 void PerspectiveAssistant::endStroke()
 {
     m_snapLine = QLineF();
 }
 
 bool PerspectiveAssistant::contains(const QPointF& pt) const
 {
     QPolygonF poly;
     if (!quad(poly)) return false;
     return poly.containsPoint(pt, Qt::OddEvenFill);
 }
 
 inline qreal lengthSquared(const QPointF& vector)
 {
     return vector.x() * vector.x() + vector.y() * vector.y();
 }
 
 inline qreal localScale(const QTransform& transform, QPointF pt)
 {
     //    const qreal epsilon = 1e-5, epsilonSquared = epsilon * epsilon;
     //    qreal xSizeSquared = lengthSquared(transform.map(pt + QPointF(epsilon, 0.0)) - orig) / epsilonSquared;
     //    qreal ySizeSquared = lengthSquared(transform.map(pt + QPointF(0.0, epsilon)) - orig) / epsilonSquared;
     //    xSizeSquared /= lengthSquared(transform.map(QPointF(0.0, pt.y())) - transform.map(QPointF(1.0, pt.y())));
     //    ySizeSquared /= lengthSquared(transform.map(QPointF(pt.x(), 0.0)) - transform.map(QPointF(pt.x(), 1.0)));
     //  when taking the limit epsilon->0:
     //  xSizeSquared=((m23*y+m33)^2*(m23*y+m33+m13)^2)/(m23*y+m13*x+m33)^4
     //  ySizeSquared=((m23*y+m33)^2*(m23*y+m33+m13)^2)/(m23*y+m13*x+m33)^4
     //  xSize*ySize=(abs(m13*x+m33)*abs(m13*x+m33+m23)*abs(m23*y+m33)*abs(m23*y+m33+m13))/(m23*y+m13*x+m33)^4
     const qreal x = transform.m13() * pt.x(),
             y = transform.m23() * pt.y(),
             a = x + transform.m33(),
             b = y + transform.m33(),
             c = x + y + transform.m33(),
             d = c * c;
     return fabs(a*(a + transform.m23())*b*(b + transform.m13()))/(d * d);
 }
 
 // returns the reciprocal of the maximum local scale at the points (0,0),(0,1),(1,0),(1,1)
 inline qreal inverseMaxLocalScale(const QTransform& transform)
 {
     const qreal a = fabs((transform.m33() + transform.m13()) * (transform.m33() + transform.m23())),
             b = fabs((transform.m33()) * (transform.m13() + transform.m33() + transform.m23())),
             d00 = transform.m33() * transform.m33(),
             d11 = (transform.m33() + transform.m23() + transform.m13())*(transform.m33() + transform.m23() + transform.m13()),
             s0011 = qMin(d00, d11) / a,
             d10 = (transform.m33() + transform.m13()) * (transform.m33() + transform.m13()),
             d01 = (transform.m33() + transform.m23()) * (transform.m33() + transform.m23()),
             s1001 = qMin(d10, d01) / b;
     return qMin(s0011, s1001);
 }
 
 qreal PerspectiveAssistant::distance(const QPointF& pt) const
 {
     QPolygonF poly;
     QTransform transform;
 
     if (!getTransform(poly, transform)) {
         return 1.0;
     }
 
     bool invertible;
     QTransform inverse = transform.inverted(&invertible);
 
     if (!invertible) {
         return 1.0;
     }
 
     if (inverse.m13() * pt.x() + inverse.m23() * pt.y() + inverse.m33() == 0.0) {
         return 0.0; // point at infinity
     }
 
     return localScale(transform, inverse.map(pt)) * inverseMaxLocalScale(transform);
 }
 
 // draw a vanishing point marker
 inline QPainterPath drawX(const QPointF& pt)
 {
     QPainterPath path;
     path.moveTo(QPointF(pt.x() - 5.0, pt.y() - 5.0)); path.lineTo(QPointF(pt.x() + 5.0, pt.y() + 5.0));
     path.moveTo(QPointF(pt.x() - 5.0, pt.y() + 5.0)); path.lineTo(QPointF(pt.x() + 5.0, pt.y() - 5.0));
     return path;
 }
 
 void PerspectiveAssistant::drawAssistant(QPainter& gc, const QRectF& updateRect, const KisCoordinatesConverter* converter, bool cached, KisCanvas2* canvas, bool assistantVisible, bool previewVisible)
 {
     gc.save();
     gc.resetTransform();
     QTransform initialTransform = converter->documentToWidgetTransform();
     //QTransform reverseTransform = converter->widgetToDocument();
     QPolygonF poly;
     QTransform transform; // unused, but computed for caching purposes
     if (getTransform(poly, transform) && assistantVisible==true) {
         // draw vanishing points
         QPointF intersection(0, 0);
         if (fmod(QLineF(poly[0], poly[1]).angle(), 180.0)>=fmod(QLineF(poly[2], poly[3]).angle(), 180.0)+2.0 || fmod(QLineF(poly[0], poly[1]).angle(), 180.0)<=fmod(QLineF(poly[2], poly[3]).angle(), 180.0)-2.0) {
             if (QLineF(poly[0], poly[1]).intersect(QLineF(poly[2], poly[3]), &intersection) != QLineF::NoIntersection) {
                 drawPath(gc, drawX(initialTransform.map(intersection)));
             }
         }
         if (fmod(QLineF(poly[1], poly[2]).angle(), 180.0)>=fmod(QLineF(poly[3], poly[0]).angle(), 180.0)+2.0 || fmod(QLineF(poly[1], poly[2]).angle(), 180.0)<=fmod(QLineF(poly[3], poly[0]).angle(), 180.0)-2.0){
             if (QLineF(poly[1], poly[2]).intersect(QLineF(poly[3], poly[0]), &intersection) != QLineF::NoIntersection) {
                 drawPath(gc, drawX(initialTransform.map(intersection)));
             }
         }
     }
 
     if (isSnappingActive() && getTransform(poly, transform) && previewVisible==true){
         //find vanishing point, find mouse, draw line between both.
         QPainterPath path2;
         QPointF intersection(0, 0);//this is the position of the vanishing point.
         QPointF mousePos(0,0);
         QLineF snapLine;
         QRect viewport= gc.viewport();
         QRect bounds;
         
         if (canvas){
             //simplest, cheapest way to get the mouse-position
             mousePos= canvas->canvasWidget()->mapFromGlobal(QCursor::pos());
         }
         else {
             //...of course, you need to have access to a canvas-widget for that.
             mousePos = QCursor::pos(); // this'll give an offset
             dbgFile<<"canvas does not exist, you may have passed arguments incorrectly:"<<canvas;
         }
         //figure out if point is in the perspective grid
         QPointF intersectTransformed(0, 0); // dummy for holding transformed intersection so the code is more readable.
 
         if (poly.containsPoint(initialTransform.inverted().map(mousePos), Qt::OddEvenFill)==true){
             // check if the lines aren't parallel to each other to avoid calculation errors in the intersection calculation (bug 345754)//
             if (fmod(QLineF(poly[0], poly[1]).angle(), 180.0)>=fmod(QLineF(poly[2], poly[3]).angle(), 180.0)+2.0 || fmod(QLineF(poly[0], poly[1]).angle(), 180.0)<=fmod(QLineF(poly[2], poly[3]).angle(), 180.0)-2.0) {
                 if (QLineF(poly[0], poly[1]).intersect(QLineF(poly[2], poly[3]), &intersection) != QLineF::NoIntersection) {
                     intersectTransformed = initialTransform.map(intersection);
                     snapLine = QLineF(intersectTransformed, mousePos);
                     KisAlgebra2D::intersectLineRect(snapLine, viewport);
                     bounds= QRect(snapLine.p1().toPoint(), snapLine.p2().toPoint());
                     QPainterPath path;
 
                     if (bounds.contains(intersectTransformed.toPoint())){
                         path2.moveTo(intersectTransformed);
                         path2.lineTo(snapLine.p1());
                     }
                     else {
                         path2.moveTo(snapLine.p1());
                         path2.lineTo(snapLine.p2());
                     }
                 }
             }
             if (fmod(QLineF(poly[1], poly[2]).angle(), 180.0)>=fmod(QLineF(poly[3], poly[0]).angle(), 180.0)+2.0 || fmod(QLineF(poly[1], poly[2]).angle(), 180.0)<=fmod(QLineF(poly[3], poly[0]).angle(), 180.0)-2.0){
                 if (QLineF(poly[1], poly[2]).intersect(QLineF(poly[3], poly[0]), &intersection) != QLineF::NoIntersection) {
                     intersectTransformed = initialTransform.map(intersection);
                     snapLine = QLineF(intersectTransformed, mousePos);
                     KisAlgebra2D::intersectLineRect(snapLine, viewport);
                     bounds= QRect(snapLine.p1().toPoint(), snapLine.p2().toPoint());
                     QPainterPath path;
 
                     if (bounds.contains(intersectTransformed.toPoint())){
                         path2.moveTo(intersectTransformed);
                         path2.lineTo(snapLine.p1());
                     }
                     else {
                         path2.moveTo(snapLine.p1());
                         path2.lineTo(snapLine.p2());
                     }
                 }
             }
             drawPreview(gc, path2);
         }
     }
 
     gc.restore();
 
     KisPaintingAssistant::drawAssistant(gc, updateRect, converter, cached,canvas, assistantVisible, previewVisible);
 }
 
 void PerspectiveAssistant::drawCache(QPainter& gc, const KisCoordinatesConverter *converter, bool assistantVisible)
 {
     if (assistantVisible == false) {
         return;
     }
 
     gc.setTransform(converter->documentToWidgetTransform());
     QPolygonF poly;
     QTransform transform;
 
     if (!getTransform(poly, transform)) {
         // color red for an invalid transform, but not for an incomplete one
         if(isAssistantComplete()) {
             gc.setPen(QColor(255, 0, 0, 125));
             gc.drawPolygon(poly);
         } else {
             QPainterPath path;
             path.addPolygon(poly);
             drawPath(gc, path, isSnappingActive());
         }
     } else {
         gc.setPen(QColor(0, 0, 0, 125));
         gc.setTransform(transform, true);
         QPainterPath path;
         for (int y = 0; y <= 8; ++y)
         {
             path.moveTo(QPointF(0.0, y * 0.125));
             path.lineTo(QPointF(1.0, y * 0.125));
         }
         for (int x = 0; x <= 8; ++x)
         {
             path.moveTo(QPointF(x * 0.125, 0.0));
             path.lineTo(QPointF(x * 0.125, 1.0));
         }
         drawPath(gc, path, isSnappingActive());
     }
     
 }
 
-QPointF PerspectiveAssistant::buttonPosition() const
+QPointF PerspectiveAssistant::getEditorPosition() const
 {
     QPointF centroid(0, 0);
     for (int i = 0; i < 4; ++i) {
         centroid += *handles()[i];
     }
 
     return centroid * 0.25;
 }
 
 template <typename T> int sign(T a)
 {
     return (a > 0) - (a < 0);
 }
 // perpendicular dot product
 inline qreal pdot(const QPointF& a, const QPointF& b)
 {
     return a.x() * b.y() - a.y() * b.x();
 }
 
 bool PerspectiveAssistant::quad(QPolygonF& poly) const
 {
     for (int i = 0; i < handles().size(); ++i) {
         poly.push_back(*handles()[i]);
     }
 
     if (!isAssistantComplete()) {
         return false;
     }
 
     int sum = 0;
     int signs[4];
 
     for (int i = 0; i < 4; ++i) {
         int j = (i == 3) ? 0 : (i + 1);
         int k = (j == 3) ? 0 : (j + 1);
         signs[i] = sign(pdot(poly[j] - poly[i], poly[k] - poly[j]));
         sum += signs[i];
     }
 
     if (sum == 0) {
         // complex (crossed)
         for (int i = 0; i < 4; ++i) {
             int j = (i == 3) ? 0 : (i + 1);
             if (signs[i] * signs[j] == -1) {
                 // opposite signs: uncross
                 std::swap(poly[i], poly[j]);
                 return true;
             }
         }
         // okay, maybe it's just a line
         return false;
     } else if (sum != 4 && sum != -4) {
         // concave, or a triangle
         if (sum == 2 || sum == -2) {
             // concave, let's return a triangle instead
             for (int i = 0; i < 4; ++i) {
                 int j = (i == 3) ? 0 : (i + 1);
                 if (signs[i] != sign(sum)) {
                     // wrong sign: drop the inside node
                     poly.remove(j);
                     return false;
                 }
             }
         }
         return false;
     }
     // convex
     return true;
 }
 
 bool PerspectiveAssistant::getTransform(QPolygonF& poly, QTransform& transform) const
 {
     if (m_cachedPolygon.size() != 0 && isAssistantComplete()) {
         for (int i = 0; i <= 4; ++i) {
             if (i == 4) {
                 poly = m_cachedPolygon;
                 transform = m_cachedTransform;
                 return m_cacheValid;
             }
             if (m_cachedPoints[i] != *handles()[i]) break;
         }
     }
 
     m_cachedPolygon.clear();
     m_cacheValid = false;
 
     if (!quad(poly)) {
         m_cachedPolygon = poly;
         return false;
     }
 
     if (!QTransform::squareToQuad(poly, transform)) {
         qWarning("Failed to create perspective mapping");
         return false;
     }
 
     for (int i = 0; i < 4; ++i) {
         m_cachedPoints[i] = *handles()[i];
     }
 
     m_cachedPolygon = poly;
     m_cachedTransform = transform;
     m_cacheValid = true;
     return true;
 }
 
 bool PerspectiveAssistant::isAssistantComplete() const
 {
     return handles().size() >= 4; // specify 4 corners to make assistant complete
 }
 
 
 
 PerspectiveAssistantFactory::PerspectiveAssistantFactory()
 {
 }
 
 PerspectiveAssistantFactory::~PerspectiveAssistantFactory()
 {
 }
 
 QString PerspectiveAssistantFactory::id() const
 {
     return "perspective";
 }
 
 QString PerspectiveAssistantFactory::name() const
 {
     return i18n("Perspective");
 }
 
 KisPaintingAssistant* PerspectiveAssistantFactory::createPaintingAssistant() const
 {
     return new PerspectiveAssistant;
 }
diff --git a/plugins/assistants/Assistants/PerspectiveAssistant.h b/plugins/assistants/Assistants/PerspectiveAssistant.h
index 7d4ccac50f..7c5c79a13a 100644
--- a/plugins/assistants/Assistants/PerspectiveAssistant.h
+++ b/plugins/assistants/Assistants/PerspectiveAssistant.h
@@ -1,78 +1,78 @@
 /*
  * 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 _PERSPECTIVE_ASSISTANT_H_
 #define _PERSPECTIVE_ASSISTANT_H_
 
 #include "kis_abstract_perspective_grid.h"
 #include "kis_painting_assistant.h"
 #include <QObject>
 #include <QPolygonF>
 #include <QLineF>
 #include <QTransform>
 
 class PerspectiveAssistant : public KisAbstractPerspectiveGrid, public KisPaintingAssistant
 {
     Q_OBJECT
 public:
     PerspectiveAssistant(QObject * parent = 0);
     KisPaintingAssistantSP clone(QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap) const override;
     QPointF adjustPosition(const QPointF& point, const QPointF& strokeBegin) override;
     void endStroke() override;
-    QPointF buttonPosition() const override;
+    QPointF getEditorPosition() const override;
     int numHandles() const override { return 4; }
     void drawAssistant(QPainter& gc, const QRectF& updateRect, const KisCoordinatesConverter* converter, bool cached = true,KisCanvas2* canvas=0, bool assistantVisible=true, bool previewVisible=true) override;
 
     bool contains(const QPointF& point) const override;
     qreal distance(const QPointF& point) const override;
 
 
     bool isAssistantComplete() const override;
 
 protected:
     void drawCache(QPainter& gc, const KisCoordinatesConverter *converter,  bool assistantVisible=true) override;
 private:
     QPointF project(const QPointF& pt, const QPointF& strokeBegin);
     // creates the convex hull, returns false if it's not a quadrilateral
     bool quad(QPolygonF& out) const;
     // finds the transform from perspective coordinates (a unit square) to the document
     bool getTransform(QPolygonF& polyOut, QTransform& transformOut) const;
     explicit PerspectiveAssistant(const PerspectiveAssistant &rhs, QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap);
 
     // which direction to snap to (in transformed coordinates)
     QLineF m_snapLine;
     // cached information
     mutable QTransform m_cachedTransform;
     mutable QPolygonF m_cachedPolygon;
     mutable QPointF m_cachedPoints[4];
     mutable bool m_cacheValid;
 };
 
 class PerspectiveAssistantFactory : public KisPaintingAssistantFactory
 {
 public:
     PerspectiveAssistantFactory();
     ~PerspectiveAssistantFactory() override;
     QString id() const override;
     QString name() const override;
     KisPaintingAssistant* createPaintingAssistant() const override;
 };
 
 #endif
diff --git a/plugins/assistants/Assistants/RulerAssistant.cc b/plugins/assistants/Assistants/RulerAssistant.cc
index ab03b906cb..48cc15e6a2 100644
--- a/plugins/assistants/Assistants/RulerAssistant.cc
+++ b/plugins/assistants/Assistants/RulerAssistant.cc
@@ -1,177 +1,177 @@
 /*
  * Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
  * 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.
  */
 
 #include "RulerAssistant.h"
 
 #include "kis_debug.h"
 #include <klocalizedstring.h>
 
 #include <QPainter>
 #include <QLinearGradient>
 #include <QTransform>
 
 #include <kis_canvas2.h>
 #include <kis_coordinates_converter.h>
 
 #include <math.h>
 
 RulerAssistant::RulerAssistant()
         : KisPaintingAssistant("ruler", i18n("Ruler assistant"))
 {
 }
 
 KisPaintingAssistantSP RulerAssistant::clone(QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap) const
 {
     return KisPaintingAssistantSP(new RulerAssistant(*this, handleMap));
 }
 
 RulerAssistant::RulerAssistant(const RulerAssistant &rhs, QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap)
     : KisPaintingAssistant(rhs, handleMap)
 {
 }
 
 QPointF RulerAssistant::project(const QPointF& pt) const
 {
     Q_ASSERT(isAssistantComplete());
     QPointF pt1 = *handles()[0];
     QPointF pt2 = *handles()[1];
     
     QPointF a = pt - pt1;
     QPointF u = pt2 - pt1;
     
     qreal u_norm = sqrt(u.x() * u.x() + u.y() * u.y());
     
     if(u_norm == 0) return pt;
     
     u /= u_norm;
     
     double t = a.x() * u.x() + a.y() * u.y();
     
     if(t < 0.0) return pt1;
     if(t > u_norm) return pt2;
     
     return t * u + pt1;
 }
 
 QPointF RulerAssistant::adjustPosition(const QPointF& pt, const QPointF& /*strokeBegin*/)
 {
     return project(pt);
 }
 
 inline double angle(const QPointF& p1, const QPointF& p2)
 {
     return atan2(p2.y() - p1.y(), p2.x() - p1.x());
 }
 
 
 inline double norm2(const QPointF& p)
 {
     return sqrt(p.x() * p.x() + p.y() * p.y());
 }
 
 void RulerAssistant::drawAssistant(QPainter& gc, const QRectF& updateRect, const KisCoordinatesConverter* converter, bool cached, KisCanvas2* canvas, bool assistantVisible, bool previewVisible)
 {
     gc.save();
     gc.resetTransform();
     QPointF mousePos;
     
     if (canvas){
         //simplest, cheapest way to get the mouse-position//
         mousePos= canvas->canvasWidget()->mapFromGlobal(QCursor::pos());
     }
     else {
         //...of course, you need to have access to a canvas-widget for that.//
         mousePos = QCursor::pos();//this'll give an offset//
         dbgFile<<"canvas does not exist in ruler, you may have passed arguments incorrectly:"<<canvas;
     }
     
     // don't draw if invalid
     if (isAssistantComplete()) {
         QTransform initialTransform = converter->documentToWidgetTransform();
 
         // first we find the path that our point create.
         QPointF p1 = *handles()[0];
         QPointF p2 = *handles()[1];
 
         gc.setTransform(initialTransform);
         QPainterPath path;
         path.moveTo(p1);
         path.lineTo(p2);
         //then we use this path to check the bounding rectangle//
         if (isSnappingActive() && path.boundingRect().contains(initialTransform.inverted().map(mousePos)) && previewVisible==true){
             drawPreview(gc, path);//and we draw the preview.
         }
     }
     gc.restore();
     
     KisPaintingAssistant::drawAssistant(gc, updateRect, converter, cached, canvas, assistantVisible, previewVisible);
 
 }
 
 void RulerAssistant::drawCache(QPainter& gc, const KisCoordinatesConverter *converter, bool assistantVisible)
 {
     if (assistantVisible == false || !isAssistantComplete()){
         return;
     }
 
     QTransform initialTransform = converter->documentToWidgetTransform();
 
     // Draw the line
     QPointF p1 = *handles()[0];
     QPointF p2 = *handles()[1];
 
     gc.setTransform(initialTransform);
     QPainterPath path;
     path.moveTo(p1);
     path.lineTo(p2);
     drawPath(gc, path, isSnappingActive());
 }
 
-QPointF RulerAssistant::buttonPosition() const
+QPointF RulerAssistant::getEditorPosition() const
 {
     return (*handles()[0] + *handles()[1]) * 0.5;
 }
 
 bool RulerAssistant::isAssistantComplete() const
 {
     return handles().size() >= 2;
 }
 
 RulerAssistantFactory::RulerAssistantFactory()
 {
 }
 
 RulerAssistantFactory::~RulerAssistantFactory()
 {
 }
 
 QString RulerAssistantFactory::id() const
 {
     return "ruler";
 }
 
 QString RulerAssistantFactory::name() const
 {
     return i18n("Ruler");
 }
 
 KisPaintingAssistant* RulerAssistantFactory::createPaintingAssistant() const
 {
     return new RulerAssistant;
 }
diff --git a/plugins/assistants/Assistants/RulerAssistant.h b/plugins/assistants/Assistants/RulerAssistant.h
index 5211c69b90..f6692fd620 100644
--- a/plugins/assistants/Assistants/RulerAssistant.h
+++ b/plugins/assistants/Assistants/RulerAssistant.h
@@ -1,57 +1,57 @@
 /*
  * Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
  * 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 _RULER_ASSISTANT_H_
 #define _RULER_ASSISTANT_H_
 
 #include <QMap>
 
 #include "kis_painting_assistant.h"
 
 class Ruler;
 
 class RulerAssistant : public KisPaintingAssistant
 {
 public:
     RulerAssistant();
     KisPaintingAssistantSP clone(QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap) const override;
     QPointF adjustPosition(const QPointF& point, const QPointF& strokeBegin) override;
-    QPointF buttonPosition() const override;
+    QPointF getEditorPosition() const override;
     int numHandles() const override { return 2; }
     bool isAssistantComplete() const override;
 
 protected:
     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;
     explicit RulerAssistant(const RulerAssistant &rhs, QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap);
 };
 
 class RulerAssistantFactory : public KisPaintingAssistantFactory
 {
 public:
     RulerAssistantFactory();
     ~RulerAssistantFactory() override;
     QString id() const override;
     QString name() const override;
     KisPaintingAssistant* createPaintingAssistant() const override;
 };
 
 #endif
diff --git a/plugins/assistants/Assistants/SplineAssistant.cc b/plugins/assistants/Assistants/SplineAssistant.cc
index 7755f38b2e..20b19dda6e 100644
--- a/plugins/assistants/Assistants/SplineAssistant.cc
+++ b/plugins/assistants/Assistants/SplineAssistant.cc
@@ -1,239 +1,239 @@
 /*
  * 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.
  */
 
 #include "SplineAssistant.h"
 
 #include <klocalizedstring.h>
 
 #include <QPainter>
 #include <QLinearGradient>
 #include <QTransform>
 
 #include <kis_canvas2.h>
 #include <kis_coordinates_converter.h>
 #include "kis_debug.h"
 
 #include <math.h>
 #include <limits>
 #include <algorithm>
 
 SplineAssistant::SplineAssistant()
     : KisPaintingAssistant("spline", i18n("Spline assistant"))
 {
 }
 
 SplineAssistant::SplineAssistant(const SplineAssistant &rhs, QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap)
     : KisPaintingAssistant(rhs, handleMap)
     , m_canvas(rhs.m_canvas)
 {
 }
 
 KisPaintingAssistantSP SplineAssistant::clone(QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap) const
 {
     return KisPaintingAssistantSP(new SplineAssistant(*this, handleMap));
 }
 
 // parametric form of a cubic spline (B(t) = (1-t)^3 P0 + 3 (1-t)^2 t P1 + 3 (1-t) t^2 P2 + t^3 P3)
 inline QPointF B(qreal t, const QPointF& P0, const QPointF& P1, const QPointF& P2, const QPointF& P3)
 {
     const qreal tp = 1 - t;
     const qreal tp2 = tp * tp;
     const qreal t2 = t * t;
 
     return  (    tp2 * tp) * P0 +
             (3 * tp2 * t ) * P1 +
             (3 * tp  * t2) * P2 +
             (    t   * t2) * P3;
 }
 // squared distance from a point on the spline to given point: we want to minimize this
 inline qreal D(qreal t, const QPointF& P0, const QPointF& P1, const QPointF& P2, const QPointF& P3, const QPointF& p)
 {
     const qreal
             tp =  1 - t,
             tp2 = tp * tp,
             t2 =  t * t,
             a =   tp2 * tp,
             b =   3 * tp2 * t,
             c =   3 * tp  * t2,
             d =   t   * t2,
             x_dist = a*P0.x() + b*P1.x() + c*P2.x() + d*P3.x() - p.x(),
             y_dist = a*P0.y() + b*P1.y() + c*P2.y() + d*P3.y() - p.y();
 
     return x_dist * x_dist + y_dist * y_dist;
 }
 
 QPointF SplineAssistant::project(const QPointF& pt) const
 {
     Q_ASSERT(isAssistantComplete());
     // minimize d(t), but keep t in the same neighbourhood as before (unless starting a new stroke)
     // (this is a rather inefficient method)
     qreal min_t = std::numeric_limits<qreal>::max();
     qreal d_min_t = std::numeric_limits<qreal>::max();
 
     for (qreal t = 0; t <= 1; t += 1e-3) {
         qreal d_t = D(t, *handles()[0], *handles()[2], *handles()[3], *handles()[1], pt);
         if (d_t < d_min_t) {
             d_min_t = d_t;
             min_t = t;
         }
     }
     return B(min_t, *handles()[0], *handles()[2], *handles()[3], *handles()[1]);
 }
 
 QPointF SplineAssistant::adjustPosition(const QPointF& pt, const QPointF& /*strokeBegin*/)
 {
     return project(pt);
 }
 
 void SplineAssistant::drawAssistant(QPainter& gc, const QRectF& updateRect, const KisCoordinatesConverter* converter, bool cached, KisCanvas2* canvas, bool assistantVisible, bool previewVisible)
 {
     gc.save();
     gc.resetTransform();
     QPoint mousePos;
     
     if (canvas){
         //simplest, cheapest way to get the mouse-position//
         mousePos= canvas->canvasWidget()->mapFromGlobal(QCursor::pos());
         m_canvas = canvas;
     }
     else {
         //...of course, you need to have access to a canvas-widget for that.//
         mousePos = QCursor::pos();//this'll give an offset//
         dbgFile<<"canvas does not exist in spline, you may have passed arguments incorrectly:"<<canvas;
     }
     
 
     if (handles().size() > 1) {
 
         QTransform initialTransform = converter->documentToWidgetTransform();
 
         // first we find the path that our point create.
         QPointF pts[4];
         pts[0] = *handles()[0];
         pts[1] = *handles()[1];
         pts[2] = (handles().size() >= 3) ? (*handles()[2]) : (*handles()[0]);
         pts[3] = (handles().size() >= 4) ? (*handles()[3]) : (handles().size() >= 3) ? (*handles()[2]) : (*handles()[1]);
         gc.setTransform(initialTransform);
 
         // Draw the spline
         QPainterPath path;
         path.moveTo(pts[0]);
         path.cubicTo(pts[2], pts[3], pts[1]);
         
         //then we use this path to check the bounding rectangle//
         if (isSnappingActive() && path.boundingRect().contains(initialTransform.inverted().map(mousePos)) && previewVisible==true){
             drawPreview(gc, path);//and we draw the preview.
         }
     }
     gc.restore();
 
    // there is some odd rectangle that is getting rendered when there is only one point, so don't start rendering the line until after 2
    // this issue only exists with this spline assistant...none of the others
    if (handles().size() > 2) {
       KisPaintingAssistant::drawAssistant(gc, updateRect, converter, cached, canvas, assistantVisible, previewVisible);
    }
 }
 
 void SplineAssistant::drawCache(QPainter& gc, const KisCoordinatesConverter *converter, bool assistantVisible)
 {
     if (assistantVisible == false || handles().size() < 2 ){
         return;
     }
 
     QTransform initialTransform = converter->documentToWidgetTransform();
 
     QPointF pts[4];
     pts[0] = *handles()[0];
     pts[1] = *handles()[1];
     pts[2] = (handles().size() >= 3) ? (*handles()[2]) : (*handles()[0]);
     pts[3] = (handles().size() >= 4) ? (*handles()[3]) : (handles().size() >= 3) ? (*handles()[2]) : (*handles()[1]);
 
     gc.setTransform(initialTransform);
 
 
     {  // Draw bezier handles control lines only if we are editing the assistant
         gc.save();
         QColor assistantColor = effectiveAssistantColor();
         QPen bezierlinePen(assistantColor);
         bezierlinePen.setStyle(Qt::DotLine);
         bezierlinePen.setWidth(1);
 
         if (m_canvas->paintingAssistantsDecoration()->isEditingAssistants()) {
 
             if (!isSnappingActive()) {
                 QColor snappingColor = assistantColor;
                 snappingColor.setAlpha(snappingColor.alpha() * 0.2);
 
                 bezierlinePen.setColor(snappingColor);
             }
 
             gc.setPen(bezierlinePen);
             gc.drawLine(pts[0], pts[2]);
 
             if (isAssistantComplete()) {
                 gc.drawLine(pts[1], pts[3]);
             }
             gc.setPen(QColor(0, 0, 0, 125));
         }
         gc.restore();
     }
 
 
     // Draw the spline
     QPainterPath path;
     path.moveTo(pts[0]);
     path.cubicTo(pts[2], pts[3], pts[1]);
     drawPath(gc, path, isSnappingActive());
 
 
 }
 
-QPointF SplineAssistant::buttonPosition() const
+QPointF SplineAssistant::getEditorPosition() const
 {
     return B(0.5, *handles()[0], *handles()[2], *handles()[3], *handles()[1]);
 }
 
 bool SplineAssistant::isAssistantComplete() const
 {
     return handles().size() >= 4; // specify 4 corners to make assistant complete
 }
 
 SplineAssistantFactory::SplineAssistantFactory()
 {
 }
 
 SplineAssistantFactory::~SplineAssistantFactory()
 {
 }
 
 QString SplineAssistantFactory::id() const
 {
     return "spline";
 }
 
 QString SplineAssistantFactory::name() const
 {
     return i18n("Spline");
 }
 
 KisPaintingAssistant* SplineAssistantFactory::createPaintingAssistant() const
 {
     return new SplineAssistant;
 }
diff --git a/plugins/assistants/Assistants/SplineAssistant.h b/plugins/assistants/Assistants/SplineAssistant.h
index 0084a3be80..f74ca50725 100644
--- a/plugins/assistants/Assistants/SplineAssistant.h
+++ b/plugins/assistants/Assistants/SplineAssistant.h
@@ -1,58 +1,58 @@
 /*
  * 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 _SPLINE_ASSISTANT_H_
 #define _SPLINE_ASSISTANT_H_
 
 #include "kis_painting_assistant.h"
 #include <QObject>
 
 class SplineAssistant : public KisPaintingAssistant
 {
 public:
     SplineAssistant();
     KisPaintingAssistantSP clone(QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap) const override;
     QPointF adjustPosition(const QPointF& point, const QPointF& strokeBegin) override;
-    QPointF buttonPosition() const override;
+    QPointF getEditorPosition() const override;
     int numHandles() const override { return 4; }
     bool isAssistantComplete() const override;
 
 protected:
     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;
     explicit SplineAssistant(const SplineAssistant &rhs, QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap);
 
     /// used for getting the decoration so the bezier handles aren't drawn while editing
     KisCanvas2* m_canvas;
 };
 
 class SplineAssistantFactory : public KisPaintingAssistantFactory
 {
 public:
     SplineAssistantFactory();
     ~SplineAssistantFactory() override;
     QString id() const override;
     QString name() const override;
     KisPaintingAssistant* createPaintingAssistant() const override;
 };
 
 #endif
diff --git a/plugins/assistants/Assistants/VanishingPointAssistant.cc b/plugins/assistants/Assistants/VanishingPointAssistant.cc
index abc93b542e..3d11d2539d 100644
--- a/plugins/assistants/Assistants/VanishingPointAssistant.cc
+++ b/plugins/assistants/Assistants/VanishingPointAssistant.cc
@@ -1,318 +1,318 @@
 /*
  * Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
  * Copyright (c) 2010 Geoffry Song <goffrie@gmail.com>
  * Copyright (c) 2014 Wolthera van Hövell tot Westerflier <griffinvalley@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.
  */
 
 #include "VanishingPointAssistant.h"
 
 #include "kis_debug.h"
 #include <klocalizedstring.h>
 
 #include <QPainter>
 #include <QLinearGradient>
 #include <QTransform>
 
 #include <kis_canvas2.h>
 #include <kis_coordinates_converter.h>
 #include <kis_algebra_2d.h>
 #include <kis_dom_utils.h>
 #include <math.h>
 
 VanishingPointAssistant::VanishingPointAssistant()
     : KisPaintingAssistant("vanishing point", i18n("Vanishing Point assistant"))
 {
 }
 
 VanishingPointAssistant::VanishingPointAssistant(const VanishingPointAssistant &rhs, QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap)
     : KisPaintingAssistant(rhs, handleMap)
     , m_canvas(rhs.m_canvas)
     , m_referenceLineDensity(rhs.m_referenceLineDensity)
 {
 }
 
 KisPaintingAssistantSP VanishingPointAssistant::clone(QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap) const
 {
     return KisPaintingAssistantSP(new VanishingPointAssistant(*this, handleMap));
 }
 
 QPointF VanishingPointAssistant::project(const QPointF& pt, const QPointF& strokeBegin)
 {
     //Q_ASSERT(handles().size() == 1 || handles().size() == 5);
     //code nicked from the perspective ruler.
     qreal dx = pt.x() - strokeBegin.x();
     qreal dy = pt.y() - strokeBegin.y();
 
     if (dx * dx + dy * dy < 4.0) {
         // allow some movement before snapping
         return strokeBegin;
     }
 
     //dbgKrita<<strokeBegin<< ", " <<*handles()[0];
     QLineF snapLine = QLineF(*handles()[0], strokeBegin);
     
     
     dx = snapLine.dx();
     dy = snapLine.dy();
 
     const qreal dx2 = dx * dx;
     const qreal dy2 = dy * dy;
     const qreal invsqrlen = 1.0 / (dx2 + dy2);
 
     QPointF r(dx2 * pt.x() + dy2 * snapLine.x1() + dx * dy * (pt.y() - snapLine.y1()),
               dx2 * snapLine.y1() + dy2 * pt.y() + dx * dy * (pt.x() - snapLine.x1()));
 
     r *= invsqrlen;
     return r;
 }
 
 QPointF VanishingPointAssistant::adjustPosition(const QPointF& pt, const QPointF& strokeBegin)
 {
     return project(pt, strokeBegin);
 }
 
 void VanishingPointAssistant::drawAssistant(QPainter& gc, const QRectF& updateRect, const KisCoordinatesConverter* converter, bool cached, KisCanvas2* canvas, bool assistantVisible, bool previewVisible)
 {
     // HACK ALERT: side handles aren't saved
     // we need to just add a default position for now if we are loading a vanishing point
     // we will need to look at how we load/save assistants in general to remedy this
     if (sideHandles().isEmpty()) {
         QPointF vpPoint = *handles()[0]; // main vanishing point
         addHandle(new KisPaintingAssistantHandle(vpPoint + QPointF(-70,0)), HandleType::SIDE);
         addHandle(new KisPaintingAssistantHandle(vpPoint + QPointF(-140,0)), HandleType::SIDE);
         addHandle(new KisPaintingAssistantHandle(vpPoint + QPointF(70,0)), HandleType::SIDE);
         addHandle(new KisPaintingAssistantHandle(vpPoint + QPointF(140,0)), HandleType::SIDE);
     }
 
     gc.save();
     gc.resetTransform();
     QPointF mousePos(0,0);
     
     if (canvas){
         //simplest, cheapest way to get the mouse-position//
         mousePos= canvas->canvasWidget()->mapFromGlobal(QCursor::pos());
         m_canvas = canvas;
     }
     else {
         //...of course, you need to have access to a canvas-widget for that.//
         mousePos = QCursor::pos();//this'll give an offset//
         dbgFile<<"canvas does not exist in ruler, you may have passed arguments incorrectly:"<<canvas;
     }
     
 
 
      // draw controls when we are not editing
      if (canvas->paintingAssistantsDecoration()->isEditingAssistants() == false && isAssistantComplete()) {
 
          if (isSnappingActive() && previewVisible == true) {
              //don't draw if invalid.
              QTransform initialTransform = converter->documentToWidgetTransform();
              QPointF startPoint = initialTransform.map(*handles()[0]);
 
              QLineF snapLine= QLineF(startPoint, mousePos);
              QRect viewport= gc.viewport();
 
              KisAlgebra2D::intersectLineRect(snapLine, viewport);
 
              QRect bounds= QRect(snapLine.p1().toPoint(), snapLine.p2().toPoint());
 
              QPainterPath path;
 
              if (bounds.contains(startPoint.toPoint())){
                  path.moveTo(startPoint);
                  path.lineTo(snapLine.p1());
              }
              else
              {
                  path.moveTo(snapLine.p1());
                  path.lineTo(snapLine.p2());
              }
 
              drawPreview(gc, path);//and we draw the preview.
          }
      }
 
 
 
 
     // editor specific controls display
     if (canvas->paintingAssistantsDecoration()->isEditingAssistants()) {
 
         // draws a circle around the vanishing point node while editing
         QTransform initialTransform = converter->documentToWidgetTransform();
         QPointF p0 = initialTransform.map(*handles()[0]); // main vanishing point
         QPointF p1 = initialTransform.map(*sideHandles()[0]);
         QPointF p2 = initialTransform.map(*sideHandles()[1]);
         QPointF p3 = initialTransform.map(*sideHandles()[2]);
         QPointF p4 = initialTransform.map(*sideHandles()[3]);
 
 
         QRectF ellipse = QRectF(QPointF(p0.x() -15, p0.y() -15), QSizeF(30, 30));
 
         QPainterPath pathCenter;
         pathCenter.addEllipse(ellipse);
         drawPath(gc, pathCenter, isSnappingActive());
 
         QColor paintingColor = effectiveAssistantColor();
 
 
         // draw the lines connecting the different nodes
         QPen penStyle(paintingColor, 2.0, Qt::SolidLine);
 
         if (!isSnappingActive()) {
             QColor snappingColor = paintingColor;
             snappingColor.setAlpha(snappingColor.alpha() * 0.2);
 
             penStyle.setColor(snappingColor);
         }
 
         gc.save();
         gc.setPen(penStyle);
         gc.drawLine(p0, p1);
         gc.drawLine(p0, p3);
         gc.drawLine(p1, p2);
         gc.drawLine(p3, p4);
         gc.restore();
     }
 
 
     // draw references guide for vanishing points at specified density
     // this is shown as part of the preview, so don't show if preview is off
     if ( (assistantVisible && canvas->paintingAssistantsDecoration()->outlineVisibility()) && this->isSnappingActive() ) {
 
         // cycle through degrees from 0 to 180. We are doing an infinite line, so we don't need to go 360
         QTransform initialTransform = converter->documentToWidgetTransform();
         QPointF p0 = initialTransform.map(*handles()[0]); // main vanishing point
 
         for (int currentAngle=0; currentAngle <= 180; currentAngle = currentAngle + m_referenceLineDensity ) {
 
            // determine the correct angle based on the iteration
            float xPos = cos(currentAngle * M_PI / 180);
            float yPos = sin(currentAngle * M_PI / 180);
            QPointF unitAngle;
            unitAngle.setX(p0.x() + xPos);
            unitAngle.setY(p0.y() + yPos);
 
            // find point
            QLineF snapLine= QLineF(p0, unitAngle);
            QRect viewport= gc.viewport();
            KisAlgebra2D::intersectLineRect(snapLine, viewport);
 
            // make a line from VP center to edge of canvas with that angle
            QPainterPath path;
            path.moveTo(snapLine.p1());
            path.lineTo(snapLine.p2());
            drawPreview(gc, path);//and we draw the preview.
         }
     }
 
 
     gc.restore();
 
     KisPaintingAssistant::drawAssistant(gc, updateRect, converter, cached, canvas, assistantVisible, previewVisible);
 }
 
 void VanishingPointAssistant::drawCache(QPainter& gc, const KisCoordinatesConverter *converter, bool assistantVisible)
 {
     if (!m_canvas || !isAssistantComplete()) {
         return;
     }
 
     if (assistantVisible == false ||   m_canvas->paintingAssistantsDecoration()->isEditingAssistants()) {
         return;
     }
 
     QTransform initialTransform = converter->documentToWidgetTransform();
     QPointF p0 = initialTransform.map(*handles()[0]);
 
     // draws an "X"
     QPainterPath path;
     path.moveTo(QPointF(p0.x() - 10.0, p0.y() - 10.0));
     path.lineTo(QPointF(p0.x() + 10.0, p0.y() + 10.0));
 
     path.moveTo(QPointF(p0.x() - 10.0, p0.y() + 10.0));
     path.lineTo(QPointF(p0.x() + 10.0, p0.y() - 10.0));
 
 
     drawPath(gc, path, isSnappingActive());
 }
 
-QPointF VanishingPointAssistant::buttonPosition() const
+QPointF VanishingPointAssistant::getEditorPosition() const
 {
     return (*handles()[0]);
 }
 
 void VanishingPointAssistant::setReferenceLineDensity(float value)
 {
     // cannot have less than 1 degree value
     if (value < 1.0) {
         value = 1.0;
     }
 
     m_referenceLineDensity = value;
 }
 
 float VanishingPointAssistant::referenceLineDensity()
 {
     return m_referenceLineDensity;
 }
 
 bool VanishingPointAssistant::isAssistantComplete() const
 {
     return handles().size() > 0; // only need one point to be ready
 }
 
 void VanishingPointAssistant::saveCustomXml(QXmlStreamWriter* xml)
 {
     xml->writeStartElement("angleDensity");
     xml->writeAttribute("value", KisDomUtils::toString( this->referenceLineDensity()));
     xml->writeEndElement();
 }
 
 bool VanishingPointAssistant::loadCustomXml(QXmlStreamReader* xml)
 {
     if (xml && xml->name() == "angleDensity") {
          this->setReferenceLineDensity((float)KisDomUtils::toDouble(xml->attributes().value("value").toString()));
     }
 
     return true;
 }
 
 
 VanishingPointAssistantFactory::VanishingPointAssistantFactory()
 {
 }
 
 VanishingPointAssistantFactory::~VanishingPointAssistantFactory()
 {
 }
 
 QString VanishingPointAssistantFactory::id() const
 {
     return "vanishing point";
 }
 
 QString VanishingPointAssistantFactory::name() const
 {
     return i18n("Vanishing Point");
 }
 
 KisPaintingAssistant* VanishingPointAssistantFactory::createPaintingAssistant() const
 {
     return new VanishingPointAssistant;
 }
diff --git a/plugins/assistants/Assistants/VanishingPointAssistant.h b/plugins/assistants/Assistants/VanishingPointAssistant.h
index 3710e602bf..8c790161ad 100644
--- a/plugins/assistants/Assistants/VanishingPointAssistant.h
+++ b/plugins/assistants/Assistants/VanishingPointAssistant.h
@@ -1,85 +1,85 @@
 /*
  * Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
  * Copyright (c) 2010 Geoffry Song <goffrie@gmail.com>
  * Copyright (c) 2014 Wolthera van Hövell tot Westerflier <griffinvalley@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 _VANISHINGPOINT_ASSISTANT_H_
 #define _VANISHINGPOINT_ASSISTANT_H_
 
 #include "kis_painting_assistant.h"
 #include <QObject>
 #include <QPolygonF>
 #include <QLineF>
 #include <QTransform>
 /* Design:
  *The idea behind the vanishing point ruler is that in a perspective deformed landscape, a set of parallel
  *lines al share a single vanishing point.
  *Therefore, a perspective can contain an theoretical infinite of vanishing points.
  *It's a pity if we only allowed an artist to access 1, 2 or 3 of these at any given time, as other
  *solutions for perspective tools do.
  *Hence a vanishing point ruler.
  *
  *This ruler is relatively simple compared to the other perspective ruler:
  *It has only one vanishing point that is required to draw.
  *However, it does have it's own weaknesses in how to determine onto which of these infinite rulers to snap.
  *Furthermore, it has four extra handles for adding a perspective ruler to a preexisting perspective.
  */
 //class VanishingPoint;
 
 class VanishingPointAssistant : public KisPaintingAssistant
 {
 public:
     VanishingPointAssistant();
     KisPaintingAssistantSP clone(QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap) const override;
     QPointF adjustPosition(const QPointF& point, const QPointF& strokeBegin) override;
     //virtual void endStroke();
-    QPointF buttonPosition() const override;
+    QPointF getEditorPosition() const override;
     int numHandles() const override { return 1; }
 
     float referenceLineDensity();
     void setReferenceLineDensity(float value);
 
     bool isAssistantComplete() const override;
 
     void saveCustomXml(QXmlStreamWriter* xml) override;
     bool loadCustomXml(QXmlStreamReader* xml) override;
 
 protected:
     void drawAssistant(QPainter& gc, const QRectF& updateRect, const KisCoordinatesConverter* converter, bool  cached = true,KisCanvas2* canvas=0, 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);
     explicit VanishingPointAssistant(const VanishingPointAssistant &rhs, QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap);
     KisCanvas2 *m_canvas;
 
     float m_referenceLineDensity = 15.0;
 
 };
 
 class VanishingPointAssistantFactory : public KisPaintingAssistantFactory
 {
 public:
     VanishingPointAssistantFactory();
     ~VanishingPointAssistantFactory() override;
     QString id() const override;
     QString name() const override;
     KisPaintingAssistant* createPaintingAssistant() const override;
 };
 
 #endif
diff --git a/plugins/assistants/Assistants/kis_assistant_tool.cc b/plugins/assistants/Assistants/kis_assistant_tool.cc
index e371b6a87b..a9af2756e8 100644
--- a/plugins/assistants/Assistants/kis_assistant_tool.cc
+++ b/plugins/assistants/Assistants/kis_assistant_tool.cc
@@ -1,1062 +1,1061 @@
 /*
  * 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.
  */
 
 #include <kis_assistant_tool.h>
 
 #include <QPainter>
 #include <QXmlStreamReader>
 #include <QXmlStreamWriter>
 #include <QStandardPaths>
 #include <QFile>
 #include <QLineF>
 
 #include <kis_debug.h>
 #include <klocalizedstring.h>
 #include <KColorButton>
 #include "kis_dom_utils.h"
 #include <QMessageBox>
 
 #include <KoIcon.h>
 #include <KoFileDialog.h>
 #include <KoViewConverter.h>
 #include <KoPointerEvent.h>
 #include <KoSnapGuide.h>
 
 #include <canvas/kis_canvas2.h>
 #include <kis_canvas_resource_provider.h>
 #include <kis_cursor.h>
 #include <kis_image.h>
 #include <KisViewManager.h>
 #include <kis_icon.h>
 #include <kis_abstract_perspective_grid.h>
 #include <kis_painting_assistants_decoration.h>
 #include "kis_global.h"
 #include "VanishingPointAssistant.h"
 #include "EditAssistantsCommand.h"
 #include <kis_undo_adapter.h>
 
 #include <math.h>
 
 KisAssistantTool::KisAssistantTool(KoCanvasBase * canvas)
     : KisTool(canvas, KisCursor::arrowCursor()), m_canvas(dynamic_cast<KisCanvas2*>(canvas)),
       m_assistantDrag(0), m_newAssistant(0), m_optionsWidget(0)
 {
     Q_ASSERT(m_canvas);
     setObjectName("tool_assistanttool");
 }
 
 KisAssistantTool::~KisAssistantTool()
 {
 }
 
 void KisAssistantTool::activate(ToolActivation toolActivation, const QSet<KoShape*> &shapes)
 {
 
     KisTool::activate(toolActivation, shapes);
 
     m_canvas->paintingAssistantsDecoration()->activateAssistantsEditor();
     m_handles = m_canvas->paintingAssistantsDecoration()->handles();
 
     m_handleDrag = 0;
     m_internalMode = MODE_CREATION;
     m_assistantHelperYOffset = 10;
 
 
     m_handleSize = 17;
     m_canvas->paintingAssistantsDecoration()->setHandleSize(m_handleSize);
 
 
     if (m_optionsWidget) {
         m_canvas->paintingAssistantsDecoration()->deselectAssistant();
         updateToolOptionsUI();
     }
 
     m_canvas->updateCanvas();
 }
 
 void KisAssistantTool::deactivate()
 {
     m_canvas->paintingAssistantsDecoration()->deactivateAssistantsEditor();
     m_canvas->updateCanvas();
     KisTool::deactivate();
 }
 
 void KisAssistantTool::beginPrimaryAction(KoPointerEvent *event)
 {
     setMode(KisTool::PAINT_MODE);
     m_origAssistantList = KisPaintingAssistant::cloneAssistantList(m_canvas->paintingAssistantsDecoration()->assistants());
 
     bool newAssistantAllowed = true;
 
     KisPaintingAssistantsDecorationSP canvasDecoration = m_canvas->paintingAssistantsDecoration();
 
     if (m_newAssistant) {
         m_internalMode = MODE_CREATION;
         *m_newAssistant->handles().back() = canvasDecoration->snapToGuide(event, QPointF(), false);
         if (m_newAssistant->handles().size() == m_newAssistant->numHandles()) {
             addAssistant();
         } else {
             m_newAssistant->addHandle(new KisPaintingAssistantHandle(canvasDecoration->snapToGuide(event, QPointF(), false)), HandleType::NORMAL);
         }
         m_canvas->updateCanvas();
         return;
     }
     m_handleDrag = 0;
     double minDist = 81.0;
 
 
     QPointF mousePos = m_canvas->viewConverter()->documentToView(canvasDecoration->snapToGuide(event, QPointF(), false));//m_canvas->viewConverter()->documentToView(event->point);
 
     // syncs the assistant handles to the handles reference we store in this tool
     // they can get out of sync with the way the actions and paintevents occur
     // we probably need to stop storing a reference in m_handles and call the assistants directly
     m_handles = m_canvas->paintingAssistantsDecoration()->handles();
 
 
     Q_FOREACH (KisPaintingAssistantSP assistant, m_canvas->paintingAssistantsDecoration()->assistants()) {
 
 
         // find out which handle on all assistants is closest to the mouse position
         // vanishing points have "side handles", so make sure to include that
         {
             QList<KisPaintingAssistantHandleSP> allAssistantHandles;
             allAssistantHandles.append(assistant->handles());
             allAssistantHandles.append(assistant->sideHandles());
 
             Q_FOREACH (const KisPaintingAssistantHandleSP handle, allAssistantHandles) {
 
                 double dist = KisPaintingAssistant::norm2(mousePos - m_canvas->viewConverter()->documentToView(*handle));
                 if (dist < minDist) {
                     minDist = dist;
                     m_handleDrag = handle;
 
                     assistantSelected(assistant); // whatever handle is the closest contains the selected assistant
                 }
             }
         }
 
 
 
 
         if(m_handleDrag && assistant->id() == "perspective") {
             // Look for the handle which was pressed
 
 
             if (m_handleDrag == assistant->topLeft()) {
                 double dist = KisPaintingAssistant::norm2(mousePos - m_canvas->viewConverter()->documentToView(*m_handleDrag));
                 if (dist < minDist) {
                     minDist = dist;
                 }
                 m_dragStart = QPointF(assistant->topRight().data()->x(),assistant->topRight().data()->y());
                 m_internalMode = MODE_DRAGGING_NODE;
             } else if (m_handleDrag == assistant->topRight()) {
                 double dist = KisPaintingAssistant::norm2(mousePos - m_canvas->viewConverter()->documentToView(*m_handleDrag));
                 if (dist < minDist) {
                     minDist = dist;
                 }
                 m_internalMode = MODE_DRAGGING_NODE;
                 m_dragStart = QPointF(assistant->topLeft().data()->x(),assistant->topLeft().data()->y());
             } else if (m_handleDrag == assistant->bottomLeft()) {
                 double dist = KisPaintingAssistant::norm2(mousePos - m_canvas->viewConverter()->documentToView(*m_handleDrag));
                 if (dist < minDist) {
                     minDist = dist;
                 }
                 m_internalMode = MODE_DRAGGING_NODE;
                 m_dragStart = QPointF(assistant->bottomRight().data()->x(),assistant->bottomRight().data()->y());
             } else if (m_handleDrag == assistant->bottomRight()) {
                 double dist = KisPaintingAssistant::norm2(mousePos - m_canvas->viewConverter()->documentToView(*m_handleDrag));
                 if (dist < minDist) {
                     minDist = dist;
                 }
                 m_internalMode = MODE_DRAGGING_NODE;
                 m_dragStart = QPointF(assistant->bottomLeft().data()->x(),assistant->bottomLeft().data()->y());
             } else if (m_handleDrag == assistant->leftMiddle()) {
                 m_internalMode = MODE_DRAGGING_TRANSLATING_TWONODES;
                 m_dragStart = QPointF((assistant->bottomLeft().data()->x()+assistant->topLeft().data()->x())*0.5,
                                       (assistant->bottomLeft().data()->y()+assistant->topLeft().data()->y())*0.5);
                 m_selectedNode1 = new KisPaintingAssistantHandle(assistant->topLeft().data()->x(),assistant->topLeft().data()->y());
                 m_selectedNode2 = new KisPaintingAssistantHandle(assistant->bottomLeft().data()->x(),assistant->bottomLeft().data()->y());
                 m_newAssistant = toQShared(KisPaintingAssistantFactoryRegistry::instance()->get("perspective")->createPaintingAssistant());
                 m_newAssistant->addHandle(assistant->topLeft(), HandleType::NORMAL );
                 m_newAssistant->addHandle(m_selectedNode1, HandleType::NORMAL);
                 m_newAssistant->addHandle(m_selectedNode2, HandleType::NORMAL);
                 m_newAssistant->addHandle(assistant->bottomLeft(), HandleType::NORMAL);
                 m_dragEnd = event->point;
                 m_handleDrag = 0;
                 m_canvas->updateCanvas(); // TODO update only the relevant part of the canvas
                 return;
             } else if (m_handleDrag == assistant->rightMiddle()) {
                 m_dragStart = QPointF((assistant->topRight().data()->x()+assistant->bottomRight().data()->x())*0.5,
                                       (assistant->topRight().data()->y()+assistant->bottomRight().data()->y())*0.5);
                 m_internalMode = MODE_DRAGGING_TRANSLATING_TWONODES;
                 m_selectedNode1 = new KisPaintingAssistantHandle(assistant->topRight().data()->x(),assistant->topRight().data()->y());
                 m_selectedNode2 = new KisPaintingAssistantHandle(assistant->bottomRight().data()->x(),assistant->bottomRight().data()->y());
                 m_newAssistant = toQShared(KisPaintingAssistantFactoryRegistry::instance()->get("perspective")->createPaintingAssistant());
                 m_newAssistant->addHandle(assistant->topRight(), HandleType::NORMAL);
                 m_newAssistant->addHandle(m_selectedNode1, HandleType::NORMAL);
                 m_newAssistant->addHandle(m_selectedNode2, HandleType::NORMAL);
                 m_newAssistant->addHandle(assistant->bottomRight(), HandleType::NORMAL);
                 m_dragEnd = event->point;
                 m_handleDrag = 0;
                 m_canvas->updateCanvas(); // TODO update only the relevant part of the canvas
                 return;
             } else if (m_handleDrag == assistant->topMiddle()) {
                 m_dragStart = QPointF((assistant->topLeft().data()->x()+assistant->topRight().data()->x())*0.5,
                                       (assistant->topLeft().data()->y()+assistant->topRight().data()->y())*0.5);
                 m_internalMode = MODE_DRAGGING_TRANSLATING_TWONODES;
                 m_selectedNode1 = new KisPaintingAssistantHandle(assistant->topLeft().data()->x(),assistant->topLeft().data()->y());
                 m_selectedNode2 = new KisPaintingAssistantHandle(assistant->topRight().data()->x(),assistant->topRight().data()->y());
                 m_newAssistant = toQShared(KisPaintingAssistantFactoryRegistry::instance()->get("perspective")->createPaintingAssistant());
                 m_newAssistant->addHandle(m_selectedNode1, HandleType::NORMAL);
                 m_newAssistant->addHandle(m_selectedNode2, HandleType::NORMAL);
                 m_newAssistant->addHandle(assistant->topRight(), HandleType::NORMAL);
                 m_newAssistant->addHandle(assistant->topLeft(), HandleType::NORMAL);
                 m_dragEnd = event->point;
                 m_handleDrag = 0;
                 m_canvas->updateCanvas(); // TODO update only the relevant part of the canvas
                 return;
             } else if (m_handleDrag == assistant->bottomMiddle()) {
                 m_dragStart = QPointF((assistant->bottomLeft().data()->x()+assistant->bottomRight().data()->x())*0.5,
                                       (assistant->bottomLeft().data()->y()+assistant->bottomRight().data()->y())*0.5);
                 m_internalMode = MODE_DRAGGING_TRANSLATING_TWONODES;
                 m_selectedNode1 = new KisPaintingAssistantHandle(assistant->bottomLeft().data()->x(),assistant->bottomLeft().data()->y());
                 m_selectedNode2 = new KisPaintingAssistantHandle(assistant->bottomRight().data()->x(),assistant->bottomRight().data()->y());
                 m_newAssistant = toQShared(KisPaintingAssistantFactoryRegistry::instance()->get("perspective")->createPaintingAssistant());
                 m_newAssistant->addHandle(assistant->bottomLeft(), HandleType::NORMAL);
                 m_newAssistant->addHandle(assistant->bottomRight(), HandleType::NORMAL);
                 m_newAssistant->addHandle(m_selectedNode2, HandleType::NORMAL);
                 m_newAssistant->addHandle(m_selectedNode1, HandleType::NORMAL);
                 m_dragEnd = event->point;
                 m_handleDrag = 0;
                 m_canvas->updateCanvas(); // TODO update only the relevant part of the canvas
                 return;
             }
             m_snapIsRadial = false;
         }
         else if (m_handleDrag && assistant->handles().size()>1 && (assistant->id() == "ruler" ||
                                                                    assistant->id() == "parallel ruler" ||
                                                                    assistant->id() == "infinite ruler" ||
                                                                    assistant->id() == "spline")){
             if (m_handleDrag == assistant->handles()[0]) {
                 m_dragStart = *assistant->handles()[1];
             } else if (m_handleDrag == assistant->handles()[1]) {
                 m_dragStart = *assistant->handles()[0];
             } else if(assistant->handles().size()==4){
                 if (m_handleDrag == assistant->handles()[2]) {
                     m_dragStart = *assistant->handles()[0];
                 } else if (m_handleDrag == assistant->handles()[3]) {
                     m_dragStart = *assistant->handles()[1];
                 }
             }
             m_snapIsRadial = false;
         } else if (m_handleDrag && assistant->handles().size()>2 && (assistant->id() == "ellipse" ||
                                     assistant->id() == "concentric ellipse" ||
                                     assistant->id() == "fisheye-point")){
             m_snapIsRadial = false;
             if (m_handleDrag == assistant->handles()[0]) {
                 m_dragStart = *assistant->handles()[1];
             } else if (m_handleDrag == assistant->handles()[1]) {
                 m_dragStart = *assistant->handles()[0];
             } else if (m_handleDrag == assistant->handles()[2]) {
-                m_dragStart = assistant->buttonPosition();
+                m_dragStart = assistant->getEditorPosition();
                 m_radius = QLineF(m_dragStart, *assistant->handles()[0]);
                 m_snapIsRadial = true;
             }
 
         } else {
-            m_dragStart = assistant->buttonPosition();
+            m_dragStart = assistant->getEditorPosition();
             m_snapIsRadial = false;
         }
     }
 
     if (m_handleDrag) {
         // TODO: Shift-press should now be handled using the alternate actions
         // if (event->modifiers() & Qt::ShiftModifier) {
         //     m_handleDrag->uncache();
         //     m_handleDrag = m_handleDrag->split()[0];
         //     m_handles = m_canvas->view()->paintingAssistantsDecoration()->handles();
         // }
         m_canvas->updateCanvas(); // TODO update only the relevant part of the canvas
         return;
     }
 
     m_assistantDrag.clear();
     Q_FOREACH (KisPaintingAssistantSP assistant, m_canvas->paintingAssistantsDecoration()->assistants()) {
 
-        // This code contains the click event behavior.
-        QTransform initialTransform = m_canvas->coordinatesConverter()->documentToWidgetTransform();
-        QPointF actionsPosition = initialTransform.map(assistant->buttonPosition());
+        AssistantEditorData editorShared; // shared position data between assistant tool and decoration
+        const KisCoordinatesConverter *converter = m_canvas->coordinatesConverter();
 
+        // This code contains the click event behavior.
+        QTransform initialTransform = converter->documentToWidgetTransform();
+        QPointF actionsPosition = initialTransform.map(assistant->viewportConstrainedEditorPosition(converter, editorShared.boundingSize));
 
         // for UI editor widget controls with move, show, and delete -- disregard document transforms like rotating and mirroring.
         // otherwise the UI controls get awkward to use when they are at 45 degree angles or the order of controls gets flipped backwards
-        QPointF uiMousePosition = initialTransform.map( canvasDecoration->snapToGuide(event, QPointF(), false));
-
-        AssistantEditorData editorShared; // shared position data between assistant tool and decoration
+        QPointF uiMousePosition = initialTransform.map(canvasDecoration->snapToGuide(event, QPointF(), false));
 
         QPointF iconMovePosition(actionsPosition + editorShared.moveIconPosition);
         QPointF iconSnapPosition(actionsPosition + editorShared.snapIconPosition);
         QPointF iconDeletePosition(actionsPosition + editorShared.deleteIconPosition);
 
-
         QRectF deleteRect(iconDeletePosition, QSizeF(editorShared.deleteIconSize, editorShared.deleteIconSize));
         QRectF visibleRect(iconSnapPosition, QSizeF(editorShared.snapIconSize, editorShared.snapIconSize));
         QRectF moveRect(iconMovePosition, QSizeF(editorShared.moveIconSize, editorShared.moveIconSize));
 
         if (moveRect.contains(uiMousePosition)) {
             m_assistantDrag = assistant;
             m_cursorStart = event->point;
             m_currentAdjustment = QPointF();
             m_internalMode = MODE_EDITING;
 
 
             assistantSelected(assistant); // whatever handle is the closest contains the selected assistant
 
             return;
         }
 
         if (deleteRect.contains(uiMousePosition)) {
             removeAssistant(assistant);
             if(m_canvas->paintingAssistantsDecoration()->assistants().isEmpty()) {
                 m_internalMode = MODE_CREATION;
             }
             else
                 m_internalMode = MODE_EDITING;
             m_canvas->updateCanvas();
             return;
         }
         if (visibleRect.contains(uiMousePosition)) {
             newAssistantAllowed = false;
             assistant->setSnappingActive(!assistant->isSnappingActive()); // toggle
             assistant->uncache();//this updates the chache of the assistant, very important.
 
             assistantSelected(assistant); // whatever handle is the closest contains the selected assistant
         }
     }
     if (newAssistantAllowed==true){//don't make a new assistant when I'm just toogling visibility//
         QString key = m_options.availableAssistantsComboBox->model()->index( m_options.availableAssistantsComboBox->currentIndex(), 0 ).data(Qt::UserRole).toString();
         m_newAssistant = toQShared(KisPaintingAssistantFactoryRegistry::instance()->get(key)->createPaintingAssistant());
         m_internalMode = MODE_CREATION;
         m_newAssistant->addHandle(new KisPaintingAssistantHandle(canvasDecoration->snapToGuide(event, QPointF(), false)), HandleType::NORMAL);
         if (m_newAssistant->numHandles() <= 1) {
             addAssistant();
         } else {
             m_newAssistant->addHandle(new KisPaintingAssistantHandle(canvasDecoration->snapToGuide(event, QPointF(), false)), HandleType::NORMAL);
         }
     }
 
     if (m_newAssistant) {
         m_newAssistant->setAssistantGlobalColorCache(m_canvas->paintingAssistantsDecoration()->globalAssistantsColor());
     }
 
     m_canvas->updateCanvas();
 }
 
 void KisAssistantTool::continuePrimaryAction(KoPointerEvent *event)
 {
     KisPaintingAssistantsDecorationSP canvasDecoration = m_canvas->paintingAssistantsDecoration();
 
     if (m_handleDrag) {
         *m_handleDrag = event->point;
         //ported from the gradient tool... we need to think about this more in the future.
         if (event->modifiers() == Qt::ShiftModifier && m_snapIsRadial) {
             QLineF dragRadius = QLineF(m_dragStart, event->point);
             dragRadius.setLength(m_radius.length());
             *m_handleDrag = dragRadius.p2();
         } else if (event->modifiers() == Qt::ShiftModifier ) {
             QPointF move = snapToClosestAxis(event->point - m_dragStart);
             *m_handleDrag = m_dragStart + move;
         } else {
             *m_handleDrag = canvasDecoration->snapToGuide(event, QPointF(), false);
         }
         m_handleDrag->uncache();
 
         m_handleCombine = 0;
         if (!(event->modifiers() & Qt::ShiftModifier)) {
             double minDist = 49.0;
             QPointF mousePos = m_canvas->viewConverter()->documentToView(event->point);
             Q_FOREACH (const KisPaintingAssistantHandleSP handle, m_handles) {
                 if (handle == m_handleDrag)
                     continue;
 
 
                 double dist = KisPaintingAssistant::norm2(mousePos - m_canvas->viewConverter()->documentToView(*handle));
                 if (dist < minDist) {
                     minDist = dist;
                     m_handleCombine = handle;
                 }
             }
         }
         m_canvas->updateCanvas();
     } else if (m_assistantDrag) {
         QPointF newAdjustment = canvasDecoration->snapToGuide(event, QPointF(), false) - m_cursorStart;
         if (event->modifiers() == Qt::ShiftModifier ) {
             newAdjustment = snapToClosestAxis(newAdjustment);
         }
         Q_FOREACH (KisPaintingAssistantHandleSP handle, m_assistantDrag->handles()) {
             *handle += (newAdjustment - m_currentAdjustment);
         }
         if (m_assistantDrag->id()== "vanishing point"){
             Q_FOREACH (KisPaintingAssistantHandleSP handle, m_assistantDrag->sideHandles()) {
                 *handle += (newAdjustment - m_currentAdjustment);
             }
         }
         m_currentAdjustment = newAdjustment;
         m_canvas->updateCanvas();
 
     } else {
         event->ignore();
     }
 
     bool wasHiglightedNode = m_higlightedNode != 0;
     QPointF mousep = m_canvas->viewConverter()->documentToView(event->point);
     QList <KisPaintingAssistantSP> pAssistant= m_canvas->paintingAssistantsDecoration()->assistants();
 
     Q_FOREACH (KisPaintingAssistantSP assistant, pAssistant) {
         if(assistant->id() == "perspective") {
             if ((m_higlightedNode = assistant->closestCornerHandleFromPoint(mousep))) {
                 if (m_higlightedNode == m_selectedNode1 || m_higlightedNode == m_selectedNode2) {
                     m_higlightedNode = 0;
                 } else {
                     m_canvas->updateCanvas(); // TODO update only the relevant part of the canvas
                     break;
                 }
             }
         }
 
         //this following bit sets the translations for the vanishing-point handles.
         if(m_handleDrag && assistant->id() == "vanishing point" && assistant->sideHandles().size()==4) {
             //for inner handles, the outer handle gets translated.
             if (m_handleDrag == assistant->sideHandles()[0]) {
                 QLineF perspectiveline = QLineF(*assistant->handles()[0],
                                                 *assistant->sideHandles()[0]);
 
                 qreal length = QLineF(*assistant->sideHandles()[0],
                                       *assistant->sideHandles()[1]).length();
 
                 if (length < 2.0){
                     length = 2.0;
                 }
 
                 length += perspectiveline.length();
                 perspectiveline.setLength(length);
                 *assistant->sideHandles()[1] = perspectiveline.p2();
             }
             else if (m_handleDrag == assistant->sideHandles()[2]){
                 QLineF perspectiveline = QLineF(*assistant->handles()[0], *assistant->sideHandles()[2]);
                 qreal length = QLineF(*assistant->sideHandles()[2], *assistant->sideHandles()[3]).length();
 
                 if (length<2.0){
                     length=2.0;
                 }
 
                 length += perspectiveline.length();
                 perspectiveline.setLength(length);
                 *assistant->sideHandles()[3] = perspectiveline.p2();
             } // for outer handles, only the vanishing point is translated, but only if there's an intersection.
             else if (m_handleDrag == assistant->sideHandles()[1]|| m_handleDrag == assistant->sideHandles()[3]){
                 QPointF vanishingpoint(0,0);
                 QLineF perspectiveline = QLineF(*assistant->sideHandles()[0], *assistant->sideHandles()[1]);
                 QLineF perspectiveline2 = QLineF(*assistant->sideHandles()[2], *assistant->sideHandles()[3]);
 
                 if (QLineF(perspectiveline2).intersect(QLineF(perspectiveline), &vanishingpoint) != QLineF::NoIntersection){
                     *assistant->handles()[0] = vanishingpoint;
                 }
             }// and for the vanishing point itself, only the outer handles get translated.
             else if (m_handleDrag == assistant->handles()[0]){
                 QLineF perspectiveline = QLineF(*assistant->handles()[0], *assistant->sideHandles()[0]);
                 QLineF perspectiveline2 = QLineF(*assistant->handles()[0], *assistant->sideHandles()[2]);
                 qreal length =  QLineF(*assistant->sideHandles()[0], *assistant->sideHandles()[1]).length();
                 qreal length2 = QLineF(*assistant->sideHandles()[2], *assistant->sideHandles()[3]).length();
 
                 if (length < 2.0) {
                     length = 2.0;
                 }
 
                 if (length2 < 2.0) {
                     length2=2.0;
                 }
 
                 length += perspectiveline.length();
                 length2 += perspectiveline2.length();
                 perspectiveline.setLength(length);
                 perspectiveline2.setLength(length2);
                 *assistant->sideHandles()[1] = perspectiveline.p2();
                 *assistant->sideHandles()[3] = perspectiveline2.p2();
             }
 
         }
     }
     if (wasHiglightedNode && !m_higlightedNode) {
         m_canvas->updateCanvas(); // TODO update only the relevant part of the canvas
     }
 }
 
 void KisAssistantTool::endPrimaryAction(KoPointerEvent *event)
 {
     setMode(KisTool::HOVER_MODE);
 
     if (m_handleDrag || m_assistantDrag) {
         if (m_handleDrag) {
             if (!(event->modifiers() & Qt::ShiftModifier) && m_handleCombine) {
                 m_handleCombine->mergeWith(m_handleDrag);
                 m_handleCombine->uncache();
                 m_handles = m_canvas->paintingAssistantsDecoration()->handles();
             }
             m_handleDrag = m_handleCombine = 0;
         } else {
             m_assistantDrag.clear();
         }
         dbgUI << "creating undo command...";
         KUndo2Command *command = new EditAssistantsCommand(m_canvas, m_origAssistantList, KisPaintingAssistant::cloneAssistantList(m_canvas->paintingAssistantsDecoration()->assistants()));
         m_canvas->viewManager()->undoAdapter()->addCommand(command);
         dbgUI << "done";
     } else if(m_internalMode == MODE_DRAGGING_TRANSLATING_TWONODES) {
         addAssistant();
         m_internalMode = MODE_CREATION;
     }
     else {
         event->ignore();
     }
 
     m_canvas->updateCanvas(); // TODO update only the relevant part of the canvas
 }
 
 void KisAssistantTool::addAssistant()
 {
     m_canvas->paintingAssistantsDecoration()->addAssistant(m_newAssistant);
 
     KisAbstractPerspectiveGrid* grid = dynamic_cast<KisAbstractPerspectiveGrid*>(m_newAssistant.data());
     if (grid) {
         m_canvas->viewManager()->canvasResourceProvider()->addPerspectiveGrid(grid);
     }
 
     QList<KisPaintingAssistantSP> assistants = m_canvas->paintingAssistantsDecoration()->assistants();
     KUndo2Command *addAssistantCmd = new EditAssistantsCommand(m_canvas, m_origAssistantList, KisPaintingAssistant::cloneAssistantList(assistants), EditAssistantsCommand::ADD, assistants.indexOf(m_newAssistant));
     m_canvas->viewManager()->undoAdapter()->addCommand(addAssistantCmd);
 
     m_handles = m_canvas->paintingAssistantsDecoration()->handles();
     m_canvas->paintingAssistantsDecoration()->setSelectedAssistant(m_newAssistant);
     updateToolOptionsUI(); // vanishing point assistant will get an extra option
 
     m_newAssistant.clear();
 }
 
 void KisAssistantTool::removeAssistant(KisPaintingAssistantSP assistant)
 {
     QList<KisPaintingAssistantSP> assistants = m_canvas->paintingAssistantsDecoration()->assistants();
 
     KisAbstractPerspectiveGrid* grid = dynamic_cast<KisAbstractPerspectiveGrid*>(assistant.data());
     if (grid) {
         m_canvas->viewManager()->canvasResourceProvider()->removePerspectiveGrid(grid);
     }
     m_canvas->paintingAssistantsDecoration()->removeAssistant(assistant);
 
     KUndo2Command *removeAssistantCmd = new EditAssistantsCommand(m_canvas, m_origAssistantList, KisPaintingAssistant::cloneAssistantList(m_canvas->paintingAssistantsDecoration()->assistants()), EditAssistantsCommand::REMOVE, assistants.indexOf(assistant));
     m_canvas->viewManager()->undoAdapter()->addCommand(removeAssistantCmd);
 
     m_handles = m_canvas->paintingAssistantsDecoration()->handles();
     m_canvas->paintingAssistantsDecoration()->deselectAssistant();
     updateToolOptionsUI();
 }
 
 void KisAssistantTool::assistantSelected(KisPaintingAssistantSP assistant)
 {
      m_canvas->paintingAssistantsDecoration()->setSelectedAssistant(assistant);
      updateToolOptionsUI();
 }
 
 void KisAssistantTool::updateToolOptionsUI()
 {
      KisPaintingAssistantSP m_selectedAssistant =  m_canvas->paintingAssistantsDecoration()->selectedAssistant();
 
      bool hasActiveAssistant = m_selectedAssistant ? true : false;
 
      if (m_selectedAssistant) {
          bool isVanishingPointAssistant = m_selectedAssistant->id() == "vanishing point";
          m_options.vanishingPointAngleSpinbox->setVisible(isVanishingPointAssistant);
 
          if (isVanishingPointAssistant) {
              QSharedPointer <VanishingPointAssistant> assis = qSharedPointerCast<VanishingPointAssistant>(m_selectedAssistant);
              m_options.vanishingPointAngleSpinbox->setValue(assis->referenceLineDensity());
          }
 
          // load custom color settings from assistant (this happens when changing assistant
          m_options.useCustomAssistantColor->setChecked(m_selectedAssistant->useCustomColor());
          m_options.customAssistantColorButton->setColor(m_selectedAssistant->assistantCustomColor());
          float opacity = (float)m_selectedAssistant->assistantCustomColor().alpha()/255.0 * 100.0 ;
          m_options.customColorOpacitySlider->setValue(opacity);
      } else {
          m_options.vanishingPointAngleSpinbox->setVisible(false); //
      }
 
      // show/hide elements if an assistant is selected or not
       m_options.assistantsGlobalOpacitySlider->setVisible(hasActiveAssistant);
       m_options.assistantsColor->setVisible(hasActiveAssistant);
       m_options.globalColorLabel->setVisible(hasActiveAssistant);
       m_options.useCustomAssistantColor->setVisible(hasActiveAssistant);
 
       // hide custom color options if use custom color is not selected
       bool showCustomColorSettings = m_options.useCustomAssistantColor->isChecked() && hasActiveAssistant;
       m_options.customColorOpacitySlider->setVisible(showCustomColorSettings);
       m_options.customAssistantColorButton->setVisible(showCustomColorSettings);
 
       // disable global color settings if we are using the custom color
       m_options.assistantsGlobalOpacitySlider->setEnabled(!showCustomColorSettings);
       m_options.assistantsColor->setEnabled(!showCustomColorSettings);
       m_options.globalColorLabel->setEnabled(!showCustomColorSettings);
 
 }
 
 void KisAssistantTool::slotChangeVanishingPointAngle(double value)
 {
     if ( m_canvas->paintingAssistantsDecoration()->assistants().length() == 0) {
         return;
     }
 
     // get the selected assistant and change the angle value
     KisPaintingAssistantSP m_selectedAssistant =  m_canvas->paintingAssistantsDecoration()->selectedAssistant();
     if (m_selectedAssistant) {
         bool isVanishingPointAssistant = m_selectedAssistant->id() == "vanishing point";
 
         if (isVanishingPointAssistant) {
             QSharedPointer <VanishingPointAssistant> assis = qSharedPointerCast<VanishingPointAssistant>(m_selectedAssistant);
             assis->setReferenceLineDensity((float)value);
         }
     }
 
     m_canvas->canvasWidget()->update();
 }
 
 void KisAssistantTool::mouseMoveEvent(KoPointerEvent *event)
 {
     if (m_newAssistant && m_internalMode == MODE_CREATION) {
         *m_newAssistant->handles().back() = event->point;
 
     } else if (m_newAssistant && m_internalMode == MODE_DRAGGING_TRANSLATING_TWONODES) {
         QPointF translate = event->point - m_dragEnd;
         m_dragEnd = event->point;
         m_selectedNode1.data()->operator = (QPointF(m_selectedNode1.data()->x(),m_selectedNode1.data()->y()) + translate);
         m_selectedNode2.data()->operator = (QPointF(m_selectedNode2.data()->x(),m_selectedNode2.data()->y()) + translate);
     }
 
      m_canvas->updateCanvas();
 }
 
 void KisAssistantTool::paint(QPainter& _gc, const KoViewConverter &_converter)
 {
     QRectF canvasSize = QRectF(QPointF(0, 0), QSizeF(m_canvas->image()->size()));
 
     // show special display while a new assistant is in the process of being created
     if (m_newAssistant) {
 
         QColor assistantColor = m_newAssistant->effectiveAssistantColor();
         assistantColor.setAlpha(80);
 
         m_newAssistant->drawAssistant(_gc, canvasSize, m_canvas->coordinatesConverter(), false, m_canvas, true, false);
         Q_FOREACH (const KisPaintingAssistantHandleSP handle, m_newAssistant->handles()) {
             QPainterPath path;
             path.addEllipse(QRectF(_converter.documentToView(*handle) -  QPointF(m_handleSize * 0.5, m_handleSize * 0.5), QSizeF(m_handleSize, m_handleSize)));
 
             _gc.save();
             _gc.setPen(Qt::NoPen);
             _gc.setBrush(assistantColor);
             _gc.drawPath(path);
             _gc.restore();
         }
     }
 
 
     Q_FOREACH (KisPaintingAssistantSP assistant, m_canvas->paintingAssistantsDecoration()->assistants()) {
 
         QColor assistantColor = assistant->effectiveAssistantColor();
         assistantColor.setAlpha(80);
 
         Q_FOREACH (const KisPaintingAssistantHandleSP handle, m_handles) {
             QRectF ellipse(_converter.documentToView(*handle) -  QPointF(m_handleSize * 0.5, m_handleSize * 0.5),
                            QSizeF(m_handleSize, m_handleSize));
 
             // render handles differently if it is the one being dragged.
             if (handle == m_handleDrag || handle == m_handleCombine) {
                 QPen stroke(assistantColor, 4);
                 _gc.save();
                 _gc.setPen(stroke);
                 _gc.setBrush(Qt::NoBrush);
                 _gc.drawEllipse(ellipse);
                 _gc.restore();
             }
 
         }
     }
 }
 
 void KisAssistantTool::removeAllAssistants()
 {
     m_canvas->viewManager()->canvasResourceProvider()->clearPerspectiveGrids();
     m_canvas->paintingAssistantsDecoration()->removeAll();
     m_handles = m_canvas->paintingAssistantsDecoration()->handles();
     m_canvas->updateCanvas();
 
     m_canvas->paintingAssistantsDecoration()->deselectAssistant();
     updateToolOptionsUI();
 }
 
 void KisAssistantTool::loadAssistants()
 {
     KoFileDialog dialog(m_canvas->viewManager()->mainWindow(), KoFileDialog::OpenFile, "OpenAssistant");
     dialog.setCaption(i18n("Select an Assistant"));
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
     dialog.setMimeTypeFilters(QStringList() << "application/x-krita-assistant", "application/x-krita-assistant");
     QString filename = dialog.filename();
     if (filename.isEmpty()) return;
     if (!QFileInfo(filename).exists()) return;
 
     QFile file(filename);
     file.open(QIODevice::ReadOnly);
 
     QByteArray data = file.readAll();
     QXmlStreamReader xml(data);
     QMap<int, KisPaintingAssistantHandleSP> handleMap;
     KisPaintingAssistantSP assistant;
     bool errors = false;
     while (!xml.atEnd()) {
         switch (xml.readNext()) {
         case QXmlStreamReader::StartElement:
             if (xml.name() == "handle") {
                 if (assistant && !xml.attributes().value("ref").isEmpty()) {
                     KisPaintingAssistantHandleSP handle = handleMap.value(xml.attributes().value("ref").toString().toInt());
                     if (handle) {
                        assistant->addHandle(handle, HandleType::NORMAL);
                     } else {
                         errors = true;
                     }
                 } else {
                     QString strId = xml.attributes().value("id").toString(),
                             strX = xml.attributes().value("x").toString(),
                             strY = xml.attributes().value("y").toString();
 
 
 
                     if (!strId.isEmpty() && !strX.isEmpty() && !strY.isEmpty()) {
                         int id = strId.toInt();
                         double x = strX.toDouble(),
                                 y = strY.toDouble();
                         if (!handleMap.contains(id)) {
                             handleMap.insert(id, new KisPaintingAssistantHandle(x, y));
                         } else {
                             errors = true;
                         }
                     } else {
                         errors = true;
                     }
                 }
             } else if (xml.name() == "assistant") {
                 const KisPaintingAssistantFactory* factory = KisPaintingAssistantFactoryRegistry::instance()->get(xml.attributes().value("type").toString());
 
                 if (factory) {
                     if (assistant) {
                         errors = true;
                         assistant.clear();
                     }
                     assistant = toQShared(factory->createPaintingAssistant());
                 } else {
                     errors = true;
                 }
 
 
                // load custom shared assistant properties
                if ( xml.attributes().hasAttribute("useCustomColor")) {
                    QStringRef useCustomColor = xml.attributes().value("useCustomColor");
 
                    bool usingColor = false;
                    if (useCustomColor.toString() == "1") {
                        usingColor = true;
                    }
                    assistant->setUseCustomColor(usingColor);
                }
 
                if ( xml.attributes().hasAttribute("useCustomColor")) {
                    QStringRef customColor = xml.attributes().value("customColor");
                    assistant->setAssistantCustomColor( KisDomUtils::qStringToQColor(customColor.toString()) );
 
                }
            }
 
             if (assistant) {
                 assistant->loadCustomXml(&xml);
             }
 
 
            break;
         case QXmlStreamReader::EndElement:
             if (xml.name() == "assistant") {
                 if (assistant) {
                     if (assistant->handles().size() == assistant->numHandles()) {
                         if (assistant->id() == "vanishing point"){
                         //ideally we'd save and load side-handles as well, but this is all I've got//
                             QPointF pos = *assistant->handles()[0];
                             assistant->addHandle(new KisPaintingAssistantHandle(pos+QPointF(-70,0)), HandleType::SIDE);
                             assistant->addHandle(new KisPaintingAssistantHandle(pos+QPointF(-140,0)), HandleType::SIDE);
                             assistant->addHandle(new KisPaintingAssistantHandle(pos+QPointF(70,0)), HandleType::SIDE);
                             assistant->addHandle(new KisPaintingAssistantHandle(pos+QPointF(140,0)), HandleType::SIDE);
                         }
                         m_canvas->paintingAssistantsDecoration()->addAssistant(assistant);
                         KisAbstractPerspectiveGrid* grid = dynamic_cast<KisAbstractPerspectiveGrid*>(assistant.data());
                         if (grid) {
                             m_canvas->viewManager()->canvasResourceProvider()->addPerspectiveGrid(grid);
                         }
                     } else {
                         errors = true;
                     }
                     assistant.clear();
                 }
             }
 
             break;
         default:
             break;
         }
 
     }
     if (assistant) {
         errors = true;
         assistant.clear();
     }
     if (xml.hasError()) {
         QMessageBox::warning(0, i18nc("@title:window", "Krita"), xml.errorString());
     }
     if (errors) {
         QMessageBox::warning(0, i18nc("@title:window", "Krita"), i18n("Errors were encountered. Not all assistants were successfully loaded."));
     }
     m_handles = m_canvas->paintingAssistantsDecoration()->handles();
     m_canvas->updateCanvas();
 
 }
 
 void KisAssistantTool::saveAssistants()
 {
 
     if (m_handles.isEmpty()) return;
 
     QByteArray data;
     QXmlStreamWriter xml(&data);
     xml.writeStartDocument();
     xml.writeStartElement("paintingassistant");
     xml.writeAttribute("color",
                        KisDomUtils::qColorToQString(
                            m_canvas->paintingAssistantsDecoration()->globalAssistantsColor())); // global color if no custom color used
 
 
     xml.writeStartElement("handles");
     QMap<KisPaintingAssistantHandleSP, int> handleMap;
     Q_FOREACH (const KisPaintingAssistantHandleSP handle, m_handles) {
         int id = handleMap.size();
         handleMap.insert(handle, id);
         xml.writeStartElement("handle");
         //xml.writeAttribute("type", handle->handleType());
         xml.writeAttribute("id", QString::number(id));
         xml.writeAttribute("x", QString::number(double(handle->x()), 'f', 3));
         xml.writeAttribute("y", QString::number(double(handle->y()), 'f', 3));
         xml.writeEndElement();
     }
     xml.writeEndElement();
     xml.writeStartElement("assistants");
 
 
     Q_FOREACH (const KisPaintingAssistantSP assistant, m_canvas->paintingAssistantsDecoration()->assistants()) {
         xml.writeStartElement("assistant");
         xml.writeAttribute("type", assistant->id());
         xml.writeAttribute("useCustomColor", QString::number(assistant->useCustomColor()));
         xml.writeAttribute("customColor",  KisDomUtils::qColorToQString(assistant->assistantCustomColor()));
 
 
 
         // custom assistant properties like angle density on vanishing point
         assistant->saveCustomXml(&xml);
 
         // handle information
         xml.writeStartElement("handles");
         Q_FOREACH (const KisPaintingAssistantHandleSP handle, assistant->handles()) {
             xml.writeStartElement("handle");
             xml.writeAttribute("ref", QString::number(handleMap.value(handle)));
             xml.writeEndElement();
         }
         xml.writeEndElement();
         xml.writeEndElement();
     }
     xml.writeEndElement();
     xml.writeEndElement();
     xml.writeEndDocument();
 
     KoFileDialog dialog(m_canvas->viewManager()->mainWindow(), KoFileDialog::SaveFile, "OpenAssistant");
     dialog.setCaption(i18n("Save Assistant"));
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
     dialog.setMimeTypeFilters(QStringList() << "application/x-krita-assistant", "application/x-krita-assistant");
     QString filename = dialog.filename();
     if (filename.isEmpty()) return;
 
     QFile file(filename);
     file.open(QIODevice::WriteOnly);
     file.write(data);
 }
 
 QWidget *KisAssistantTool::createOptionWidget()
 {
     if (!m_optionsWidget) {
         m_optionsWidget = new QWidget;
         m_options.setupUi(m_optionsWidget);
 
         // 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_options.loadAssistantButton->setIcon(KisIconUtils::loadIcon("document-open"));
         m_options.saveAssistantButton->setIcon(KisIconUtils::loadIcon("document-save"));
         m_options.deleteAllAssistantsButton->setIcon(KisIconUtils::loadIcon("edit-delete"));
 
         QList<KoID> assistants;
         Q_FOREACH (const QString& key, KisPaintingAssistantFactoryRegistry::instance()->keys()) {
             QString name = KisPaintingAssistantFactoryRegistry::instance()->get(key)->name();
             assistants << KoID(key, name);
         }
         std::sort(assistants.begin(), assistants.end(), KoID::compareNames);
         Q_FOREACH(const KoID &id, assistants) {
             m_options.availableAssistantsComboBox->addItem(id.name(), id.id());
         }
 
         connect(m_options.saveAssistantButton, SIGNAL(clicked()), SLOT(saveAssistants()));
         connect(m_options.loadAssistantButton, SIGNAL(clicked()), SLOT(loadAssistants()));
         connect(m_options.deleteAllAssistantsButton, SIGNAL(clicked()), SLOT(removeAllAssistants()));
 
         connect(m_options.assistantsColor, SIGNAL(changed(QColor)), SLOT(slotGlobalAssistantsColorChanged(QColor)));
         connect(m_options.assistantsGlobalOpacitySlider, SIGNAL(valueChanged(int)), SLOT(slotGlobalAssistantOpacityChanged()));
 
 
         connect(m_options.vanishingPointAngleSpinbox, SIGNAL(valueChanged(double)), this, SLOT(slotChangeVanishingPointAngle(double)));
 
         //ENTER_FUNCTION() << ppVar(m_canvas) << ppVar(m_canvas && m_canvas->paintingAssistantsDecoration());
 
         // initialize UI elements with existing data if possible
         if (m_canvas && m_canvas->paintingAssistantsDecoration()) {
             const QColor color = m_canvas->paintingAssistantsDecoration()->globalAssistantsColor();
 
             QColor opaqueColor = color;
             opaqueColor.setAlpha(255);
 
             //ENTER_FUNCTION() << ppVar(opaqueColor);
 
             m_options.assistantsColor->setColor(opaqueColor);
             m_options.customAssistantColorButton->setColor(opaqueColor);
             m_options.assistantsGlobalOpacitySlider->setValue(color.alphaF() * 100.0);
 
         } else {
             m_options.assistantsColor->setColor(QColor(176, 176, 176, 255)); // grey default for all assistants
             m_options.assistantsGlobalOpacitySlider->setValue(100); // 100%
         }
 
         m_options.assistantsGlobalOpacitySlider->setPrefix(i18n("Opacity: "));
         m_options.assistantsGlobalOpacitySlider->setSuffix(" %");
 
 
         // custom color of selected assistant
         m_options.customColorOpacitySlider->setValue(100); // 100%
         m_options.customColorOpacitySlider->setPrefix(i18n("Opacity: "));
         m_options.customColorOpacitySlider->setSuffix(" %");
 
         connect(m_options.useCustomAssistantColor, SIGNAL(clicked(bool)), this, SLOT(slotUpdateCustomColor()));
         connect(m_options.customAssistantColorButton, SIGNAL(changed(QColor)), this, SLOT(slotUpdateCustomColor()));
         connect(m_options.customColorOpacitySlider, SIGNAL(valueChanged(int)), SLOT(slotCustomOpacityChanged()));
 
         m_options.vanishingPointAngleSpinbox->setPrefix(i18n("Density: "));
         m_options.vanishingPointAngleSpinbox->setSuffix(QChar(Qt::Key_degree));
         m_options.vanishingPointAngleSpinbox->setRange(1.0, 180.0);
         m_options.vanishingPointAngleSpinbox->setSingleStep(0.5);
 
 
         m_options.vanishingPointAngleSpinbox->setVisible(false);
 
     }
 
     updateToolOptionsUI();
 
     return m_optionsWidget;
 }
 
 void KisAssistantTool::slotGlobalAssistantsColorChanged(const QColor& setColor)
 {
     // color and alpha are stored separately, so we need to merge the values before sending it on
     int oldAlpha = m_canvas->paintingAssistantsDecoration()->globalAssistantsColor().alpha();
 
     QColor newColor = setColor;
     newColor.setAlpha(oldAlpha);
 
     m_canvas->paintingAssistantsDecoration()->setGlobalAssistantsColor(newColor);
 
     m_canvas->paintingAssistantsDecoration()->uncache();
     m_canvas->canvasWidget()->update();
 }
 
 void KisAssistantTool::slotGlobalAssistantOpacityChanged()
 {
     QColor newColor = m_canvas->paintingAssistantsDecoration()->globalAssistantsColor();
     qreal newOpacity = m_options.assistantsGlobalOpacitySlider->value() * 0.01 * 255.0;
     newColor.setAlpha(int(newOpacity));
     m_canvas->paintingAssistantsDecoration()->setGlobalAssistantsColor(newColor);
 
     m_canvas->paintingAssistantsDecoration()->uncache();
     m_canvas->canvasWidget()->update();
 }
 
 void KisAssistantTool::slotUpdateCustomColor()
 {
     // get the selected assistant and change the angle value
     KisPaintingAssistantSP m_selectedAssistant =  m_canvas->paintingAssistantsDecoration()->selectedAssistant();
     if (m_selectedAssistant) {
         m_selectedAssistant->setUseCustomColor(m_options.useCustomAssistantColor->isChecked());
 
         // changing color doesn't keep alpha, so update that before we send it on
         QColor newColor = m_options.customAssistantColorButton->color();
         newColor.setAlpha(m_selectedAssistant->assistantCustomColor().alpha());
 
         m_selectedAssistant->setAssistantCustomColor(newColor);
         m_selectedAssistant->uncache();
     }
 
     updateToolOptionsUI();
     m_canvas->canvasWidget()->update();
 }
 
 void KisAssistantTool::slotCustomOpacityChanged()
 {
     KisPaintingAssistantSP m_selectedAssistant =  m_canvas->paintingAssistantsDecoration()->selectedAssistant();
     if (m_selectedAssistant) {
         QColor newColor = m_selectedAssistant->assistantCustomColor();
         qreal newOpacity = m_options.customColorOpacitySlider->value() * 0.01 * 255.0;
         newColor.setAlpha(int(newOpacity));
         m_selectedAssistant->setAssistantCustomColor(newColor);
         m_selectedAssistant->uncache();
     }
 
     // this forces the canvas to refresh to see the changes immediately
     m_canvas->paintingAssistantsDecoration()->uncache();
     m_canvas->canvasWidget()->update();
 }
diff --git a/plugins/dockers/advancedcolorselector/kis_color_selector.cpp b/plugins/dockers/advancedcolorselector/kis_color_selector.cpp
index 83c6a29aba..92688e12da 100644
--- a/plugins/dockers/advancedcolorselector/kis_color_selector.cpp
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector.cpp
@@ -1,396 +1,415 @@
 /*
  *  Copyright (c) 2010 Adam Celarek <kdedev at xibo dot at>
  *
  *  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 "kis_color_selector.h"
 
 #include <cmath>
 
 #include <QHBoxLayout>
 #include <QColor>
 #include <QPainter>
 #include <QMouseEvent>
 #include <QTimer>
 #include <QPushButton>
 #include <QApplication>
 
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 
 #include <kis_debug.h>
 
 #include <KoCanvasResourceProvider.h>
+#include <kis_canvas_resource_provider.h>
 #include <kis_icon.h>
 
 #include "kis_color_selector_ring.h"
 #include "kis_color_selector_triangle.h"
 #include "kis_color_selector_simple.h"
 #include "kis_color_selector_wheel.h"
 #include "kis_color_selector_container.h"
 #include "kis_canvas2.h"
 #include "kis_signal_compressor.h"
 #include "KisViewManager.h"
 
 
 KisColorSelector::KisColorSelector(KisColorSelectorConfiguration conf, QWidget* parent)
     : KisColorSelectorBase(parent),
       m_ring(0),
       m_triangle(0),
       m_slider(0),
       m_square(0),
       m_wheel(0),
       m_mainComponent(0),
       m_subComponent(0),
       m_grabbingComponent(0),
       m_blipDisplay(true)
 {
     init();
     updateSettings();
     setConfiguration(conf);
 }
 
 KisColorSelector::KisColorSelector(QWidget* parent)
     : KisColorSelectorBase(parent),
       m_ring(0),
       m_triangle(0),
       m_slider(0),
       m_square(0),
       m_wheel(0),
       m_button(0),
       m_mainComponent(0),
       m_subComponent(0),
       m_grabbingComponent(0),
       m_blipDisplay(true)
 {
     init();
     updateSettings();
 }
 
 KisColorSelectorBase* KisColorSelector::createPopup() const
 {
     KisColorSelectorBase* popup = new KisColorSelector(0);
     popup->setColor(m_lastRealColor);
     return popup;
 }
 
 void KisColorSelector::setConfiguration(KisColorSelectorConfiguration conf)
 {
     m_configuration = conf;
 
     if(m_mainComponent!=0) {
         Q_ASSERT(m_subComponent!=0);
         m_mainComponent->setGeometry(0, 0, 0, 0);
         m_subComponent->setGeometry(0, 0, 0, 0);
 
         m_mainComponent->disconnect();
         m_subComponent->disconnect();
     }
 
     switch (m_configuration.mainType) {
     case KisColorSelectorConfiguration::Square:
         m_mainComponent=m_square;
         break;
     case KisColorSelectorConfiguration::Wheel:
         m_mainComponent=m_wheel;
         break;
     case KisColorSelectorConfiguration::Triangle:
         m_mainComponent=m_triangle;
         break;
     default:
         Q_ASSERT(false);
     }
 
     switch (m_configuration.subType) {
     case KisColorSelectorConfiguration::Ring:
         m_subComponent=m_ring;
         break;
     case KisColorSelectorConfiguration::Slider:
         m_subComponent=m_slider;
         break;
     default:
         Q_ASSERT(false);
     }
 
     connect(m_mainComponent, SIGNAL(paramChanged(qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal)),
             m_subComponent,  SLOT(setParam(qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal)), Qt::UniqueConnection);
     connect(m_subComponent,  SIGNAL(paramChanged(qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal)),
             m_mainComponent, SLOT(setParam(qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal,qreal)), Qt::UniqueConnection);
 
     connect(m_mainComponent, SIGNAL(update()), m_signalCompressor, SLOT(start()), Qt::UniqueConnection);
     connect(m_subComponent,  SIGNAL(update()), m_signalCompressor, SLOT(start()), Qt::UniqueConnection);
 
     m_mainComponent->setConfiguration(m_configuration.mainTypeParameter, m_configuration.mainType);
     m_subComponent->setConfiguration(m_configuration.subTypeParameter, m_configuration.subType);
 
     QResizeEvent event(QSize(width(), height()), QSize());
     resizeEvent(&event);
 }
 
 KisColorSelectorConfiguration KisColorSelector::configuration() const
 {
     return m_configuration;
 }
 
 void KisColorSelector::updateSettings()
 {
     KisColorSelectorBase::updateSettings();
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
 
     setConfiguration(KisColorSelectorConfiguration::fromString(cfg.readEntry("colorSelectorConfiguration", KisColorSelectorConfiguration().toString())));
+
+    if (m_canvas && m_canvas->viewManager() && m_canvas->viewManager()->canvasResourceProvider()) {
+        bool gamutMaskActive = m_canvas->viewManager()->canvasResourceProvider()->gamutMaskActive();
+
+        if (gamutMaskActive) {
+            KoGamutMask* currentMask = m_canvas->viewManager()->canvasResourceProvider()->currentGamutMask();
+            if (currentMask) {
+                slotGamutMaskSet(currentMask);
+            }
+        } else {
+            slotGamutMaskToggle(false);
+        }
+    }
 }
 
 void KisColorSelector::slotGamutMaskSet(KoGamutMask *gamutMask)
 {
     m_mainComponent->setGamutMask(gamutMask);
     m_subComponent->setGamutMask(gamutMask);
 
     slotGamutMaskToggle(true);
 }
 
 void KisColorSelector::slotGamutMaskUnset()
 {
     m_mainComponent->unsetGamutMask();
     m_subComponent->unsetGamutMask();
 
     slotGamutMaskToggle(false);
 }
 
 void KisColorSelector::slotGamutMaskPreviewUpdate()
 {
     m_mainComponent->updateGamutMaskPreview();
     m_subComponent->updateGamutMaskPreview();
 }
 
+void KisColorSelector::slotGamutMaskDeactivate()
+{
+    slotGamutMaskToggle(false);
+}
+
 void KisColorSelector::slotGamutMaskToggle(bool state)
 {
     m_mainComponent->toggleGamutMask(state);
     m_subComponent->toggleGamutMask(state);
 }
 
 void KisColorSelector::updateIcons() {
     if (m_button) {
         m_button->setIcon(KisIconUtils::loadIcon("configure"));
     }
 }
 
 void KisColorSelector::hasAtLeastOneDocument(bool value)
 {
     m_hasAtLeastOneDocumentOpen = value;
 }
 
 void KisColorSelector::reset()
 {
     if (m_mainComponent) {
         m_mainComponent->setDirty();
     }
 
     if (m_subComponent) {
         m_subComponent->setDirty();
     }
 
     KisColorSelectorBase::reset();
 }
 
 void KisColorSelector::paintEvent(QPaintEvent* e)
 {
     Q_UNUSED(e);
     QPainter p(this);
     p.fillRect(0,0,width(), height(), QColor(128,128,128));
     p.setRenderHint(QPainter::Antialiasing);
 
     // this variable name isn't entirely accurate to what always happens. see definition in header file to understand it better
     if (!m_hasAtLeastOneDocumentOpen) {
         p.setOpacity(0.2);
     }
 
     m_mainComponent->paintEvent(&p);
     m_subComponent->paintEvent(&p);
 
     p.setOpacity(1.0);
 }
 
 inline int iconSize(qreal width, qreal height) {
     qreal radius = qMin(width, height)/2.;
     qreal xm = width/2.;
     qreal ym = height/2.;
     if(xm>=2*ym || ym>=2*xm)
         return qBound<qreal>(5., radius, 32.);
 
     qreal a=-2;
     qreal b=2.*(xm+ym);
     qreal c=radius*radius-xm*xm-ym*ym;
     return qBound<qreal>(5., ((-b+sqrt(b*b-4*a*c))/(2*a)), 32.);
 }
 
 void KisColorSelector::resizeEvent(QResizeEvent* e) {
     if (m_configuration.subType == KisColorSelectorConfiguration::Ring) {
 
         m_ring->setGeometry(0,0,width(), height());
 
         if (displaySettingsButton()) {
             int size = iconSize(width(), height());
             m_button->setGeometry(0, 0, size, size);
         }
 
         if (m_configuration.mainType == KisColorSelectorConfiguration::Triangle) {
             m_triangle->setGeometry(width()/2-m_ring->innerRadius(),
                                     height()/2-m_ring->innerRadius(),
                                     m_ring->innerRadius()*2,
                                     m_ring->innerRadius()*2);
         }
         else {
             int size = m_ring->innerRadius()*2/sqrt(2.);
             m_square->setGeometry(width()/2-size/2,
                                   height()/2-size/2,
                                   size,
                                   size);
         }
     }
     else {
         // type wheel and square
         if (m_configuration.mainType == KisColorSelectorConfiguration::Wheel) {
             if(displaySettingsButton()) {
                 int size = iconSize(width(), height()*0.9);
                 m_button->setGeometry(0, height()*0.1, size, size);
             }
             m_mainComponent->setGeometry(0, height()*0.1, width(), height()*0.9);
             m_subComponent->setGeometry( 0, 0,            width(), height()*0.1);
         }
         else {
             int buttonSize = 0;
             if(displaySettingsButton()) {
                 buttonSize = qBound(20, int(0.1*height()), 32);
                 m_button->setGeometry(0, 0, buttonSize, buttonSize);
             }
 
             if(height()>width()) {
                 int selectorHeight=height()-buttonSize;
                 m_mainComponent->setGeometry(0, buttonSize+selectorHeight*0.1, width(), selectorHeight*0.9);
                 m_subComponent->setGeometry( 0, buttonSize,                    width(), selectorHeight*0.1);
             }
             else {
                 int selectorWidth=width()-buttonSize;
                 m_mainComponent->setGeometry(buttonSize, height()*0.1, selectorWidth, height()*0.9);
                 m_subComponent->setGeometry( buttonSize, 0,            selectorWidth, height()*0.1);
             }
         }
     }
 
     // reset the correct color after resizing the widget
     setColor(m_lastRealColor);
 
     KisColorSelectorBase::resizeEvent(e);
 }
 
 void KisColorSelector::mousePressEvent(QMouseEvent* e)
 {
     e->setAccepted(false);
     KisColorSelectorBase::mousePressEvent(e);
 
     if(!e->isAccepted()) {
         if(m_mainComponent->wantsGrab(e->x(), e->y()))
             m_grabbingComponent=m_mainComponent;
         else if(m_subComponent->wantsGrab(e->x(), e->y()))
             m_grabbingComponent=m_subComponent;
 
         mouseEvent(e);
         updatePreviousColorPreview();
         e->accept();
     }
 }
 
 void KisColorSelector::mouseMoveEvent(QMouseEvent* e)
 {
     KisColorSelectorBase::mouseMoveEvent(e);
 
     mouseEvent(e);
     e->accept();
 }
 
 void KisColorSelector::mouseReleaseEvent(QMouseEvent* e)
 {
     e->setAccepted(false);
     KisColorSelectorBase::mouseReleaseEvent(e);
 
     if(!e->isAccepted() &&
        !(m_lastRealColor == m_currentRealColor)) {
 
         m_lastRealColor = m_currentRealColor;
         m_lastColorRole = Acs::buttonToRole(e->button());
 
         updateColor(m_lastRealColor, m_lastColorRole, false);
         updateBaseColorPreview(m_currentRealColor);
         e->accept();
     }
 
     m_grabbingComponent=0;
 }
 
 bool KisColorSelector::displaySettingsButton()
 {
     return dynamic_cast<KisColorSelectorContainer*>(parent());
 }
 
 void KisColorSelector::setColor(const KoColor &color)
 {
     m_mainComponent->setColor(color);
     m_subComponent->setColor(color);
     m_lastRealColor = color;
 
     m_signalCompressor->start();
 }
 
 void KisColorSelector::mouseEvent(QMouseEvent *e)
 {
     if (m_grabbingComponent && (e->buttons() & Qt::LeftButton || e->buttons() & Qt::RightButton)) {
 
         m_grabbingComponent->mouseEvent(e->x(), e->y());
 
         KoColor color = m_mainComponent->currentColor();
         Acs::ColorRole role = Acs::buttonsToRole(e->button(), e->buttons());
         m_currentRealColor = color;
 
         requestUpdateColorAndPreview(color, role);
     }
 }
 
 void KisColorSelector::init()
 {
     setAcceptDrops(true);
 
     m_lastColorRole = Acs::Foreground;
     m_ring = new KisColorSelectorRing(this);
     m_triangle = new KisColorSelectorTriangle(this);
     m_slider = new KisColorSelectorSimple(this);
     m_square = new KisColorSelectorSimple(this);
     m_wheel = new KisColorSelectorWheel(this);
 
     if(displaySettingsButton()) {
         m_button = new QPushButton(this);
         m_button->setIcon(KisIconUtils::loadIcon("configure"));
         m_button->setFlat(true);
         connect(m_button, SIGNAL(clicked()), SIGNAL(settingsButtonClicked()));
     }
 
     // a tablet can send many more signals, than a mouse
     // this causes many repaints, if updating after every signal.
     m_signalCompressor = new KisSignalCompressor(20, KisSignalCompressor::FIRST_INACTIVE, this);
     connect(m_signalCompressor, SIGNAL(timeout()), SLOT(update()));
 
     setMinimumSize(40, 40);
 }
diff --git a/plugins/dockers/advancedcolorselector/kis_color_selector.h b/plugins/dockers/advancedcolorselector/kis_color_selector.h
index 5d73ba5489..a28c860b27 100644
--- a/plugins/dockers/advancedcolorselector/kis_color_selector.h
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector.h
@@ -1,105 +1,106 @@
 /*
  *  Copyright (c) 2010 Adam Celarek <kdedev at xibo dot at>
  *
  *  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 KIS_COLOR_SELECTOR_H
 #define KIS_COLOR_SELECTOR_H
 
 #include "kis_color_selector_base.h"
 #include <KisColorSelectorConfiguration.h>
 
 
 class KisColorSelectorRing;
 class KisColorSelectorComponent;
 class KisColorSelectorSimple;
 class KisColorSelectorWheel;
 class QPushButton;
 class KisSignalCompressor;
 
 class KisColorSelector : public KisColorSelectorBase
 {
     Q_OBJECT
 public:
 
     KisColorSelector(KisColorSelectorConfiguration conf, QWidget* parent = 0);
     KisColorSelector(QWidget* parent=0);
     KisColorSelectorBase* createPopup() const override;
 
     void setConfiguration(KisColorSelectorConfiguration conf);
     KisColorSelectorConfiguration configuration() const;
     void setColor(const KoColor &color) override;
 
     /// update icons when a theme update happens
     void updateIcons();
 
     void hasAtLeastOneDocument(bool value);
 
 public Q_SLOTS:
     void reset() override;
     void updateSettings() override;
     void slotGamutMaskSet(KoGamutMask* gamutMask);
     void slotGamutMaskUnset();
     void slotGamutMaskPreviewUpdate();
     void slotGamutMaskToggle(bool state);
+    void slotGamutMaskDeactivate();
 
 Q_SIGNALS:
     void settingsButtonClicked();
 
 protected:
     void paintEvent(QPaintEvent*) override;
     void resizeEvent(QResizeEvent*) override;
     void mousePressEvent(QMouseEvent*) override;
     void mouseMoveEvent(QMouseEvent*) override;
     void mouseReleaseEvent(QMouseEvent*) override;
     bool displaySettingsButton();
 
 private:
     void mouseEvent(QMouseEvent* e);
     void init();
 
     KisColorSelectorRing* m_ring;
     KisColorSelectorComponent* m_triangle;
     KisColorSelectorSimple* m_slider;
     KisColorSelectorSimple* m_square;
     KisColorSelectorWheel* m_wheel;
     QPushButton* m_button;
     KisColorSelectorComponent* m_mainComponent;
     KisColorSelectorComponent* m_subComponent;
     KisColorSelectorComponent* m_grabbingComponent;
 
     KisSignalCompressor *m_signalCompressor;
 
     KisColorSelectorConfiguration m_configuration;
 
     KoColor m_lastRealColor;
     KoColor m_currentRealColor;
     bool m_blipDisplay;
     Acs::ColorRole m_lastColorRole;
 
 
     /// if Krita starts with a reference to this component that is attached to a canvas, it will call setCanvas()
     /// that check will be what ultimately decides whether this component will look enabled or disabled
     /// This color selector is sometimes not attached to the canvas, so we shouldn't disable it in that situation
     /// One instance of that is when you select the color wheel type from the settings.
     bool m_hasAtLeastOneDocumentOpen = true;
 
 public:
     void setDisplayBlip(bool disp) {m_blipDisplay = disp;}
     bool displayBlip() const {return m_blipDisplay;}
 };
 
 #endif // KIS_COLSELNG_COLOR_SELECTOR_H
diff --git a/plugins/dockers/advancedcolorselector/kis_color_selector_container.cpp b/plugins/dockers/advancedcolorselector/kis_color_selector_container.cpp
index 215d1850da..1366fc68e8 100644
--- a/plugins/dockers/advancedcolorselector/kis_color_selector_container.cpp
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector_container.cpp
@@ -1,251 +1,251 @@
 /*
  *  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_container.h"
 
 #include "kis_color_selector.h"
 #include "kis_my_paint_shade_selector.h"
 #include "kis_minimal_shade_selector.h"
 
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 #include <QPushButton>
 #include <QAction>
 
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 
 #include <kactioncollection.h>
 
 #include <KisDocument.h>
 #include <KisGamutMaskToolbar.h>
 #include "KisViewManager.h"
 #include "kis_canvas2.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_node_manager.h"
 #include "kis_node.h"
 #include "kis_paint_device.h"
 
 #include "kis_action_registry.h"
 
 KisColorSelectorContainer::KisColorSelectorContainer(QWidget *parent) :
     QWidget(parent),
     m_colorSelector(new KisColorSelector(this)),
     m_myPaintShadeSelector(new KisMyPaintShadeSelector(this)),
     m_minimalShadeSelector(new KisMinimalShadeSelector(this)),
     m_shadeSelector(m_myPaintShadeSelector),
     m_gamutMaskToolbar(new KisGamutMaskToolbar(this)),
     m_showColorSelector(true),
     m_canvas(0)
 {
     m_widgetLayout = new QBoxLayout(QBoxLayout::TopToBottom, this);
     m_widgetLayout->setSpacing(0);
     m_widgetLayout->setMargin(0);
 
     m_gamutMaskToolbar->setContentsMargins(0, 0, 0, 5);
     m_gamutMaskToolbar->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
     m_colorSelector->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
     m_myPaintShadeSelector->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
     m_minimalShadeSelector->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
 
     m_widgetLayout->addWidget(m_gamutMaskToolbar);
     m_widgetLayout->addWidget(m_colorSelector);
     m_widgetLayout->addWidget(m_myPaintShadeSelector);
     m_widgetLayout->addWidget(m_minimalShadeSelector);
 
     m_gamutMaskToolbar->hide();
     m_myPaintShadeSelector->hide();
     m_minimalShadeSelector->hide();
 
     connect(m_colorSelector,SIGNAL(settingsButtonClicked()), SIGNAL(openSettings()));
 
     connect(this, SIGNAL(settingsChanged()), m_colorSelector,        SLOT(updateSettings()));
     connect(this, SIGNAL(settingsChanged()), m_myPaintShadeSelector, SLOT(updateSettings()));
     connect(this, SIGNAL(settingsChanged()), this,                   SLOT(updateSettings()));
     connect(this, SIGNAL(settingsChanged()), m_minimalShadeSelector, SLOT(updateSettings()));
 
 
     m_colorSelAction = KisActionRegistry::instance()->makeQAction("show_color_selector", this);
     connect(m_colorSelAction, SIGNAL(triggered()), m_colorSelector, SLOT(showPopup()), Qt::UniqueConnection);
 
     m_mypaintAction = KisActionRegistry::instance()->makeQAction("show_mypaint_shade_selector", this);
     connect(m_mypaintAction, SIGNAL(triggered()), m_myPaintShadeSelector, SLOT(showPopup()), Qt::UniqueConnection);
 
     m_minimalAction = KisActionRegistry::instance()->makeQAction("show_minimal_shade_selector", this);
     connect(m_minimalAction, SIGNAL(triggered()), m_minimalShadeSelector, SLOT(showPopup()), Qt::UniqueConnection);
 
 }
 
 void KisColorSelectorContainer::unsetCanvas()
 {
     m_colorSelector->hasAtLeastOneDocument(doesAtleastOneDocumentExist());
 
     m_colorSelector->unsetCanvas();
     m_myPaintShadeSelector->unsetCanvas();
     m_minimalShadeSelector->unsetCanvas();
     m_canvas = 0;
 }
 
 bool KisColorSelectorContainer::doesAtleastOneDocumentExist()
 {
     if (m_canvas && m_canvas->viewManager() && m_canvas->viewManager()->document() ) {
         if (m_canvas->viewManager()->document()->image()->height() == 0) {
             return false;
         } else {
            return true;
         }
     } else {
         return false;
     }
 }
 
 void KisColorSelectorContainer::slotUpdateIcons()
 {
     m_colorSelector->updateIcons();
 }
 
 void KisColorSelectorContainer::setCanvas(KisCanvas2* canvas)
 {
     if (m_canvas) {
         m_canvas->disconnectCanvasObserver(this);
         m_canvas->viewManager()->nodeManager()->disconnect(this);
         KActionCollection *ac = m_canvas->viewManager()->actionCollection();
         ac->takeAction(ac->action("show_color_selector"));
         ac->takeAction(ac->action("show_mypaint_shade_selector"));
         ac->takeAction(ac->action("show_minimal_shade_selector"));
     }
 
     m_canvas = canvas;
 
     m_colorSelector->setCanvas(canvas);
     m_myPaintShadeSelector->setCanvas(canvas);
     m_minimalShadeSelector->setCanvas(canvas);
 
 
     m_colorSelector->hasAtLeastOneDocument(doesAtleastOneDocumentExist());
 
 
     if (m_canvas && m_canvas->viewManager()) {
         if (m_canvas->viewManager()->nodeManager()) {
             connect(m_canvas->viewManager()->nodeManager(), SIGNAL(sigLayerActivated(KisLayerSP)), SLOT(reactOnLayerChange()), Qt::UniqueConnection);
         }
 
         connect(m_canvas->viewManager()->canvasResourceProvider(), SIGNAL(sigGamutMaskChanged(KoGamutMask*)),
                 m_colorSelector, SLOT(slotGamutMaskSet(KoGamutMask*)), Qt::UniqueConnection);
 
         connect(m_canvas->viewManager()->canvasResourceProvider(), SIGNAL(sigGamutMaskUnset()),
                 m_colorSelector, SLOT(slotGamutMaskUnset()), Qt::UniqueConnection);
 
         connect(m_canvas->viewManager()->canvasResourceProvider(), SIGNAL(sigGamutMaskPreviewUpdate()),
                 m_colorSelector, SLOT(slotGamutMaskPreviewUpdate()), Qt::UniqueConnection);
 
-        m_gamutMaskToolbar->connectMaskSignals(m_canvas->viewManager()->canvasResourceProvider());
+        connect(m_canvas->viewManager()->canvasResourceProvider(), SIGNAL(sigGamutMaskDeactivated()),
+                m_colorSelector, SLOT(slotGamutMaskDeactivate()), Qt::UniqueConnection);
 
-        // gamut mask connections
-        connect(m_gamutMaskToolbar, SIGNAL(sigGamutMaskToggle(bool)), m_colorSelector, SLOT(slotGamutMaskToggle(bool)), Qt::UniqueConnection);
+        m_gamutMaskToolbar->connectMaskSignals(m_canvas->viewManager()->canvasResourceProvider());
 
         KActionCollection* actionCollection = canvas->viewManager()->actionCollection();
         actionCollection->addAction("show_color_selector", m_colorSelAction);
         actionCollection->addAction("show_mypaint_shade_selector", m_mypaintAction);
         actionCollection->addAction("show_minimal_shade_selector", m_minimalAction);
     }
 }
 
 void KisColorSelectorContainer::updateSettings()
 {
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
     m_onDockerResizeSetting =  (int)cfg.readEntry("onDockerResize", 0);
     m_showColorSelector = (bool) cfg.readEntry("showColorSelector", true);
 
     if (m_showColorSelector) {
         m_colorSelector->show();
 
         if (m_colorSelector->configuration().mainType == KisColorSelectorConfiguration::Wheel) {
             m_gamutMaskToolbar->show();
         } else {
             m_gamutMaskToolbar->hide();
         }
     } else {
         m_colorSelector->hide();
         m_gamutMaskToolbar->hide();
     }
 
     QString type = cfg.readEntry("shadeSelectorType", "Minimal");
 
     QWidget* newShadeSelector;
     if(type=="MyPaint")
         newShadeSelector = m_myPaintShadeSelector;
     else if (type=="Minimal")
         newShadeSelector = m_minimalShadeSelector;
     else
         newShadeSelector = 0;
 
 
 
     if(m_shadeSelector!=newShadeSelector && m_shadeSelector!=0) {
         m_shadeSelector->hide();
     }
     m_shadeSelector=newShadeSelector;
 
     if(m_shadeSelector!=0)
         m_shadeSelector->show();
 }
 
 void KisColorSelectorContainer::reactOnLayerChange()
 {
     if (m_canvas) {
         KisNodeSP node = m_canvas->viewManager()->canvasResourceProvider()->currentNode();
         if (node) {
             KisPaintDeviceSP device = node->paintDevice();
             if (device) {
                 m_colorSelAction->setEnabled(true);
                 m_mypaintAction->setEnabled(true);
                 m_minimalAction->setEnabled(true);
             }
             else {
                 //            m_colorSelAction->setEnabled(false);
                 //            m_mypaintAction->setEnabled(false);
                 //            m_minimalAction->setEnabled(false);
             }
         }
     }
 }
 
 void KisColorSelectorContainer::resizeEvent(QResizeEvent * e)
 {
     if(m_shadeSelector!=0) {
         int minimumHeightForBothWidgets = m_colorSelector->minimumHeight()+m_shadeSelector->minimumHeight()+30; //+30 for the buttons (temporarily)
 
         if(height()<minimumHeightForBothWidgets && m_onDockerResizeSetting== 1) {  // 1 option is hide shade selector
             m_shadeSelector->hide();
         }
         else {
             m_shadeSelector->show();
         }
 
         // m_onDockerResizeSetting==0 is allow horizontal layout
         if(height() < width() && m_onDockerResizeSetting==0 && m_shadeSelector!=m_minimalShadeSelector) {
             m_widgetLayout->setDirection(QBoxLayout::LeftToRight);
         }
         else {
             m_widgetLayout->setDirection(QBoxLayout::TopToBottom);
         }
     }
 
     QWidget::resizeEvent(e);
 }
diff --git a/plugins/dockers/animation/onion_skins_docker.cpp b/plugins/dockers/animation/onion_skins_docker.cpp
index 84739711b4..309c68c67b 100644
--- a/plugins/dockers/animation/onion_skins_docker.cpp
+++ b/plugins/dockers/animation/onion_skins_docker.cpp
@@ -1,271 +1,271 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "onion_skins_docker.h"
 #include "ui_onion_skins_docker.h"
 
 #include <QSlider>
 #include <QFrame>
 #include <QGridLayout>
 
 #include "kis_icon_utils.h"
 #include "kis_image_config.h"
 #include "kis_onion_skin_compositor.h"
 #include "kis_signals_blocker.h"
 #include "kis_node_view_color_scheme.h"
 #include "KisViewManager.h"
 #include "kis_action_manager.h"
 #include "kis_action.h"
 #include <KoColorSpaceRegistry.h>
 
 #include "kis_equalizer_widget.h"
 
 OnionSkinsDocker::OnionSkinsDocker(QWidget *parent) :
     QDockWidget(i18n("Onion Skins"), parent),
     ui(new Ui::OnionSkinsDocker),
     m_updatesCompressor(300, KisSignalCompressor::FIRST_ACTIVE),
     m_toggleOnionSkinsAction(0)
 {
     QWidget* mainWidget = new QWidget(this);
     setWidget(mainWidget);
 
     KisImageConfig config(true);
     ui->setupUi(mainWidget);
 
     mainWidget->setContentsMargins(10, 10, 10, 10);
 
 
     ui->doubleTintFactor->setMinimum(0);
     ui->doubleTintFactor->setMaximum(100);
     ui->doubleTintFactor->setPrefix(i18n("Tint: "));
-    ui->doubleTintFactor->setSuffix("%");
+    ui->doubleTintFactor->setSuffix(i18n("%"));
 
     ui->btnBackwardColor->setToolTip(i18n("Tint color for past frames"));
     ui->btnForwardColor->setToolTip(i18n("Tint color for future frames"));
 
 
     QVBoxLayout *layout = ui->slidersLayout;
 
     m_equalizerWidget = new KisEqualizerWidget(10, this);
     connect(m_equalizerWidget, SIGNAL(sigConfigChanged()), &m_updatesCompressor, SLOT(start()));
     layout->addWidget(m_equalizerWidget, 1);
 
     connect(ui->btnBackwardColor, SIGNAL(changed(KoColor)), &m_updatesCompressor, SLOT(start()));
     connect(ui->btnForwardColor, SIGNAL(changed(KoColor)), &m_updatesCompressor, SLOT(start()));
     connect(ui->doubleTintFactor, SIGNAL(valueChanged(qreal)), &m_updatesCompressor, SLOT(start()));
 
     connect(&m_updatesCompressor, SIGNAL(timeout()),
             SLOT(changed()));
 
 
     {
         const bool isShown = config.showAdditionalOnionSkinsSettings();
         ui->btnShowHide->setChecked(isShown);
         connect(ui->btnShowHide, SIGNAL(toggled(bool)), SLOT(slotShowAdditionalSettings(bool)));
         slotShowAdditionalSettings(isShown);
     }
 
     // create colored checkboxes for onion skin filtering
     KisNodeViewColorScheme scm;
     QPalette filterColorPalette;
     QPixmap iconPixmap(10, 10);
 
     //iconPixmap.fill(scm.colorLabel(0));
     //ui->colorFilter0_checkbox->setIcon(iconPixmap); // default(no) color
 
     iconPixmap.fill(scm.colorLabel(1));
     ui->colorFilter1_checkbox->setIcon(QIcon(iconPixmap));
 
     iconPixmap.fill(scm.colorLabel(2));
     ui->colorFilter2_checkbox->setIcon(QIcon(iconPixmap));
 
     iconPixmap.fill(scm.colorLabel(3));
     ui->colorFilter3_checkbox->setIcon(QIcon(iconPixmap));
 
     iconPixmap.fill(scm.colorLabel(4));
     ui->colorFilter4_checkbox->setIcon(QIcon(iconPixmap));
 
     iconPixmap.fill(scm.colorLabel(5));
     ui->colorFilter5_checkbox->setIcon(QIcon(iconPixmap));
 
     iconPixmap.fill(scm.colorLabel(6));
     ui->colorFilter6_checkbox->setIcon(QIcon(iconPixmap));
 
     iconPixmap.fill(scm.colorLabel(7));
     ui->colorFilter7_checkbox->setIcon(QIcon(iconPixmap));
 
     iconPixmap.fill(scm.colorLabel(8));
     ui->colorFilter8_checkbox->setIcon(QIcon(iconPixmap));
 
 
     // assign click events to color filters and group checkbox
     connect(ui->colorFilter0_checkbox, SIGNAL(toggled(bool)), this, SLOT(slotFilteredColorsChanged()));
     connect(ui->colorFilter1_checkbox, SIGNAL(toggled(bool)), this, SLOT(slotFilteredColorsChanged()));
     connect(ui->colorFilter2_checkbox, SIGNAL(toggled(bool)), this, SLOT(slotFilteredColorsChanged()));
     connect(ui->colorFilter3_checkbox, SIGNAL(toggled(bool)), this, SLOT(slotFilteredColorsChanged()));
     connect(ui->colorFilter4_checkbox, SIGNAL(toggled(bool)), this, SLOT(slotFilteredColorsChanged()));
     connect(ui->colorFilter5_checkbox, SIGNAL(toggled(bool)), this, SLOT(slotFilteredColorsChanged()));
     connect(ui->colorFilter6_checkbox, SIGNAL(toggled(bool)), this, SLOT(slotFilteredColorsChanged()));
     connect(ui->colorFilter7_checkbox, SIGNAL(toggled(bool)), this, SLOT(slotFilteredColorsChanged()));
     connect(ui->colorFilter8_checkbox, SIGNAL(toggled(bool)), this, SLOT(slotFilteredColorsChanged()));
     connect(ui->colorFilterGroupbox, SIGNAL(toggled(bool)), this, SLOT(slotFilteredColorsChanged()));
 
     loadSettings();
     KisOnionSkinCompositor::instance()->configChanged();
 
     // this mostly hides the checkboxes since no filtering is done by default
     slotFilteredColorsChanged();
 
     resize(sizeHint());
 }
 
 
 OnionSkinsDocker::~OnionSkinsDocker()
 {
     delete ui;
 }
 
 void OnionSkinsDocker::setCanvas(KoCanvasBase *canvas)
 {
     Q_UNUSED(canvas);
 }
 
 void OnionSkinsDocker::unsetCanvas()
 {
 }
 
 void OnionSkinsDocker::setViewManager(KisViewManager *view)
 {
     KisActionManager *actionManager = view->actionManager();
 
     m_toggleOnionSkinsAction = actionManager->createAction("toggle_onion_skin");
     connect(m_toggleOnionSkinsAction, SIGNAL(triggered()), SLOT(slotToggleOnionSkins()));
 
     slotUpdateIcons();
     connect(view->mainWindow(), SIGNAL(themeChanged()), this, SLOT(slotUpdateIcons()));
 }
 
 void OnionSkinsDocker::slotToggleOnionSkins()
 {
     m_equalizerWidget->toggleMasterSwitch();
 }
 
 void OnionSkinsDocker::slotFilteredColorsChanged()
 {
     // what colors are selected to filter??
     QList<int> selectedFilterColors;
 
     if (ui->colorFilter0_checkbox->isChecked()) selectedFilterColors << 0;
     if (ui->colorFilter1_checkbox->isChecked()) selectedFilterColors << 1;
     if (ui->colorFilter2_checkbox->isChecked()) selectedFilterColors << 2;
     if (ui->colorFilter3_checkbox->isChecked()) selectedFilterColors << 3;
     if (ui->colorFilter4_checkbox->isChecked()) selectedFilterColors << 4;
     if (ui->colorFilter5_checkbox->isChecked()) selectedFilterColors << 5;
     if (ui->colorFilter6_checkbox->isChecked()) selectedFilterColors << 6;
     if (ui->colorFilter7_checkbox->isChecked()) selectedFilterColors << 7;
     if (ui->colorFilter8_checkbox->isChecked()) selectedFilterColors << 8;
 
     // show all colors if the filter is off and ignore the checkboxes
     if(ui->colorFilterGroupbox->isChecked() == false) {
         selectedFilterColors.clear();
         selectedFilterColors << 0 << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8; // show everything
     }
 
     ui->colorFilter0_checkbox->setVisible(ui->colorFilterGroupbox->isChecked());
     ui->colorFilter1_checkbox->setVisible(ui->colorFilterGroupbox->isChecked());
     ui->colorFilter2_checkbox->setVisible(ui->colorFilterGroupbox->isChecked());
     ui->colorFilter3_checkbox->setVisible(ui->colorFilterGroupbox->isChecked());
     ui->colorFilter4_checkbox->setVisible(ui->colorFilterGroupbox->isChecked());
     ui->colorFilter5_checkbox->setVisible(ui->colorFilterGroupbox->isChecked());
     ui->colorFilter6_checkbox->setVisible(ui->colorFilterGroupbox->isChecked());
     ui->colorFilter7_checkbox->setVisible(ui->colorFilterGroupbox->isChecked());
     ui->colorFilter8_checkbox->setVisible(ui->colorFilterGroupbox->isChecked());
 
     // existing code
     KisOnionSkinCompositor::instance()->setColorLabelFilter(selectedFilterColors);
     KisOnionSkinCompositor::instance()->configChanged();
 }
 
 void OnionSkinsDocker::slotUpdateIcons()
 {
     if (m_toggleOnionSkinsAction) {
         m_toggleOnionSkinsAction->setIcon(KisIconUtils::loadIcon("onion_skin_options"));
     }
 }
 
 void OnionSkinsDocker::slotShowAdditionalSettings(bool value)
 {
     ui->lblPrevColor->setVisible(value);
     ui->lblNextColor->setVisible(value);
 
     ui->btnBackwardColor->setVisible(value);
     ui->btnForwardColor->setVisible(value);
 
     ui->doubleTintFactor->setVisible(value);
 
     QIcon icon = KisIconUtils::loadIcon(value ? "arrow-down" : "arrow-up");
     ui->btnShowHide->setIcon(icon);
 
     KisImageConfig(false).setShowAdditionalOnionSkinsSettings(value);
 }
 
 void OnionSkinsDocker::changed()
 {
     KisImageConfig config(false);
 
     KisEqualizerWidget::EqualizerValues v = m_equalizerWidget->getValues();
     config.setNumberOfOnionSkins(v.maxDistance);
 
     for (int i = -v.maxDistance; i <= v.maxDistance; i++) {
         config.setOnionSkinOpacity(i, v.value[i] * 255.0 / 100.0);
         config.setOnionSkinState(i, v.state[i]);
     }
 
     config.setOnionSkinTintFactor(ui->doubleTintFactor->value() * 255.0 / 100.0);
     config.setOnionSkinTintColorBackward(ui->btnBackwardColor->color().toQColor());
     config.setOnionSkinTintColorForward(ui->btnForwardColor->color().toQColor());
 
     KisOnionSkinCompositor::instance()->configChanged();
 }
 
 void OnionSkinsDocker::loadSettings()
 {
     KisImageConfig config(true);
 
     KisSignalsBlocker b(ui->doubleTintFactor,
                         ui->btnBackwardColor,
                         ui->btnForwardColor,
                         m_equalizerWidget);
 
     ui->doubleTintFactor->setValue(qRound(config.onionSkinTintFactor() * 100.0 / 255));
     KoColor bcol(KoColorSpaceRegistry::instance()->rgb8());
     bcol.fromQColor(config.onionSkinTintColorBackward());
     ui->btnBackwardColor->setColor(bcol);
     bcol.fromQColor(config.onionSkinTintColorForward());
     ui->btnForwardColor->setColor(bcol);
 
     KisEqualizerWidget::EqualizerValues v;
     v.maxDistance = 10;
 
     for (int i = -v.maxDistance; i <= v.maxDistance; i++) {
         v.value.insert(i, qRound(config.onionSkinOpacity(i) * 100.0 / 255.0));
         v.state.insert(i, config.onionSkinState(i));
     }
 
     m_equalizerWidget->setValues(v);
 }
diff --git a/plugins/dockers/animation/timeline_frames_view.cpp b/plugins/dockers/animation/timeline_frames_view.cpp
index 391ce050b3..382d1e8e09 100644
--- a/plugins/dockers/animation/timeline_frames_view.cpp
+++ b/plugins/dockers/animation/timeline_frames_view.cpp
@@ -1,1547 +1,1547 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "timeline_frames_view.h"
 
 #include "timeline_frames_model.h"
 #include "timeline_ruler_header.h"
 #include "timeline_layers_header.h"
 #include "timeline_insert_keyframe_dialog.h"
 #include "timeline_frames_item_delegate.h"
 
 #include <QPainter>
 #include <QApplication>
 #include <QDropEvent>
 #include <QMenu>
 #include <QScrollBar>
 #include <QScroller>
 #include <QDrag>
 #include <QInputDialog>
 #include <QClipboard>
 #include <QMimeData>
 #include "config-qtmultimedia.h"
 
 #include "KSharedConfig"
 #include "KisKineticScroller.h"
 
 #include "kis_zoom_button.h"
 #include "kis_icon_utils.h"
 #include "kis_animation_utils.h"
 #include "kis_custom_modifiers_catcher.h"
 #include "kis_action.h"
 #include "kis_signal_compressor.h"
 #include "kis_time_range.h"
 #include "kis_color_label_selector_widget.h"
 #include "kis_keyframe_channel.h"
 #include "kis_slider_spin_box.h"
 #include <KisImportExportManager.h>
 #include <kis_signals_blocker.h>
 #include <kis_image_config.h>
 
 #include <KoFileDialog.h>
 #include <KoIconToolTip.h>
 
 typedef QPair<QRect, QModelIndex> QItemViewPaintPair;
 typedef QList<QItemViewPaintPair> QItemViewPaintPairs;
 
 struct TimelineFramesView::Private
 {
     Private(TimelineFramesView *_q)
         : q(_q),
           fps(1),
           zoomStillPointIndex(-1),
           zoomStillPointOriginalOffset(0),
           dragInProgress(false),
           dragWasSuccessful(false),
           modifiersCatcher(0),
           selectionChangedCompressor(300, KisSignalCompressor::FIRST_INACTIVE)
     {}
 
     TimelineFramesView *q;
 
     TimelineFramesModel *model;
     TimelineRulerHeader *horizontalRuler;
     TimelineLayersHeader *layersHeader;
     int fps;
     int zoomStillPointIndex;
     int zoomStillPointOriginalOffset;
     QPoint initialDragPanValue;
     QPoint initialDragPanPos;
 
     QToolButton *addLayersButton;
     KisAction *showHideLayerAction;
 
     QToolButton *audioOptionsButton;
 
     KisColorLabelSelectorWidget *colorSelector;
     QWidgetAction *colorSelectorAction;
     KisColorLabelSelectorWidget *multiframeColorSelector;
     QWidgetAction *multiframeColorSelectorAction;
 
     QMenu *audioOptionsMenu;
     QAction *openAudioAction;
     QAction *audioMuteAction;
     KisSliderSpinBox *volumeSlider;
 
     QMenu *layerEditingMenu;
     QMenu *existingLayersMenu;
 
     TimelineInsertKeyframeDialog *insertKeyframeDialog;
 
     KisZoomButton *zoomDragButton;
 
     bool dragInProgress;
     bool dragWasSuccessful;
 
     KisCustomModifiersCatcher *modifiersCatcher;
     QPoint lastPressedPosition;
     Qt::KeyboardModifiers lastPressedModifier;
     KisSignalCompressor selectionChangedCompressor;
 
     QStyleOptionViewItem viewOptionsV4() const;
     QItemViewPaintPairs draggablePaintPairs(const QModelIndexList &indexes, QRect *r) const;
     QPixmap renderToPixmap(const QModelIndexList &indexes, QRect *r) const;
 
     KoIconToolTip tip;
 
     KisActionManager *actionMan = 0;
 };
 
 TimelineFramesView::TimelineFramesView(QWidget *parent)
     : QTableView(parent),
       m_d(new Private(this))
 {
     m_d->modifiersCatcher = new KisCustomModifiersCatcher(this);
     m_d->modifiersCatcher->addModifier("pan-zoom", Qt::Key_Space);
     m_d->modifiersCatcher->addModifier("offset-frame", Qt::Key_Alt);
 
     setCornerButtonEnabled(false);
     setSelectionBehavior(QAbstractItemView::SelectItems);
     setSelectionMode(QAbstractItemView::ExtendedSelection);
 
     setItemDelegate(new TimelineFramesItemDelegate(this));
 
     setDragEnabled(true);
     setDragDropMode(QAbstractItemView::DragDrop);
     setAcceptDrops(true);
     setDropIndicatorShown(true);
     setDefaultDropAction(Qt::MoveAction);
 
     m_d->horizontalRuler = new TimelineRulerHeader(this);
     this->setHorizontalHeader(m_d->horizontalRuler);
 
     connect(m_d->horizontalRuler, SIGNAL(sigInsertColumnLeft()), SLOT(slotInsertKeyframeColumnLeft()));
     connect(m_d->horizontalRuler, SIGNAL(sigInsertColumnRight()), SLOT(slotInsertKeyframeColumnRight()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigInsertMultipleColumns()), SLOT(slotInsertMultipleKeyframeColumns()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigRemoveColumns()), SLOT(slotRemoveSelectedColumns()));
     connect(m_d->horizontalRuler, SIGNAL(sigRemoveColumnsAndShift()), SLOT(slotRemoveSelectedColumnsAndShift()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigInsertHoldColumns()), SLOT(slotInsertHoldFrameColumn()));
     connect(m_d->horizontalRuler, SIGNAL(sigRemoveHoldColumns()), SLOT(slotRemoveHoldFrameColumn()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigInsertHoldColumnsCustom()), SLOT(slotInsertMultipleHoldFrameColumns()));
     connect(m_d->horizontalRuler, SIGNAL(sigRemoveHoldColumnsCustom()), SLOT(slotRemoveMultipleHoldFrameColumns()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigMirrorColumns()), SLOT(slotMirrorColumns()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigCopyColumns()), SLOT(slotCopyColumns()));
     connect(m_d->horizontalRuler, SIGNAL(sigCutColumns()), SLOT(slotCutColumns()));
     connect(m_d->horizontalRuler, SIGNAL(sigPasteColumns()), SLOT(slotPasteColumns()));
 
     m_d->layersHeader = new TimelineLayersHeader(this);
 
     m_d->layersHeader->setSectionResizeMode(QHeaderView::Fixed);
 
     m_d->layersHeader->setDefaultSectionSize(24);
     m_d->layersHeader->setMinimumWidth(60);
     m_d->layersHeader->setHighlightSections(true);
 
     this->setVerticalHeader(m_d->layersHeader);
 
     connect(horizontalScrollBar(), SIGNAL(valueChanged(int)), SLOT(slotUpdateInfiniteFramesCount()));
     connect(horizontalScrollBar(), SIGNAL(sliderReleased()), SLOT(slotUpdateInfiniteFramesCount()));
 
     /********** New Layer Menu ***********************************************************/
 
     m_d->addLayersButton = new QToolButton(this);
     m_d->addLayersButton->setAutoRaise(true);
     m_d->addLayersButton->setIcon(KisIconUtils::loadIcon("addlayer"));
     m_d->addLayersButton->setIconSize(QSize(20, 20));
     m_d->addLayersButton->setPopupMode(QToolButton::InstantPopup);
 
     m_d->layerEditingMenu = new QMenu(this);
     m_d->layerEditingMenu->addAction(KisAnimationUtils::newLayerActionName, this, SLOT(slotAddNewLayer()));
     m_d->existingLayersMenu = m_d->layerEditingMenu->addMenu(KisAnimationUtils::addExistingLayerActionName);
     m_d->layerEditingMenu->addSeparator();
 
     m_d->layerEditingMenu->addAction(KisAnimationUtils::removeLayerActionName, this, SLOT(slotRemoveLayer()));
 
     connect(m_d->existingLayersMenu, SIGNAL(aboutToShow()), SLOT(slotUpdateLayersMenu()));
     connect(m_d->existingLayersMenu, SIGNAL(triggered(QAction*)), SLOT(slotAddExistingLayer(QAction*)));
 
     connect(m_d->layersHeader, SIGNAL(sigRequestContextMenu(QPoint)), SLOT(slotLayerContextMenuRequested(QPoint)));
 
     m_d->addLayersButton->setMenu(m_d->layerEditingMenu);
 
     /********** Audio Channel Menu *******************************************************/
 
     m_d->audioOptionsButton = new QToolButton(this);
     m_d->audioOptionsButton->setAutoRaise(true);
     m_d->audioOptionsButton->setIcon(KisIconUtils::loadIcon("audio-none"));
     m_d->audioOptionsButton->setIconSize(QSize(20, 20)); // very small on windows if not explicitly set
     m_d->audioOptionsButton->setPopupMode(QToolButton::InstantPopup);
 
     m_d->audioOptionsMenu = new QMenu(this);
 
 #ifndef HAVE_QT_MULTIMEDIA
     m_d->audioOptionsMenu->addSection(i18nc("@item:inmenu", "Audio playback is not supported in this build!"));
 #endif
 
     m_d->openAudioAction= new QAction("XXX", this);
     connect(m_d->openAudioAction, SIGNAL(triggered()), this, SLOT(slotSelectAudioChannelFile()));
     m_d->audioOptionsMenu->addAction(m_d->openAudioAction);
 
     m_d->audioMuteAction = new QAction(i18nc("@item:inmenu", "Mute"), this);
     m_d->audioMuteAction->setCheckable(true);
     connect(m_d->audioMuteAction, SIGNAL(triggered(bool)), SLOT(slotAudioChannelMute(bool)));
 
     m_d->audioOptionsMenu->addAction(m_d->audioMuteAction);
     m_d->audioOptionsMenu->addAction(i18nc("@item:inmenu", "Remove audio"), this, SLOT(slotAudioChannelRemove()));
 
     m_d->audioOptionsMenu->addSeparator();
 
     m_d->volumeSlider = new KisSliderSpinBox(this);
     m_d->volumeSlider->setRange(0, 100);
-    m_d->volumeSlider->setSuffix("%");
+    m_d->volumeSlider->setSuffix(i18n("%"));
     m_d->volumeSlider->setPrefix(i18nc("@item:inmenu, slider", "Volume:"));
     m_d->volumeSlider->setSingleStep(1);
     m_d->volumeSlider->setPageStep(10);
     m_d->volumeSlider->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Fixed);
 
     connect(m_d->volumeSlider, SIGNAL(valueChanged(int)), SLOT(slotAudioVolumeChanged(int)));
 
     QWidgetAction *volumeAction = new QWidgetAction(m_d->audioOptionsMenu);
     volumeAction->setDefaultWidget(m_d->volumeSlider);
     m_d->audioOptionsMenu->addAction(volumeAction);
 
     m_d->audioOptionsButton->setMenu(m_d->audioOptionsMenu);
 
     /********** Frame Editing Context Menu ***********************************************/
 
     m_d->colorSelector = new KisColorLabelSelectorWidget(this);
     m_d->colorSelectorAction = new QWidgetAction(this);
     m_d->colorSelectorAction->setDefaultWidget(m_d->colorSelector);
     connect(m_d->colorSelector, &KisColorLabelSelectorWidget::currentIndexChanged, this, &TimelineFramesView::slotColorLabelChanged);
 
     m_d->multiframeColorSelector = new KisColorLabelSelectorWidget(this);
     m_d->multiframeColorSelectorAction = new QWidgetAction(this);
     m_d->multiframeColorSelectorAction->setDefaultWidget(m_d->multiframeColorSelector);
     connect(m_d->multiframeColorSelector, &KisColorLabelSelectorWidget::currentIndexChanged, this, &TimelineFramesView::slotColorLabelChanged);
 
     /********** Insert Keyframes Dialog **************************************************/
 
     m_d->insertKeyframeDialog = new TimelineInsertKeyframeDialog(this);
 
     /********** Zoom Button **************************************************************/
 
     m_d->zoomDragButton = new KisZoomButton(this);
     m_d->zoomDragButton->setAutoRaise(true);
     m_d->zoomDragButton->setIcon(KisIconUtils::loadIcon("zoom-horizontal"));
     m_d->zoomDragButton->setIconSize(QSize(20, 20)); // this icon is very small on windows if no explicitly set
 
     m_d->zoomDragButton->setToolTip(i18nc("@info:tooltip", "Zoom Timeline. Hold down and drag left or right."));
     m_d->zoomDragButton->setPopupMode(QToolButton::InstantPopup);
     connect(m_d->zoomDragButton, SIGNAL(zoomLevelChanged(qreal)), SLOT(slotZoomButtonChanged(qreal)));
     connect(m_d->zoomDragButton, SIGNAL(zoomStarted(qreal)), SLOT(slotZoomButtonPressed(qreal)));
 
     setFramesPerSecond(12);
     setHorizontalScrollMode(QAbstractItemView::ScrollPerPixel);
 
     {
         QScroller *scroller = KisKineticScroller::createPreconfiguredScroller(this);
         if( scroller ) {
             connect(scroller, SIGNAL(stateChanged(QScroller::State)),
                     this, SLOT(slotScrollerStateChanged(QScroller::State)));
         }
     }
 
     connect(&m_d->selectionChangedCompressor, SIGNAL(timeout()),
             SLOT(slotSelectionChanged()));
     connect(&m_d->selectionChangedCompressor, SIGNAL(timeout()),
             SLOT(slotUpdateFrameActions()));
 
     {
         QClipboard *cb = QApplication::clipboard();
         connect(cb, SIGNAL(dataChanged()), SLOT(slotUpdateFrameActions()));
     }
 }
 
 TimelineFramesView::~TimelineFramesView()
 {
 }
 
 void TimelineFramesView::setShowInTimeline(KisAction *action)
 {
     m_d->showHideLayerAction = action;
     m_d->layerEditingMenu->addAction(m_d->showHideLayerAction);
 }
 
 void TimelineFramesView::setActionManager(KisActionManager *actionManager)
 {
     m_d->actionMan = actionManager;
     m_d->horizontalRuler->setActionManager(actionManager);
 
 
     if (actionManager) {
         KisAction *action = 0;
 
         action = m_d->actionMan->createAction("add_blank_frame");
         connect(action, SIGNAL(triggered()), SLOT(slotAddBlankFrame()));
 
         action = m_d->actionMan->createAction("add_duplicate_frame");
         connect(action, SIGNAL(triggered()), SLOT(slotAddDuplicateFrame()));
 
         action = m_d->actionMan->createAction("insert_keyframe_left");
         connect(action, SIGNAL(triggered()), SLOT(slotInsertKeyframeLeft()));
 
         action = m_d->actionMan->createAction("insert_keyframe_right");
         connect(action, SIGNAL(triggered()), SLOT(slotInsertKeyframeRight()));
 
         action = m_d->actionMan->createAction("insert_multiple_keyframes");
         connect(action, SIGNAL(triggered()), SLOT(slotInsertMultipleKeyframes()));
 
         action = m_d->actionMan->createAction("remove_frames_and_pull");
         connect(action, SIGNAL(triggered()), SLOT(slotRemoveSelectedFramesAndShift()));
 
         action = m_d->actionMan->createAction("remove_frames");
         connect(action, SIGNAL(triggered()), SLOT(slotRemoveSelectedFrames()));
 
         action = m_d->actionMan->createAction("insert_hold_frame");
         connect(action, SIGNAL(triggered()), SLOT(slotInsertHoldFrame()));
 
         action = m_d->actionMan->createAction("insert_multiple_hold_frames");
         connect(action, SIGNAL(triggered()), SLOT(slotInsertMultipleHoldFrames()));
 
         action = m_d->actionMan->createAction("remove_hold_frame");
         connect(action, SIGNAL(triggered()), SLOT(slotRemoveHoldFrame()));
 
         action = m_d->actionMan->createAction("remove_multiple_hold_frames");
         connect(action, SIGNAL(triggered()), SLOT(slotRemoveMultipleHoldFrames()));
 
         action = m_d->actionMan->createAction("mirror_frames");
         connect(action, SIGNAL(triggered()), SLOT(slotMirrorFrames()));
 
         action = m_d->actionMan->createAction("copy_frames_to_clipboard");
         connect(action, SIGNAL(triggered()), SLOT(slotCopyFrames()));
 
         action = m_d->actionMan->createAction("cut_frames_to_clipboard");
         connect(action, SIGNAL(triggered()), SLOT(slotCutFrames()));
 
         action = m_d->actionMan->createAction("paste_frames_from_clipboard");
         connect(action, SIGNAL(triggered()), SLOT(slotPasteFrames()));
 
         action = m_d->actionMan->createAction("set_start_time");
         connect(action, SIGNAL(triggered()), SLOT(slotSetStartTimeToCurrentPosition()));
 
         action = m_d->actionMan->createAction("set_end_time");
         connect(action, SIGNAL(triggered()), SLOT(slotSetEndTimeToCurrentPosition()));
 
         action = m_d->actionMan->createAction("update_playback_range");
         connect(action, SIGNAL(triggered()), SLOT(slotUpdatePlackbackRange()));
     }
 }
 
 void resizeToMinimalSize(QAbstractButton *w, int minimalSize) {
     QSize buttonSize = w->sizeHint();
     if (buttonSize.height() > minimalSize) {
         buttonSize = QSize(minimalSize, minimalSize);
     }
     w->resize(buttonSize);
 }
 
 void TimelineFramesView::updateGeometries()
 {
     QTableView::updateGeometries();
 
     const int availableHeight = m_d->horizontalRuler->height();
     const int margin = 2;
     const int minimalSize = availableHeight - 2 * margin;
 
     resizeToMinimalSize(m_d->addLayersButton, minimalSize);
     resizeToMinimalSize(m_d->audioOptionsButton, minimalSize);
     resizeToMinimalSize(m_d->zoomDragButton, minimalSize);
 
     int x = 2 * margin;
     int y = (availableHeight - minimalSize) / 2;
     m_d->addLayersButton->move(x, 2 * y);
     m_d->audioOptionsButton->move(x + minimalSize + 2 * margin, 2 * y);
 
     const int availableWidth = m_d->layersHeader->width();
 
     x = availableWidth - margin - minimalSize;
     m_d->zoomDragButton->move(x, 2 * y);
 }
 
 void TimelineFramesView::setModel(QAbstractItemModel *model)
 {
     TimelineFramesModel *framesModel = qobject_cast<TimelineFramesModel*>(model);
     m_d->model = framesModel;
 
     QTableView::setModel(model);
 
     connect(m_d->model, SIGNAL(headerDataChanged(Qt::Orientation,int,int)),
             this, SLOT(slotHeaderDataChanged(Qt::Orientation,int,int)));
 
     connect(m_d->model, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
             this, SLOT(slotDataChanged(QModelIndex,QModelIndex)));
 
     connect(m_d->model, SIGNAL(rowsRemoved(QModelIndex,int,int)),
             this, SLOT(slotReselectCurrentIndex()));
 
     connect(m_d->model, SIGNAL(sigInfiniteTimelineUpdateNeeded()),
             this, SLOT(slotUpdateInfiniteFramesCount()));
 
     connect(m_d->model, SIGNAL(sigAudioChannelChanged()),
             this, SLOT(slotUpdateAudioActions()));
 
     connect(selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
             &m_d->selectionChangedCompressor, SLOT(start()));
 
     connect(m_d->model, SIGNAL(sigEnsureRowVisible(int)), SLOT(slotEnsureRowVisible(int)));
     slotUpdateAudioActions();
 }
 
 void TimelineFramesView::setFramesPerSecond(int fps)
 {
     m_d->fps = fps;
     m_d->horizontalRuler->setFramePerSecond(fps);
 
     // For some reason simple update sometimes doesn't work here, so
     // reset the whole header
     //
     // m_d->horizontalRuler->reset();
 }
 
 void TimelineFramesView::slotZoomButtonPressed(qreal staticPoint)
 {
     m_d->zoomStillPointIndex =
             qIsNaN(staticPoint) ? currentIndex().column() : staticPoint;
 
     const int w = m_d->horizontalRuler->defaultSectionSize();
 
     m_d->zoomStillPointOriginalOffset =
             w * m_d->zoomStillPointIndex -
             horizontalScrollBar()->value();
 }
 
 void TimelineFramesView::slotZoomButtonChanged(qreal zoomLevel)
 {
     if (m_d->horizontalRuler->setZoom(zoomLevel)) {
         slotUpdateInfiniteFramesCount();
 
         const int w = m_d->horizontalRuler->defaultSectionSize();
         horizontalScrollBar()->setValue(w * m_d->zoomStillPointIndex - m_d->zoomStillPointOriginalOffset);
 
         viewport()->update();
     }
 }
 
 void TimelineFramesView::slotColorLabelChanged(int label)
 {
     Q_FOREACH(QModelIndex index, selectedIndexes()) {
         m_d->model->setData(index, label, TimelineFramesModel::FrameColorLabelIndexRole);
     }
     KisImageConfig(false).setDefaultFrameColorLabel(label);
 }
 
 void TimelineFramesView::slotSelectAudioChannelFile()
 {
     if (!m_d->model) return;
 
     QString defaultDir = QStandardPaths::writableLocation(QStandardPaths::MusicLocation);
 
     const QString currentFile = m_d->model->audioChannelFileName();
     QDir baseDir = QFileInfo(currentFile).absoluteDir();
     if (baseDir.exists()) {
         defaultDir = baseDir.absolutePath();
     }
 
     const QString result = KisImportExportManager::askForAudioFileName(defaultDir, this);
     const QFileInfo info(result);
 
     if (info.exists()) {
         m_d->model->setAudioChannelFileName(info.absoluteFilePath());
     }
 }
 
 void TimelineFramesView::slotAudioChannelMute(bool value)
 {
     if (!m_d->model) return;
 
     if (value != m_d->model->isAudioMuted()) {
         m_d->model->setAudioMuted(value);
     }
 }
 
 void TimelineFramesView::slotUpdateIcons()
 {
     m_d->addLayersButton->setIcon(KisIconUtils::loadIcon("addlayer"));
     m_d->audioOptionsButton->setIcon(KisIconUtils::loadIcon("audio-none"));
     m_d->zoomDragButton->setIcon(KisIconUtils::loadIcon("zoom-horizontal"));
 }
 
 void TimelineFramesView::slotAudioChannelRemove()
 {
     if (!m_d->model) return;
     m_d->model->setAudioChannelFileName(QString());
 }
 
 void TimelineFramesView::slotUpdateAudioActions()
 {
     if (!m_d->model) return;
 
     const QString currentFile = m_d->model->audioChannelFileName();
 
     if (currentFile.isEmpty()) {
         m_d->openAudioAction->setText(i18nc("@item:inmenu", "Open audio..."));
     } else {
         QFileInfo info(currentFile);
         m_d->openAudioAction->setText(i18nc("@item:inmenu", "Change audio (%1)...", info.fileName()));
     }
 
     m_d->audioMuteAction->setChecked(m_d->model->isAudioMuted());
 
     QIcon audioIcon;
     if (currentFile.isEmpty()) {
         audioIcon = KisIconUtils::loadIcon("audio-none");
     } else {
         if (m_d->model->isAudioMuted()) {
             audioIcon = KisIconUtils::loadIcon("audio-volume-mute");
         } else {
             audioIcon = KisIconUtils::loadIcon("audio-volume-high");
         }
     }
 
     m_d->audioOptionsButton->setIcon(audioIcon);
 
     m_d->volumeSlider->setEnabled(!m_d->model->isAudioMuted());
 
     KisSignalsBlocker b(m_d->volumeSlider);
     m_d->volumeSlider->setValue(qRound(m_d->model->audioVolume() * 100.0));
 }
 
 void TimelineFramesView::slotAudioVolumeChanged(int value)
 {
     m_d->model->setAudioVolume(qreal(value) / 100.0);
 }
 
 void TimelineFramesView::slotUpdateInfiniteFramesCount()
 {
     if (horizontalScrollBar()->isSliderDown()) return;
 
     const int sectionWidth = m_d->horizontalRuler->defaultSectionSize();
     const int calculatedIndex =
             (horizontalScrollBar()->value() +
              m_d->horizontalRuler->width() - 1) / sectionWidth;
 
     m_d->model->setLastVisibleFrame(calculatedIndex);
 }
 
 void TimelineFramesView::slotScrollerStateChanged( QScroller::State state ) {
     KisKineticScroller::updateCursor(this, state);
 }
 
 void TimelineFramesView::currentChanged(const QModelIndex &current, const QModelIndex &previous)
 {
     QTableView::currentChanged(current, previous);
 
     if (previous.column() != current.column()) {
         m_d->model->setData(previous, false, TimelineFramesModel::ActiveFrameRole);
         m_d->model->setData(current, true, TimelineFramesModel::ActiveFrameRole);
     }
 }
 
 QItemSelectionModel::SelectionFlags TimelineFramesView::selectionCommand(const QModelIndex &index,
                                                                          const QEvent *event) const
 {
     // WARNING: Copy-pasted from KisNodeView! Please keep in sync!
 
     /**
      * Qt has a bug: when we Ctrl+click on an item, the item's
      * selections gets toggled on mouse *press*, whereas usually it is
      * done on mouse *release*.  Therefore the user cannot do a
      * Ctrl+D&D with the default configuration. This code fixes the
      * problem by manually returning QItemSelectionModel::NoUpdate
      * flag when the user clicks on an item and returning
      * QItemSelectionModel::Toggle on release.
      */
 
     if (event &&
             (event->type() == QEvent::MouseButtonPress ||
              event->type() == QEvent::MouseButtonRelease) &&
             index.isValid()) {
 
         const QMouseEvent *mevent = static_cast<const QMouseEvent*>(event);
 
         if (mevent->button() == Qt::RightButton &&
                 selectionModel()->selectedIndexes().contains(index)) {
 
             // Allow calling context menu for multiple layers
             return QItemSelectionModel::NoUpdate;
         }
 
         if (event->type() == QEvent::MouseButtonPress &&
                 (mevent->modifiers() & Qt::ControlModifier)) {
 
             return QItemSelectionModel::NoUpdate;
         }
 
         if (event->type() == QEvent::MouseButtonRelease &&
                 (mevent->modifiers() & Qt::ControlModifier)) {
 
             return QItemSelectionModel::Toggle;
         }
     }
 
     return QAbstractItemView::selectionCommand(index, event);
 }
 
 void TimelineFramesView::slotSelectionChanged()
 {
     int minColumn = std::numeric_limits<int>::max();
     int maxColumn = std::numeric_limits<int>::min();
 
     foreach (const QModelIndex &idx, selectedIndexes()) {
         if (idx.column() > maxColumn) {
             maxColumn = idx.column();
         }
 
         if (idx.column() < minColumn) {
             minColumn = idx.column();
         }
     }
 
     KisTimeRange range;
     if (maxColumn > minColumn) {
         range = KisTimeRange(minColumn, maxColumn - minColumn + 1);
     }
     m_d->model->setPlaybackRange(range);
 }
 
 void TimelineFramesView::slotReselectCurrentIndex()
 {
     QModelIndex index = currentIndex();
     currentChanged(index, index);
 }
 
 void TimelineFramesView::slotEnsureRowVisible(int row)
 {
     QModelIndex index = currentIndex();
     if (!index.isValid() || row < 0) return;
 
     index = m_d->model->index(row, index.column());
     scrollTo(index);
 }
 
 void TimelineFramesView::slotDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight)
 {
     if (m_d->model->isPlaybackActive()) return;
 
     int selectedColumn = -1;
 
     for (int j = topLeft.column(); j <= bottomRight.column(); j++) {
         QVariant value = m_d->model->data(
                     m_d->model->index(topLeft.row(), j),
                     TimelineFramesModel::ActiveFrameRole);
 
         if (value.isValid() && value.toBool()) {
             selectedColumn = j;
             break;
         }
     }
 
     QModelIndex index = currentIndex();
 
     if (!index.isValid() && selectedColumn < 0) {
         return;
     }
 
 
     if (selectedColumn == -1) {
         selectedColumn = index.column();
     }
 
     if (selectedColumn != index.column() && !m_d->dragInProgress) {
         int row= index.isValid() ? index.row() : 0;
         selectionModel()->setCurrentIndex(m_d->model->index(row, selectedColumn), QItemSelectionModel::ClearAndSelect);
     }
 }
 
 void TimelineFramesView::slotHeaderDataChanged(Qt::Orientation orientation, int first, int last)
 {
     Q_UNUSED(first);
     Q_UNUSED(last);
 
     if (orientation == Qt::Horizontal) {
         const int newFps = m_d->model->headerData(0, Qt::Horizontal, TimelineFramesModel::FramesPerSecondRole).toInt();
 
         if (newFps != m_d->fps) {
             setFramesPerSecond(newFps);
         }
     }
 }
 
 void TimelineFramesView::rowsInserted(const QModelIndex& parent, int start, int end)
 {
     QTableView::rowsInserted(parent, start, end);
 }
 
 inline bool isIndexDragEnabled(QAbstractItemModel *model, const QModelIndex &index) {
     return (model->flags(index) & Qt::ItemIsDragEnabled);
 }
 
 QStyleOptionViewItem TimelineFramesView::Private::viewOptionsV4() const
 {
     QStyleOptionViewItem option = q->viewOptions();
     option.locale = q->locale();
     option.locale.setNumberOptions(QLocale::OmitGroupSeparator);
     option.widget = q;
     return option;
 }
 
 QItemViewPaintPairs TimelineFramesView::Private::draggablePaintPairs(const QModelIndexList &indexes, QRect *r) const
 {
     Q_ASSERT(r);
     QRect &rect = *r;
     const QRect viewportRect = q->viewport()->rect();
     QItemViewPaintPairs ret;
     for (int i = 0; i < indexes.count(); ++i) {
         const QModelIndex &index = indexes.at(i);
         const QRect current = q->visualRect(index);
         if (current.intersects(viewportRect)) {
             ret += qMakePair(current, index);
             rect |= current;
         }
     }
     rect &= viewportRect;
     return ret;
 }
 
 QPixmap TimelineFramesView::Private::renderToPixmap(const QModelIndexList &indexes, QRect *r) const
 {
     Q_ASSERT(r);
     QItemViewPaintPairs paintPairs = draggablePaintPairs(indexes, r);
     if (paintPairs.isEmpty())
         return QPixmap();
     QPixmap pixmap(r->size());
     pixmap.fill(Qt::transparent);
     QPainter painter(&pixmap);
     QStyleOptionViewItem option = viewOptionsV4();
     option.state |= QStyle::State_Selected;
     for (int j = 0; j < paintPairs.count(); ++j) {
         option.rect = paintPairs.at(j).first.translated(-r->topLeft());
         const QModelIndex &current = paintPairs.at(j).second;
         //adjustViewOptionsForIndex(&option, current);
 
         q->itemDelegate(current)->paint(&painter, option, current);
     }
     return pixmap;
 }
 
 void TimelineFramesView::startDrag(Qt::DropActions supportedActions)
 {
     QModelIndexList indexes = selectionModel()->selectedIndexes();
 
     if (!indexes.isEmpty() && m_d->modifiersCatcher->modifierPressed("offset-frame")) {
         QVector<int> rows;
         int leftmostColumn = std::numeric_limits<int>::max();
 
         Q_FOREACH (const QModelIndex &index, indexes) {
             leftmostColumn = qMin(leftmostColumn, index.column());
             if (!rows.contains(index.row())) {
                 rows.append(index.row());
             }
         }
 
         const int lastColumn = m_d->model->columnCount() - 1;
 
         selectionModel()->clear();
         Q_FOREACH (const int row, rows) {
             QItemSelection sel(m_d->model->index(row, leftmostColumn), m_d->model->index(row, lastColumn));
             selectionModel()->select(sel, QItemSelectionModel::Select);
         }
 
         supportedActions = Qt::MoveAction;
 
         {
             QModelIndexList indexes = selectedIndexes();
             for(int i = indexes.count() - 1 ; i >= 0; --i) {
                 if (!isIndexDragEnabled(m_d->model, indexes.at(i)))
                     indexes.removeAt(i);
             }
 
             selectionModel()->clear();
 
             if (indexes.count() > 0) {
                 QMimeData *data = m_d->model->mimeData(indexes);
                 if (!data)
                     return;
                 QRect rect;
                 QPixmap pixmap = m_d->renderToPixmap(indexes, &rect);
                 rect.adjust(horizontalOffset(), verticalOffset(), 0, 0);
                 QDrag *drag = new QDrag(this);
                 drag->setPixmap(pixmap);
                 drag->setMimeData(data);
                 drag->setHotSpot(m_d->lastPressedPosition - rect.topLeft());
                 drag->exec(supportedActions, Qt::MoveAction);
                 setCurrentIndex(currentIndex());
             }
         }
     } else {
 
         /**
          * Workaround for Qt5's bug: if we start a dragging action right during
          * Shift-selection, Qt will get crazy. We cannot workaround it easily,
          * because we would need to fork mouseMoveEvent() for that (where the
          * decision about drag state is done). So we just abort dragging in that
          * case.
          *
          * BUG:373067
          */
         if (m_d->lastPressedModifier & Qt::ShiftModifier) {
             return;
         }
 
         /**
          * Workaround for Qt5's bugs:
          *
          * 1) Qt doesn't treat selection the selection on D&D
          *    correctly, so we save it in advance and restore
          *    afterwards.
          *
          * 2) There is a private variable in QAbstractItemView:
          *    QAbstractItemView::Private::currentSelectionStartIndex.
          *    It is initialized *only* when the setCurrentIndex() is called
          *    explicitly on the view object, not on the selection model.
          *    Therefore we should explicitly call setCurrentIndex() after
          *    D&D, even if it already has *correct* value!
          *
          * 2) We should also call selectionModel()->select()
          *    explicitly.  There are two reasons for it: 1) Qt doesn't
          *    maintain selection over D&D; 2) when reselecting single
          *    element after D&D, Qt goes crazy, because it tries to
          *    read *global* keyboard modifiers. Therefore if we are
          *    dragging with Shift or Ctrl pressed it'll get crazy. So
          *    just reset it explicitly.
          */
 
         QModelIndexList selectionBefore = selectionModel()->selectedIndexes();
         QModelIndex currentBefore = selectionModel()->currentIndex();
 
         // initialize a global status variable
         m_d->dragWasSuccessful = false;
         QAbstractItemView::startDrag(supportedActions);
 
         QModelIndex newCurrent;
         QPoint selectionOffset;
 
         if (m_d->dragWasSuccessful) {
             newCurrent = currentIndex();
             selectionOffset = QPoint(newCurrent.column() - currentBefore.column(),
                                      newCurrent.row() - currentBefore.row());
         } else {
             newCurrent = currentBefore;
             selectionOffset = QPoint();
         }
 
         setCurrentIndex(newCurrent);
         selectionModel()->clearSelection();
         Q_FOREACH (const QModelIndex &idx, selectionBefore) {
             QModelIndex newIndex =
                     model()->index(idx.row() + selectionOffset.y(),
                                    idx.column() + selectionOffset.x());
             selectionModel()->select(newIndex, QItemSelectionModel::Select);
         }
     }
 }
 
 void TimelineFramesView::dragEnterEvent(QDragEnterEvent *event)
 {
     m_d->dragInProgress = true;
     m_d->model->setScrubState(true);
 
     QTableView::dragEnterEvent(event);
 }
 
 void TimelineFramesView::dragMoveEvent(QDragMoveEvent *event)
 {
     m_d->dragInProgress = true;
     m_d->model->setScrubState(true);
 
     QTableView::dragMoveEvent(event);
 
     if (event->isAccepted()) {
         QModelIndex index = indexAt(event->pos());
         if (!m_d->model->canDropFrameData(event->mimeData(), index)) {
             event->ignore();
         } else {
             selectionModel()->setCurrentIndex(index, QItemSelectionModel::NoUpdate);
         }
     }
 }
 
 void TimelineFramesView::dropEvent(QDropEvent *event)
 {
     m_d->dragInProgress = false;
     m_d->model->setScrubState(false);
 
     if (event->keyboardModifiers() & Qt::ControlModifier) {
         event->setDropAction(Qt::CopyAction);
     }
     QAbstractItemView::dropEvent(event);
     m_d->dragWasSuccessful = event->isAccepted();
 }
 
 void TimelineFramesView::dragLeaveEvent(QDragLeaveEvent *event)
 {
     m_d->dragInProgress = false;
     m_d->model->setScrubState(false);
 
     QAbstractItemView::dragLeaveEvent(event);
 }
 
 void TimelineFramesView::createFrameEditingMenuActions(QMenu *menu, bool addFrameCreationActions)
 {
     slotUpdateFrameActions();
 
     // calculate if selection range is set. This will determine if the update playback range is available
     QSet<int> rows;
     int minColumn = 0;
     int maxColumn = 0;
     calculateSelectionMetrics(minColumn, maxColumn, rows);
 
     bool selectionExists = minColumn != maxColumn;
 
 
     if (selectionExists) {
         KisActionManager::safePopulateMenu(menu, "update_playback_range", m_d->actionMan);
     } else {
         KisActionManager::safePopulateMenu(menu, "set_start_time", m_d->actionMan);
         KisActionManager::safePopulateMenu(menu, "set_end_time", m_d->actionMan);
     }
 
     menu->addSeparator();
 
     KisActionManager::safePopulateMenu(menu, "cut_frames_to_clipboard", m_d->actionMan);
     KisActionManager::safePopulateMenu(menu, "copy_frames_to_clipboard", m_d->actionMan);
     KisActionManager::safePopulateMenu(menu, "paste_frames_from_clipboard", m_d->actionMan);
 
     menu->addSeparator();
 
     {   //Frames submenu.
         QMenu *frames = menu->addMenu(i18nc("@item:inmenu", "Keyframes"));
         KisActionManager::safePopulateMenu(frames, "insert_keyframe_left", m_d->actionMan);
         KisActionManager::safePopulateMenu(frames, "insert_keyframe_right", m_d->actionMan);
         frames->addSeparator();
         KisActionManager::safePopulateMenu(frames, "insert_multiple_keyframes", m_d->actionMan);
     }
 
     {   //Holds submenu.
         QMenu *hold = menu->addMenu(i18nc("@item:inmenu", "Hold Frames"));
         KisActionManager::safePopulateMenu(hold, "insert_hold_frame", m_d->actionMan);
         KisActionManager::safePopulateMenu(hold, "remove_hold_frame", m_d->actionMan);
         hold->addSeparator();
         KisActionManager::safePopulateMenu(hold, "insert_multiple_hold_frames", m_d->actionMan);
         KisActionManager::safePopulateMenu(hold, "remove_multiple_hold_frames", m_d->actionMan);
     }
 
     menu->addSeparator();
 
     KisActionManager::safePopulateMenu(menu, "remove_frames", m_d->actionMan);
     KisActionManager::safePopulateMenu(menu, "remove_frames_and_pull", m_d->actionMan);
 
     menu->addSeparator();
 
     if (addFrameCreationActions) {
         KisActionManager::safePopulateMenu(menu, "add_blank_frame", m_d->actionMan);
         KisActionManager::safePopulateMenu(menu, "add_duplicate_frame", m_d->actionMan);
         menu->addSeparator();
     }
 }
 
 void TimelineFramesView::mousePressEvent(QMouseEvent *event)
 {
     QPersistentModelIndex index = indexAt(event->pos());
 
     if (m_d->modifiersCatcher->modifierPressed("pan-zoom")) {
 
         if (event->button() == Qt::RightButton) {
             // TODO: try calculate index under mouse cursor even when
             //       it is outside any visible row
             qreal staticPoint = index.isValid() ? index.column() : currentIndex().column();
             m_d->zoomDragButton->beginZoom(event->pos(), staticPoint);
         } else if (event->button() == Qt::LeftButton) {
             m_d->initialDragPanPos = event->pos();
             m_d->initialDragPanValue =
                     QPoint(horizontalScrollBar()->value(),
                            verticalScrollBar()->value());
         }
         event->accept();
 
     } else if (event->button() == Qt::RightButton) {
 
         int numSelectedItems = selectionModel()->selectedIndexes().size();
 
         if (index.isValid() &&
                 numSelectedItems <= 1 &&
                 m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) {
 
             model()->setData(index, true, TimelineFramesModel::ActiveLayerRole);
             model()->setData(index, true, TimelineFramesModel::ActiveFrameRole);
             setCurrentIndex(index);
 
             if (model()->data(index, TimelineFramesModel::FrameExistsRole).toBool() ||
                     model()->data(index, TimelineFramesModel::SpecialKeyframeExists).toBool()) {
 
                 {
                     KisSignalsBlocker b(m_d->colorSelector);
                     QVariant colorLabel = index.data(TimelineFramesModel::FrameColorLabelIndexRole);
                     int labelIndex = colorLabel.isValid() ? colorLabel.toInt() : 0;
                     m_d->colorSelector->setCurrentIndex(labelIndex);
                 }
 
                 QMenu menu;
                 createFrameEditingMenuActions(&menu, false);
                 menu.addSeparator();
                 menu.addAction(m_d->colorSelectorAction);
                 menu.exec(event->globalPos());
 
             } else {
                 {
                     KisSignalsBlocker b(m_d->colorSelector);
                     const int labelIndex = KisImageConfig(true).defaultFrameColorLabel();
                     m_d->colorSelector->setCurrentIndex(labelIndex);
                 }
 
                 QMenu menu;
                 createFrameEditingMenuActions(&menu, true);
 
                 menu.addSeparator();
                 menu.addAction(m_d->colorSelectorAction);
                 menu.exec(event->globalPos());
             }
         } else if (numSelectedItems > 1) {
             int labelIndex = -1;
             bool haveFrames = false;
             Q_FOREACH(QModelIndex index, selectedIndexes()) {
                 haveFrames |= index.data(TimelineFramesModel::FrameExistsRole).toBool();
                 QVariant colorLabel = index.data(TimelineFramesModel::FrameColorLabelIndexRole);
                 if (colorLabel.isValid()) {
                     if (labelIndex == -1) {
                         // First label
                         labelIndex = colorLabel.toInt();
                     } else if (labelIndex != colorLabel.toInt()) {
                         // Mixed colors in selection
                         labelIndex = -1;
                         break;
                     }
                 }
             }
 
             if (haveFrames) {
                 KisSignalsBlocker b(m_d->multiframeColorSelector);
                 m_d->multiframeColorSelector->setCurrentIndex(labelIndex);
             }
 
             QMenu menu;
             createFrameEditingMenuActions(&menu, false);
             menu.addSeparator();
             KisActionManager::safePopulateMenu(&menu, "mirror_frames", m_d->actionMan);
             menu.addSeparator();
             menu.addAction(m_d->multiframeColorSelectorAction);
             menu.exec(event->globalPos());
         }
     } else if (event->button() == Qt::MidButton) {
         QModelIndex index = model()->buddy(indexAt(event->pos()));
         if (index.isValid()) {
             QStyleOptionViewItem option = viewOptions();
             option.rect = visualRect(index);
             // The offset of the headers is needed to get the correct position inside the view.
             m_d->tip.showTip(this, event->pos() + QPoint(verticalHeader()->width(), horizontalHeader()->height()), option, index);
         }
         event->accept();
     } else {
         if (index.isValid()) {
             m_d->model->setLastClickedIndex(index);
         }
 
         m_d->lastPressedPosition =
                 QPoint(horizontalOffset(), verticalOffset()) + event->pos();
         m_d->lastPressedModifier = event->modifiers();
 
         QAbstractItemView::mousePressEvent(event);
     }
 }
 
 void TimelineFramesView::mouseMoveEvent(QMouseEvent *e)
 {
     if (m_d->modifiersCatcher->modifierPressed("pan-zoom")) {
 
         if (e->buttons() & Qt::RightButton) {
             m_d->zoomDragButton->continueZoom(e->pos());
         } else if (e->buttons() & Qt::LeftButton) {
             QPoint diff = e->pos() - m_d->initialDragPanPos;
             QPoint offset = QPoint(m_d->initialDragPanValue.x() - diff.x(),
                                    m_d->initialDragPanValue.y() - diff.y());
 
             const int height = m_d->layersHeader->defaultSectionSize();
 
             horizontalScrollBar()->setValue(offset.x());
             verticalScrollBar()->setValue(offset.y() / height);
         }
         e->accept();
     } else if (e->buttons() == Qt::MidButton) {
         QModelIndex index = model()->buddy(indexAt(e->pos()));
         if (index.isValid()) {
             QStyleOptionViewItem option = viewOptions();
             option.rect = visualRect(index);
             // The offset of the headers is needed to get the correct position inside the view.
             m_d->tip.showTip(this, e->pos() + QPoint(verticalHeader()->width(), horizontalHeader()->height()), option, index);
         }
         e->accept();
     } else {
         m_d->model->setScrubState(true);
         QTableView::mouseMoveEvent(e);
     }
 }
 
 void TimelineFramesView::mouseReleaseEvent(QMouseEvent *e)
 {
     if (m_d->modifiersCatcher->modifierPressed("pan-zoom")) {
         e->accept();
     } else {
         m_d->model->setScrubState(false);
         QTableView::mouseReleaseEvent(e);
     }
 }
 
 void TimelineFramesView::wheelEvent(QWheelEvent *e)
 {
     QModelIndex index = currentIndex();
     int column= -1;
 
     if (index.isValid()) {
         column= index.column() + ((e->delta() > 0) ? 1 : -1);
     }
 
     if (column >= 0 && !m_d->dragInProgress) {
         setCurrentIndex(m_d->model->index(index.row(), column));
     }
 }
 
 void TimelineFramesView::slotUpdateLayersMenu()
 {
     QAction *action = 0;
 
     m_d->existingLayersMenu->clear();
 
     QVariant value = model()->headerData(0, Qt::Vertical, TimelineFramesModel::OtherLayersRole);
     if (value.isValid()) {
         TimelineFramesModel::OtherLayersList list = value.value<TimelineFramesModel::OtherLayersList>();
 
         int i = 0;
         Q_FOREACH (const TimelineFramesModel::OtherLayer &l, list) {
             action = m_d->existingLayersMenu->addAction(l.name);
             action->setData(i++);
         }
     }
 }
 
 void TimelineFramesView::slotUpdateFrameActions()
 {
     if (!m_d->actionMan) return;
 
     const QModelIndexList editableIndexes = calculateSelectionSpan(false, true);
     const bool hasEditableFrames = !editableIndexes.isEmpty();
 
     bool hasExistingFrames = false;
     Q_FOREACH (const QModelIndex &index, editableIndexes) {
         if (model()->data(index, TimelineFramesModel::FrameExistsRole).toBool()) {
             hasExistingFrames = true;
             break;
         }
     }
 
     auto enableAction = [this] (const QString &id, bool value) {
         KisAction *action = m_d->actionMan->actionByName(id);
         KIS_SAFE_ASSERT_RECOVER_RETURN(action);
         action->setEnabled(value);
     };
 
     enableAction("add_blank_frame", hasEditableFrames);
     enableAction("add_duplicate_frame", hasEditableFrames);
 
     enableAction("insert_keyframe_left", hasEditableFrames);
     enableAction("insert_keyframe_right", hasEditableFrames);
     enableAction("insert_multiple_keyframes", hasEditableFrames);
 
     enableAction("remove_frames", hasEditableFrames && hasExistingFrames);
     enableAction("remove_frames_and_pull", hasEditableFrames);
 
     enableAction("insert_hold_frame", hasEditableFrames);
     enableAction("insert_multiple_hold_frames", hasEditableFrames);
 
     enableAction("remove_hold_frame", hasEditableFrames);
     enableAction("remove_multiple_hold_frames", hasEditableFrames);
 
     enableAction("mirror_frames", hasEditableFrames && editableIndexes.size() > 1);
 
     enableAction("copy_frames_to_clipboard", true);
     enableAction("cut_frames_to_clipboard", hasEditableFrames);
 
     QClipboard *cp = QApplication::clipboard();
     const QMimeData *data = cp->mimeData();
 
     enableAction("paste_frames_from_clipboard", data && data->hasFormat("application/x-krita-frame"));
 
     //TODO: update column actions!
 }
 
 void TimelineFramesView::slotSetStartTimeToCurrentPosition()
 {
      m_d->model->setFullClipRangeStart(this->currentIndex().column());
 }
 
 void TimelineFramesView::slotSetEndTimeToCurrentPosition()
 {
     m_d->model->setFullClipRangeEnd(this->currentIndex().column());
 }
 
 void TimelineFramesView::slotUpdatePlackbackRange()
 {
     QSet<int> rows;
     int minColumn = 0;
     int maxColumn = 0;
 
     calculateSelectionMetrics(minColumn, maxColumn, rows);
 
     m_d->model->setFullClipRangeStart(minColumn);
     m_d->model->setFullClipRangeEnd(maxColumn);
 }
 
 void TimelineFramesView::slotLayerContextMenuRequested(const QPoint &globalPos)
 {
     m_d->layerEditingMenu->exec(globalPos);
 }
 
 void TimelineFramesView::slotAddNewLayer()
 {
     QModelIndex index = currentIndex();
     const int newRow = index.isValid() ? index.row() : 0;
     model()->insertRow(newRow);
 }
 
 void TimelineFramesView::slotAddExistingLayer(QAction *action)
 {
     QVariant value = action->data();
 
     if (value.isValid()) {
         QModelIndex index = currentIndex();
         const int newRow = index.isValid() ? index.row() + 1 : 0;
 
         m_d->model->insertOtherLayer(value.toInt(), newRow);
     }
 }
 
 void TimelineFramesView::slotRemoveLayer()
 {
     QModelIndex index = currentIndex();
     if (!index.isValid()) return;
 
     model()->removeRow(index.row());
 }
 
 void TimelineFramesView::slotAddBlankFrame()
 {
     QModelIndex index = currentIndex();
     if (!index.isValid() ||
         !m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) {
 
         return;
     }
 
     m_d->model->createFrame(index);
 }
 
 void TimelineFramesView::slotAddDuplicateFrame()
 {
     QModelIndex index = currentIndex();
     if (!index.isValid() ||
         !m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) {
 
         return;
     }
 
     m_d->model->copyFrame(index);
 }
 
 void TimelineFramesView::calculateSelectionMetrics(int &minColumn, int &maxColumn, QSet<int> &rows) const
 {
     minColumn = std::numeric_limits<int>::max();
     maxColumn = std::numeric_limits<int>::min();
 
     Q_FOREACH (const QModelIndex &index, selectionModel()->selectedIndexes()) {
         if (!m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) continue;
 
         rows.insert(index.row());
         minColumn = qMin(minColumn, index.column());
         maxColumn = qMax(maxColumn, index.column());
     }
 }
 
 void TimelineFramesView::insertKeyframes(int count, int timing, TimelineDirection direction, bool entireColumn)
 {
     QSet<int> rows;
     int minColumn = 0, maxColumn = 0;
 
     calculateSelectionMetrics(minColumn, maxColumn, rows);
 
     if (count <= 0) { //Negative count? Use number of selected frames.
         count = qMax(1, maxColumn - minColumn + 1);
     }
 
     const int insertionColumn =
         direction == TimelineDirection::RIGHT ?
         maxColumn + 1 : minColumn;
 
     if (entireColumn) {
         rows.clear();
         for (int i = 0; i < m_d->model->rowCount(); i++) {
             if (!m_d->model->data(m_d->model->index(i, insertionColumn), TimelineFramesModel::FrameEditableRole).toBool()) continue;
             rows.insert(i);
         }
     }
 
     if (!rows.isEmpty()) {
         m_d->model->insertFrames(insertionColumn, rows.toList(), count, timing);
     }
 }
 
 void TimelineFramesView::insertMultipleKeyframes(bool entireColumn)
 {
     int count, timing;
     TimelineDirection direction;
 
     if (m_d->insertKeyframeDialog->promptUserSettings(count, timing, direction)) {
         insertKeyframes(count, timing, direction, entireColumn);
     }
 }
 
 QModelIndexList TimelineFramesView::calculateSelectionSpan(bool entireColumn, bool editableOnly) const
 {
     QModelIndexList indexes;
 
     if (entireColumn) {
         QSet<int> rows;
         int minColumn = 0;
         int maxColumn = 0;
 
         calculateSelectionMetrics(minColumn, maxColumn, rows);
 
         rows.clear();
         for (int i = 0; i < m_d->model->rowCount(); i++) {
             if (editableOnly &&
                 !m_d->model->data(m_d->model->index(i, minColumn), TimelineFramesModel::FrameEditableRole).toBool()) continue;
 
             for (int column = minColumn; column <= maxColumn; column++) {
                 indexes << m_d->model->index(i, column);
             }
         }
     } else {
         Q_FOREACH (const QModelIndex &index, selectionModel()->selectedIndexes()) {
             if (!editableOnly || m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) {
                 indexes << index;
             }
         }
     }
 
     return indexes;
 }
 
 void TimelineFramesView::slotRemoveSelectedFrames(bool entireColumn, bool pull)
 {
     const QModelIndexList selectedIndices = calculateSelectionSpan(entireColumn);
 
     if (!selectedIndices.isEmpty()) {
         if (pull) {
             m_d->model->removeFramesAndOffset(selectedIndices);
         } else {
             m_d->model->removeFrames(selectedIndices);
         }
     }
 }
 
 void TimelineFramesView::insertOrRemoveHoldFrames(int count, bool entireColumn)
 {
     QModelIndexList indexes;
 
     if (!entireColumn) {
         Q_FOREACH (const QModelIndex &index, selectionModel()->selectedIndexes()) {
             if (m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) {
                 indexes << index;
             }
         }
     } else {
         const int column = selectionModel()->currentIndex().column();
 
         for (int i = 0; i < m_d->model->rowCount(); i++) {
             const QModelIndex index = m_d->model->index(i, column);
             if (m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) {
                 indexes << index;
             }
         }
     }
 
     if (!indexes.isEmpty()) {
 
         // add extra columns to the end of the timeline if we are adding hold frames
         // they will be truncated if we don't do this
         if (count > 0) {
             // Scan all the layers and find out what layer has the most keyframes
             // only keep a reference of layer that has the most keyframes
             int keyframesInLayerNode = 0;
             Q_FOREACH (const QModelIndex &index, indexes) {
                 KisNodeSP layerNode = m_d->model->nodeAt(index);
 
                 KisKeyframeChannel *channel = layerNode->getKeyframeChannel(KisKeyframeChannel::Content.id());
                 if (!channel) continue;
 
                 if (keyframesInLayerNode < channel->allKeyframeIds().count()) {
                    keyframesInLayerNode = channel->allKeyframeIds().count();
                 }
             }
             m_d->model->setLastVisibleFrame(m_d->model->columnCount() + count*keyframesInLayerNode);
         }
 
 
         m_d->model->insertHoldFrames(indexes, count);
 
         // bulk adding frames can add too many
         // trim timeline to clean up extra frames that might have been added
         slotUpdateInfiniteFramesCount();
     }
 }
 
 void TimelineFramesView::insertOrRemoveMultipleHoldFrames(bool insertion, bool entireColumn)
 {
     bool ok = false;
     const int count = QInputDialog::getInt(this,
                                            i18nc("@title:window", "Insert or Remove Hold Frames"),
                                            i18nc("@label:spinbox", "Enter number of frames"),
                                            insertion ?
                                                m_d->insertKeyframeDialog->defaultTimingOfAddedFrames() :
                                                m_d->insertKeyframeDialog->defaultNumberOfHoldFramesToRemove(),
                                            1, 10000, 1, &ok);
 
     if (ok) {
         if (insertion) {
             m_d->insertKeyframeDialog->setDefaultTimingOfAddedFrames(count);
             insertOrRemoveHoldFrames(count, entireColumn);
         } else {
             m_d->insertKeyframeDialog->setDefaultNumberOfHoldFramesToRemove(count);
             insertOrRemoveHoldFrames(-count, entireColumn);
         }
 
     }
 }
 
 void TimelineFramesView::slotMirrorFrames(bool entireColumn)
 {
     const QModelIndexList indexes = calculateSelectionSpan(entireColumn);
 
     if (!indexes.isEmpty()) {
         m_d->model->mirrorFrames(indexes);
     }
 }
 
 void TimelineFramesView::cutCopyImpl(bool entireColumn, bool copy)
 {
     const QModelIndexList selectedIndices = calculateSelectionSpan(entireColumn, !copy);
     if (selectedIndices.isEmpty()) return;
 
     int minColumn = std::numeric_limits<int>::max();
     int minRow = std::numeric_limits<int>::max();
 
     Q_FOREACH (const QModelIndex &index, selectedIndices) {
         minRow = qMin(minRow, index.row());
         minColumn = qMin(minColumn, index.column());
     }
 
     const QModelIndex baseIndex = m_d->model->index(minRow, minColumn);
 
     QMimeData *data = m_d->model->mimeDataExtended(selectedIndices,
                                                    baseIndex,
                                                    copy ?
                                                        TimelineFramesModel::CopyFramesPolicy :
                                                        TimelineFramesModel::MoveFramesPolicy);
 
     if (data) {
         QClipboard *cb = QApplication::clipboard();
         cb->setMimeData(data);
     }
 }
 
 void TimelineFramesView::slotPasteFrames(bool entireColumn)
 {
     const QModelIndex currentIndex =
         !entireColumn ? this->currentIndex() : m_d->model->index(0, this->currentIndex().column());
 
     if (!currentIndex.isValid()) return;
 
     QClipboard *cb = QApplication::clipboard();
     const QMimeData *data = cb->mimeData();
 
     if (data && data->hasFormat("application/x-krita-frame")) {
 
         bool dataMoved = false;
         bool result = m_d->model->dropMimeDataExtended(data, Qt::MoveAction, currentIndex, &dataMoved);
 
         if (result && dataMoved) {
             cb->clear();
         }
     }
 }
 
 bool TimelineFramesView::viewportEvent(QEvent *event)
 {
     if (event->type() == QEvent::ToolTip && model()) {
         QHelpEvent *he = static_cast<QHelpEvent *>(event);
         QModelIndex index = model()->buddy(indexAt(he->pos()));
         if (index.isValid()) {
             QStyleOptionViewItem option = viewOptions();
             option.rect = visualRect(index);
             // The offset of the headers is needed to get the correct position inside the view.
             m_d->tip.showTip(this, he->pos() + QPoint(verticalHeader()->width(), horizontalHeader()->height()), option, index);
             return true;
         }
     }
 
     return QTableView::viewportEvent(event);
 }
diff --git a/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.cpp b/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.cpp
index 58c9788fe0..ab2b45c0fe 100644
--- a/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.cpp
+++ b/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.cpp
@@ -1,460 +1,465 @@
 /*
  *  Copyright (c) 2009 Cyrille Berger <cberger@cberger.net>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include <kis_debug.h>
 
 #include <klocalizedstring.h>
 #include <KoCanvasResourceProvider.h>
 #include <KoResourceServerProvider.h>
 #include <KoResourceServerObserver.h>
 #include <KoResourceServerAdapter.h>
 #include <KoCanvasBase.h>
 #include <kis_canvas2.h>
 #include <KoColor.h>
 #include <resources/KoGamutMask.h>
 #include <kis_icon_utils.h>
 #include <KisPart.h>
 #include <kis_shape_layer.h>
 #include <kis_types.h>
 #include <KisDocument.h>
 #include <kis_node_selection_adapter.h>
 #include <kis_group_layer.h>
 #include <KisView.h>
 #include <KoResourceItemChooser.h>
 #include <kis_display_color_converter.h>
 
 #include <QWidget>
 #include <QMenu>
 #include <QButtonGroup>
 #include <QRegExpValidator>
 #include <QRegExp>
 #include <QFileInfo>
 
 #include "artisticcolorselector_dock.h"
 #include <KisViewManager.h>
 #include <kis_canvas_resource_provider.h>
 #include <kis_arcs_constants.h>
 #include <KisGamutMaskToolbar.h>
 
 #include "ui_wdgArtisticColorSelector.h"
 #include "ui_wdgARCSSettings.h"
 #include "ui_wdgWheelPreferencesPopup.h"
 
 class KisMainWindow;
 
 struct ArtisticColorSelectorUI: public QWidget, public Ui_wdgArtisticColorSelector
 {
     ArtisticColorSelectorUI() {
         setupUi(this);
     }
 };
 
 struct ARCSSettingsUI: public QWidget, public Ui_wdgARCSSettings
 {
     ARCSSettingsUI() {
         setupUi(this);
     }
 };
 
 struct WheelPreferencesPopupUI: public QWidget, public Ui_wdgWheelPreferencesPopup
 {
     WheelPreferencesPopupUI() {
         setupUi(this);
     }
 };
 
 
 ArtisticColorSelectorDock::ArtisticColorSelectorDock()
     : QDockWidget(i18n("Artistic Color Selector"))
     , m_canvas(nullptr)
     , m_resourceProvider(0)
     , m_selectedMask(nullptr)
 {
     setEnabled(false);
 
     m_hsxButtons    = new QButtonGroup();
     m_preferencesUI = new ARCSSettingsUI();
     m_wheelPrefsUI  = new WheelPreferencesPopupUI();
     m_selectorUI    = new ArtisticColorSelectorUI();
 
     QPixmap hueStepsPixmap = KisIconUtils::loadIcon("wheel-sectors").pixmap(16,16);
     QPixmap saturationStepsPixmap = KisIconUtils::loadIcon("wheel-rings").pixmap(16,16);
     QPixmap valueScaleStepsPixmap = KisIconUtils::loadIcon("wheel-light").pixmap(16,16);
     QIcon infinityIcon = KisIconUtils::loadIcon("infinity");
     m_infinityPixmap = infinityIcon.pixmap(16,16);
 
     m_selectorUI->colorSelector->loadSettings();
 
     m_selectorUI->bnWheelPrefs->setIcon(KisIconUtils::loadIcon("wheel-sectors"));
     m_selectorUI->bnWheelPrefs->setPopupWidget(m_wheelPrefsUI);
 
     m_selectorUI->bnDockerPrefs->setPopupWidget(m_preferencesUI);
     m_selectorUI->bnDockerPrefs->setIcon(KisIconUtils::loadIcon("configure"));
 
     //preferences
     m_hsxButtons->addButton(m_preferencesUI->bnHsy, KisColor::HSY);
     m_hsxButtons->addButton(m_preferencesUI->bnHsi, KisColor::HSI);
     m_hsxButtons->addButton(m_preferencesUI->bnHsl, KisColor::HSL);
     m_hsxButtons->addButton(m_preferencesUI->bnHsv, KisColor::HSV);
 
     m_wheelPrefsUI->bnInverseSat->setChecked(m_selectorUI->colorSelector->isSaturationInverted());
 
     m_wheelPrefsUI->labelHueSteps->setPixmap(hueStepsPixmap);
     m_wheelPrefsUI->labelSaturationSteps->setPixmap(saturationStepsPixmap);
     m_wheelPrefsUI->labelValueScaleSteps->setPixmap(valueScaleStepsPixmap);
 
     m_wheelPrefsUI->numHueSteps->setRange(MIN_NUM_UI_HUE_PIECES, MAX_NUM_HUE_PIECES);
     m_wheelPrefsUI->numSaturationSteps->setRange(MIN_NUM_SATURATION_RINGS, MAX_NUM_SATURATION_RINGS);
     m_wheelPrefsUI->numValueScaleSteps->setRange(MIN_NUM_UI_LIGHT_PIECES, MAX_NUM_LIGHT_PIECES);
 
     m_wheelPrefsUI->bnInfHueSteps->setIcon(infinityIcon);
     m_wheelPrefsUI->bnInfValueScaleSteps->setIcon(infinityIcon);
 
     m_wheelPrefsUI->bnInfHueSteps->setToolTip(i18n("Continuous Mode"));
     m_wheelPrefsUI->bnInfValueScaleSteps->setToolTip(i18n("Continuous Mode"));
 
     int selectorHueSteps = m_selectorUI->colorSelector->getNumPieces();
     if (selectorHueSteps == 1) {
         m_wheelPrefsUI->bnInfHueSteps->setChecked(true);
     } else {
         m_wheelPrefsUI->bnInfHueSteps->setChecked(false);
     }
     m_wheelPrefsUI->numHueSteps->setValue(selectorHueSteps);
 
     m_wheelPrefsUI->numSaturationSteps->setValue(m_selectorUI->colorSelector->getNumRings());
 
     int selectorValueScaleSteps = m_selectorUI->colorSelector->getNumLightPieces();
     if (selectorValueScaleSteps == 1) {
         m_wheelPrefsUI->bnInfValueScaleSteps->setChecked(true);
     } else {
         m_wheelPrefsUI->bnInfValueScaleSteps->setChecked(false);
     }
     m_wheelPrefsUI->numValueScaleSteps->setValue(m_selectorUI->colorSelector->getNumLightPieces());
 
     m_preferencesUI->bnDefInfHueSteps->setIcon(infinityIcon);
     m_preferencesUI->bnDefInfValueScaleSteps->setIcon(infinityIcon);
 
     m_preferencesUI->labelDefHueSteps->setPixmap(hueStepsPixmap);
     m_preferencesUI->labelDefSaturationSteps->setPixmap(saturationStepsPixmap);
     m_preferencesUI->labelDefValueScaleSteps->setPixmap(valueScaleStepsPixmap);
 
     m_preferencesUI->defaultHueSteps->setRange(MIN_NUM_HUE_PIECES, MAX_NUM_HUE_PIECES);
     m_preferencesUI->defaultSaturationSteps->setRange(MIN_NUM_SATURATION_RINGS, MAX_NUM_SATURATION_RINGS);
     m_preferencesUI->defaultValueScaleSteps->setRange(MIN_NUM_LIGHT_PIECES, MAX_NUM_LIGHT_PIECES);
 
     m_preferencesUI->defaultHueSteps->setValue(m_selectorUI->colorSelector->getDefaultHueSteps());
     m_preferencesUI->defaultSaturationSteps->setValue(m_selectorUI->colorSelector->getDefaultSaturationSteps());
     m_preferencesUI->defaultValueScaleSteps->setValue(m_selectorUI->colorSelector->getDefaultValueScaleSteps());
 
     m_preferencesUI->showBgColor->setChecked(m_selectorUI->colorSelector->getShowBgColor());
     m_preferencesUI->showValueScaleNumbers->setChecked(m_selectorUI->colorSelector->getShowValueScaleNumbers());
 
     m_preferencesUI->enforceGamutMask->setChecked(m_selectorUI->colorSelector->enforceGamutMask());
     m_preferencesUI->permissiveGamutMask->setChecked(!m_selectorUI->colorSelector->enforceGamutMask());
 
     m_preferencesUI->spLumaR->setValue(m_selectorUI->colorSelector->lumaR());
     m_preferencesUI->spLumaG->setValue(m_selectorUI->colorSelector->lumaG());
     m_preferencesUI->spLumaB->setValue(m_selectorUI->colorSelector->lumaB());
     m_preferencesUI->spLumaGamma->setValue(m_selectorUI->colorSelector->lumaGamma());
 
     switch(m_selectorUI->colorSelector->getColorSpace())
     {
         case KisColor::HSV: { m_preferencesUI->bnHsv->setChecked(true); } break;
         case KisColor::HSI: { m_preferencesUI->bnHsi->setChecked(true); } break;
         case KisColor::HSL: { m_preferencesUI->bnHsl->setChecked(true); } break;
         case KisColor::HSY: { m_preferencesUI->bnHsy->setChecked(true); } break;
     }
 
     if (m_selectorUI->colorSelector->getColorSpace() == KisColor::HSY) {
         m_preferencesUI->lumaCoefficientBox->show();
     } else {
         m_preferencesUI->lumaCoefficientBox->hide();
     }
 
     connect(m_wheelPrefsUI->numValueScaleSteps  , SIGNAL(valueChanged(int))                      , SLOT(slotPreferenceChanged()));
     connect(m_wheelPrefsUI->numHueSteps         , SIGNAL(valueChanged(int))                      , SLOT(slotPreferenceChanged()));
     connect(m_wheelPrefsUI->numSaturationSteps  , SIGNAL(valueChanged(int))                      , SLOT(slotPreferenceChanged()));
     connect(m_wheelPrefsUI->bnInverseSat        , SIGNAL(clicked(bool))                          , SLOT(slotPreferenceChanged()));
     connect(m_wheelPrefsUI->bnInfHueSteps       , SIGNAL(clicked(bool))                           , SLOT(slotPreferenceChanged()));
     connect(m_wheelPrefsUI->bnInfValueScaleSteps, SIGNAL(clicked(bool))                           , SLOT(slotPreferenceChanged()));
     connect(m_wheelPrefsUI->bnDefault           , SIGNAL(clicked(bool))                          , SLOT(slotResetDefaultSettings()));
 
     connect(m_preferencesUI->defaultHueSteps    , SIGNAL(valueChanged(int))                      , SLOT(slotPreferenceChanged()));
     connect(m_preferencesUI->defaultSaturationSteps, SIGNAL(valueChanged(int))                      , SLOT(slotPreferenceChanged()));
     connect(m_preferencesUI->defaultValueScaleSteps, SIGNAL(valueChanged(int))                      , SLOT(slotPreferenceChanged()));
     connect(m_preferencesUI->bnDefInfHueSteps       , SIGNAL(clicked(bool))                           , SLOT(slotPreferenceChanged()));
     connect(m_preferencesUI->bnDefInfValueScaleSteps, SIGNAL(clicked(bool))                           , SLOT(slotPreferenceChanged()));
 
     connect(m_preferencesUI->showBgColor        , SIGNAL(toggled(bool))                      , SLOT(slotPreferenceChanged()));
     connect(m_preferencesUI->showValueScaleNumbers, SIGNAL(toggled(bool))                      , SLOT(slotPreferenceChanged()));
     connect(m_preferencesUI->enforceGamutMask   , SIGNAL(toggled(bool))                      , SLOT(slotPreferenceChanged()));
 
     connect(m_preferencesUI->spLumaR   , SIGNAL(valueChanged(qreal)), SLOT(slotColorSpaceSelected()));
     connect(m_preferencesUI->spLumaG   , SIGNAL(valueChanged(qreal)), SLOT(slotColorSpaceSelected()));
     connect(m_preferencesUI->spLumaB   , SIGNAL(valueChanged(qreal)), SLOT(slotColorSpaceSelected()));
     connect(m_preferencesUI->spLumaGamma   , SIGNAL(valueChanged(qreal)), SLOT(slotColorSpaceSelected()));
 
     connect(m_selectorUI->colorSelector         , SIGNAL(sigFgColorChanged(KisColor))     , SLOT(slotFgColorChanged(KisColor)));
     connect(m_selectorUI->colorSelector         , SIGNAL(sigBgColorChanged(KisColor))     , SLOT(slotBgColorChanged(KisColor)));
 
-    // gamut mask connections
-    connect(m_selectorUI->gamutMaskToolbar, SIGNAL(sigGamutMaskToggle(bool)), SLOT(slotGamutMaskToggle(bool)));
-
     connect(m_hsxButtons                        , SIGNAL(buttonClicked(int))                     , SLOT(slotColorSpaceSelected()));
 
     setWidget(m_selectorUI);
 }
 
 ArtisticColorSelectorDock::~ArtisticColorSelectorDock()
 {
     m_selectorUI->colorSelector->saveSettings();
     delete m_hsxButtons;
 }
 
 void ArtisticColorSelectorDock::setViewManager(KisViewManager* kisview)
 {
     m_resourceProvider = kisview->canvasResourceProvider();
     m_selectorUI->colorSelector->setFgColor(m_resourceProvider->resourceManager()->foregroundColor());
     m_selectorUI->colorSelector->setBgColor(m_resourceProvider->resourceManager()->backgroundColor());
 
     connect(m_resourceProvider, SIGNAL(sigGamutMaskChanged(KoGamutMask*)),
             this, SLOT(slotGamutMaskSet(KoGamutMask*)), Qt::UniqueConnection);
 
     connect(m_resourceProvider, SIGNAL(sigGamutMaskUnset()),
             this, SLOT(slotGamutMaskUnset()), Qt::UniqueConnection);
 
     connect(m_resourceProvider, SIGNAL(sigGamutMaskPreviewUpdate()),
             this, SLOT(slotGamutMaskPreviewUpdate()), Qt::UniqueConnection);
 
+    connect(m_resourceProvider, SIGNAL(sigGamutMaskDeactivated()),
+            this, SLOT(slotGamutMaskDeactivate()), Qt::UniqueConnection);
+
     m_selectorUI->gamutMaskToolbar->connectMaskSignals(m_resourceProvider);
 }
 
 void ArtisticColorSelectorDock::slotCanvasResourceChanged(int key, const QVariant& value)
 {
     if(key == KoCanvasResourceProvider::ForegroundColor)
         m_selectorUI->colorSelector->setFgColor(value.value<KoColor>());
 
     if(key == KoCanvasResourceProvider::BackgroundColor)
         m_selectorUI->colorSelector->setBgColor(value.value<KoColor>());
 }
 
 void ArtisticColorSelectorDock::slotFgColorChanged(const KisColor& color)
 {
     m_resourceProvider->resourceManager()->setForegroundColor(
         KoColor(color.toKoColor(), m_resourceProvider->resourceManager()->foregroundColor().colorSpace())
     );
 }
 
 void ArtisticColorSelectorDock::slotBgColorChanged(const KisColor& color)
 {
     m_resourceProvider->resourceManager()->setBackgroundColor(
         KoColor(color.toKoColor(), m_resourceProvider->resourceManager()->backgroundColor().colorSpace())
     );
 }
 
 void ArtisticColorSelectorDock::slotColorSpaceSelected()
 {
     KisColor::Type type = static_cast<KisColor::Type>(
                 m_hsxButtons->id(m_hsxButtons->checkedButton()));
 
     m_selectorUI->colorSelector->setColorSpace(type);
 
     if (type == KisColor::HSY) {
         m_preferencesUI->lumaCoefficientBox->show();
     } else {
         m_preferencesUI->lumaCoefficientBox->hide();
     }
 
     m_selectorUI->colorSelector->setLumaCoefficients(
                 m_preferencesUI->spLumaR->value(),
                 m_preferencesUI->spLumaG->value(),
                 m_preferencesUI->spLumaB->value(),
                 m_preferencesUI->spLumaGamma->value()
                 );
 }
 
 void ArtisticColorSelectorDock::slotPreferenceChanged()
 {
     int hueSteps = DEFAULT_HUE_STEPS;
     if (m_wheelPrefsUI->bnInfHueSteps->isChecked()) {
         m_wheelPrefsUI->numHueSteps->setEnabled(false);
         hueSteps = 1;
     } else {
         m_wheelPrefsUI->numHueSteps->setEnabled(true);
         hueSteps = m_wheelPrefsUI->numHueSteps->value();
     }
     m_selectorUI->colorSelector->setNumPieces(hueSteps);
 
     m_selectorUI->colorSelector->setNumRings(m_wheelPrefsUI->numSaturationSteps->value());
 
     int valueScaleSteps;
     if (m_wheelPrefsUI->bnInfValueScaleSteps->isChecked()) {
         m_wheelPrefsUI->numValueScaleSteps->setEnabled(false);
         valueScaleSteps = 1;
     } else {
         valueScaleSteps = m_wheelPrefsUI->numValueScaleSteps->value();
         m_wheelPrefsUI->numValueScaleSteps->setEnabled(true);
     }
     m_selectorUI->colorSelector->setNumLightPieces(valueScaleSteps);
 
     int defHueSteps;
     if (m_preferencesUI->bnDefInfHueSteps->isChecked()) {
         m_preferencesUI->defaultHueSteps->setEnabled(false);
         defHueSteps = 1;
     } else {
         m_preferencesUI->defaultHueSteps->setEnabled(true);
         defHueSteps = m_preferencesUI->defaultHueSteps->value();
     }
     m_selectorUI->colorSelector->setDefaultHueSteps(defHueSteps);
 
     m_selectorUI->colorSelector->setDefaultSaturationSteps(m_preferencesUI->defaultSaturationSteps->value());
 
     int defValueScaleSteps;
     if (m_preferencesUI->bnDefInfValueScaleSteps->isChecked()) {
         m_preferencesUI->defaultValueScaleSteps->setEnabled(false);
         defValueScaleSteps = 1;
     } else {
         m_preferencesUI->defaultValueScaleSteps->setEnabled(true);
         defValueScaleSteps = m_preferencesUI->defaultValueScaleSteps->value();
     }
     m_selectorUI->colorSelector->setDefaultValueScaleSteps(defValueScaleSteps);
 
     m_selectorUI->colorSelector->setShowBgColor(m_preferencesUI->showBgColor->isChecked());
     m_selectorUI->colorSelector->setShowValueScaleNumbers(m_preferencesUI->showValueScaleNumbers->isChecked());
     m_selectorUI->colorSelector->setEnforceGamutMask(m_preferencesUI->enforceGamutMask->isChecked());
 
     m_selectorUI->colorSelector->setInverseSaturation(m_wheelPrefsUI->bnInverseSat->isChecked());
 }
 
 void ArtisticColorSelectorDock::slotResetDefaultSettings()
 {
     quint32 hueSteps = m_selectorUI->colorSelector->getDefaultHueSteps();
     quint32 saturationSteps = m_selectorUI->colorSelector->getDefaultSaturationSteps();
     quint32 valueScaleSteps = m_selectorUI->colorSelector->getDefaultValueScaleSteps();
 
     m_selectorUI->colorSelector->setNumRings(saturationSteps);
     m_wheelPrefsUI->numSaturationSteps->blockSignals(true);
     m_wheelPrefsUI->numSaturationSteps->setValue(saturationSteps);
     m_wheelPrefsUI->numSaturationSteps->blockSignals(false);
 
     m_selectorUI->colorSelector->setNumPieces(hueSteps);
     m_wheelPrefsUI->numHueSteps->blockSignals(true);
     m_wheelPrefsUI->numHueSteps->setValue(hueSteps);
     m_wheelPrefsUI->numHueSteps->blockSignals(false);
 
     if (hueSteps == 1) {
         m_wheelPrefsUI->numHueSteps->setEnabled(false);
         m_wheelPrefsUI->bnInfHueSteps->setChecked(true);
     } else {
         m_wheelPrefsUI->numHueSteps->setEnabled(true);
         m_wheelPrefsUI->bnInfHueSteps->setChecked(false);
     }
 
     m_selectorUI->colorSelector->setNumLightPieces(valueScaleSteps);
     m_wheelPrefsUI->numValueScaleSteps->blockSignals(true);
     m_wheelPrefsUI->numValueScaleSteps->setValue(valueScaleSteps);
     m_wheelPrefsUI->numValueScaleSteps->blockSignals(false);
 
     if (valueScaleSteps == 1) {
         m_wheelPrefsUI->numValueScaleSteps->setEnabled(false);
         m_wheelPrefsUI->bnInfValueScaleSteps->setChecked(true);
     } else {
         m_wheelPrefsUI->numValueScaleSteps->setEnabled(true);
         m_wheelPrefsUI->bnInfValueScaleSteps->setChecked(false);
     }
 }
 
 void ArtisticColorSelectorDock::slotGamutMaskToggle(bool checked)
 {
     bool b = (!m_selectedMask) ? false : checked;
 
     if (b == true) {
         m_selectorUI->colorSelector->setGamutMask(m_selectedMask);
     }
 
     m_selectorUI->colorSelector->setGamutMaskOn(b);
 }
 
 void ArtisticColorSelectorDock::setCanvas(KoCanvasBase *canvas)
 {
     if (!canvas) {
         return;
     }
 
     m_canvas = dynamic_cast<KisCanvas2*>(canvas);
 
     if (m_canvas) {
         m_canvas->disconnectCanvasObserver(this);
     }
 
     if (m_canvas) {
         connect(m_canvas->resourceManager(), SIGNAL(canvasResourceChanged(int,QVariant)),
                 SLOT(slotCanvasResourceChanged(int,QVariant)), Qt::UniqueConnection);
 
         connect(m_canvas->displayColorConverter(), SIGNAL(displayConfigurationChanged()),
                 SLOT(slotSelectorSettingsChanged()), Qt::UniqueConnection);
 
         m_selectorUI->colorSelector->setColorConverter(m_canvas->displayColorConverter());
         setEnabled(true);
     }
 }
 
 void ArtisticColorSelectorDock::unsetCanvas()
 {
     setEnabled(false);
     m_canvas = nullptr;
     m_selectorUI->colorSelector->setColorConverter(KisDisplayColorConverter::dumbConverterInstance());
 }
 
 void ArtisticColorSelectorDock::slotGamutMaskSet(KoGamutMask *mask)
 {
     if (!mask) {
         return;
     }
 
     m_selectedMask = mask;
 
     if (m_selectedMask) {
         m_selectorUI->colorSelector->setGamutMask(m_selectedMask);
         slotGamutMaskToggle(true);
     } else {
         slotGamutMaskToggle(false);
     }
 }
 
 void ArtisticColorSelectorDock::slotGamutMaskUnset()
 {
     if (!m_selectedMask) {
         return;
     }
 
     m_selectedMask = nullptr;
 
     slotGamutMaskToggle(false);
     m_selectorUI->colorSelector->setGamutMask(m_selectedMask);
 }
 
 void ArtisticColorSelectorDock::slotGamutMaskPreviewUpdate()
 {
     m_selectorUI->colorSelector->setDirty();
 }
 
+void ArtisticColorSelectorDock::slotGamutMaskDeactivate()
+{
+    slotGamutMaskToggle(false);
+}
+
 void ArtisticColorSelectorDock::slotSelectorSettingsChanged()
 {
     m_selectorUI->colorSelector->setDirty();
 }
diff --git a/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.h b/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.h
index 68172f0c43..edafebacc7 100644
--- a/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.h
+++ b/plugins/dockers/artisticcolorselector/artisticcolorselector_dock.h
@@ -1,87 +1,88 @@
 /*
  *  Copyright (c) 2009 Cyrille Berger <cberger@cberger.net>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2 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 H_ARTISTIC_COLOR_SELECTOR_DOCK_H
 #define H_ARTISTIC_COLOR_SELECTOR_DOCK_H
 
 #include <QDockWidget>
 #include <QPointer>
 #include <QRegExpValidator>
 
 #include <KoCanvasObserverBase.h>
 #include <KoResourceServerProvider.h>
 #include <KoResourceServerAdapter.h>
 #include <KoResourceServerObserver.h>
 #include <resources/KoGamutMask.h>
 #include <KisDocument.h>
 #include <kis_types.h>
 #include <KoResourceItemChooser.h>
 
 #include <kis_mainwindow_observer.h>
 
 class KisCanvasResourceProvider;
 class KisColor;
 class QButtonGroup;
 class QMenu;
 
 struct ArtisticColorSelectorUI;
 struct ARCSSettingsUI;
 struct WheelPreferencesPopupUI;
 
 class ArtisticColorSelectorDock: public QDockWidget, public KisMainwindowObserver
 {
     Q_OBJECT
     
 public:
     ArtisticColorSelectorDock();
     ~ArtisticColorSelectorDock() override;
     QString observerName() override { return "ArtisticColorSelectorDock"; }
     void setViewManager(KisViewManager* kisview) override;
     void setCanvas(KoCanvasBase* canvas) override;
     void unsetCanvas() override;
 
 private Q_SLOTS:
     void slotCanvasResourceChanged(int key, const QVariant& value);
     void slotFgColorChanged(const KisColor& color);
     void slotBgColorChanged(const KisColor& color);
     void slotColorSpaceSelected();
     void slotPreferenceChanged();
     void slotResetDefaultSettings();
     void slotGamutMaskToggle(bool value);
     void slotGamutMaskSet(KoGamutMask* mask);
     void slotGamutMaskUnset();
     void slotGamutMaskPreviewUpdate();
+    void slotGamutMaskDeactivate();
     void slotSelectorSettingsChanged();
 
 private:
     KisCanvas2* m_canvas;
     KisCanvasResourceProvider* m_resourceProvider;
     QButtonGroup*            m_hsxButtons;
     ArtisticColorSelectorUI* m_selectorUI;
     ARCSSettingsUI* m_preferencesUI;
     WheelPreferencesPopupUI* m_wheelPrefsUI;
     KoGamutMask* m_selectedMask;
 
     QIcon m_iconMaskOff;
     QIcon m_iconMaskOn;
 
     QPixmap m_infinityPixmap;
 };
 
 
 #endif // H_ARTISTIC_COLOR_SELECTOR_DOCK_H
diff --git a/plugins/dockers/gamutmask/KisGamutMaskChooser.cpp b/plugins/dockers/gamutmask/KisGamutMaskChooser.cpp
index f0dd21399a..7c7e19440d 100644
--- a/plugins/dockers/gamutmask/KisGamutMaskChooser.cpp
+++ b/plugins/dockers/gamutmask/KisGamutMaskChooser.cpp
@@ -1,252 +1,252 @@
 /*
  *  Copyright (c) 2018 Anna Medonosova <anna.medonosova@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 "KisGamutMaskChooser.h"
 
 #include <QWidget>
 #include <QVBoxLayout>
 #include <QAbstractItemDelegate>
 #include <QMenu>
 #include <QActionGroup>
 #include <QToolButton>
 #include <QFontMetrics>
 #include <QTextDocument>
 #include <QTextLayout>
 
 #include <KoResourceServer.h>
 #include <KoResourceServerProvider.h>
 #include <KoResourceItemChooser.h>
 #include <KoResourceServerAdapter.h>
 #include <kis_icon_utils.h>
 #include <kis_config.h>
 
 /// The resource item delegate for rendering the resource preview
 class KisGamutMaskDelegate: public QAbstractItemDelegate
 {
 public:
     KisGamutMaskDelegate(QObject * parent = 0) : QAbstractItemDelegate(parent)
       , m_mode(KisGamutMaskChooser::ViewMode::THUMBNAIL) {}
     ~KisGamutMaskDelegate() override {}
 
     /// reimplemented
     void paint(QPainter *, const QStyleOptionViewItem &, const QModelIndex &) const override;
 
     /// reimplemented
     QSize sizeHint(const QStyleOptionViewItem & option, const QModelIndex &) const override {
         return option.decorationSize;
     }
 
     void setViewMode(KisGamutMaskChooser::ViewMode mode) {
         m_mode = mode;
     }
 
 private:
     KisGamutMaskChooser::ViewMode m_mode;
 };
 
 void KisGamutMaskDelegate::paint(QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index) const
 {
     painter->save();
     painter->setRenderHint(QPainter::SmoothPixmapTransform, true);
 
     if (!index.isValid())
         return;
 
     KoResource* resource = static_cast<KoResource*>(index.internalPointer());
     KoGamutMask* mask = static_cast<KoGamutMask*>(resource);
 
     if (!mask) {
         return;
     }
 
     QImage preview = mask->image();
 
     if(preview.isNull()) {
         return;
     }
 
     QRect paintRect = option.rect.adjusted(1, 1, -1, -1);
 
     if (m_mode == KisGamutMaskChooser::ViewMode::THUMBNAIL) {
         painter->drawImage(paintRect.x(), paintRect.y(),
                            preview.scaled(paintRect.size(), Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
 
         if (option.state & QStyle::State_Selected) {
             painter->setCompositionMode(QPainter::CompositionMode_Overlay);
             painter->setOpacity(0.5);
             painter->fillRect(paintRect, Qt::white);
             painter->setCompositionMode(QPainter::CompositionMode_SourceOver);
             painter->setOpacity(1.0);
             painter->setPen(QPen(option.palette.highlight(), 2, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin));
             QRect selectedBorder = option.rect.adjusted(1, 1, -1, -1);
             painter->drawRect(selectedBorder);
         }
     } else {
         QSize previewSize(paintRect.height(), paintRect.height());
         painter->drawImage(paintRect.x(), paintRect.y(),
                            preview.scaled(previewSize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
 
         int leftMargin = 8;
         int rightMargin = 7;
         int vertMargin = 4;
         int descOffset = 7;
         QFont font = option.font;
         font.setBold(true);
         painter->setFont(font);
         QRectF titleRect(QPointF(previewSize.width() + leftMargin, paintRect.y() + vertMargin),
                        QPointF(paintRect.width() - rightMargin, paintRect.y() + descOffset + painter->fontMetrics().lineSpacing()));
         painter->drawText(titleRect, Qt::AlignLeft,
                           painter->fontMetrics().elidedText(
                               mask->title(), Qt::ElideRight, titleRect.width()
                               )
                           );
 
         if (!mask->description().isEmpty() && !mask->description().isNull()) {
             font.setPointSize(font.pointSize()-1);
             font.setBold(false);
             font.setStyle(QFont::StyleItalic);
             painter->setFont(font);
             QRectF descRect(QPointF(previewSize.width() + leftMargin, paintRect.y() + descOffset + painter->fontMetrics().lineSpacing()),
                             QPointF(paintRect.right() - rightMargin, paintRect.bottom() - vertMargin));
 
             int numLines = floor(((float)descRect.height() / (float)painter->fontMetrics().lineSpacing()));
             if (numLines > 0) {
                 int elideWidth = 0;
                 QTextLayout textLayout(mask->description());
                 textLayout.beginLayout();
                 for (int i = 0; i < numLines; i++) {
                     QTextLine line = textLayout.createLine();
                     if (line.isValid()) {
                         line.setLineWidth(descRect.width());
                         elideWidth += line.naturalTextWidth();
                     }
                 }
 
                 QString elidedText = painter->fontMetrics().elidedText(mask->description(), Qt::ElideRight, elideWidth);
                 painter->drawText(descRect, Qt::AlignLeft|Qt::TextWordWrap, elidedText);
             }
         }
     }
 
     painter->restore();
 }
 
 
 KisGamutMaskChooser::KisGamutMaskChooser(QWidget *parent) : QWidget(parent)
 {
     m_delegate = new KisGamutMaskDelegate(this);
 
     KoResourceServer<KoGamutMask>* rServer = KoResourceServerProvider::instance()->gamutMaskServer();
     QSharedPointer<KoAbstractResourceServerAdapter> adapter(new KoResourceServerAdapter<KoGamutMask>(rServer));
     m_itemChooser = new KoResourceItemChooser(adapter, this);
     m_itemChooser->setItemDelegate(m_delegate);
     m_itemChooser->showTaggingBar(true);
     m_itemChooser->showButtons(false);
     m_itemChooser->setColumnCount(4);
     m_itemChooser->setSynced(true);
 
     QVBoxLayout* layout = new QVBoxLayout(this);
     layout->setContentsMargins(0,0,0,0);
 
     // TODO: menu for view mode change
     QMenu* menu = new QMenu(this);
     menu->setStyleSheet("margin: 6px");
-    menu->addSection(i18n("Display"));
+    menu->addSection(i18nc("@title Which elements to display (e.g., thumbnails or details)", "Display"));
 
     QActionGroup *actionGroup = new QActionGroup(this);
 
     KisConfig cfg(true);
     m_mode = KisGamutMaskChooser::ViewMode(cfg.readEntry<quint32>("GamutMasks.viewMode", KisGamutMaskChooser::THUMBNAIL));
 
     QAction* action = menu->addAction(KisIconUtils::loadIcon("view-preview"),
                                       i18n("Thumbnails"), this, SLOT(slotSetModeThumbnail()));
     action->setCheckable(true);
     action->setChecked(m_mode == KisGamutMaskChooser::THUMBNAIL);
     action->setActionGroup(actionGroup);
 
     action = menu->addAction(KisIconUtils::loadIcon("view-list-details"),
                              i18n("Details"), this, SLOT(slotSetModeDetail()));
     action->setCheckable(true);
     action->setChecked(m_mode == KisGamutMaskChooser::DETAIL);
     action->setActionGroup(actionGroup);
 
     // setting the view mode
     setViewMode(m_mode);
     m_itemChooser->setViewModeButtonVisible(true);
     QToolButton* viewModeButton = m_itemChooser->viewModeButton();
     viewModeButton->setMenu(menu);
 
     layout->addWidget(m_itemChooser);
     setLayout(layout);
 
     connect(m_itemChooser, SIGNAL(resourceSelected(KoResource*)), this, SLOT(resourceSelected(KoResource*)));
 }
 
 KisGamutMaskChooser::~KisGamutMaskChooser()
 {
 
 }
 
 void KisGamutMaskChooser::setCurrentResource(KoResource *resource)
 {
     m_itemChooser->setCurrentResource(resource);
 }
 
 void KisGamutMaskChooser::resizeEvent(QResizeEvent *event)
 {
     QWidget::resizeEvent(event);
     updateViewSettings();
 }
 
 void KisGamutMaskChooser::setViewMode(KisGamutMaskChooser::ViewMode mode)
 {
     m_mode = mode;
     updateViewSettings();
 }
 
 void KisGamutMaskChooser::updateViewSettings()
 {
     KisConfig cfg(false);
     cfg.writeEntry("GamutMasks.viewMode", qint32(m_mode));
 
     if (m_mode == KisGamutMaskChooser::THUMBNAIL) {
         m_itemChooser->setSynced(true);
         m_delegate->setViewMode(m_mode);
     } else if (m_mode == KisGamutMaskChooser::DETAIL) {
         m_itemChooser->setSynced(false);
         m_itemChooser->setColumnCount(1);
         m_itemChooser->setRowHeight(this->fontMetrics().lineSpacing()*4);
         m_itemChooser->setColumnWidth(m_itemChooser->width());
         m_delegate->setViewMode(m_mode);
     }
 }
 
 void KisGamutMaskChooser::resourceSelected(KoResource* resource)
 {
     emit sigGamutMaskSelected(static_cast<KoGamutMask*>(resource));
 }
 
 void KisGamutMaskChooser::slotSetModeThumbnail()
 {
     setViewMode(KisGamutMaskChooser::THUMBNAIL);
 }
 
 void KisGamutMaskChooser::slotSetModeDetail()
 {
     setViewMode(KisGamutMaskChooser::DETAIL);
 }
diff --git a/plugins/dockers/layerdocker/LayerBox.cpp b/plugins/dockers/layerdocker/LayerBox.cpp
index aebf3caca7..fbe2d55c2d 100644
--- a/plugins/dockers/layerdocker/LayerBox.cpp
+++ b/plugins/dockers/layerdocker/LayerBox.cpp
@@ -1,1101 +1,1103 @@
 /*
  *  LayerBox.cc - part of Krita aka Krayon aka KimageShop
  *
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (C) 2006 Gábor Lehel <illissius@gmail.com>
  *  Copyright (C) 2007 Thomas Zander <zander@kde.org>
  *  Copyright (C) 2007 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2011 José Luis Vergara <pentalis@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "LayerBox.h"
 
 #include <QToolButton>
 #include <QLayout>
 #include <QMouseEvent>
 #include <QPainter>
 #include <QPoint>
 #include <QRect>
 #include <QString>
 #include <QToolTip>
 #include <QWidget>
 #include <QComboBox>
 #include <QCheckBox>
 #include <QVBoxLayout>
 #include <QPixmap>
 #include <QList>
 #include <QVector>
 #include <QLabel>
 #include <QMenu>
 #include <QWidgetAction>
 #include <QProxyStyle>
 
 #include <kis_debug.h>
 #include <klocalizedstring.h>
 
 #include <kis_icon.h>
 #include <KoColorSpace.h>
 #include <KoCompositeOpRegistry.h>
 #include <KisDocument.h>
 
 #include <kis_types.h>
 #include <kis_image.h>
 #include <kis_paint_device.h>
 #include <kis_layer.h>
 #include <kis_group_layer.h>
 #include <kis_mask.h>
 #include <kis_node.h>
 #include <kis_base_node.h>
 #include <kis_composite_ops_model.h>
 #include <kis_keyframe_channel.h>
 #include <kis_image_animation_interface.h>
 #include <KoProperties.h>
 
 #include <kis_action.h>
 #include "kis_action_manager.h"
 #include "widgets/kis_cmb_composite.h"
 #include "widgets/kis_slider_spin_box.h"
 #include "KisViewManager.h"
 #include "kis_node_manager.h"
 #include "kis_node_model.h"
 
 #include "canvas/kis_canvas2.h"
 #include "kis_dummies_facade_base.h"
 #include "kis_shape_controller.h"
 #include "kis_selection_mask.h"
 #include "kis_config.h"
 #include "KisView.h"
 #include "krita_utils.h"
 #include "kis_color_label_selector_widget.h"
 #include "kis_signals_blocker.h"
 #include "kis_color_filter_combo.h"
 #include "kis_node_filter_proxy_model.h"
 
 #include "kis_selection.h"
 #include "kis_processing_applicator.h"
 #include "commands/kis_set_global_selection_command.h"
 #include "KisSelectionActionsAdapter.h"
 
 #include "kis_layer_utils.h"
 
 #include "ui_WdgLayerBox.h"
 #include "NodeView.h"
 #include "SyncButtonAndAction.h"
 
 
 class LayerBoxStyle : public QProxyStyle
 {
 public:
     LayerBoxStyle(QStyle *baseStyle = 0) : QProxyStyle(baseStyle) {}
 
     void drawPrimitive(PrimitiveElement element, const QStyleOption *option,
                        QPainter *painter, const QWidget *widget) const
     {
         if (element == QStyle::PE_IndicatorItemViewItemDrop)
         {
             QColor color(widget->palette().color(QPalette::Highlight).lighter());
 
             if (option->rect.height() == 0) {
                 QBrush brush(color);
 
                 QRect r(option->rect);
                 r.setTop(r.top() - 2);
                 r.setBottom(r.bottom() + 2);
 
                 painter->fillRect(r, brush);
             } else {
                 color.setAlpha(200);
                 QBrush brush(color);
                 painter->fillRect(option->rect, brush);
             }
         }
         else
         {
             QProxyStyle::drawPrimitive(element, option, painter, widget);
         }
     }
 };
 
 inline void LayerBox::connectActionToButton(KisViewManager* viewManager, QAbstractButton *button, const QString &id)
 {
     if (!viewManager || !button) return;
 
     KisAction *action = viewManager->actionManager()->actionByName(id);
 
     if (!action) return;
 
     connect(button, SIGNAL(clicked()), action, SLOT(trigger()));
     connect(action, SIGNAL(sigEnableSlaves(bool)), button, SLOT(setEnabled(bool)));
     connect(viewManager->mainWindow(), SIGNAL(themeChanged()), this, SLOT(slotUpdateIcons()));
 }
 
 inline void LayerBox::addActionToMenu(QMenu *menu, const QString &id)
 {
     if (m_canvas) {
         menu->addAction(m_canvas->viewManager()->actionManager()->actionByName(id));
     }
 }
 
 LayerBox::LayerBox()
     : QDockWidget(i18n("Layers"))
     , m_canvas(0)
     , m_wdgLayerBox(new Ui_WdgLayerBox)
     , m_thumbnailCompressor(500, KisSignalCompressor::FIRST_INACTIVE)
     , m_colorLabelCompressor(900, KisSignalCompressor::FIRST_INACTIVE)
     , m_thumbnailSizeCompressor(100, KisSignalCompressor::FIRST_INACTIVE)
 {
     KisConfig cfg(false);
 
     QWidget* mainWidget = new QWidget(this);
     setWidget(mainWidget);
     m_opacityDelayTimer.setSingleShot(true);
 
     m_wdgLayerBox->setupUi(mainWidget);
 
     m_wdgLayerBox->listLayers->setStyle(new LayerBoxStyle(m_wdgLayerBox->listLayers->style()));
 
     connect(m_wdgLayerBox->listLayers,
             SIGNAL(contextMenuRequested(QPoint,QModelIndex)),
             this, SLOT(slotContextMenuRequested(QPoint,QModelIndex)));
     connect(m_wdgLayerBox->listLayers,
             SIGNAL(collapsed(QModelIndex)), SLOT(slotCollapsed(QModelIndex)));
     connect(m_wdgLayerBox->listLayers,
             SIGNAL(expanded(QModelIndex)), SLOT(slotExpanded(QModelIndex)));
     connect(m_wdgLayerBox->listLayers,
             SIGNAL(selectionChanged(QModelIndexList)), SLOT(selectionChanged(QModelIndexList)));
 
     slotUpdateIcons();
 
     m_wdgLayerBox->bnDelete->setIconSize(QSize(22, 22));
     m_wdgLayerBox->bnRaise->setIconSize(QSize(22, 22));
     m_wdgLayerBox->bnLower->setIconSize(QSize(22, 22));
     m_wdgLayerBox->bnProperties->setIconSize(QSize(22, 22));
     m_wdgLayerBox->bnDuplicate->setIconSize(QSize(22, 22));
 
     m_wdgLayerBox->bnLower->setEnabled(false);
     m_wdgLayerBox->bnRaise->setEnabled(false);
 
     if (cfg.sliderLabels()) {
         m_wdgLayerBox->opacityLabel->hide();
         m_wdgLayerBox->doubleOpacity->setPrefix(QString("%1:  ").arg(i18n("Opacity")));
     }
     m_wdgLayerBox->doubleOpacity->setRange(0, 100, 0);
-    m_wdgLayerBox->doubleOpacity->setSuffix("%");
+    m_wdgLayerBox->doubleOpacity->setSuffix(i18n("%"));
 
     connect(m_wdgLayerBox->doubleOpacity, SIGNAL(valueChanged(qreal)), SLOT(slotOpacitySliderMoved(qreal)));
     connect(&m_opacityDelayTimer, SIGNAL(timeout()), SLOT(slotOpacityChanged()));
 
     connect(m_wdgLayerBox->cmbComposite, SIGNAL(activated(int)), SLOT(slotCompositeOpChanged(int)));
 
     m_newLayerMenu = new QMenu(this);
     m_wdgLayerBox->bnAdd->setMenu(m_newLayerMenu);
     m_wdgLayerBox->bnAdd->setPopupMode(QToolButton::MenuButtonPopup);
 
     m_nodeModel = new KisNodeModel(this);
     m_filteringModel = new KisNodeFilterProxyModel(this);
     m_filteringModel->setNodeModel(m_nodeModel);
 
     /**
      * Connect model updateUI() to enable/disable controls.
      * Note: nodeActivated() is connected separately in setImage(), because
      *       it needs particular order of calls: first the connection to the
      *       node manager should be called, then updateUI()
      */
     connect(m_nodeModel, SIGNAL(rowsInserted(QModelIndex,int,int)), SLOT(updateUI()));
     connect(m_nodeModel, SIGNAL(rowsRemoved(QModelIndex,int,int)), SLOT(updateUI()));
     connect(m_nodeModel, SIGNAL(rowsMoved(QModelIndex,int,int,QModelIndex,int)), SLOT(updateUI()));
     connect(m_nodeModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)), SLOT(updateUI()));
     connect(m_nodeModel, SIGNAL(modelReset()), SLOT(slotModelReset()));
 
     KisAction *showGlobalSelectionMask = new KisAction(i18n("&Show Global Selection Mask"), this);
     showGlobalSelectionMask->setObjectName("show-global-selection-mask");
     showGlobalSelectionMask->setActivationFlags(KisAction::ACTIVE_IMAGE);
     showGlobalSelectionMask->setToolTip(i18nc("@info:tooltip", "Shows global selection as a usual selection mask in <b>Layers</b> docker"));
     showGlobalSelectionMask->setCheckable(true);
     connect(showGlobalSelectionMask, SIGNAL(triggered(bool)), SLOT(slotEditGlobalSelection(bool)));
     m_actions.append(showGlobalSelectionMask);
 
     showGlobalSelectionMask->setChecked(cfg.showGlobalSelection());
 
     m_colorSelector = new KisColorLabelSelectorWidget(this);
     connect(m_colorSelector, SIGNAL(currentIndexChanged(int)), SLOT(slotColorLabelChanged(int)));
     m_colorSelectorAction = new QWidgetAction(this);
     m_colorSelectorAction->setDefaultWidget(m_colorSelector);
 
     connect(m_nodeModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
             &m_colorLabelCompressor, SLOT(start()));
 
     m_wdgLayerBox->listLayers->setModel(m_filteringModel);
     // this connection should be done *after* the setModel() call to
     // happen later than the internal selection model
     connect(m_filteringModel.data(), &KisNodeFilterProxyModel::rowsAboutToBeRemoved,
             this, &LayerBox::slotAboutToRemoveRows);
 
     connect(m_wdgLayerBox->cmbFilter, SIGNAL(selectedColorsChanged()), SLOT(updateLayerFiltering()));
 
     setEnabled(false);
 
     connect(&m_thumbnailCompressor, SIGNAL(timeout()), SLOT(updateThumbnail()));
     connect(&m_colorLabelCompressor, SIGNAL(timeout()), SLOT(updateAvailableLabels()));
 
 
 
     // set up the configure menu for changing thumbnail size
     QMenu* configureMenu = new QMenu(this);
     configureMenu->setStyleSheet("margin: 6px");
     configureMenu->addSection(i18n("Thumbnail Size"));
 
     m_wdgLayerBox->configureLayerDockerToolbar->setMenu(configureMenu);
     m_wdgLayerBox->configureLayerDockerToolbar->setIcon(KisIconUtils::loadIcon("configure"));
 
     m_wdgLayerBox->configureLayerDockerToolbar->setPopupMode(QToolButton::InstantPopup);
 
 
     // add horizontal slider
     thumbnailSizeSlider = new QSlider(this);
     thumbnailSizeSlider->setOrientation(Qt::Horizontal);
     thumbnailSizeSlider->setRange(20, 80);
 
     thumbnailSizeSlider->setValue(cfg.layerThumbnailSize(false)); // grab this from the kritarc
 
     thumbnailSizeSlider->setMinimumHeight(20);
     thumbnailSizeSlider->setMinimumWidth(40);
     thumbnailSizeSlider->setTickInterval(5);
 
 
     QWidgetAction *sliderAction= new QWidgetAction(this);
     sliderAction->setDefaultWidget(thumbnailSizeSlider);
     configureMenu->addAction(sliderAction);
 
 
     connect(thumbnailSizeSlider, SIGNAL(sliderMoved(int)), &m_thumbnailSizeCompressor, SLOT(start()));
     connect(&m_thumbnailSizeCompressor, SIGNAL(timeout()), SLOT(slotUpdateThumbnailIconSize()));
 
 }
 
 LayerBox::~LayerBox()
 {
     delete m_wdgLayerBox;
 }
 
 
 void expandNodesRecursively(KisNodeSP root, QPointer<KisNodeFilterProxyModel> filteringModel, NodeView *nodeView)
 {
     if (!root) return;
     if (filteringModel.isNull()) return;
     if (!nodeView) return;
 
     nodeView->blockSignals(true);
 
     KisNodeSP node = root->firstChild();
     while (node) {
         QModelIndex idx = filteringModel->indexFromNode(node);
         if (idx.isValid()) {
             nodeView->setExpanded(idx, !node->collapsed());
         }
         if (!node->collapsed() && node->childCount() > 0) {
             expandNodesRecursively(node, filteringModel, nodeView);
         }
         node = node->nextSibling();
     }
     nodeView->blockSignals(false);
 }
 
 void LayerBox::slotAddLayerBnClicked()
 {
     if (m_canvas) {
         KisNodeList nodes = m_nodeManager->selectedNodes();
 
         if (nodes.size() == 1) {
             KisAction *action = m_canvas->viewManager()->actionManager()->actionByName("add_new_paint_layer");
             action->trigger();
         } else {
             KisAction *action = m_canvas->viewManager()->actionManager()->actionByName("create_quick_group");
             action->trigger();
         }
     }
 }
 
 void LayerBox::setViewManager(KisViewManager* kisview)
 {
     m_nodeManager = kisview->nodeManager();
 
     Q_FOREACH (KisAction *action, m_actions) {
         kisview->actionManager()->
                 addAction(action->objectName(),
                           action);
     }
 
     connect(m_wdgLayerBox->bnAdd, SIGNAL(clicked()), this, SLOT(slotAddLayerBnClicked()));
     connectActionToButton(kisview, m_wdgLayerBox->bnDuplicate, "duplicatelayer");
 
     KisActionManager *actionManager = kisview->actionManager();
 
     KisAction *action = actionManager->createAction("RenameCurrentLayer");
     Q_ASSERT(action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotRenameCurrentNode()));
 
     m_propertiesAction = actionManager->createAction("layer_properties");
     Q_ASSERT(m_propertiesAction);
     new SyncButtonAndAction(m_propertiesAction, m_wdgLayerBox->bnProperties, this);
     connect(m_propertiesAction, SIGNAL(triggered()), this, SLOT(slotPropertiesClicked()));
 
     m_removeAction = actionManager->createAction("remove_layer");
     Q_ASSERT(m_removeAction);
     new SyncButtonAndAction(m_removeAction, m_wdgLayerBox->bnDelete, this);
     connect(m_removeAction, SIGNAL(triggered()), this, SLOT(slotRmClicked()));
 
     action = actionManager->createAction("move_layer_up");
     Q_ASSERT(action);
     new SyncButtonAndAction(action, m_wdgLayerBox->bnRaise, this);
     connect(action, SIGNAL(triggered()), this, SLOT(slotRaiseClicked()));
 
     action = actionManager->createAction("move_layer_down");
     Q_ASSERT(action);
     new SyncButtonAndAction(action, m_wdgLayerBox->bnLower, this);
     connect(action, SIGNAL(triggered()), this, SLOT(slotLowerClicked()));
 
     m_changeCloneSourceAction = actionManager->createAction("set-copy-from");
     Q_ASSERT(m_changeCloneSourceAction);
     connect(m_changeCloneSourceAction, &KisAction::triggered,
             this, &LayerBox::slotChangeCloneSourceClicked);
 }
 
 void LayerBox::setCanvas(KoCanvasBase *canvas)
 {
     if (m_canvas == canvas)
         return;
 
     setEnabled(canvas != 0);
 
     if (m_canvas) {
         m_canvas->disconnectCanvasObserver(this);
         m_nodeModel->setDummiesFacade(0, 0, 0, 0, 0);
         m_selectionActionsAdapter.reset();
 
         if (m_image) {
             KisImageAnimationInterface *animation = m_image->animationInterface();
             animation->disconnect(this);
         }
 
         disconnect(m_image, 0, this, 0);
         disconnect(m_nodeManager, 0, this, 0);
         disconnect(m_nodeModel, 0, m_nodeManager, 0);
         m_nodeManager->slotSetSelectedNodes(KisNodeList());
     }
 
     m_canvas = dynamic_cast<KisCanvas2*>(canvas);
 
     if (m_canvas) {
         m_image = m_canvas->image();
         connect(m_image, SIGNAL(sigImageUpdated(QRect)), &m_thumbnailCompressor, SLOT(start()));
 
         KisDocument* doc = static_cast<KisDocument*>(m_canvas->imageView()->document());
         KisShapeController *kritaShapeController =
                 dynamic_cast<KisShapeController*>(doc->shapeController());
         KisDummiesFacadeBase *kritaDummiesFacade =
                 static_cast<KisDummiesFacadeBase*>(kritaShapeController);
 
 
         m_selectionActionsAdapter.reset(new KisSelectionActionsAdapter(m_canvas->viewManager()->selectionManager()));
         m_nodeModel->setDummiesFacade(kritaDummiesFacade,
                                       m_image,
                                       kritaShapeController,
                                       m_selectionActionsAdapter.data(),
                                       m_nodeManager);
 
         connect(m_image, SIGNAL(sigAboutToBeDeleted()), SLOT(notifyImageDeleted()));
         connect(m_image, SIGNAL(sigNodeCollapsedChanged()), SLOT(slotNodeCollapsedChanged()));
 
         // cold start
         if (m_nodeManager) {
             setCurrentNode(m_nodeManager->activeNode());
             // Connection KisNodeManager -> LayerBox
             connect(m_nodeManager, SIGNAL(sigUiNeedChangeActiveNode(KisNodeSP)),
                     this, SLOT(setCurrentNode(KisNodeSP)));
 
             connect(m_nodeManager,
                     SIGNAL(sigUiNeedChangeSelectedNodes(QList<KisNodeSP>)),
                     SLOT(slotNodeManagerChangedSelection(QList<KisNodeSP>)));
         }
         else {
             setCurrentNode(m_canvas->imageView()->currentNode());
         }
 
         // Connection LayerBox -> KisNodeManager (isolate layer)
         connect(m_nodeModel, SIGNAL(toggleIsolateActiveNode()),
                 m_nodeManager, SLOT(toggleIsolateActiveNode()));
 
         KisImageAnimationInterface *animation = m_image->animationInterface();
         connect(animation, &KisImageAnimationInterface::sigUiTimeChanged, this, &LayerBox::slotImageTimeChanged);
 
         expandNodesRecursively(m_image->rootLayer(), m_filteringModel, m_wdgLayerBox->listLayers);
         m_wdgLayerBox->listLayers->scrollTo(m_wdgLayerBox->listLayers->currentIndex());
         updateAvailableLabels();
 
         addActionToMenu(m_newLayerMenu, "add_new_paint_layer");
         addActionToMenu(m_newLayerMenu, "add_new_group_layer");
         addActionToMenu(m_newLayerMenu, "add_new_clone_layer");
         addActionToMenu(m_newLayerMenu, "add_new_shape_layer");
         addActionToMenu(m_newLayerMenu, "add_new_adjustment_layer");
         addActionToMenu(m_newLayerMenu, "add_new_fill_layer");
         addActionToMenu(m_newLayerMenu, "add_new_file_layer");
         m_newLayerMenu->addSeparator();
         addActionToMenu(m_newLayerMenu, "add_new_transparency_mask");
         addActionToMenu(m_newLayerMenu, "add_new_filter_mask");
         addActionToMenu(m_newLayerMenu, "add_new_colorize_mask");
         addActionToMenu(m_newLayerMenu, "add_new_transform_mask");
         addActionToMenu(m_newLayerMenu, "add_new_selection_mask");
     }
 
 }
 
 
 void LayerBox::unsetCanvas()
 {
     setEnabled(false);
     if (m_canvas) {
         m_newLayerMenu->clear();
     }
 
     m_filteringModel->unsetDummiesFacade();
     disconnect(m_image, 0, this, 0);
     disconnect(m_nodeManager, 0, this, 0);
     disconnect(m_nodeModel, 0, m_nodeManager, 0);
     m_nodeManager->slotSetSelectedNodes(KisNodeList());
 
     m_canvas = 0;
 }
 
 void LayerBox::notifyImageDeleted()
 {
     setCanvas(0);
 }
 
 void LayerBox::updateUI()
 {
     if (!m_canvas) return;
     if (!m_nodeManager) return;
 
     KisNodeSP activeNode = m_nodeManager->activeNode();
 
     if (activeNode != m_activeNode) {
         if( !m_activeNode.isNull() )
             m_activeNode->disconnect(this);
         m_activeNode = activeNode;
 
         if (activeNode) {
             KisKeyframeChannel *opacityChannel = activeNode->getKeyframeChannel(KisKeyframeChannel::Opacity.id(), false);
             if (opacityChannel) {
                 watchOpacityChannel(opacityChannel);
             } else {
                 watchOpacityChannel(0);
                 connect(activeNode.data(), &KisNode::keyframeChannelAdded, this, &LayerBox::slotKeyframeChannelAdded);
             }
         }
     }
 
     m_wdgLayerBox->bnRaise->setEnabled(activeNode && activeNode->isEditable(false) && (activeNode->nextSibling()
                                                                                        || (activeNode->parent() && activeNode->parent() != m_image->root())));
     m_wdgLayerBox->bnLower->setEnabled(activeNode && activeNode->isEditable(false) && (activeNode->prevSibling()
                                                                                        || (activeNode->parent() && activeNode->parent() != m_image->root())));
 
     m_wdgLayerBox->doubleOpacity->setEnabled(activeNode && activeNode->isEditable(false));
 
     m_wdgLayerBox->cmbComposite->setEnabled(activeNode && activeNode->isEditable(false));
     m_wdgLayerBox->cmbComposite->validate(m_image->colorSpace());
 
     if (activeNode) {
         if (activeNode->inherits("KisColorizeMask") ||
                 activeNode->inherits("KisLayer")) {
 
             m_wdgLayerBox->doubleOpacity->setEnabled(true);
 
             if (!m_wdgLayerBox->doubleOpacity->isDragging()) {
                 slotSetOpacity(activeNode->opacity() * 100.0 / 255);
             }
 
             const KoCompositeOp* compositeOp = activeNode->compositeOp();
             if (compositeOp) {
                 slotSetCompositeOp(compositeOp);
             } else {
                 m_wdgLayerBox->cmbComposite->setEnabled(false);
             }
 
             const KisGroupLayer *group = qobject_cast<const KisGroupLayer*>(activeNode.data());
             bool compositeSelectionActive = !(group && group->passThroughMode());
 
             m_wdgLayerBox->cmbComposite->setEnabled(compositeSelectionActive);
         } else if (activeNode->inherits("KisMask")) {
             m_wdgLayerBox->cmbComposite->setEnabled(false);
             m_wdgLayerBox->doubleOpacity->setEnabled(false);
         }
     }
 }
 
 
 /**
  * This method is called *only* when non-GUI code requested the
  * change of the current node
  */
 void LayerBox::setCurrentNode(KisNodeSP node)
 {
     m_filteringModel->setActiveNode(node);
 
     QModelIndex index = node ? m_filteringModel->indexFromNode(node) : QModelIndex();
     m_filteringModel->setData(index, true, KisNodeModel::ActiveRole);
     updateUI();
 }
 
 void LayerBox::slotModelReset()
 {
     if(m_nodeModel->hasDummiesFacade()) {
         QItemSelection selection;
         Q_FOREACH (const KisNodeSP node, m_nodeManager->selectedNodes()) {
             const QModelIndex &idx = m_filteringModel->indexFromNode(node);
             if(idx.isValid()){
                 QItemSelectionRange selectionRange(idx);
                 selection << selectionRange;
             }
         }
 
         m_wdgLayerBox->listLayers->selectionModel()->select(selection, QItemSelectionModel::ClearAndSelect);
     }
 
     updateUI();
 }
 
 void LayerBox::slotSetCompositeOp(const KoCompositeOp* compositeOp)
 {
     KoID opId = KoCompositeOpRegistry::instance().getKoID(compositeOp->id());
 
     m_wdgLayerBox->cmbComposite->blockSignals(true);
     m_wdgLayerBox->cmbComposite->selectCompositeOp(opId);
     m_wdgLayerBox->cmbComposite->blockSignals(false);
 }
 
 // range: 0-100
 void LayerBox::slotSetOpacity(double opacity)
 {
     Q_ASSERT(opacity >= 0 && opacity <= 100);
     m_wdgLayerBox->doubleOpacity->blockSignals(true);
     m_wdgLayerBox->doubleOpacity->setValue(opacity);
     m_wdgLayerBox->doubleOpacity->blockSignals(false);
 }
 
 void LayerBox::slotContextMenuRequested(const QPoint &pos, const QModelIndex &index)
 {
     KisNodeList nodes = m_nodeManager->selectedNodes();
     KisNodeSP activeNode = m_nodeManager->activeNode();
     if (nodes.isEmpty() || !activeNode) return;
 
     if (m_canvas) {
         QMenu menu;
 
         const bool singleLayer = nodes.size() == 1;
 
         if (index.isValid()) {
             menu.addAction(m_propertiesAction);
 
             if (singleLayer) {
                 addActionToMenu(&menu, "layer_style");
             }
 
             Q_FOREACH(KisNodeSP node, nodes) {
                 if (node && node->inherits("KisCloneLayer")) {
                     menu.addAction(m_changeCloneSourceAction);
                     break;
                 }
             }
 
             {
                 KisSignalsBlocker b(m_colorSelector);
                 m_colorSelector->setCurrentIndex(singleLayer ? activeNode->colorLabelIndex() : -1);
             }
             menu.addAction(m_colorSelectorAction);
 
             menu.addSeparator();
 
             addActionToMenu(&menu, "cut_layer_clipboard");
             addActionToMenu(&menu, "copy_layer_clipboard");
             addActionToMenu(&menu, "paste_layer_from_clipboard");
             menu.addAction(m_removeAction);
             addActionToMenu(&menu, "duplicatelayer");
             addActionToMenu(&menu, "merge_layer");
+            addActionToMenu(&menu, "new_from_visible");
+
 
             if (singleLayer) {
                 addActionToMenu(&menu, "flatten_image");
                 addActionToMenu(&menu, "flatten_layer");
             }
 
             menu.addSeparator();
             QMenu *selectMenu = menu.addMenu(i18n("&Select"));
             addActionToMenu(selectMenu, "select_all_layers");
             addActionToMenu(selectMenu, "select_visible_layers");
             addActionToMenu(selectMenu, "select_invisible_layers");
             addActionToMenu(selectMenu, "select_locked_layers");
             addActionToMenu(selectMenu, "select_unlocked_layers");
             QMenu *groupMenu = menu.addMenu(i18n("&Group"));
             addActionToMenu(groupMenu, "create_quick_group");
             addActionToMenu(groupMenu, "create_quick_clipping_group");
             addActionToMenu(groupMenu, "quick_ungroup");
             QMenu *locksMenu = menu.addMenu(i18n("&Toggle Locks && Visibility"));
             addActionToMenu(locksMenu, "toggle_layer_visibility");
             addActionToMenu(locksMenu, "toggle_layer_lock");
             addActionToMenu(locksMenu, "toggle_layer_inherit_alpha");
             addActionToMenu(locksMenu, "toggle_layer_alpha_lock");
 
             if (singleLayer) {
                 QMenu *addLayerMenu = menu.addMenu(i18n("&Add"));
                 addActionToMenu(addLayerMenu, "add_new_transparency_mask");
                 addActionToMenu(addLayerMenu, "add_new_filter_mask");
                 addActionToMenu(addLayerMenu, "add_new_colorize_mask");
                 addActionToMenu(addLayerMenu, "add_new_transform_mask");
                 addActionToMenu(addLayerMenu, "add_new_selection_mask");
 
                 QMenu *convertToMenu = menu.addMenu(i18n("&Convert"));
                 addActionToMenu(convertToMenu, "convert_to_paint_layer");
                 addActionToMenu(convertToMenu, "convert_to_transparency_mask");
                 addActionToMenu(convertToMenu, "convert_to_filter_mask");
                 addActionToMenu(convertToMenu, "convert_to_selection_mask");
                 addActionToMenu(convertToMenu, "convert_to_file_layer");
 
                 QMenu *splitAlphaMenu = menu.addMenu(i18n("S&plit Alpha"));
                 addActionToMenu(splitAlphaMenu, "split_alpha_into_mask");
                 addActionToMenu(splitAlphaMenu, "split_alpha_write");
                 addActionToMenu(splitAlphaMenu, "split_alpha_save_merged");
             }
 
             menu.addSeparator();
 
             addActionToMenu(&menu, "show_in_timeline");
 
             if (singleLayer) {
                 KisNodeSP node = m_filteringModel->nodeFromIndex(index);
                 if (node && !node->inherits("KisTransformMask")) {
                     addActionToMenu(&menu, "isolate_layer");
                 }
 
                 addActionToMenu(&menu, "selectopaque");
 
             }
         }
         menu.exec(pos);
     }
 }
 
 void LayerBox::slotMinimalView()
 {
     m_wdgLayerBox->listLayers->setDisplayMode(NodeView::MinimalMode);
 }
 
 void LayerBox::slotDetailedView()
 {
     m_wdgLayerBox->listLayers->setDisplayMode(NodeView::DetailedMode);
 }
 
 void LayerBox::slotThumbnailView()
 {
     m_wdgLayerBox->listLayers->setDisplayMode(NodeView::ThumbnailMode);
 }
 
 void LayerBox::slotRmClicked()
 {
     if (!m_canvas) return;
     m_nodeManager->removeNode();
 }
 
 void LayerBox::slotRaiseClicked()
 {
     if (!m_canvas) return;
     m_nodeManager->raiseNode();
 }
 
 void LayerBox::slotLowerClicked()
 {
     if (!m_canvas) return;
     m_nodeManager->lowerNode();
 }
 
 void LayerBox::slotPropertiesClicked()
 {
     if (!m_canvas) return;
     if (KisNodeSP active = m_nodeManager->activeNode()) {
         m_nodeManager->nodeProperties(active);
     }
 }
 
 void LayerBox::slotChangeCloneSourceClicked()
 {
     if (!m_canvas) return;
     m_nodeManager->changeCloneSource();
 }
 
 void LayerBox::slotCompositeOpChanged(int index)
 {
     Q_UNUSED(index);
     if (!m_canvas) return;
 
     QString compositeOp = m_wdgLayerBox->cmbComposite->selectedCompositeOp().id();
     m_nodeManager->nodeCompositeOpChanged(m_nodeManager->activeColorSpace()->compositeOp(compositeOp));
 }
 
 void LayerBox::slotOpacityChanged()
 {
     if (!m_canvas) return;
     m_blockOpacityUpdate = true;
     m_nodeManager->nodeOpacityChanged(m_newOpacity);
     m_blockOpacityUpdate = false;
 }
 
 void LayerBox::slotOpacitySliderMoved(qreal opacity)
 {
     m_newOpacity = opacity;
     m_opacityDelayTimer.start(200);
 }
 
 void LayerBox::slotCollapsed(const QModelIndex &index)
 {
     KisNodeSP node = m_filteringModel->nodeFromIndex(index);
     if (node) {
         node->setCollapsed(true);
     }
 }
 
 void LayerBox::slotExpanded(const QModelIndex &index)
 {
     KisNodeSP node = m_filteringModel->nodeFromIndex(index);
     if (node) {
         node->setCollapsed(false);
     }
 }
 
 void LayerBox::slotSelectOpaque()
 {
     if (!m_canvas) return;
     QAction *action = m_canvas->viewManager()->actionManager()->actionByName("selectopaque");
     if (action) {
         action->trigger();
     }
 }
 
 void LayerBox::slotNodeCollapsedChanged()
 {
     expandNodesRecursively(m_image->rootLayer(), m_filteringModel, m_wdgLayerBox->listLayers);
 }
 
 inline bool isSelectionMask(KisNodeSP node)
 {
     return dynamic_cast<KisSelectionMask*>(node.data());
 }
 
 KisNodeSP LayerBox::findNonHidableNode(KisNodeSP startNode)
 {
     if (KisNodeManager::isNodeHidden(startNode, true) &&
             startNode->parent() &&
             !startNode->parent()->parent()) {
 
 
         KisNodeSP node = startNode->prevSibling();
         while (node && KisNodeManager::isNodeHidden(node, true)) {
             node = node->prevSibling();
         }
 
         if (!node) {
             node = startNode->nextSibling();
             while (node && KisNodeManager::isNodeHidden(node, true)) {
                 node = node->nextSibling();
             }
         }
 
         if (!node) {
             node = m_image->root()->lastChild();
             while (node && KisNodeManager::isNodeHidden(node, true)) {
                 node = node->prevSibling();
             }
         }
 
         KIS_ASSERT_RECOVER_NOOP(node && "cannot activate any node!");
         startNode = node;
     }
 
     return startNode;
 }
 
 void LayerBox::slotEditGlobalSelection(bool showSelections)
 {
     KisNodeSP lastActiveNode = m_nodeManager->activeNode();
     KisNodeSP activateNode = lastActiveNode;
     KisSelectionMaskSP globalSelectionMask;
 
     if (!showSelections) {
         activateNode = findNonHidableNode(activateNode);
     }
 
     m_nodeModel->setShowGlobalSelection(showSelections);
 
     globalSelectionMask = m_image->rootLayer()->selectionMask();
 
     // try to find deactivated, but visible masks
     if (!globalSelectionMask) {
         KoProperties properties;
         properties.setProperty("visible", true);
         QList<KisNodeSP> masks = m_image->rootLayer()->childNodes(QStringList("KisSelectionMask"), properties);
         if (!masks.isEmpty()) {
             globalSelectionMask = dynamic_cast<KisSelectionMask*>(masks.first().data());
         }
     }
 
     // try to find at least any selection mask
     if (!globalSelectionMask) {
         KoProperties properties;
         QList<KisNodeSP> masks = m_image->rootLayer()->childNodes(QStringList("KisSelectionMask"), properties);
         if (!masks.isEmpty()) {
             globalSelectionMask = dynamic_cast<KisSelectionMask*>(masks.first().data());
         }
     }
 
     if (globalSelectionMask) {
         if (showSelections) {
             activateNode = globalSelectionMask;
         }
     }
 
     if (activateNode != lastActiveNode) {
         m_nodeManager->slotNonUiActivatedNode(activateNode);
     } else if (lastActiveNode) {
         setCurrentNode(lastActiveNode);
     }
 
     if (showSelections && !globalSelectionMask) {
         KisProcessingApplicator applicator(m_image, 0,
                                            KisProcessingApplicator::NONE,
                                            KisImageSignalVector() << ModifiedSignal,
                                            kundo2_i18n("Quick Selection Mask"));
 
         applicator.applyCommand(
             new KisLayerUtils::KeepNodesSelectedCommand(
                 m_nodeManager->selectedNodes(), KisNodeList(),
                 lastActiveNode, 0, m_image, false),
             KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
         applicator.applyCommand(new KisSetEmptyGlobalSelectionCommand(m_image),
                                 KisStrokeJobData::SEQUENTIAL,
                                 KisStrokeJobData::EXCLUSIVE);
         applicator.applyCommand(new KisLayerUtils::SelectGlobalSelectionMask(m_image),
                                 KisStrokeJobData::SEQUENTIAL,
                                 KisStrokeJobData::EXCLUSIVE);
 
         applicator.end();
     } else if (!showSelections &&
                globalSelectionMask &&
                globalSelectionMask->selection()->selectedRect().isEmpty()) {
 
         KisProcessingApplicator applicator(m_image, 0,
                                            KisProcessingApplicator::NONE,
                                            KisImageSignalVector() << ModifiedSignal,
                                            kundo2_i18n("Cancel Quick Selection Mask"));
         applicator.applyCommand(new KisSetGlobalSelectionCommand(m_image, 0), KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
         applicator.end();
     }
 
 }
 
 void LayerBox::selectionChanged(const QModelIndexList selection)
 {
     if (!m_nodeManager) return;
 
     /**
      * When the user clears the extended selection by clicking on the
      * empty area of the docker, the selection should be reset on to
      * the active layer, which might be even unselected(!).
      */
     if (selection.isEmpty() && m_nodeManager->activeNode()) {
         QModelIndex selectedIndex =
                 m_filteringModel->indexFromNode(m_nodeManager->activeNode());
 
         m_wdgLayerBox->listLayers->selectionModel()->
                 setCurrentIndex(selectedIndex, QItemSelectionModel::ClearAndSelect);
         return;
     }
 
     QList<KisNodeSP> selectedNodes;
     Q_FOREACH (const QModelIndex &idx, selection) {
         selectedNodes << m_filteringModel->nodeFromIndex(idx);
     }
 
     m_nodeManager->slotSetSelectedNodes(selectedNodes);
     updateUI();
 }
 
 void LayerBox::slotAboutToRemoveRows(const QModelIndex &parent, int start, int end)
 {
     /**
      * Qt has changed its behavior when deleting an item. Previously
      * the selection priority was on the next item in the list, and
      * now it has shanged to the previous item. Here we just adjust
      * the selected item after the node removal. Please take care that
      * this method overrides what was done by the corresponding method
      * of QItemSelectionModel, which *has already done* its work. That
      * is why we use (start - 1) and (end + 1) in the activation
      * condition.
      *
      * See bug: https://bugs.kde.org/show_bug.cgi?id=345601
      */
 
     QModelIndex currentIndex = m_wdgLayerBox->listLayers->currentIndex();
     QAbstractItemModel *model = m_filteringModel;
 
     if (currentIndex.isValid() && parent == currentIndex.parent()
             && currentIndex.row() >= start - 1 && currentIndex.row() <= end + 1) {
         QModelIndex old = currentIndex;
         if (model && end < model->rowCount(parent) - 1) // there are rows left below the change
             currentIndex = model->index(end + 1, old.column(), parent);
         else if (start > 0) // there are rows left above the change
             currentIndex = model->index(start - 1, old.column(), parent);
         else // there are no rows left in the table
             currentIndex = QModelIndex();
 
         if (currentIndex.isValid() && currentIndex != old) {
             m_wdgLayerBox->listLayers->setCurrentIndex(currentIndex);
         }
     }
 }
 
 void LayerBox::slotNodeManagerChangedSelection(const KisNodeList &nodes)
 {
     if (!m_nodeManager) return;
 
     QModelIndexList newSelection;
     Q_FOREACH(KisNodeSP node, nodes) {
         newSelection << m_filteringModel->indexFromNode(node);
     }
 
     QItemSelectionModel *model = m_wdgLayerBox->listLayers->selectionModel();
 
     if (KritaUtils::compareListsUnordered(newSelection, model->selectedIndexes())) {
         return;
     }
 
     QItemSelection selection;
     Q_FOREACH(const QModelIndex &idx, newSelection) {
         selection.select(idx, idx);
     }
 
     model->select(selection, QItemSelectionModel::ClearAndSelect);
 }
 
 void LayerBox::updateThumbnail()
 {
     m_wdgLayerBox->listLayers->updateNode(m_wdgLayerBox->listLayers->currentIndex());
 }
 
 void LayerBox::slotRenameCurrentNode()
 {
     m_wdgLayerBox->listLayers->edit(m_wdgLayerBox->listLayers->currentIndex());
 }
 
 void LayerBox::slotColorLabelChanged(int label)
 {
     KisNodeList nodes = m_nodeManager->selectedNodes();
 
     Q_FOREACH(KisNodeSP node, nodes) {
         auto applyLabelFunc =
                 [label](KisNodeSP node) {
             node->setColorLabelIndex(label);
         };
 
         KisLayerUtils::recursiveApplyNodes(node, applyLabelFunc);
     }
 }
 
 void LayerBox::updateAvailableLabels()
 {
     if (!m_image) return;
     m_wdgLayerBox->cmbFilter->updateAvailableLabels(m_image->root());
 }
 
 void LayerBox::updateLayerFiltering()
 {
     m_filteringModel->setAcceptedLabels(m_wdgLayerBox->cmbFilter->selectedColors());
 }
 
 void LayerBox::slotKeyframeChannelAdded(KisKeyframeChannel *channel)
 {
     if (channel->id() == KisKeyframeChannel::Opacity.id()) {
         watchOpacityChannel(channel);
     }
 }
 
 void LayerBox::watchOpacityChannel(KisKeyframeChannel *channel)
 {
     if (m_opacityChannel) {
         m_opacityChannel->disconnect(this);
     }
 
     m_opacityChannel = channel;
     if (m_opacityChannel) {
         connect(m_opacityChannel, SIGNAL(sigKeyframeAdded(KisKeyframeSP)), this, SLOT(slotOpacityKeyframeChanged(KisKeyframeSP)));
         connect(m_opacityChannel, SIGNAL(sigKeyframeRemoved(KisKeyframeSP)), this, SLOT(slotOpacityKeyframeChanged(KisKeyframeSP)));
         connect(m_opacityChannel, SIGNAL(sigKeyframeMoved(KisKeyframeSP)), this, SLOT(slotOpacityKeyframeMoved(KisKeyframeSP)));
         connect(m_opacityChannel, SIGNAL(sigKeyframeChanged(KisKeyframeSP)), this, SLOT(slotOpacityKeyframeChanged(KisKeyframeSP)));
     }
 }
 
 void LayerBox::slotOpacityKeyframeChanged(KisKeyframeSP keyframe)
 {
     Q_UNUSED(keyframe);
     if (m_blockOpacityUpdate) return;
     updateUI();
 }
 
 void LayerBox::slotOpacityKeyframeMoved(KisKeyframeSP keyframe, int fromTime)
 {
     Q_UNUSED(fromTime);
     slotOpacityKeyframeChanged(keyframe);
 }
 
 void LayerBox::slotImageTimeChanged(int time)
 {
     Q_UNUSED(time);
     updateUI();
 }
 
 void LayerBox::slotUpdateIcons() {
     m_wdgLayerBox->bnAdd->setIcon(KisIconUtils::loadIcon("addlayer"));
     m_wdgLayerBox->bnRaise->setIcon(KisIconUtils::loadIcon("arrowupblr"));
     m_wdgLayerBox->bnDelete->setIcon(KisIconUtils::loadIcon("deletelayer"));
     m_wdgLayerBox->bnLower->setIcon(KisIconUtils::loadIcon("arrowdown"));
     m_wdgLayerBox->bnProperties->setIcon(KisIconUtils::loadIcon("properties"));
     m_wdgLayerBox->bnDuplicate->setIcon(KisIconUtils::loadIcon("duplicatelayer"));
 
     // call child function about needing to update icons
     m_wdgLayerBox->listLayers->slotUpdateIcons();
 }
 
 void LayerBox::slotUpdateThumbnailIconSize()
 {
     KisConfig cfg(false);
     cfg.setLayerThumbnailSize(thumbnailSizeSlider->value());
 
     // this is a hack to force the layers list to update its display and
     // re-layout all the layers with the new thumbnail size
     resize(this->width()+1, this->height()+1);
     resize(this->width()-1, this->height()-1);
 }
 
 
 #include "moc_LayerBox.cpp"
diff --git a/plugins/dockers/smallcolorselector/smallcolorselector.cc b/plugins/dockers/smallcolorselector/smallcolorselector.cc
index 1d5e4ccaa0..6be8462d37 100644
--- a/plugins/dockers/smallcolorselector/smallcolorselector.cc
+++ b/plugins/dockers/smallcolorselector/smallcolorselector.cc
@@ -1,70 +1,70 @@
 /*
  *  Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2 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 "smallcolorselector.h"
 
 
 #include <kpluginfactory.h>
 
 #include <KoDockFactoryBase.h>
 #include <KoDockRegistry.h>
 
 #include "smallcolorselector_dock.h"
 #include "opengl/kis_opengl.h"
 
 K_PLUGIN_FACTORY_WITH_JSON(SmallColorSelectorPluginFactory, "krita_smallcolorselector.json", registerPlugin<SmallColorSelectorPlugin>();)
 
 class SmallColorSelectorDockFactory : public KoDockFactoryBase
 {
 public:
     SmallColorSelectorDockFactory() {
     }
 
     QString id() const override {
         return QString("SmallColorSelector");
     }
 
     virtual Qt::DockWidgetArea defaultDockWidgetArea() const {
         return Qt::RightDockWidgetArea;
     }
 
     QDockWidget* createDockWidget() override {
         SmallColorSelectorDock * dockWidget = new SmallColorSelectorDock();
         dockWidget->setObjectName(id());
 
         return dockWidget;
     }
 
     DockPosition defaultDockPosition() const override {
         return DockRight;
     }
 };
 
 SmallColorSelectorPlugin::SmallColorSelectorPlugin(QObject *parent, const QVariantList &)
         : QObject(parent)
 {
-    if (KisOpenGL::hasOpenGL3()) {
+    if (KisOpenGL::hasOpenGL3() || KisOpenGL::hasOpenGLES()) {
         KoDockRegistry::instance()->add(new SmallColorSelectorDockFactory());
     }
 }
 
 SmallColorSelectorPlugin::~SmallColorSelectorPlugin()
 {
 }
 
 #include "smallcolorselector.moc"
diff --git a/plugins/extensions/resourcemanager/dlg_bundle_manager.cpp b/plugins/extensions/resourcemanager/dlg_bundle_manager.cpp
index 26cd6781a9..bdf4ddfca0 100644
--- a/plugins/extensions/resourcemanager/dlg_bundle_manager.cpp
+++ b/plugins/extensions/resourcemanager/dlg_bundle_manager.cpp
@@ -1,425 +1,433 @@
 /*
  *  Copyright (c) 2014 Victor Lafon metabolic.ewilan@hotmail.fr
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 #include "dlg_bundle_manager.h"
 #include "ui_wdgdlgbundlemanager.h"
 
 #include "resourcemanager.h"
 #include "dlg_create_bundle.h"
 
 #include <QListWidget>
 #include <QTreeWidget>
 #include <QListWidgetItem>
 #include <QPainter>
 #include <QPixmap>
 #include <QMessageBox>
 
 #include <kis_icon.h>
 #include "kis_action.h"
 #include <KisResourceServerProvider.h>
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 
 #define ICON_SIZE 48
 
 DlgBundleManager::DlgBundleManager(ResourceManager *resourceManager, KisActionManager* actionMgr, QWidget *parent)
     : KoDialog(parent)
     , m_page(new QWidget())
     , m_ui(new Ui::WdgDlgBundleManager)
     , m_currentBundle(0)
     , m_resourceManager(resourceManager)
 {
     setCaption(i18n("Manage Resource Bundles"));
     m_ui->setupUi(m_page);
     setMainWidget(m_page);
     resize(m_page->sizeHint());
     setButtons(Ok | Cancel);
     setDefaultButton(Ok);
 
     m_ui->listActive->setIconSize(QSize(ICON_SIZE, ICON_SIZE));
     m_ui->listActive->setSelectionMode(QAbstractItemView::SingleSelection);
     connect(m_ui->listActive, SIGNAL(currentItemChanged(QListWidgetItem*,QListWidgetItem*)), SLOT(itemSelected(QListWidgetItem*,QListWidgetItem*)));
     connect(m_ui->listActive, SIGNAL(itemClicked(QListWidgetItem*)), SLOT(itemSelected(QListWidgetItem*)));
 
     m_ui->listInactive->setIconSize(QSize(ICON_SIZE, ICON_SIZE));
     m_ui->listInactive->setSelectionMode(QAbstractItemView::SingleSelection);
     connect(m_ui->listInactive, SIGNAL(currentItemChanged(QListWidgetItem*,QListWidgetItem*)), SLOT(itemSelected(QListWidgetItem*,QListWidgetItem*)));
     connect(m_ui->listInactive, SIGNAL(itemClicked(QListWidgetItem*)), SLOT(itemSelected(QListWidgetItem*)));
 
     m_ui->bnAdd->setIcon(KisIconUtils::loadIcon("arrow-right"));
     connect(m_ui->bnAdd, SIGNAL(clicked()), SLOT(addSelected()));
 
     m_ui->bnRemove->setIcon(KisIconUtils::loadIcon("arrow-left"));
     connect(m_ui->bnRemove, SIGNAL(clicked()), SLOT(removeSelected()));
 
     m_ui->listBundleContents->setHeaderLabel(i18n("Resource"));
     m_ui->listBundleContents->setSelectionMode(QAbstractItemView::NoSelection);
 
     m_actionManager = actionMgr;
 
     refreshListData();
 
     connect(m_ui->bnEditBundle, SIGNAL(clicked()), SLOT(editBundle()));
 
     connect(m_ui->bnImportBrushes, SIGNAL(clicked()), SLOT(slotImportResource()));
     connect(m_ui->bnImportGradients, SIGNAL(clicked()), SLOT(slotImportResource()));
     connect(m_ui->bnImportPalettes, SIGNAL(clicked()), SLOT(slotImportResource()));
     connect(m_ui->bnImportPatterns, SIGNAL(clicked()), SLOT(slotImportResource()));
     connect(m_ui->bnImportPresets, SIGNAL(clicked()), SLOT(slotImportResource()));
     connect(m_ui->bnImportWorkspaces, SIGNAL(clicked()), SLOT(slotImportResource()));
     connect(m_ui->bnImportBundles, SIGNAL(clicked()), SLOT(slotImportResource()));
 
 
     connect(m_ui->createBundleButton, SIGNAL(clicked()), SLOT(slotCreateBundle()));
     connect(m_ui->deleteBackupFilesButton, SIGNAL(clicked()), SLOT(slotDeleteBackupFiles()));
     connect(m_ui->openResourceFolderButton, SIGNAL(clicked()), SLOT(slotOpenResourceFolder()));
 
 }
 
 
 void DlgBundleManager::refreshListData()
 {
     KoResourceServer<KisResourceBundle> *bundleServer = KisResourceBundleServerProvider::instance()->resourceBundleServer();
 
     m_ui->listInactive->clear();
     m_ui->listActive->clear();
 
     Q_FOREACH (const QString &f, bundleServer->blackListedFiles()) {
         KisResourceBundle *bundle = new KisResourceBundle(f);
         bundle->load();
         if (bundle->valid()) {
             bundle->setInstalled(false);
             m_blacklistedBundles[f] = bundle;
         }
     }
     fillListWidget(m_blacklistedBundles.values(), m_ui->listInactive);
 
     Q_FOREACH (KisResourceBundle *bundle, bundleServer->resources()) {
         if (bundle->valid()) {
             m_activeBundles[bundle->filename()] = bundle;
         }
     }
     fillListWidget(m_activeBundles.values(), m_ui->listActive);
 }
 
 void DlgBundleManager::accept()
 {
     KoResourceServer<KisResourceBundle> *bundleServer = KisResourceBundleServerProvider::instance()->resourceBundleServer();
 
     for (int i = 0; i < m_ui->listActive->count(); ++i) {
         QListWidgetItem *item = m_ui->listActive->item(i);
         QByteArray ba = item->data(Qt::UserRole).toByteArray();
         QString name = item->text();
         KisResourceBundle *bundle = bundleServer->resourceByMD5(ba);
         QMessageBox bundleFeedback;
         bundleFeedback.setIcon(QMessageBox::Warning);
         QString feedback = "bundlefeedback";
 
         if (!bundle) {
             // Get it from the blacklisted bundles
             Q_FOREACH (KisResourceBundle *b2, m_blacklistedBundles.values()) {
                 if (b2->md5() == ba) {
                     bundle = b2;
                     break;
                 }
             }
         }
 
         if (bundle) {
             bool isKrita3Bundle = false;
             if (bundle->filename().endsWith("Krita_3_Default_Resources.bundle")) {
                 isKrita3Bundle = true;
                 KConfigGroup group = KSharedConfig::openConfig()->group("BundleHack");
                 group.writeEntry("HideKrita3Bundle", false);
             }
             else {
                 if (!bundle->isInstalled()) {
                     bundle->install();
                     //this removes the bundle from the blacklist and add it to the server without saving or putting it in front//
                     if (!bundleServer->addResource(bundle, false, false)){
 
                         feedback = i18n("Couldn't add bundle \"%1\" to resource server", name);
                         bundleFeedback.setText(feedback);
                         bundleFeedback.exec();
                     }
                     if (!isKrita3Bundle) {
                         if (!bundleServer->removeFromBlacklist(bundle)) {
                             feedback = i18n("Couldn't remove bundle \"%1\" from blacklist", name);
                             bundleFeedback.setText(feedback);
                             bundleFeedback.exec();
                         }
                     }
                 }
                 else {
                     if (!isKrita3Bundle) {
                         bundleServer->removeFromBlacklist(bundle);
                     }
                     //let's assume that bundles that exist and are installed have to be removed from the blacklist, and if they were already this returns false, so that's not a problem.
                 }
             }
         }
         else{
             QString feedback = i18n("Bundle \"%1\" doesn't exist!", name);
             bundleFeedback.setText(feedback);
             bundleFeedback.exec();
 
         }
     }
 
     for (int i = 0; i < m_ui->listInactive->count(); ++i) {
         QListWidgetItem *item = m_ui->listInactive->item(i);
         QByteArray ba = item->data(Qt::UserRole).toByteArray();
         KisResourceBundle *bundle = bundleServer->resourceByMD5(ba);
         bool isKrits3Bundle = false;
         if (bundle) {
             if (bundle->filename().contains("Krita_3_Default_Resources.bundle")) {
                 isKrits3Bundle = true;
                 KConfigGroup group = KSharedConfig::openConfig()->group("BundleHack");
                 group.writeEntry("HideKrita3Bundle", true);
             }
             if (bundle->isInstalled()) {
                 bundle->uninstall();
                 if (!isKrits3Bundle) {
                     bundleServer->removeResourceAndBlacklist(bundle);
                 }
             }
         }
     }
 
 
     KoDialog::accept();
 }
 
 void DlgBundleManager::addSelected()
 {
     Q_FOREACH (QListWidgetItem *item, m_ui->listActive->selectedItems()) {
         m_ui->listInactive->addItem(m_ui->listActive->takeItem(m_ui->listActive->row(item)));
     }
 
 }
 
 void DlgBundleManager::removeSelected()
 {
     Q_FOREACH (QListWidgetItem *item, m_ui->listInactive->selectedItems()) {
         m_ui->listActive->addItem(m_ui->listInactive->takeItem(m_ui->listInactive->row(item)));
     }
 }
 
 void DlgBundleManager::itemSelected(QListWidgetItem *current, QListWidgetItem *)
 {
     if (!current) {
         m_ui->lblName->clear();
         m_ui->lblAuthor->clear();
         m_ui->lblEmail->clear();
         m_ui->lblLicense->clear();
         m_ui->lblWebsite->clear();
         m_ui->lblDescription->clear();
         m_ui->lblCreated->clear();
         m_ui->lblUpdated->clear();
         m_ui->lblPreview->setPixmap(QPixmap::fromImage(QImage()));
         m_ui->listBundleContents->clear();
         m_ui->bnEditBundle->setEnabled(false);
         m_currentBundle = 0;
     }
     else {
 
         QByteArray ba = current->data(Qt::UserRole).toByteArray();
         KoResourceServer<KisResourceBundle> *bundleServer = KisResourceBundleServerProvider::instance()->resourceBundleServer();
         KisResourceBundle *bundle = bundleServer->resourceByMD5(ba);
 
         if (!bundle) {
             // Get it from the blacklisted bundles
             Q_FOREACH (KisResourceBundle *b2, m_blacklistedBundles.values()) {
                 if (b2->md5() == ba) {
                     bundle = b2;
                     break;
                 }
             }
         }
 
 
         if (bundle) {
             QFontMetrics metrics(this->font());
 
             m_currentBundle = bundle;
             m_ui->bnEditBundle->setEnabled(true);
 
             m_ui->lblName->setText(bundle->name());
             m_ui->lblAuthor->setText(metrics.elidedText(bundle->getMeta("author"), Qt::ElideRight, m_ui->lblAuthor->width()));
             m_ui->lblAuthor->setToolTip(bundle->getMeta("author"));
             m_ui->lblEmail->setText(metrics.elidedText(bundle->getMeta("email"), Qt::ElideRight, m_ui->lblEmail->width()));
             m_ui->lblEmail->setToolTip(bundle->getMeta("email"));
             m_ui->lblLicense->setText(metrics.elidedText(bundle->getMeta("license"), Qt::ElideRight, m_ui->lblLicense->width()));
             m_ui->lblLicense->setToolTip(bundle->getMeta("license"));
             m_ui->lblWebsite->setText(metrics.elidedText(bundle->getMeta("website"), Qt::ElideRight, m_ui->lblWebsite->width()));
             m_ui->lblWebsite->setToolTip(bundle->getMeta("website"));
             m_ui->lblDescription->setPlainText(bundle->getMeta("description"));
-            m_ui->lblCreated->setText(bundle->getMeta("created"));
-            m_ui->lblUpdated->setText(bundle->getMeta("updated"));
+            if (QDateTime::fromString(bundle->getMeta("created"), Qt::ISODate).isValid()) {
+                m_ui->lblCreated->setText(QDateTime::fromString(bundle->getMeta("created"), Qt::ISODate).toLocalTime().toString(Qt::DefaultLocaleShortDate));
+            } else {
+                m_ui->lblCreated->setText(QDate::fromString(bundle->getMeta("created"), "dd/MM/yyyy").toString(Qt::DefaultLocaleShortDate));
+            }
+            if (QDateTime::fromString(bundle->getMeta("updated"), Qt::ISODate).isValid()) {
+                m_ui->lblUpdated->setText(QDateTime::fromString(bundle->getMeta("updated"), Qt::ISODate).toLocalTime().toString(Qt::DefaultLocaleShortDate));
+            } else {
+                m_ui->lblUpdated->setText(QDate::fromString(bundle->getMeta("updated"), "dd/MM/yyyy").toString(Qt::DefaultLocaleShortDate));
+            }
             m_ui->lblPreview->setPixmap(QPixmap::fromImage(bundle->image().scaled(128, 128, Qt::KeepAspectRatio, Qt::SmoothTransformation)));
             m_ui->listBundleContents->clear();
 
             Q_FOREACH (const QString & resType, bundle->resourceTypes()) {
 
                 QTreeWidgetItem *toplevel = new QTreeWidgetItem();
                 if (resType == "gradients") {
                     toplevel->setText(0, i18n("Gradients"));
                 }
                 else if (resType  == "patterns") {
                     toplevel->setText(0, i18n("Patterns"));
                 }
                 else if (resType  == "brushes") {
                     toplevel->setText(0, i18n("Brushes"));
                 }
                 else if (resType  == "palettes") {
                     toplevel->setText(0, i18n("Palettes"));
                 }
                 else if (resType  == "workspaces") {
                     toplevel->setText(0, i18n("Workspaces"));
                 }
                 else if (resType  == "paintoppresets") {
                     toplevel->setText(0, i18n("Brush Presets"));
                 }
                 else if (resType  == "gamutmasks") {
                     toplevel->setText(0, i18n("Gamut Masks"));
                 }
 
 
                 m_ui->listBundleContents->addTopLevelItem(toplevel);
 
                 Q_FOREACH (const KoResource *res, bundle->resources(resType)) {
                     if (res) {
                         QTreeWidgetItem *i = new QTreeWidgetItem();
                         i->setIcon(0, QIcon(QPixmap::fromImage(res->image())));
                         i->setText(0, res->name());
                         toplevel->addChild(i);
                     }
                 }
             }
         }
         else {
             m_currentBundle = 0;
         }
     }
 }
 
 void DlgBundleManager::itemSelected(QListWidgetItem *current)
 {
     itemSelected(current, 0);
 }
 
 void DlgBundleManager::editBundle()
 {
     if (m_currentBundle) {
         DlgCreateBundle dlg(m_currentBundle);
         m_activeBundles.remove(m_currentBundle->filename());
         m_currentBundle = 0;
         if (dlg.exec() != QDialog::Accepted) {
             return;
         }
         m_currentBundle = m_resourceManager->saveBundle(dlg);
         refreshListData();
     }
 }
 
 void DlgBundleManager::fillListWidget(QList<KisResourceBundle *> bundles, QListWidget *w)
 {
     w->setIconSize(QSize(ICON_SIZE, ICON_SIZE));
     w->setSelectionMode(QAbstractItemView::MultiSelection);
 
     Q_FOREACH (KisResourceBundle *bundle, bundles) {
         QPixmap pixmap(ICON_SIZE, ICON_SIZE);
         pixmap.fill(Qt::gray);
         if (!bundle->image().isNull()) {
             QImage scaled = bundle->image().scaled(ICON_SIZE, ICON_SIZE, Qt::KeepAspectRatio, Qt::SmoothTransformation);
             int x = (ICON_SIZE - scaled.width()) / 2;
             int y = (ICON_SIZE - scaled.height()) / 2;
             QPainter gc(&pixmap);
             gc.drawImage(x, y, scaled);
             gc.end();
         }
 
         QListWidgetItem *item = new QListWidgetItem(pixmap, bundle->name());
         item->setData(Qt::UserRole, bundle->md5());
         w->addItem(item);
     }
 }
 
 
 void DlgBundleManager::slotImportResource()
 {
     if (m_actionManager) {
         QObject *button = sender();
         QString buttonName = button->objectName();
         KisAction *action = 0;
         if (buttonName == "bnImportBundles") {
             action = m_actionManager->actionByName("import_bundles");
         }
         else if (buttonName == "bnImportBrushes") {
             action = m_actionManager->actionByName("import_brushes");
         }
         else if (buttonName == "bnImportGradients") {
             action = m_actionManager->actionByName("import_gradients");
         }
         else if (buttonName == "bnImportPalettes") {
             action = m_actionManager->actionByName("import_palettes");
         }
         else if (buttonName == "bnImportPatterns") {
             action = m_actionManager->actionByName("import_patterns");
         }
         else if (buttonName == "bnImportPresets") {
             action = m_actionManager->actionByName("import_presets");
         }
         else if (buttonName == "bnImportWorkspaces") {
             action = m_actionManager->actionByName("import_workspaces");
         }
         else {
             warnUI << "Unhandled bundle manager import button " << buttonName;
             return;
         }
 
         action->trigger();
         refreshListData();
     }
 }
 
 void DlgBundleManager::slotCreateBundle() {
 
     if (m_actionManager) {
         KisAction *action = m_actionManager->actionByName("create_bundle");
         action->trigger();
         refreshListData();
     }
 }
 
 void DlgBundleManager::slotDeleteBackupFiles() {
 
     if (m_actionManager) {
         KisAction *action = m_actionManager->actionByName("edit_blacklist_cleanup");
         action->trigger();
     }
 }
 
 void DlgBundleManager::slotOpenResourceFolder() {
 
     if (m_actionManager) {
         KisAction *action = m_actionManager->actionByName("open_resources_directory");
         action->trigger();
     }
 }
 
diff --git a/plugins/extensions/resourcemanager/resourcemanager.cpp b/plugins/extensions/resourcemanager/resourcemanager.cpp
index e6d0423a8e..8e1d4d0753 100644
--- a/plugins/extensions/resourcemanager/resourcemanager.cpp
+++ b/plugins/extensions/resourcemanager/resourcemanager.cpp
@@ -1,334 +1,334 @@
 /*
  * resourcemanager.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 "resourcemanager.h"
 
 #include <QDir>
 #include <QFileInfo>
 #include <QTimer>
 #include <QThread>
 
 #include <QMessageBox>
 #include <QGlobalStatic>
 #include <QStandardPaths>
 
 #include <klocalizedstring.h>
 #include <KoResourcePaths.h>
 #include <kpluginfactory.h>
 
 #include <KoFileDialog.h>
 #include <resources/KoResource.h>
 #include <KoResourceServer.h>
 #include <KoResourceServerProvider.h>
 
 #include <kis_debug.h>
 #include <kis_action.h>
 #include <KisViewManager.h>
 #include <KisResourceServerProvider.h>
 #include <kis_workspace_resource.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <kis_brush_server.h>
 #include <kis_paintop_settings.h>
 #include "dlg_bundle_manager.h"
 #include "dlg_create_bundle.h"
 #include <KisPaintopSettingsIds.h>
 #include "krita_container_utils.h"
 
 class ResourceManager::Private {
 
 public:
 
     Private()
     {
         brushServer = KisBrushServer::instance()->brushServer();
         paintopServer = KisResourceServerProvider::instance()->paintOpPresetServer();
         gradientServer = KoResourceServerProvider::instance()->gradientServer();
         patternServer = KoResourceServerProvider::instance()->patternServer();
         paletteServer = KoResourceServerProvider::instance()->paletteServer();
         workspaceServer = KisResourceServerProvider::instance()->workspaceServer();
         gamutMaskServer = KoResourceServerProvider::instance()->gamutMaskServer();
     }
 
     KisBrushResourceServer* brushServer;
     KisPaintOpPresetResourceServer * paintopServer;
     KoResourceServer<KoAbstractGradient>* gradientServer;
     KoResourceServer<KoPattern> *patternServer;
     KoResourceServer<KoColorSet>* paletteServer;
     KoResourceServer<KisWorkspaceResource>* workspaceServer;
     KoResourceServer<KoGamutMask>* gamutMaskServer;
 };
 
 K_PLUGIN_FACTORY_WITH_JSON(ResourceManagerFactory, "kritaresourcemanager.json", registerPlugin<ResourceManager>();)
 
 ResourceManager::ResourceManager(QObject *parent, const QVariantList &)
     : KisActionPlugin(parent)
     , d(new Private())
 {
     KisAction *action = new KisAction(i18n("Import Bundles..."), this);
     addAction("import_bundles", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotImportBundles()));
 
     action = new KisAction(i18n("Import Brushes..."), this);
     addAction("import_brushes", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotImportBrushes()));
 
     action = new KisAction(i18n("Import Gradients..."), this);
     addAction("import_gradients", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotImportGradients()));
 
     action = new KisAction(i18n("Import Palettes..."), this);
     addAction("import_palettes", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotImportPalettes()));
 
     action = new KisAction(i18n("Import Patterns..."), this);
     addAction("import_patterns", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotImportPatterns()));
 
     action = new KisAction(i18n("Import Presets..."), this);
     addAction("import_presets", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotImportPresets()));
 
     action = new KisAction(i18n("Import Workspaces..."), this);
     addAction("import_workspaces", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotImportWorkspaces()));
 
     action = new KisAction(i18n("Create Resource Bundle..."), this);
     addAction("create_bundle", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotCreateBundle()));
 
     action = new KisAction(i18n("Manage Resources..."), this);
     addAction("manage_bundles", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotManageBundles()));
 
 }
 
 ResourceManager::~ResourceManager()
 {
 }
 
 void ResourceManager::slotCreateBundle()
 {
     DlgCreateBundle dlgCreateBundle;
     if (dlgCreateBundle.exec() != QDialog::Accepted) {
         return;
     }
     saveBundle(dlgCreateBundle);
 }
 
 KisResourceBundle *ResourceManager::saveBundle(const DlgCreateBundle &dlgCreateBundle)
 {
     QString bundlePath =  dlgCreateBundle.saveLocation() + "/" + dlgCreateBundle.bundleName() + ".bundle";
 
     KisResourceBundle *newBundle = new KisResourceBundle(bundlePath);
 
     newBundle->addMeta("name", dlgCreateBundle.bundleName());
     newBundle->addMeta("author", dlgCreateBundle.authorName());
     newBundle->addMeta("email", dlgCreateBundle.email());
     newBundle->addMeta("license", dlgCreateBundle.license());
     newBundle->addMeta("website", dlgCreateBundle.website());
     newBundle->addMeta("description", dlgCreateBundle.description());
     newBundle->setThumbnail(dlgCreateBundle.previewImage());
 
     QStringList res = dlgCreateBundle.selectedBrushes();
     Q_FOREACH (const QString &r, res) {
         KoResource *res = d->brushServer->resourceByFilename(r).data();
         newBundle->addResource("kis_brushes", res->filename(), d->brushServer->assignedTagsList(res), res->md5());
     }
 
     res = dlgCreateBundle.selectedGradients();
     Q_FOREACH (const QString &r, res) {
         KoResource *res = d->gradientServer->resourceByFilename(r);
         newBundle->addResource("ko_gradients", res->filename(), d->gradientServer->assignedTagsList(res), res->md5());
     }
 
     res = dlgCreateBundle.selectedPalettes();
     Q_FOREACH (const QString &r, res) {
         KoResource *res = d->paletteServer->resourceByFilename(r);
         newBundle->addResource("ko_palettes", res->filename(), d->paletteServer->assignedTagsList(res), res->md5());
     }
 
     res = dlgCreateBundle.selectedPatterns();
     Q_FOREACH (const QString &r, res) {
         KoResource *res = d->patternServer->resourceByFilename(r);
         newBundle->addResource("ko_patterns", res->filename(), d->patternServer->assignedTagsList(res), res->md5());
     }
 
     res = dlgCreateBundle.selectedPresets();
     Q_FOREACH (const QString &r, res) {
         KisPaintOpPresetSP preset = d->paintopServer->resourceByFilename(r);
         KoResource *res = preset.data();
         newBundle->addResource("kis_paintoppresets", res->filename(), d->paintopServer->assignedTagsList(res), res->md5());
         KisPaintOpSettingsSP settings = preset->settings();
 
         QStringList requiredFiles = settings->getStringList(KisPaintOpUtils::RequiredBrushFilesListTag);
         requiredFiles << settings->getString(KisPaintOpUtils::RequiredBrushFileTag);
         KritaUtils::makeContainerUnique(requiredFiles);
 
         Q_FOREACH (const QString &brushFile, requiredFiles) {
             KisBrush *brush = d->brushServer->resourceByFilename(brushFile).data();
             if (brush) {
                 newBundle->addResource("kis_brushes", brushFile, d->brushServer->assignedTagsList(brush), brush->md5());
             } else {
                 qWarning() << "There is no brush with name" << brushFile;
             }
         }
     }
 
     res = dlgCreateBundle.selectedWorkspaces();
     Q_FOREACH (const QString &r, res) {
         KoResource *res = d->workspaceServer->resourceByFilename(r);
         newBundle->addResource("kis_workspaces", res->filename(), d->workspaceServer->assignedTagsList(res), res->md5());
     }
 
     res = dlgCreateBundle.selectedGamutMasks();
     Q_FOREACH (const QString &r, res) {
         KoResource *res = d->gamutMaskServer->resourceByFilename(r);
         newBundle->addResource("ko_gamutmasks", res->filename(), d->gamutMaskServer->assignedTagsList(res), res->md5());
     }
 
     newBundle->addMeta("fileName", bundlePath);
-    newBundle->addMeta("created", QDate::currentDate().toString("dd/MM/yyyy"));
+    newBundle->addMeta("created", QDateTime::currentDateTime().toOffsetFromUtc(0).toString(Qt::ISODate));
 
     if (!newBundle->save()) {
         QMessageBox::critical(viewManager()->mainWindow(), i18nc("@title:window", "Krita"), i18n("Could not create the new bundle."));
     }
     else {
         newBundle->setValid(true);
         if (QDir(KisResourceBundleServerProvider::instance()->resourceBundleServer()->saveLocation()) != QDir(QFileInfo(bundlePath).path())) {
             newBundle->setFilename(KisResourceBundleServerProvider::instance()->resourceBundleServer()->saveLocation() + "/" + dlgCreateBundle.bundleName() + ".bundle");
         }
         if (KisResourceBundleServerProvider::instance()->resourceBundleServer()->resourceByName(newBundle->name())) {
             KisResourceBundleServerProvider::instance()->resourceBundleServer()->removeResourceFromServer(
                         KisResourceBundleServerProvider::instance()->resourceBundleServer()->resourceByName(newBundle->name()));
         }
         KisResourceBundleServerProvider::instance()->resourceBundleServer()->addResource(newBundle, true);
         newBundle->load();
     }
 
     return newBundle;
 }
 
 void ResourceManager::slotManageBundles()
 {
     DlgBundleManager* dlg = new DlgBundleManager(this, viewManager()->actionManager());
     if (dlg->exec() != QDialog::Accepted) {
         return;
     }
 }
 
 QStringList ResourceManager::importResources(const QString &title, const QStringList &mimes) const
 {
     KoFileDialog dialog(viewManager()->mainWindow(), KoFileDialog::OpenFiles, "krita_resources");
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::HomeLocation));
     dialog.setCaption(title);
     dialog.setMimeTypeFilters(mimes);
     return dialog.filenames();
 }
 
 void ResourceManager::slotImportBrushes()
 {
     QStringList resources = importResources(i18n("Import Brushes"), QStringList() << "image/x-gimp-brush"
                                    << "image/x-gimp-x-gimp-brush-animated"
                                    << "image/x-adobe-brushlibrary"
                                    << "image/png"
                                    << "image/svg+xml");
     Q_FOREACH (const QString &res, resources) {
         d->brushServer->importResourceFile(res);
     }
 }
 
 void ResourceManager::slotImportPresets()
 {
     QStringList resources = importResources(i18n("Import Presets"), QStringList() << "application/x-krita-paintoppreset");
     Q_FOREACH (const QString &res, resources) {
         d->paintopServer->importResourceFile(res);
     }
 }
 
 void ResourceManager::slotImportGradients()
 {
     QStringList resources = importResources(i18n("Import Gradients"), QStringList() << "image/svg+xml"
                                    << "application/x-gimp-gradient");
     Q_FOREACH (const QString &res, resources) {
         d->gradientServer->importResourceFile(res);
     }
 }
 
 void ResourceManager::slotImportBundles()
 {
     QStringList resources = importResources(i18n("Import Bundles"), QStringList() << "application/x-krita-bundle");
     Q_FOREACH (const QString &res, resources) {
         KisResourceBundle *bundle = KisResourceBundleServerProvider::instance()->resourceBundleServer()->createResource(res);
         bundle->load();
         if (bundle->valid()) {
             if (!bundle->install()) {
                 QMessageBox::warning(0, i18nc("@title:window", "Krita"), i18n("Could not install the resources for bundle %1.", res));
             }
         }
         else {
             QMessageBox::warning(0, i18nc("@title:window", "Krita"), i18n("Could not load bundle %1.", res));
         }
 
         QFileInfo fi(res);
         QString newFilename = KisResourceBundleServerProvider::instance()->resourceBundleServer()->saveLocation() + fi.completeBaseName() + bundle->defaultFileExtension();
         QFileInfo fileInfo(newFilename);
 
         int i = 1;
         while (fileInfo.exists()) {
             fileInfo.setFile(KisResourceBundleServerProvider::instance()->resourceBundleServer()->saveLocation() + fi.completeBaseName() + QString("%1").arg(i) + bundle->defaultFileExtension());
             i++;
         }
         bundle->setFilename(fileInfo.filePath());
         QFile::copy(res, newFilename);
         KisResourceBundleServerProvider::instance()->resourceBundleServer()->addResource(bundle, false);
     }
 }
 
 void ResourceManager::slotImportPatterns()
 {
     QStringList resources = importResources(i18n("Import Patterns"), QStringList() << "image/png"
                                    << "image/svg+xml"
                                    << "application/x-gimp-pattern"
                                    << "image/jpeg"
                                    << "image/tiff"
                                    << "image/bmp"
                                    << "image/xpg");
     Q_FOREACH (const QString &res, resources) {
         d->patternServer->importResourceFile(res);
     }
 }
 
 void ResourceManager::slotImportPalettes()
 {
     QStringList resources = importResources(i18n("Import Palettes"), QStringList() << "image/x-gimp-color-palette");
     Q_FOREACH (const QString &res, resources) {
         d->paletteServer->importResourceFile(res);
     }
 }
 
 void ResourceManager::slotImportWorkspaces()
 {
     QStringList resources = importResources(i18n("Import Workspaces"), QStringList() << "application/x-krita-workspace");
     Q_FOREACH (const QString &res, resources) {
         d->workspaceServer->importResourceFile(res);
     }
 }
 
 #include "resourcemanager.moc"
diff --git a/plugins/impex/brush/krita_brush.desktop b/plugins/impex/brush/krita_brush.desktop
index 0f48da01e8..6557938577 100644
--- a/plugins/impex/brush/krita_brush.desktop
+++ b/plugins/impex/brush/krita_brush.desktop
@@ -1,74 +1,74 @@
 [Desktop Entry]
 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
 Exec=krita %F
 MimeType=image/x-gimp-brush;
 Type=Application
-Icon=calligrakrita
+Icon=krita
 Categories=Qt;KDE;Office;Graphics;
 StartupNotify=true
 X-DBUS-StartupType=Multi
 X-DBUS-ServiceName=org.krita.krita
 NoDisplay=true
diff --git a/plugins/impex/csv/krita_csv.desktop b/plugins/impex/csv/krita_csv.desktop
index b818e5555e..c29e8914a1 100644
--- a/plugins/impex/csv/krita_csv.desktop
+++ b/plugins/impex/csv/krita_csv.desktop
@@ -1,72 +1,72 @@
 [Desktop Entry]
 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
 Exec=krita %F
 MimeType=text/csv;
 Type=Application
-Icon=calligrakrita
+Icon=krita
 Categories=Qt;KDE;Office;Graphics;
 StartupNotify=true
 NoDisplay=true
diff --git a/plugins/impex/exr/krita_exr.desktop b/plugins/impex/exr/krita_exr.desktop
index d0637c6ccc..52600f6f3c 100644
--- a/plugins/impex/exr/krita_exr.desktop
+++ b/plugins/impex/exr/krita_exr.desktop
@@ -1,126 +1,126 @@
 [Desktop Entry]
 Categories=Qt;KDE;Office;Graphics;
 Exec=krita %F
 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[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[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]=繪圖與影像處理的應用程式
-Icon=calligrakrita
+Icon=krita
 MimeType=image/exr;
 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
 StartupNotify=true
 Terminal=false
 Type=Application
 X-KDE-SubstituteUID=false
 X-KDE-Username=
 NoDisplay=true
diff --git a/plugins/impex/gif/krita_gif.desktop b/plugins/impex/gif/krita_gif.desktop
index 970e7e8e7a..61b503b34c 100644
--- a/plugins/impex/gif/krita_gif.desktop
+++ b/plugins/impex/gif/krita_gif.desktop
@@ -1,72 +1,72 @@
 [Desktop Entry]
 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
 Exec=krita %F
 MimeType=image/gif;
 Type=Application
-Icon=calligrakrita
+Icon=krita
 Categories=Qt;KDE;Office;Graphics;
 StartupNotify=true
 NoDisplay=true
diff --git a/plugins/impex/gif/qgiflibhandler.cpp b/plugins/impex/gif/qgiflibhandler.cpp
index ed3f8227ca..fec916c424 100644
--- a/plugins/impex/gif/qgiflibhandler.cpp
+++ b/plugins/impex/gif/qgiflibhandler.cpp
@@ -1,368 +1,367 @@
 /*
  * Copyright (C) 2009 Shawn T. Rutledge (shawn.t.rutledge@gmail.com)
  * Copyright (c) 2018 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
  *
  */
 #include "qgiflibhandler.h"
 #include <QDebug>
 #include <QVariant>
 #include <gif_lib.h>
 #include <string.h>		// memset
 #include <QPainter>
 
 extern int _GifError;
 
 static const int InterlacedOffset[] = { 0, 4, 2, 1 };	/* The way Interlaced image should */
 static const int InterlacedJumps[] = { 8, 8, 4, 2 };	/* be read - offsets and jumps... */
 
 int doOutput(GifFileType* gif, const GifByteType * data, int i)
 {
     QIODevice* out = (QIODevice*)gif->UserData;
     //	qDebug("given %d bytes to write; device is writeable? %d", i, out->isWritable());
     return out->write((const char*)data, i);
 }
 
 int doInput(GifFileType* gif, GifByteType* data, int i)
 {
     QIODevice* in = (QIODevice*)gif->UserData;
     return in->read((char*)data, i);
 }
 
 QGIFLibHandler::QGIFLibHandler()
     : QImageIOHandler()
 {
 }
 
 bool QGIFLibHandler::canRead () const
 {
     if (canRead(device())) {
         setFormat("gif");
         return true;
     }
     return false;
 }
 
 bool QGIFLibHandler::read ( QImage * image )
 {
     // The contents of this function are based on gif2rgb.c, from the giflib source.
 //    qDebug("QGIFLibHandler::read into image with size %d x %d", image->size().width(), image->size().height());
 
     int err;
     GifFileType* gifFile = DGifOpen(device(), doInput, &err);
     if (!gifFile) {
         qWarning() << "Received error code" << err;
         return false;
     }
 //    qDebug("dimensions %d x %d", gifFile->SWidth, gifFile->SHeight);
 
     *image = QImage(gifFile->SWidth, gifFile->SHeight, QImage::Format_Indexed8);
 
     GifRecordType recordType;
     ColorMapObject* ColorMap;
 
-    int	i, row, imageNum = 0, topRow, leftCol, width, height;
+    int	i, row, imageNum = 0, topRow, width, height;
     int transColor = -1;
     do
     {
         DGifGetRecordType(gifFile, &recordType);
         switch (recordType)
         {
         case IMAGE_DESC_RECORD_TYPE:
             if (DGifGetImageDesc(gifFile) == GIF_ERROR)
             {
                 qWarning("QGIFLibHandler::read: error %d", gifFile->Error);
                 return false;
             }
             topRow = gifFile->Image.Top; /* Image Position relative to Screen. */
-            leftCol = gifFile->Image.Left;
             width = gifFile->Image.Width;
             height = gifFile->Image.Height;
-            //qDebug("Image %d at (%d, %d) [%dx%d]", ++imageNum, leftCol, topRow, width, height);
+            //qDebug("Image %d at (%d, %d) [%dx%d]", ++imageNum, gifFile->Image.Left, topRow, width, height);
             if (gifFile->Image.Left + width > gifFile->SWidth ||
                     gifFile->Image.Top + height > gifFile->SHeight)
             {
                 qWarning("Image %d is not confined to screen dimension, aborted.", imageNum);
                 return false;
             }
 
             // Pre-fill with background color
 //            qDebug("background color is at index %d", gifFile->SBackGroundColor);
             image->fill(gifFile->SBackGroundColor);
 
             // Now read the image data
             if (gifFile->Image.Interlace)
             {
                 /* Need to perform 4 passes on the images: */
                 for (i = 0; i < 4; i++)
                     for (row = topRow + InterlacedOffset[i]; row < topRow + height;
                          row += InterlacedJumps[i])
                     {
                         if (DGifGetLine(gifFile, image->scanLine(row), width) == GIF_ERROR)
                         {
                             qWarning("QGIFLibHandler::read: error %d", gifFile->Error);
                             return false;
                         }
                         //						else
                         //							qDebug("got row %d: %d %d %d %d %d %d %d %d ...", row,
                         //								image->scanLine(row)[0], image->scanLine(row)[1], image->scanLine(row)[2], image->scanLine(row)[3],
                         //								image->scanLine(row)[4], image->scanLine(row)[5], image->scanLine(row)[6], image->scanLine(row)[7]);
                     }
             }
             else
             {
                 for (row = 0; row < height; row++)
                 {
                     if (DGifGetLine(gifFile, image->scanLine(row), width) == GIF_ERROR)
                     {
                         qWarning("QGIFLibHandler::read: error %d", gifFile->Error);
                         return false;
                     }
                     //					else
                     //						qDebug("got row %d: %d %d %d %d %d %d %d %d ...", row,
                     //							image->scanLine(row)[0], image->scanLine(row)[1], image->scanLine(row)[2], image->scanLine(row)[3],
                     //							image->scanLine(row)[4], image->scanLine(row)[5], image->scanLine(row)[6], image->scanLine(row)[7]);
                 }
             }
             break;
         case EXTENSION_RECORD_TYPE:
         {
             int extCode;
             GifByteType* extData;
             /* Skip any extension blocks in file: */
             if (DGifGetExtension(gifFile, &extCode, &extData) == GIF_ERROR)
             {
                 qWarning("QGIFLibHandler::read: error %d", gifFile->Error);
                 return false;
             }
             while (extData != NULL)
             {
                 int len = extData[0];
                 switch (extCode)
                 {
                 case GRAPHICS_EXT_FUNC_CODE:	// Graphics control extension
 //                    qDebug("graphics control: %x %x %x %x %x", extData[0], extData[1], extData[2], extData[3], extData[4]);
                     // Should be block size, packed fields, delay time,
                     // transparent color, block terminator
                     // see doc/gif89.txt in libgif source package
                     // If the trans bit is set in packed fields,
                     // then set the trans color to the one given
                     if (extData[1] & 0x01)
                     {
                         transColor = extData[3];
 //                        qDebug("transparent color is at index %d", transColor);
                         /// @todo is it correct to override default fill color?
                         //							image->fill(transColor);
                     }
                     break;
                 case COMMENT_EXT_FUNC_CODE:
                 {
                     QByteArray comment((char*)(extData + 1), len);
                     //							qDebug("comment of len %d: \"%s\"", len, comment.constData());
                     image->setText("Description", comment);
                 }
                     break;
                 case PLAINTEXT_EXT_FUNC_CODE:
                     break;
                 }
                 if (DGifGetExtensionNext(gifFile, &extData) == GIF_ERROR)
                 {
                     qWarning("QGIFLibHandler::read: error %d", gifFile->Error);
                     return false;
                 }
             }
         }
             break;
         case TERMINATE_RECORD_TYPE:
             break;
         default:
             break;
         }
     }
     while (recordType != TERMINATE_RECORD_TYPE);
 
     //	BackGround = gifFile->SBackGroundColor;
     ColorMap = (gifFile->Image.ColorMap
                 ? gifFile->Image.ColorMap
                 : gifFile->SColorMap);
     if (!ColorMap)
     {
         qWarning("QGIFLibHandler::read: Image does not have a colormap");
         return false;
     }
     int ccount = ColorMap->ColorCount;
     image->setColorCount(ccount);
     for (i = 0; i < ccount; ++i)
     {
         GifColorType gifColor = ColorMap->Colors[i];
         QRgb color = gifColor.Blue | (gifColor.Green << 8) | (gifColor.Red << 16);
         // If this is not the transparent color,
         // set the alpha to opaque.
         if (i != transColor)
             color |= 0xff << 24;
         //		qDebug("color %d: 0x%X", i, color);
         image->setColor(i, color);
     }
 
     return true;
 }
 
 bool QGIFLibHandler::canRead(QIODevice *device)
 {
     if (!device) {
         qWarning("QGIFLibHandler::canRead() called with no device");
         return false;
     }
 
     char head[6];
     if (device->peek(head, sizeof(head)) == sizeof(head))
         return qstrncmp(head, "GIF87a", 6) == 0
                 || qstrncmp(head, "GIF89a", 6) == 0;
     return false;
 }
 
 bool QGIFLibHandler::write ( const QImage & image )
 {
     QImage toWrite(image);
     /// @todo how to specify dithering method
     if (toWrite.colorCount() == 0 || toWrite.colorCount() > 256)
         toWrite = image.convertToFormat(QImage::Format_Indexed8);
 
     QVector<QRgb> colorTable = toWrite.colorTable();
     ColorMapObject cmap;
     // colorCount must be a power of 2
     int colorCount = 1 << GifBitSize(toWrite.colorCount());
     cmap.ColorCount = colorCount;
     cmap.BitsPerPixel = 8;	/// @todo based on colorCount (or not? we did ask for Format_Indexed8, so the data is always 8-bit, right?)
     GifColorType* colorValues = (GifColorType*)malloc(cmap.ColorCount * sizeof(GifColorType));
     cmap.Colors = colorValues;
     int c = 0;
     for(; c < toWrite.colorCount(); ++c)
     {
 //        qDebug("color %d has %02X%02X%02X", c, qRed(colorTable[c]), qGreen(colorTable[c]), qBlue(colorTable[c]));
         colorValues[c].Red = qRed(colorTable[c]);
         colorValues[c].Green = qGreen(colorTable[c]);
         colorValues[c].Blue = qBlue(colorTable[c]);
     }
     // In case we had an actual number of colors that's not a power of 2,
     // fill the rest with something (black perhaps).
     for (; c < colorCount; ++c)
     {
         colorValues[c].Red = 0;
         colorValues[c].Green = 0;
         colorValues[c].Blue = 0;
     }
     /// @todo transparent GIFs (use alpha?)
 
 
     /// @todo write to m_device
     int err;
     GifFileType *gif = EGifOpen(device(), doOutput, &err);
 
     /// @todo how to specify which version, or decide based on features in use
     // Because of this call, libgif is not re-entrant
     EGifSetGifVersion(gif, true);
 
     /// @todo how to specify background
     if (EGifPutScreenDesc(gif, toWrite.width(), toWrite.height(), colorCount, 0, &cmap) == GIF_ERROR) {
         qWarning("EGifPutScreenDesc returned error %d", gif->Error);
     }
 
     QVariant descText = option(QImageIOHandler::Description);
     if (descText.type() == QVariant::String)
     {
         QString comment = descText.toString();
         // Will be something like "Description: actual text" or just
         // ": actual text", so remove everything leading up to and
         // including the first colon and the space following it.
         int idx = comment.indexOf(": ");
         if (idx >= 0)
             comment.remove(0, idx + 2);
         //		qDebug() << "comment:" << comment;
         if (!comment.isEmpty())
             EGifPutComment(gif, comment.toUtf8().constData());
     }
     //	else
     //		qDebug("description is of qvariant type %d", descText.type());
 
     /// @todo foreach of multiple images in an animation...
     if (EGifPutImageDesc(gif, 0, 0, toWrite.width(), toWrite.height(), 0, &cmap) == GIF_ERROR)
         qWarning("EGifPutImageDesc returned error %d", gif->Error);
 
     int lc = toWrite.height();
 
     // NOTE: we suppose that the pixel size is exactly 1 byte, right now we
     //       cannot save anything else
     int llen = toWrite.width();
 
     //	qDebug("will write %d lines, %d bytes each", lc, llen);
 
     for (int l = 0; l < lc; ++l)
     {
         uchar* line = toWrite.scanLine(l);
         if (EGifPutLine(gif, (GifPixelType*)line, llen) == GIF_ERROR)
         {
             int i = gif->Error;
             qWarning("EGifPutLine returned error %d", i);
         }
     }
 
     EGifCloseFile(gif, &err);
     free(colorValues);
 
     return true;
 }
 
 bool QGIFLibHandler::supportsOption ( ImageOption option ) const
 {
     //	qDebug("supportsOption %d", option);
     switch (option)
     {
     // These are relevant only for reading
     case QImageIOHandler::ImageFormat:
     case QImageIOHandler::Size:
         // This is relevant for both reading and writing
     case QImageIOHandler::Description:
         return true;
         break;
     default:
         return false;
     }
 }
 
 void QGIFLibHandler::setOption ( ImageOption option, const QVariant & value )
 {
     //	qDebug("setOption given option %d, variant of type %d", option, value.type());
     if (option == QImageIOHandler::Description)
         m_description = value.toString();
 }
 
 QVariant QGIFLibHandler::option( ImageOption option ) const
 {
     switch (option)
     {
     case QImageIOHandler::ImageFormat:
         return QVariant();	/// @todo
         break;
     case QImageIOHandler::Size:
         return QVariant();	/// @todo
         break;
     case QImageIOHandler::Description:
         return QVariant(m_description);
         break;
     default:
         return QVariant();
     }
 }
diff --git a/plugins/impex/heif/krita_heif.desktop b/plugins/impex/heif/krita_heif.desktop
index 1b5b286886..e0c46d0466 100644
--- a/plugins/impex/heif/krita_heif.desktop
+++ b/plugins/impex/heif/krita_heif.desktop
@@ -1,126 +1,126 @@
 [Desktop Entry]
 Categories=Qt;KDE;Office;Graphics;
 Exec=krita %F
 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[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[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]=繪圖與影像處理的應用程式
-Icon=calligrakrita
+Icon=krita
 MimeType=image/heic;
 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
 StartupNotify=true
 Terminal=false
 Type=Application
 X-KDE-SubstituteUID=false
 X-KDE-Username=
 NoDisplay=true
diff --git a/plugins/impex/heightmap/krita_heightmap.desktop b/plugins/impex/heightmap/krita_heightmap.desktop
index d35b79d3c6..773de5c0bd 100644
--- a/plugins/impex/heightmap/krita_heightmap.desktop
+++ b/plugins/impex/heightmap/krita_heightmap.desktop
@@ -1,76 +1,76 @@
 [Desktop Entry]
 Categories=Qt;KDE;Office;Graphics;
 Exec=krita %F
 GenericName=
-Icon=calligrakrita
+Icon=krita
 MimeType=image/x-r16;
 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
 NoDisplay=true
 StartupNotify=true
 Terminal=false
 Type=Application
 X-KDE-SubstituteUID=false
 X-KDE-Username=
diff --git a/plugins/impex/jpeg/kis_jpeg_export.cc b/plugins/impex/jpeg/kis_jpeg_export.cc
index 6bd8b31c72..fa4294a451 100644
--- a/plugins/impex/jpeg/kis_jpeg_export.cc
+++ b/plugins/impex/jpeg/kis_jpeg_export.cc
@@ -1,291 +1,291 @@
 /*
  *  Copyright (c) 2005 Cyrille Berger <cberger@cberger.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "kis_jpeg_export.h"
 
 #include <QCheckBox>
 #include <QSlider>
 #include <QColor>
 #include <QString>
 #include <QStringList>
 #include <QApplication>
 #include <QFileInfo>
 #include <QScopedPointer>
 
 #include <kpluginfactory.h>
 
 #include <KoColorSpace.h>
 #include <KoColorProfile.h>
 #include <KoColorSpaceConstants.h>
 #include <KoColorSpaceRegistry.h>
 
 #include <KisImportExportManager.h>
 #include <kis_slider_spin_box.h>
 #include <KisDocument.h>
 #include <KoDocumentInfo.h>
 #include <kis_image.h>
 #include <kis_group_layer.h>
 #include <kis_paint_layer.h>
 #include <kis_paint_device.h>
 #include <kis_properties_configuration.h>
 #include <kis_config.h>
 #include <kis_meta_data_store.h>
 #include <kis_meta_data_entry.h>
 #include <kis_meta_data_value.h>
 #include <kis_meta_data_schema.h>
 #include <kis_meta_data_schema_registry.h>
 #include <kis_meta_data_filter_registry_model.h>
 #include <kis_exif_info_visitor.h>
 #include <generator/kis_generator_layer.h>
 #include <KisExportCheckRegistry.h>
 #include "kis_jpeg_converter.h"
 
 class KisExternalLayer;
 
 K_PLUGIN_FACTORY_WITH_JSON(KisJPEGExportFactory, "krita_jpeg_export.json", registerPlugin<KisJPEGExport>();)
 
 KisJPEGExport::KisJPEGExport(QObject *parent, const QVariantList &) : KisImportExportFilter(parent)
 {
 }
 
 KisJPEGExport::~KisJPEGExport()
 {
 }
 
 KisImportExportErrorCode KisJPEGExport::convert(KisDocument *document, QIODevice *io,  KisPropertiesConfigurationSP configuration)
 {
     KisImageSP image = document->savingImage();
     Q_CHECK_PTR(image);
 
     // An extra option to pass to the config widget to set the state correctly, this isn't saved
     const KoColorSpace* cs = image->projection()->colorSpace();
     bool sRGB = cs->profile()->name().contains(QLatin1String("srgb"), Qt::CaseInsensitive);
     configuration->setProperty("is_sRGB", sRGB);
 
     KisJPEGOptions options;
     options.progressive = configuration->getBool("progressive", false);
     options.quality = configuration->getInt("quality", 80);
     options.forceSRGB = configuration->getBool("forceSRGB", false);
     options.saveProfile = configuration->getBool("saveProfile", true);
     options.optimize = configuration->getBool("optimize", true);
     options.smooth = configuration->getInt("smoothing", 0);
     options.baseLineJPEG = configuration->getBool("baseline", true);
     options.subsampling = configuration->getInt("subsampling", 0);
     options.exif = configuration->getBool("exif", true);
     options.iptc = configuration->getBool("iptc", true);
     options.xmp = configuration->getBool("xmp", true);
     KoColor c(KoColorSpaceRegistry::instance()->rgb8());
     c.fromQColor(Qt::white);
     options.transparencyFillColor = configuration->getColor("transparencyFillcolor", c).toQColor();
     KisMetaData::FilterRegistryModel m;
     m.setEnabledFilters(configuration->getString("filters").split(","));
     options.filters = m.enabledFilters();
     options.storeAuthor = configuration->getBool("storeAuthor", false);
     options.storeDocumentMetaData = configuration->getBool("storeMetaData", false);
 
     KisPaintDeviceSP pd = new KisPaintDevice(*image->projection());
 
     KisJPEGConverter kpc(document, batchMode());
     KisPaintLayerSP l = new KisPaintLayer(image, "projection", OPACITY_OPAQUE_U8, pd);
 
     KisExifInfoVisitor exivInfoVisitor;
     exivInfoVisitor.visit(image->rootLayer().data());
 
     QScopedPointer<KisMetaData::Store> metaDataStore;
     if (exivInfoVisitor.metaDataCount() == 1) {
         metaDataStore.reset(new KisMetaData::Store(*exivInfoVisitor.exifInfo()));
     }
     else {
         metaDataStore.reset(new KisMetaData::Store());
     }
 
     //add extra meta-data here
     const KisMetaData::Schema* dcSchema = KisMetaData::SchemaRegistry::instance()->schemaFromUri(KisMetaData::Schema::DublinCoreSchemaUri);
     Q_ASSERT(dcSchema);
     if (options.storeDocumentMetaData) {
         QString title = document->documentInfo()->aboutInfo("title");
         if (!title.isEmpty()) {
             if (metaDataStore->containsEntry("title")) {
                 metaDataStore->removeEntry("title");
             }
             metaDataStore->addEntry(KisMetaData::Entry(dcSchema, "title", KisMetaData::Value(QVariant(title))));
         }
         QString description = document->documentInfo()->aboutInfo("subject");
         if (description.isEmpty()) {
             description = document->documentInfo()->aboutInfo("abstract");
         }
         if (!description.isEmpty()) {
             QString keywords = document->documentInfo()->aboutInfo("keyword");
             if (!keywords.isEmpty()) {
                 description = description + " keywords: " + keywords;
             }
             if (metaDataStore->containsEntry("description")) {
                 metaDataStore->removeEntry("description");
             }
             metaDataStore->addEntry(KisMetaData::Entry(dcSchema, "description", KisMetaData::Value(QVariant(description))));
         }
         QString license = document->documentInfo()->aboutInfo("license");
         if (!license.isEmpty()) {
             if (metaDataStore->containsEntry("rights")) {
                 metaDataStore->removeEntry("rights");
             }
             metaDataStore->addEntry(KisMetaData::Entry(dcSchema, "rights", KisMetaData::Value(QVariant(license))));
         }
         QString date = document->documentInfo()->aboutInfo("date");
         if (!date.isEmpty() && !metaDataStore->containsEntry("rights")) {
             metaDataStore->addEntry(KisMetaData::Entry(dcSchema, "date", KisMetaData::Value(QVariant(date))));
         }
     }
     if (options.storeAuthor) {
         QString author = document->documentInfo()->authorInfo("creator");
         if (!author.isEmpty()) {
             if (!document->documentInfo()->authorContactInfo().isEmpty()) {
                 QString contact = document->documentInfo()->authorContactInfo().at(0);
                 if (!contact.isEmpty()) {
                     author = author+"("+contact+")";
                 }
             }
             if (metaDataStore->containsEntry("creator")) {
                 metaDataStore->removeEntry("creator");
             }
             metaDataStore->addEntry(KisMetaData::Entry(dcSchema, "creator", KisMetaData::Value(QVariant(author))));
         }
     }
 
     KisImportExportErrorCode res = kpc.buildFile(io, l, options, metaDataStore.data());
     return res;
 }
 
 KisPropertiesConfigurationSP KisJPEGExport::defaultConfiguration(const QByteArray &/*from*/, const QByteArray &/*to*/) const
 {
     KisPropertiesConfigurationSP cfg = new KisPropertiesConfiguration();
     cfg->setProperty("progressive", false);
     cfg->setProperty("quality", 80);
     cfg->setProperty("forceSRGB", false);
     cfg->setProperty("saveProfile", true);
     cfg->setProperty("optimize", true);
     cfg->setProperty("smoothing", 0);
     cfg->setProperty("baseline", true);
     cfg->setProperty("subsampling", 0);
     cfg->setProperty("exif", true);
     cfg->setProperty("iptc", true);
     cfg->setProperty("xmp", true);
     cfg->setProperty("storeAuthor", false);
     cfg->setProperty("storeMetaData", false);
 
     KoColor fill_color(KoColorSpaceRegistry::instance()->rgb8());
     fill_color = KoColor();
     fill_color.fromQColor(Qt::white);
     QVariant v;
     v.setValue(fill_color);
 
     cfg->setProperty("transparencyFillcolor", v);
     cfg->setProperty("filters", "");
 
     return cfg;
 }
 
 KisConfigWidget *KisJPEGExport::createConfigurationWidget(QWidget *parent, const QByteArray &/*from*/, const QByteArray &/*to*/) const
 {
     return new KisWdgOptionsJPEG(parent);
 }
 
 void KisJPEGExport::initializeCapabilities()
 {
     addCapability(KisExportCheckRegistry::instance()->get("sRGBProfileCheck")->create(KisExportCheckBase::SUPPORTED));
     addCapability(KisExportCheckRegistry::instance()->get("ExifCheck")->create(KisExportCheckBase::SUPPORTED));
 
     QList<QPair<KoID, KoID> > supportedColorModels;
     supportedColorModels << QPair<KoID, KoID>()
             << QPair<KoID, KoID>(RGBAColorModelID, Integer8BitsColorDepthID)
             << QPair<KoID, KoID>(GrayAColorModelID, Integer8BitsColorDepthID)
             << QPair<KoID, KoID>(CMYKAColorModelID, Integer8BitsColorDepthID);
     addSupportedColorModels(supportedColorModels, "JPEG");
 }
 
 
 KisWdgOptionsJPEG::KisWdgOptionsJPEG(QWidget *parent)
     : KisConfigWidget(parent)
 {
     setupUi(this);
 
     metaDataFilters->setModel(&m_filterRegistryModel);
     qualityLevel->setRange(0, 100, 0);
-    qualityLevel->setSuffix("%");
+    qualityLevel->setSuffix(i18n("%"));
     smoothLevel->setRange(0, 100, 0);
-    smoothLevel->setSuffix("%");
+    smoothLevel->setSuffix(i18n("%"));
 }
 
 
 void KisWdgOptionsJPEG::setConfiguration(const KisPropertiesConfigurationSP cfg)
 {
     progressive->setChecked(cfg->getBool("progressive", false));
     qualityLevel->setValue(cfg->getInt("quality", 80));
     optimize->setChecked(cfg->getBool("optimize", true));
     smoothLevel->setValue(cfg->getInt("smoothing", 0));
     baseLineJPEG->setChecked(cfg->getBool("baseline", true));
     subsampling->setCurrentIndex(cfg->getInt("subsampling", 0));
     exif->setChecked(cfg->getBool("exif", true));
     iptc->setChecked(cfg->getBool("iptc", true));
     xmp->setChecked(cfg->getBool("xmp", true));
     chkForceSRGB->setVisible(cfg->getBool("is_sRGB"));
     chkForceSRGB->setChecked(cfg->getBool("forceSRGB", false));
     chkSaveProfile->setChecked(cfg->getBool("saveProfile", true));
     KoColor background(KoColorSpaceRegistry::instance()->rgb8());
     background.fromQColor(Qt::white);
     bnTransparencyFillColor->setDefaultColor(background);
     bnTransparencyFillColor->setColor(cfg->getColor("transparencyFillcolor", background));
     chkAuthor->setChecked(cfg->getBool("storeAuthor", false));
     chkMetaData->setChecked(cfg->getBool("storeMetaData", false));
 
     m_filterRegistryModel.setEnabledFilters(cfg->getString("filters").split(','));
 
 }
 
 KisPropertiesConfigurationSP KisWdgOptionsJPEG::configuration() const
 {
     KisPropertiesConfigurationSP cfg = new KisPropertiesConfiguration();
 
     QVariant transparencyFillcolor;
     transparencyFillcolor.setValue(bnTransparencyFillColor->color());
 
     cfg->setProperty("progressive", progressive->isChecked());
     cfg->setProperty("quality", (int)qualityLevel->value());
     cfg->setProperty("forceSRGB", chkForceSRGB->isChecked());
     cfg->setProperty("saveProfile", chkSaveProfile->isChecked());
     cfg->setProperty("optimize", optimize->isChecked());
     cfg->setProperty("smoothing", (int)smoothLevel->value());
     cfg->setProperty("baseline", baseLineJPEG->isChecked());
     cfg->setProperty("subsampling", subsampling->currentIndex());
     cfg->setProperty("exif", exif->isChecked());
     cfg->setProperty("iptc", iptc->isChecked());
     cfg->setProperty("xmp", xmp->isChecked());
     cfg->setProperty("transparencyFillcolor", transparencyFillcolor);
     cfg->setProperty("storeAuthor", chkAuthor->isChecked());
     cfg->setProperty("storeMetaData", chkMetaData->isChecked());
 
     QString enabledFilters;
     Q_FOREACH (const KisMetaData::Filter* filter, m_filterRegistryModel.enabledFilters()) {
         enabledFilters = enabledFilters + filter->id() + ',';
     }
     cfg->setProperty("filters", enabledFilters);
 
     return cfg;
 }
 #include <kis_jpeg_export.moc>
diff --git a/plugins/impex/jpeg/krita_jpeg.desktop b/plugins/impex/jpeg/krita_jpeg.desktop
index cc1202f22f..218780e312 100644
--- a/plugins/impex/jpeg/krita_jpeg.desktop
+++ b/plugins/impex/jpeg/krita_jpeg.desktop
@@ -1,75 +1,75 @@
 [Desktop Entry]
 Categories=Qt;KDE;Office;Graphics;
 Exec=krita %F
-Icon=calligrakrita
+Icon=krita
 MimeType=image/jpeg;
 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
 StartupNotify=true
 Terminal=false
 Type=Application
 X-KDE-SubstituteUID=false
 X-KDE-Username=
 NoDisplay=true
diff --git a/plugins/impex/kra/krita_kra.desktop b/plugins/impex/kra/krita_kra.desktop
index a983c17f8b..5e068ed377 100644
--- a/plugins/impex/kra/krita_kra.desktop
+++ b/plugins/impex/kra/krita_kra.desktop
@@ -1,76 +1,76 @@
 [Desktop Entry]
 Categories=Qt;KDE;Office;Graphics;
 Comment=
 Exec=krita %F
-Icon=calligrakrita
+Icon=krita
 MimeType=application/x-krita;
 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
 StartupNotify=true
 Terminal=false
 Type=Application
 X-KDE-SubstituteUID=false
 X-KDE-Username=
 NoDisplay=true
diff --git a/plugins/impex/ora/krita_ora.desktop b/plugins/impex/ora/krita_ora.desktop
index 52fcee7c36..70b0957ae8 100644
--- a/plugins/impex/ora/krita_ora.desktop
+++ b/plugins/impex/ora/krita_ora.desktop
@@ -1,76 +1,76 @@
 [Desktop Entry]
 Categories=Qt;KDE;Office;Graphics;
 Comment=
 Exec=krita %F
-Icon=calligrakrita
+Icon=krita
 MimeType=image/openraster;
 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
 StartupNotify=true
 Terminal=false
 Type=Application
 X-KDE-SubstituteUID=false
 X-KDE-Username=
 NoDisplay=true
diff --git a/plugins/impex/pdf/krita_pdf.desktop b/plugins/impex/pdf/krita_pdf.desktop
index 0f526234ef..45fc3d699d 100644
--- a/plugins/impex/pdf/krita_pdf.desktop
+++ b/plugins/impex/pdf/krita_pdf.desktop
@@ -1,75 +1,75 @@
 [Desktop Entry]
 Categories=Qt;KDE;Office;Graphics;
 Exec=krita %F
-Icon=calligrakrita
+Icon=krita
 MimeType=application/pdf;
 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
 StartupNotify=true
 Terminal=false
 Type=Application
 X-KDE-SubstituteUID=false
 X-KDE-Username=
 NoDisplay=true
diff --git a/plugins/impex/png/krita_png.desktop b/plugins/impex/png/krita_png.desktop
index a0968bbf75..b04171379f 100644
--- a/plugins/impex/png/krita_png.desktop
+++ b/plugins/impex/png/krita_png.desktop
@@ -1,72 +1,72 @@
 [Desktop Entry]
 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
 Exec=krita %F
 MimeType=image/png;
 Type=Application
-Icon=calligrakrita
+Icon=krita
 Categories=Qt;KDE;Office;Graphics;
 StartupNotify=true
 NoDisplay=true
diff --git a/plugins/impex/psd/krita_psd.desktop b/plugins/impex/psd/krita_psd.desktop
index 01620121cb..0dcd4878ee 100644
--- a/plugins/impex/psd/krita_psd.desktop
+++ b/plugins/impex/psd/krita_psd.desktop
@@ -1,75 +1,75 @@
 [Desktop Entry]
 Categories=Qt;KDE;Office;Graphics;
 Exec=krita %F
-Icon=calligrakrita
+Icon=krita
 MimeType=image/x-psd;image/photoshop;image/x-photoshop;image/vnd.adobe.photoshop;
 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
 NoDisplay=true
 StartupNotify=true
 Terminal=false
 Type=Application
 X-KDE-SubstituteUID=false
 X-KDE-Username=
diff --git a/plugins/impex/qimageio/krita_qimageio.desktop b/plugins/impex/qimageio/krita_qimageio.desktop
index 87f2c9b15a..0c8d2dacf5 100644
--- a/plugins/impex/qimageio/krita_qimageio.desktop
+++ b/plugins/impex/qimageio/krita_qimageio.desktop
@@ -1,72 +1,72 @@
 [Desktop Entry]
 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
 Exec=krita %F
 MimeType=image/bmp;image/x-xpixmap;image/x-xbitmap;image/webp;image/vnd.microsoft.icon;image/x-portable-pixmap;image/x-portable-graymap;image/x-portable-bitmap;
 Type=Application
-Icon=calligrakrita
+Icon=krita
 Categories=Qt;KDE;Office;Graphics;
 StartupNotify=true
 NoDisplay=true
diff --git a/plugins/impex/raw/krita_raw.desktop b/plugins/impex/raw/krita_raw.desktop
index 57ef9d4626..a9847c3771 100644
--- a/plugins/impex/raw/krita_raw.desktop
+++ b/plugins/impex/raw/krita_raw.desktop
@@ -1,72 +1,72 @@
 [Desktop Entry]
 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
 Exec=krita %F
 MimeType=image/x-nikon-nef;image/x-canon-cr2;image/x-sony-sr2;image/x-canon-crw;image/x-pentax-pef;image/x-sigma-x3f;image/x-kodak-kdc;image/x-minolta-mrw;image/x-sony-arw;image/x-kodak-k25;image/x-kodak-dcr;image/x-olympus-orf;image/x-panasonic-raw;image/x-panasonic-raw2;image/x-fuji-raf;image/x-sony-srf;image/x-adobe-dng;
-Icon=calligrakrita
+Icon=krita
 Categories=Qt;KDE;Office;Graphics;
 StartupNotify=true
 NoDisplay=true
 Type=Application
diff --git a/plugins/impex/spriter/krita_spriter.desktop b/plugins/impex/spriter/krita_spriter.desktop
index c8564c9b83..a2aea09f00 100644
--- a/plugins/impex/spriter/krita_spriter.desktop
+++ b/plugins/impex/spriter/krita_spriter.desktop
@@ -1,72 +1,72 @@
 [Desktop Entry]
 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
 Exec=krita %F
 MimeType=image/x-scml;
 Type=Application
-Icon=calligrakrita
+Icon=krita
 Categories=Qt;KDE;Office;Graphics;
 StartupNotify=true
 NoDisplay=true
diff --git a/plugins/impex/svg/krita_svg.desktop b/plugins/impex/svg/krita_svg.desktop
index c531f1a056..ac82eedf61 100644
--- a/plugins/impex/svg/krita_svg.desktop
+++ b/plugins/impex/svg/krita_svg.desktop
@@ -1,72 +1,72 @@
 [Desktop Entry]
 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
 Exec=krita %F
 MimeType=image/svg+xml;
 Type=Application
-Icon=calligrakrita
+Icon=krita
 Categories=Qt;KDE;Office;Graphics;
 StartupNotify=true
 NoDisplay=true
diff --git a/plugins/impex/tga/krita_tga.desktop b/plugins/impex/tga/krita_tga.desktop
index 330ba11c9c..b94d1f0cbe 100644
--- a/plugins/impex/tga/krita_tga.desktop
+++ b/plugins/impex/tga/krita_tga.desktop
@@ -1,72 +1,72 @@
 [Desktop Entry]
 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
 Exec=krita %F
 MimeType=image/x-tga;
 Type=Application
-Icon=calligrakrita
+Icon=krita
 Categories=Qt;KDE;Office;Graphics;
 StartupNotify=true
 NoDisplay=true
diff --git a/plugins/impex/tiff/krita_tiff.desktop b/plugins/impex/tiff/krita_tiff.desktop
index 4353a74312..3018ab809b 100644
--- a/plugins/impex/tiff/krita_tiff.desktop
+++ b/plugins/impex/tiff/krita_tiff.desktop
@@ -1,75 +1,75 @@
 [Desktop Entry]
 Categories=Qt;KDE;Office;Graphics;
 Exec=krita %F
-Icon=calligrakrita
+Icon=krita
 MimeType=image/tiff;
 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
 NoDisplay=true
 StartupNotify=true
 Terminal=false
 Type=Application
 X-KDE-SubstituteUID=false
 X-KDE-Username=
diff --git a/plugins/impex/xcf/krita_xcf.desktop b/plugins/impex/xcf/krita_xcf.desktop
index 3801617f88..3c5c043bb6 100644
--- a/plugins/impex/xcf/krita_xcf.desktop
+++ b/plugins/impex/xcf/krita_xcf.desktop
@@ -1,75 +1,75 @@
 [Desktop Entry]
 Categories=Qt;KDE;Office;Graphics;
 Exec=krita %F
-Icon=calligrakrita
+Icon=krita
 MimeType=image/x-xcf;
 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
 Type=Application
 NoDisplay=true
 StartupNotify=true
 Terminal=false
 X-KDE-SubstituteUID=false
 X-KDE-Username=
diff --git a/plugins/paintops/defaultpaintops/brush/tests/kis_brushop_test.cpp b/plugins/paintops/defaultpaintops/brush/tests/kis_brushop_test.cpp
index f6bbb6fe56..30b0f85fdf 100644
--- a/plugins/paintops/defaultpaintops/brush/tests/kis_brushop_test.cpp
+++ b/plugins/paintops/defaultpaintops/brush/tests/kis_brushop_test.cpp
@@ -1,242 +1,254 @@
 /*
  *  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_brushop_test.h"
 
 #include <QTest>
 #include <qimage_based_test.h>
 #include <stroke_testing_utils.h>
 #include <brushengine/kis_paint_information.h>
 #include <kis_canvas_resource_provider.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <brushengine/kis_paintop_settings.h>
 #include <kis_pressure_mirror_option.h>
 #include <kis_pressure_rotation_option.h>
 
 class TestBrushOp : public TestUtil::QImageBasedTest
 {
 public:
     TestBrushOp(const QString &presetFileName, const QString &prefix = "simple")
         : QImageBasedTest("brushop") {
         m_presetFileName = presetFileName;
         m_prefix = prefix;
     }
 
     virtual ~TestBrushOp() {}
 
     void test() {
         test(false, false,  0.0);
         test(false, false, 10.0);
         test(false, false, 20.0);
 
         test(true, false,  0.0);
         test(true, false, 10.0);
         test(true, false, 20.0);
 
         test(false, true,  0.0);
         test(false, true, 10.0);
         test(false, true, 20.0);
 
         test(true, true,  0.0);
         test(true, true, 10.0);
         test(true, true, 20.0);
     }
 
     void test(bool mirrorX, bool mirrorY, qreal rotation) {
         test(mirrorX, mirrorY, rotation, false, false);
         test(mirrorX, mirrorY, rotation, true,  false);
         test(mirrorX, mirrorY, rotation, false, true);
         test(mirrorX, mirrorY, rotation, true,  true);
     }
 
     void test(bool mirrorX, bool mirrorY, qreal rotation, bool mirrorDabX, bool mirrorDabY) {
         test(mirrorX, mirrorY, rotation, mirrorDabX, mirrorDabY, 0.0);
         test(mirrorX, mirrorY, rotation, mirrorDabX, mirrorDabY, 360.0 - 10.0);
         test(mirrorX, mirrorY, rotation, mirrorDabX, mirrorDabY, 360.0 - 20.0);
     }
 
     void test(bool mirrorX, bool mirrorY, qreal rotation, bool mirrorDabX, bool mirrorDabY, qreal dabRotation) {
 
         KisSurrogateUndoStore *undoStore = new KisSurrogateUndoStore();
         KisImageSP image = createTrivialImage(undoStore);
         image->initialRefreshGraph();
 
         KisNodeSP paint1 = findNode(image->root(), "paint1");
 
         QVERIFY(paint1->extent().isEmpty());
 
         KisPainter gc(paint1->paintDevice());
 
         QScopedPointer<KoCanvasResourceProvider> manager(
             utils::createResourceManager(image, 0, m_presetFileName));
 
         KisPaintOpPresetSP preset =
             manager->resource(KisCanvasResourceProvider::CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
 
-        preset->settings()->setCanvasRotation(rotation);
-        preset->settings()->setCanvasMirroring(mirrorY, mirrorX);
-
-
         if (mirrorDabX || mirrorDabY) {
             KisPaintOpSettingsSP settings = preset->settings()->clone();
 
             KisPressureMirrorOption mirrorOption;
             mirrorOption.readOptionSetting(settings);
 
             mirrorOption.setChecked(true);
             mirrorOption.setCurveUsed(false);
 
             mirrorOption.enableHorizontalMirror(mirrorDabX);
             mirrorOption.enableVerticalMirror(mirrorDabY);
 
             mirrorOption.writeOptionSetting(settings.data());
 
             preset->setSettings(settings);
         }
 
         if (dabRotation != 0.0) {
             KisPaintOpSettingsSP settings = preset->settings()->clone();
 
             KisPressureRotationOption rotationOption;
             rotationOption.readOptionSetting(settings);
 
             rotationOption.setChecked(true);
             rotationOption.setCurveUsed(false);
 
             rotationOption.setValue(dabRotation / 360.0);
 
             rotationOption.writeOptionSetting(settings.data());
 
             preset->setSettings(settings);
         }
 
 
         QString testName =
             QString("%7_cmY_%1_cmX_%2_cR_%3_dmX_%4_dmY_%5_dR_%6")
             .arg(mirrorY)
             .arg(mirrorX)
             .arg(rotation)
             .arg(mirrorDabX)
             .arg(mirrorDabY)
             .arg(std::fmod(360.0 - dabRotation, 360.0))
             .arg(m_prefix);
 
         KisResourcesSnapshotSP resources =
             new KisResourcesSnapshot(image,
                                      paint1,
                                      manager.data());
 
         resources->setupPainter(&gc);
 
-        doPaint(gc);
+        doPaint(gc, rotation, mirrorX, mirrorY);
 
         checkOneLayer(image, paint1, testName);
     }
 
-    virtual void doPaint(KisPainter &gc) {
+    virtual void doPaint(KisPainter &gc, qreal rotation, bool mirrorX, bool mirrorY) {
         KisPaintInformation pi(QPointF(100, 100), 1.0);
+        pi.setCanvasRotation(rotation);
+        pi.setCanvasMirroredH(mirrorX);
+        pi.setCanvasMirroredV(mirrorY);
 
         KisDistanceInformation dist;
         gc.paintAt(pi, &dist);
     }
 
     QString m_presetFileName;
     QString m_prefix;
 };
 
 class TestBrushOpLines : public TestBrushOp
 {
 public:
     TestBrushOpLines(const QString &presetFileName)
         : TestBrushOp(presetFileName) {
     }
 
-    void doPaint(KisPainter &gc) override {
+    void doPaint(KisPainter &gc, qreal rotation, bool mirrorX, bool mirrorY) override {
 
         QVector<KisPaintInformation> vector;
 
         vector << KisPaintInformation(QPointF(100, 100));
         vector << KisPaintInformation(QPointF(200, 150));
         vector << KisPaintInformation(QPointF(100, 350));
 
+
+        for (auto pi : vector) {
+            pi.setCanvasRotation(rotation);
+            pi.setCanvasMirroredH(mirrorX);
+            pi.setCanvasMirroredV(mirrorY);
+        }
+
         KisDistanceInformation dist;
 
         for (int i = 1; i < vector.size(); i++) {
             gc.paintLine(vector[i - 1], vector[i], &dist);
         }
     }
 };
 
 class TestBrushOpPressureLines : public TestBrushOp
 {
 public:
     TestBrushOpPressureLines(const QString &presetFileName, const QString &prefix)
         : TestBrushOp(presetFileName, prefix) {
     }
 
-    void doPaint(KisPainter &gc) override {
+    void doPaint(KisPainter &gc, qreal rotation, bool mirrorX, bool mirrorY) override {
 
         QVector<KisPaintInformation> vector;
 
         vector << KisPaintInformation(QPointF(0, 0), 0.2);
         vector << KisPaintInformation(QPointF(200, 50), 1.0);
         vector << KisPaintInformation(QPointF(100, 250), 0.0);
         vector << KisPaintInformation(QPointF(200, 150), 1.0);
         vector << KisPaintInformation(QPointF(100, 350), 1.0);
 
+        for (auto pi : vector) {
+            pi.setCanvasRotation(rotation);
+            pi.setCanvasMirroredH(mirrorX);
+            pi.setCanvasMirroredV(mirrorY);
+        }
+
         KisDistanceInformation dist;
 
         for (int i = 1; i < vector.size(); i++) {
             gc.paintLine(vector[i - 1], vector[i], &dist);
         }
     }
 };
 
 #include <KoResourcePaths.h>
 void KisBrushOpTest::initTestCase()
 {
     KoResourcePaths::addResourceDir("kis_brushes", QString(SYSTEM_RESOURCES_DATA_DIR) + "/brushes");
 }
 
 void KisBrushOpTest::testRotationMirroring()
 {
     TestBrushOp t("LR_simple.kpp");
     t.test();
 }
 
 void KisBrushOpTest::testRotationMirroringDrawingAngle()
 {
     TestBrushOpLines t("LR_drawing_angle.kpp");
     t.test();
 }
 
 void KisBrushOpTest::testMagicSeven()
 {
     /**
      * A special preset that forces Qt to bug:
      *     mask size: 56
      *     brush size: 7
      *     therefore scale is: 0.125
      *     which causes QTransform work as a pure Translate in the mipmap
      */
 
     TestBrushOpPressureLines t("magic_seven.kpp", "magicseven");
     t.test();
 }
 
 QTEST_MAIN(KisBrushOpTest)
diff --git a/plugins/paintops/deform/kis_brush_size_option.cpp b/plugins/paintops/deform/kis_brush_size_option.cpp
index 115f798fc9..3e4a7a2d2f 100644
--- a/plugins/paintops/deform/kis_brush_size_option.cpp
+++ b/plugins/paintops/deform/kis_brush_size_option.cpp
@@ -1,154 +1,154 @@
 /*
  *  Copyright (c) 2009,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_brush_size_option.h"
 #include <klocalizedstring.h>
 
 #include <QWidget>
 #include <QRadioButton>
 
 #include "ui_wdgBrushSizeOptions.h"
 
 class KisBrushSizeOptionsWidget: public QWidget, public Ui::WdgBrushSizeOptions
 {
 public:
     KisBrushSizeOptionsWidget(QWidget *parent = 0)
         : QWidget(parent) {
         setupUi(this);
     }
 
 };
 
 
 KisBrushSizeOption::KisBrushSizeOption()
     : KisPaintOpOption(KisPaintOpOption::GENERAL, false)
 {
     setObjectName("KisBrushSizeOption");
 
     m_checkable = false;
     m_options = new KisBrushSizeOptionsWidget();
 
 
     // init slider values
     m_options->diameter->setRange(1.0, 1000, 0);
     m_options->diameter->setValue(20);
     m_options->diameter->setExponentRatio(3.0);
     m_options->diameter->setSuffix(i18n(" px"));
 
     m_options->aspectBox->setRange(0.01, 2.0, 2);
     m_options->aspectBox->setValue(1.0);
     m_options->aspectBox->setExponentRatio(1.0);
 
 
     m_options->scale->setRange(0.01, 10.0, 2);
     m_options->scale->setValue(1.0);
 
     m_options->spacing->setRange(0.01, 5.0, 2);
     m_options->spacing->setValue(0.3);
 
 
     m_options->rotationBox->setRange(0.0, 360.0, 0);
     m_options->rotationBox->setValue(0.0);
     m_options->rotationBox->setSuffix(QChar(Qt::Key_degree));
 
 
     m_options->densityBox->setRange(0.0, 100.0, 0);
     m_options->densityBox->setValue(100);
-    m_options->densityBox->setSuffix("%");
+    m_options->densityBox->setSuffix(i18n("%"));
 
 
     m_options->jitterMove->setRange(0.0, 5.0, 2);
     m_options->jitterMove->setValue(0.0);
 
     connect(m_options->diameter, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
     connect(m_options->scale, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
     connect(m_options->aspectBox, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
     connect(m_options->spacing, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
     connect(m_options->rotationBox, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
     connect(m_options->densityBox, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
     connect(m_options->jitterMove, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
     connect(m_options->jitterMoveBox, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
 
     connect(m_options->jitterMoveBox, SIGNAL(toggled(bool)), m_options->jitterMove, SLOT(setEnabled(bool)));
     setConfigurationPage(m_options);
 }
 
 KisBrushSizeOption::~KisBrushSizeOption()
 {
     delete m_options;
 }
 
 
 int KisBrushSizeOption::diameter() const
 {
     return qRound(m_options->diameter->value());
 }
 
 
 void KisBrushSizeOption::setDiameter(int diameter)
 {
     m_options->diameter->setValue(diameter);
 }
 
 qreal KisBrushSizeOption::brushAspect() const
 {
     return m_options->aspectBox->value();
 }
 
 
 void KisBrushSizeOption::writeOptionSetting(KisPropertiesConfigurationSP setting) const
 {
     KisBrushSizeOptionProperties op;
 
     op.brush_diameter = m_options->diameter->value();
     op.brush_aspect = m_options->aspectBox->value();
     op.brush_rotation = m_options->rotationBox->value();
     op.brush_scale = m_options->scale->value();
     op.brush_spacing = m_options->spacing->value();
     op.brush_density = m_options->densityBox->value() / 100.0;
     op.brush_jitter_movement = m_options->jitterMove->value();
     op.brush_jitter_movement_enabled = m_options->jitterMoveBox->isChecked();
 
     op.writeOptionSetting(setting);
 }
 
 void KisBrushSizeOption::readOptionSetting(const KisPropertiesConfigurationSP setting)
 {
     KisBrushSizeOptionProperties op;
     op.readOptionSetting(setting);
 
     m_options->diameter->setValue(op.brush_diameter);
     m_options->aspectBox->setValue(op.brush_aspect);
     m_options->rotationBox->setValue(op.brush_rotation);
     m_options->scale->setValue(op.brush_scale);
     m_options->spacing->setValue(op.brush_spacing);
     m_options->densityBox->setValue(op.brush_density * 100.0);
     m_options->jitterMove->setValue(op.brush_jitter_movement);
     m_options->jitterMoveBox->setChecked(op.brush_jitter_movement_enabled);
 
 }
 
 void KisBrushSizeOption::setSpacing(qreal spacing)
 {
     m_options->spacing->setValue(spacing);
 }
 
 qreal KisBrushSizeOption::spacing() const
 {
     return m_options->spacing->value();
 }
 
diff --git a/plugins/paintops/hairy/kis_hairy_ink_option.cpp b/plugins/paintops/hairy/kis_hairy_ink_option.cpp
index 820a116c91..427351d275 100644
--- a/plugins/paintops/hairy/kis_hairy_ink_option.cpp
+++ b/plugins/paintops/hairy/kis_hairy_ink_option.cpp
@@ -1,158 +1,158 @@
 /*
  *  Copyright (c) 2008-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_hairy_ink_option.h"
 #include "kis_hairy_paintop_settings.h"
 
 #include <klocalizedstring.h>
 #include "ui_wdgInkOptions.h"
 
 class KisInkOptionsWidget: public QWidget, public Ui::WdgInkOptions
 {
 public:
     KisInkOptionsWidget(QWidget *parent = 0)
         : QWidget(parent) {
         setupUi(this);
     }
 };
 
 KisHairyInkOption::KisHairyInkOption()
     : KisPaintOpOption(KisPaintOpOption::COLOR, false)
 {
     setObjectName("KisHairyInkOption");
 
 
     m_checkable = true;
     m_options = new KisInkOptionsWidget();
 
     // init values for slider
     m_options->pressureSlider->setRange(0.0, 100, 0);
     m_options->pressureSlider->setValue(50);
-    m_options->pressureSlider->setSuffix("%");
+    m_options->pressureSlider->setSuffix(i18n("%"));
 
     m_options->bristleLengthSlider->setRange(0, 100, 0);
     m_options->bristleLengthSlider->setValue(50);
-    m_options->bristleLengthSlider->setSuffix("%");
+    m_options->bristleLengthSlider->setSuffix(i18n("%"));
 
     m_options->bristleInkAmountSlider->setRange(0, 100, 0);
     m_options->bristleInkAmountSlider->setValue(50);
-    m_options->bristleInkAmountSlider->setSuffix("%");
+    m_options->bristleInkAmountSlider->setSuffix(i18n("%"));
 
     m_options->inkDepletionSlider->setRange(0, 100, 0);
     m_options->inkDepletionSlider->setValue(50);
-    m_options->inkDepletionSlider->setSuffix("%");
+    m_options->inkDepletionSlider->setSuffix(i18n("%"));
 
 
     connect(m_options->inkAmountSpinBox, SIGNAL(valueChanged(int)), SLOT(emitSettingChanged()));
     connect(m_options->saturationCBox, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
     connect(m_options->opacityCBox, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
     connect(m_options->useWeightCHBox, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
     connect(m_options->pressureSlider, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
     connect(m_options->bristleLengthSlider, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
     connect(m_options->bristleInkAmountSlider, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
     connect(m_options->inkDepletionSlider, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
     connect(m_options->inkCurve, SIGNAL(modified()), SLOT(emitSettingChanged()));
     connect(m_options->soakInkCBox, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
 
     setConfigurationPage(m_options);
 }
 
 KisHairyInkOption::~KisHairyInkOption()
 {
     delete m_options;
 }
 
 
 void KisHairyInkOption::readOptionSetting(const KisPropertiesConfigurationSP settings)
 {
     setChecked(settings->getBool(HAIRY_INK_DEPLETION_ENABLED));
     m_options->inkAmountSpinBox->setValue(settings->getInt(HAIRY_INK_AMOUNT));
     m_options->saturationCBox->setChecked(settings->getBool(HAIRY_INK_USE_SATURATION));
     m_options->opacityCBox->setChecked(settings->getBool(HAIRY_INK_USE_OPACITY));
     m_options->useWeightCHBox->setChecked(settings->getBool(HAIRY_INK_USE_WEIGHTS));
     m_options->pressureSlider->setValue(settings->getInt(HAIRY_INK_PRESSURE_WEIGHT));
     m_options->bristleLengthSlider->setValue(settings->getInt(HAIRY_INK_BRISTLE_LENGTH_WEIGHT));
     m_options->bristleInkAmountSlider->setValue(settings->getInt(HAIRY_INK_BRISTLE_INK_AMOUNT_WEIGHT));
     m_options->inkDepletionSlider->setValue(settings->getInt(HAIRY_INK_DEPLETION_WEIGHT));
     m_options->inkCurve->setCurve(settings->getCubicCurve(HAIRY_INK_DEPLETION_CURVE));
     m_options->soakInkCBox->setChecked(settings->getBool(HAIRY_INK_SOAK));
 }
 
 void KisHairyInkOption::writeOptionSetting(KisPropertiesConfigurationSP settings) const
 {
     settings->setProperty(HAIRY_INK_DEPLETION_ENABLED, isChecked());
     settings->setProperty(HAIRY_INK_AMOUNT, inkAmount());
     settings->setProperty(HAIRY_INK_USE_SATURATION, useSaturation());
     settings->setProperty(HAIRY_INK_USE_OPACITY, useOpacity());
     settings->setProperty(HAIRY_INK_USE_WEIGHTS, useWeights());
     settings->setProperty(HAIRY_INK_PRESSURE_WEIGHT, pressureWeight());
     settings->setProperty(HAIRY_INK_BRISTLE_LENGTH_WEIGHT, bristleLengthWeight());
     settings->setProperty(HAIRY_INK_BRISTLE_INK_AMOUNT_WEIGHT, bristleInkAmountWeight());
     settings->setProperty(HAIRY_INK_DEPLETION_WEIGHT, inkDepletionWeight());
     settings->setProperty(HAIRY_INK_DEPLETION_CURVE, qVariantFromValue(m_options->inkCurve->curve()));
     settings->setProperty(HAIRY_INK_SOAK, m_options->soakInkCBox->isChecked());
 }
 
 
 int KisHairyInkOption::inkAmount() const
 {
     return m_options->inkAmountSpinBox->value();
 }
 
 
 bool KisHairyInkOption::useOpacity() const
 {
     return m_options->opacityCBox->isChecked();
 }
 
 
 bool KisHairyInkOption::useSaturation() const
 {
     return m_options->saturationCBox->isChecked();
 }
 
 
 bool KisHairyInkOption::useWeights() const
 {
     return m_options->useWeightCHBox->isChecked();
 }
 
 
 int KisHairyInkOption::pressureWeight() const
 {
     return m_options->pressureSlider->value();
 }
 
 
 int KisHairyInkOption::bristleLengthWeight() const
 {
     return m_options->bristleLengthSlider->value();
 }
 
 
 int KisHairyInkOption::bristleInkAmountWeight() const
 {
     return m_options->bristleInkAmountSlider->value();
 }
 
 
 int KisHairyInkOption::inkDepletionWeight() const
 {
     return m_options->inkDepletionSlider->value();
 }
 
 
diff --git a/plugins/paintops/hairy/kis_hairy_paintop.cpp b/plugins/paintops/hairy/kis_hairy_paintop.cpp
index 2927af5fae..bd53194983 100644
--- a/plugins/paintops/hairy/kis_hairy_paintop.cpp
+++ b/plugins/paintops/hairy/kis_hairy_paintop.cpp
@@ -1,172 +1,170 @@
 /*
  *  Copyright (c) 2008-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_hairy_paintop.h"
 #include "kis_hairy_paintop_settings.h"
 
 #include <cmath>
 #include <QRect>
 
 #include <kis_image.h>
 #include <kis_debug.h>
 
 #include "kis_paint_device.h"
 #include "kis_painter.h"
 #include <kis_vec.h>
 
 #include <kis_hairy_ink_option.h>
 #include <kis_hairy_bristle_option.h>
 #include <kis_brush_option.h>
 #include <kis_brush_based_paintop_settings.h>
 #include <kis_fixed_paint_device.h>
 #include <kis_lod_transform.h>
 #include <kis_spacing_information.h>
 
 
 #include "kis_brush.h"
 
 KisHairyPaintOp::KisHairyPaintOp(const KisPaintOpSettingsSP settings, KisPainter * painter, KisNodeSP node, KisImageSP image)
     : KisPaintOp(painter)
 {
     Q_UNUSED(image)
     Q_ASSERT(settings);
 
     m_dev = node ? node->paintDevice() : 0;
 
     KisBrushOptionProperties brushOption;
     brushOption.readOptionSetting(settings);
     KisBrushSP brush = brushOption.brush();
     KisFixedPaintDeviceSP dab = cachedDab(painter->device()->compositionSourceColorSpace());
 
     // properly initialize fake paint information to avoid warnings
     KisPaintInformation fakePaintInformation;
     fakePaintInformation.setRandomSource(new KisRandomSource());
     fakePaintInformation.setPerStrokeRandomSource(new KisPerStrokeRandomSource());
 
     if (brush->brushType() == IMAGE || brush->brushType() == PIPE_IMAGE) {
         dab = brush->paintDevice(source()->colorSpace(), KisDabShape(), fakePaintInformation);
     } else {
         brush->mask(dab, painter->paintColor(), KisDabShape(), fakePaintInformation);
     }
 
     m_brush.fromDabWithDensity(dab, settings->getDouble(HAIRY_BRISTLE_DENSITY) * 0.01);
     m_brush.setInkColor(painter->paintColor());
 
     loadSettings(static_cast<const KisBrushBasedPaintOpSettings*>(settings.data()));
     m_brush.setProperties(&m_properties);
 
     m_rotationOption.readOptionSetting(settings);
     m_opacityOption.readOptionSetting(settings);
     m_sizeOption.readOptionSetting(settings);
     m_rotationOption.resetAllSensors();
     m_opacityOption.resetAllSensors();
     m_sizeOption.resetAllSensors();
-
-    bool mirrorXAxis = settings->getBool("runtimeCanvasMirroredX", false);
-    bool mirrorYAxis = settings->getBool("runtimeCanvasMirroredY", false);
-    m_mirrorFlip = mirrorXAxis != mirrorYAxis;
 }
 
 
 void KisHairyPaintOp::loadSettings(const KisBrushBasedPaintOpSettings *settings)
 {
     m_properties.inkAmount = settings->getInt(HAIRY_INK_AMOUNT);
     //TODO: wait for the transfer function with variable size
 
     m_properties.inkDepletionCurve = settings->getCubicCurve(HAIRY_INK_DEPLETION_CURVE).floatTransfer(m_properties.inkAmount);
 
     m_properties.inkDepletionEnabled = settings->getBool(HAIRY_INK_DEPLETION_ENABLED);
     m_properties.useSaturation = settings->getBool(HAIRY_INK_USE_SATURATION);
     m_properties.useOpacity = settings->getBool(HAIRY_INK_USE_OPACITY);
     m_properties.useWeights = settings->getBool(HAIRY_INK_USE_WEIGHTS);
 
     m_properties.pressureWeight = settings->getDouble(HAIRY_INK_PRESSURE_WEIGHT) / 100.0;
     m_properties.bristleLengthWeight = settings->getDouble(HAIRY_INK_BRISTLE_LENGTH_WEIGHT) / 100.0;
     m_properties.bristleInkAmountWeight = settings->getDouble(HAIRY_INK_BRISTLE_INK_AMOUNT_WEIGHT) / 100.0;
     m_properties.inkDepletionWeight = settings->getDouble(HAIRY_INK_DEPLETION_WEIGHT);
     m_properties.useSoakInk = settings->getBool(HAIRY_INK_SOAK);
 
     m_properties.useMousePressure = settings->getBool(HAIRY_BRISTLE_USE_MOUSEPRESSURE);
     m_properties.shearFactor = settings->getDouble(HAIRY_BRISTLE_SHEAR);
     m_properties.randomFactor = settings->getDouble(HAIRY_BRISTLE_RANDOM);
     m_properties.scaleFactor = settings->getDouble(HAIRY_BRISTLE_SCALE);
     m_properties.threshold = settings->getBool(HAIRY_BRISTLE_THRESHOLD);
     m_properties.antialias = settings->getBool(HAIRY_BRISTLE_ANTI_ALIASING);
     m_properties.useCompositing = settings->getBool(HAIRY_BRISTLE_USE_COMPOSITING);
     m_properties.connectedPath = settings->getBool(HAIRY_BRISTLE_CONNECTED);
 }
 
 
 KisSpacingInformation KisHairyPaintOp::paintAt(const KisPaintInformation& info)
 {
     return updateSpacingImpl(info);
 }
 
 KisSpacingInformation KisHairyPaintOp::updateSpacingImpl(const KisPaintInformation &info) const
 {
     Q_UNUSED(info);
     return KisSpacingInformation(0.5);
 }
 
 
 void KisHairyPaintOp::paintLine(const KisPaintInformation &pi1, const KisPaintInformation &pi2, KisDistanceInformation *currentDistance)
 {
     Q_UNUSED(currentDistance);
     if (!painter()) return;
 
     if (!m_dab) {
         m_dab = source()->createCompositionSourceDevice();
     }
     else {
         m_dab->clear();
     }
 
     /**
      * Even though we don't use spacing in hairy brush, we should still
      * initialize its distance information to ensure drawing angle and
      * other history-based sensors work fine.
      */
     KisPaintInformation pi(pi2);
     KisPaintInformation::DistanceInformationRegistrar r =
         pi.registerDistanceInformation(currentDistance);
 
     // Hairy Brush is capable of working with zero scale,
     // so no additional checks for 'zero'ness are needed
     qreal scale = m_sizeOption.apply(pi);
     scale *= KisLodTransform::lodToScale(painter()->device());
     qreal rotation = m_rotationOption.apply(pi);
     quint8 origOpacity = m_opacityOption.apply(painter(), pi);
 
+    const bool mirrorFlip = pi1.canvasMirroredH() != pi1.canvasMirroredV();
+
     // we don't use spacing here (the brush itself is used only once
     // during initialization), so we should just skip the distance info
     // update
 
-    m_brush.paintLine(m_dab, m_dev, pi1, pi, scale * m_properties.scaleFactor, m_mirrorFlip? -rotation : rotation);
+    m_brush.paintLine(m_dab, m_dev, pi1, pi, scale * m_properties.scaleFactor, mirrorFlip ? -rotation : rotation);
 
     //QRect rc = m_dab->exactBounds();
     QRect rc = m_dab->extent();
     painter()->bitBlt(rc.topLeft(), m_dab, rc);
     painter()->renderMirrorMask(rc, m_dab);
     painter()->setOpacity(origOpacity);
 
     // we don't use spacing in hairy brush, but history is
     // still important for us
     currentDistance->registerPaintedDab(pi,
                                         KisSpacingInformation(),
                                         KisTimingInformation());
 }
diff --git a/plugins/paintops/hairy/kis_hairy_paintop.h b/plugins/paintops/hairy/kis_hairy_paintop.h
index 9bda32cbe2..e9de44d51d 100644
--- a/plugins/paintops/hairy/kis_hairy_paintop.h
+++ b/plugins/paintops/hairy/kis_hairy_paintop.h
@@ -1,65 +1,63 @@
 /*
  *  Copyright (c) 2008 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2008-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.
  */
 
 #ifndef KIS_HAIRYPAINTOP_H_
 #define KIS_HAIRYPAINTOP_H_
 
 #include <klocalizedstring.h>
 #include <brushengine/kis_paintop.h>
 #include <brushengine/kis_paintop_factory.h>
 #include <kis_types.h>
 
 #include "hairy_brush.h"
 
 #include <kis_pressure_size_option.h>
 #include <kis_pressure_rotation_option.h>
 #include <kis_pressure_opacity_option.h>
 
 class KisPainter;
 class KisBrushBasedPaintOpSettings;
 
 class KisHairyPaintOp : public KisPaintOp
 {
 
 public:
     KisHairyPaintOp(const KisPaintOpSettingsSP settings, KisPainter *painter, KisNodeSP node, KisImageSP image);
 
     void paintLine(const KisPaintInformation &pi1, const KisPaintInformation &pi2, KisDistanceInformation *currentDistance) override;
 
 protected:
     KisSpacingInformation paintAt(const KisPaintInformation& info) override;
 
     KisSpacingInformation updateSpacingImpl(const KisPaintInformation &info) const override;
 
 private:
     KisHairyProperties m_properties;
 
     KisPaintDeviceSP m_dab;
     KisPaintDeviceSP m_dev;
     HairyBrush m_brush;
     KisPressureRotationOption m_rotationOption;
     KisPressureSizeOption m_sizeOption;
     KisPressureOpacityOption m_opacityOption;
 
-    bool m_mirrorFlip;
-
     void loadSettings(const KisBrushBasedPaintOpSettings* settings);
 };
 
 #endif // KIS_HAIRYPAINTOP_H_
diff --git a/plugins/paintops/libpaintop/kis_auto_brush_widget.cpp b/plugins/paintops/libpaintop/kis_auto_brush_widget.cpp
index 0ecdab3bf4..b1c318594d 100644
--- a/plugins/paintops/libpaintop/kis_auto_brush_widget.cpp
+++ b/plugins/paintops/libpaintop/kis_auto_brush_widget.cpp
@@ -1,295 +1,295 @@
 /*
  *  Copyright (c) 2004,2007,2009 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 <compositeops/KoVcMultiArchBuildSupport.h> //MSVC requires that Vc come first
 #include "kis_auto_brush_widget.h"
 
 #include <kconfig.h>
 #include <ksharedconfig.h>
 #include <kconfiggroup.h>
 
 #include <math.h>
 #include <kis_debug.h>
 #include <QSpinBox>
 #include <QToolButton>
 #include <QImage>
 #include <QComboBox>
 #include <QLabel>
 #include <QPixmap>
 #include <QResizeEvent>
 
 #include <kis_fixed_paint_device.h>
 #include <kis_mask_generator.h>
 #include <kis_slider_spin_box.h>
 #include "kis_signals_blocker.h"
 #include "kis_signal_compressor.h"
 #include "kis_aspect_ratio_locker.h"
 
 
 #define showSlider(input, step) input->setRange(input->minimum(), input->maximum(), step)
 #include <kis_cubic_curve.h>
 
 KisAutoBrushWidget::KisAutoBrushWidget(QWidget *parent, const char* name)
     : KisWdgAutoBrush(parent, name)
     , m_autoBrush(0)
     , m_updateCompressor(new KisSignalCompressor(100, KisSignalCompressor::FIRST_ACTIVE))
     , m_fadeAspectLocker(new KisAspectRatioLocker())
 {
     connect(m_updateCompressor.data(), SIGNAL(timeout()), SLOT(paramChanged()));
 
     connect((QObject*)comboBoxShape, SIGNAL(activated(int)), m_updateCompressor.data(), SLOT(start()));
 
     inputRadius->setRange(0.01, KSharedConfig::openConfig()->group("").readEntry("maximumBrushSize", 1000), 2);
     inputRadius->setExponentRatio(3.0);
     inputRadius->setSingleStep(1);
     inputRadius->setValue(5);
     inputRadius->setSuffix(i18n(" px"));
     inputRadius->setBlockUpdateSignalOnDrag(true);
     connect(inputRadius, SIGNAL(valueChanged(qreal)), m_updateCompressor.data(), SLOT(start()));
 
     inputRatio->setRange(0.0, 1.0, 2);
     inputRatio->setSingleStep(0.1);
     inputRatio->setValue(1.0);
     inputRatio->setBlockUpdateSignalOnDrag(true);
     connect(inputRatio, SIGNAL(valueChanged(qreal)), m_updateCompressor.data(), SLOT(start()));
 
     inputHFade->setRange(0.0, 1.0, 2);
     inputHFade->setSingleStep(0.1);
     inputHFade->setValue(0.5);
 
     inputVFade->setRange(0.0, 1.0, 2);
     inputVFade->setSingleStep(0.1);
     inputVFade->setValue(0.5);
 
     aspectButton->setKeepAspectRatio(true);
 
     m_fadeAspectLocker->connectSpinBoxes(inputHFade, inputVFade, aspectButton);
     m_fadeAspectLocker->setBlockUpdateSignalOnDrag(true);
     connect(m_fadeAspectLocker.data(), SIGNAL(sliderValueChanged()), m_updateCompressor.data(), SLOT(start()));
     connect(m_fadeAspectLocker.data(), SIGNAL(aspectButtonChanged()), m_updateCompressor.data(), SLOT(start()));
 
     inputSpikes->setRange(2, 20);
     inputSpikes->setValue(2);
     inputSpikes->setBlockUpdateSignalOnDrag(true);
     connect(inputSpikes, SIGNAL(valueChanged(int)), m_updateCompressor.data(), SLOT(start()));
 
     inputRandomness->setRange(0, 100);
     inputRandomness->setValue(0);
     inputRandomness->setBlockUpdateSignalOnDrag(true);
     connect(inputRandomness, SIGNAL(valueChanged(qreal)), m_updateCompressor.data(), SLOT(start()));
 
     inputAngle->setRange(0, 360);
     inputAngle->setSuffix(QChar(Qt::Key_degree));
     inputAngle->setValue(0);
     inputAngle->setBlockUpdateSignalOnDrag(true);
     connect(inputAngle, SIGNAL(valueChanged(int)), m_updateCompressor.data(), SLOT(start()));
 
     connect(spacingWidget, SIGNAL(sigSpacingChanged()), m_updateCompressor.data(), SLOT(start()));
 
     density->setRange(0, 100, 0);
     density->setSingleStep(1);
     density->setValue(100);
-    density->setSuffix("%");
+    density->setSuffix(i18n("%"));
     density->setBlockUpdateSignalOnDrag(true);
     connect(density, SIGNAL(valueChanged(qreal)), m_updateCompressor.data(), SLOT(start()));
 
     KisCubicCurve topLeftBottomRightLinearCurve;
     topLeftBottomRightLinearCurve.setPoint(0, QPointF(0.0, 1.0));
     topLeftBottomRightLinearCurve.setPoint(1, QPointF(1.0, 0.0));
     softnessCurve->setCurve(topLeftBottomRightLinearCurve);
     connect(softnessCurve, SIGNAL(modified()), m_updateCompressor.data(), SLOT(start()));
 
     m_brush = QImage(1, 1, QImage::Format_RGB32);
 
     connect(brushPreview, SIGNAL(clicked()), m_updateCompressor.data(), SLOT(start()));
 
     QList<KoID> ids = KisMaskGenerator::maskGeneratorIds();
     for (int i = 0; i < ids.size(); i++) {
         comboBoxMaskType->insertItem(i, ids[i].name());
     }
 
     connect(comboBoxMaskType, SIGNAL(activated(int)), m_updateCompressor.data(), SLOT(start()));
     connect(comboBoxMaskType, SIGNAL(currentIndexChanged(int)), SLOT(setStackedWidget(int)));
     setStackedWidget(comboBoxMaskType->currentIndex());
 
     brushPreview->setIconSize(QSize(100, 100));
 
     connect(btnAntialiasing, SIGNAL(toggled(bool)), m_updateCompressor.data(), SLOT(start()));
 
     m_updateCompressor->start();
 
 }
 
 KisAutoBrushWidget::~KisAutoBrushWidget()
 {
 }
 
 void KisAutoBrushWidget::resizeEvent(QResizeEvent *)
 {
     brushPreview->setMinimumHeight(brushPreview->width()); // dirty hack !
     brushPreview->setMaximumHeight(brushPreview->width()); // dirty hack !
 }
 
 void KisAutoBrushWidget::activate()
 {
     m_updateCompressor->start();
 }
 
 void KisAutoBrushWidget::paramChanged()
 {
     KisMaskGenerator* kas;
 
     bool antialiasEdges = btnAntialiasing->isChecked();
 
     if (comboBoxMaskType->currentIndex() == 2) { // gaussian brush
         if (comboBoxShape->currentIndex() == 0) {
             kas = new KisGaussCircleMaskGenerator(inputRadius->value(),  inputRatio->value(), inputHFade->value(), inputVFade->value(), inputSpikes->value(), antialiasEdges);
         }
         else {
             kas = new KisGaussRectangleMaskGenerator(inputRadius->value(),  inputRatio->value(), inputHFade->value(), inputVFade->value(), inputSpikes->value(), antialiasEdges);
         }
     }
     else if (comboBoxMaskType->currentIndex() == 1) { // soft brush
         if (comboBoxShape->currentIndex() == 0) {
             kas = new KisCurveCircleMaskGenerator(inputRadius->value(),  inputRatio->value(), inputHFade->value(), inputVFade->value(), inputSpikes->value(), softnessCurve->curve(), antialiasEdges);
         }
         else {
             kas = new KisCurveRectangleMaskGenerator(inputRadius->value(),  inputRatio->value(), inputHFade->value(), inputVFade->value(), inputSpikes->value(), softnessCurve->curve(), antialiasEdges);
         }
     }
     else {// default == 0 or any other
         if (comboBoxShape->currentIndex() == 0) { // use index compare instead of comparing a translatable string
             kas = new KisCircleMaskGenerator(inputRadius->value(),  inputRatio->value(), inputHFade->value(), inputVFade->value(), inputSpikes->value(), antialiasEdges);
         }
         else {
             kas = new KisRectangleMaskGenerator(inputRadius->value(),  inputRatio->value(), inputHFade->value(), inputVFade->value(), inputSpikes->value(), antialiasEdges);
         }
     }
     Q_CHECK_PTR(kas);
 
     m_autoBrush = new KisAutoBrush(kas, inputAngle->value() / 180.0 * M_PI, inputRandomness->value() / 100.0, density->value() / 100.0);
     m_autoBrush->setSpacing(spacingWidget->spacing());
     m_autoBrush->setAutoSpacing(spacingWidget->autoSpacingActive(), spacingWidget->autoSpacingCoeff());
     m_brush = m_autoBrush->image();
 
     drawBrushPreviewArea();
 
     emit sigBrushChanged();
 }
 
 void KisAutoBrushWidget::drawBrushPreviewArea() {
     QImage pi(m_brush);
     double coeff = 1.0;
     int bPw = brushPreview->width() - 3;
     if (pi.width() > bPw) {
         coeff =  bPw / (double)pi.width();
     }
     int bPh = brushPreview->height() - 3;
     if (pi.height() > coeff * bPh) {
         coeff = bPh / (double)pi.height();
     }
     if (coeff < 1.0) {
         pi = pi.scaled((int)(coeff * pi.width()) , (int)(coeff * pi.height()),  Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
     }
 
     QPixmap p = QPixmap::fromImage(pi);
     brushPreview->setIcon(QIcon(p));
 }
 
 void KisAutoBrushWidget::setStackedWidget(int index)
 {
     if (index == 1) {
         stackedWidget->setCurrentIndex(1);
     }
     else {
         stackedWidget->setCurrentIndex(0);
     }
 }
 
 KisBrushSP KisAutoBrushWidget::brush()
 {
     return m_autoBrush;
 }
 
 void KisAutoBrushWidget::setBrush(KisBrushSP brush)
 {
     m_autoBrush = brush;
     m_brush = brush->image();
     // XXX: lock, set and unlock the widgets.
     KisAutoBrush* aBrush = dynamic_cast<KisAutoBrush*>(brush.data());
 
     KisSignalsBlocker b1(comboBoxShape, comboBoxMaskType);
     KisSignalsBlocker b2(inputRadius, inputRatio, inputHFade, inputVFade, inputAngle, inputSpikes);
     KisSignalsBlocker b3(spacingWidget, inputRandomness, density, softnessCurve, btnAntialiasing);
 
     if (aBrush->maskGenerator()->type() == KisMaskGenerator::CIRCLE) {
         comboBoxShape->setCurrentIndex(0);
     }
     else if (aBrush->maskGenerator()->type() == KisMaskGenerator::RECTANGLE) {
         comboBoxShape->setCurrentIndex(1);
     }
     else {
         comboBoxShape->setCurrentIndex(2);
     }
 
     const int mastTypeIndex = comboBoxMaskType->findText(aBrush->maskGenerator()->name());
     comboBoxMaskType->setCurrentIndex(mastTypeIndex);
     setStackedWidget(mastTypeIndex); // adjusting manually because the signals are blocked
 
     inputRadius->setValue(aBrush->maskGenerator()->diameter());
     inputRatio->setValue(aBrush->maskGenerator()->ratio());
     inputHFade->setValue(aBrush->maskGenerator()->horizontalFade());
     inputVFade->setValue(aBrush->maskGenerator()->verticalFade());
     inputAngle->setValue(aBrush->angle() * 180 / M_PI);
     inputSpikes->setValue(aBrush->maskGenerator()->spikes());
     spacingWidget->setSpacing(aBrush->autoSpacingActive(),
                               aBrush->autoSpacingActive() ?
                               aBrush->autoSpacingCoeff() : aBrush->spacing());
     inputRandomness->setValue(aBrush->randomness() * 100);
     density->setValue(aBrush->density() * 100);
 
     if (!aBrush->maskGenerator()->curveString().isEmpty()) {
         KisCubicCurve curve;
         curve.fromString(aBrush->maskGenerator()->curveString());
         softnessCurve->setCurve(curve);
     }
 
     btnAntialiasing->setChecked(aBrush->maskGenerator()->antialiasEdges());
 
     drawBrushPreviewArea(); // sync up what the brush preview area looks like
 }
 
 
 void KisAutoBrushWidget::setBrushSize(qreal dxPixels, qreal dyPixels)
 {
     Q_UNUSED(dyPixels);
 
     qreal newWidth = inputRadius->value() + dxPixels;
     newWidth = qMax(newWidth, qreal(0.1));
 
     inputRadius->setValue(newWidth);
 }
 
 QSizeF KisAutoBrushWidget::brushSize() const
 {
     return QSizeF(inputRadius->value(), inputRadius->value() * inputRatio->value());
 }
 
 #include "moc_kis_auto_brush_widget.cpp"
diff --git a/plugins/paintops/libpaintop/kis_current_outline_fetcher.cpp b/plugins/paintops/libpaintop/kis_current_outline_fetcher.cpp
index 599a46d649..fee3928f66 100644
--- a/plugins/paintops/libpaintop/kis_current_outline_fetcher.cpp
+++ b/plugins/paintops/libpaintop/kis_current_outline_fetcher.cpp
@@ -1,162 +1,162 @@
 /*
  *  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_current_outline_fetcher.h"
 
 #include "kis_pressure_size_option.h"
 #include "kis_pressure_rotation_option.h"
 #include "kis_pressure_mirror_option.h"
 #include <brushengine/kis_paintop_settings.h>
 #include <kis_properties_configuration.h>
 #include "kis_paintop_settings.h"
 #include <QElapsedTimer>
 
 #define NOISY_UPDATE_SPEED 50  // Time in ms for outline updates to noisy brushes
 
 struct KisCurrentOutlineFetcher::Private {
     Private(Options optionsAvailable)
         : isDirty(true) {
         if (optionsAvailable & SIZE_OPTION) {
             sizeOption.reset(new KisPressureSizeOption());
         }
 
         if (optionsAvailable & ROTATION_OPTION) {
             rotationOption.reset(new KisPressureRotationOption());
         }
 
         if (optionsAvailable & MIRROR_OPTION) {
             mirrorOption.reset(new KisPressureMirrorOption());
         }
     }
 
     QScopedPointer<KisPressureSizeOption> sizeOption;
     QScopedPointer<KisPressureRotationOption> rotationOption;
     QScopedPointer<KisPressureMirrorOption> mirrorOption;
 
     bool isDirty;
     QElapsedTimer lastUpdateTime;
 
     qreal lastRotationApplied;
     qreal lastSizeApplied;
     MirrorProperties lastMirrorApplied;
 };
 
 KisCurrentOutlineFetcher::KisCurrentOutlineFetcher(Options optionsAvailable)
     : d(new Private(optionsAvailable))
 {
     d->lastUpdateTime.start();
 }
 
 KisCurrentOutlineFetcher::~KisCurrentOutlineFetcher()
 {
 }
 
 void KisCurrentOutlineFetcher::setDirty()
 {
     d->isDirty = true;
 }
 
 QPainterPath KisCurrentOutlineFetcher::fetchOutline(const KisPaintInformation &info,
                                                     const KisPaintOpSettingsSP settings,
                                                     const QPainterPath &originalOutline,
                                                     const KisPaintOpSettings::OutlineMode &mode,
                                                     qreal additionalScale,
                                                     qreal additionalRotation,
                                                     bool tilt, qreal tiltcenterx, qreal tiltcentery) const
 {
     if (d->isDirty) {
         if (d->sizeOption) {
             d->sizeOption->readOptionSetting(settings);
             d->sizeOption->resetAllSensors();
         }
 
         if (d->rotationOption) {
             d->rotationOption->readOptionSetting(settings);
             d->rotationOption->resetAllSensors();
         }
 
         if (d->mirrorOption) {
             d->mirrorOption->readOptionSetting(settings);
             d->mirrorOption->resetAllSensors();
         }
 
         d->isDirty = false;
     }
 
     qreal scale = additionalScale;
     qreal rotation = additionalRotation;
     bool needsUpdate = false;
 
     // Randomized rotation at full speed looks noisy, so slow it down
     if (d->lastUpdateTime.elapsed() > NOISY_UPDATE_SPEED) {
         needsUpdate = true;
         d->lastUpdateTime.restart();
     }
 
     if (d->sizeOption && !tilt && !mode.forceFullSize) {
         if (!d->sizeOption->isRandom() || needsUpdate) {
             d->lastSizeApplied = d->sizeOption->apply(info);
         }
         scale *= d->lastSizeApplied;
     }
 
     if (d->rotationOption && !tilt) {
         if (!d->rotationOption->isRandom() || needsUpdate) {
             d->lastRotationApplied = d->rotationOption->apply(info);
         }
         rotation += d->lastRotationApplied;
     } else if (d->rotationOption && tilt) {
-        rotation += settings->getDouble("runtimeCanvasRotation", 0.0) * M_PI / 180.0;
+        rotation += info.canvasRotation() * M_PI / 180.0;
     }
 
     qreal xFlip = 1.0;
     qreal yFlip = 1.0;
 
     if (d->mirrorOption) {
         if (!d->mirrorOption->isRandom() || needsUpdate) {
             d->lastMirrorApplied = d->mirrorOption->apply(info);
         }
 
         if (d->lastMirrorApplied.coordinateSystemFlipped) {
             rotation = 2 * M_PI - rotation;
         }
 
         if (d->lastMirrorApplied.horizontalMirror) {
             xFlip = -1.0;
         }
 
         if (d->lastMirrorApplied.verticalMirror) {
             yFlip = -1.0;
         }
     }
 
 
     QTransform rot;
     rot.rotateRadians(-rotation);
 
     QPointF hotSpot = originalOutline.boundingRect().center();
     if (tilt) {
         hotSpot.setX(tiltcenterx);
         hotSpot.setY(tiltcentery);
     }
     QTransform T1 = QTransform::fromTranslate(-hotSpot.x(), -hotSpot.y());
     QTransform T2 = QTransform::fromTranslate(info.pos().x(), info.pos().y());
     QTransform S  = QTransform::fromScale(xFlip * scale, yFlip * scale);
 
     return (T1 * rot * S * T2).map(originalOutline);
 }
diff --git a/plugins/paintops/libpaintop/kis_curve_option.h b/plugins/paintops/libpaintop/kis_curve_option.h
index 2397ae6ca6..881d3dc3a4 100644
--- a/plugins/paintops/libpaintop/kis_curve_option.h
+++ b/plugins/paintops/libpaintop/kis_curve_option.h
@@ -1,213 +1,213 @@
 /* This file is part of the KDE project
  * Copyright (C) 2008 Boudewijn Rempt <boud@valdyas.org>
  * Copyright (C) 2011 Silvio Heinrich <plassy@web.de>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_CURVE_OPTION_H
 #define KIS_CURVE_OPTION_H
 
 #include <QObject>
 #include <QVector>
 
 #include "kis_paintop_option.h"
 #include "kis_global.h"
 #include <brushengine/kis_paint_information.h>
 #include "kritapaintop_export.h"
 #include "kis_dynamic_sensor.h"
 
 class KisDynamicSensor;
 
 /**
  * KisCurveOption is the base class for paintop options that are
  * defined through one or more curves.
  *
  * Note: it is NOT a KisPaintOpOption, even though the API is pretty similar!
  *
  * KisCurveOption classes have a generic GUI widget, KisCurveOptionWidget. So,
  * in contrast to KisPaintOpOption classes, KisCurveOption instances can and
  * will be created in the constructor of KisPaintOp paintops. This class can
  * manage to read and write its settings directly.
  *
  */
 class PAINTOP_EXPORT KisCurveOption
 {
 public:
     KisCurveOption(const QString& name,
                    KisPaintOpOption::PaintopCategory category,
                    bool checked,
                    qreal value = 1.0,
                    qreal min = 0.0,
                    qreal max = 1.0);
 
     virtual ~KisCurveOption();
 
     virtual void writeOptionSetting(KisPropertiesConfigurationSP setting) const;
     virtual void readOptionSetting(KisPropertiesConfigurationSP setting);
     virtual void lodLimitations(KisPaintopLodLimitations *l) const;
 
     //Please override for other values than 0-100 and %
     virtual int intMinValue()const;
     virtual int intMaxValue()const;
     virtual QString valueSuffix()const;
 
     const QString& name() const;
     KisPaintOpOption::PaintopCategory category() const;
     qreal minValue() const;
     qreal maxValue() const;
     qreal value() const;
 
     void resetAllSensors();
     KisDynamicSensorSP sensor(DynamicSensorType sensorType, bool active) const;
     void replaceSensor(KisDynamicSensorSP sensor);
     QList<KisDynamicSensorSP> sensors();
     QList<KisDynamicSensorSP> activeSensors() const;
 
     bool isCheckable();
     bool isChecked() const;
     bool isCurveUsed() const;
     bool isSameCurveUsed() const;
     bool isRandom() const;
 
     int getCurveMode() const;
 
     void setSeparateCurveValue(bool separateCurveValue);
 
     void setChecked(bool checked);
     void setCurveUsed(bool useCurve);
     void setCurve(DynamicSensorType sensorType, bool useSameCurve, const KisCubicCurve &curve);
     void setValue(qreal value);
     void setCurveMode(int mode);
 
     struct ValueComponents {
 
         ValueComponents()
             : constant(1.0),
               scaling(1.0),
               additive(0.0),
               absoluteOffset(0.0),
               hasAbsoluteOffset(false),
               hasScaling(false),
               hasAdditive(false)
         {
         }
 
         qreal constant;
         qreal scaling;
         qreal additive;
         qreal absoluteOffset;
         bool hasAbsoluteOffset;
         bool hasScaling;
         bool hasAdditive;
         qreal minSizeLikeValue;
         qreal maxSizeLikeValue;
 
         /**
          * @param normalizedBaseAngle canvas rotation angle normalized to range [0; 1]
          * @param absoluteAxesFlipped true if underlying image coordinate system is flipped (horiz. mirror != vert. mirror)
          */
 
         qreal rotationLikeValue(qreal normalizedBaseAngle, bool absoluteAxesFlipped) const {
             const qreal offset =
                 !hasAbsoluteOffset ? normalizedBaseAngle :
                 absoluteAxesFlipped ? 1.0 - absoluteOffset :
                 absoluteOffset;
 
             const qreal realScalingPart = hasScaling ? KisDynamicSensor::scalingToAdditive(scaling) : 0.0;
             const qreal realAdditivePart = hasAdditive ? additive : 0;
 
-            qreal value = wrapInRange(2 * offset + constant * realScalingPart + realAdditivePart, -1.0, 1.0);
+            qreal value = wrapInRange(2 * offset + constant * (realScalingPart + realAdditivePart), -1.0, 1.0);
             if (qIsNaN(value)) {
                 qWarning() << "rotationLikeValue returns NaN!" << normalizedBaseAngle << absoluteAxesFlipped;
                 value = 0;
             }
             return value;
         }
 
         qreal sizeLikeValue() const {
             const qreal offset =
                 hasAbsoluteOffset ? absoluteOffset : 1.0;
 
             const qreal realScalingPart = hasScaling ? scaling : 1.0;
             const qreal realAdditivePart = hasAdditive ? KisDynamicSensor::additiveToScaling(additive) : 1.0;
 
             return qBound(minSizeLikeValue,
                           constant * offset * realScalingPart * realAdditivePart,
                           maxSizeLikeValue);
         }
 
     private:
         static inline qreal wrapInRange(qreal x, qreal min, qreal max) {
             const qreal range = max - min;
 
             x -= min;
 
             if (x < 0.0) {
                 x = range + fmod(x, range);
             }
 
             if (x > range) {
                 x = fmod(x, range);
             }
 
             return x + min;
         }
     };
 
     /**
      * Uses the curves set on the sensors to compute a single
      * double value that can control the parameters of a brush.
      *
      * This value is derives from the values stored in
      * ValuesComponents object.
      */
     ValueComponents computeValueComponents(const KisPaintInformation& info) const;
 
     qreal computeSizeLikeValue(const KisPaintInformation &info) const;
     qreal computeRotationLikeValue(const KisPaintInformation& info, qreal baseValue, bool absoluteAxesFlipped) const;
 
 protected:
 
     void setValueRange(qreal min, qreal max);
 
     /**
      * Read the option using the prefix in argument
      */
     void readNamedOptionSetting(const QString& prefix, const KisPropertiesConfigurationSP setting);
 
     QString m_name;
     KisPaintOpOption::PaintopCategory m_category;
 
     bool m_checkable;
     bool m_checked;
     bool m_useCurve;
     bool m_useSameCurve;
     bool m_separateCurveValue;
 
     int m_curveMode;
 
     QMap<DynamicSensorType, KisDynamicSensorSP> m_sensorMap;
     QMap<DynamicSensorType, KisCubicCurve> m_curveCache;
 
 private:
 
     qreal m_value;
     qreal m_minValue;
     qreal m_maxValue;
 };
 
 #endif
diff --git a/plugins/paintops/libpaintop/kis_curve_option_widget.cpp b/plugins/paintops/libpaintop/kis_curve_option_widget.cpp
index d474fe0376..66d41decdb 100644
--- a/plugins/paintops/libpaintop/kis_curve_option_widget.cpp
+++ b/plugins/paintops/libpaintop/kis_curve_option_widget.cpp
@@ -1,324 +1,340 @@
 /* This file is part of the KDE project
  * Copyright (C) 2008 Boudewijn Rempt <boud@valdyas.org>
  * Copyright (C) 2009 Sven Langkamp   <sven.langkamp@gmail.com>
  * Copyright (C) 2011 Silvio Heinrich <plassy@web.de>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "kis_curve_option_widget.h"
 
 #include "ui_wdgcurveoption.h"
 #include "widgets/kis_curve_widget.h"
 #include "kis_dynamic_sensor.h"
 #include "kis_global.h"
 #include "kis_curve_option.h"
 #include "kis_signals_blocker.h"
 #include "kis_icon_utils.h"
 
 inline void setLabel(QLabel* label, const KisCurveLabel& curve_label)
 {
     if (curve_label.icon().isNull()) {
         label->setText(curve_label.name());
     }
     else {
         label->setPixmap(QPixmap::fromImage(curve_label.icon()));
     }
 }
 
 KisCurveOptionWidget::KisCurveOptionWidget(KisCurveOption* curveOption, const QString &minLabel, const QString &maxLabel, bool hideSlider)
     : KisPaintOpOption(curveOption->category(), curveOption->isChecked())
     , m_widget(new QWidget)
     , m_curveOptionWidget(new Ui_WdgCurveOption())
     , m_curveOption(curveOption)
 {
     setObjectName("KisCurveOptionWidget");
 
     m_curveOptionWidget->setupUi(m_widget);
     setConfigurationPage(m_widget);
 
     m_curveOptionWidget->sensorSelector->setCurveOption(curveOption);
 
     updateSensorCurveLabels(m_curveOptionWidget->sensorSelector->currentHighlighted());
     updateCurve(m_curveOptionWidget->sensorSelector->currentHighlighted());
 
-    connect(m_curveOptionWidget->curveWidget, SIGNAL(modified()), this, SLOT(transferCurve()));
+    connect(m_curveOptionWidget->curveWidget, SIGNAL(modified()), this, SLOT(slotModified()));
     connect(m_curveOptionWidget->sensorSelector, SIGNAL(parametersChanged()), SLOT(emitSettingChanged()));
     connect(m_curveOptionWidget->sensorSelector, SIGNAL(parametersChanged()), SLOT(updateLabelsOfCurrentSensor()));
     connect(m_curveOptionWidget->sensorSelector, SIGNAL(highlightedSensorChanged(KisDynamicSensorSP)), SLOT(updateSensorCurveLabels(KisDynamicSensorSP)));
     connect(m_curveOptionWidget->sensorSelector, SIGNAL(highlightedSensorChanged(KisDynamicSensorSP)), SLOT(updateCurve(KisDynamicSensorSP)));
-    connect(m_curveOptionWidget->checkBoxUseSameCurve, SIGNAL(stateChanged(int)), SLOT(transferCurve()));
+    connect(m_curveOptionWidget->checkBoxUseSameCurve, SIGNAL(stateChanged(int)), SLOT(slotStateChanged()));
 
 
     // set all the icons for the curve preset shapes
     updateThemedIcons();
 
     // various curve preset buttons with predefined curves
     connect(m_curveOptionWidget->linearCurveButton, SIGNAL(clicked(bool)), this, SLOT(changeCurveLinear()));
     connect(m_curveOptionWidget->revLinearButton, SIGNAL(clicked(bool)), this, SLOT(changeCurveReverseLinear()));
     connect(m_curveOptionWidget->jCurveButton, SIGNAL(clicked(bool)), this, SLOT(changeCurveJShape()));
     connect(m_curveOptionWidget->lCurveButton, SIGNAL(clicked(bool)), this, SLOT(changeCurveLShape()));
     connect(m_curveOptionWidget->sCurveButton, SIGNAL(clicked(bool)), this, SLOT(changeCurveSShape()));
     connect(m_curveOptionWidget->reverseSCurveButton, SIGNAL(clicked(bool)), this, SLOT(changeCurveReverseSShape()));
     connect(m_curveOptionWidget->uCurveButton, SIGNAL(clicked(bool)), this, SLOT(changeCurveUShape()));
     connect(m_curveOptionWidget->revUCurveButton, SIGNAL(clicked(bool)), this, SLOT(changeCurveArchShape()));
 
 
     m_curveOptionWidget->label_ymin->setText(minLabel);
     m_curveOptionWidget->label_ymax->setText(maxLabel);
 
     // strength settings is shown as 0-100%
     m_curveOptionWidget->strengthSlider->setRange(curveOption->minValue()*100, curveOption->maxValue()*100, 0);
     m_curveOptionWidget->strengthSlider->setValue(curveOption->value()*100);
     m_curveOptionWidget->strengthSlider->setPrefix(i18n("Strength: "));
     m_curveOptionWidget->strengthSlider->setSuffix(i18n("%"));
 
 
     if (hideSlider) {
          m_curveOptionWidget->strengthSlider->hide();
     }
 
     connect(m_curveOptionWidget->checkBoxUseCurve, SIGNAL(stateChanged(int))  , SLOT(updateValues()));
     connect(m_curveOptionWidget->curveMode, SIGNAL(currentIndexChanged(int)), SLOT(updateMode()));
     connect(m_curveOptionWidget->strengthSlider, SIGNAL(valueChanged(qreal)), SLOT(updateValues()));
 }
 
 KisCurveOptionWidget::~KisCurveOptionWidget()
 {
     delete m_curveOption;
     delete m_curveOptionWidget;
 }
 
 void KisCurveOptionWidget::writeOptionSetting(KisPropertiesConfigurationSP setting) const
 {
     m_curveOption->writeOptionSetting(setting);
 }
 
 void KisCurveOptionWidget::readOptionSetting(const KisPropertiesConfigurationSP setting)
 {
     //setting->dump();
 
     m_curveOption->readOptionSetting(setting);
 
     m_curveOptionWidget->checkBoxUseCurve->setChecked(m_curveOption->isCurveUsed());
     m_curveOptionWidget->strengthSlider->setValue(m_curveOption->value()*100);
     m_curveOptionWidget->checkBoxUseSameCurve->setChecked(m_curveOption->isSameCurveUsed());
     m_curveOptionWidget->curveMode->setCurrentIndex(m_curveOption->getCurveMode());
 
     disableWidgets(!m_curveOption->isCurveUsed());
 
     m_curveOptionWidget->sensorSelector->reload();
     m_curveOptionWidget->sensorSelector->setCurrent(m_curveOption->activeSensors().first());
     updateSensorCurveLabels(m_curveOptionWidget->sensorSelector->currentHighlighted());
     updateCurve(m_curveOptionWidget->sensorSelector->currentHighlighted());
+
+    if (m_curveOption->isSameCurveUsed()) {
+        // make sure the curve is transfered to all sensors to avoid updating from a wrong curve later
+        transferCurve();
+    }
 }
 
 void KisCurveOptionWidget::lodLimitations(KisPaintopLodLimitations *l) const
 {
     m_curveOption->lodLimitations(l);
 }
 
 bool KisCurveOptionWidget::isCheckable() const
 {
     return m_curveOption->isCheckable();
 }
 
 bool KisCurveOptionWidget::isChecked() const
 {
     return m_curveOption->isChecked();
 }
 
 void KisCurveOptionWidget::setChecked(bool checked)
 {
     m_curveOption->setChecked(checked);
 }
 
 KisCurveOption* KisCurveOptionWidget::curveOption()
 {
     return m_curveOption;
 }
 
 QWidget* KisCurveOptionWidget::curveWidget()
 {
     return m_widget;
 }
 
+void KisCurveOptionWidget::slotModified()
+{
+    transferCurve();
+}
+
+void KisCurveOptionWidget::slotStateChanged()
+{
+    transferCurve();
+}
+
+
 void KisCurveOptionWidget::transferCurve()
 {
     m_curveOptionWidget->sensorSelector->setCurrentCurve(m_curveOptionWidget->curveWidget->curve(), m_curveOptionWidget->checkBoxUseSameCurve->isChecked());
     emitSettingChanged();
 }
 
 void KisCurveOptionWidget::updateSensorCurveLabels(KisDynamicSensorSP sensor)
 {
     if (sensor) {
         m_curveOptionWidget->label_xmin->setText(KisDynamicSensor::minimumLabel(sensor->sensorType()));
         m_curveOptionWidget->label_xmax->setText(KisDynamicSensor::maximumLabel(sensor->sensorType(), sensor->length()));
 
         int inMinValue = KisDynamicSensor::minimumValue(sensor->sensorType());
         int inMaxValue = KisDynamicSensor::maximumValue(sensor->sensorType(), sensor->length());
         QString inSuffix = KisDynamicSensor::valueSuffix(sensor->sensorType());
 
         int outMinValue = m_curveOption->intMinValue();
         int outMaxValue = m_curveOption->intMaxValue();
         QString outSuffix = m_curveOption->valueSuffix();
 
         m_curveOptionWidget->intIn->setSuffix(inSuffix);
         m_curveOptionWidget->intOut->setSuffix(outSuffix);
 
         m_curveOptionWidget->curveWidget->setupInOutControls(m_curveOptionWidget->intIn,m_curveOptionWidget->intOut,
                                                          inMinValue,inMaxValue,outMinValue,outMaxValue);
     }
 }
 
 void KisCurveOptionWidget::updateCurve(KisDynamicSensorSP sensor)
 {
     if (sensor) {
         bool blockSignal = m_curveOptionWidget->curveWidget->blockSignals(true);
         m_curveOptionWidget->curveWidget->setCurve(sensor->curve());
         m_curveOptionWidget->curveWidget->blockSignals(blockSignal);
     }
 }
 
 void KisCurveOptionWidget::updateLabelsOfCurrentSensor()
 {
     updateSensorCurveLabels(m_curveOptionWidget->sensorSelector->currentHighlighted());
     updateCurve(m_curveOptionWidget->sensorSelector->currentHighlighted());
 }
 
 void KisCurveOptionWidget::updateValues()
 {
     m_curveOption->setValue(m_curveOptionWidget->strengthSlider->value()/100.0); // convert back to 0-1 for data
     m_curveOption->setCurveUsed(m_curveOptionWidget->checkBoxUseCurve->isChecked());
     disableWidgets(!m_curveOptionWidget->checkBoxUseCurve->isChecked());
     emitSettingChanged();
 }
 
 void KisCurveOptionWidget::updateMode()
 {
     m_curveOption->setCurveMode(m_curveOptionWidget->curveMode->currentIndex());
     emitSettingChanged();
 }
 
 void KisCurveOptionWidget::changeCurveLinear()
 {
     QList<QPointF> points;
     points.push_back(QPointF(0,0));
     points.push_back(QPointF(1,1));
     m_curveOptionWidget->curveWidget->setCurve(KisCubicCurve(points));
 }
 
 void KisCurveOptionWidget::changeCurveReverseLinear()
 {
         QList<QPointF> points;
         points.push_back(QPointF(0,1));
         points.push_back(QPointF(1,0));
         m_curveOptionWidget->curveWidget->setCurve(KisCubicCurve(points));
 }
 
 void KisCurveOptionWidget::changeCurveSShape()
 {
         QList<QPointF> points;
         points.push_back(QPointF(0,0));
         points.push_back(QPointF(0.25,0.1));
         points.push_back(QPointF(0.75,0.9));
         points.push_back(QPointF(1, 1));
         m_curveOptionWidget->curveWidget->setCurve(KisCubicCurve(points));
 }
 
 
 void KisCurveOptionWidget::changeCurveReverseSShape()
 {
         QList<QPointF> points;
         points.push_back(QPointF(0,1));
         points.push_back(QPointF(0.25,0.9));
         points.push_back(QPointF(0.75,0.1));
         points.push_back(QPointF(1,0));
         m_curveOptionWidget->curveWidget->setCurve(KisCubicCurve(points));
 }
 
 void KisCurveOptionWidget::changeCurveJShape()
 {
     QList<QPointF> points;
     points.push_back(QPointF(0,0));
     points.push_back(QPointF(0.35,0.1));
     points.push_back(QPointF(1,1));
     m_curveOptionWidget->curveWidget->setCurve(KisCubicCurve(points));
 }
 
 void KisCurveOptionWidget::changeCurveLShape()
 {
     QList<QPointF> points;
     points.push_back(QPointF(0,1));
     points.push_back(QPointF(0.25,0.48));
     points.push_back(QPointF(1,0));
     m_curveOptionWidget->curveWidget->setCurve(KisCubicCurve(points));
 }
 
 void KisCurveOptionWidget::changeCurveUShape()
 {
     QList<QPointF> points;
     points.push_back(QPointF(0,1));
     points.push_back(QPointF(0.5,0));
     points.push_back(QPointF(1,1));
     m_curveOptionWidget->curveWidget->setCurve(KisCubicCurve(points));
 }
 
 void KisCurveOptionWidget::changeCurveArchShape()
 {
     QList<QPointF> points;
     points.push_back(QPointF(0,0));
     points.push_back(QPointF(0.5,1));
     points.push_back(QPointF(1,0));
     m_curveOptionWidget->curveWidget->setCurve(KisCubicCurve(points));
 }
 
 
 
 
 void KisCurveOptionWidget::disableWidgets(bool disable)
 {
     m_curveOptionWidget->checkBoxUseSameCurve->setDisabled(disable);
     m_curveOptionWidget->curveWidget->setDisabled(disable);
     m_curveOptionWidget->sensorSelector->setDisabled(disable);
     m_curveOptionWidget->label_xmax->setDisabled(disable);
     m_curveOptionWidget->label_xmin->setDisabled(disable);
     m_curveOptionWidget->label_ymax->setDisabled(disable);
     m_curveOptionWidget->label_ymin->setDisabled(disable);
 
 }
 
 
 void KisCurveOptionWidget::updateThemedIcons()
 {
     // set all the icons for the curve preset shapes
     m_curveOptionWidget->linearCurveButton->setIcon(KisIconUtils::loadIcon("curve-preset-linear"));
     m_curveOptionWidget->revLinearButton->setIcon(KisIconUtils::loadIcon("curve-preset-linear-reverse"));
     m_curveOptionWidget->jCurveButton->setIcon(KisIconUtils::loadIcon("curve-preset-j"));
     m_curveOptionWidget->lCurveButton->setIcon(KisIconUtils::loadIcon("curve-preset-l"));
     m_curveOptionWidget->sCurveButton->setIcon(KisIconUtils::loadIcon("curve-preset-s"));
     m_curveOptionWidget->reverseSCurveButton->setIcon(KisIconUtils::loadIcon("curve-preset-s-reverse"));
     m_curveOptionWidget->uCurveButton->setIcon(KisIconUtils::loadIcon("curve-preset-u"));
     m_curveOptionWidget->revUCurveButton->setIcon(KisIconUtils::loadIcon("curve-preset-arch"));
 
     // this helps make the checkboxes show themselves on the dark color themes
     QPalette pal = m_curveOptionWidget->sensorSelector->palette();
     QPalette newPalette = pal;
     newPalette.setColor(QPalette::Active, QPalette::Background, pal.text().color() );
     m_curveOptionWidget->sensorSelector->setPalette(newPalette);
 
 }
 
diff --git a/plugins/paintops/libpaintop/kis_curve_option_widget.h b/plugins/paintops/libpaintop/kis_curve_option_widget.h
index eae9d1be19..e5ba4a2ccc 100644
--- a/plugins/paintops/libpaintop/kis_curve_option_widget.h
+++ b/plugins/paintops/libpaintop/kis_curve_option_widget.h
@@ -1,84 +1,87 @@
 /* This file is part of the KDE project
  * Copyright (C) 2008 Boudewijn Rempt <boud@valdyas.org>
  * Copyright (C) 2009 Sven Langkamp   <sven.langkamp@gmail.com>
  * Copyright (C) 2011 Silvio Heinrich <plassy@web.de>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_CURVE_OPTION_WIDGET_H
 #define KIS_CURVE_OPTION_WIDGET_H
 
 #include <kis_paintop_option.h>
 
 class Ui_WdgCurveOption;
 class KisCurveOption;
 class QComboBox;
 
 #include <kis_dynamic_sensor.h>
 
 class PAINTOP_EXPORT KisCurveOptionWidget : public KisPaintOpOption
 {
     Q_OBJECT
 public:
     KisCurveOptionWidget(KisCurveOption* curveOption, const QString &minLabel, const QString &maxLabel, bool hideSlider = false);
     ~KisCurveOptionWidget() override;
 
     void writeOptionSetting(KisPropertiesConfigurationSP setting) const override;
     void readOptionSetting(const KisPropertiesConfigurationSP setting) override;
     void lodLimitations(KisPaintopLodLimitations *l) const override;
 
     bool isCheckable() const override;
     bool isChecked() const override;
     void setChecked(bool checked) override;
     void show();
 
 protected:
 
     KisCurveOption* curveOption();
     QWidget* curveWidget();
 
 private Q_SLOTS:
 
+    void slotModified();
+    void slotStateChanged();
+
     void transferCurve();
     void updateSensorCurveLabels(KisDynamicSensorSP sensor);
     void updateCurve(KisDynamicSensorSP sensor);
     void updateValues();
     void updateMode();
     void updateLabelsOfCurrentSensor();
     void disableWidgets(bool disable);
     void updateThemedIcons();
 
 
     // curve shape preset buttons
     void changeCurveLinear();
     void changeCurveReverseLinear();
     void changeCurveSShape();
     void changeCurveReverseSShape();
     void changeCurveJShape();
     void changeCurveLShape();
     void changeCurveUShape();
     void changeCurveArchShape();
 
 
 private:
     QWidget* m_widget;
     Ui_WdgCurveOption* m_curveOptionWidget;
     QComboBox* m_curveMode;
     KisCurveOption* m_curveOption;
 };
 
 #endif // KIS_CURVE_OPTION_WIDGET_H
diff --git a/plugins/paintops/libpaintop/kis_pressure_flow_opacity_option_widget.cpp b/plugins/paintops/libpaintop/kis_pressure_flow_opacity_option_widget.cpp
index 393e30c35d..fce135725f 100644
--- a/plugins/paintops/libpaintop/kis_pressure_flow_opacity_option_widget.cpp
+++ b/plugins/paintops/libpaintop/kis_pressure_flow_opacity_option_widget.cpp
@@ -1,75 +1,75 @@
 /*
  * Copyright (c) 2011 Silvio Heinrich <plassy@web.de>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include <klocalizedstring.h>
 
 #include <QWidget>
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 #include <QGroupBox>
 #include <QStackedWidget>
 #include <QButtonGroup>
 #include <QPushButton>
 
 #include "kis_pressure_flow_opacity_option_widget.h"
 #include "kis_curve_option_widget.h"
 #include "kis_node.h"
 #include <kis_slider_spin_box.h>
 
 #include "ui_wdgflowopacityoption.h"
 
 KisFlowOpacityOptionWidget::KisFlowOpacityOptionWidget():
     KisCurveOptionWidget(new KisFlowOpacityOption(0), i18n("Transparent"), i18n("Opaque"), true)
 {
     setObjectName("KisFlowOpacityOptionWidget");
 
     QWidget* widget = new QWidget();
 
     Ui_wdgFlowOpacityOption ui;
     ui.setupUi(widget);
     ui.layout->addWidget(curveWidget());
 
     m_opacitySlider = ui.opacitySlider;
     m_opacitySlider->setRange(0.0, 100.0, 0);
     m_opacitySlider->setValue(100);
     m_opacitySlider->setPrefix("Opacity: ");
-    m_opacitySlider->setSuffix("%");
+    m_opacitySlider->setSuffix(i18n("%"));
 
     setConfigurationPage(widget);
 
     connect(m_opacitySlider, SIGNAL(valueChanged(qreal)), SLOT(slotSliderValueChanged()));
 }
 
 void KisFlowOpacityOptionWidget::readOptionSetting(const KisPropertiesConfigurationSP setting)
 {
     KisCurveOptionWidget::readOptionSetting(setting);
     KisFlowOpacityOption* option = static_cast<KisFlowOpacityOption*>(curveOption());
 
     m_opacitySlider->blockSignals(true);
     m_opacitySlider->setValue(option->getStaticOpacity()*100);
     m_opacitySlider->blockSignals(false);
 }
 
 void KisFlowOpacityOptionWidget::slotSliderValueChanged()
 {
     KisFlowOpacityOption* option = static_cast<KisFlowOpacityOption*>(curveOption());
     option->setOpacity(m_opacitySlider->value()/100.0);
 
     emitSettingChanged();
 }
diff --git a/plugins/paintops/libpaintop/kis_pressure_hsv_option.cpp b/plugins/paintops/libpaintop/kis_pressure_hsv_option.cpp
index d6a7f748c7..22d45c2ba7 100644
--- a/plugins/paintops/libpaintop/kis_pressure_hsv_option.cpp
+++ b/plugins/paintops/libpaintop/kis_pressure_hsv_option.cpp
@@ -1,175 +1,174 @@
 /* This file is part of the KDE project
  * Copyright (c) 2010 Cyrille Berger <cberger@cberger.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU 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_pressure_hsv_option.h"
 #include <KoColorTransformation.h>
 #include <kis_debug.h>
 
 KisPressureHSVOption* KisPressureHSVOption::createHueOption() {
     return new KisPressureHSVOption("h");
 }
 
 QString KisPressureHSVOption::hueMinLabel()
 {
     // xgettext: no-c-format
     QString activeColorMsg = i18n("(0° is active color)");
     QString br("<br />");
     QString fullPercent = i18n("+180°");
     QString zeroPercent = i18n("-180°");
 
     return QString(zeroPercent + br + i18n("CCW hue") + br + activeColorMsg);
 }
 
 QString KisPressureHSVOption::huemaxLabel()
 {
     // xgettext: no-c-format
     QString activeColorMsg = i18n("(0° is active color)");
     QString br("<br />");
     QString fullPercent = i18n("+180°");
     QString zeroPercent = i18n("-180°");
 
     return QString(fullPercent + br + i18n("CW hue"));
 }
 
 KisPressureHSVOption* KisPressureHSVOption::createSaturationOption() {
     return new KisPressureHSVOption("s");
 }
 
 QString KisPressureHSVOption::saturationMinLabel()
 {
     // xgettext: no-c-format
     QString activeColorMsg = i18n("(50% is active color)");
     QString br("<br />");
     QString fullPercent = i18n("+100%");
     QString zeroPercent = i18n("-100%");
 
     return QString(zeroPercent + br + i18n("Less saturation ") + br + activeColorMsg);
 
 }
 
 QString KisPressureHSVOption::saturationmaxLabel()
 {
     // xgettext: no-c-format
     QString activeColorMsg = i18n("(50% is active color)");
     QString br("<br />");
     QString fullPercent = i18n("+100%");
     QString zeroPercent = i18n("-100%");
 
     return QString(fullPercent + br + i18n("More saturation"));
 }
 
 KisPressureHSVOption* KisPressureHSVOption::createValueOption() {
     return new KisPressureHSVOption("v");
 }
 
 QString KisPressureHSVOption::valueMinLabel()
 {
     // xgettext: no-c-format
     QString activeColorMsg = i18n("(50% is active color)");
     QString br("<br />");
     QString fullPercent = i18n("+100%");
     QString zeroPercent = i18n("-100%");
 
     return QString(zeroPercent + br + i18n("Lower value ") + br + activeColorMsg);
 
 }
 
 QString KisPressureHSVOption::valuemaxLabel()
 {
     // xgettext: no-c-format
     QString activeColorMsg = i18n("(50% is active color)");
     QString br("<br />");
     QString fullPercent = i18n("+100%");
     QString zeroPercent = i18n("-100%");
 
     return QString(fullPercent + br + i18n("Higher value"));
 
 
 }
 
 struct KisPressureHSVOption::Private
 {
     QString parameterName;
     int paramId;
 };
 
 KisPressureHSVOption::KisPressureHSVOption(const QString& parameterName)
     : KisCurveOption(parameterName, KisPaintOpOption::COLOR, false)
     , d(new Private())
 {
     d->parameterName = parameterName;
     d->paramId = -1;
 }
 
 KisPressureHSVOption::~KisPressureHSVOption()
 {
     delete d;
 }
 
 
 void KisPressureHSVOption::apply(KoColorTransformation* transfo, const KisPaintInformation& info) const
 {
     if (!isChecked()) {
         return;
     }
 
     if (d->paramId == -1) {
         d->paramId = transfo->parameterId(d->parameterName);
     }
 
     qreal v = computeSizeLikeValue(info);
     if (d->parameterName == "h") {
         v = computeRotationLikeValue(info, 0, false);
-        v = (v) * (this->value());//multiply by strength slider.
     } else {
         qreal halfValue = this->value()*0.5;
         v = (v*this->value()) + (0.5-halfValue);
         v = (v*2)-1;
     }
     transfo->setParameter(d->paramId, v);
     transfo->setParameter(3, 0); //sets the type to HSV.
     transfo->setParameter(4, false); //sets the colorize to false.
 }
 
 
 int KisPressureHSVOption::intMinValue() const
 {
     if (name() == "h") {
         return -180;
     } else {
         return -100;
     }
 }
 
 int KisPressureHSVOption::intMaxValue() const
 {
     if (name() == "h") {
         return 180;
     } else {
         return 100;
     }
 }
 
 QString KisPressureHSVOption::valueSuffix() const
 {
     if (name() == "h") {
         return i18n("°");
     } else {
         return i18n("%");
     }
 }
diff --git a/plugins/paintops/libpaintop/kis_pressure_mirror_option.cpp b/plugins/paintops/libpaintop/kis_pressure_mirror_option.cpp
index f32d6158b4..c026ba12bf 100644
--- a/plugins/paintops/libpaintop/kis_pressure_mirror_option.cpp
+++ b/plugins/paintops/libpaintop/kis_pressure_mirror_option.cpp
@@ -1,101 +1,98 @@
 /*
  *  Copyright (c) 2010 Lukáš Tvrdý <lukast.dev@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_pressure_mirror_option.h"
 
 #include <klocalizedstring.h>
 
 #include <kis_paint_device.h>
 #include <widgets/kis_curve_widget.h>
 
 #include <KoColor.h>
 
 KisPressureMirrorOption::KisPressureMirrorOption()
     : KisCurveOption("Mirror", KisPaintOpOption::GENERAL, false)
 {
     m_enableHorizontalMirror = false;
     m_enableVerticalMirror = false;
 }
 
 void KisPressureMirrorOption::enableHorizontalMirror(bool mirror)
 {
     m_enableHorizontalMirror = mirror;
 }
 
 void KisPressureMirrorOption::enableVerticalMirror(bool mirror)
 {
     m_enableVerticalMirror = mirror;
 }
 
 bool KisPressureMirrorOption::isHorizontalMirrorEnabled()
 {
     return m_enableHorizontalMirror;
 }
 
 bool KisPressureMirrorOption::isVerticalMirrorEnabled()
 {
     return m_enableVerticalMirror;
 }
 
 void KisPressureMirrorOption::writeOptionSetting(KisPropertiesConfigurationSP setting) const
 {
     KisCurveOption::writeOptionSetting(setting);
     setting->setProperty(MIRROR_HORIZONTAL_ENABLED, m_enableHorizontalMirror);
     setting->setProperty(MIRROR_VERTICAL_ENABLED, m_enableVerticalMirror);
 }
 
 void KisPressureMirrorOption::readOptionSetting(const KisPropertiesConfigurationSP setting)
 {
     KisCurveOption::readOptionSetting(setting);
     m_enableHorizontalMirror = setting->getBool(MIRROR_HORIZONTAL_ENABLED, false);
     m_enableVerticalMirror = setting->getBool(MIRROR_VERTICAL_ENABLED, false);
-
-    m_canvasAxisXMirrored = setting->getBool("runtimeCanvasMirroredX", false);
-    m_canvasAxisYMirrored = setting->getBool("runtimeCanvasMirroredY", false);
 }
 
 MirrorProperties KisPressureMirrorOption::apply(const KisPaintInformation& info) const
 {
-    int mirrorXIncrement = m_canvasAxisXMirrored;
-    int mirrorYIncrement = m_canvasAxisYMirrored;
+    int mirrorXIncrement = info.canvasMirroredH();
+    int mirrorYIncrement = info.canvasMirroredV();
     bool coordinateSystemFlipped = false;
 
     if (isChecked() && (m_enableHorizontalMirror || m_enableVerticalMirror)) {
 
         qreal sensorResult = computeSizeLikeValue(info);
 
         bool result = (sensorResult >= 0.5);
 
         mirrorXIncrement += result && m_enableHorizontalMirror;
         mirrorYIncrement += result && m_enableVerticalMirror;
         coordinateSystemFlipped = result &&
                                   (m_enableHorizontalMirror != m_enableVerticalMirror);
     }
 
     MirrorProperties mirrors;
 
     mirrors.verticalMirror = mirrorYIncrement % 2;
     mirrors.horizontalMirror = mirrorXIncrement % 2;
     mirrors.coordinateSystemFlipped = coordinateSystemFlipped;
 
     return mirrors;
 }
 
 
 
diff --git a/plugins/paintops/libpaintop/kis_pressure_mirror_option.h b/plugins/paintops/libpaintop/kis_pressure_mirror_option.h
index 5bcf75e837..14edf66872 100644
--- a/plugins/paintops/libpaintop/kis_pressure_mirror_option.h
+++ b/plugins/paintops/libpaintop/kis_pressure_mirror_option.h
@@ -1,76 +1,74 @@
 /*
  *  Copyright (c) 2010 Lukáš Tvrdý <lukast.dev@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_PRESSURE_MIRROR_OPTION_H
 #define KIS_PRESSURE_MIRROR_OPTION_H
 
 #include "kis_curve_option.h"
 #include <brushengine/kis_paint_information.h>
 #include <kritapaintop_export.h>
 #include <kis_types.h>
 
 
 struct MirrorProperties {
     MirrorProperties()
         : horizontalMirror(false),
           verticalMirror(false),
           coordinateSystemFlipped(false) {}
 
     bool horizontalMirror;
     bool verticalMirror;
 
     bool coordinateSystemFlipped;
 
     bool isEmpty() const {
         return !horizontalMirror && !verticalMirror;
     }
 };
 
 const QString MIRROR_HORIZONTAL_ENABLED = "HorizontalMirrorEnabled";
 const QString MIRROR_VERTICAL_ENABLED = "VerticalMirrorEnabled";
 
 /**
  * If the sensor value is higher then 0.5, then the related mirror option is true, false otherwise
  */
 class PAINTOP_EXPORT KisPressureMirrorOption : public KisCurveOption
 {
 public:
     KisPressureMirrorOption();
 
     /**
     * Set the
     */
     MirrorProperties apply(const KisPaintInformation& info) const;
 
     void writeOptionSetting(KisPropertiesConfigurationSP setting) const override;
     void readOptionSetting(const KisPropertiesConfigurationSP setting) override;
 
     void enableVerticalMirror(bool mirror);
     void enableHorizontalMirror(bool mirror);
     bool isVerticalMirrorEnabled();
     bool isHorizontalMirrorEnabled();
 
 private:
     bool m_enableVerticalMirror;
     bool m_enableHorizontalMirror;
-    bool m_canvasAxisXMirrored;
-    bool m_canvasAxisYMirrored;
 };
 
 #endif
diff --git a/plugins/paintops/libpaintop/kis_pressure_rotation_option.cpp b/plugins/paintops/libpaintop/kis_pressure_rotation_option.cpp
index 9421a53d9d..ea6f60a72c 100644
--- a/plugins/paintops/libpaintop/kis_pressure_rotation_option.cpp
+++ b/plugins/paintops/libpaintop/kis_pressure_rotation_option.cpp
@@ -1,86 +1,80 @@
 /* This file is part of the KDE project
  * Copyright (c) 2009 Cyrille Berger <cberger@cberger.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU 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_pressure_rotation_option.h"
 #include "kis_pressure_opacity_option.h"
 #include "sensors/kis_dynamic_sensor_drawing_angle.h"
 #include "sensors/kis_dynamic_sensor_fuzzy.h"
 #include <klocalizedstring.h>
 #include <kis_painter.h>
 #include <brushengine/kis_paintop.h>
 #include <KoColor.h>
 
 KisPressureRotationOption::KisPressureRotationOption()
-        : KisCurveOption("Rotation", KisPaintOpOption::GENERAL, false),
-          m_defaultAngle(0.0),
-          m_canvasAxisXMirrored(false),
-          m_canvasAxisYMirrored(false)
+        : KisCurveOption("Rotation", KisPaintOpOption::GENERAL, false)
 {
 }
 
 double KisPressureRotationOption::apply(const KisPaintInformation & info) const
 {
-    if (!isChecked()) return m_defaultAngle;
+    if (!isChecked()) return kisDegreesToRadians(info.canvasRotation());
 
-    const bool absoluteAxesFlipped = m_canvasAxisXMirrored != m_canvasAxisYMirrored;
-    const qreal normalizedBaseAngle = -m_defaultAngle / (2 * M_PI);
+    const bool absoluteAxesFlipped = info.canvasMirroredH() != info.canvasMirroredV();
+
+    const qreal normalizedBaseAngle = info.canvasRotation() / 360.0;
 
     qreal value = computeRotationLikeValue(info, normalizedBaseAngle, absoluteAxesFlipped);
 
     // flip to conform global legacy code
     value = 1.0 - value;
 
     return normalizeAngle(value * M_PI);
  }
 
 void KisPressureRotationOption::readOptionSetting(const KisPropertiesConfigurationSP setting)
 {
-    m_defaultAngle = setting->getDouble("runtimeCanvasRotation", 0.0) * M_PI / 180.0;
     KisCurveOption::readOptionSetting(setting);
-
-    m_canvasAxisXMirrored = setting->getBool("runtimeCanvasMirroredX", false);
-    m_canvasAxisYMirrored = setting->getBool("runtimeCanvasMirroredY", false);
 }
 
 void KisPressureRotationOption::applyFanCornersInfo(KisPaintOp *op)
 {
     KisDynamicSensorDrawingAngle *sensor = dynamic_cast<KisDynamicSensorDrawingAngle*>(this->sensor(ANGLE, true).data());
 
     /**
      * A special case for the Drawing Angle sensor, because it
      * changes the behavior of KisPaintOp::paintLine()
      */
     if (sensor) {
         op->setFanCornersInfo(sensor->fanCornersEnabled(), qreal(sensor->fanCornersStep()) * M_PI / 180.0);
     }
 }
 
 int KisPressureRotationOption::intMinValue() const
 {
     return -180;
 }
 
 int KisPressureRotationOption::intMaxValue() const
 {
     return 180;
 }
 
 QString KisPressureRotationOption::valueSuffix() const
 {
     return i18n("°");
 }
diff --git a/plugins/paintops/libpaintop/kis_pressure_rotation_option.h b/plugins/paintops/libpaintop/kis_pressure_rotation_option.h
index f52e6e8c0a..52396d501c 100644
--- a/plugins/paintops/libpaintop/kis_pressure_rotation_option.h
+++ b/plugins/paintops/libpaintop/kis_pressure_rotation_option.h
@@ -1,56 +1,49 @@
 /* This file is part of the KDE project
  * Copyright (c) 2009 Cyrille Berger <cberger@cberger.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU 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_PRESSURE_ROTATION_OPTION_H
 #define KIS_PRESSURE_ROTATION_OPTION_H
 
 #include "kis_curve_option.h"
 #include <brushengine/kis_paint_information.h>
 #include <kritapaintop_export.h>
 
 /**
  * The pressure opacity option defines a curve that is used to
  * calculate the effect of pressure on the size of the dab
  */
 class PAINTOP_EXPORT KisPressureRotationOption : public KisCurveOption
 {
 public:
     KisPressureRotationOption();
     double apply(const KisPaintInformation & info) const;
     void readOptionSetting(const KisPropertiesConfigurationSP setting) override;
     void applyFanCornersInfo(KisPaintOp *op);
 
  // KisCurveOption interface
 public:
     int intMinValue() const override;
     int intMaxValue() const override;
     QString valueSuffix() const override;
 
 private:
-    qreal m_defaultAngle;
-    bool m_canvasAxisXMirrored;
-    bool m_canvasAxisYMirrored;
-
-
-
-
 
 };
 
 #endif
diff --git a/plugins/paintops/sketch/kis_sketchop_option.cpp b/plugins/paintops/sketch/kis_sketchop_option.cpp
index 4e744e4146..c76d2f2fc4 100644
--- a/plugins/paintops/sketch/kis_sketchop_option.cpp
+++ b/plugins/paintops/sketch/kis_sketchop_option.cpp
@@ -1,108 +1,108 @@
 /*
  *  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_sketchop_option.h"
 
 #include "ui_wdgsketchoptions.h"
 #include <brushengine/kis_paintop_lod_limitations.h>
 
 
 class KisSketchOpOptionsWidget: public QWidget, public Ui::WdgSketchOptions
 {
 public:
     KisSketchOpOptionsWidget(QWidget *parent = 0)
         : QWidget(parent) {
         setupUi(this);
     }
 };
 
 KisSketchOpOption::KisSketchOpOption()
     : KisPaintOpOption(KisPaintOpOption::GENERAL, false)
 {
     setObjectName("KisSketchOpOption");
 
     m_checkable = false;
     m_options = new KisSketchOpOptionsWidget();
 
     // initialize slider values
     m_options->lineWidthSPBox->setRange(1.0, 100.0, 0);
     m_options->lineWidthSPBox->setValue(1.0);
     m_options->lineWidthSPBox->setSuffix(i18n(" px"));
     m_options->lineWidthSPBox->setExponentRatio(1.5);
 
 
     m_options->offsetSPBox->setRange(0.0, 200.0, 0);
     m_options->offsetSPBox->setValue(30.0);
-    m_options->offsetSPBox->setSuffix("%");
+    m_options->offsetSPBox->setSuffix(i18n("%"));
 
     m_options->densitySPBox->setRange(0.0, 100.0, 0);
     m_options->densitySPBox->setValue(50.0);
-    m_options->densitySPBox->setSuffix("%");
+    m_options->densitySPBox->setSuffix(i18n("%"));
 
 
     connect(m_options->offsetSPBox, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
     connect(m_options->lineWidthSPBox, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
     connect(m_options->densitySPBox, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
     connect(m_options->simpleModeCHBox, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
     connect(m_options->connectionCHBox, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
     connect(m_options->magnetifyCHBox, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
     connect(m_options->randomRGBCHbox, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
     connect(m_options->randomOpacityCHbox, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
     connect(m_options->distanceDensityCHBox, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
     connect(m_options->distanceOpacityCHbox, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
 
 
     setConfigurationPage(m_options);
 }
 
 KisSketchOpOption::~KisSketchOpOption()
 {
     // delete m_options;
 }
 
 void KisSketchOpOption::writeOptionSetting(KisPropertiesConfigurationSP settings) const
 {
     settings->setProperty(SKETCH_OFFSET, m_options->offsetSPBox->value());
     settings->setProperty(SKETCH_PROBABILITY, m_options->densitySPBox->value() * 0.01);
     settings->setProperty(SKETCH_USE_SIMPLE_MODE, m_options->simpleModeCHBox->isChecked());
     settings->setProperty(SKETCH_MAKE_CONNECTION, m_options->connectionCHBox->isChecked());
     settings->setProperty(SKETCH_MAGNETIFY, m_options->magnetifyCHBox->isChecked());
     settings->setProperty(SKETCH_RANDOM_RGB, m_options->randomRGBCHbox->isChecked());
     settings->setProperty(SKETCH_LINE_WIDTH, m_options->lineWidthSPBox->value());
     settings->setProperty(SKETCH_RANDOM_OPACITY, m_options->randomOpacityCHbox->isChecked());
     settings->setProperty(SKETCH_DISTANCE_DENSITY, m_options->distanceDensityCHBox->isChecked());
     settings->setProperty(SKETCH_DISTANCE_OPACITY, m_options->distanceOpacityCHbox->isChecked());
 }
 
 void KisSketchOpOption::readOptionSetting(const KisPropertiesConfigurationSP settings)
 {
     m_options->offsetSPBox->setValue(settings->getDouble(SKETCH_OFFSET));
     m_options->simpleModeCHBox->setChecked(settings->getBool(SKETCH_USE_SIMPLE_MODE));
     m_options->connectionCHBox->setChecked(settings->getBool(SKETCH_MAKE_CONNECTION));
     m_options->magnetifyCHBox->setChecked(settings->getBool(SKETCH_MAGNETIFY));
     m_options->lineWidthSPBox->setValue(settings->getInt(SKETCH_LINE_WIDTH));
     m_options->densitySPBox->setValue(settings->getDouble(SKETCH_PROBABILITY) * 100.0);
     m_options->randomRGBCHbox->setChecked(settings->getBool(SKETCH_RANDOM_RGB));
     m_options->randomOpacityCHbox->setChecked(settings->getBool(SKETCH_RANDOM_OPACITY));
     m_options->distanceDensityCHBox->setChecked(settings->getBool(SKETCH_DISTANCE_DENSITY));
     m_options->distanceOpacityCHbox->setChecked(settings->getBool(SKETCH_DISTANCE_OPACITY));
 }
 
 void KisSketchOpOption::lodLimitations(KisPaintopLodLimitations *l) const
 {
     l->limitations << KoID("sketch-brush", i18nc("PaintOp instant preview limitation", "Sketch brush (differences in connecting lines are possible)"));
 }
diff --git a/plugins/paintops/spray/kis_spray_shape_option.cpp b/plugins/paintops/spray/kis_spray_shape_option.cpp
index 9dbb4458d7..7954382758 100644
--- a/plugins/paintops/spray/kis_spray_shape_option.cpp
+++ b/plugins/paintops/spray/kis_spray_shape_option.cpp
@@ -1,144 +1,144 @@
 /*
  *  Copyright (c) 2008,2009,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_spray_shape_option.h"
 #include <klocalizedstring.h>
 
 #include <QImage>
 #include <QFile>
 #include <KisImportExportManager.h>
 #include <kis_file_name_requester.h>
 #include "kis_aspect_ratio_locker.h"
 #include "kis_signals_blocker.h"
 
 #include "ui_wdgsprayshapeoptions.h"
 
 class KisShapeOptionsWidget: public QWidget, public Ui::WdgSprayShapeOptions
 {
 public:
     KisShapeOptionsWidget(QWidget *parent = 0)
         : QWidget(parent) {
         setupUi(this);
         imageUrl->setMimeTypeFilters(KisImportExportManager::supportedMimeTypes(KisImportExportManager::Import));
     }
 
 };
 
 KisSprayShapeOption::KisSprayShapeOption()
     : KisPaintOpOption(KisPaintOpOption::GENERAL, true),
       m_sizeRatioLocker(new KisAspectRatioLocker(this))
 {
 
     setObjectName("KisSprayShapeOption");
 
     m_checkable = true;
     // save this to be able to restore it back
     m_maxSize = 1000;
 
     m_options = new KisShapeOptionsWidget();
 
     //initializer slider values
     m_options->widthSpin->setRange(1, 1000, 0);
     m_options->widthSpin->setValue(6);
     m_options->widthSpin->setSuffix(i18n(" px"));
 
     m_options->heightSpin->setRange(1, 1000, 0);
     m_options->heightSpin->setValue(6);
     m_options->heightSpin->setSuffix(i18n(" px"));
 
     // UI signals
     connect(m_options->proportionalBox, SIGNAL(clicked(bool)), SLOT(changeSizeUI(bool)));
     connect(m_options->imageUrl, SIGNAL(textChanged(QString)), this, SLOT(prepareImage()));
 
     m_sizeRatioLocker->connectSpinBoxes(m_options->widthSpin, m_options->heightSpin, m_options->aspectButton);
     m_sizeRatioLocker->setBlockUpdateSignalOnDrag(true);
     connect(m_sizeRatioLocker, SIGNAL(sliderValueChanged()), SLOT(emitSettingChanged()));
     connect(m_sizeRatioLocker, SIGNAL(aspectButtonChanged()), SLOT(emitSettingChanged()));
 
     connect(m_options->proportionalBox, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
     connect(m_options->proportionalBox, SIGNAL(clicked(bool)), SLOT(emitSettingChanged()));
     connect(m_options->shapeBox, SIGNAL(currentIndexChanged(int)), SLOT(emitSettingChanged()));
     connect(m_options->imageUrl, SIGNAL(textChanged(QString)), SLOT(emitSettingChanged()));
 
     setConfigurationPage(m_options);
 }
 
 KisSprayShapeOption::~KisSprayShapeOption()
 {
     delete m_options;
 }
 
 int KisSprayShapeOption::shape() const
 {
     return m_options->shapeBox->currentIndex();
 }
 
 
 void KisSprayShapeOption::writeOptionSetting(KisPropertiesConfigurationSP setting) const
 {
     setting->setProperty(SPRAYSHAPE_ENABLED, isChecked());
     setting->setProperty(SPRAYSHAPE_SHAPE, shape());
     setting->setProperty(SPRAYSHAPE_USE_ASPECT, m_options->aspectButton->keepAspectRatio());
     setting->setProperty(SPRAYSHAPE_PROPORTIONAL, m_options->proportionalBox->isChecked());
     setting->setProperty(SPRAYSHAPE_WIDTH, m_options->widthSpin->value());
     setting->setProperty(SPRAYSHAPE_HEIGHT, m_options->heightSpin->value());
     setting->setProperty(SPRAYSHAPE_IMAGE_URL, m_options->imageUrl->fileName());
 }
 
 
 void KisSprayShapeOption::readOptionSetting(const KisPropertiesConfigurationSP setting)
 {
     // in 2.2 there is not shape enabled so true by default
     setChecked(setting->getBool(SPRAYSHAPE_ENABLED, true));
     m_options->shapeBox->setCurrentIndex(setting->getInt(SPRAYSHAPE_SHAPE));
     m_options->proportionalBox->setChecked(setting->getBool(SPRAYSHAPE_PROPORTIONAL));
     m_options->aspectButton->setKeepAspectRatio(setting->getBool(SPRAYSHAPE_USE_ASPECT, false));
     m_options->widthSpin->setValue(setting->getInt(SPRAYSHAPE_WIDTH));
     m_options->heightSpin->setValue(setting->getInt(SPRAYSHAPE_HEIGHT));
     m_options->imageUrl->setFileName(setting->getString(SPRAYSHAPE_IMAGE_URL));
 }
 
 
 void KisSprayShapeOption::prepareImage()
 {
     QString path = m_options->imageUrl->fileName();
     if (QFile::exists(path)) {
         QImage image(path);
         if (!image.isNull()) {
             KisSignalsBlocker b(m_options->widthSpin, m_options->heightSpin);
             m_options->widthSpin->setValue(image.width());
             m_options->heightSpin->setValue(image.height());
         }
     }
 }
 
 void KisSprayShapeOption::changeSizeUI(bool proportionalSize)
 {
     // if proportionalSize is false, pixel size is used
     if (!proportionalSize) {
         m_options->widthSpin->setMaximum(m_maxSize);
         m_options->widthSpin->setSuffix(i18n(" px"));
         m_options->heightSpin->setMaximum(m_maxSize);
         m_options->heightSpin->setSuffix(i18n(" px"));
     }
     else {
         m_options->widthSpin->setMaximum(100);
-        m_options->widthSpin->setSuffix("%");
+        m_options->widthSpin->setSuffix(i18n("%"));
         m_options->heightSpin->setMaximum(100);
-        m_options->heightSpin->setSuffix("%");
+        m_options->heightSpin->setSuffix(i18n("%"));
     }
 }
diff --git a/plugins/paintops/spray/kis_sprayop_option.cpp b/plugins/paintops/spray/kis_sprayop_option.cpp
index 34c71c8ace..4f246a2a91 100644
--- a/plugins/paintops/spray/kis_sprayop_option.cpp
+++ b/plugins/paintops/spray/kis_sprayop_option.cpp
@@ -1,149 +1,149 @@
 /*
  *  Copyright (c) 2008,2009,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_sprayop_option.h"
 #include <klocalizedstring.h>
 
 #include "ui_wdgsprayoptions.h"
 
 class KisSprayOpOptionsWidget: public QWidget, public Ui::WdgSprayOptions
 {
 public:
     KisSprayOpOptionsWidget(QWidget *parent = 0)
         : QWidget(parent) {
         setupUi(this);
     }
 };
 
 KisSprayOpOption::KisSprayOpOption()
     : KisPaintOpOption(KisPaintOpOption::GENERAL, false)
 {
     setObjectName("KisSprayOpOption");
 
     m_checkable = false;
     m_options = new KisSprayOpOptionsWidget();
 
     m_options->diameterSpinBox->setRange(1, 1000, 0);
     m_options->diameterSpinBox->setValue(100);
     m_options->diameterSpinBox->setExponentRatio(1.5);
     m_options->diameterSpinBox->setSuffix(i18n(" px"));
 
     m_options->aspectSPBox->setRange(0.0, 2.0, 2);
     m_options->aspectSPBox->setValue(1.0);
 
     m_options->rotationSPBox->setRange(0.0, 360.0, 0);
     m_options->rotationSPBox->setValue(0.0);
     m_options->rotationSPBox->setSuffix(QChar(Qt::Key_degree));
 
     m_options->scaleSpin->setRange(0.0, 10.0, 2);
     m_options->scaleSpin->setValue(1.0);
 
     m_options->spacingSpin->setRange(0.0, 5.0, 2);
     m_options->spacingSpin->setValue(0.5);
 
     m_options->coverageSpin->setRange(0.001, 0.02, 3);
     m_options->coverageSpin->setValue(0.003);
-    m_options->coverageSpin->setSuffix("%");
+    m_options->coverageSpin->setSuffix(i18n("%"));
 
     m_options->particlesSpinBox->setRange(1.0, 1000.0, 0);
     m_options->particlesSpinBox->setValue(12);
     m_options->particlesSpinBox->setExponentRatio(3.0);
 
     m_options->jitterMovementSpin->setRange(0.0,5.0, 1);
     m_options->jitterMovementSpin->setValue(1.0);
 
 
     connect(m_options->diameterSpinBox, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
     connect(m_options->coverageSpin, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
     connect(m_options->jitterMovementSpin, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
     connect(m_options->spacingSpin, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
     connect(m_options->scaleSpin, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
     connect(m_options->particlesSpinBox, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
     connect(m_options->countRadioButton, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
     connect(m_options->densityRadioButton, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
     connect(m_options->gaussianBox, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
     connect(m_options->aspectSPBox, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
     connect(m_options->rotationSPBox, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
     connect(m_options->jitterMoveBox, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
 
     connect(m_options->countRadioButton, SIGNAL(toggled(bool)), m_options->particlesSpinBox, SLOT(setEnabled(bool)));
     connect(m_options->densityRadioButton, SIGNAL(toggled(bool)), m_options->coverageSpin, SLOT(setEnabled(bool)));
     connect(m_options->jitterMoveBox, SIGNAL(toggled(bool)), m_options->jitterMovementSpin, SLOT(setEnabled(bool)));
 
     setConfigurationPage(m_options);
 }
 
 KisSprayOpOption::~KisSprayOpOption()
 {
     delete m_options;
 }
 
 void KisSprayOpOption::writeOptionSetting(KisPropertiesConfigurationSP setting) const
 {
     KisSprayOptionProperties op;
 
     op.diameter = m_options->diameterSpinBox->value();
     op.particleCount = m_options->particlesSpinBox->value();
     op.aspect = m_options->aspectSPBox->value();
     op.coverage = m_options->coverageSpin->value();
     op.amount = m_options->jitterMovementSpin->value();
     op.spacing = m_options->spacingSpin->value();
     op.scale = m_options->scaleSpin->value();
     op.brushRotation = m_options->rotationSPBox->value();
     op.jitterMovement = m_options->jitterMoveBox->isChecked();
     op.useDensity = m_options->densityRadioButton->isChecked();
     op.gaussian = m_options->gaussianBox->isChecked();
 
     op.writeOptionSetting(setting);
 }
 
 void KisSprayOpOption::readOptionSetting(const KisPropertiesConfigurationSP setting)
 {
     KisSprayOptionProperties op;
     op.readOptionSetting(setting);
 
     m_options->diameterSpinBox->setValue(op.diameter);
     m_options->aspectSPBox->setValue(op.aspect);
     m_options->coverageSpin->setValue(op.coverage);
     m_options->scaleSpin->setValue(op.scale);
     m_options->rotationSPBox->setValue(op.brushRotation);
     m_options->particlesSpinBox->setValue(op.particleCount);
     m_options->jitterMovementSpin->setValue(op.amount);
     m_options->jitterMoveBox->setChecked(op.jitterMovement);
     m_options->spacingSpin->setValue(op.spacing);
     m_options->gaussianBox->setChecked(op.gaussian);
     //TODO: come on, do this nicer! e.g. button group or something
     bool useDensity = op.useDensity;
     m_options->densityRadioButton->setChecked(useDensity);
     m_options->countRadioButton->setChecked(!useDensity);
 }
 
 
 void KisSprayOpOption::setDiameter(int diameter) const
 {
     m_options->diameterSpinBox->setValue(diameter);
 }
 
 int KisSprayOpOption::diameter() const
 {
     return m_options->diameterSpinBox->value();
 }
 
 qreal KisSprayOpOption::brushAspect() const
 {
     return m_options->aspectSPBox->value();
 }
diff --git a/plugins/paintops/tangentnormal/kis_tangent_tilt_option.cpp b/plugins/paintops/tangentnormal/kis_tangent_tilt_option.cpp
index b6edb053b0..d5115b599a 100644
--- a/plugins/paintops/tangentnormal/kis_tangent_tilt_option.cpp
+++ b/plugins/paintops/tangentnormal/kis_tangent_tilt_option.cpp
@@ -1,269 +1,260 @@
 /* This file is part of the KDE project
  *
  * Copyright (C) 2015 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_tangent_tilt_option.h"
 #include <cmath>
 #include <QColor>
 #include <QPoint>
 
 #include "ui_wdgtangenttiltoption.h"
 
 #include "kis_global.h"
 
 class KisTangentTiltOptionWidget: public QWidget, public Ui::WdgTangentTiltOptions
 {
 public:
     KisTangentTiltOptionWidget(QWidget *parent = 0)
         : QWidget(parent) {
         setupUi(this);
     }
 };
 
 KisTangentTiltOption::KisTangentTiltOption()
-: KisPaintOpOption(KisPaintOpOption::GENERAL, false),
-            m_canvasAngle(0.0),
-            m_canvasAxisXMirrored(false),
-            m_canvasAxisYMirrored(false)
+: KisPaintOpOption(KisPaintOpOption::GENERAL, false)
 {
     m_checkable = false;
     m_options = new KisTangentTiltOptionWidget();
     //Setup tangent tilt.
     m_options->comboRed->setCurrentIndex(0);
     m_options->comboGreen->setCurrentIndex(2);
     m_options->comboBlue->setCurrentIndex(4);
 
     m_options->sliderElevationSensitivity->setRange(0, 100, 0);
     m_options->sliderElevationSensitivity->setValue(100);
-    m_options->sliderElevationSensitivity->setSuffix("%");
+    m_options->sliderElevationSensitivity->setSuffix(i18n("%"));
 
     m_options->sliderMixValue->setRange(0, 100, 0);
     m_options->sliderMixValue->setValue(50);
-    m_options->sliderMixValue->setSuffix("%");
+    m_options->sliderMixValue->setSuffix(i18n("%"));
 
     connect(m_options->comboRed, SIGNAL(currentIndexChanged(int)), SLOT(emitSettingChanged()));
     connect(m_options->comboGreen, SIGNAL(currentIndexChanged(int)), SLOT(emitSettingChanged()));
     connect(m_options->comboBlue, SIGNAL(currentIndexChanged(int)), SLOT(emitSettingChanged()));
     connect(m_options->comboRed, SIGNAL(currentIndexChanged(int)), m_options->TangentTiltPreview, SLOT(setRedChannel(int)));
     connect(m_options->comboGreen, SIGNAL(currentIndexChanged(int)), m_options->TangentTiltPreview, SLOT(setGreenChannel(int)));
     connect(m_options->comboBlue, SIGNAL(currentIndexChanged(int)), m_options->TangentTiltPreview, SLOT(setBlueChannel(int)));
 
     connect(m_options->optionTilt, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
     connect(m_options->optionDirection, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
     connect(m_options->optionRotation, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
     connect(m_options->optionMix, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
 
     connect(m_options->sliderElevationSensitivity, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
     connect(m_options->sliderMixValue, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
     m_options->sliderMixValue->setVisible(false);
 
     setConfigurationPage(m_options);
 
 }
 
 KisTangentTiltOption::~KisTangentTiltOption()
 {
     delete m_options;
 }
 
 //options
 int KisTangentTiltOption::redChannel() const
 {
     return m_options->comboRed->currentIndex();
 }
 int KisTangentTiltOption::greenChannel() const
 {
     return m_options->comboGreen->currentIndex();
 }
 int KisTangentTiltOption::blueChannel() const
 {
     return m_options->comboBlue->currentIndex();
 }
 
 int KisTangentTiltOption::directionType() const
 {
     int type=0;
 
     if (m_options->optionTilt->isChecked()==true) {
         type=0;
     }
     else if (m_options->optionDirection->isChecked()==true) {
         type=1;
     }
     else if (m_options->optionRotation->isChecked()==true) {
         type=2;
     }
     else if (m_options->optionMix->isChecked()==true) {
         type=3;
     }
     else {
         warnKrita<<"There's something odd with the radio buttons. We'll use Tilt";
     }
 
     return type;
 }
 
 double KisTangentTiltOption::elevationSensitivity() const
 {
     return m_options->sliderElevationSensitivity->value(); 
 }
 
 double KisTangentTiltOption::mixValue() const
 {
     return m_options->sliderMixValue->value();
 }
 
 void KisTangentTiltOption::swizzleAssign(qreal const horizontal, qreal const vertical, qreal const depth, qreal *component, int index, qreal maxvalue)
 {
     switch(index) {
     case 0: *component = horizontal; break;
     case 1: *component = maxvalue-horizontal; break;
     case 2: *component = vertical; break;
     case 3: *component = maxvalue-vertical; break;
     case 4: *component = depth; break;
     case 5: *component = maxvalue-depth; break;
     }
 }
 
 void KisTangentTiltOption::apply(const KisPaintInformation& info,qreal *r,qreal *g,qreal *b)
 {
     //formula based on http://www.cerebralmeltdown.com/programming_projects/Altitude%20and%20Azimuth%20to%20Vector/index.html
 
     /* It doesn't make sense of have higher than 8bit color depth.
      * Instead we make sure in the paintAt function of kis_tangent_normal_paintop to pick an 8bit space of the current
      * color space if the space is an RGB space. If not, it'll pick sRGB 8bit.
      */
     qreal halfvalue = 0.5;
     qreal maxvalue = 1.0;
 
     //have the azimuth and altitude in degrees.
     qreal direction = KisPaintInformation::tiltDirection(info, true)*360.0;
     qreal elevation= (info.tiltElevation(info, 60.0, 60.0, true)*90.0);
-    if (directionType()==0) {
+
+    if (directionType() == 0) {
         direction = KisPaintInformation::tiltDirection(info, true)*360.0;
-	elevation= (info.tiltElevation(info, 60.0, 60.0, true)*90.0);
-    } else if (directionType()==1) {
+        elevation= (info.tiltElevation(info, 60.0, 60.0, true)*90.0);
+    } else if (directionType() == 1) {
         direction = (0.75 + info.drawingAngle() / (2.0 * M_PI))*360.0;
-	elevation= 0;//turns out that tablets that don't support tilt just return 90 degrees for elevation.
-    } else if (directionType()==2) {
+        elevation= 0;//turns out that tablets that don't support tilt just return 90 degrees for elevation.
+    } else if (directionType() == 2) {
         direction = info.rotation();
-	elevation= (info.tiltElevation(info, 60.0, 60.0, true)*90.0);//artpens have tilt-recognition, so this should work.
-    } else if (directionType()==3) {//mix of tilt+direction
-	qreal mixamount = mixValue()/100.0;
+        elevation= (info.tiltElevation(info, 60.0, 60.0, true)*90.0);//artpens have tilt-recognition, so this should work.
+    } else if (directionType() == 3) {//mix of tilt+direction
+        qreal mixamount = mixValue()/100.0;
         direction = (KisPaintInformation::tiltDirection(info, true)*360.0*(1.0-mixamount))+((0.75 + info.drawingAngle() / (2.0 * M_PI))*360.0*(mixamount));
-	elevation= (info.tiltElevation(info, 60.0, 60.0, true)*90.0);
+        elevation= (info.tiltElevation(info, 60.0, 60.0, true)*90.0);
     }
 
-    //subtract/add the rotation of the canvas.
+    const qreal oldDirection = direction;
 
-    if (info.canvasRotation()!=m_canvasAngle && info.canvasMirroredH()==m_canvasAxisXMirrored) {
-       m_canvasAngle=info.canvasRotation();
-    }
-    if (directionType()!=1) {
-        direction = direction-m_canvasAngle;
+    //subtract/add the rotation of the canvas.
+    if (directionType() != 1) {
+        direction = normalizeAngleDegrees(direction - info.canvasRotation());
     }
 
     //limit the direction/elevation
 
     //qreal elevationMax = (elevationSensitivity()*90.0)/100.0;
     qreal elevationT = elevation*(elevationSensitivity()/100.0)+(90-(elevationSensitivity()*90.0)/100.0);
     elevation = static_cast<int>(elevationT);
 
     //convert to radians.
     // Convert this to kis_global's radian function.
     direction = kisDegreesToRadians(direction);
     elevation = kisDegreesToRadians(elevation);
 
     //make variables for axes for easy switching later on.
     qreal horizontal, vertical, depth;
 
     //spherical coordinates always center themselves around the origin, leading to values. We need to work around those...
 
     horizontal = cos(elevation)*sin(direction);
     if (horizontal>0.0) {
         horizontal= halfvalue+(fabs(horizontal)*halfvalue);
     }
     else {
         horizontal= halfvalue-(fabs(horizontal)*halfvalue);
     }
     vertical = cos(elevation)*cos(direction);
     if (vertical>0.0) {
         vertical = halfvalue+(fabs(vertical)*halfvalue);
     }
     else {
         vertical = halfvalue-(fabs(vertical)*halfvalue);
     }
 
-    if (m_canvasAxisXMirrored && info.canvasMirroredH()) {horizontal = maxvalue-horizontal;}
-    if (m_canvasAxisYMirrored && info.canvasMirroredH()) {vertical = maxvalue-vertical;}
+    if (info.canvasMirroredH()) {horizontal = maxvalue - horizontal;}
+    if (info.canvasMirroredV()) {vertical = maxvalue - vertical;}
 
     depth = sin(elevation)*maxvalue;
 
     //assign right components to correct axes.
     swizzleAssign(horizontal, vertical, depth, r, redChannel(), maxvalue);
     swizzleAssign(horizontal, vertical, depth, g, greenChannel(), maxvalue);
     swizzleAssign(horizontal, vertical, depth, b, blueChannel(), maxvalue);
 
 }
 
 /*settings*/
 void KisTangentTiltOption::writeOptionSetting(KisPropertiesConfigurationSP setting) const
 {
     setting->setProperty(TANGENT_RED, redChannel());
     setting->setProperty(TANGENT_GREEN, greenChannel());
     setting->setProperty(TANGENT_BLUE, blueChannel());
     setting->setProperty(TANGENT_TYPE, directionType());
     setting->setProperty(TANGENT_EV_SEN, elevationSensitivity());
     setting->setProperty(TANGENT_MIX_VAL, mixValue());
 }
 
 void KisTangentTiltOption::readOptionSetting(const KisPropertiesConfigurationSP setting)
 {
     m_options->comboRed->setCurrentIndex(setting->getInt(TANGENT_RED, 0));
     m_options->comboGreen->setCurrentIndex(setting->getInt(TANGENT_GREEN, 2));
     m_options->comboBlue->setCurrentIndex(setting->getInt(TANGENT_BLUE, 4));
     
     //The comboboxes are connected to the TangentTiltPreview, so that gets automatically updated by them.
 
     if (setting->getInt(TANGENT_TYPE)== 0){
         m_options->optionTilt->setChecked(true);
-	m_options->sliderMixValue->setVisible(false);
+        m_options->sliderMixValue->setVisible(false);
     }
     else if (setting->getInt(TANGENT_TYPE)== 1) {
         m_options->optionDirection->setChecked(true);
-	m_options->sliderMixValue->setVisible(false);
+        m_options->sliderMixValue->setVisible(false);
     }
     else if (setting->getInt(TANGENT_TYPE)== 2) {
         m_options->optionRotation->setChecked(true);
-	m_options->sliderMixValue->setVisible(false);
+        m_options->sliderMixValue->setVisible(false);
     }
     else if (setting->getInt(TANGENT_TYPE)== 3) {
         m_options->optionMix->setChecked(true);
-	m_options->sliderMixValue->setVisible(true);
+        m_options->sliderMixValue->setVisible(true);
     }
 
-    m_canvasAngle = setting->getDouble("runtimeCanvasRotation", 0.0);//in degrees please.
-    m_canvasAxisXMirrored = setting->getBool("runtimeCanvasMirroredX", false);
-    m_canvasAxisYMirrored = setting->getBool("runtimeCanvasMirroredY", false);
-
     m_options->sliderElevationSensitivity->setValue(setting->getDouble(TANGENT_EV_SEN, 100));
     m_options->sliderMixValue->setValue(setting->getDouble(TANGENT_MIX_VAL, 50));
-
 }
diff --git a/plugins/paintops/tangentnormal/kis_tangent_tilt_option.h b/plugins/paintops/tangentnormal/kis_tangent_tilt_option.h
index 53f84cb31b..0a7fbad56e 100644
--- a/plugins/paintops/tangentnormal/kis_tangent_tilt_option.h
+++ b/plugins/paintops/tangentnormal/kis_tangent_tilt_option.h
@@ -1,68 +1,65 @@
 /* This file is part of the KDE project
  *
  * Copyright (C) 2015 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_TANGENT_TILT_OPTION_H
 #define KIS_TANGENT_TILT_OPTION_H
 
 #include <brushengine/kis_paint_information.h>
 #include <kis_types.h>
 
 #include <kis_paintop_option.h>
 
 const QString TANGENT_RED = "Tangent/swizzleRed";
 const QString TANGENT_GREEN = "Tangent/swizzleGreen";
 const QString TANGENT_BLUE = "Tangent/swizzleBlue";
 const QString TANGENT_TYPE = "Tangent/directionType";
 const QString TANGENT_EV_SEN = "Tangent/elevationSensitivity";
 const QString TANGENT_MIX_VAL = "Tangent/mixValue";
 //const QString TANGENT_DIR_MIN = "Tangent/directionMinimum";
 //const QString TANGENT_DIR_MAX = "Tangent/directionMaximum";
 
 class KisPropertiesConfiguration;
 class KisTangentTiltOptionWidget;
 
 class KisTangentTiltOption: public KisPaintOpOption //not really//
 {
 public:
     KisTangentTiltOption();
     ~KisTangentTiltOption() override;
     /*These three give away which the index of the combobox for a given channel*/
     int redChannel() const;
     int greenChannel() const;
     int blueChannel() const;
     int directionType() const;
     double elevationSensitivity() const;
     double mixValue() const;
-    qreal m_canvasAngle;
-    bool m_canvasAxisXMirrored;
-    bool m_canvasAxisYMirrored;
     /*This assigns the right axis to the component, based on index and maximum value*/
     void swizzleAssign(qreal const horizontal, qreal const vertical, qreal const depth, qreal *component, int index, qreal maxvalue);
 
     //takes the RGB values and will deform them depending on tilt.
     void apply(const KisPaintInformation& info, qreal *r, qreal *g, qreal *b);
 
     void writeOptionSetting(KisPropertiesConfigurationSP setting) const override;
     void readOptionSetting(const KisPropertiesConfigurationSP setting) override;
 private:
     KisTangentTiltOptionWidget * m_options;
 };
 
 #endif // KIS_TANGENT_TILT_OPTION_H
diff --git a/plugins/python/CMakeLists.txt b/plugins/python/CMakeLists.txt
index 2624db1435..d82c284d08 100644
--- a/plugins/python/CMakeLists.txt
+++ b/plugins/python/CMakeLists.txt
@@ -1,117 +1,117 @@
 # Copyright (C) 2012, 2013 Shaheed Haque <srhaque@theiet.org>
 # Copyright (C) 2013 Alex Turbov <i.zaufi@gmail.com>
 # Copyright (C) 2014-2016 Boudewijn Rempt <boud@valdyas.org>
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions
 # are met:
 #
 # 1. Redistributions of source code must retain the above copyright
 #    notice, this list of conditions and the following disclaimer.
 # 2. Redistributions in binary form must reproduce the above copyright
 #    notice, this list of conditions and the following disclaimer in the
 #    documentation and/or other materials provided with the distribution.
 #
 # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 include(CMakeParseArguments)
 
 #
 # Simple helper function to install plugin and related files
 # having only a name of the plugin...
 # (just to reduce syntactic noise when a lot of plugins get installed)
 #
 function(install_pykrita_plugin name)
     set(_options)
     set(_one_value_args)
     set(_multi_value_args PATTERNS FILE)
     cmake_parse_arguments(install_pykrita_plugin "${_options}" "${_one_value_args}" "${_multi_value_args}" ${ARGN})
     if(NOT name)
         message(FATAL_ERROR "Plugin filename is not given")
     endif()
     if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${name}.py)
         install(FILES kritapykrita_${name}.desktop DESTINATION ${DATA_INSTALL_DIR}/krita/pykrita)
         foreach(_f ${name}.py ${name}.ui ${install_pykrita_plugin_FILE})
             if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${_f})
                 install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/${_f} DESTINATION ${DATA_INSTALL_DIR}/krita/pykrita)
             endif()
         endforeach()
     elseif(IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/${name})
         install(FILES ${name}/kritapykrita_${name}.desktop DESTINATION ${DATA_INSTALL_DIR}/krita/pykrita)
         install(
             DIRECTORY ${name}
             DESTINATION ${DATA_INSTALL_DIR}/krita/pykrita
             FILES_MATCHING
                 PATTERN "*.py"
                 PATTERN "*.ui"
                 PATTERN "*.txt"
                 PATTERN "*.csv"
                 PATTERN "*.html"
                 PATTERN "__pycache__*" EXCLUDE
                 PATTERN "tests*" EXCLUDE
            )
         # TODO Is there any way to form a long PATTERN options string
         # and use it in a single install() call?
         # NOTE Install specified patterns one-by-one...
         foreach(_pattern ${install_pykrita_plugin_PATTERNS})
             install(
                 DIRECTORY ${name}
                 DESTINATION ${DATA_INSTALL_DIR}/krita/pykrita
                 FILES_MATCHING
                     PATTERN "${_pattern}"
                     PATTERN "__pycache__*" EXCLUDE
 		    PATTERN "tests*" EXCLUDE
               )
         endforeach()
     else()
         message(FATAL_ERROR "Do not know what to do with ${name}")
     endif()
 endfunction()
 
 install_pykrita_plugin(hello)
 install_pykrita_plugin(assignprofiledialog)
 install_pykrita_plugin(scripter)
 install_pykrita_plugin(colorspace)
 install_pykrita_plugin(documenttools)
 install_pykrita_plugin(filtermanager)
 install_pykrita_plugin(exportlayers)
 #install_pykrita_plugin(highpass)
 install_pykrita_plugin(tenbrushes)
 install_pykrita_plugin(tenscripts)
-install_pykrita_plugin(palette_docker)
+#install_pykrita_plugin(palette_docker)  # Needs fixing -> bug 405194
 install_pykrita_plugin(quick_settings_docker)
 install_pykrita_plugin(lastdocumentsdocker)
 # install_pykrita_plugin(scriptdocker)
 install_pykrita_plugin(comics_project_management_tools)
 install_pykrita_plugin(krita_script_starter)
 install_pykrita_plugin(plugin_importer)
 
 # if(PYTHON_VERSION_MAJOR VERSION_EQUAL 3)
 #     install_pykrita_plugin(cmake_utils)
 #     install_pykrita_plugin(js_utils PATTERNS "*.json")
 #     install_pykrita_plugin(expand PATTERNS "*.expand" "templates/*.tpl")
 # endif()
 
 install( FILES
     hello/hello.action
     tenbrushes/tenbrushes.action
     tenscripts/tenscripts.action
     plugin_importer/plugin_importer.action
 DESTINATION  ${DATA_INSTALL_DIR}/krita/actions)
 
 install(
     DIRECTORY libkritapykrita
     DESTINATION ${DATA_INSTALL_DIR}/krita/pykrita
     FILES_MATCHING
         PATTERN "*.py"
         PATTERN "__pycache__*" EXCLUDE
   )
diff --git a/plugins/python/assignprofiledialog/kritapykrita_assignprofiledialog.desktop b/plugins/python/assignprofiledialog/kritapykrita_assignprofiledialog.desktop
index 835e341b20..544eda162d 100644
--- a/plugins/python/assignprofiledialog/kritapykrita_assignprofiledialog.desktop
+++ b/plugins/python/assignprofiledialog/kritapykrita_assignprofiledialog.desktop
@@ -1,57 +1,57 @@
 [Desktop Entry]
 Type=Service
 ServiceTypes=Krita/PythonPlugin
 X-KDE-Library=assignprofiledialog
 X-Python-2-Compatible=true
 X-Krita-Manual=Manual.html
 Name=Assign Profile to Image
 Name[ar]=إسناد اللاحات إلى الصور
 Name[ca]=Assigna un perfil a una imatge
 Name[ca@valencia]=Assigna un perfil a una imatge
 Name[cs]=Přiřadit obrázku profil
 Name[el]=Αντιστοίχιση προφίλ σε εικόνα
 Name[en_GB]=Assign Profile to Image
 Name[es]=Asignar perfil a imagen
 Name[eu]=Esleitu profila irudiari
 Name[fi]=Liitä kuvaan profiili
 Name[fr]=Attribuer un profil à l'image
 Name[gl]=Asignar un perfil á imaxe
 Name[is]=Úthluta litasniði á myndina
 Name[it]=Assegna profilo a immagine
 Name[ko]=이미지에 프로필 할당
 Name[nl]=Profiel aan afbeelding toewijzen
 Name[nn]=Tildel profil til bilete
 Name[pl]=Przypisz profil do obrazu
 Name[pt]=Atribuir um Perfil à Imagem
 Name[pt_BR]=Atribuir perfil a imagem
 Name[sv]=Tilldela profil till bild
 Name[tr]=Görüntüye Profil Ata
 Name[uk]=Призначити профіль до зображення
 Name[x-test]=xxAssign Profile to Imagexx
 Name[zh_CN]=为图像指定特性文件
 Name[zh_TW]=指定設定檔到圖像
 Comment=Assign a profile to an image without converting it.
 Comment[ar]=أسنِد لاحة إلى صورة دون تحويلها.
 Comment[ca]=Assigna un perfil a una imatge sense convertir-la.
 Comment[ca@valencia]=Assigna un perfil a una imatge sense convertir-la.
 Comment[el]=Αντιστοιχίζει ένα προφίλ σε μια εικόνα χωρίς μετατροπή.
 Comment[en_GB]=Assign a profile to an image without converting it.
 Comment[es]=Asignar un perfil a una imagen sin convertirla.
 Comment[eu]=Esleitu profil bat irudi bati hura bihurtu gabe.
 Comment[fi]=Liitä kuvaan profiili muuntamatta kuvaa
 Comment[fr]=Attribuer un profil à une image sans la convertir.
 Comment[gl]=Asignar un perfil a unha imaxe sen convertela.
 Comment[is]=Úthluta litasniði á myndina án þess að umbreyta henni.
 Comment[it]=Assegna un profilo a un'immagine senza convertirla.
 Comment[ko]=프로필을 변환하지 않고 이미지에 할당합니다.
 Comment[nl]=Een profiel aan een afbeelding toewijzen zonder het te converteren.
-Comment[nn]=Tildel profil til eit bilete utan å konvertera det
+Comment[nn]=Tildel fargeprofil til eit bilete utan å konvertera det til profilen
 Comment[pl]=Przypisz profil do obrazu bez jego przekształcania.
 Comment[pt]=Atribui um perfil à imagem sem a converter.
 Comment[pt_BR]=Atribui um perfil para uma imagem sem convertê-la.
 Comment[sv]=Tilldela en profil till en bild utan att konvertera den.
 Comment[tr]=Bir görüntüye, görüntüyü değiştirmeden bir profil ata.
 Comment[uk]=Призначити профіль до зображення без його перетворення.
 Comment[x-test]=xxAssign a profile to an image without converting it.xx
 Comment[zh_CN]=仅为图像指定特性文件，不转换其色彩空间
 Comment[zh_TW]=將設定檔指定給圖像，而不進行轉換。
diff --git a/plugins/python/comics_project_management_tools/kritapykrita_comics_project_management_tools.desktop b/plugins/python/comics_project_management_tools/kritapykrita_comics_project_management_tools.desktop
index df0266eec2..f72ea33d5a 100644
--- a/plugins/python/comics_project_management_tools/kritapykrita_comics_project_management_tools.desktop
+++ b/plugins/python/comics_project_management_tools/kritapykrita_comics_project_management_tools.desktop
@@ -1,58 +1,58 @@
 [Desktop Entry]
 Type=Service
 ServiceTypes=Krita/PythonPlugin
 X-KDE-Library=comics_project_management_tools
 X-Krita-Manual=README.html
 X-Python-2-Compatible=false
 Name=Comics Project Management Tools
 Name[ar]=أدوات إدارة المشاريع الهزليّة
 Name[ca]=Eines per a la gestió dels projectes de còmics
 Name[ca@valencia]=Eines per a la gestió dels projectes de còmics
 Name[cs]=Nástroje pro správu projektů komixů
 Name[el]=Εργαλεία διαχείρισης έργων ιστοριών σε εικόνες
 Name[en_GB]=Comics Project Management Tools
 Name[es]=Herramientas de gestión de proyectos de cómics
 Name[eu]=Komikien proiektuak kudeatzeko tresnak
 Name[fi]=Sarjakuvaprojektien hallintatyökalut
 Name[fr]=Outils de gestion d'un projet de bande dessinée
 Name[gl]=Ferramentas de xestión de proxectos de cómics
 Name[is]=Verkefnisstjórn teiknimyndasögu
 Name[it]=Strumenti per la gestione dei progetti di fumetti
 Name[ko]=만화 프로젝트 관리 도구
 Name[nl]=Hulpmiddelen voor projectbeheer van strips
-Name[nn]=Prosjekthandsamingsverktøy for teikneseriar
+Name[nn]=Prosjekthandsaming for teikneseriar
 Name[pl]=Narzędzia do zarządzania projektami komiksów
 Name[pt]=Ferramentas de Gestão de Projectos de Banda Desenhada
 Name[pt_BR]=Ferramentas de gerenciamento de projeto de quadrinhos
 Name[sv]=Projekthanteringsverktyg för tecknade serier
 Name[tr]=Çizgi Roman Projesi Yönetimi Araçları
 Name[uk]=Інструменти для керування проєктами коміксів
 Name[x-test]=xxComics Project Management Toolsxx
 Name[zh_CN]=漫画项目管理工具
 Name[zh_TW]=漫畫專案管理工具
 Comment=Tools for managing comics.
 Comment[ar]=أدوات لإدارة الهزليّات.
 Comment[ca]=Eines per a gestionar els còmics.
 Comment[ca@valencia]=Eines per a gestionar els còmics.
 Comment[cs]=Nástroje pro správu komixů.
 Comment[el]=Εργαλεία για τη διαχείριση ιστοριών σε εικόνες.
 Comment[en_GB]=Tools for managing comics.
 Comment[es]=Herramientas para gestionar cómics.
 Comment[eu]=Komikiak kudeatzeko tresnak.
 Comment[fi]=Sarjakuvien hallintatyökalut.
 Comment[fr]=Outils pour gérer les bandes dessinées.
 Comment[gl]=Ferramentas para xestionar cómics.
 Comment[is]=Verkfæri til að stýra gerð teiknimyndasögu.
 Comment[it]=Strumenti per la gestione dei fumetti.
 Comment[ko]=만화 관리 도구입니다.
 Comment[nl]=Hulpmiddelen voor beheer van strips.
 Comment[nn]=Verktøy for handsaming av teikneseriar
 Comment[pl]=Narzędzie do zarządzania komiksami.
 Comment[pt]=Ferramentas para gerir bandas desenhadas.
 Comment[pt_BR]=Ferramentas para gerenciar quadrinhos.
 Comment[sv]=Verktyg för att hantera tecknade serier.
 Comment[tr]=Çizgi romanları yönetmek için araçlar.
 Comment[uk]=Інструменти для керування коміксами
 Comment[x-test]=xxTools for managing comics.xx
 Comment[zh_CN]=用于管理漫画的工具。
 Comment[zh_TW]=管理漫畫的工具。
diff --git a/plugins/python/documenttools/kritapykrita_documenttools.desktop b/plugins/python/documenttools/kritapykrita_documenttools.desktop
index 260b23215b..c34c388ee2 100644
--- a/plugins/python/documenttools/kritapykrita_documenttools.desktop
+++ b/plugins/python/documenttools/kritapykrita_documenttools.desktop
@@ -1,56 +1,56 @@
 [Desktop Entry]
 Type=Service
 ServiceTypes=Krita/PythonPlugin
 X-KDE-Library=documenttools
 X-Python-2-Compatible=true
 X-Krita-Manual=Manual.html
 Name=Document Tools
 Name[ar]=أدوات المستندات
 Name[ca]=Eines de document
 Name[ca@valencia]=Eines de document
 Name[cs]=Dokumentové nástroje
 Name[el]=Εργαλεία για έγγραφα
 Name[en_GB]=Document Tools
 Name[es]=Herramientas de documentos
 Name[eu]=Dokumentuen tresnak
 Name[fi]=Tiedostotyökalut
 Name[fr]=Outil Document
 Name[gl]=Ferramentas de documentos
 Name[it]=Strumenti per i documenti
 Name[ko]=문서 도구
 Name[nl]=Documenthulpmiddelen
 Name[nn]=Dokumentverktøy
 Name[pl]=Narzędzia dokumentu
 Name[pt]=Ferramentas de Documentos
 Name[pt_BR]=Ferramentas de documento
 Name[sv]=Dokumentverktyg
 Name[tr]=Belge Araçları
 Name[uk]=Засоби документа
 Name[x-test]=xxDocument Toolsxx
 Name[zh_CN]=文档工具
 Name[zh_TW]=檔案工具
 Comment=Plugin to manipulate properties of selected documents
 Comment[ar]=ملحقة لتعديل خصائص المستندات المحددة
 Comment[ca]=Un connector per a manipular les propietats dels documents seleccionats
 Comment[ca@valencia]=Un connector per a manipular les propietats dels documents seleccionats
 Comment[cs]=Modul pro správu vlastností vybraných dokumentů
 Comment[el]=Πρόσθετο χειρισμού ιδιοτήτων σε επιλεγμένα έγγραφα
 Comment[en_GB]=Plugin to manipulate properties of selected documents
 Comment[es]=Complemento para manipular las propiedades de los documentos seleccionados
 Comment[eu]=Hautatutako dokumentuen propietateak manipulatzeko plugina
 Comment[fi]=Liitännäinen valittujen tiedostojen ominaisuuksien käsittelemiseksi
 Comment[fr]=Module externe de gestion des propriétés des documents sélectionnés
 Comment[gl]=Complemento para manipular as propiedades dos documentos seleccionados.
 Comment[it]=Estensione per manipolare le proprietà dei documenti selezionati
 Comment[ko]=선택한 문서의 속성을 변경하는 플러그인
 Comment[nl]=Plug-in om eigenschappen van geselecteerde documenten te manipuleren
-Comment[nn]=Programtillegg for endra eigenskapar på utvalde dokument
+Comment[nn]=Programtillegg for å endra eigenskapar på utvalde dokument
 Comment[pl]=Wtyczka do zmiany właściwości wybranych dokumentów
 Comment[pt]='Plugin' para manipular as propriedades dos documentos seleccionados
 Comment[pt_BR]=Plugin para manipular as propriedades de documentos selecionados
 Comment[sv]=Insticksprogram för att ändra egenskaper för valda dokument
 Comment[tr]=Seçili belgelerin özelliklerini değiştirmek için eklenti
 Comment[uk]=Додаток для керування властивостями позначених документів
 Comment[x-test]=xxPlugin to manipulate properties of selected documentsxx
 Comment[zh_CN]=用于编辑选定文档属性的插件
 Comment[zh_TW]=用於修改所選檔案屬性的外掛程式
diff --git a/plugins/python/krita_script_starter/kritapykrita_krita_script_starter.desktop b/plugins/python/krita_script_starter/kritapykrita_krita_script_starter.desktop
index 3d70df7b0c..6a13606e33 100644
--- a/plugins/python/krita_script_starter/kritapykrita_krita_script_starter.desktop
+++ b/plugins/python/krita_script_starter/kritapykrita_krita_script_starter.desktop
@@ -1,45 +1,45 @@
 [Desktop Entry]
 Type=Service
 ServiceTypes=Krita/PythonPlugin
 X-KDE-Library=krita_script_starter
 X-Python-2-Compatible=false
 X-Krita-Manual=Manual.html
 Name=Krita Script Starter
 Name[ca]=Iniciador de scripts del Krita
 Name[ca@valencia]=Iniciador de scripts del Krita
 Name[cs]=Spouštěč skriptů Krita
 Name[en_GB]=Krita Script Starter
 Name[es]=Iniciador de guiones de Krita
 Name[eu]=Krita-ren script abiarazlea
 Name[gl]=Iniciador de scripts de Krita
 Name[it]=Iniziatore di script per Krita
 Name[ko]=Krita 스크립트 시작 도구
 Name[nl]=Script-starter van Krita
 Name[nn]=Krita skriptbyggjar
 Name[pl]=Starter skryptów Krity
 Name[pt]=Inicialização do Programa do Krita
 Name[sv]=Krita skriptstart
 Name[tr]=Krita Betik Başlatıcı
 Name[uk]=Створення скрипту Krita
 Name[x-test]=xxKrita Script Starterxx
 Name[zh_CN]=Krita 空脚本生成器
 Name[zh_TW]=Krita 指令啟動器
 Comment=Create the metadata and file structure for a new Krita script
 Comment[ca]=Crea les metadades i l'estructura de fitxers d'un script nou del Krita
 Comment[ca@valencia]=Crea les metadades i l'estructura de fitxers d'un script nou del Krita
 Comment[en_GB]=Create the metadata and file structure for a new Krita script
 Comment[es]=Crear los metadatos y la estructura de archivos para un nuevo guion de Krita
 Comment[eu]=Sortu Krita-script berri baterako meta-datuak eta fitxategi egitura
 Comment[gl]=Crear os metadatos e a estrutura de ficheiros para un novo script de Krita.
 Comment[it]=Crea i metadati e la struttura dei file per un nuovo script di Krita
 Comment[ko]=새 Krita 스크립트에 대한 메타데이터 및 파일 구조 생성
 Comment[nl]=Maak de metagegevens en bestandsstructuur voor een nieuw Krita-script
-Comment[nn]=Generer metadata og filstruktur for nytt Krita-skript
+Comment[nn]=Generer metadata og filstruktur for nye Krita-skript
 Comment[pl]=Utwórz metadane i strukturę plików dla nowego skryptu Krity
 Comment[pt]=Cria os meta-dados e a estrutura de ficheiros para um novo programa do Krita
 Comment[sv]=Skapa metadata och filstruktur för ett nytt Krita-skript
 Comment[tr]=Yeni Krita betiği için üstveri ve dosya yapısı oluştur
 Comment[uk]=Створення метаданих і структури файлів для нового скрипту Krita
 Comment[x-test]=xxCreate the metadata and file structure for a new Krita scriptxx
 Comment[zh_CN]=为新的 Krita 脚本创建元数据及文件结构
 Comment[zh_TW]=為新的 Krita 指令稿建立中繼資料和檔案建構體
diff --git a/plugins/python/lastdocumentsdocker/kritapykrita_lastdocumentsdocker.desktop b/plugins/python/lastdocumentsdocker/kritapykrita_lastdocumentsdocker.desktop
index 5b54ae897f..846e94d779 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 brukte dokument
+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_TW]=基於 Python 的面板，用於顯示最後 10 個檔案縮圖
diff --git a/plugins/python/palette_docker/__init__.py b/plugins/python/palette_docker/__init__.py
index f15a5c7a32..ce5aea935b 100644
--- a/plugins/python/palette_docker/__init__.py
+++ b/plugins/python/palette_docker/__init__.py
@@ -1,2 +1,7 @@
-# let's make a module
-from .palette_docker import *
+from krita import DockWidgetFactory, DockWidgetFactoryBase
+from .palette_docker import PaletteDocker
+
+
+Application.addDockWidgetFactory(
+    DockWidgetFactory("palette_docker", DockWidgetFactoryBase.DockRight,
+                      PaletteDocker))
diff --git a/plugins/python/palette_docker/palette_docker.py b/plugins/python/palette_docker/palette_docker.py
index f86808f004..8783b1fcf9 100644
--- a/plugins/python/palette_docker/palette_docker.py
+++ b/plugins/python/palette_docker/palette_docker.py
@@ -1,262 +1,279 @@
-'''
-Description: A Python based docker that allows you to edit KPL color palettes.
+# Description: A Python based docker that allows you to edit KPL color
+# palettes.
 
-By Wolthera(originally)
+# By Wolthera(originally)
 
-This script is licensed CC 0 1.0, so that you can learn from it.
+# This script is licensed CC 0 1.0, so that you can learn from it.
 
------- CC 0 1.0 ---------------
+# ------ CC 0 1.0 ---------------
 
-The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
+# The person who associated a work with this deed has dedicated the
+# work to the public domain by waiving all of his or her rights to the
+# work worldwide under copyright law, including all related and
+# neighboring rights, to the extent allowed by law.
 
-You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
+# You can copy, modify, distribute and perform the work, even for
+# commercial purposes, all without asking permission.
 
-https://creativecommons.org/publicdomain/zero/1.0/legalcode
+# https://creativecommons.org/publicdomain/zero/1.0/legalcode
+
+# @package palette_docker
 
-@package palette_docker
-'''
 
 # Importing the relevant dependencies:
-import sys
-from PyQt5.QtGui import QPixmap, QIcon, QImage, QPainter, QBrush, QPalette
-from PyQt5.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout, QComboBox, QAction, QTabWidget, QLineEdit, QSpinBox, QDialogButtonBox, QToolButton, QDialog, QPlainTextEdit, QCompleter, QMenu
-from PyQt5.Qt import Qt, pyqtSignal, pyqtSlot
-import math
-from krita import *
+from PyQt5.QtWidgets import (
+    QWidget, QVBoxLayout, QHBoxLayout, QComboBox, QAction, QTabWidget,
+    QLineEdit, QSpinBox, QDialogButtonBox, QToolButton, QDialog,
+    QPlainTextEdit, QCompleter, QMenu)
+from PyQt5.Qt import Qt, pyqtSlot
+from krita import DockWidget, Palette, PaletteView
 
 # import the exporters
-from . import palette_exporter_gimppalette, palette_exporter_inkscapeSVG, palette_sortColors
+from . import (
+    palette_exporter_gimppalette,
+    palette_exporter_inkscapeSVG,
+    palette_sortColors,
+)
 
 
-class Palette_Docker(DockWidget):
+class PaletteDocker(DockWidget):
     # Init the docker
 
     def __init__(self):
-        super(Palette_Docker, self).__init__()
+        super(PaletteDocker, self).__init__()
         # make base-widget and layout
         widget = QWidget()
         layout = QVBoxLayout()
         buttonLayout = QHBoxLayout()
         widget.setLayout(layout)
         self.setWindowTitle(i18n("Python Palette Docker"))
 
         # Make a combobox and add palettes
         self.cmb_palettes = QComboBox()
         allPalettes = Application.resources("palette")
         for palette_name in allPalettes:
             self.cmb_palettes.addItem(palette_name)
             self.cmb_palettes.model().sort(0)
 
         if len(allPalettes.keys()) > 0:
-            self.currentPalette = Palette(allPalettes[list(allPalettes.keys())[0]])
+            self.currentPalette = Palette(list(allPalettes.values())[0])
         else:
             self.currentPalette = None
 
         self.cmb_palettes.currentTextChanged.connect(self.slot_paletteChanged)
         layout.addWidget(self.cmb_palettes)  # add combobox to the layout
         self.paletteView = PaletteView()
         self.paletteView.setPalette(self.currentPalette)
         layout.addWidget(self.paletteView)
-        self.paletteView.entrySelectedForeGround.connect(self.slot_swatchSelected)
+        self.paletteView.entrySelectedForeGround.connect(
+            self.slot_swatchSelected)
 
         self.colorComboBox = QComboBox()
         self.colorList = list()
         buttonLayout.addWidget(self.colorComboBox)
         self.bnSetColor = QToolButton()
         self.bnSetColor.setText(i18n("Set"))
         self.bnSetColor.clicked.connect(self.slot_get_color_from_combobox)
         buttonLayout.addWidget(self.bnSetColor)
-        
+
         self.addEntry = QAction(self)
         self.addEntry.setIconText(i18n("+"))
         self.addEntry.triggered.connect(self.slot_add_entry)
         self.addGroup = QAction(self)
         self.addGroup.triggered.connect(self.slot_add_group)
         self.addGroup.setText(i18n("Add Group"))
         self.addGroup.setIconText(str("\U0001F4C2"))
         self.removeEntry = QAction(self)
         self.removeEntry.setText(i18n("Remove Entry"))
         self.removeEntry.setIconText("-")
         self.removeEntry.triggered.connect(self.slot_remove_entry)
         addEntryButton = QToolButton()
         addEntryButton.setDefaultAction(self.addEntry)
         buttonLayout.addWidget(addEntryButton)
         addGroupButton = QToolButton()
         addGroupButton.setDefaultAction(self.addGroup)
         buttonLayout.addWidget(addGroupButton)
         removeEntryButton = QToolButton()
         removeEntryButton.setDefaultAction(self.removeEntry)
         buttonLayout.addWidget(removeEntryButton)
 
         # QActions
         self.extra = QToolButton()
         self.editPaletteData = QAction(self)
         self.editPaletteData.setText(i18n("Edit Palette Settings"))
         self.editPaletteData.triggered.connect(self.slot_edit_palette_data)
         self.extra.setDefaultAction(self.editPaletteData)
         buttonLayout.addWidget(self.extra)
         self.actionMenu = QMenu()
         self.exportToGimp = QAction(self)
         self.exportToGimp.setText(i18n("Export as GIMP Palette File"))
         self.exportToGimp.triggered.connect(self.slot_export_to_gimp_palette)
         self.exportToInkscape = QAction(self)
-        self.exportToInkscape.setText(i18n("Export as Inkscape SVG with Swatches"))
-        self.exportToInkscape.triggered.connect(self.slot_export_to_inkscape_svg)
+        self.exportToInkscape.setText(
+            i18n("Export as Inkscape SVG with Swatches"))
+        self.exportToInkscape.triggered.connect(
+            self.slot_export_to_inkscape_svg)
         self.sortColors = QAction(self)
         self.sortColors.setText(i18n("Sort Colors"))
         self.sortColors.triggered.connect(self.slot_sort_colors)
         self.actionMenu.addAction(self.editPaletteData)
         self.actionMenu.addAction(self.exportToGimp)
         self.actionMenu.addAction(self.exportToInkscape)
         # self.actionMenu.addAction(self.sortColors)
 
         self.extra.setMenu(self.actionMenu)
 
         layout.addLayout(buttonLayout)
         self.slot_fill_combobox()
         self.setWidget(widget)        # add widget to the docker
 
     def slot_paletteChanged(self, name):
         allPalettes = Application.resources("palette")
         if len(allPalettes) > 0 and name in allPalettes:
-            self.currentPalette = Palette(Application.resources("palette")[name])
+            self.currentPalette = Palette(
+                Application.resources("palette")[name])
             self.paletteView.setPalette(self.currentPalette)
             self.slot_fill_combobox()
 
     @pyqtSlot('KisSwatch')
     def slot_swatchSelected(self, entry):
         if (self.canvas()) is not None:
             if (self.canvas().view()) is not None:
                 name = entry.name()
                 if len(entry.id) > 0:
                     name = entry.id() + " - " + entry.name()
                 if len(name) > 0:
                     if name in self.colorList:
-                        self.colorComboBox.setCurrentIndex(self.colorList.index(name))
+                        self.colorComboBox.setCurrentIndex(
+                            self.colorList.index(name))
                 color = self.currentPalette.colorForEntry(entry)
                 self.canvas().view().setForeGroundColor(color)
-    '''
-    A function for making a combobox with the available colors. We use QCompleter on the colorComboBox so that people
-    can type in the name of a color to select it. This is useful for people with carefully made palettes where the colors
-    are named properly, which makes it easier for them to find colors.
-    '''
 
     def slot_fill_combobox(self):
+        '''A function for making a combobox with the available colors. We use
+        QCompleter on the colorComboBox so that people can type in the
+        name of a color to select it. This is useful for people with
+        carefully made palettes where the colors are named properly,
+        which makes it easier for them to find colors.
+        '''
+
         if self.currentPalette is None:
             pass
-        palette = self.currentPalette
         self.colorComboBox.clear()
         self.colorList = list()
+#        palette = self.currentPalette
 #        for info in palette.infoList():
 #            entry = info.swatch
 #            color = palette.colorForEntry(entry).colorForCanvas(self.canvas())
 #            colorSquare = QPixmap(12, 12)
 #            if entry.spotColor() is True:
 #                img = colorSquare.toImage()
 #                circlePainter = QPainter()
 #                img.fill(self.colorComboBox.palette().color(QPalette.Base))
 #                circlePainter.begin(img)
 #                brush = QBrush(Qt.SolidPattern)
 #                brush.setColor(color)
 #                circlePainter.setBrush(brush)
 #                circlePainter.pen().setWidth(0)
 #                circlePainter.drawEllipse(0, 0, 11, 11)
 #                circlePainter.end()
 #                colorSquare = QPixmap.fromImage(img)
 #            else:
 #                colorSquare.fill(color)
 #            name = entry.name()
 #            if len(entry.id()) > 0:
 #                name = entry.id() + " - " + entry.name()
 #            self.colorList.append(name)
 #            self.colorComboBox.addItem(QIcon(colorSquare), name)
         self.colorComboBox.setEditable(True)
         self.colorComboBox.setInsertPolicy(QComboBox.NoInsert)
-        self.colorComboBox.completer().setCompletionMode(QCompleter.PopupCompletion)
+        self.colorComboBox.completer().setCompletionMode(
+            QCompleter.PopupCompletion)
         self.colorComboBox.completer().setCaseSensitivity(False)
         self.colorComboBox.completer().setFilterMode(Qt.MatchContains)
-        
 
     def slot_get_color_from_combobox(self):
         if self.currentPalette is not None:
-            entry = self.currentPalette.colorSetEntryByIndex(self.colorComboBox.currentIndex())
+            entry = self.currentPalette.colorSetEntryByIndex(
+                self.colorComboBox.currentIndex())
             self.slot_swatchSelected(entry)
 
     def slot_add_entry(self):
         if (self.canvas()) is not None:
             if (self.canvas().view()) is not None:
                 color = self.canvas().view().foregroundColor()
                 success = self.paletteView.addEntryWithDialog(color)
                 if success is True:
                     self.slot_fill_combobox()
 
     def slot_add_group(self):
         success = self.paletteView.addGroupWithDialog()
         if success is True:
             self.slot_fill_combobox()
 
     def slot_remove_entry(self):
         success = self.paletteView.removeSelectedEntryWithDialog()
         if success is True:
             self.slot_fill_combobox()
 
-    '''
-    A function for giving a gui to edit palette metadata... I also want this to be the way to edit the settings of the
-    palette docker.
-    '''
-
     def slot_edit_palette_data(self):
+        '''A function for giving a gui to edit palette metadata... I also
+        want this to be the way to edit the settings of the palette
+        docker.
+        '''
+
         dialog = QDialog(self)
         tabWidget = QTabWidget()
         dialog.setWindowTitle(i18n("Edit Palette Data"))
         dialog.setLayout(QVBoxLayout())
         dialog.layout().addWidget(tabWidget)
         paletteWidget = QWidget()
         paletteWidget.setLayout(QVBoxLayout())
         tabWidget.addTab(paletteWidget, i18n("Palette Data"))
         paletteName = QLineEdit()
         paletteName.setText(self.cmb_palettes.currentText())
         paletteWidget.layout().addWidget(paletteName)
         paletteColumns = QSpinBox()
         paletteColumns.setValue(self.currentPalette.columnCount())
         paletteWidget.layout().addWidget(paletteColumns)
         paletteComment = QPlainTextEdit()
         paletteComment.appendPlainText(self.currentPalette.comment())
         paletteWidget.layout().addWidget(paletteComment)
         buttons = QDialogButtonBox(QDialogButtonBox.Ok)
         dialog.layout().addWidget(buttons)
         buttons.accepted.connect(dialog.accept)
         # buttons.rejected.connect(dialog.reject())
 
         if dialog.exec_() == QDialog.Accepted:
-            Resource = Application.resources("palette")[self.cmb_palettes.currentText()]
+            Resource = Application.resources("palette")[
+                self.cmb_palettes.currentText()]
             Resource.setName(paletteName.text())
             self.currentPalette = Palette(Resource)
             self.currentPalette.setColumnCount(paletteColumns.value())
             self.paletteView.setPalette(self.currentPalette)
             self.slot_fill_combobox()
             self.currentPalette.setComment(paletteComment.toPlainText())
             self.currentPalette.save()
 
     def slot_export_to_gimp_palette(self):
-        palette_exporter_gimppalette.gimpPaletteExporter(self.cmb_palettes.currentText())
+        palette_exporter_gimppalette.gimpPaletteExporter(
+            self.cmb_palettes.currentText())
 
     def slot_export_to_inkscape_svg(self):
-        palette_exporter_inkscapeSVG.inkscapeSVGExporter(self.cmb_palettes.currentText())
+        palette_exporter_inkscapeSVG.inkscapeSVGExporter(
+            self.cmb_palettes.currentText())
 
     def slot_sort_colors(self):
-        colorSorter = palette_sortColors.sortColors(self.cmb_palettes.currentText())
+        colorSorter = palette_sortColors.sortColors(
+            self.cmb_palettes.currentText())
         self.paletteView.setPalette(colorSorter.palette())
 
     def canvasChanged(self, canvas):
         self.cmb_palettes.clear()
         allPalettes = Application.resources("palette")
         for palette_name in allPalettes:
             self.cmb_palettes.addItem(palette_name)
             self.cmb_palettes.model().sort(0)
 
-        if self.currentPalette == None and len(allPalettes.keys()) > 0:
-            self.currentPalette = Palette(allPalettes[list(allPalettes.keys())[0]])
-
-# Add docker to the application :)
-Application.addDockWidgetFactory(DockWidgetFactory("palette_docker", DockWidgetFactoryBase.DockRight, Palette_Docker))
+        if self.currentPalette is None and len(allPalettes.keys()) > 0:
+            self.currentPalette = Palette(list(allPalettes.values())[0])
diff --git a/plugins/python/palette_docker/palette_exporter_gimppalette.py b/plugins/python/palette_docker/palette_exporter_gimppalette.py
index 3724ab89e2..56773b0924 100644
--- a/plugins/python/palette_docker/palette_exporter_gimppalette.py
+++ b/plugins/python/palette_docker/palette_exporter_gimppalette.py
@@ -1,73 +1,86 @@
-'''
-A script that converts the palette with the given name to a gimp palette at the location asked for.
+# A script that converts the palette with the given name to a gimp
+# palette at the location asked for.
 
-By Wolthera(originally)
+# By Wolthera(originally)
 
-This script is licensed CC 0 1.0, so that you can learn from it.
+# This script is licensed CC 0 1.0, so that you can learn from it.
 
------- CC 0 1.0 ---------------
+# ------ CC 0 1.0 ---------------
 
-The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
+# The person who associated a work with this deed has dedicated the
+# work to the public domain by waiving all of his or her rights to the
+# work worldwide under copyright law, including all related and
+# neighboring rights, to the extent allowed by law.
 
-You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
+# You can copy, modify, distribute and perform the work, even for
+# commercial purposes, all without asking permission.
 
-https://creativecommons.org/publicdomain/zero/1.0/legalcode
+# https://creativecommons.org/publicdomain/zero/1.0/legalcode
 
-@package palette_docker
-'''
+# @package palette_docker
 
 
 # Importing the relevant dependencies:
-import sys
 from PyQt5.QtWidgets import QFileDialog, QMessageBox
-import math
-from krita import *
+from krita import Palette
 
 
 class gimpPaletteExporter:
 
     def __init__(self, name):
         # We want people to select a palette and a location to save to...
         self.fileName = QFileDialog.getExistingDirectory()
         allPalettes = Application.resources("palette")
         self.paletteName = name
         self.currentPalette = Palette(allPalettes[self.paletteName])
         self.export()
         done = QMessageBox()
         done.setWindowTitle(i18n("Export Successful"))
-        done.setText(str(i18n("{input} has been exported to {output}.")).format(input=self.paletteName, output=self.fileName))
+        done.setText(
+            str(i18n("{input} has been exported to {output}.")).format(
+                input=self.paletteName, output=self.fileName))
         done.exec_()
         pass
 
     def export(self):
         # open the appropriate file...
         gplFile = open(self.fileName + "/" + self.paletteName + ".gpl", "w")
         gplFile.write("GIMP Palette\n")
-        gplFile.write("Name: " + self.paletteName + "\n")
-        gplFile.write("Columns: " + str(self.currentPalette.columnCount()) + "\n")
-        gplFile.write("#" + self.currentPalette.comment() + "\n")
+        gplFile.write("Name: %s\n" % self.paletteName)
+        gplFile.write("Columns: %s/n", self.currentPalette.columnCount())
+        gplFile.write("#%s\n" % self.currentPalette.comment())
         colorCount = self.currentPalette.colorsCountGroup("")
 
         for i in range(colorCount):
             entry = self.currentPalette.colorSetEntryFromGroup(i, "")
             color = self.currentPalette.colorForEntry(entry)
             # convert to sRGB
             color.setColorSpace("RGBA", "U8", "sRGB built-in")
 
             red = max(min(int(color.componentsOrdered()[0] * 255), 255), 0)
             green = max(min(int(color.componentsOrdered()[1] * 255), 255), 0)
             blue = max(min(int(color.componentsOrdered()[2] * 255), 255), 0)
-            gplFile.write(str(red) + " " + str(green) + " " + str(blue) + "    " + entry.id() + "-" + entry.name() + "\n")
+            gplFile.write(
+                "{red} {green} {blue}    {id}-{name}\n".format(
+                    red=red, green=green, blue=blue, id=entry.id(),
+                    name=entry.name))
             groupNames = self.currentPalette.groupNames()
             for groupName in groupNames:
                 colorCount = self.currentPalette.colorsCountGroup(groupName)
                 for i in range(colorCount):
-                    entry = self.currentPalette.colorSetEntryFromGroup(i, groupName)
+                    entry = self.currentPalette.colorSetEntryFromGroup(
+                        i, groupName)
                     color = self.currentPalette.colorForEntry(entry)
                     # convert to sRGB
                     color.setColorSpace("RGBA", "U8", "sRGB built-in")
-                    red = max(min(int(color.componentsOrdered()[0] * 255), 255), 0)
-                    green = max(min(int(color.componentsOrdered()[1] * 255), 255), 0)
-                    blue = max(min(int(color.componentsOrdered()[2] * 255), 255), 0)
-                    gplFile.write(str(red) + " " + str(green) + " " + str(blue) + "    " + entry.id() + "-" + entry.name() + "\n")
+                    red = max(
+                        min(int(color.componentsOrdered()[0] * 255), 255), 0)
+                    green = max(
+                        min(int(color.componentsOrdered()[1] * 255), 255), 0)
+                    blue = max(
+                        min(int(color.componentsOrdered()[2] * 255), 255), 0)
+                    gplFile.write(
+                        "{red} {green} {blue}    {id}-{name}\n".format(
+                            red=red, green=green, blue=blue, id=entry.id(),
+                            name=entry.name))
         gplFile.close()
diff --git a/plugins/python/palette_docker/palette_exporter_inkscapeSVG.py b/plugins/python/palette_docker/palette_exporter_inkscapeSVG.py
index f782ca2059..f6c1dda828 100644
--- a/plugins/python/palette_docker/palette_exporter_inkscapeSVG.py
+++ b/plugins/python/palette_docker/palette_exporter_inkscapeSVG.py
@@ -1,186 +1,218 @@
-'''
-A script that converts the palette named "Default" to a SVG so that Inkscape may use the colors
-The icc-color stuff doesn't work right, because we'd need the ability to get the url of the colorprofile somehow, and then we can make color-profile things in the definitions.
+# A script that converts the palette named "Default" to a SVG so that
+# Inkscape may use the colors
 
-By Wolthera(originally)
+# The icc-color stuff doesn't work right, because we'd need the
+# ability to get the url of the colorprofile somehow, and then we can
+# make color-profile things in the definitions.
 
-This script is licensed CC 0 1.0, so that you can learn from it.
+# By Wolthera(originally)
 
------- CC 0 1.0 ---------------
+# This script is licensed CC 0 1.0, so that you can learn from it.
 
-The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
+# ------ CC 0 1.0 ---------------
 
-You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
+# The person who associated a work with this deed has dedicated the
+# work to the public domain by waiving all of his or her rights to the
+# work worldwide under copyright law, including all related and
+# neighboring rights, to the extent allowed by law.
 
-https://creativecommons.org/publicdomain/zero/1.0/legalcode
+# You can copy, modify, distribute and perform the work, even for
+# commercial purposes, all without asking permission.
+
+# https://creativecommons.org/publicdomain/zero/1.0/legalcode
+
+# @package palette_docker
 
-@package palette_docker
-'''
 
 # Importing the relevant dependencies:
-import sys
 from PyQt5.QtXml import QDomDocument
 from PyQt5.QtWidgets import QFileDialog, QMessageBox
-import math
-from krita import *
+from krita import Palette
 
 
 class inkscapeSVGExporter:
 
     def __init__(self, name):
         # We want people to select a palette and a location to save to...
         self.fileName = QFileDialog.getExistingDirectory()
         allPalettes = Application.resources("palette")
         self.paletteName = name
         self.currentPalette = Palette(allPalettes[self.paletteName])
         self.export()
         done = QMessageBox()
         done.setWindowTitle(i18n("Export Successful"))
-        done.setText(str(i18n("{input} has been exported to {output}.")).format(input=self.paletteName, output=self.fileName))
+        done.setText(
+            str(i18n("{input} has been exported to {output}.")).format(
+                input=self.paletteName, output=self.fileName))
         done.exec_()
         pass
 
     def export(self):
         # open the appropriate file...
         svgFile = open(self.fileName + "/" + self.paletteName + ".svg", "w")
         svgDoc = QDomDocument()
         svgBaseElement = svgDoc.createElement("svg")
-        svgBaseElement.setAttribute("xmlns:osb", "http://www.openswatchbook.org/uri/2009/osb")
-        svgBaseElement.setAttribute("xmlns:svg", "http://www.w3.org/2000/svg")
-        svgBaseElement.setAttribute("xmlns:dc", "http://purl.org/dc/elements/1.1/")
-        svgBaseElement.setAttribute("xmlns:cc", "http://creativecommons.org/ns#")
-        svgBaseElement.setAttribute("xmlns:rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#")
+        svgBaseElement.setAttribute(
+            "xmlns:osb", "http://www.openswatchbook.org/uri/2009/osb")
+        svgBaseElement.setAttribute(
+            "xmlns:svg", "http://www.w3.org/2000/svg")
+        svgBaseElement.setAttribute(
+            "xmlns:dc", "http://purl.org/dc/elements/1.1/")
+        svgBaseElement.setAttribute(
+            "xmlns:cc", "http://creativecommons.org/ns#")
+        svgBaseElement.setAttribute(
+            "xmlns:rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#")
         svgDefs = svgDoc.createElement("defs")
         svgSwatches = svgDoc.createElement("g")
         svgSwatches.setAttribute("id", "Swatches")
 
         svgMeta = svgDoc.createElement("metadata")
         svgBaseElement.appendChild(svgMeta)
         rdf = svgDoc.createElement("rdf:RDF")
         ccwork = svgDoc.createElement("cc:Work")
         dctitle = svgDoc.createElement("dc:title")
         dcdescription = svgDoc.createElement("dc:description")
         dctitle.appendChild(svgDoc.createTextNode(self.paletteName))
-        dcdescription.appendChild(svgDoc.createTextNode(self.currentPalette.comment()))
+        dcdescription.appendChild(svgDoc.createTextNode(
+            self.currentPalette.comment()))
         ccwork.appendChild(dctitle)
         ccwork.appendChild(dcdescription)
         rdf.appendChild(ccwork)
         svgMeta.appendChild(rdf)
         Row = 0
         Column = 0
         iccProfileList = []
 
         colorCount = self.currentPalette.colorsCountGroup("")
 
         for i in range(colorCount):
             entry = self.currentPalette.colorSetEntryFromGroup(i, "")
             color = self.currentPalette.colorForEntry(entry)
 
             iccColor = "icc-color(" + color.colorProfile()
             for c in range(len(color.componentsOrdered()) - 1):
-                iccColor = iccColor + "," + str(color.componentsOrdered()[c])
+                iccColor = "{col},{c}".format(
+                    col=iccColor, c=color.componentsOrdered()[c])
             iccColor = iccColor + ")"
             if color.colorProfile() not in iccProfileList:
                 iccProfileList.append(color.colorProfile())
 
             # convert to sRGB
             color.setColorSpace("RGBA", "U8", "sRGB built-in")
             red = max(min(int(color.componentsOrdered()[0] * 255), 255), 0)
             green = max(min(int(color.componentsOrdered()[1] * 255), 255), 0)
             blue = max(min(int(color.componentsOrdered()[2] * 255), 255), 0)
-            hexcode = "#" + str(format(red, '02x')) + str(format(green, '02x')) + str(format(blue, '02x'))
-            swatchName = str(i) + "-" + entry.name()
+            hexcode = "#{red:02x}{green:02x}{blue:02x}".format(
+                red=red, green=green, blue=blue)
+            swatchName = "{i}-{name}".format(i=i, name=entry.name())
             swatchName = swatchName.replace(" ", "-")
             swatchName = swatchName.replace("(", "-")
             swatchName = swatchName.replace(")", "-")
             swatchMain = svgDoc.createElement("linearGradient")
             swatchMain.setAttribute("osb:paint", "solid")
             swatchMain.setAttribute("id", swatchName)
             swatchSub = svgDoc.createElement("stop")
-            swatchSub.setAttribute("style", "stop-color: " + hexcode + " " + iccColor + ";stop-opacity:1;")
+            swatchSub.setAttribute(
+                "style",
+                "stop-color: {hex} {color};stop-opacity:1;".format(
+                    hex=hexcode, color=iccColor))
             swatchMain.appendChild(swatchSub)
             svgDefs.appendChild(swatchMain)
             svgSingleSwatch = svgDoc.createElement("rect")
             svgSingleSwatch.setAttribute("x", str(int(Column * 20)))
             svgSingleSwatch.setAttribute("y", str(int(Row * 20)))
             svgSingleSwatch.setAttribute("width", str(int(20)))
             svgSingleSwatch.setAttribute("height", str(int(20)))
-            svgSingleSwatch.setAttribute("fill", "url(#" + swatchName + ")")
-            svgSingleSwatch.setAttribute("id", "swatch" + swatchName)
+            svgSingleSwatch.setAttribute("fill", "url(#%s)" % swatchName)
+            svgSingleSwatch.setAttribute("id", "swatch %s" % swatchName)
             if entry.spotColor() is True:
                 svgSingleSwatch.setAttribute("rx", str(10))
                 svgSingleSwatch.setAttribute("ry", str(10))
             svgSwatches.appendChild(svgSingleSwatch)
             Column += 1
             if (Column >= self.currentPalette.columnCount()):
                 Column = 0
                 Row += 1
 
         groupNames = self.currentPalette.groupNames()
         for groupName in groupNames:
             Column = 0
             Row += 1
             groupTitle = svgDoc.createElement("text")
             groupTitle.setAttribute("x", str(int(Column * 20)))
             groupTitle.setAttribute("y", str(int(Row * 20) + 15))
             groupTitle.appendChild(svgDoc.createTextNode(groupName))
             svgSwatches.appendChild(groupTitle)
             Row += 1
             colorCount = self.currentPalette.colorsCountGroup(groupName)
             for i in range(colorCount):
-                entry = self.currentPalette.colorSetEntryFromGroup(i, groupName)
+                entry = self.currentPalette.colorSetEntryFromGroup(
+                    i, groupName)
                 color = self.currentPalette.colorForEntry(entry)
                 iccColor = "icc-color(" + color.colorProfile()
                 for c in range(len(color.componentsOrdered()) - 1):
-                    iccColor = iccColor + "," + str(color.componentsOrdered()[c])
+                    iccColor = "{col},{c}".format(
+                        col=iccColor, c=color.componentsOrdered()[c])
                 iccColor = iccColor + ")"
                 if color.colorProfile() not in iccProfileList:
                     iccProfileList.append(color.colorProfile())
                 # convert to sRGB
                 color.setColorSpace("RGBA", "U8", "sRGB built-in")
-                red = max(min(int(color.componentsOrdered()[0] * 255), 255), 0)
-                green = max(min(int(color.componentsOrdered()[1] * 255), 255), 0)
-                blue = max(min(int(color.componentsOrdered()[2] * 255), 255), 0)
-                hexcode = "#" + str(format(red, '02x')) + str(format(green, '02x')) + str(format(blue, '02x'))
-
+                red = max(
+                    min(int(color.componentsOrdered()[0] * 255), 255), 0)
+                green = max(
+                    min(int(color.componentsOrdered()[1] * 255), 255), 0)
+                blue = max(
+                    min(int(color.componentsOrdered()[2] * 255), 255), 0)
+                hexcode = "#{red:02x}{green:02x}{blue:02x}".format(
+                    red=red, green=green, blue=blue)
                 swatchName = groupName + str(i) + "-" + entry.name()
                 swatchName = swatchName.replace(" ", "-")
                 swatchName = swatchName.replace("(", "-")
                 swatchName = swatchName.replace(")", "-")
                 swatchMain = svgDoc.createElement("linearGradient")
                 swatchMain.setAttribute("osb:paint", "solid")
                 swatchMain.setAttribute("id", swatchName)
                 swatchSub = svgDoc.createElement("stop")
-                swatchSub.setAttribute("style", "stop-color: " + hexcode + " " + iccColor + ";stop-opacity:1;")
+                swatchSub.setAttribute(
+                    "style",
+                    "stop-color: {hex} {color};stop-opacity:1;".format(
+                        hex=hexcode, color=iccColor))
+
                 swatchMain.appendChild(swatchSub)
                 svgDefs.appendChild(swatchMain)
                 svgSingleSwatch = svgDoc.createElement("rect")
                 svgSingleSwatch.setAttribute("x", str(int(Column * 20)))
                 svgSingleSwatch.setAttribute("y", str(int(Row * 20)))
                 svgSingleSwatch.setAttribute("width", str(int(20)))
                 svgSingleSwatch.setAttribute("height", str(int(20)))
-                svgSingleSwatch.setAttribute("fill", "url(#" + swatchName + ")")
-                svgSingleSwatch.setAttribute("id", "swatch " + swatchName)
+                svgSingleSwatch.setAttribute("fill", "url(#%s)" % swatchName)
+                svgSingleSwatch.setAttribute("id", "swatch %s" % swatchName)
                 if entry.spotColor() is True:
                     svgSingleSwatch.setAttribute("rx", str(10))
                     svgSingleSwatch.setAttribute("ry", str(10))
                 svgSwatches.appendChild(svgSingleSwatch)
                 Column += 1
                 if (Column >= self.currentPalette.columnCount()):
                     Column = 0
                     Row += 1
 
         for profile in iccProfileList:
             svgProfileDesc = svgDoc.createElement("color-profile")
             svgProfileDesc.setAttribute("name", profile)
-            # This is incomplete because python api doesn't have any way to ask for this data yet.
+            # This is incomplete because python api doesn't have any
+            # way to ask for this data yet.
             # svgProfileDesc.setAttribute("local", "sRGB")
             # svgProfileDesc.setAttribute("xlink:href", colorprofileurl)
             svgProfileDesc.setAttribute("rendering-intent", "perceptual")
             svgDefs.appendChild(svgProfileDesc)
         svgBaseElement.appendChild(svgDefs)
         svgBaseElement.appendChild(svgSwatches)
-        svgBaseElement.setAttribute("viewBox", "0 0 " + str(self.currentPalette.columnCount() * 20) + " " + str(int((Row + 1) * 20)))
+        svgBaseElement.setAttribute(
+            "viewBox",
+            "0 0 {cols} {row}".format(
+                cols=self.currentPalette.columnCount() * 20,
+                row=int((Row + 1) * 20)))
         svgDoc.appendChild(svgBaseElement)
         svgFile.write(svgDoc.toString())
         svgFile.close()
diff --git a/plugins/python/palette_docker/palette_sortColors.py b/plugins/python/palette_docker/palette_sortColors.py
index 304ff9d6eb..70abe81f8e 100644
--- a/plugins/python/palette_docker/palette_sortColors.py
+++ b/plugins/python/palette_docker/palette_sortColors.py
@@ -1,78 +1,80 @@
-'''
-A script that sorts the colors in the group.
+# A script that sorts the colors in the group.
 
-By Wolthera(originally)
+# By Wolthera(originally)
 
-This script is licensed CC 0 1.0, so that you can learn from it.
+# This script is licensed CC 0 1.0, so that you can learn from it.
 
------- CC 0 1.0 ---------------
+# ------ CC 0 1.0 ---------------
 
-The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
+# The person who associated a work with this deed has dedicated the
+# work to the public domain by waiving all of his or her rights to the
+# work worldwide under copyright law, including all related and
+# neighboring rights, to the extent allowed by law.
 
-You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
+# You can copy, modify, distribute and perform the work, even for
+# commercial purposes, all without asking permission.
 
-https://creativecommons.org/publicdomain/zero/1.0/legalcode
+# https://creativecommons.org/publicdomain/zero/1.0/legalcode
 
-@package palette_docker
-'''
+# @package palette_docker
 
-
-# Importing the relevant dependencies:
-from krita import *
+from krita import Palette
 
 
 class sortColors(object):
 
     def __init__(self, name):
         # We want people to select a palette...
         allPalettes = Application.resources("palette")
         self.paletteName = name
         self.currentPalette = Palette(allPalettes[self.paletteName])
         self.sort_all_groups()
 
     def sort_all_groups(self):
         self.sort_color_by_name(str())
         groupNames = self.currentPalette.groupNames()
         for groupName in groupNames:
             self.sort_color_by_name(groupName)
 
     def sort_color_by_name(self, groupName):
-        l = {}
+        d = {}
         colorCount = self.currentPalette.colorsCountGroup(groupName)
         for i in range(colorCount - 1, -1, -1):
             entry = self.currentPalette.colorSetEntryFromGroup((i), groupName)
-            l[entry.name + str(i)] = entry
+            d[entry.name + str(i)] = entry
             self.currentPalette.removeEntry((i), groupName)
 
-        for s in sorted(l):
-            self.currentPalette.addEntry(l[s], groupName)
+        for s in sorted(d):
+            self.currentPalette.addEntry(d[s], groupName)
 
     def sort_color_by_id(self, groupName):
-        l = {}
+        d = {}
         colorCount = self.currentPalette.colorsCountGroup(groupName)
         for i in range(colorCount - 1, -1, -1):
             entry = self.currentPalette.colorSetEntryFromGroup((i), groupName)
-            l[entry.id() + " " + str(i)] = entry
+            d[entry.id() + " " + str(i)] = entry
             self.currentPalette.removeEntry((i), groupName)
 
-        for s in sorted(l):
-            self.currentPalette.addEntry(l[s], groupName)
+        for s in sorted(d):
+            self.currentPalette.addEntry(d[s], groupName)
 
     def sort_by_value(self, groupName):
-        l = {}
+        d = {}
         colorCount = self.currentPalette.colorsCountGroup(groupName)
         for i in range(colorCount - 1, -1, -1):
             entry = self.currentPalette.colorSetEntryFromGroup((i), groupName)
             color = self.currentPalette.colorForEntry(entry)
             color.setColorSpace("RGBA", "U8", "sRGB built-in")
-            l[color.components()[0] + color.components()[1] + color.components()[2]] = entry
+            d[color.components()[0] +
+              color.components()[1] +
+              color.components()[2]] = entry
             self.currentPalette.removeEntry((i), groupName)
 
-        for s in sorted(l):
-            self.currentPalette.addEntry(l[s], groupName)
+        for s in sorted(d):
+            self.currentPalette.addEntry(d[s], groupName)
 
     def sort_by_hue(self, stepsize, groupName):
         pass
 
     def palette(self):
         return self.currentPalette
diff --git a/plugins/python/scripter/kritapykrita_scripter.desktop b/plugins/python/scripter/kritapykrita_scripter.desktop
index 7ad09b506f..e79dde80b6 100644
--- a/plugins/python/scripter/kritapykrita_scripter.desktop
+++ b/plugins/python/scripter/kritapykrita_scripter.desktop
@@ -1,49 +1,49 @@
 [Desktop Entry]
 Type=Service
 ServiceTypes=Krita/PythonPlugin
 X-KDE-Library=scripter
 X-Python-2-Compatible=true
 X-Krita-Manual=Manual.html
 Name=Scripter
 Name[ca]=Scripter
 Name[ca@valencia]=Scripter
 Name[de]=Scripter
 Name[el]=Σενάρια
 Name[en_GB]=Scripter
 Name[es]=Guionador
 Name[eu]=Script egilea
 Name[fr]=Scripter
 Name[gl]=Executor de scripts
 Name[it]=Scripter
 Name[ko]=스크립트 도구
 Name[nl]=Scriptmaker
 Name[nn]=Skriptkøyrer
 Name[pl]=Skrypter
 Name[pt]=Programador
 Name[sv]=Skriptgenerator
 Name[tr]=Betik yazarı
 Name[uk]=Скриптер
 Name[x-test]=xxScripterxx
 Name[zh_CN]=脚本工具
 Name[zh_TW]=指令稿編寫者
 Comment=Plugin to execute ad-hoc Python code
 Comment[ca]=Connector per executar codi «ad hoc» en Python
 Comment[ca@valencia]=Connector per executar codi «ad hoc» en Python
 Comment[el]=Πρόσθετο για την εκτέλεση συγκεκριμένου κώδικα Python
 Comment[en_GB]=Plugin to execute ad-hoc Python code
 Comment[es]=Complemento para ejecutar código Python a medida
 Comment[eu]=Berariaz egindako Python kodea exekutatzeko plugina
 Comment[fi]=Liitännäinen satunnaisen Python-koodin suorittamiseksi
 Comment[gl]=Complemento para executar código de Python escrito no momento.
 Comment[it]=Estensione per eseguire ad-hoc codice Python
 Comment[ko]=즉석에서 Python 코드를 실행하는 플러그인
 Comment[nl]=Plug-in om ad-hoc Python code uit te voeren
-Comment[nn]=Programtillegg for køyring av ad hoc-køyring av Python-kode
+Comment[nn]=Programtillegg for køyring av ad hoc Python-kode
 Comment[pl]=Wtyczka do wykonywania kodu Pythona ad-hoc
 Comment[pt]='Plugin' para executar código em Python arbitrário
 Comment[sv]=Insticksprogram för att köra godtycklig Python-kod
 Comment[tr]=Geçici Python kodu çalıştırmak için eklenti
 Comment[uk]=Додаток для виконання апріорного коду Python
 Comment[x-test]=xxPlugin to execute ad-hoc Python codexx
 Comment[zh_CN]=用于执行当场编写的 Python 代码的插件
 Comment[zh_TW]=外掛程式，用於執行特定 Python 程式碼
diff --git a/plugins/python/tenscripts/kritapykrita_tenscripts.desktop b/plugins/python/tenscripts/kritapykrita_tenscripts.desktop
index 0550f859b4..abde5797ff 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_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 for å leggja til ti handlingar og tildela dei til Python-skript
+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_TW]=基於 Python 的外掛程式，用於建立 10 個動作並且將它們指定給 Python 指令稿
diff --git a/plugins/tools/basictools/kis_tool_brush.cc b/plugins/tools/basictools/kis_tool_brush.cc
index 7e138645a4..85fb5634e3 100644
--- a/plugins/tools/basictools/kis_tool_brush.cc
+++ b/plugins/tools/basictools/kis_tool_brush.cc
@@ -1,484 +1,484 @@
 /*
  *  kis_tool_brush.cc - part of Krita
  *
  *  Copyright (c) 2003-2004 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2015 Moritz Molch <kde@moritzmolch.de>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_tool_brush.h"
 #include <kis_icon.h>
 
 #include <QCheckBox>
 #include <QComboBox>
 
 #include <klocalizedstring.h>
 #include <QAction>
 #include <QLabel>
 #include <kactioncollection.h>
 
 #include <KoCanvasBase.h>
 #include <KoCanvasController.h>
 
 #include <kis_action_registry.h>
 #include "kis_cursor.h"
 #include "kis_config.h"
 #include "kis_slider_spin_box.h"
 #include "kundo2magicstring.h"
 
 #include <KisUsageLogger.h>
 
 #define MAXIMUM_SMOOTHNESS_DISTANCE 1000.0 // 0..1000.0 == weight in gui
 #define MAXIMUM_MAGNETISM 1000
 
 
 void KisToolBrush::addSmoothingAction(int enumId, const QString &id)
 {
     /**
      * KisToolBrush is the base of several tools, but the actions
      * should be unique, so let's be careful with them
      */
     QAction *a = action(id);
     connect(a, SIGNAL(triggered()), &m_signalMapper, SLOT(map()));
     m_signalMapper.setMapping(a, enumId);
 }
 
 KisToolBrush::KisToolBrush(KoCanvasBase * canvas)
     : KisToolFreehand(canvas,
                       KisCursor::load("tool_freehand_cursor.png", 5, 5),
                       kundo2_i18n("Freehand Brush Stroke"))
 {
     setObjectName("tool_brush");
 
     createOptionWidget();
 
     connect(this, SIGNAL(smoothingTypeChanged()), this, SLOT(resetCursorStyle()));
 
     addSmoothingAction(KisSmoothingOptions::NO_SMOOTHING, "set_no_brush_smoothing");
     addSmoothingAction(KisSmoothingOptions::SIMPLE_SMOOTHING, "set_simple_brush_smoothing");
     addSmoothingAction(KisSmoothingOptions::WEIGHTED_SMOOTHING, "set_weighted_brush_smoothing");
     addSmoothingAction(KisSmoothingOptions::STABILIZER, "set_stabilizer_brush_smoothing");
 
 }
 
 KisToolBrush::~KisToolBrush()
 {
 }
 
 void KisToolBrush::activate(ToolActivation activation, const QSet<KoShape*> &shapes)
 {
     KisToolFreehand::activate(activation, shapes);
     connect(&m_signalMapper, SIGNAL(mapped(int)), SLOT(slotSetSmoothingType(int)), Qt::UniqueConnection);
 
     QAction *toggleaction = action("toggle_assistant");
     connect(toggleaction, SIGNAL(triggered(bool)), m_chkAssistant, SLOT(toggle()), Qt::UniqueConnection);
 
     m_configGroup =  KSharedConfig::openConfig()->group(toolId());
 }
 
 void KisToolBrush::deactivate()
 {
     disconnect(&m_signalMapper, 0, this, 0);
     QAction *toggleaction = action("toggle_assistant");
     disconnect(toggleaction, 0, m_chkAssistant, 0);
 
     KisToolFreehand::deactivate();
 }
 
 int KisToolBrush::smoothingType() const
 {
     return smoothingOptions()->smoothingType();
 }
 
 bool KisToolBrush::smoothPressure() const
 {
     return smoothingOptions()->smoothPressure();
 }
 
 int KisToolBrush::smoothnessQuality() const
 {
     return smoothingOptions()->smoothnessDistance();
 }
 
 qreal KisToolBrush::smoothnessFactor() const
 {
     return smoothingOptions()->tailAggressiveness();
 }
 
 void KisToolBrush::slotSetSmoothingType(int index)
 {
     /**
      * The slot can also be called from smoothing-type-switching
      * action that would mean the combo box will not be synchronized
      */
     if (m_cmbSmoothingType->currentIndex() != index) {
         m_cmbSmoothingType->setCurrentIndex(index);
     }
 
     switch (index) {
     case 0:
         KisUsageLogger::log("Disabled smoothing.");
         smoothingOptions()->setSmoothingType(KisSmoothingOptions::NO_SMOOTHING);
         showControl(m_sliderSmoothnessDistance, false);
         showControl(m_sliderTailAggressiveness, false);
         showControl(m_chkSmoothPressure, false);
         showControl(m_chkUseScalableDistance, false);
         showControl(m_sliderDelayDistance, false);
         showControl(m_chkFinishStabilizedCurve, false);
         showControl(m_chkStabilizeSensors, false);
         break;
     case 1:
         KisUsageLogger::log("Enabled simple smoothing.");
         smoothingOptions()->setSmoothingType(KisSmoothingOptions::SIMPLE_SMOOTHING);
         showControl(m_sliderSmoothnessDistance, false);
         showControl(m_sliderTailAggressiveness, false);
         showControl(m_chkSmoothPressure, false);
         showControl(m_chkUseScalableDistance, false);
         showControl(m_sliderDelayDistance, false);
         showControl(m_chkFinishStabilizedCurve, false);
         showControl(m_chkStabilizeSensors, false);
         break;
     case 2:
         KisUsageLogger::log("Enabled weighted smoothing.");
         smoothingOptions()->setSmoothingType(KisSmoothingOptions::WEIGHTED_SMOOTHING);
         showControl(m_sliderSmoothnessDistance, true);
         showControl(m_sliderTailAggressiveness, true);
         showControl(m_chkSmoothPressure, true);
         showControl(m_chkUseScalableDistance, true);
         showControl(m_sliderDelayDistance, false);
         showControl(m_chkFinishStabilizedCurve, false);
         showControl(m_chkStabilizeSensors, false);
         break;
     case 3:
     default:
         KisUsageLogger::log("Enabled stabilizer.");
         smoothingOptions()->setSmoothingType(KisSmoothingOptions::STABILIZER);
         showControl(m_sliderSmoothnessDistance, true);
         showControl(m_sliderTailAggressiveness, false);
         showControl(m_chkSmoothPressure, false);
         showControl(m_chkUseScalableDistance, true);
         showControl(m_sliderDelayDistance, true);
         showControl(m_chkFinishStabilizedCurve, true);
         showControl(m_chkStabilizeSensors, true);
     }
 
     emit smoothingTypeChanged();
 }
 
 void KisToolBrush::slotSetSmoothnessDistance(qreal distance)
 {
     smoothingOptions()->setSmoothnessDistance(distance);
     emit smoothnessQualityChanged();
 }
 
 void KisToolBrush::slotSetTailAgressiveness(qreal argh_rhhrr)
 {
     smoothingOptions()->setTailAggressiveness(argh_rhhrr);
     emit smoothnessFactorChanged();
 }
 
 // used with weighted smoothing
 void KisToolBrush::setSmoothPressure(bool value)
 {
     smoothingOptions()->setSmoothPressure(value);
 }
 
 void KisToolBrush::slotSetMagnetism(int magnetism)
 {
     m_magnetism = expf(magnetism / (double)MAXIMUM_MAGNETISM) / expf(1.0);
 }
 
 bool KisToolBrush::useScalableDistance() const
 {
     return smoothingOptions()->useScalableDistance();
 }
 
 // used with weighted smoothing
 void KisToolBrush::setUseScalableDistance(bool value)
 {
     smoothingOptions()->setUseScalableDistance(value);
 
     emit useScalableDistanceChanged();
 }
 
 void KisToolBrush::resetCursorStyle()
 {
     KisConfig cfg(true);
     CursorStyle cursorStyle = cfg.newCursorStyle();
 
     // When the stabilizer is in use, we avoid using the brush outline cursor,
     // because it would hide the real position of the cursor to the user,
     // yielding unexpected results.
     if (smoothingOptions()->smoothingType() == KisSmoothingOptions::STABILIZER &&
             smoothingOptions()->useDelayDistance() &&
             cursorStyle == CURSOR_STYLE_NO_CURSOR) {
 
         useCursor(KisCursor::roundCursor());
     } else {
         KisToolFreehand::resetCursorStyle();
     }
 
     overrideCursorIfNotEditable();
 }
 
 // stabilizer brush settings
 bool KisToolBrush::useDelayDistance() const
 {
     return smoothingOptions()->useDelayDistance();
 }
 
 qreal KisToolBrush::delayDistance() const
 {
     return smoothingOptions()->delayDistance();
 }
 
 void KisToolBrush::setUseDelayDistance(bool value)
 {
     smoothingOptions()->setUseDelayDistance(value);
     m_sliderDelayDistance->setEnabled(value);
     enableControl(m_chkFinishStabilizedCurve, !value);
 
     emit useDelayDistanceChanged();
 }
 
 void KisToolBrush::setDelayDistance(qreal value)
 {
     smoothingOptions()->setDelayDistance(value);
     emit delayDistanceChanged();
 }
 
 void KisToolBrush::setFinishStabilizedCurve(bool value)
 {
     smoothingOptions()->setFinishStabilizedCurve(value);
 
     emit finishStabilizedCurveChanged();
 }
 
 bool KisToolBrush::finishStabilizedCurve() const
 {
     return smoothingOptions()->finishStabilizedCurve();
 }
 
 void KisToolBrush::setStabilizeSensors(bool value)
 {
     smoothingOptions()->setStabilizeSensors(value);
     emit stabilizeSensorsChanged();
 }
 
 bool KisToolBrush::stabilizeSensors() const
 {
     return smoothingOptions()->stabilizeSensors();
 }
 
 void KisToolBrush::updateSettingsViews()
 {
     m_cmbSmoothingType->setCurrentIndex(smoothingOptions()->smoothingType());
 
     m_sliderSmoothnessDistance->setValue(smoothingOptions()->smoothnessDistance());
     m_chkDelayDistance->setChecked(smoothingOptions()->useDelayDistance());
     m_sliderDelayDistance->setValue(smoothingOptions()->delayDistance());
     m_sliderTailAggressiveness->setValue(smoothingOptions()->tailAggressiveness());
     m_chkSmoothPressure->setChecked(smoothingOptions()->smoothPressure());
     m_chkUseScalableDistance->setChecked(smoothingOptions()->useScalableDistance());
     m_cmbSmoothingType->setCurrentIndex((int)smoothingOptions()->smoothingType());
     m_chkStabilizeSensors->setChecked(smoothingOptions()->stabilizeSensors());
 
     emit smoothnessQualityChanged();
     emit smoothnessFactorChanged();
     emit smoothPressureChanged();
     emit smoothingTypeChanged();
     emit useScalableDistanceChanged();
     emit useDelayDistanceChanged();
     emit delayDistanceChanged();
     emit finishStabilizedCurveChanged();
     emit stabilizeSensorsChanged();
 
     KisTool::updateSettingsViews();
 }
 
 QWidget * KisToolBrush::createOptionWidget()
 {
     QWidget *optionsWidget = KisToolFreehand::createOptionWidget();
     optionsWidget->setObjectName(toolId() + "option widget");
 
     // See https://bugs.kde.org/show_bug.cgi?id=316896
     QWidget *specialSpacer = new QWidget(optionsWidget);
     specialSpacer->setObjectName("SpecialSpacer");
     specialSpacer->setFixedSize(0, 0);
     optionsWidget->layout()->addWidget(specialSpacer);
 
     // Line smoothing configuration
     m_cmbSmoothingType = new QComboBox(optionsWidget);
     m_cmbSmoothingType->addItems(QStringList()
-                                 << i18n("None")
-                                 << i18n("Basic")
-                                 << i18n("Weighted")
-                                 << i18n("Stabilizer"));
+                                 << i18nc("@item:inlistbox Brush Smoothing", "None")
+                                 << i18nc("@item:inlistbox Brush Smoothing", "Basic")
+                                 << i18nc("@item:inlistbox Brush Smoothing", "Weighted")
+                                 << i18nc("@item:inlistbox Brush Smoothing", "Stabilizer"));
     connect(m_cmbSmoothingType, SIGNAL(currentIndexChanged(int)), this, SLOT(slotSetSmoothingType(int)));
     addOptionWidgetOption(m_cmbSmoothingType, new QLabel(i18n("Brush Smoothing:")));
 
     m_sliderSmoothnessDistance = new KisDoubleSliderSpinBox(optionsWidget);
     m_sliderSmoothnessDistance->setRange(3.0, MAXIMUM_SMOOTHNESS_DISTANCE, 1);
     m_sliderSmoothnessDistance->setExponentRatio(3.0); // help pick smaller values
 
 
     m_sliderSmoothnessDistance->setEnabled(true);
     connect(m_sliderSmoothnessDistance, SIGNAL(valueChanged(qreal)), SLOT(slotSetSmoothnessDistance(qreal)));
     m_sliderSmoothnessDistance->setValue(smoothingOptions()->smoothnessDistance());
     addOptionWidgetOption(m_sliderSmoothnessDistance, new QLabel(i18n("Distance:")));
 
     // Finish stabilizer curve
     m_chkFinishStabilizedCurve = new QCheckBox(optionsWidget);
     m_chkFinishStabilizedCurve->setMinimumHeight(qMax(m_sliderSmoothnessDistance->sizeHint().height()-3,
                                                       m_chkFinishStabilizedCurve->sizeHint().height()));
     connect(m_chkFinishStabilizedCurve, SIGNAL(toggled(bool)), this, SLOT(setFinishStabilizedCurve(bool)));
     m_chkFinishStabilizedCurve->setChecked(smoothingOptions()->finishStabilizedCurve());
 
     // Delay Distance for Stabilizer
     QWidget* delayWidget = new QWidget(optionsWidget);
     QHBoxLayout* delayLayout = new QHBoxLayout(delayWidget);
     delayLayout->setContentsMargins(0,0,0,0);
     delayLayout->setSpacing(1);
     QLabel* delayLabel = new QLabel(i18n("Delay:"), optionsWidget);
     delayLabel->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
     delayLayout->addWidget(delayLabel);
     m_chkDelayDistance = new QCheckBox(optionsWidget);
     m_chkDelayDistance->setLayoutDirection(Qt::RightToLeft);
     delayWidget->setToolTip(i18n("Delay the brush stroke to make the line smoother"));
     connect(m_chkDelayDistance, SIGNAL(toggled(bool)), this, SLOT(setUseDelayDistance(bool)));
     delayLayout->addWidget(m_chkDelayDistance);
     m_sliderDelayDistance = new KisDoubleSliderSpinBox(optionsWidget);
     m_sliderDelayDistance->setToolTip(i18n("Radius where the brush is blocked"));
     m_sliderDelayDistance->setRange(0, 500);
     m_sliderDelayDistance->setExponentRatio(3.0); // help pick smaller values
     m_sliderDelayDistance->setSuffix(i18n(" px"));
     connect(m_sliderDelayDistance, SIGNAL(valueChanged(qreal)), SLOT(setDelayDistance(qreal)));
 
     addOptionWidgetOption(m_sliderDelayDistance, delayWidget);
     addOptionWidgetOption(m_chkFinishStabilizedCurve, new QLabel(i18n("Finish line:")));
 
     m_sliderDelayDistance->setValue(smoothingOptions()->delayDistance());
     m_chkDelayDistance->setChecked(smoothingOptions()->useDelayDistance());
     // if the state is not flipped, then the previous line doesn't generate any signals
     setUseDelayDistance(m_chkDelayDistance->isChecked());
 
     // Stabilize sensors
     m_chkStabilizeSensors = new QCheckBox(optionsWidget);
     m_chkStabilizeSensors->setMinimumHeight(qMax(m_sliderSmoothnessDistance->sizeHint().height()-3,
                                                  m_chkStabilizeSensors->sizeHint().height()));
     connect(m_chkStabilizeSensors, SIGNAL(toggled(bool)), this, SLOT(setStabilizeSensors(bool)));
     m_chkStabilizeSensors->setChecked(smoothingOptions()->stabilizeSensors());
     addOptionWidgetOption(m_chkStabilizeSensors, new QLabel(i18n("Stabilize Sensors:")));
 
 
     m_sliderTailAggressiveness = new KisDoubleSliderSpinBox(optionsWidget);
     m_sliderTailAggressiveness->setRange(0.0, 1.0, 2);
     m_sliderTailAggressiveness->setEnabled(true);
     connect(m_sliderTailAggressiveness, SIGNAL(valueChanged(qreal)), SLOT(slotSetTailAgressiveness(qreal)));
     m_sliderTailAggressiveness->setValue(smoothingOptions()->tailAggressiveness());
     addOptionWidgetOption(m_sliderTailAggressiveness, new QLabel(i18n("Stroke Ending:")));
 
     m_chkSmoothPressure = new QCheckBox(optionsWidget);
     m_chkSmoothPressure->setMinimumHeight(qMax(m_sliderSmoothnessDistance->sizeHint().height()-3,
                                                m_chkSmoothPressure->sizeHint().height()));
     m_chkSmoothPressure->setChecked(smoothingOptions()->smoothPressure());
     connect(m_chkSmoothPressure, SIGNAL(toggled(bool)), this, SLOT(setSmoothPressure(bool)));
     addOptionWidgetOption(m_chkSmoothPressure, new QLabel(QString("%1:").arg(i18n("Smooth Pressure"))));
 
     m_chkUseScalableDistance = new QCheckBox(optionsWidget);
     m_chkUseScalableDistance->setChecked(smoothingOptions()->useScalableDistance());
     m_chkUseScalableDistance->setMinimumHeight(qMax(m_sliderSmoothnessDistance->sizeHint().height()-3,
                                                     m_chkUseScalableDistance->sizeHint().height()));
     m_chkUseScalableDistance->setToolTip(i18nc("@info:tooltip",
                                                "Scalable distance takes zoom level "
                                                "into account and makes the distance "
                                                "be visually constant whatever zoom "
                                                "level is chosen"));
     connect(m_chkUseScalableDistance, SIGNAL(toggled(bool)), this, SLOT(setUseScalableDistance(bool)));
     addOptionWidgetOption(m_chkUseScalableDistance, new QLabel(QString("%1:").arg(i18n("Scalable Distance"))));
 
 
     // add a line spacer so we know that the next set of options are for different settings
     QFrame* line = new QFrame(optionsWidget);
     line->setObjectName(QString::fromUtf8("line"));
     line->setFrameShape(QFrame::HLine);
     addOptionWidgetOption(line);
 
     // Drawing assistant configuration
     QWidget* assistantWidget = new QWidget(optionsWidget);
     QGridLayout* assistantLayout = new QGridLayout(assistantWidget);
     assistantLayout->setContentsMargins(10,0,0,0);
     assistantLayout->setSpacing(5);
 
     m_chkAssistant = new QCheckBox(optionsWidget);
     m_chkAssistant->setText(i18n("Snap to Assistants"));
 
     assistantWidget->setToolTip(i18n("You need to add Assistants before this tool will work."));
     connect(m_chkAssistant, SIGNAL(toggled(bool)), this, SLOT(setAssistant(bool)));
     addOptionWidgetOption(assistantWidget, m_chkAssistant);
 
     m_sliderMagnetism = new KisSliderSpinBox(optionsWidget);
     m_sliderMagnetism->setToolTip(i18n("Assistant Magnetism"));
     m_sliderMagnetism->setRange(0, MAXIMUM_MAGNETISM);
 
     m_sliderMagnetism->setValue(m_magnetism * MAXIMUM_MAGNETISM);
     connect(m_sliderMagnetism, SIGNAL(valueChanged(int)), SLOT(slotSetMagnetism(int)));
 
     QLabel* magnetismLabel = new QLabel(i18n("Magnetism:"));
     addOptionWidgetOption(m_sliderMagnetism, magnetismLabel);
 
     QLabel* snapSingleLabel = new QLabel(i18n("Snap Single:"));
 
     m_chkOnlyOneAssistant = new QCheckBox(optionsWidget);
     m_chkOnlyOneAssistant->setToolTip(i18nc("@info:tooltip","Make it only snap to a single assistant, prevents snapping mess while using the infinite assistants."));
     m_chkOnlyOneAssistant->setCheckState(Qt::Checked);//turn on by default.
     connect(m_chkOnlyOneAssistant, SIGNAL(toggled(bool)), this, SLOT(setOnlyOneAssistantSnap(bool)));
     addOptionWidgetOption(m_chkOnlyOneAssistant, snapSingleLabel);
 
     // set the assistant snapping options to hidden by default and toggle their visibility based based off snapping checkbox
     m_sliderMagnetism->setVisible(false);
     m_chkOnlyOneAssistant->setVisible(false);
     snapSingleLabel->setVisible(false);
     magnetismLabel->setVisible(false);
 
     connect(m_chkAssistant, SIGNAL(toggled(bool)), m_sliderMagnetism, SLOT(setVisible(bool)));
     connect(m_chkAssistant, SIGNAL(toggled(bool)), m_chkOnlyOneAssistant, SLOT(setVisible(bool)));
     connect(m_chkAssistant, SIGNAL(toggled(bool)), snapSingleLabel, SLOT(setVisible(bool)));
     connect(m_chkAssistant, SIGNAL(toggled(bool)), magnetismLabel, SLOT(setVisible(bool)));
 
 
     KisConfig cfg(true);
 
     slotSetSmoothingType(cfg.lineSmoothingType());
 
     return optionsWidget;
 }
 
 QList<QAction *> KisToolBrushFactory::createActionsImpl()
 {
     KisActionRegistry *actionRegistry = KisActionRegistry::instance();
 
     QList<QAction *> actions = KisToolPaintFactoryBase::createActionsImpl();
 
     actions << actionRegistry->makeQAction("set_no_brush_smoothing");
     actions << actionRegistry->makeQAction("set_simple_brush_smoothing");
     actions << actionRegistry->makeQAction("set_weighted_brush_smoothing");
     actions << actionRegistry->makeQAction("set_stabilizer_brush_smoothing");
     actions << actionRegistry->makeQAction("toggle_assistant");
 
     return actions;
 
 }
diff --git a/plugins/tools/basictools/kis_tool_colorpicker.cc b/plugins/tools/basictools/kis_tool_colorpicker.cc
index 5fedb3248f..b40dbfcef1 100644
--- a/plugins/tools/basictools/kis_tool_colorpicker.cc
+++ b/plugins/tools/basictools/kis_tool_colorpicker.cc
@@ -1,373 +1,373 @@
 /*
  *  Copyright (c) 1999 Matthias Elter <me@kde.org>
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2010 Lukáš Tvrdý <lukast.dev@gmail.com>
  *  Copyright (c) 2018 Emmet & Eoin O'Neill <emmetoneill.pdx@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_colorpicker.h"
 
 #include <boost/thread/locks.hpp>
 #include <QMessageBox>
 #include "kis_cursor.h"
 #include "KisDocument.h"
 #include "kis_canvas2.h"
 #include "KisReferenceImagesLayer.h"
 #include "KoCanvasBase.h"
 #include "kis_random_accessor_ng.h"
 #include "KoResourceServerProvider.h"
 #include <KoMixColorsOp.h>
 #include "kis_wrapped_rect.h"
 #include "kis_tool_utils.h"
 
 namespace
 {
 // GUI ComboBox index constants
 const int SAMPLE_MERGED = 0;
 }
 
 KisToolColorPicker::KisToolColorPicker(KoCanvasBase *canvas)
     : KisTool(canvas, KisCursor::pickerCursor()),
       m_config(new KisToolUtils::ColorPickerConfig)
 {
     setObjectName("tool_colorpicker");
     m_isActivated = false;
     m_optionsWidget = 0;
     m_pickedColor = KoColor();
 }
 
 KisToolColorPicker::~KisToolColorPicker()
 {
     if (m_isActivated) {
         m_config->save(m_toolActivationSource == KisTool::DefaultActivation);
     }
 }
 
 void KisToolColorPicker::paint(QPainter &gc, const KoViewConverter &converter)
 {
     Q_UNUSED(gc);
     Q_UNUSED(converter);
 }
 
 void KisToolColorPicker::activate(ToolActivation activation, const QSet<KoShape*> &shapes)
 {
     m_isActivated = true;
     m_toolActivationSource = activation;
     m_config->load(m_toolActivationSource == KisTool::DefaultActivation);
     updateOptionWidget();
 
     KisTool::activate(activation, shapes);
 }
 
 void KisToolColorPicker::deactivate()
 {
     m_config->save(m_toolActivationSource == KisTool::DefaultActivation);
     m_isActivated = false;
     KisTool::deactivate();
 }
 
 bool KisToolColorPicker::pickColor(const QPointF &pos)
 {
     // Timer check.
     if (m_colorPickerDelayTimer.isActive()) {
         return false;
     }
     else {
         m_colorPickerDelayTimer.setSingleShot(true);
         m_colorPickerDelayTimer.start(100);
     }
 
     QScopedPointer<boost::lock_guard<KisImage>> imageLocker;
 
     m_pickedColor.setOpacity(0.0);
 
     // Pick from reference images.
     if (m_optionsWidget->cmbSources->currentIndex() == SAMPLE_MERGED) {
         auto *kisCanvas = dynamic_cast<KisCanvas2 *>(canvas());
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(kisCanvas, false);
         KisSharedPtr<KisReferenceImagesLayer> referenceImageLayer =
             kisCanvas->imageView()->document()->referenceImagesLayer();
 
         if (referenceImageLayer && kisCanvas->referenceImagesDecoration()->visible()) {
             QColor color = referenceImageLayer->getPixel(pos);
             if (color.isValid()) {
                 m_pickedColor.fromQColor(color);
             }
         }
     }
 
     if (m_pickedColor.opacityU8() == OPACITY_TRANSPARENT_U8) {
         if (!currentImage()->bounds().contains(pos.toPoint()) &&
             !currentImage()->wrapAroundModePermitted()) {
             return false;
         }
 
         KisPaintDeviceSP dev;
 
         if (m_optionsWidget->cmbSources->currentIndex() != SAMPLE_MERGED &&
             currentNode() && currentNode()->colorPickSourceDevice()) {
             dev = currentNode()->colorPickSourceDevice();
         }
         else {
             imageLocker.reset(new boost::lock_guard<KisImage>(*currentImage()));
             dev = currentImage()->projection();
         }
 
         KoColor previousColor = canvas()->resourceManager()->foregroundColor();
 
         KisToolUtils::pickColor(m_pickedColor, dev, pos.toPoint(), &previousColor, m_config->radius, m_config->blend);
     }
 
     if (m_config->updateColor &&
         m_pickedColor.opacityU8() != OPACITY_TRANSPARENT_U8) {
 
         KoColor publicColor = m_pickedColor;
         publicColor.setOpacity(OPACITY_OPAQUE_U8); // Alpha is unwanted for FG and BG colors.
 
         if (m_config->toForegroundColor) {
             canvas()->resourceManager()->setResource(KoCanvasResourceProvider::ForegroundColor, publicColor);
         }
         else {
             canvas()->resourceManager()->setResource(KoCanvasResourceProvider::BackgroundColor, publicColor);
         }
     }
 
     return true;
 }
 
 void KisToolColorPicker::beginPrimaryAction(KoPointerEvent *event)
 {
     bool sampleMerged = m_optionsWidget->cmbSources->currentIndex() == SAMPLE_MERGED;
     if (!sampleMerged) {
         if (!currentNode()) {
             QMessageBox::information(0, i18nc("@title:window", "Krita"), i18n("Cannot pick a color as no layer is active."));
             event->ignore();
             return;
         }
         if (!currentNode()->visible()) {
             QMessageBox::information(0, i18nc("@title:window", "Krita"), i18n("Cannot pick a color as the active layer is not visible."));
             event->ignore();
             return;
         }
     }
 
     QPoint pos = convertToImagePixelCoordFloored(event);
 
     setMode(KisTool::PAINT_MODE);
 
     bool picked = pickColor(pos);
     if (!picked) {
         // Color picking has to start in the visible part of the layer
         event->ignore();
         return;
     }
 
     displayPickedColor();
 }
 
 void KisToolColorPicker::continuePrimaryAction(KoPointerEvent *event)
 {
     CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
 
     QPoint pos = convertToImagePixelCoordFloored(event);
     pickColor(pos);
     displayPickedColor();
 }
 
 #include "kis_canvas2.h"
 #include "kis_display_color_converter.h"
 
 void KisToolColorPicker::endPrimaryAction(KoPointerEvent *event)
 {
     Q_UNUSED(event);
     CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
 
     if (m_config->addPalette) {
         KisSwatch ent;
         ent.setColor(m_pickedColor);
         // We don't ask for a name, too intrusive here
 
         KoColorSet *palette = m_palettes.at(m_optionsWidget->cmbPalette->currentIndex());
         palette->add(ent);
 
         if (!palette->save()) {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Cannot write to palette file %1. Maybe it is read-only.", palette->filename()));
         }
     }
 
 }
 
 struct PickedChannel {
     QString name;
     QString valueText;
 };
 
 void KisToolColorPicker::displayPickedColor()
 {
     if (m_pickedColor.data() && m_optionsWidget) {
 
         QList<KoChannelInfo *> channels = m_pickedColor.colorSpace()->channels();
         m_optionsWidget->listViewChannels->clear();
 
         QVector<PickedChannel> pickedChannels;
         for (int i = 0; i < channels.count(); ++i) {
             pickedChannels.append(PickedChannel());
         }
 
         for (int i = 0; i < channels.count(); ++i) {
 
             PickedChannel pc;
             pc.name = channels[i]->name();
 
             if (m_config->normaliseValues) {
                 pc.valueText = m_pickedColor.colorSpace()->normalisedChannelValueText(m_pickedColor.data(), i);
             } else {
                 pc.valueText = m_pickedColor.colorSpace()->channelValueText(m_pickedColor.data(), i);
             }
 
             pickedChannels[channels[i]->displayPosition()] = pc;
 
         }
 
         Q_FOREACH (const PickedChannel &pc, pickedChannels) {
             QTreeWidgetItem *item = new QTreeWidgetItem(m_optionsWidget->listViewChannels);
             item->setText(0, pc.name);
             item->setText(1, pc.valueText);
         }
 
         KisCanvas2 *kritaCanvas = dynamic_cast<KisCanvas2*>(canvas());
         KoColor newColor = kritaCanvas->displayColorConverter()->applyDisplayFiltering(m_pickedColor, Float32BitsColorDepthID);
         QVector<float> values(4);
         newColor.colorSpace()->normalisedChannelsValue(newColor.data(), values);
 
         for (int i = 0; i < values.size(); i++) {
             QTreeWidgetItem *item = new QTreeWidgetItem(m_optionsWidget->listViewChannels);
             item->setText(0, QString("DisplayCh%1").arg(i));
             item->setText(1, QString::number(values[i]));
         }
     }
 }
 
 QWidget* KisToolColorPicker::createOptionWidget()
 {
     m_optionsWidget = new ColorPickerOptionsWidget(0);
     m_optionsWidget->setObjectName(toolId() + " option widget");
     m_optionsWidget->listViewChannels->setSortingEnabled(false);
 
     // 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);
 
     // Initialize blend KisSliderSpinBox
     m_optionsWidget->blend->setRange(0,100);
-    m_optionsWidget->blend->setSuffix("%");
+    m_optionsWidget->blend->setSuffix(i18n("%"));
 
     updateOptionWidget();
 
     connect(m_optionsWidget->cbUpdateCurrentColor, SIGNAL(toggled(bool)), SLOT(slotSetUpdateColor(bool)));
     connect(m_optionsWidget->cbNormaliseValues, SIGNAL(toggled(bool)), SLOT(slotSetNormaliseValues(bool)));
     connect(m_optionsWidget->cbPalette, SIGNAL(toggled(bool)),
             SLOT(slotSetAddPalette(bool)));
     connect(m_optionsWidget->radius, SIGNAL(valueChanged(int)),
             SLOT(slotChangeRadius(int)));
     connect(m_optionsWidget->blend, SIGNAL(valueChanged(int)),
             SLOT(slotChangeBlend(int)));
     connect(m_optionsWidget->cmbSources, SIGNAL(currentIndexChanged(int)),
             SLOT(slotSetColorSource(int)));
 
     KoResourceServer<KoColorSet> *srv = KoResourceServerProvider::instance()->paletteServer();
 
     if (!srv) {
         return m_optionsWidget;
     }
 
     QList<KoColorSet*> palettes = srv->resources();
 
     Q_FOREACH (KoColorSet *palette, palettes) {
         if (palette) {
             m_optionsWidget->cmbPalette->addSqueezedItem(palette->name());
             m_palettes.append(palette);
         }
     }
 
     return m_optionsWidget;
 }
 
 void KisToolColorPicker::updateOptionWidget()
 {
     if (!m_optionsWidget) return;
 
     m_optionsWidget->cbNormaliseValues->setChecked(m_config->normaliseValues);
     m_optionsWidget->cbUpdateCurrentColor->setChecked(m_config->updateColor);
     m_optionsWidget->cmbSources->setCurrentIndex(SAMPLE_MERGED + !m_config->sampleMerged);
     m_optionsWidget->cbPalette->setChecked(m_config->addPalette);
     m_optionsWidget->radius->setValue(m_config->radius);
     m_optionsWidget->blend->setValue(m_config->blend);
 }
 
 void KisToolColorPicker::setToForeground(bool newValue)
 {
     m_config->toForegroundColor = newValue;
     emit toForegroundChanged();
 }
 
 bool KisToolColorPicker::toForeground() const
 {
     return m_config->toForegroundColor;
 }
 
 void KisToolColorPicker::slotSetUpdateColor(bool state)
 {
     m_config->updateColor = state;
 }
 
 void KisToolColorPicker::slotSetNormaliseValues(bool state)
 {
     m_config->normaliseValues = state;
     displayPickedColor();
 }
 
 void KisToolColorPicker::slotSetAddPalette(bool state)
 {
     m_config->addPalette = state;
 }
 
 void KisToolColorPicker::slotChangeRadius(int value)
 {
     m_config->radius = value;
 }
 
 void KisToolColorPicker::slotChangeBlend(int value)
 {
     m_config->blend = value;
 }
 
 void KisToolColorPicker::slotSetColorSource(int value)
 {
     m_config->sampleMerged = value == SAMPLE_MERGED;
 }
 
 void KisToolColorPicker::slotAddPalette(KoResource *resource)
 {
     KoColorSet *palette = dynamic_cast<KoColorSet*>(resource);
     if (palette) {
         m_optionsWidget->cmbPalette->addSqueezedItem(palette->name());
         m_palettes.append(palette);
     }
 }
diff --git a/plugins/tools/basictools/kis_tool_move.cc b/plugins/tools/basictools/kis_tool_move.cc
index 3abda4d635..9e2747f23c 100644
--- a/plugins/tools/basictools/kis_tool_move.cc
+++ b/plugins/tools/basictools/kis_tool_move.cc
@@ -1,699 +1,714 @@
 /*
  *  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 { return new KisToolMoveState(*this); }
+    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 = dynamic_cast<KisCanvas2*>(canvas());
         kisCanvas->viewManager()->
             showFloatingMessage(
                 i18nc("floating message in move tool",
                       "X: %1 px, Y: %2 px",
-                      currentTopLeft.x(),
-                      currentTopLeft.y()),
+                      QLocale().toString(currentTopLeft.x()),
+                      QLocale().toString(currentTopLeft.y())),
                 QIcon(), 1000, KisFloatingMessage::High);
     }
 }
 
-bool KisToolMove::tryEndPreviousStroke(KisNodeList nodes)
+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()));
 
     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();
 
     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(KisNodeList nodes)
+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 d71ccaa9c2..d6271f06bb 100644
--- a/plugins/tools/basictools/kis_tool_move.h
+++ b/plugins/tools/basictools/kis_tool_move.h
@@ -1,205 +1,208 @@
 /*
  *  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(KisNodeList nodes);
+    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(KisNodeList nodes);
+    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;
+
+    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/basictools/wdgmovetool.ui b/plugins/tools/basictools/wdgmovetool.ui
index 4191e70a6c..b01666a2a4 100644
--- a/plugins/tools/basictools/wdgmovetool.ui
+++ b/plugins/tools/basictools/wdgmovetool.ui
@@ -1,342 +1,339 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgMoveTool</class>
  <widget class="QWidget" name="WdgMoveTool">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>245</width>
     <height>517</height>
    </rect>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
     <widget class="QGroupBox" name="grpSelectionMethod">
      <property name="minimumSize">
       <size>
        <width>221</width>
        <height>101</height>
       </size>
      </property>
      <property name="title">
       <string>Selection Mode</string>
      </property>
      <layout class="QGridLayout" name="gridLayout_2">
       <item row="0" column="0">
        <widget class="QRadioButton" name="radioSelectedLayer">
         <property name="toolTip">
          <string>Move the layer that you have currently selected in the layerbox with its masks. Shortcut: ctrl-click.</string>
         </property>
         <property name="text">
          <string>&amp;Move current layer</string>
         </property>
         <property name="checked">
          <bool>true</bool>
         </property>
        </widget>
       </item>
       <item row="1" column="0">
        <widget class="QRadioButton" name="radioFirstLayer">
         <property name="toolTip">
          <string>Move the first layer with visible content at the place where you click. This will also select that layer in the layerbox.</string>
         </property>
         <property name="text">
          <string>Mo&amp;ve layer with content</string>
         </property>
         <property name="checked">
          <bool>false</bool>
         </property>
        </widget>
       </item>
       <item row="2" column="0">
        <widget class="QRadioButton" name="radioGroup">
         <property name="toolTip">
          <string>Move the group containing the first layer that contains visible content. Shortcut: ctrl-shift-click.</string>
         </property>
         <property name="text">
          <string>Move &amp;the whole group</string>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="grpMoveStep">
      <property name="minimumSize">
       <size>
        <width>227</width>
        <height>91</height>
       </size>
      </property>
      <property name="title">
       <string>Move Shortcut</string>
      </property>
      <layout class="QGridLayout" name="gridLayout_3">
       <item row="2" column="1">
        <widget class="KisDoubleParseSpinBox" name="spinMoveScale">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="toolTip">
          <string>When holding shift, move keyboard shortcuts scale up by this amount.</string>
         </property>
         <property name="minimum">
          <double>1.000000000000000</double>
         </property>
         <property name="maximum">
          <double>1000.000000000000000</double>
         </property>
         <property name="value">
          <double>10.000000000000000</double>
         </property>
        </widget>
       </item>
       <item row="2" column="0">
        <widget class="QLabel" name="scaleLabel">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="text">
          <string>Multiplier:</string>
         </property>
        </widget>
       </item>
       <item row="1" column="1">
        <widget class="QComboBox" name="cmbUnit"/>
       </item>
       <item row="0" column="1">
        <widget class="KisDoubleParseSpinBox" name="spinMoveStep">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="toolTip">
-         <string>Number of pixels to move after move shortcut keypress.</string>
-        </property>
-        <property name="suffix">
-         <string> px</string>
+         <string>Number of units to move after move shortcut keypress.</string>
         </property>
         <property name="minimum">
          <double>1.000000000000000</double>
         </property>
         <property name="maximum">
          <double>100000.000000000000000</double>
         </property>
         <property name="value">
          <double>1.000000000000000</double>
         </property>
        </widget>
       </item>
       <item row="0" 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="text">
          <string>Amount:</string>
         </property>
        </widget>
       </item>
       <item row="1" 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="text">
          <string>Unit:</string>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="moveGroup">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="minimumSize">
       <size>
        <width>100</width>
        <height>101</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>5</number>
       </property>
       <property name="leftMargin">
        <number>5</number>
       </property>
       <property name="topMargin">
        <number>5</number>
       </property>
       <property name="bottomMargin">
        <number>0</number>
       </property>
       <item>
        <layout class="QFormLayout" name="formLayout_3">
         <property name="fieldGrowthPolicy">
          <enum>QFormLayout::AllNonFixedFieldsGrow</enum>
         </property>
         <property name="leftMargin">
          <number>5</number>
         </property>
         <property name="topMargin">
          <number>5</number>
         </property>
         <property name="rightMargin">
          <number>5</number>
         </property>
         <property name="bottomMargin">
          <number>5</number>
         </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>&amp;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="Preferred" 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="Preferred" 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>&amp;y:</string>
           </property>
           <property name="buddy">
            <cstring>translateYBox</cstring>
           </property>
          </widget>
         </item>
        </layout>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QCheckBox" name="chkShowCoordinates">
      <property name="toolTip">
       <string>Show coordinates on canvas</string>
      </property>
      <property name="text">
       <string>Show coordinates on canvas</string>
      </property>
     </widget>
    </item>
    <item>
     <widget class="QWidget" name="SpecialSpacer" native="true"/>
    </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>
  <customwidgets>
   <customwidget>
    <class>KisDoubleParseSpinBox</class>
    <extends>QDoubleSpinBox</extends>
    <header>kis_double_parse_spin_box.h</header>
   </customwidget>
   <customwidget>
    <class>KisIntParseSpinBox</class>
    <extends>QSpinBox</extends>
    <header>kis_int_parse_spin_box.h</header>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/plugins/tools/defaulttool/defaulttool/DefaultToolGeometryWidget.ui b/plugins/tools/defaulttool/defaulttool/DefaultToolGeometryWidget.ui
index 95b52f2098..4256246437 100644
--- a/plugins/tools/defaulttool/defaulttool/DefaultToolGeometryWidget.ui
+++ b/plugins/tools/defaulttool/defaulttool/DefaultToolGeometryWidget.ui
@@ -1,283 +1,283 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>DefaultToolGeometryWidget</class>
  <widget class="QWidget" name="DefaultToolGeometryWidget">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>182</width>
     <height>303</height>
    </rect>
   </property>
   <property name="focusPolicy">
    <enum>Qt::NoFocus</enum>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout_2">
    <item>
     <layout class="QGridLayout" name="gridLayout">
      <property name="spacing">
       <number>1</number>
      </property>
      <item row="0" column="0">
       <widget class="QLabel" name="label">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="text">
         <string>X:</string>
        </property>
       </widget>
      </item>
      <item row="0" column="1">
       <widget class="KisDoubleParseUnitSpinBox" name="positionXSpinBox">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="minimumSize">
         <size>
          <width>30</width>
          <height>0</height>
         </size>
        </property>
        <property name="minimum">
         <double>-10000.000000000000000</double>
        </property>
        <property name="maximum">
         <double>10000.000000000000000</double>
        </property>
       </widget>
      </item>
      <item row="0" column="2">
       <widget class="KisDoubleParseUnitSpinBox" name="widthSpinBox">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="minimumSize">
         <size>
          <width>30</width>
          <height>0</height>
         </size>
        </property>
        <property name="minimum">
         <double>-10000.000000000000000</double>
        </property>
        <property name="maximum">
         <double>10000.000000000000000</double>
        </property>
       </widget>
      </item>
      <item row="0" column="3" rowspan="2">
       <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="text" stdset="0">
         <string/>
        </property>
       </widget>
      </item>
      <item row="1" column="0">
       <widget class="QLabel" name="label_2">
        <property name="text">
         <string>Y:</string>
        </property>
       </widget>
      </item>
      <item row="1" column="1">
       <widget class="KisDoubleParseUnitSpinBox" name="positionYSpinBox">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="minimumSize">
         <size>
          <width>30</width>
          <height>0</height>
         </size>
        </property>
        <property name="minimum">
         <double>-10000.000000000000000</double>
        </property>
        <property name="maximum">
         <double>10000.000000000000000</double>
        </property>
       </widget>
      </item>
      <item row="1" column="2">
       <widget class="KisDoubleParseUnitSpinBox" name="heightSpinBox">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="minimumSize">
         <size>
          <width>30</width>
          <height>0</height>
         </size>
        </property>
        <property name="minimum">
         <double>-10000.000000000000000</double>
        </property>
        <property name="maximum">
         <double>10000.000000000000000</double>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item>
     <widget class="Line" name="line">
      <property name="orientation">
       <enum>Qt::Horizontal</enum>
      </property>
     </widget>
    </item>
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout" stretch="0,0,1">
      <property name="spacing">
       <number>1</number>
      </property>
      <item>
       <widget class="KoAnchorSelectionWidget" name="positionSelector" native="true">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
       </widget>
      </item>
      <item>
       <spacer name="horizontalSpacer">
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
        <property name="sizeType">
         <enum>QSizePolicy::MinimumExpanding</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>20</width>
          <height>20</height>
         </size>
        </property>
       </spacer>
      </item>
      <item>
       <layout class="QVBoxLayout" name="verticalLayout">
        <property name="spacing">
         <number>1</number>
        </property>
        <item>
         <widget class="QCheckBox" name="chkAnchorLock">
          <property name="text">
           <string>Anchor Lock</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QCheckBox" name="chkUniformScaling">
          <property name="toolTip">
-          <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;When &amp;quot;Uniform Scaling&amp;quot; is &lt;span style=&quot; font-weight:600;&quot;&gt;enabled&lt;/span&gt;, the shape's stroke is scaled with the shape itself. &lt;/p&gt;&lt;p&gt;In &lt;span style=&quot; font-weight:600;&quot;&gt;disabled&lt;/span&gt; state, the shape is only resized, keeping the stroke width and style intact.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+          <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;When &amp;quot;Scale Styles&amp;quot; is &lt;span style=&quot; font-weight:600;&quot;&gt;enabled&lt;/span&gt;, the shape's stroke is scaled with the shape itself.&lt;/p&gt;&lt;p&gt;In the &lt;span style=&quot; font-weight:600;&quot;&gt;disabled&lt;/span&gt; state, only the shape is resized, keeping the stroke width and style unaltered.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
          </property>
          <property name="text">
           <string>Scale Styles</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QCheckBox" name="chkGlobalCoordinates">
          <property name="minimumSize">
           <size>
            <width>50</width>
            <height>0</height>
           </size>
          </property>
          <property name="toolTip">
           <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;In &amp;quot;Global Coordinates&amp;quot; mode Width and Height fields show the size of the shape's bounding box in image-aligned coordinates, even when the shape is rotated or has any other transform. &lt;/p&gt;&lt;p&gt;If &amp;quot;Global Coordinates&amp;quot; mode is disabled, Width and Height fields show the shape's &amp;quot;local&amp;quot; size, before application of any transformations.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
          </property>
          <property name="text">
           <string>Global Coordinates</string>
          </property>
         </widget>
        </item>
       </layout>
      </item>
     </layout>
    </item>
    <item>
     <widget class="Line" name="line_2">
      <property name="orientation">
       <enum>Qt::Horizontal</enum>
      </property>
     </widget>
    </item>
    <item>
     <widget class="KisShapePropertySlider" name="dblOpacity" native="true"/>
    </item>
    <item>
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>1</height>
       </size>
      </property>
     </spacer>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KoAspectButton</class>
    <extends>QWidget</extends>
    <header>KoAspectButton.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>KisDoubleParseUnitSpinBox</class>
    <extends>QDoubleSpinBox</extends>
    <header>kis_double_parse_unit_spin_box.h</header>
   </customwidget>
   <customwidget>
    <class>KoAnchorSelectionWidget</class>
    <extends>QWidget</extends>
    <header>KoAnchorSelectionWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>KisShapePropertySlider</class>
    <extends>QWidget</extends>
    <header location="global">KisSelectionPropertySlider.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <tabstops>
   <tabstop>positionXSpinBox</tabstop>
   <tabstop>positionYSpinBox</tabstop>
   <tabstop>widthSpinBox</tabstop>
   <tabstop>heightSpinBox</tabstop>
  </tabstops>
  <resources/>
  <connections/>
 </ui>
diff --git a/plugins/tools/karbonplugins/tools/CalligraphyTool/KarbonCalligraphyOptionWidget.cpp b/plugins/tools/karbonplugins/tools/CalligraphyTool/KarbonCalligraphyOptionWidget.cpp
index 3c453a2110..4bf3971769 100644
--- a/plugins/tools/karbonplugins/tools/CalligraphyTool/KarbonCalligraphyOptionWidget.cpp
+++ b/plugins/tools/karbonplugins/tools/CalligraphyTool/KarbonCalligraphyOptionWidget.cpp
@@ -1,614 +1,614 @@
 /* This file is part of the KDE project
    Copyright (C) 2008 Fela Winkelmolen <fela.kde@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 "KarbonCalligraphyOptionWidget.h"
 
 #include <KoIcon.h>
 
 #include <klocalizedstring.h>
 #include <kcombobox.h>
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 #include <kconfig.h>
 #include <QDebug>
 #include <kmessagebox.h>
 
 #include <QInputDialog>
 #include <QSpinBox>
 #include <QCheckBox>
 #include <QDoubleSpinBox>
 #include <QLabel>
 #include <QGridLayout>
 #include <QToolButton>
 
 #include "kis_double_parse_spin_box.h"
 #include "kis_int_parse_spin_box.h"
 
 /*
 Profiles are saved in karboncalligraphyrc
 
 In the group "General", profile is the name of profile used
 
 Every profile is described in a group, the name of which is "ProfileN"
 Starting to count from 0 onwards
 (NOTE: the index in profiles is different from the N)
 
 Default profiles are added by the function addDefaultProfiles(), once they
 have been added, the entry defaultProfilesAdded in the "General" group is
 set to true
 
 TODO: add a reset defaults option?
 */
 
 // name of the configuration file
 const QString RCFILENAME = "karboncalligraphyrc";
 
 KarbonCalligraphyOptionWidget::KarbonCalligraphyOptionWidget()
     : m_changingProfile(false)
 {
     QGridLayout *layout = new QGridLayout(this);
     layout->setContentsMargins(0, 0, 0, 0);
 
     m_comboBox = new KComboBox(this);
     layout->addWidget(m_comboBox, 0, 0);
 
     m_saveButton = new QToolButton(this);
     m_saveButton->setToolTip(i18n("Save profile as..."));
     m_saveButton->setIcon(koIcon("document-save-as"));
     layout->addWidget(m_saveButton, 0, 1);
 
     m_removeButton = new QToolButton(this);
     m_removeButton->setToolTip(i18n("Remove profile"));
     m_removeButton->setIcon(koIcon("list-remove"));
     layout->addWidget(m_removeButton, 0, 2);
 
     QGridLayout *detailsLayout = new QGridLayout();
     detailsLayout->setContentsMargins(0, 0, 0, 0);
     detailsLayout->setVerticalSpacing(0);
 
     m_usePath = new QCheckBox(i18n("&Follow selected path"), this);
     detailsLayout->addWidget(m_usePath, 0, 0, 1, 4);
 
     m_usePressure = new QCheckBox(i18n("Use tablet &pressure"), this);
     detailsLayout->addWidget(m_usePressure, 1, 0, 1, 4);
 
     QLabel *widthLabel = new QLabel(i18n("Width:"), this);
     widthLabel->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
     m_widthBox = new KisDoubleParseSpinBox(this);
     m_widthBox->setRange(0.0, 999.0);
     widthLabel->setBuddy(m_widthBox);
     detailsLayout->addWidget(widthLabel, 2, 2);
     detailsLayout->addWidget(m_widthBox, 2, 3);
 
     QLabel *thinningLabel = new QLabel(i18n("Thinning:"), this);
     thinningLabel->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
     m_thinningBox = new KisDoubleParseSpinBox(this);
     m_thinningBox->setRange(-1.0, 1.0);
     m_thinningBox->setSingleStep(0.1);
     thinningLabel->setBuddy(m_thinningBox);
     detailsLayout->addWidget(thinningLabel, 2, 0);
     detailsLayout->addWidget(m_thinningBox, 2, 1);
 
     m_useAngle = new QCheckBox(i18n("Use tablet &angle"), this);
     detailsLayout->addWidget(m_useAngle, 3, 0, 1, 4);
 
     QLabel *angleLabel = new QLabel(i18n("Angle:"), this);
     angleLabel->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
     m_angleBox = new KisIntParseSpinBox(this);
     m_angleBox->setRange(0, 179);
     m_angleBox->setWrapping(true);
     angleLabel->setBuddy(m_angleBox);
     detailsLayout->addWidget(angleLabel, 4, 0);
     detailsLayout->addWidget(m_angleBox, 4, 1);
 
     QLabel *fixationLabel = new QLabel(i18n("Fixation:"), this);
     fixationLabel->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
     m_fixationBox = new KisDoubleParseSpinBox(this);
     m_fixationBox->setRange(0.0, 1.0);
     m_fixationBox->setSingleStep(0.1);
     fixationLabel->setBuddy(m_fixationBox);
     detailsLayout->addWidget(fixationLabel, 5, 0);
     detailsLayout->addWidget(m_fixationBox, 5, 1);
 
     QLabel *capsLabel = new QLabel(i18n("Caps:"), this);
     capsLabel->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
     m_capsBox = new KisDoubleParseSpinBox(this);
     m_capsBox->setRange(0.0, 2.0);
     m_capsBox->setSingleStep(0.03);
     capsLabel->setBuddy(m_capsBox);
     detailsLayout->addWidget(capsLabel, 5, 2);
     detailsLayout->addWidget(m_capsBox, 5, 3);
 
     QLabel *massLabel = new QLabel(i18n("Mass:"), this);
     massLabel->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
     m_massBox = new KisDoubleParseSpinBox(this);
     m_massBox->setRange(0.0, 20.0);
     m_massBox->setDecimals(1);
     massLabel->setBuddy(m_massBox);
     detailsLayout->addWidget(massLabel, 6, 0);
     detailsLayout->addWidget(m_massBox, 6, 1);
 
     QLabel *dragLabel = new QLabel(i18n("Drag:"), this);
     dragLabel->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
     m_dragBox = new KisDoubleParseSpinBox(this);
     m_dragBox->setRange(0.0, 1.0);
     m_dragBox->setSingleStep(0.1);
     dragLabel->setBuddy(m_dragBox);
     detailsLayout->addWidget(dragLabel, 6, 2);
     detailsLayout->addWidget(m_dragBox, 6, 3);
 
     layout->addLayout(detailsLayout, 1, 0, 1, 3);
     layout->setRowStretch(2, 1);
 
     createConnections();
     addDefaultProfiles(); // if they are already added does nothing
     loadProfiles();
 }
 
 KarbonCalligraphyOptionWidget::~KarbonCalligraphyOptionWidget()
 {
     qDeleteAll(m_profiles);
 }
 
 void KarbonCalligraphyOptionWidget::emitAll()
 {
     emit usePathChanged(m_usePath->isChecked());
     emit usePressureChanged(m_usePressure->isChecked());
     emit useAngleChanged(m_useAngle->isChecked());
     emit widthChanged(m_widthBox->value());
     emit thinningChanged(m_thinningBox->value());
     emit angleChanged(m_angleBox->value());
     emit fixationChanged(m_fixationBox->value());
     emit capsChanged(m_capsBox->value());
     emit massChanged(m_massBox->value());
     emit dragChanged(m_dragBox->value());
 }
 
 void KarbonCalligraphyOptionWidget::loadProfile(const QString &name)
 {
     if (m_changingProfile) {
         return;
     }
     // write the new profile in the config file
     KConfig config(RCFILENAME);
     KConfigGroup generalGroup(&config, "General");
     generalGroup.writeEntry("profile", name);
     config.sync();
 
     // and load it
     loadCurrentProfile();
 
     // don't show Current if it isn't selected
     if (name != i18n("Current")) {
         removeProfile(i18n("Current"));
     }
 }
 
 void KarbonCalligraphyOptionWidget::updateCurrentProfile()
 {
     if (!m_changingProfile) {
-        saveProfile("Current");
+        saveProfile(i18n("Current"));
     }
 }
 
 void KarbonCalligraphyOptionWidget::saveProfileAs()
 {
     QString name;
 
     // loop until a valid name is entered or the user cancelled
     while (1) {
         bool ok;
         name = QInputDialog::getText(this,
                                      i18n("Profile name"),
                                      i18n("Please insert the name by which "
                                           "you want to save this profile:"),
                                      QLineEdit::Normal, QString(), &ok);
         if (!ok) {
             return;
         }
 
         if (name.isEmpty() || name == i18n("Current")) {
             KMessageBox::sorry(this,
                                i18n("Sorry, the name you entered is invalid."),
                                i18nc("invalid profile name", "Invalid name."));
             // try again
             saveProfileAs();
             continue; // ask again
         }
 
         if (m_profiles.contains(name)) {
             int ret = KMessageBox::warningYesNo(this,
                                                 i18n("A profile with that name already exists.\n"
                                                         "Do you want to overwrite it?"));
 
             if (ret == KMessageBox::Yes) {
                 break;    // exit while loop (save profile)
             }
             // else ask again
         } else {
             // the name is valid
             break; // exit while loop (save profile)
         }
     }
 
     saveProfile(name);
 }
 
 void KarbonCalligraphyOptionWidget::removeProfile()
 {
     removeProfile(m_comboBox->currentText());
 }
 
 void KarbonCalligraphyOptionWidget::toggleUseAngle(bool checked)
 {
     m_angleBox->setEnabled(! checked);
 }
 
 void KarbonCalligraphyOptionWidget::increaseWidth()
 {
     m_widthBox->setValue(m_widthBox->value() + 1);
 }
 
 void KarbonCalligraphyOptionWidget::decreaseWidth()
 {
     m_widthBox->setValue(m_widthBox->value() - 1);
 }
 
 void KarbonCalligraphyOptionWidget::increaseAngle()
 {
     m_angleBox->setValue((m_angleBox->value() + 3) % 180);
 }
 
 void KarbonCalligraphyOptionWidget::decreaseAngle()
 {
     m_angleBox->setValue((m_angleBox->value() - 3) % 180);
 }
 
 /******************************************************************************
  ************************* Convenience Functions ******************************
  ******************************************************************************/
 
 void KarbonCalligraphyOptionWidget::createConnections()
 {
     connect(m_comboBox, SIGNAL(currentIndexChanged(QString)),
             SLOT(loadProfile(QString)));
 
     // propagate changes
     connect(m_usePath, SIGNAL(toggled(bool)),
             SIGNAL(usePathChanged(bool)));
 
     connect(m_usePressure, SIGNAL(toggled(bool)),
             SIGNAL(usePressureChanged(bool)));
 
     connect(m_useAngle, SIGNAL(toggled(bool)),
             SIGNAL(useAngleChanged(bool)));
 
     connect(m_widthBox, SIGNAL(valueChanged(double)),
             SIGNAL(widthChanged(double)));
 
     connect(m_thinningBox, SIGNAL(valueChanged(double)),
             SIGNAL(thinningChanged(double)));
 
     connect(m_angleBox, SIGNAL(valueChanged(int)),
             SIGNAL(angleChanged(int)));
 
     connect(m_fixationBox, SIGNAL(valueChanged(double)),
             SIGNAL(fixationChanged(double)));
 
     connect(m_capsBox, SIGNAL(valueChanged(double)),
             SIGNAL(capsChanged(double)));
 
     connect(m_massBox, SIGNAL(valueChanged(double)),
             SIGNAL(massChanged(double)));
 
     connect(m_dragBox, SIGNAL(valueChanged(double)),
             SIGNAL(dragChanged(double)));
 
     // update profile
     connect(m_usePath, SIGNAL(toggled(bool)),
             SLOT(updateCurrentProfile()));
 
     connect(m_usePressure, SIGNAL(toggled(bool)),
             SLOT(updateCurrentProfile()));
 
     connect(m_useAngle, SIGNAL(toggled(bool)),
             SLOT(updateCurrentProfile()));
 
     connect(m_widthBox, SIGNAL(valueChanged(double)),
             SLOT(updateCurrentProfile()));
 
     connect(m_thinningBox, SIGNAL(valueChanged(double)),
             SLOT(updateCurrentProfile()));
 
     connect(m_angleBox, SIGNAL(valueChanged(int)),
             SLOT(updateCurrentProfile()));
 
     connect(m_fixationBox, SIGNAL(valueChanged(double)),
             SLOT(updateCurrentProfile()));
 
     connect(m_capsBox, SIGNAL(valueChanged(double)),
             SLOT(updateCurrentProfile()));
 
     connect(m_massBox, SIGNAL(valueChanged(double)),
             SLOT(updateCurrentProfile()));
 
     connect(m_dragBox, SIGNAL(valueChanged(double)),
             SLOT(updateCurrentProfile()));
 
     connect(m_saveButton, SIGNAL(clicked()), SLOT(saveProfileAs()));
     connect(m_removeButton, SIGNAL(clicked()), SLOT(removeProfile()));
 
     // visualization
     connect(m_useAngle, SIGNAL(toggled(bool)), SLOT(toggleUseAngle(bool)));
 }
 
 void KarbonCalligraphyOptionWidget::addDefaultProfiles()
 {
     // check if the profiles where already added
     KConfig config(RCFILENAME);
     KConfigGroup generalGroup(&config, "General");
 
     if (generalGroup.readEntry("defaultProfilesAdded", false)) {
         return;
     }
 
     KConfigGroup profile0(&config, "Profile0");
     profile0.writeEntry("name", i18n("Mouse"));
     profile0.writeEntry("usePath", false);
     profile0.writeEntry("usePressure", false);
     profile0.writeEntry("useAngle", false);
     profile0.writeEntry("width", 30.0);
     profile0.writeEntry("thinning", 0.2);
     profile0.writeEntry("angle", 30);
     profile0.writeEntry("fixation", 1.0);
     profile0.writeEntry("caps", 0.0);
     profile0.writeEntry("mass", 3.0);
     profile0.writeEntry("drag", 0.7);
 
     KConfigGroup profile1(&config, "Profile1");
     profile1.writeEntry("name", i18n("Graphics Pen"));
     profile1.writeEntry("width", 50.0);
     profile1.writeEntry("usePath", false);
     profile1.writeEntry("usePressure", false);
     profile1.writeEntry("useAngle", false);
     profile1.writeEntry("thinning", 0.2);
     profile1.writeEntry("angle", 30);
     profile1.writeEntry("fixation", 1.0);
     profile1.writeEntry("caps", 0.0);
     profile1.writeEntry("mass", 1.0);
     profile1.writeEntry("drag", 0.9);
 
     generalGroup.writeEntry("profile", i18n("Mouse"));
     generalGroup.writeEntry("defaultProfilesAdded", true);
 
     config.sync();
 }
 
 void KarbonCalligraphyOptionWidget::loadProfiles()
 {
     KConfig config(RCFILENAME);
 
     // load profiles as long as they are present
     int i = 0;
     while (1) { // forever
         KConfigGroup profileGroup(&config, "Profile" + QString::number(i));
         // invalid profile, assume we reached the last one
         if (!profileGroup.hasKey("name")) {
             break;
         }
 
         Profile *profile = new Profile;
         profile->index = i;
         profile->name =         profileGroup.readEntry("name", QString());
         profile->usePath =      profileGroup.readEntry("usePath", false);
         profile->usePressure =  profileGroup.readEntry("usePressure", false);
         profile->useAngle =     profileGroup.readEntry("useAngle", false);
         profile->width =        profileGroup.readEntry("width", 30.0);
         profile->thinning =     profileGroup.readEntry("thinning", 0.2);
         profile->angle =        profileGroup.readEntry("angle", 30);
         profile->fixation =     profileGroup.readEntry("fixation", 0.0);
         profile->caps =         profileGroup.readEntry("caps", 0.0);
         profile->mass =         profileGroup.readEntry("mass", 3.0);
         profile->drag =         profileGroup.readEntry("drag", 0.7);
 
         m_profiles.insert(profile->name, profile);
         ++i;
     }
 
     m_changingProfile = true;
     ProfileMap::const_iterator it = m_profiles.constBegin();
     ProfileMap::const_iterator lastIt = m_profiles.constEnd();
     for (; it != lastIt; ++it) {
         m_comboBox->addItem(it.key());
     }
     m_changingProfile = false;
 
     loadCurrentProfile();
 }
 
 void KarbonCalligraphyOptionWidget::loadCurrentProfile()
 {
     KConfig config(RCFILENAME);
     KConfigGroup generalGroup(&config, "General");
     QString currentProfile = generalGroup.readEntry("profile", QString());
     // find the index needed by the comboBox
     int index = profilePosition(currentProfile);
 
     if (currentProfile.isEmpty() || index < 0) {
         return;
     }
 
     m_comboBox->setCurrentIndex(index);
 
     Profile *profile = m_profiles[currentProfile];
 
     m_changingProfile = true;
     m_usePath->setChecked(profile->usePath);
     m_usePressure->setChecked(profile->usePressure);
     m_useAngle->setChecked(profile->useAngle);
     m_widthBox->setValue(profile->width);
     m_thinningBox->setValue(profile->thinning);
     m_angleBox->setValue(profile->angle);
     m_fixationBox->setValue(profile->fixation);
     m_capsBox->setValue(profile->caps);
     m_massBox->setValue(profile->mass);
     m_dragBox->setValue(profile->drag);
     m_changingProfile = false;
 }
 
 void KarbonCalligraphyOptionWidget::saveProfile(const QString &name)
 {
     Profile *profile = new Profile;
     profile->name = name;
     profile->usePath = m_usePath->isChecked();
     profile->usePressure = m_usePressure->isChecked();
     profile->useAngle = m_useAngle->isChecked();
     profile->width = m_widthBox->value();
     profile->thinning = m_thinningBox->value();
     profile->angle = m_angleBox->value();
     profile->fixation = m_fixationBox->value();
     profile->caps = m_capsBox->value();
     profile->mass = m_massBox->value();
     profile->drag = m_dragBox->value();
 
     if (m_profiles.contains(name)) {
         // there is already a profile with the same name, overwrite
         profile->index = m_profiles[name]->index;
         m_profiles.insert(name, profile);
     } else {
         // it is a new profile
         profile->index = m_profiles.count();
         m_profiles.insert(name, profile);
         // add the profile to the combobox
         QString dbg;
         for (int i = 0; i < m_comboBox->count(); ++i) {
             dbg += m_comboBox->itemText(i) + ' ';
         }
         int pos = profilePosition(name);
         m_changingProfile = true;
         m_comboBox->insertItem(pos, name);
         m_changingProfile = false;
         for (int i = 0; i < m_comboBox->count(); ++i) {
             dbg += m_comboBox->itemText(i) + ' ';
         }
     }
 
     KConfig config(RCFILENAME);
     QString str = "Profile" + QString::number(profile->index);
     KConfigGroup profileGroup(&config, str);
 
     profileGroup.writeEntry("name", name);
     profileGroup.writeEntry("usePath", profile->usePath);
     profileGroup.writeEntry("usePressure", profile->usePressure);
     profileGroup.writeEntry("useAngle", profile->useAngle);
     profileGroup.writeEntry("width", profile->width);
     profileGroup.writeEntry("thinning", profile->thinning);
     profileGroup.writeEntry("angle", profile->angle);
     profileGroup.writeEntry("fixation", profile->fixation);
     profileGroup.writeEntry("caps", profile->caps);
     profileGroup.writeEntry("mass", profile->mass);
     profileGroup.writeEntry("drag", profile->drag);
 
     KConfigGroup generalGroup(&config, "General");
     generalGroup.writeEntry("profile", name);
 
     config.sync();
 
     m_comboBox->setCurrentIndex(profilePosition(name));
 }
 
 void KarbonCalligraphyOptionWidget::removeProfile(const QString &name)
 {
     int index = profilePosition(name);
     if (index < 0) {
         return;    // no such profile
     }
 
     // remove the file from the config file
     KConfig config(RCFILENAME);
     int deletedIndex = m_profiles[name]->index;
     QString deletedGroup = "Profile" + QString::number(deletedIndex);
     config.deleteGroup(deletedGroup);
     config.sync();
 
     // and from profiles
     m_profiles.remove(name);
 
     m_comboBox->removeItem(index);
 
     // now in the config file there is value ProfileN missing,
     // where N = configIndex, so put the last one there
     if (m_profiles.isEmpty()) {
         return;
     }
 
     int lastN = -1;
     Profile *profile = 0; // profile to be moved, will be the last one
     Q_FOREACH (Profile *p, m_profiles) {
         if (p->index > lastN) {
             lastN = p->index;
             profile = p;
         }
     }
 
     Q_ASSERT(profile != 0);
 
     // do nothing if the deleted group was the last one
     if (deletedIndex > lastN) {
         return;
     }
 
     QString lastGroup = "Profile" + QString::number(lastN);
     config.deleteGroup(lastGroup);
 
     KConfigGroup profileGroup(&config, deletedGroup);
     profileGroup.writeEntry("name", profile->name);
     profileGroup.writeEntry("usePath", profile->usePath);
     profileGroup.writeEntry("usePressure", profile->usePressure);
     profileGroup.writeEntry("useAngle", profile->useAngle);
     profileGroup.writeEntry("width", profile->width);
     profileGroup.writeEntry("thinning", profile->thinning);
     profileGroup.writeEntry("angle", profile->angle);
     profileGroup.writeEntry("fixation", profile->fixation);
     profileGroup.writeEntry("caps", profile->caps);
     profileGroup.writeEntry("mass", profile->mass);
     profileGroup.writeEntry("drag", profile->drag);
     config.sync();
 
     profile->index = deletedIndex;
 }
 
 int KarbonCalligraphyOptionWidget::profilePosition(const QString &profileName)
 {
     int res = 0;
     ProfileMap::const_iterator it = m_profiles.constBegin();
     ProfileMap::const_iterator lastIt = m_profiles.constEnd();
     for (; it != lastIt; ++it) {
         if (it.key() == profileName) {
             return res;
         }
         ++res;
     }
     return -1;
 }
 
 void KarbonCalligraphyOptionWidget::setUsePathEnabled(bool enabled)
 {
     m_usePath->setEnabled(enabled);
 }
diff --git a/plugins/tools/karbonplugins/tools/filterEffectTool/KarbonFilterEffectsTool.cpp b/plugins/tools/karbonplugins/tools/filterEffectTool/KarbonFilterEffectsTool.cpp
index 5a92a591e0..963deb1b06 100644
--- a/plugins/tools/karbonplugins/tools/filterEffectTool/KarbonFilterEffectsTool.cpp
+++ b/plugins/tools/karbonplugins/tools/filterEffectTool/KarbonFilterEffectsTool.cpp
@@ -1,554 +1,554 @@
 /* This file is part of the KDE project
  * Copyright (c) 2009-2011 Jan Hambrecht <jaham@gmx.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "KarbonFilterEffectsTool.h"
 
 #include "KoFilterEffect.h"
 #include "KoFilterEffectStack.h"
 #include "KoFilterEffectFactoryBase.h"
 #include "KoFilterEffectRegistry.h"
 #include "KoFilterEffectConfigWidgetBase.h"
 #include "KoCanvasBase.h"
 #include "KoDocumentResourceManager.h"
 #include "KoSelectedShapesProxy.h"
 #include "KoViewConverter.h"
 #include "KoSelection.h"
 #include "FilterEffectEditWidget.h"
 #include "FilterEffectResource.h"
 #include "FilterResourceServerProvider.h"
 #include "FilterStackSetCommand.h"
 #include "FilterRegionChangeCommand.h"
 #include "FilterRegionEditStrategy.h"
 #include "KoResourceServerAdapter.h"
 #include "KoResourceSelector.h"
 #include <KoPointerEvent.h>
 
 #include <KoIcon.h>
 
 #include <kcombobox.h>
 #include <klocalizedstring.h>
 #include <QDialog>
 #include <QSpinBox>
 
 #include <QWidget>
 #include <QGridLayout>
 #include <QToolButton>
 #include <QStackedWidget>
 #include <QLabel>
 #include <QDialogButtonBox>
 #include <QPushButton>
 #include <QVBoxLayout>
 
 #include "kis_double_parse_spin_box.h"
 
 class KarbonFilterEffectsTool::Private
 {
 public:
     Private()
         : filterSelector(0)
         , configSelector(0)
         , configStack(0)
         , posX(0)
         , posY(0)
         , posW(0)
         , posH(0)
         , clearButton(0)
         , currentEffect(0)
         , currentPanel(0)
         , currentShape(0)
     {
     }
 
     void fillConfigSelector(KoShape *shape, KarbonFilterEffectsTool *tool)
     {
         if (!configSelector) {
             return;
         }
 
         configSelector->clear();
         clearButton->setEnabled(false);
 
         if (!shape || !shape->filterEffectStack()) {
             addWidgetForEffect(0, tool);
             return;
         }
 
         configSelector->blockSignals(true);
 
         int index = 0;
         Q_FOREACH (KoFilterEffect *effect, shape->filterEffectStack()->filterEffects()) {
             configSelector->addItem(QString("%1 - ").arg(index) + effect->name());
             index++;
         }
 
         configSelector->blockSignals(false);
 
         KoFilterEffect *effect = index > 0 ? shape->filterEffectStack()->filterEffects().first() : 0;
 
         addWidgetForEffect(effect, tool);
         clearButton->setEnabled(shape->filterEffectStack() != 0);
     }
 
     void addWidgetForEffect(KoFilterEffect *filterEffect, KarbonFilterEffectsTool *tool)
     {
         // remove current widget if new effect is zero or effect type has changed
         if (!filterEffect || (currentEffect && filterEffect->id() != currentEffect->id())) {
             while (configStack->count()) {
                 configStack->removeWidget(configStack->widget(0));
             }
         }
 
         if (!filterEffect) {
             currentEffect = 0;
             currentPanel = 0;
         } else if (!currentEffect || currentEffect->id() != filterEffect->id()) {
             // when a effect is set and is differs from the previous one
             // get the config widget and insert it into the option widget
             currentEffect = filterEffect;
 
             KoFilterEffectRegistry *registry = KoFilterEffectRegistry::instance();
             KoFilterEffectFactoryBase *factory = registry->value(currentEffect->id());
             if (!factory) {
                 return;
             }
 
             currentPanel = factory->createConfigWidget();
             if (!currentPanel) {
                 return;
             }
 
             currentPanel->layout()->setContentsMargins(0, 0, 0, 0);
             configStack->insertWidget(0, currentPanel);
             configStack->layout()->setContentsMargins(0, 0, 0, 0);
             connect(currentPanel, SIGNAL(filterChanged()), tool, SLOT(filterChanged()));
         }
 
         if (currentPanel) {
             currentPanel->editFilterEffect(filterEffect);
         }
 
         updateFilterRegion();
     }
 
     void updateFilterRegion()
     {
         QRectF region = currentEffect ? currentEffect->filterRect() : QRectF(0, 0, 0, 0);
 
         posX->blockSignals(true);
         posX->setValue(100.0 * region.x());
         posX->blockSignals(false);
         posX->setEnabled(currentEffect != 0);
         posY->blockSignals(true);
         posY->setValue(100.0 * region.y());
         posY->blockSignals(false);
         posY->setEnabled(currentEffect != 0);
         posW->blockSignals(true);
         posW->setValue(100.0 * region.width());
         posW->blockSignals(false);
         posW->setEnabled(currentEffect != 0);
         posH->blockSignals(true);
         posH->setValue(100.0 * region.height());
         posH->blockSignals(false);
         posH->setEnabled(currentEffect != 0);
     }
 
     EditMode editModeFromMousePosition(const QPointF &mousePosition, KarbonFilterEffectsTool *tool)
     {
         if (currentShape && currentShape->filterEffectStack() && currentEffect) {
             // get the size rect of the shape
             QRectF sizeRect(QPointF(), currentShape->size());
             // get the filter rectangle in shape coordinates
             QRectF filterRect = currentEffect->filterRectForBoundingRect(sizeRect);
             // get the transformation from document to shape coordinates
             QTransform transform = currentShape->absoluteTransformation(0).inverted();
             // adjust filter rectangle by grab sensitivity
             const int grabDistance = tool->grabSensitivity();
             QPointF border = tool->canvas()->viewConverter()->viewToDocument(QPointF(grabDistance, grabDistance));
             filterRect.adjust(-border.x(), -border.y(), border.x(), border.y());
             // map event point from document to shape coordinates
             QPointF shapePoint = transform.map(mousePosition);
             // check if the mouse is inside/near our filter rect
             if (filterRect.contains(shapePoint)) {
                 if (qAbs(shapePoint.x() - filterRect.left()) <= border.x()) {
                     return MoveLeft;
                 } else if (qAbs(shapePoint.x() - filterRect.right()) <= border.x()) {
                     return MoveRight;
                 } else if (qAbs(shapePoint.y() - filterRect.top()) <= border.y()) {
                     return MoveTop;
                 } else if (qAbs(shapePoint.y() - filterRect.bottom()) <= border.y()) {
                     return MoveBottom;
                 } else {
                     return MoveAll;
                 }
             } else {
                 return None;
             }
         }
         return None;
     }
 
     KoResourceSelector *filterSelector;
     KComboBox *configSelector;
     QStackedWidget *configStack;
     QDoubleSpinBox *posX;
     QDoubleSpinBox *posY;
     QDoubleSpinBox *posW;
     QDoubleSpinBox *posH;
     QToolButton *clearButton;
     KoFilterEffect *currentEffect;
     KoFilterEffectConfigWidgetBase *currentPanel;
     KoShape *currentShape;
 };
 
 KarbonFilterEffectsTool::KarbonFilterEffectsTool(KoCanvasBase *canvas)
     : KoInteractionTool(canvas)
     , d(new Private())
 {
     connect(canvas->selectedShapesProxy(), SIGNAL(selectionChanged()),
             this, SLOT(selectionChanged()));
     connect(canvas->selectedShapesProxy(), SIGNAL(selectionContentChanged()),
             this, SLOT(selectionChanged()));
 }
 
 KarbonFilterEffectsTool::~KarbonFilterEffectsTool()
 {
     delete d;
 }
 
 void KarbonFilterEffectsTool::paint(QPainter &painter, const KoViewConverter &converter)
 {
     if (d->currentShape && d->currentShape->filterEffectStack()) {
         painter.save();
         // apply the shape transformation
         QTransform transform = d->currentShape->absoluteTransformation(&converter);
         painter.setTransform(transform, true);
         // apply the zoom transformation
         KoShape::applyConversion(painter, converter);
         // get the size rect of the shape
         QRectF sizeRect(QPointF(), d->currentShape->size());
         // get the clipping rect of the filter stack
         KoFilterEffectStack *filterStack = d->currentShape->filterEffectStack();
         QRectF clipRect = filterStack->clipRectForBoundingRect(sizeRect);
         // finally paint the clipping rect
         painter.setBrush(Qt::NoBrush);
         painter.setPen(Qt::blue);
         painter.drawRect(clipRect);
 
         if (currentStrategy()) {
             currentStrategy()->paint(painter, converter);
         } else if (d->currentEffect) {
             QRectF filterRect = d->currentEffect->filterRectForBoundingRect(sizeRect);
             // paint the filter subregion rect
             painter.setBrush(Qt::NoBrush);
             painter.setPen(Qt::red);
             painter.drawRect(filterRect);
         }
 
         painter.restore();
     }
 }
 
 void KarbonFilterEffectsTool::repaintDecorations()
 {
     if (d->currentShape && d->currentShape->filterEffectStack()) {
         QRectF bb = d->currentShape->boundingRect();
         const int radius = handleRadius();
         canvas()->updateCanvas(bb.adjusted(-radius, -radius, radius, radius));
     }
 }
 
 void KarbonFilterEffectsTool::activate(ToolActivation toolActivation, const QSet<KoShape *> &shapes)
 {
     Q_UNUSED(toolActivation);
     if (shapes.isEmpty()) {
         emit done();
         return;
     }
 
     d->currentShape = canvas()->selectedShapesProxy()->selection()->firstSelectedShape();
     d->fillConfigSelector(d->currentShape, this);
 }
 
 void KarbonFilterEffectsTool::mouseMoveEvent(KoPointerEvent *event)
 {
     if (currentStrategy()) {
         KoInteractionTool::mouseMoveEvent(event);
     } else {
         EditMode mode = d->editModeFromMousePosition(event->point, this);
         switch (mode) {
         case MoveAll:
             useCursor(Qt::SizeAllCursor);
             break;
         case MoveLeft:
         case MoveRight:
             useCursor(Qt::SizeHorCursor);
             break;
         case MoveTop:
         case MoveBottom:
             useCursor(Qt::SizeVerCursor);
             break;
         case None:
             useCursor(Qt::ArrowCursor);
             break;
         }
     }
 }
 
 KoInteractionStrategy *KarbonFilterEffectsTool::createStrategy(KoPointerEvent *event)
 {
     EditMode mode = d->editModeFromMousePosition(event->point, this);
     if (mode == None) {
         return 0;
     }
 
     return new FilterRegionEditStrategy(this, d->currentShape, d->currentEffect, mode);
 }
 
 void KarbonFilterEffectsTool::presetSelected(KoResource *resource)
 {
     if (!d->currentShape) {
         return;
     }
 
     FilterEffectResource *effectResource = dynamic_cast<FilterEffectResource *>(resource);
     if (!effectResource) {
         return;
     }
 
     KoFilterEffectStack *filterStack = effectResource->toFilterStack();
     if (!filterStack) {
         return;
     }
 
     canvas()->addCommand(new FilterStackSetCommand(filterStack, d->currentShape));
     d->fillConfigSelector(d->currentShape, this);
 }
 
 void KarbonFilterEffectsTool::editFilter()
 {
     QPointer<QDialog> dlg = new QDialog();
     dlg->setWindowTitle(i18n("Filter Effect Editor"));
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Close);
     QWidget *mainWidget = new QWidget(0);
     QVBoxLayout *mainLayout = new QVBoxLayout;
     dlg->setLayout(mainLayout);
     mainLayout->addWidget(mainWidget);
     connect(buttonBox->button(QDialogButtonBox::Close), SIGNAL(clicked()), dlg, SLOT(close()));
 
     FilterEffectEditWidget *editor = new FilterEffectEditWidget(dlg);
     editor->editShape(d->currentShape, canvas());
 
     mainLayout->addWidget(editor);
     mainLayout->addWidget(buttonBox);
     dlg->exec();
     delete dlg;
 
     d->fillConfigSelector(d->currentShape, this);
 }
 
 void KarbonFilterEffectsTool::clearFilter()
 {
     if (!d->currentShape) {
         return;
     }
     if (!d->currentShape->filterEffectStack()) {
         return;
     }
 
     canvas()->addCommand(new FilterStackSetCommand(0, d->currentShape));
 
     d->fillConfigSelector(d->currentShape, this);
 }
 
 void KarbonFilterEffectsTool::filterChanged()
 {
     if (!d->currentShape) {
         return;
     }
 
     d->currentShape->update();
 }
 
 void KarbonFilterEffectsTool::filterSelected(int index)
 {
     if (!d->currentShape || ! d->currentShape->filterEffectStack()) {
         return;
     }
 
     KoFilterEffect *effect = 0;
     QList<KoFilterEffect *> filterEffects = d->currentShape->filterEffectStack()->filterEffects();
     if (index >= 0 && index < filterEffects.count()) {
         effect = filterEffects[index];
     }
 
     d->addWidgetForEffect(effect, this);
 
     repaintDecorations();
 }
 
 void KarbonFilterEffectsTool::selectionChanged()
 {
     d->currentShape = canvas()->selectedShapesProxy()->selection()->firstSelectedShape();
     d->fillConfigSelector(d->currentShape, this);
 }
 
 void KarbonFilterEffectsTool::regionXChanged(double x)
 {
     if (!d->currentEffect) {
         return;
     }
 
     QRectF region = d->currentEffect->filterRect();
     region.setX(x / 100.0);
     canvas()->addCommand(new FilterRegionChangeCommand(d->currentEffect, region, d->currentShape));
 }
 
 void KarbonFilterEffectsTool::regionYChanged(double y)
 {
     if (!d->currentEffect) {
         return;
     }
 
     QRectF region = d->currentEffect->filterRect();
     region.setY(y / 100.0);
     canvas()->addCommand(new FilterRegionChangeCommand(d->currentEffect, region, d->currentShape));
 }
 
 void KarbonFilterEffectsTool::regionWidthChanged(double width)
 {
     if (!d->currentEffect) {
         return;
     }
 
     QRectF region = d->currentEffect->filterRect();
     region.setWidth(width / 100.0);
     canvas()->addCommand(new FilterRegionChangeCommand(d->currentEffect, region, d->currentShape));
 }
 
 void KarbonFilterEffectsTool::regionHeightChanged(double height)
 {
     if (!d->currentEffect) {
         return;
     }
 
     QRectF region = d->currentEffect->filterRect();
     region.setHeight(height / 100.0);
     canvas()->addCommand(new FilterRegionChangeCommand(d->currentEffect, region, d->currentShape));
 }
 
 QList<QPointer<QWidget> > KarbonFilterEffectsTool::createOptionWidgets()
 {
     QList<QPointer<QWidget> > widgets;
 
     FilterResourceServerProvider *serverProvider = FilterResourceServerProvider::instance();
     KoResourceServer<FilterEffectResource> *server = serverProvider->filterEffectServer();
     QSharedPointer<KoAbstractResourceServerAdapter> adapter(new KoResourceServerAdapter<FilterEffectResource>(server));
 
     //---------------------------------------------------------------------
 
     QWidget *addFilterWidget = new QWidget();
     addFilterWidget->setObjectName("AddEffect");
     QGridLayout *addFilterLayout = new QGridLayout(addFilterWidget);
 
     d->filterSelector = new KoResourceSelector(addFilterWidget);
     d->filterSelector->setResourceAdapter(adapter);
     d->filterSelector->setDisplayMode(KoResourceSelector::TextMode);
     d->filterSelector->setColumnCount(1);
     addFilterLayout->addWidget(new QLabel(i18n("Effects"), addFilterWidget), 0, 0);
     addFilterLayout->addWidget(d->filterSelector, 0, 1);
     connect(d->filterSelector, SIGNAL(resourceSelected(KoResource*)),
             this, SLOT(presetSelected(KoResource*)));
 
     connect(d->filterSelector, SIGNAL(resourceApplied(KoResource*)),
             this, SLOT(presetSelected(KoResource*)));
 
     QToolButton *editButton = new QToolButton(addFilterWidget);
     editButton->setIcon(koIcon("view-filter"));
     editButton->setToolTip(i18n("View and edit filter"));
     addFilterLayout->addWidget(editButton, 0, 2);
     connect(editButton, SIGNAL(clicked()), this, SLOT(editFilter()));
 
     d->clearButton = new QToolButton(addFilterWidget);
     d->clearButton->setIcon(koIcon("edit-delete"));
     d->clearButton->setToolTip(i18n("Remove filter from object"));
     addFilterLayout->addWidget(d->clearButton, 0, 3);
     connect(d->clearButton, SIGNAL(clicked()), this, SLOT(clearFilter()));
 
     addFilterWidget->setWindowTitle(i18n("Add Filter"));
     widgets.append(addFilterWidget);
 
     //---------------------------------------------------------------------
 
     QWidget *configFilterWidget = new QWidget();
     configFilterWidget->setObjectName("ConfigEffect");
     QGridLayout *configFilterLayout = new QGridLayout(configFilterWidget);
 
     d->configSelector = new KComboBox(configFilterWidget);
     configFilterLayout->addWidget(d->configSelector, 0, 0);
     connect(d->configSelector, SIGNAL(currentIndexChanged(int)), this, SLOT(filterSelected(int)));
 
     d->configStack = new QStackedWidget(configFilterWidget);
     configFilterLayout->addWidget(d->configStack, 1, 0);
     configFilterLayout->setContentsMargins(0, 0, 0, 0);
 
     configFilterWidget->setWindowTitle(i18n("Effect Properties"));
     widgets.append(configFilterWidget);
 
     //---------------------------------------------------------------------
 
     QWidget *filterRegionWidget = new QWidget();
     filterRegionWidget->setObjectName("EffectRegion");
     QGridLayout *filterRegionLayout = new QGridLayout(filterRegionWidget);
 
     d->posX = new KisDoubleParseSpinBox(filterRegionWidget);
-    d->posX->setSuffix("%");
+    d->posX->setSuffix(i18n("%"));
     connect(d->posX, SIGNAL(valueChanged(double)), this, SLOT(regionXChanged(double)));
     filterRegionLayout->addWidget(new QLabel(i18n("X:")), 0, 0);
     filterRegionLayout->addWidget(d->posX, 0, 1);
 
     d->posY = new KisDoubleParseSpinBox(filterRegionWidget);
-    d->posY->setSuffix("%");
+    d->posY->setSuffix(i18n("%"));
     connect(d->posY, SIGNAL(valueChanged(double)), this, SLOT(regionYChanged(double)));
     filterRegionLayout->addWidget(new QLabel(i18n("Y:")), 1, 0);
     filterRegionLayout->addWidget(d->posY, 1, 1);
 
     d->posW = new KisDoubleParseSpinBox(filterRegionWidget);
-    d->posW->setSuffix("%");
+    d->posW->setSuffix(i18n("%"));
     connect(d->posW, SIGNAL(valueChanged(double)), this, SLOT(regionWidthChanged(double)));
     filterRegionLayout->addWidget(new QLabel(i18n("W:")), 0, 2);
     filterRegionLayout->addWidget(d->posW, 0, 3);
 
     d->posH = new KisDoubleParseSpinBox(filterRegionWidget);
-    d->posH->setSuffix("%");
+    d->posH->setSuffix(i18n("%"));
     connect(d->posH, SIGNAL(valueChanged(double)), this, SLOT(regionHeightChanged(double)));
     filterRegionLayout->addWidget(new QLabel(i18n("H:")), 1, 2);
     filterRegionLayout->addWidget(d->posH, 1, 3);
     filterRegionLayout->addItem(new QSpacerItem(0, 0, QSizePolicy::Minimum, QSizePolicy::Expanding), 2, 0);
     filterRegionLayout->setContentsMargins(0, 0, 0, 0);
 
     filterRegionWidget->setWindowTitle(i18n("Effect Region"));
     widgets.append(filterRegionWidget);
 
     //---------------------------------------------------------------------
 
     d->fillConfigSelector(d->currentShape, this);
 
     return widgets;
 }
 
diff --git a/plugins/tools/selectiontools/kis_tool_select_outline.cc b/plugins/tools/selectiontools/kis_tool_select_outline.cc
index 667b425177..87763bd16c 100644
--- a/plugins/tools/selectiontools/kis_tool_select_outline.cc
+++ b/plugins/tools/selectiontools/kis_tool_select_outline.cc
@@ -1,278 +1,280 @@
 /*
  *  kis_tool_select_freehand.h - part of Krayon^WKrita
  *
  *  Copyright (c) 2000 John Califf <jcaliff@compuzone.net>
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2004 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2007 Sven Langkamp <sven.langkamp@gmail.com>
  *  Copyright (c) 2015 Michael Abrahams <miabraha@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_tool_select_outline.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"
 
 
 #define FEEDBACK_LINE_WIDTH 2
 
 
 KisToolSelectOutline::KisToolSelectOutline(KoCanvasBase * canvas)
     : KisToolSelect(canvas,
                     KisCursor::load("tool_outline_selection_cursor.png", 5, 5),
                     i18n("Outline Selection")),
       m_continuedMode(false)
 {
 }
 
 KisToolSelectOutline::~KisToolSelectOutline()
 {
 }
 
 void KisToolSelectOutline::keyPressEvent(QKeyEvent *event)
 {
     if (event->key() == Qt::Key_Control) {
         m_continuedMode = true;
     }
     KisToolSelect::keyPressEvent(event);
 }
 
 void KisToolSelectOutline::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);
 }
 
 void KisToolSelectOutline::mouseMoveEvent(KoPointerEvent *event)
 {
     if (selectionDragInProgress()) return;
 
     m_lastCursorPos = convertToPixelCoord(event);
     if (m_continuedMode && mode() != PAINT_MODE) {
         updateContinuedMode();
     }
+
+    KisToolSelect::mouseMoveEvent(event);
 }
 
 void KisToolSelectOutline::beginPrimaryAction(KoPointerEvent *event)
 {
     if (selectionDragInProgress()) return;
 
     if (!selectionEditable()) {
         event->ignore();
         return;
     }
 
     setMode(KisTool::PAINT_MODE);
 
     if (m_continuedMode && !m_points.isEmpty()) {
         m_paintPath.lineTo(pixelToView(convertToPixelCoord(event)));
     } else {
         m_paintPath.moveTo(pixelToView(convertToPixelCoord(event)));
     }
 
     m_points.append(convertToPixelCoord(event));
 }
 
 void KisToolSelectOutline::continuePrimaryAction(KoPointerEvent *event)
 {
     if (selectionDragInProgress()) return;
 
     CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
 
     QPointF point = convertToPixelCoord(event);
     m_paintPath.lineTo(pixelToView(point));
     m_points.append(point);
     updateFeedback();
 }
 
 void KisToolSelectOutline::endPrimaryAction(KoPointerEvent *event)
 {
     Q_UNUSED(event);
     const bool hadMoveInProgress = selectionDragInProgress();
 
     if (hadMoveInProgress) return;
 
     CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
     setMode(KisTool::HOVER_MODE);
 
     if (!m_continuedMode) {
         finishSelectionAction();
         m_points.clear(); // ensure points are always cleared
     }
 }
 
 void KisToolSelectOutline::finishSelectionAction()
 {
     KisCanvas2 * kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     KIS_ASSERT_RECOVER_RETURN(kisCanvas);
     kisCanvas->updateCanvas();
 
     const QRectF boundingRect = KisAlgebra2D::accumulateBounds(m_points);
     const QRectF boundingViewRect = pixelToView(boundingRect);
 
     KisSelectionToolHelper helper(kisCanvas, kundo2_i18n("Select by Outline"));
 
     if (helper.tryDeselectCurrentSelection(boundingViewRect, selectionAction())) {
         return;
     }
 
     if (m_points.count() > 2) {
         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();
     }
 
     m_points.clear();
     m_paintPath = QPainterPath();
 }
 
 void KisToolSelectOutline::paint(QPainter& gc, const KoViewConverter &converter)
 {
     Q_UNUSED(converter);
 
     if ((mode() == KisTool::PAINT_MODE || m_continuedMode) &&
         !m_points.isEmpty()) {
 
         QPainterPath outline = m_paintPath;
         if (m_continuedMode && mode() != KisTool::PAINT_MODE) {
             outline.lineTo(pixelToView(m_lastCursorPos));
         }
         paintToolOutline(&gc, outline);
     }
 }
 
 
 
 void KisToolSelectOutline::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 KisToolSelectOutline::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 KisToolSelectOutline::deactivate()
 {
     KisCanvas2 * kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     KIS_ASSERT_RECOVER_RETURN(kisCanvas);
     kisCanvas->updateCanvas();
 
     m_continuedMode = false;
 
     KisTool::deactivate();
 }
 
 void KisToolSelectOutline::resetCursorStyle()
 {
     if (selectionAction() == SELECTION_ADD) {
         useCursor(KisCursor::load("tool_outline_selection_cursor_add.png", 6, 6));
     } else if (selectionAction() == SELECTION_SUBTRACT) {
         useCursor(KisCursor::load("tool_outline_selection_cursor_sub.png", 6, 6));
     } else {
         KisToolSelect::resetCursorStyle();
     }
 }
 
diff --git a/plugins/tools/svgtexttool/SvgTextEditor.cpp b/plugins/tools/svgtexttool/SvgTextEditor.cpp
index 75e4da1ef8..37a79c4834 100644
--- a/plugins/tools/svgtexttool/SvgTextEditor.cpp
+++ b/plugins/tools/svgtexttool/SvgTextEditor.cpp
@@ -1,1195 +1,1224 @@
 /* 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'));
         }
     }
 
 }
 
 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();
 
-    /**
-     * Make sure that when we remove the very last symbol, the last used font will not change
-     */
-    m_textEditorWidget.richTextEdit->document()->setDefaultFont(format.font());
-
     // 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().background().color());
     textSettings.colorEditorBackground->setColor(background);
     textSettings.colorEditorForeground->setColor(cfg.readEntry("colorEditorForeground", qApp->palette().text().color()));
 
     textSettings.colorKeyword->setColor(cfg.readEntry("colorKeyword", QColor(background.value() < 100 ? Qt::cyan : Qt::blue)));
     textSettings.chkBoldKeyword->setChecked(cfg.readEntry("BoldKeyword", true));
     textSettings.chkItalicKeyword->setChecked(cfg.readEntry("ItalicKeyword", false));
 
     textSettings.colorElement->setColor(cfg.readEntry("colorElement", QColor(background.value() < 100 ? Qt::magenta : Qt::darkMagenta)));
     textSettings.chkBoldElement->setChecked(cfg.readEntry("BoldElement", true));
     textSettings.chkItalicElement->setChecked(cfg.readEntry("ItalicElement", false));
 
     textSettings.colorAttribute->setColor(cfg.readEntry("colorAttribute", QColor(background.value() < 100 ? Qt::green : Qt::darkGreen)));
     textSettings.chkBoldAttribute->setChecked(cfg.readEntry("BoldAttribute", true));
     textSettings.chkItalicAttribute->setChecked(cfg.readEntry("ItalicAttribute", true));
 
     textSettings.colorValue->setColor(cfg.readEntry("colorValue", QColor(background.value() < 100 ? Qt::red: Qt::darkRed)));
     textSettings.chkBoldValue->setChecked(cfg.readEntry("BoldValue", true));
     textSettings.chkItalicValue->setChecked(cfg.readEntry("ItalicValue", false));
 
     textSettings.colorComment->setColor(cfg.readEntry("colorComment", QColor(background.value() < 100 ? Qt::lightGray : Qt::gray)));
     textSettings.chkBoldComment->setChecked(cfg.readEntry("BoldComment", false));
     textSettings.chkItalicComment->setChecked(cfg.readEntry("ItalicComment", false));
 
     settingsDialog.setButtons(KoDialog::Ok | KoDialog::Cancel);
     if (settingsDialog.exec() == QDialog::Accepted) {
         // 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().background().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());
     }
-    qobject_cast<KisFontComboBoxes*>(qobject_cast<QWidgetAction*>(actionCollection()->action("svg_font"))->defaultWidget())->refillComboBox(writingSystems);
 
+    {
+        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("%");
+    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/SvgTextEditor.h b/plugins/tools/svgtexttool/SvgTextEditor.h
index 1e2a277340..4a2adda3c2 100644
--- a/plugins/tools/svgtexttool/SvgTextEditor.h
+++ b/plugins/tools/svgtexttool/SvgTextEditor.h
@@ -1,169 +1,171 @@
 /* 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.
  */
 
 #ifndef TEXTNGSHAPECONFIGWIDGET_H
 #define TEXTNGSHAPECONFIGWIDGET_H
 
 #include <QWidget>
 #include <QTextEdit>
 
 #include <kxmlguiwindow.h>
 #include <KoColor.h>
 #include <KoSvgText.h>//for the enums
 
 #include <BasicXMLSyntaxHighlighter.h>
 
 #include "ui_WdgSvgTextEditor.h"
 #include "ui_WdgSvgTextSettings.h"
 
 class KoSvgTextShape;
 class KoDialog;
 
 class SvgTextEditor : public KXmlGuiWindow
 {
     Q_OBJECT
 public:
     SvgTextEditor(QWidget *parent = 0, Qt::WindowFlags flags = 0);
     ~SvgTextEditor();
 
     //tiny enum to keep track of the tab on which editor something happens while keeping the code readable.
     enum Editor {
         Richtext, // 0
         SVGsource // 1
     };
 
     // enum to store which tabs are visible in the configuration
     enum EditorMode {
         RichText,
         SvgSource,
         Both
     };
 
     void setShape(KoSvgTextShape *shape);
 
 private Q_SLOTS:
     /**
      * switch the text editor tab.
      */
     void switchTextEditorTab(bool convertData = true);
 
     void slotCloseEditor();
 
     /**
      * in rich text, check the current format, and toggle the given buttons.
      */
     void checkFormat();
 
+    void slotFixUpEmptyTextBlock();
+
     void save();
 
     void undo();
     void redo();
 
     void cut();
     void copy();
     void paste();
 
     void selectAll();
     void deselect();
 
     void find();
     void findNext();
     void findPrev();
     void replace();
 
     void zoomOut();
     void zoomIn();
 #ifndef Q_OS_WIN
     void showInsertSpecialCharacterDialog();
     void insertCharacter(const QChar &c);
 #endif
     void setTextBold(QFont::Weight weight = QFont::Bold);
     void setTextWeightLight();
     void setTextWeightNormal();
     void setTextWeightDemi();
     void setTextWeightBlack();
 
     void setTextItalic(QFont::Style style = QFont::StyleOblique);
     void setTextDecoration(KoSvgText::TextDecoration decor);
     void setTextUnderline();
     void setTextOverline();
     void setTextStrikethrough();
     void setTextSubscript();
     void setTextSuperScript();
     void increaseTextSize();
     void decreaseTextSize();
 
     void setLineHeight(double lineHeightPercentage);
     void setLetterSpacing(double letterSpacing);
     void alignLeft();
     void alignRight();
     void alignCenter();
     void alignJustified();
 
     void setFont(const QString &fontName);
     void setFontSize(qreal size);
     void setBaseline(KoSvgText::BaselineShiftMode baseline);
 
     void setSettings();
     void slotToolbarToggled(bool);
 
     void setFontColor(const KoColor &c);
     void setBackgroundColor(const KoColor &c);
 
     void setModified(bool modified);
     void dialogButtonClicked(QAbstractButton *button);
 
 Q_SIGNALS:
     void textUpdated(KoSvgTextShape *shape, const QString &svg, const QString &defs, bool richTextPreferred);
     void textEditorClosed();
 
 protected:
     void wheelEvent(QWheelEvent *event) override;
     /**
      * Selects all if there is no selection
      * @returns a copy of the previous cursor.
      */
     QTextCursor setTextSelection();
 
 private:
     void applySettings();
 
     QAction *createAction(const QString &name,
                           const char *member);
     void createActions();
     void enableRichTextActions(bool enable);
     void enableSvgTextActions(bool enable);
 
     Ui_WdgSvgTextEditor m_textEditorWidget;
     QTextEdit *m_currentEditor {0};
     QWidget *m_page {0};
     QList<QAction*> m_richTextActions;
     QList<QAction*> m_svgTextActions;
 
     KoSvgTextShape *m_shape {0};
 #ifndef Q_OS_WIN
     KoDialog *m_charSelectDialog {0};
 #endif
     BasicXMLSyntaxHighlighter *m_syntaxHighlighter;
 
     QString m_searchKey;
 };
 
 #endif //TEXTNGSHAPECONFIGWIDGET_H
diff --git a/plugins/tools/tool_crop/wdg_tool_crop.ui b/plugins/tools/tool_crop/wdg_tool_crop.ui
index 20b92cc398..4a9d3e62c3 100644
--- a/plugins/tools/tool_crop/wdg_tool_crop.ui
+++ b/plugins/tools/tool_crop/wdg_tool_crop.ui
@@ -1,500 +1,503 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgToolCrop</class>
  <widget class="QWidget" name="WdgToolCrop">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>288</width>
     <height>242</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Crop</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout_2">
    <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">
      <property name="spacing">
       <number>0</number>
      </property>
      <item>
       <layout class="QVBoxLayout" name="verticalLayout">
        <property name="spacing">
         <number>0</number>
        </property>
        <item>
         <layout class="QGridLayout" name="gridLayout">
          <property name="leftMargin">
           <number>5</number>
          </property>
          <property name="topMargin">
           <number>5</number>
          </property>
          <property name="rightMargin">
           <number>5</number>
          </property>
          <property name="bottomMargin">
           <number>5</number>
          </property>
          <property name="spacing">
           <number>5</number>
          </property>
          <item row="2" column="1">
           <widget class="QCheckBox" name="boolCenter">
            <property name="toolTip">
             <string>Resize keeping center fixed</string>
            </property>
            <property name="text">
             <string>Center</string>
            </property>
           </widget>
          </item>
          <item row="1" column="0">
           <widget class="QLabel" name="label_vertiPos">
            <property name="toolTip">
             <string>Vertical Position</string>
            </property>
            <property name="text">
             <string>&amp;Y:</string>
            </property>
            <property name="buddy">
             <cstring>intY</cstring>
            </property>
           </widget>
          </item>
          <item row="0" column="0">
           <widget class="QLabel" name="label_horizPos">
            <property name="toolTip">
             <string>Horizontal Position</string>
            </property>
            <property name="text">
             <string>&amp;X:</string>
            </property>
            <property name="buddy">
             <cstring>intX</cstring>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <widget class="KisIntParseSpinBox" name="intX">
            <property name="minimumSize">
             <size>
              <width>60</width>
              <height>0</height>
             </size>
            </property>
            <property name="maximumSize">
             <size>
              <width>16777215</width>
              <height>16777215</height>
             </size>
            </property>
            <property name="toolTip">
             <string>Horizontal Position</string>
            </property>
            <property name="suffix">
             <string> px</string>
            </property>
            <property name="maximum">
             <number>30000</number>
            </property>
           </widget>
          </item>
          <item row="1" column="1">
           <widget class="KisIntParseSpinBox" name="intY">
            <property name="minimumSize">
             <size>
              <width>60</width>
              <height>0</height>
             </size>
            </property>
            <property name="maximumSize">
             <size>
              <width>16777215</width>
              <height>16777215</height>
             </size>
            </property>
            <property name="toolTip">
             <string>Vertical Position</string>
            </property>
            <property name="suffix">
             <string> px</string>
            </property>
            <property name="maximum">
             <number>30000</number>
            </property>
           </widget>
          </item>
          <item row="3" column="1">
           <widget class="QCheckBox" name="boolGrow">
            <property name="toolTip">
             <string>Allow growing the image by dragging outside bounds of the image</string>
            </property>
            <property name="text">
             <string>Grow</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>0</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </item>
      <item>
       <spacer name="horizontalSpacer">
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>0</width>
          <height>20</height>
         </size>
        </property>
       </spacer>
      </item>
      <item>
       <layout class="QGridLayout" name="gridLayout_2">
        <property name="leftMargin">
         <number>5</number>
        </property>
        <property name="topMargin">
         <number>5</number>
        </property>
        <property name="rightMargin">
         <number>5</number>
        </property>
        <property name="bottomMargin">
         <number>5</number>
        </property>
        <property name="spacing">
         <number>5</number>
        </property>
        <item row="3" column="2">
         <spacer name="verticalSpacer_3">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
        <item row="1" column="2">
         <widget class="QLabel" name="heightLabel">
          <property name="toolTip">
           <string>Height</string>
          </property>
          <property name="text">
-          <string>H:</string>
+          <string>Height:</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
          </property>
         </widget>
        </item>
        <item row="1" column="4">
         <widget class="KisIntParseSpinBox" name="intHeight">
          <property name="minimumSize">
           <size>
            <width>60</width>
            <height>0</height>
           </size>
          </property>
          <property name="maximumSize">
           <size>
            <width>16777215</width>
            <height>16777215</height>
           </size>
          </property>
          <property name="toolTip">
           <string>Height</string>
          </property>
          <property name="suffix">
           <string> px</string>
          </property>
          <property name="maximum">
           <number>30000</number>
          </property>
         </widget>
        </item>
        <item row="0" column="4">
         <widget class="KisIntParseSpinBox" name="intWidth">
          <property name="minimumSize">
           <size>
            <width>60</width>
            <height>0</height>
           </size>
          </property>
          <property name="maximumSize">
           <size>
            <width>16777215</width>
            <height>16777215</height>
           </size>
          </property>
          <property name="toolTip">
           <string>Width</string>
          </property>
          <property name="suffix">
           <string> px</string>
          </property>
          <property name="maximum">
           <number>30000</number>
          </property>
         </widget>
        </item>
        <item row="2" column="4">
         <widget class="KisDoubleParseSpinBox" name="doubleRatio">
          <property name="minimumSize">
           <size>
            <width>60</width>
            <height>0</height>
           </size>
          </property>
          <property name="maximumSize">
           <size>
            <width>16777215</width>
            <height>16777215</height>
           </size>
          </property>
          <property name="toolTip">
-          <string>Ratio</string>
+          <string>Aspect ratio</string>
          </property>
          <property name="singleStep">
           <double>0.100000000000000</double>
          </property>
          <property name="precision" stdset="0">
           <number>2</number>
          </property>
         </widget>
        </item>
        <item row="2" column="2">
         <widget class="QLabel" name="aspectLabel">
          <property name="text">
           <string>Ratio:</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
          </property>
         </widget>
        </item>
        <item row="0" column="2">
         <widget class="QLabel" name="widthLabel">
          <property name="toolTip">
           <string>Width</string>
          </property>
          <property name="text">
-          <string>W:</string>
+          <string>Width:</string>
          </property>
          <property name="alignment">
           <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
          </property>
         </widget>
        </item>
        <item row="0" column="5">
         <widget class="QPushButton" name="lockWidthButton">
          <property name="toolTip">
           <string>Lock the width</string>
          </property>
          <property name="text">
           <string/>
          </property>
          <property name="checkable">
           <bool>true</bool>
          </property>
         </widget>
        </item>
        <item row="1" column="5">
         <widget class="QPushButton" name="lockHeightButton">
          <property name="toolTip">
           <string>Lock the height</string>
          </property>
          <property name="text">
           <string/>
          </property>
          <property name="checkable">
           <bool>true</bool>
          </property>
         </widget>
        </item>
        <item row="2" column="5">
         <widget class="QPushButton" name="lockRatioButton">
          <property name="toolTip">
           <string>Lock the aspect ratio</string>
          </property>
          <property name="text">
           <string/>
          </property>
          <property name="checkable">
           <bool>true</bool>
          </property>
          <property name="flat">
           <bool>false</bool>
          </property>
         </widget>
        </item>
       </layout>
      </item>
     </layout>
    </item>
    <item>
     <layout class="QGridLayout" name="gridLayout_3">
      <property name="leftMargin">
       <number>5</number>
      </property>
      <property name="topMargin">
       <number>0</number>
      </property>
      <property name="rightMargin">
       <number>5</number>
      </property>
      <property name="bottomMargin">
       <number>5</number>
      </property>
+     <property name="spacing">
+      <number>5</number>
+     </property>
      <item row="2" column="1">
       <widget class="QComboBox" name="cmbType">
        <property name="currentIndex">
         <number>1</number>
        </property>
        <item>
         <property name="text">
          <string>Layer</string>
         </property>
        </item>
        <item>
         <property name="text">
          <string>Image</string>
         </property>
        </item>
       </widget>
      </item>
      <item row="4" column="1">
       <widget class="QPushButton" name="bnCrop">
        <property name="text">
         <string>&amp;Crop</string>
        </property>
       </widget>
      </item>
      <item row="2" column="0">
       <widget class="QLabel" name="label">
        <property name="text">
         <string>Applies to:</string>
        </property>
        <property name="alignment">
         <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
        </property>
       </widget>
      </item>
      <item row="3" column="1">
       <widget class="QComboBox" name="cmbDecor">
        <item>
         <property name="text">
          <string>None</string>
         </property>
        </item>
        <item>
         <property name="text">
          <string>Thirds</string>
         </property>
        </item>
        <item>
         <property name="text">
          <string>Fifths</string>
         </property>
        </item>
        <item>
         <property name="text">
          <string>Passport photo</string>
         </property>
        </item>
        <item>
         <property name="text">
          <string>Crosshair</string>
         </property>
        </item>
       </widget>
      </item>
      <item row="3" column="0">
       <widget class="QLabel" name="label_2">
        <property name="text">
         <string>Decoration:</string>
        </property>
        <property name="alignment">
         <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
        </property>
       </widget>
      </item>
      <item row="5" column="1">
       <spacer name="verticalSpacer_2">
        <property name="orientation">
         <enum>Qt::Vertical</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>20</width>
          <height>40</height>
         </size>
        </property>
       </spacer>
      </item>
     </layout>
    </item>
    <item>
     <widget class="QWidget" name="SpecialSpacer" native="true"/>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KisIntParseSpinBox</class>
    <extends>QSpinBox</extends>
    <header>kis_int_parse_spin_box.h</header>
   </customwidget>
   <customwidget>
    <class>KisDoubleParseSpinBox</class>
    <extends>QDoubleSpinBox</extends>
    <header>kis_double_parse_spin_box.h</header>
   </customwidget>
  </customwidgets>
  <tabstops>
   <tabstop>intX</tabstop>
   <tabstop>intY</tabstop>
   <tabstop>intWidth</tabstop>
   <tabstop>intHeight</tabstop>
   <tabstop>cmbType</tabstop>
  </tabstops>
  <resources/>
  <connections/>
 </ui>
diff --git a/plugins/tools/tool_transform2/kis_tool_transform.cc b/plugins/tools/tool_transform2/kis_tool_transform.cc
index 31e3656630..d8b0bfd777 100644
--- a/plugins/tools/tool_transform2/kis_tool_transform.cc
+++ b/plugins/tools/tool_transform2/kis_tool_transform.cc
@@ -1,1135 +1,1136 @@
 /*
  *  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 {
         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_changesTracker.isEmpty()) {
         cancelStroke();
     } else {
         m_changesTracker.requestUndo();
     }
 }
 
 void KisToolTransform::requestStrokeEnd()
 {
     endStroke();
 }
 
 void KisToolTransform::requestStrokeCancellation()
 {
     if (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)));
 
     m_strokeId = image()->startStroke(strategy);
 
     KIS_SAFE_ASSERT_RECOVER_NOOP(m_changesTracker.isEmpty());
 
     slotPreviewDeviceGenerated(0, QPainterPath());
 }
 
 void KisToolTransform::endStroke()
 {
     if (!m_strokeId) return;
 
     if (!m_currentArgs.isIdentity()) {
         image()->addJob(m_strokeId,
                         new TransformStrokeStrategy::TransformAllData(m_currentArgs));
         image()->endStroke(m_strokeId);
     } else {
         image()->cancelStroke(m_strokeId);
     }
 
     m_strokeId.clear();
     m_changesTracker.reset();
     m_transaction = TransformTransactionProperties(QRectF(), &m_currentArgs, KisNodeSP(), {});
     outlineChanged();
 }
 
 void KisToolTransform::slotTransactionGenerated(TransformTransactionProperties transaction, ToolTransformArgs args)
 {
     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)
 {
     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();
     }
 }
 
 void KisToolTransform::commitChanges()
 {
     if (!m_strokeId) 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() {
     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_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;
 
     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_config_widget.cpp b/plugins/tools/tool_transform2/kis_tool_transform_config_widget.cpp
index 941cc3a6f7..47340b8ead 100644
--- a/plugins/tools/tool_transform2/kis_tool_transform_config_widget.cpp
+++ b/plugins/tools/tool_transform2/kis_tool_transform_config_widget.cpp
@@ -1,1299 +1,1297 @@
 /*
  *  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 <QSignalMapper>
 #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->setSuffix("%");
-    scaleYBox->setSuffix("%");
     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(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."));
+    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"));
 
     QSignalMapper *liquifyModeMapper = new QSignalMapper(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/wdg_tool_transform.ui b/plugins/tools/tool_transform2/wdg_tool_transform.ui
index c9c378769e..028721a566 100644
--- a/plugins/tools/tool_transform2/wdg_tool_transform.ui
+++ b/plugins/tools/tool_transform2/wdg_tool_transform.ui
@@ -1,2265 +1,2265 @@
 <?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>Posi&amp;tion</string>
+              <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>&amp;Rotate</string>
+              <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>Scale</string>
+              <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>Shear</string>
+              <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>w&amp;idth:</string>
+                 <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>&amp;height:</string>
+                 <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"/>
  </buttongroups>
 </ui>
diff --git a/sdk/tests/ui_manager_test.h b/sdk/tests/ui_manager_test.h
index 4d29bc2d95..2f3b891ac5 100644
--- a/sdk/tests/ui_manager_test.h
+++ b/sdk/tests/ui_manager_test.h
@@ -1,180 +1,180 @@
 /*
  *  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.
  */
 
 #ifndef __UI_MANAGER_TEST_H
 #define __UI_MANAGER_TEST_H
 
 #include "testutil.h"
 #include "qimage_based_test.h"
 #include "ksharedconfig.h"
 #include <kis_filter_configuration.h>
 #include <resources/KoPattern.h>
 #include "KisResourceServerProvider.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_filter_strategy.h"
 #include "kis_selection_manager.h"
 #include "kis_node_manager.h"
 #include "KisViewManager.h"
 #include "KisView.h"
 #include "KisPart.h"
 #include <KisDocument.h>
 #include <kis_action_manager.h>
 #include "KisMainWindow.h"
 #include "kis_selection_mask.h"
 
 namespace TestUtil
 {
 
 class UiManagerTest : public TestUtil::QImageBasedTest
 {
 public:
     UiManagerTest(bool useSelection, bool useShapeLayer, const QString &testName)
         : QImageBasedTest(testName) // "selection_manager_test"
     {
         undoStore = new KisSurrogateUndoStore();
         image = createImage(undoStore);
 
         part = KisPart::instance();
         doc = qobject_cast<KisDocument*>(part->createDocument());
         doc->setCurrentImage(image);
 
         if(useSelection) addGlobalSelection(image);
         if(useShapeLayer) addShapeLayer(doc, image);
         image->initialRefreshGraph();
 
         mainWindow = new KisMainWindow();
-        imageView = new KisView(doc, mainWindow->resourceManager(), mainWindow->actionCollection(), mainWindow);
+        imageView = new KisView(doc, mainWindow->viewManager(), mainWindow);
         view = new KisViewManager(mainWindow, mainWindow->actionCollection());
 
         KoPattern *newPattern = new KoPattern(fetchDataFileLazy("HR_SketchPaper_01.pat"));
         newPattern->load();
         Q_ASSERT(newPattern->valid());
         view->canvasResourceProvider()->slotPatternActivated(newPattern);
 
         KoColor fgColor(Qt::black, image->colorSpace());
         KoColor bgColor(Qt::white, image->colorSpace());
         view->canvasResourceProvider()->blockSignals(true);
         view->canvasResourceProvider()->setBGColor(bgColor);
         view->canvasResourceProvider()->setFGColor(fgColor);
         view->canvasResourceProvider()->setOpacity(1.0);
 
         KisNodeSP paint1 = findNode(image->root(), "paint1");
         Q_ASSERT(paint1);
 
         imageView->setViewManager(view);
         view->setCurrentView(imageView);
 
         view->nodeManager()->slotUiActivatedNode(paint1);
 
         selectionManager = view->selectionManager();
         Q_ASSERT(selectionManager);
         actionManager = view->actionManager();
         Q_ASSERT(actionManager);
 
         QVERIFY(checkLayersInitial());
 
     }
 
     ~UiManagerTest() {
         /**
          * Here is a weird way of precessing pending events.
          * This is needed for the dummies facade could process
          * all the queued events telling it some nodes were
          * added/deleted
          */
         QApplication::processEvents();
         QTest::qSleep(500);
         QApplication::processEvents();
 
         delete mainWindow;
         delete doc;
 
         /**
          * The event queue may have up to 200k events
          * by the time all the tests are finished. Removing
          * all of them may last forever, so clear them after
          * every single test is finished
          */
         QApplication::removePostedEvents(0);
     }
 
     void checkUndo() {
         undoStore->undo();
         image->waitForDone();
         QVERIFY(checkLayersInitial());
     }
 
     void checkDoubleUndo() {
         undoStore->undo();
         undoStore->undo();
         image->waitForDone();
         QVERIFY(checkLayersInitial());
     }
 
     void startConcurrentTask() {
         KisFilterStrategy * filter = new KisBoxFilterStrategy();
         QSize initialSize = image->size();
 
         image->scaleImage(2 * initialSize, image->xRes(), image->yRes(), filter);
         image->waitForDone();
 
         image->scaleImage(initialSize, image->xRes(), image->yRes(), filter);
     }
 
     using QImageBasedTest::checkLayers;
 
     bool checkLayers(const QString &name) {
         return checkLayers(image, name);
     }
 
     using QImageBasedTest::checkLayersInitial;
 
     bool checkLayersInitial() {
         return checkLayersInitial(image);
     }
 
     bool checkLayersFuzzy(const QString &name) {
         return checkLayers(image, name, 1);
     }
 
     bool checkSelectionOnly(const QString &name) {
         KisNodeSP mask = dynamic_cast<const KisLayer*>(image->root().data())->selectionMask();
         return checkOneLayer(image, mask, name);
     }
 
     bool checkNoSelection() {
         KisNodeSP mask = dynamic_cast<const KisLayer*>(image->root().data())->selectionMask();
         return !mask && !image->globalSelection();
     }
 
     KisImageSP image;
     KisSelectionManager *selectionManager;
     KisActionManager *actionManager;
     KisSurrogateUndoStore *undoStore;
 
 protected:
     KisView *imageView;
     KisViewManager *view;
     KisDocument *doc;
     KisPart *part;
     KisMainWindow *mainWindow;
 };
 
 }
 
 #endif /* __UI_MANAGER_TEST_H */