diff --git a/3rdparty/CMakeLists.txt b/3rdparty/CMakeLists.txt
index 568f805628..fbdf43cb71 100644
--- a/3rdparty/CMakeLists.txt
+++ b/3rdparty/CMakeLists.txt
@@ -1,217 +1,209 @@
 project (krita-and-all-its-deps)
 
 #
 # Build all dependencies for Krita and finally Krita itself.
 # Parameters: EXTERNALS_DOWNLOAD_DIR place to download all packages
 #             INSTALL_ROOT place to install everything to
 #             MXE_TOOLCHAIN: the toolchain file to cross-compile using MXE
 #
 # Example usage: cmake ..\kritadeposx -DEXTERNALS_DOWNLOAD_DIR=/dev2/d -DINSTALL_ROOT=/dev2/i -DWIN64_BUILD=TRUE  -DBOOST_LIBRARYDIR=/dev2/i/lib   -G "Visual Studio 11 Win64"
 
 
 cmake_minimum_required(VERSION 2.8.6)
 
 if(NOT SUBMAKE_JOBS)
 	set(SUBMAKE_JOBS 1)
-endif(NOT SUBMAKE_JOBS)
+endif()
 
 if (CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR)
 	message(FATAL_ERROR "Compiling in the source directory is not supported. Use for example 'mkdir build; cd build; cmake ..'.")
 endif (CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR)
 
 # Tools must be obtained to work with:
 include (ExternalProject)
 
 # allow specification of a directory with pre-downloaded
 # requirements
 if(NOT IS_DIRECTORY ${EXTERNALS_DOWNLOAD_DIR})
     message(FATAL_ERROR "No externals download dir set. Use -DEXTERNALS_DOWNLOAD_DIR")
 endif()
 
 if(NOT IS_DIRECTORY ${INSTALL_ROOT})
     message(FATAL_ERROR "No install dir set. Use -DINSTALL_ROOT")
 endif()
 
 set(TOP_INST_DIR ${INSTALL_ROOT})
 set(EXTPREFIX "${TOP_INST_DIR}")
 set(CMAKE_PREFIX_PATH "${EXTPREFIX}")
 
 if (${CMAKE_GENERATOR} STREQUAL "Visual Studio 14 2015 Win64")
     SET(GLOBAL_PROFILE
         -DCMAKE_MODULE_LINKER_FLAGS=/machine:x64
         -DCMAKE_EXE_LINKER_FLAGS=/machine:x64
         -DCMAKE_SHARED_LINKER_FLAGS=/machine:x64
         -DCMAKE_STATIC_LINKER_FLAGS=/machine:x64
     )
 endif ()
 
 message( STATUS "CMAKE_GENERATOR: ${CMAKE_GENERATOR}")
 message( STATUS "CMAKE_CL_64: ${CMAKE_CL_64}")
 
 set(GLOBAL_BUILD_TYPE RelWithDebInfo)
 set(GLOBAL_PROFILE ${GLOBAL_PROFILE} -DBUILD_TESTING=false)
 
 if (MINGW)
 	option(QT_ENABLE_DEBUG_INFO "Build Qt with debug info included" OFF)
 	option(QT_ENABLE_DYNAMIC_OPENGL "Build Qt with dynamic ANGLE support '-opengl dynamic -angle' (needs env var 'WindowsSdkDir' set to path of Windows 10 SDK)" ON)
     if (QT_ENABLE_DYNAMIC_OPENGL)
 		if (DEFINED ENV{WindowsSdkDir})
 			message(STATUS "WindowsSdkDir is set to '$ENV{WindowsSdkDir}'")
 		else (DEFINED ENV{WindowsSdkDir})
 			message(FATAL_ERROR "Environment variable 'WindowsSdkDir' not set! Please set it to path of Windows 10 SDK or disable QT_ENABLE_DYNAMIC_OPENGL")
-		endif (DEFINED ENV{WindowsSdkDir})
-	endif (QT_ENABLE_DYNAMIC_OPENGL)
+		endif ()
+	endif ()
 endif (MINGW)
 
 set(SECURITY_EXE_LINKER_FLAGS "")
 set(SECURITY_SHARED_LINKER_FLAGS "")
 set(SECURITY_MODULE_LINKER_FLAGS "")
 if (MINGW)
 	option(USE_MINGW_HARDENING_LINKER "Enable DEP (NX), ASLR and high-entropy ASLR linker flags (mingw-w64)" ON)
 	if (USE_MINGW_HARDENING_LINKER)
 		set(SECURITY_EXE_LINKER_FLAGS "-Wl,--dynamicbase -Wl,--nxcompat -Wl,--disable-auto-image-base")
 		set(SECURITY_SHARED_LINKER_FLAGS "-Wl,--dynamicbase -Wl,--nxcompat -Wl,--disable-auto-image-base")
 		set(SECURITY_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(SECURITY_EXE_LINKER_FLAGS "${SECURITY_EXE_LINKER_FLAGS} -Wl,--high-entropy-va -Wl,--image-base,0x140000000")
 			set(SECURITY_SHARED_LINKER_FLAGS "${SECURITY_SHARED_LINKER_FLAGS} -Wl,--high-entropy-va -Wl,--image-base,0x180000000")
 			set(SECURITY_MODULE_LINKER_FLAGS "${SECURITY_MODULE_LINKER_FLAGS} -Wl,--high-entropy-va -Wl,--image-base,0x180000000")
 			set(GLOBAL_PROFILE ${GLOBAL_PROFILE}
 				-DCMAKE_EXE_LINKER_FLAGS=${SECURITY_EXE_LINKER_FLAGS}
 				-DCMAKE_SHARED_LINKER_FLAGS=${SECURITY_SHARED_LINKER_FLAGS}
 				-DCMAKE_MODULE_LINKER_FLAGS=${SECURITY_MODULE_LINKER_FLAGS}
 			)
-		endif ("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
-	else (USE_MINGW_HARDENING_LINKER)
+		endif ()
+	else ()
 		message(WARNING "Linker Security Flags not enabled!")
-	endif (USE_MINGW_HARDENING_LINKER)
-endif (MINGW)
+	endif ()
+endif ()
 
 if (DEFINED EP_PREFIX)
 	set_directory_properties(PROPERTIES EP_PREFIX ${EP_PREFIX})
-endif (DEFINED EP_PREFIX)
+endif ()
 
 if (MSVC)
-        set(GLOBAL_PROFILE ${GLOBAL_PROFILE} -DCMAKE_EXE_LINKER_FLAGS=/PROFILE -DCMAKE_SHARED_LINKER_FLAGS=/PROFILE)
-	set(PATCH_COMMAND myptch)
+    message(FATAL_ERROR "Krita cannot be built with MSVC. See the README.md file!")
 endif()
 
 if (MINGW)
    set(PATCH_COMMAND myptch)
 endif()
 
 if (MSYS)
 	set(PATCH_COMMAND patch)
     set(GLOBAL_PROFILE ${GLOBAL_PROFILE}
                            -DCMAKE_TOOLCHAIN_FILE=${MXE_TOOLCHAIN}
                            -DCMAKE_FIND_PREFIX_PATH=${CMAKE_PREFIX_PATH}
                            -DCMAKE_SYSTEM_INCLUDE_PATH=${CMAKE_PREFIX_PATH}/include
                            -DCMAKE_INCLUDE_PATH=${CMAKE_PREFIX_PATH}/include
                            -DCMAKE_LIBRARY_PATH=${CMAKE_PREFIX_PATH}/lib
                            -DZLIB_ROOT=${CMAKE_PREFIX_PATH}
     )
     set(GLOBAL_AUTOMAKE_PROFILE  --host=i686-pc-mingw32 )
 endif()
 
 if (APPLE)
     set(GLOBAL_PROFILE ${GLOBAL_PROFILE} -DCMAKE_MACOSX_RPATH=ON -DKDE_SKIP_RPATH_SETTINGS=ON -DBUILD_WITH_INSTALL_RPATH=ON -DAPPLE_SUPPRESS_X11_WARNING=ON)
     set(PATCH_COMMAND patch)
 endif ()
 
 if (UNIX AND NOT APPLE)
 	set(LINUX true)
     set(PATCH_COMMAND patch)
 endif ()
 
 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)
+	endif ()
 	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)
 	option(ENABLE_PYTHON_DEPS "Enable Python deps (sip, pyqt)" ON)
 	if (ENABLE_PYTHON_DEPS)
         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)
+        endif()
 		if (PYTHONLIBS_FOUND AND PYTHONINTERP_FOUND)
 			message(STATUS "Python requirements met.")
 			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!")
-			endif (NOT CAN_USE_PYTHON_LIBS)
+			endif ()
 		else (PYTHONLIBS_FOUND AND PYTHONINTERP_FOUND)
 			message(FATAL_ERROR "Python requirements not met. To disable Python deps, set ENABLE_PYTHON_DEPS to OFF.")
-		endif (PYTHONLIBS_FOUND AND PYTHONINTERP_FOUND)
-	endif (ENABLE_PYTHON_DEPS)
-endif (MINGW)
+		endif ()
+	endif ()
+endif ()
 
 # this list must be dependency-ordered
 if (ENABLE_PYTHON_DEPS OR NOT MINGW)
 	add_subdirectory( ext_python )
-endif (ENABLE_PYTHON_DEPS OR NOT MINGW)
-if (MSVC)
-    add_subdirectory( ext_patch )
-    add_subdirectory( ext_png2ico )
-endif (MSVC)
+endif ()
 if (MINGW)
     add_subdirectory( ext_patch )
     add_subdirectory( ext_png2ico )
-endif (MINGW)
+endif ()
 add_subdirectory( ext_iconv )
 add_subdirectory( ext_gettext )
 add_subdirectory( ext_zlib )
 add_subdirectory( ext_boost )
 add_subdirectory( ext_jpeg )
 add_subdirectory( ext_tiff )
 add_subdirectory( ext_png )
 add_subdirectory( ext_eigen3 )
 add_subdirectory( ext_expat ) # for exiv2
 add_subdirectory( ext_exiv2 )
 add_subdirectory( ext_ilmbase )
 add_subdirectory( ext_lcms2 )
 add_subdirectory( ext_openexr )
 add_subdirectory( ext_vc )
 add_subdirectory( ext_gsl )
 add_subdirectory( ext_fftw3 )
 add_subdirectory( ext_ocio )
-if (MSVC)
-    add_subdirectory( ext_pthreads )
-endif (MSVC)
 add_subdirectory( ext_fontconfig)
 add_subdirectory( ext_freetype)
 add_subdirectory( ext_qt )
 add_subdirectory( ext_poppler )
 add_subdirectory( ext_libraw )
 add_subdirectory( ext_frameworks )
 if (ENABLE_PYTHON_DEPS OR NOT MINGW)
 	add_subdirectory( ext_sip )
 	add_subdirectory( ext_pyqt )
-endif (ENABLE_PYTHON_DEPS OR NOT MINGW)
+endif ()
 
-if (MSVC OR MINGW)
+if (MINGW)
     add_subdirectory( ext_drmingw )
 #    add_subdirectory( ext_ffmpeg )
-endif (MSVC OR MINGW)
+endif ()
 
 if (NOT APPLE)
 	add_subdirectory( ext_gmic )
-endif (NOT APPLE)
+endif ()
 
 add_subdirectory(ext_giflib)
diff --git a/3rdparty/ext_boost/CMakeLists.txt b/3rdparty/ext_boost/CMakeLists.txt
index e20ea14060..072e32b63f 100644
--- a/3rdparty/ext_boost/CMakeLists.txt
+++ b/3rdparty/ext_boost/CMakeLists.txt
@@ -1,86 +1,40 @@
 SET(PREFIX_ext_boost "${EXTPREFIX}" )
-if (MSVC)
-	if (${CMAKE_GENERATOR} STREQUAL "Visual Studio 14 2015 Win64")
-		ExternalProject_Add(
-			ext_boost
-			DOWNLOAD_DIR ${EXTERNALS_DOWNLOAD_DIR}
-			URL http://files.kde.org/krita/build/dependencies/boost_1_61_0.zip
-			URL_MD5 015ae4afa6f3e597232bfe1dab949ace
-
-			CONFIGURE_COMMAND <SOURCE_DIR>/bootstrap.bat --prefix=${PREFIX_ext_boost}
-			BUILD_COMMAND <SOURCE_DIR>/b2.exe -j${SUBMAKE_JOBS} --with-system --build-dir=build-dir --prefix=${PREFIX_ext_boost} toolset=msvc-14.0 variant=release link=shared  threading=multi architecture=x86 address-model=64 variant=release install
-			INSTALL_COMMAND ""
-			INSTALL_DIR ${EXTPREFIX_boost}
-
-			UPDATE_COMMAND ""
-			BUILD_IN_SOURCE 1
-		)
-		ExternalProject_Add_Step(
-			ext_boost
-			post_install
-			COMMAND ${CMAKE_COMMAND} -E copy ${PREFIX_ext_boost}/lib/boost_system-vc140-mt-1_61.dll ${PREFIX_ext_boost}/bin/boost_system-vc140-mt-1_61.dll
-			DEPENDEES install
-		)
-		
-	else()
-		ExternalProject_Add(
-			ext_boost
-
-			DOWNLOAD_DIR ${EXTERNALS_DOWNLOAD_DIR}
-			URL http://files.kde.org/krita/build/dependencies/boost_1_61_0.zip
-			URL_MD5 015ae4afa6f3e597232bfe1dab949ace
-
-			CONFIGURE_COMMAND <SOURCE_DIR>/bootstrap.bat --prefix=${PREFIX_ext_boost}
-			BUILD_COMMAND <SOURCE_DIR>/b2.exe -j${SUBMAKE_JOBS} --with-system --build-dir=build-dir --prefix=${PREFIX_ext_boost} toolset=msvc-14.0 variant=release link=shared  threading=multi architecture=x86 variant=release install
-			INSTALL_COMMAND ""
-			INSTALL_DIR ${EXTPREFIX_boost}
-
-			UPDATE_COMMAND ""
-			BUILD_IN_SOURCE 1
-        )
-        ExternalProject_Add_Step(
-			ext_boost
-			post_install
-			COMMAND ${CMAKE_COMMAND} -E copy ${PREFIX_ext_boost}/lib/boost_system-vc140-mt-1_61.dll ${PREFIX_ext_boost}/bin/boost_system-vc140-mt-1_61.dll
-			DEPENDEES install
-		)
-	endif()
-elseif(MINGW)
+if(MINGW)
    string(REGEX REPLACE "([0-9])\\.([0-9])(\\.[0-9])?" "\\1\\2"
       KRITA_boost_COMPILER_VERSION ${CMAKE_CXX_COMPILER_VERSION})
    ExternalProject_Add(
        ext_boost
 
        DOWNLOAD_DIR ${EXTERNALS_DOWNLOAD_DIR}
        URL http://files.kde.org/krita/build/dependencies/boost_1_61_0.zip
        URL_MD5 015ae4afa6f3e597232bfe1dab949ace
 
        CONFIGURE_COMMAND <SOURCE_DIR>/bootstrap.bat gcc --prefix=${PREFIX_ext_boost}
        BUILD_COMMAND <SOURCE_DIR>/b2.exe -j${SUBMAKE_JOBS} linkflags=${SECURITY_SHARED_LINKER_FLAGS} --with-system --build-dir=build-dir --prefix=${PREFIX_ext_boost} toolset=gcc variant=release link=shared  threading=multi architecture=x86 variant=release install
        INSTALL_COMMAND ""
        INSTALL_DIR ${EXTPREFIX_boost}
 
        UPDATE_COMMAND ""
        BUILD_IN_SOURCE 1
    )
    ExternalProject_Add_Step(
        ext_boost
        post_install
        COMMAND ${CMAKE_COMMAND} -E copy ${PREFIX_ext_boost}/lib/libboost_system-mgw${KRITA_boost_COMPILER_VERSION}-mt-1_61.dll ${PREFIX_ext_boost}/bin/
        DEPENDEES install
    )
 else()
 	ExternalProject_Add( ext_boost
         	DOWNLOAD_DIR ${EXTERNALS_DOWNLOAD_DIR}
 	        URL http://files.kde.org/krita/build/dependencies/boost_1_61_0.tar.bz2
         	URL_MD5 6095876341956f65f9d35939ccea1a9f
 
         	CONFIGURE_COMMAND <SOURCE_DIR>/bootstrap.sh --prefix=${PREFIX_ext_boost} --with-libraries=system
 	        BUILD_COMMAND <SOURCE_DIR>/b2 -j${SUBMAKE_JOBS} install
 	        INSTALL_COMMAND ""
         	INSTALL_DIR ${PREFIX_ext_boost}
 
 	        UPDATE_COMMAND ""
 	        BUILD_IN_SOURCE 1
 )
 endif()
diff --git a/3rdparty/ext_drmingw/CMakeLists.txt b/3rdparty/ext_drmingw/CMakeLists.txt
index 70f9bf1405..8c5ae34225 100644
--- a/3rdparty/ext_drmingw/CMakeLists.txt
+++ b/3rdparty/ext_drmingw/CMakeLists.txt
@@ -1,46 +1,46 @@
 SET (PREFIX_ext_drmingw "${EXTPREFIX}")
-if (MSVC OR MINGW)
+if (MINGW)
     ExternalProject_Add(ext_drmingw
         DOWNLOAD_DIR ${EXTERNALS_DOWNLOAD_DIR}
         URL https://files.kde.org/krita/build/dependencies/drmingw-25e5211.zip
         URL_HASH SHA1=d7c0480344801b431146ee29ff3a18e43bd29271
 
         INSTALL_DIR ${PREFIX_ext_drmingw}
         CMAKE_ARGS -DCMAKE_DISABLE_FIND_PACKAGE_PythonInterp=1 -DCMAKE_DISABLE_FIND_PACKAGE_WinDbg=1 -DCMAKE_INSTALL_PREFIX=${PREFIX_ext_drmingw} -DCMAKE_BUILD_TYPE=${GLOBAL_BUILD_TYPE} ${GLOBAL_PROFILE}
 
         UPDATE_COMMAND ""
     )
     if ("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
         ExternalProject_Add(ext_drmingw_deps
             DOWNLOAD_DIR ${EXTERNALS_DOWNLOAD_DIR}
             URL https://github.com/jrfonseca/drmingw/releases/download/0.8.1/drmingw-0.8.1-win64.7z
             URL_HASH SHA1=8be29cc7efc0d611056c3b745e7f8de30d7c8baa
 
             INSTALL_DIR ${PREFIX_ext_drmingw}
             CONFIGURE_COMMAND ""
             BUILD_COMMAND ${CMAKE_COMMAND} -E echo Deploying Dr. Mingw 64-bit dependencies
             INSTALL_COMMAND ${CMAKE_COMMAND} -E copy <SOURCE_DIR>/bin/dbghelp.dll ${PREFIX_ext_drmingw}/bin/
                     COMMAND ${CMAKE_COMMAND} -E copy <SOURCE_DIR>/bin/symsrv.dll ${PREFIX_ext_drmingw}/bin/
                     COMMAND ${CMAKE_COMMAND} -E copy <SOURCE_DIR>/bin/symsrv.yes ${PREFIX_ext_drmingw}/bin/
 
             UPDATE_COMMAND ""
         )
     else ("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
         ExternalProject_Add(ext_drmingw_deps
             DOWNLOAD_DIR ${EXTERNALS_DOWNLOAD_DIR}
             URL https://github.com/jrfonseca/drmingw/releases/download/0.8.1/drmingw-0.8.1-win32.7z
             URL_HASH SHA1=5eefeefc392cae36afb891ca81e3756aa0d79644
 
             INSTALL_DIR ${PREFIX_ext_drmingw}
             CONFIGURE_COMMAND ""
             BUILD_COMMAND ${CMAKE_COMMAND} -E echo Deploying Dr. Mingw 32-bit dependencies
             INSTALL_COMMAND ${CMAKE_COMMAND} -E copy <SOURCE_DIR>/bin/dbghelp.dll ${PREFIX_ext_drmingw}/bin/
                     COMMAND ${CMAKE_COMMAND} -E copy <SOURCE_DIR>/bin/symsrv.dll ${PREFIX_ext_drmingw}/bin/
                     COMMAND ${CMAKE_COMMAND} -E copy <SOURCE_DIR>/bin/symsrv.yes ${PREFIX_ext_drmingw}/bin/
 
             UPDATE_COMMAND ""
         )
     endif ("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
 
     add_dependencies(ext_drmingw ext_drmingw_deps)
-endif (MSVC OR MINGW)
+endif (MINGW)
diff --git a/3rdparty/ext_ffmpeg/CMakeLists.txt b/3rdparty/ext_ffmpeg/CMakeLists.txt
index 2e60c26203..d6acbbca52 100644
--- a/3rdparty/ext_ffmpeg/CMakeLists.txt
+++ b/3rdparty/ext_ffmpeg/CMakeLists.txt
@@ -1,34 +1,34 @@
 SET(PREFIX_ext_ffmpeg "${EXTPREFIX}" )
 
-if(MSVC OR MINGW)
+if(MINGW)
     if("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
         ExternalProject_Add( ext_ffmpeg
             DOWNLOAD_DIR ${EXTERNALS_DOWNLOAD_DIR}
             URL https://ffmpeg.zeranoe.com/builds/win64/static/ffmpeg-4.0-win64-static.zip
             URL_MD5 bf496481c6991c529e2e94a8e0fa3113
 
             INSTALL_DIR ${PREFIX_ext_ffmpeg}
             CONFIGURE_COMMAND ""
             BUILD_COMMAND ${CMAKE_COMMAND} -E echo deploying ffmpeg3 64-bit binary
             INSTALL_COMMAND ${CMAKE_COMMAND} -E copy <SOURCE_DIR>/bin/ffmpeg.exe ${PREFIX_ext_ffmpeg}/bin/ffmpeg.exe
                     COMMAND ${CMAKE_COMMAND} -E copy <SOURCE_DIR>/LICENSE.txt ${PREFIX_ext_ffmpeg}/bin/ffmpeg_LICENSE.txt
                     COMMAND ${CMAKE_COMMAND} -E copy <SOURCE_DIR>/README.txt ${PREFIX_ext_ffmpeg}/bin/ffmpeg_README.txt
             UPDATE_COMMAND ""
         )
     else("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
         ExternalProject_Add( ext_ffmpeg
             DOWNLOAD_DIR ${EXTERNALS_DOWNLOAD_DIR}
             URL https://ffmpeg.zeranoe.com/builds/win32/static/ffmpeg-4.0-win32-static.zip
             URL_MD5 a969a969e3404fe35100e85a37186e5f
 
             INSTALL_DIR ${PREFIX_ext_ffmpeg}
             CONFIGURE_COMMAND ""
             BUILD_COMMAND ${CMAKE_COMMAND} -E echo deploying ffmpeg3 32-bit binary
             INSTALL_COMMAND ${CMAKE_COMMAND} -E copy <SOURCE_DIR>/bin/ffmpeg.exe ${PREFIX_ext_ffmpeg}/bin/ffmpeg.exe
                     COMMAND ${CMAKE_COMMAND} -E copy <SOURCE_DIR>/LICENSE.txt ${PREFIX_ext_ffmpeg}/bin/ffmpeg_LICENSE.txt
                     COMMAND ${CMAKE_COMMAND} -E copy <SOURCE_DIR>/README.txt ${PREFIX_ext_ffmpeg}/bin/ffmpeg_README.txt
             UPDATE_COMMAND ""
         )
     endif("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
 
 endif()
diff --git a/3rdparty/ext_gettext/CMakeLists.txt b/3rdparty/ext_gettext/CMakeLists.txt
index 519c77b81f..0a010e13ea 100644
--- a/3rdparty/ext_gettext/CMakeLists.txt
+++ b/3rdparty/ext_gettext/CMakeLists.txt
@@ -1,30 +1,30 @@
 SET(PREFIX_ext_gettext "${EXTPREFIX}" )
-if (MSVC OR MINGW)
+if (MINGW)
 ExternalProject_Add(
     ext_gettext
     DOWNLOAD_DIR ${EXTERNALS_DOWNLOAD_DIR}
     URL http://files.kde.org/krita/build/dependencies/gettext-0.18.tar.gz
     URL_MD5 d52a3e061032a1ed13856d42fc86f0fd
 
     PATCH_COMMAND ${PATCH_COMMAND} --binary -p1 -i ${CMAKE_CURRENT_SOURCE_DIR}/gettext-0.18-20130319.diff
     INSTALL_DIR ${PREFIX_ext_gettext}
     CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${PREFIX_ext_gettext} -DCMAKE_BUILD_TYPE=${GLOBAL_BUILD_TYPE} ${GLOBAL_PROFILE}
 
     UPDATE_COMMAND ""
     DEPENDS ext_patch ext_iconv
 )
-else (MSVC OR MINGW)
+else (MINGW)
 ExternalProject_Add( ext_gettext
 	DOWNLOAD_DIR ${EXTERNALS_DOWNLOAD_DIR}
     URL http://files.kde.org/krita/build/dependencies/gettext-0.19.8.tar.gz
     URL_MD5 e4fffc004f21596becd1055cf36be31d
 	
 	INSTALL_DIR ${PREFIX_ext_gettext}
 	CONFIGURE_COMMAND <SOURCE_DIR>/configure --prefix=${PREFIX_ext_gettext} --disable-java   ${GLOBAL_AUTOMAKE_PROFILE} --disable-native-java 
         BUILD_COMMAND make
         INSTALL_COMMAND make install
 
 	UPDATE_COMMAND ""
 	DEPENDS ext_iconv
 )
-endif (MSVC OR MINGW)
+endif (MINGW)
diff --git a/3rdparty/ext_giflib/CMakeLists.txt b/3rdparty/ext_giflib/CMakeLists.txt
index 75d147d7c1..4d9bab2370 100644
--- a/3rdparty/ext_giflib/CMakeLists.txt
+++ b/3rdparty/ext_giflib/CMakeLists.txt
@@ -1,27 +1,27 @@
 SET(PREFIX_ext_giflib "${EXTPREFIX}" )
-if (MINGW OR MSVC)
+if (MINGW )
 ExternalProject_Add(
     ext_giflib
     DOWNLOAD_DIR ${EXTERNALS_DOWNLOAD_DIR}
     URL http://files.kde.org/krita/build/dependencies/giflib-5.1.4.tar.bz2
     URL_MD5 2c171ced93c0e83bb09e6ccad8e3ba2b
 
     PATCH_COMMAND ${PATCH_COMMAND} -p1 -i ${CMAKE_CURRENT_SOURCE_DIR}/giflib-5.1.4-20180220.diff
     CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${PREFIX_ext_giflib} -DCMAKE_BUILD_TYPE=${GLOBAL_BUILD_TYPE} ${GLOBAL_PROFILE} -DBUILD_utils=OFF
 
     UPDATE_COMMAND ""
 )
 else()
 ExternalProject_Add(
     ext_giflib
     DOWNLOAD_DIR ${EXTERNALS_DOWNLOAD_DIR}
     URL http://files.kde.org/krita/build/dependencies/giflib-5.1.4.tar.bz2
     URL_MD5 2c171ced93c0e83bb09e6ccad8e3ba2b
 
     CONFIGURE_COMMAND <SOURCE_DIR>/configure --prefix=${PREFIX_ext_giflib}   ${GLOBAL_AUTOMAKE_PROFILE}
     BUILD_COMMAND make
     INSTALL_COMMAND make install
 
     UPDATE_COMMAND ""
 )
 endif()
diff --git a/3rdparty/ext_iconv/CMakeLists.txt b/3rdparty/ext_iconv/CMakeLists.txt
index 9b7f799db8..35f33a65e5 100644
--- a/3rdparty/ext_iconv/CMakeLists.txt
+++ b/3rdparty/ext_iconv/CMakeLists.txt
@@ -1,29 +1,29 @@
 SET(PREFIX_ext_iconv "${EXTPREFIX}" )
-if (MSVC OR MINGW)
+if (MINGW)
 ExternalProject_Add( ext_iconv
 	DOWNLOAD_DIR ${EXTERNALS_DOWNLOAD_DIR}
 	URL http://files.kde.org/krita/build/dependencies/win-iconv-0.0.6.tar.bz2
 	URL_MD5 1e97ed4d9e7379ff0ee22077256e8c58
 	
     INSTALL_DIR ${PREFIX_ext_iconv}
 	CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${PREFIX_ext_iconv} -DCMAKE_BUILD_TYPE=${GLOBAL_BUILD_TYPE} ${GLOBAL_PROFILE}
 
 	UPDATE_COMMAND ""
 )
 else ()
 ExternalProject_Add( ext_iconv
 	DOWNLOAD_DIR ${EXTERNALS_DOWNLOAD_DIR}
 	URL http://files.kde.org/krita/build/dependencies/libiconv-1.14.tar.gz
 	URL_MD5 e34509b1623cec449dfeb73d7ce9c6c6
 	
     INSTALL_DIR ${PREFIX_ext_iconv}
     PATCH_COMMAND ${PATCH_COMMAND} -p1 -i ${CMAKE_CURRENT_SOURCE_DIR}/iconv.diff
 	CONFIGURE_COMMAND ./configure --prefix=${PREFIX_ext_iconv}  ${GLOBAL_AUTOMAKE_PROFILE}
     BUILD_COMMAND make
     INSTALL_COMMAND make install
 	
     UPDATE_COMMAND ""
 	BUILD_IN_SOURCE 1
 )
 
 endif ()
diff --git a/3rdparty/ext_ilmbase/CMakeLists.txt b/3rdparty/ext_ilmbase/CMakeLists.txt
index dcddb90f10..a33df70142 100644
--- a/3rdparty/ext_ilmbase/CMakeLists.txt
+++ b/3rdparty/ext_ilmbase/CMakeLists.txt
@@ -1,36 +1,22 @@
 SET(PREFIX_ext_ilmbase "${EXTPREFIX}" )
 ExternalProject_Add( ext_ilmbase
         DOWNLOAD_DIR ${EXTERNALS_DOWNLOAD_DIR}
         URL http://files.kde.org/krita/build/dependencies/ilmbase-2.2.1.tar.gz
         URL_MD5 7b86128b04f0541b6bb33633e299cb44
 
         CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${PREFIX_ext_ilmbase} -DCMAKE_BUILD_TYPE=${GLOBAL_BUILD_TYPE} ${GLOBAL_PROFILE} -DNAMESPACE_VERSIONING=OFF
 
         UPDATE_COMMAND ""
 )
-
-if (MSVC)
-	ExternalProject_Add_Step(
-			ext_ilmbase
-			post_install
-			COMMAND ${CMAKE_COMMAND} -E copy ${PREFIX_ext_ilmbase}/lib/Half.dll ${PREFIX_ext_ilmbase}/bin/Half.dll
-			COMMAND ${CMAKE_COMMAND} -E copy ${PREFIX_ext_ilmbase}/lib/Iex.dll ${PREFIX_ext_ilmbase}/bin/Iex.dll
-			COMMAND ${CMAKE_COMMAND} -E copy ${PREFIX_ext_ilmbase}/lib/Imath.dll ${PREFIX_ext_ilmbase}/bin/Imath.dll
-			COMMAND ${CMAKE_COMMAND} -E copy ${PREFIX_ext_ilmbase}/lib/IlmThread.dll ${PREFIX_ext_ilmbase}/bin/IlmThread.dll
-			COMMAND ${CMAKE_COMMAND} -E copy ${PREFIX_ext_ilmbase}/lib/IexMath.dll ${PREFIX_ext_ilmbase}/bin/IexMath.dll
-			DEPENDEES install
-	)
-endif()
-
 if (MINGW)
    ExternalProject_Add_Step(
            ext_ilmbase
            post_install
            COMMAND ${CMAKE_COMMAND} -E copy ${PREFIX_ext_ilmbase}/lib/libHalf.dll ${PREFIX_ext_ilmbase}/bin/libHalf.dll
            COMMAND ${CMAKE_COMMAND} -E copy ${PREFIX_ext_ilmbase}/lib/libIex.dll ${PREFIX_ext_ilmbase}/bin/libIex.dll
            COMMAND ${CMAKE_COMMAND} -E copy ${PREFIX_ext_ilmbase}/lib/libImath.dll ${PREFIX_ext_ilmbase}/bin/libImath.dll
            COMMAND ${CMAKE_COMMAND} -E copy ${PREFIX_ext_ilmbase}/lib/libIlmThread.dll ${PREFIX_ext_ilmbase}/bin/libIlmThread.dll
            COMMAND ${CMAKE_COMMAND} -E copy ${PREFIX_ext_ilmbase}/lib/libIexMath.dll ${PREFIX_ext_ilmbase}/bin/libIexMath.dll
            DEPENDEES install
    )
 endif()
diff --git a/3rdparty/ext_jpeg/CMakeLists.txt b/3rdparty/ext_jpeg/CMakeLists.txt
index 581bd85212..076bab80f7 100644
--- a/3rdparty/ext_jpeg/CMakeLists.txt
+++ b/3rdparty/ext_jpeg/CMakeLists.txt
@@ -1,25 +1,25 @@
 SET(PREFIX_ext_jpeg "${EXTPREFIX}" )
-if (MSVC OR MINGW)
+if (MINGW)
 ExternalProject_Add( ext_jpeg
     DOWNLOAD_DIR ${EXTERNALS_DOWNLOAD_DIR}
     URL http://files.kde.org/krita/build/dependencies/libjpeg-turbo-1.5.3.tar.gz
     URL_MD5 7c82f0f6a3130ec06b8a4d0b321cbca3
         
     INSTALL_DIR ${PREFIX_ext_jpeg}
     CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${PREFIX_ext_jpeg} -DWITH_SIMD=OFF -DCMAKE_BUILD_TYPE=${GLOBAL_BUILD_TYPE} ${GLOBAL_PROFILE}
 
     UPDATE_COMMAND ""
 )
 else()
 ExternalProject_Add( ext_jpeg
     DOWNLOAD_DIR ${EXTERNALS_DOWNLOAD_DIR}
     URL http://files.kde.org/krita/build/dependencies/libjpeg-turbo-1.5.3.tar.gz
     URL_MD5 7c82f0f6a3130ec06b8a4d0b321cbca3
   
     CONFIGURE_COMMAND <SOURCE_DIR>/configure --prefix=${PREFIX_ext_jpeg}  ${GLOBAL_AUTOMAKE_PROFILE} --without-simd
     BUILD_COMMAND make
     INSTALL_COMMAND make install      
 
     UPDATE_COMMAND ""
 )
 endif()
diff --git a/3rdparty/ext_lcms2/CMakeLists.txt b/3rdparty/ext_lcms2/CMakeLists.txt
index 0ce8c798a3..f9c69fcdf2 100644
--- a/3rdparty/ext_lcms2/CMakeLists.txt
+++ b/3rdparty/ext_lcms2/CMakeLists.txt
@@ -1,27 +1,27 @@
 SET(PREFIX_ext_lcms2 "${EXTPREFIX}" )
-if (MSVC OR MINGW)
+if (MINGW)
 ExternalProject_Add( ext_lcms2
 	DOWNLOAD_DIR ${EXTERNALS_DOWNLOAD_DIR}
 	URL http://files.kde.org/krita/build/dependencies/lcms2-2.9.tar.gz
     URL_MD5 8de1b7724f578d2995c8fdfa35c3ad0e
 		
     PATCH_COMMAND ${PATCH_COMMAND} -p1 -i ${CMAKE_CURRENT_SOURCE_DIR}/lcms2-9.diff
 	INSTALL_DIR ${PREFIX_ext_lcms2}
 	CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${PREFIX_ext_lcms2} -DCMAKE_BUILD_TYPE=${GLOBAL_BUILD_TYPE} ${GLOBAL_PROFILE} -DBUILD_TESTS=FALSE -DBUILD_UTILS=FALSE -DBUILD_STATIC=FALSE
 	
     UPDATE_COMMAND ""
 	DEPENDS ext_patch
 )
-else (MSVC OR MINGW)
+else ()
 ExternalProject_Add( ext_lcms2
 	DOWNLOAD_DIR ${EXTERNALS_DOWNLOAD_DIR}
 	URL http://files.kde.org/krita/build/dependencies/lcms2-2.9.tar.gz
     URL_MD5 8de1b7724f578d2995c8fdfa35c3ad0e
 		
     PATCH_COMMAND ${PATCH_COMMAND} -p1 -i ${CMAKE_CURRENT_SOURCE_DIR}/lcms2-9.diff
 	INSTALL_DIR ${PREFIX_ext_lcms2}
 	CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${PREFIX_ext_lcms2} -DCMAKE_BUILD_TYPE=${GLOBAL_BUILD_TYPE} ${GLOBAL_PROFILE} -DBUILD_TESTS=FALSE -DBUILD_UTILS=FALSE -DBUILD_STATIC=FALSE
 	
     UPDATE_COMMAND ""
 )
-endif (MSVC OR MINGW)
+endif ()
diff --git a/3rdparty/ext_ocio/CMakeLists.txt b/3rdparty/ext_ocio/CMakeLists.txt
index afedead262..edb402849d 100644
--- a/3rdparty/ext_ocio/CMakeLists.txt
+++ b/3rdparty/ext_ocio/CMakeLists.txt
@@ -1,35 +1,35 @@
 #
 # The latest opencolorio doesn't build on Windows without using boost::ptr, but if you build
 # it with boost::ptr, you cannot link to it because of missing dll exports, so build an older
 # ocio on Windows.
 #
 SET(EXTPREFIX_ocio "${EXTPREFIX}" )
-if (MSVC OR MINGW)
+if (MINGW)
 ExternalProject_Add(
     ext_ocio
     DOWNLOAD_DIR ${EXTERNALS_DOWNLOAD_DIR}
     URL http://files.kde.org/krita/build/dependencies/OpenColorIO-master.zip
     URL_MD5 7065faa41103ed27f5ea9b01b9e14c91
 
     INSTALL_DIR ${EXTPREFIX_ocio}
     PATCH_COMMAND ${PATCH_COMMAND} -p1 -i ${CMAKE_CURRENT_SOURCE_DIR}/patch.diff
 
     CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${EXTPREFIX_ocio} -DCMAKE_BUILD_TYPE=${GLOBAL_BUILD_TYPE} ${GLOBAL_PROFILE} -DOCIO_BUILD_APPS=OFF -DOCIO_BUILD_TRUELIGHT=OFF -DOCIO_BUILD_NUKE=OFF -DOCIO_BUILD_DOCS=OFF -DOCIO_BUILD_TESTS=OFF -DOCIO_BUILD_PYGLUE=OFF -DOCIO_BUILD_STATIC_JNIGLUE=OFF
 
     UPDATE_COMMAND ""
     DEPENDS ext_boost
 )
 else()
 ExternalProject_Add(
     ext_ocio
     DOWNLOAD_DIR ${EXTERNALS_DOWNLOAD_DIR}
     URL http://files.kde.org/krita/build/dependencies/OpenColorIO-master.zip
     URL_MD5 7065faa41103ed27f5ea9b01b9e14c91
 
     INSTALL_DIR ${EXTPREFIX_ocio}
     CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${EXTPREFIX_ocio} -DCMAKE_BUILD_TYPE=${GLOBAL_BUILD_TYPE} ${GLOBAL_PROFILE} -DOCIO_BUILD_APPS=OFF -DOCIO_BUILD_TRUELIGHT=OFF -DOCIO_BUILD_NUKE=OFF -DOCIO_BUILD_DOCS=OFF -DOCIO_BUILD_TESTS=OFF -DOCIO_BUILD_PYGLUE=OFF -DOCIO_BUILD_STATIC_JNIGLUE=OFF
 
     UPDATE_COMMAND ""
     DEPENDS ext_boost
 )
 endif()
diff --git a/3rdparty/ext_openexr/CMakeLists.txt b/3rdparty/ext_openexr/CMakeLists.txt
index d5050e4a06..f1b0c31a17 100644
--- a/3rdparty/ext_openexr/CMakeLists.txt
+++ b/3rdparty/ext_openexr/CMakeLists.txt
@@ -1,31 +1,31 @@
 SET(EXTPREFIX_openexr "${EXTPREFIX}" )
-if (MSVC OR MINGW)
+if (MINGW)
 ExternalProject_Add( ext_openexr
         DOWNLOAD_DIR ${EXTERNALS_DOWNLOAD_DIR}
         URL http://files.kde.org/krita/build/dependencies/openexr-2.2.1.tar.gz
         URL_MD5 421815c32989e1b98fc4798ee754c433
 
         PATCH_COMMAND ${PATCH_COMMAND} -p1 -i ${CMAKE_CURRENT_SOURCE_DIR}/openexr.diff
               COMMAND ${PATCH_COMMAND} -p1 -i ${CMAKE_CURRENT_SOURCE_DIR}/patch_mingw.patch
 
         INSTALL_DIR ${EXTPREFIX_openexr}
         CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${EXTPREFIX_openexr} -DILMBASE_PACKAGE_PREFIX=${EXTPREFIX_openexr} -DCMAKE_BUILD_TYPE=${GLOBAL_BUILD_TYPE} ${GLOBAL_PROFILE} -DNAMESPACE_VERSIONING=OFF
 
         UPDATE_COMMAND ""
         DEPENDS ext_ilmbase ext_zlib
 )
 else()
 ExternalProject_Add(ext_openexr
         DOWNLOAD_DIR ${EXTERNALS_DOWNLOAD_DIR}
         URL http://files.kde.org/krita/build/dependencies/openexr-2.2.1.tar.gz
         URL_MD5 421815c32989e1b98fc4798ee754c433
 
         PATCH_COMMAND ${PATCH_COMMAND} -p1 -i ${CMAKE_CURRENT_SOURCE_DIR}/openexr.diff
 
         INSTALL_DIR ${EXTPREFIX_openexr}
         CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${EXTPREFIX_openexr} -DILMBASE_PACKAGE_PREFIX=${EXTPREFIX_openexr} -DCMAKE_BUILD_TYPE=${GLOBAL_BUILD_TYPE} ${GLOBAL_PROFILE} -DNAMESPACE_VERSIONING=OFF
 
         UPDATE_COMMAND ""
         DEPENDS ext_ilmbase
 )
 endif()
diff --git a/README.md b/README.md
index cf9cd94f2b..16721489d9 100644
--- a/README.md
+++ b/README.md
@@ -1,47 +1,45 @@
 ![Picture](https://krita.org/wp-content/uploads/2016/04/krita_logo_200-ef21fd67a8add4f0.png)
 
 Krita is a free and open source digital painting application. It is for artists who want to create professional work from start to end. Krita is used by comic book artists, illustrators, concept artists, matte and texture painters and in the digital VFX industry.
 
 If you are reading this on Github, be aware that this is just a mirror. Our real
 code repository is provided by KDE: https://phabricator.kde.org/source/krita/ 
 
-This repository contains the current, Qt5-based, development version of Krita 3. Krita 3.0 has been released and development on Krita 2.9 has stopped.  Krita 2.9 was part of Calligra: https://phabricator.kde.org/source/krita/
-
 ![Picture](https://krita.org/wp-content/uploads/2016/04/krita-30-screenshot.jpg)
 
 
 ### User Manual
 https://docs.krita.org/en/user_manual.html
 
 ### Development Notes and Build Instructions
 If you're building on Windows or OSX you'll need to build some third-party dependencies first. You should look at the README in the 3rdparty folder for directions. 
 
 If you're building on Linux, please follow David Revoy's Cat Guide: http://www.davidrevoy.com/article193/guide-building-krita-on-linux-for-cats
 
 Other developer guides, notes and wiki:
 
 https://community.kde.org/Krita
 
 Apidox:
 
 https://api.kde.org/extragear-api/graphics-apidocs/krita/html/index.html
 
 ### Bugs and Wishes
 
 https://bugs.kde.org/buglist.cgi?bug_status=UNCONFIRMED&bug_status=CONFIRMED&bug_status=ASSIGNED&bug_status=REOPENED&list_id=1315444&product=krita&query_format=advanced
 
 ### Discussion Forum
 http://forum.kde.org/viewforum.php?f=136
 
 ### IRC channel
 Most of the developers hang out here. If you are interested in helping with the project this is a great place to start. Many of the developers based in Europe so they may be offline depending on when you join.
 
 irc.freenode.net, #krita
 
 ### Project Website
 
   http://www.krita.org
 
 ### License
 
 Krita as a whole is licensed under the GNU Public License, Version 3. Individual files may have a different, but compatible license.
diff --git a/README_PACKAGERS.md b/README_PACKAGERS.md
deleted file mode 100644
index c688d58de7..0000000000
--- a/README_PACKAGERS.md
+++ /dev/null
@@ -1,71 +0,0 @@
-= Notes for Packagers =
-
-== Patching Qt ==
-
-Qt 5.6 is currently the recommended version to build Krita with on all platforms. However, Qt 5.6 on Linux needs to be patched for https://bugreports.qt.io/browse/QTBUG-44964 .
-
-The patch in 3rdparty/ext_qt/qt-no-motion-compression.diff 
-
-
-== Package Contents ==
-
-We recommend that all of Krita packaged in one package: there is no need to split Krita up. In particular, do not make a separate package out of the plugins directory; without the plugins Krita will not even start.
-
-Krita does not install header files, so there is no need for a corresponding -dev(el) package.
-
-== Third Party Libraries ==
-
-The top-level 3rd-party directory is not relevant for packaging: it only contains CMake projects for all of Krita's dependencies which are used for building Krita on Windows and OSX. It is not called from the top-level CMakeLists.txt project.
-
-There are four forks of 3rd party libraries that are relevant and cannot be replaced by system libraries:
-
-* plugins/impex/raw/3rdparty contains a fork of kdcraw. Upstream removed most functionality from this library and is in general unable to provide a stable API. The library has been renamed to avoid conflicts with upstream kdcraw.
-
-* plugins/impex/xcf/3rdparty contains the xcftools code. This has never been released as a library
-
-* libs/image/3rdparty contains einspline. This code is directly linked into the kritaimage library and has never been released as a separate library.
-
-== Build flags ==
-
-Krita no longer supports a build without OpenGL.
-
-For alpha and beta packages, please build with debug output enabled, but for production packages the -DCMAKE_CXX_FLAGS="-DKDE_NO_DEBUG_OUTPUT" is recommended. A significant performance increase will be the result.
-
-If you build Krita with RelWithDebInfo to be able to create a corresponding  -dbg package, please define -DQT_NO_DEBUG=1 as well to disable asserts. 
-
-== Dependencies ==
-
-Krita depends on:
-
-  * boost and the boost-system library        
-  * eigen3       
-  * exiv2   
-  * fftw3   
-  * gsl       
-  * ilmbase   
-  * jpeg: Note that libjpeg-turbo is recommended.       
-  * lcms2     
-  * libraw    
-  * opencolorio
-  * openexr   
-  * png        
-  * poppler-qt5
-  * pthreads   
-  * qt-5: Note that Qt 5.6 is _strongly_ recommended. Qt 5.5 has bugs that interfere with proper handling of tablet events
-  * tiff  
-  * vc: this is a build-time dependency only
-  * zlib
-
-And the following KDE Frameworks:
-
- * Archive 
- * Completion
- * Config 
- * CoreAddons
- * GuiAddons 
- * I18n 
- * ItemModels 
- * ItemViews
- * KCrash
- * WidgetsAddons 
- * WindowSystem
diff --git a/build-tools/docker/.gitignore b/build-tools/docker/.gitignore
deleted file mode 100644
index f050bccf3b..0000000000
--- a/build-tools/docker/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-persistent
diff --git a/build-tools/docker/Dockerfile b/build-tools/docker/Dockerfile
deleted file mode 100644
index 8682392bed..0000000000
--- a/build-tools/docker/Dockerfile
+++ /dev/null
@@ -1,44 +0,0 @@
-FROM kdeorg/appimage-base
-
-MAINTAINER Dmitry Kazakov <dimula73@gmail.com>
-RUN apt-get update && \
-    apt-get -y install curl && \
-    apt-get -y install emacs24-nox && \
-    apt-get -y install gitk git-gui && \
-    apt-get -y install cmake3-curses-gui gdb valgrind sysvinit-utils && \
-    apt-get -y install mirage && \
-    apt-get -y install mesa-utils
-
-ENV USRHOME=/home/appimage
-
-RUN chsh -s /bin/bash appimage
-
-RUN locale-gen en_US.UTF-8
-
-RUN echo 'export LC_ALL=en_US.UTF-8' >> ${USRHOME}/.bashrc && \
-    echo 'export LANG=en_US.UTF-8'  >> ${USRHOME}/.bashrc && \
-    echo "export PS1='\u@\h:\w>'"  >> ${USRHOME}/.bashrc && \
-    echo 'source ~/devenv.inc' >> ${USRHOME}/.bashrc && \
-    echo 'prepend PATH ~/bin/' >> ${USRHOME}/.bashrc
-
-RUN mkdir -p ${USRHOME}/appimage-workspace/krita-inst && \
-    mkdir -p ${USRHOME}/appimage-workspace/krita-build && \
-    mkdir -p ${USRHOME}/bin
-
-COPY ./default-home/devenv.inc \
-     ./default-home/.bash_aliases \
-     ${USRHOME}/
-
-COPY ./default-home/run_cmake.sh \
-     ${USRHOME}/bin
-
-ADD persistent/krita-appimage-deps.tar ${USRHOME}/appimage-workspace/
-
-RUN chown appimage:appimage -R ${USRHOME}/
-RUN chmod a+rwx /tmp
-
-USER appimage
-
-CMD tail -f /dev/null
-
-
diff --git a/build-tools/docker/README.md b/build-tools/docker/README.md
index 55054b94fe..b96868d723 100644
--- a/build-tools/docker/README.md
+++ b/build-tools/docker/README.md
@@ -1,125 +1,10 @@
-# Krita developer environment Docker image
+# [MOVED] Krita developer environment Docker image
 
-This *Dockerfile* is based on the official KDE build environmet [0]
-that in used on KDE CI for building official AppImage packages.
-Therefore running this image in a docker container is the best way
-to reproduce AppImage-only bugs in Krita.
+The official Krita developers docker image has been moved into
+a separate repository:
 
-[0] - https://binary-factory.kde.org/job/Krita_Nightly_Appimage_Dependency_Build/
+https://cgit.kde.org/scratch/dkazakov/krita-docker-env.git/
 
-## Prerequisites
+Here is a direct link to the README.md file:
 
-Firstly make sure you have Docker installed
-
-```bash
-sudo apt install docker docker.io
-```
-
-Then you need to download deps and Krita source tree. These steps are not
-included into the *Dockerfile* to save internal bandwidth (most Krita
-developers already have al least one clone of Krita source tree).
-
-```bash
-# create directory structure for container control directory
-mkdir -p krita-master/persistent
-cd krita-master
-
-# copy/chechout Krita sources to 'persistent/krita'
-cp -r /path/to/sources/krita ./persistent/krita
-
-# initialize control scripts and the Dockerfile
-./persistent/krita/build-tools/docker/bin/bootstrap-root.sh
-
-# download the deps archive
-./bin/bootstrap-deps.sh
-```
-
-## Build the docker image and run the container
-
-```bash
-./bin/build_image krita-deps
-./bin/run_container krita-deps krita-master
-```
-
-## Enter the container and build Krita
-
-```bash
-# enter the docker container (the name will be
-# fetched automatically from '.container_name' file)
-
-./bin/enter
-
-# ... now your are inside the container with all the deps prepared ...
-
-# build Krita as usual
-cd appimage-workspace/krita-build/
-run_cmake.sh ~/persistent/krita
-make -j8 install
-
-# start Krita
-krita
-
-```
-
-## Extra developer tools
-
-To install QtCreator, enter container and start the installer, downloaded while
-fetching dependencies. Make sure you install it into '~/qtcreator' directory
-without any version suffixes, then you will be able to use the script below:
-
-```bash
-# inside the container
-./persistent/qt-creator-opensource-linux-x86_64-4.6.2.run
-```
-
-To start QtCreator:
-
-```bash
-# from the host
-./bin/qtcreator
-```
-
-## Stopping the container and cleaning up
-
-When not in use you can stop the container. All your filesystem state is saved, but
-all the currently running processes are killed (just ensure you logout from all the
-terminals before stopping).
-
-```bash
-# stop the container
-./bin/stop
-
-# start the container
-./bin/start
-```
-
-If you don't need your container/image anymore, you can delete them from the docker
-
-```bash
-# remove the container
-sudo docker rm krita-master
-
-# remove the image
-sudo docker rmi krita-deps
-```
-
-TODO: do we need some extra cleaups for docker's caches?
-
-
-## Troubleshooting
-
-### Krita binary is not found after the first build
-
-Either relogin to the container or just execute `source ~/.devenv.inc`
-
-
-### Not enough space on root partition
-
-All the docker images and containers are stored in a special docker-daemon controlled
-folder under */var* directory. You might not have enough space there for building Krita
-(it needs about 10 GiB). In such a case it is recommended to move the docker images
-folder into another location, where there is enough space.
-
-```bash
-echo 'DOCKER_OPTS="-g /home/devel5/docker"' >> /etc/default/docker
-```
+https://cgit.kde.org/scratch/dkazakov/krita-docker-env.git/tree/README.md
diff --git a/build-tools/docker/bin/bootstrap-deps.sh b/build-tools/docker/bin/bootstrap-deps.sh
deleted file mode 100755
index b4bb707821..0000000000
--- a/build-tools/docker/bin/bootstrap-deps.sh
+++ /dev/null
@@ -1,23 +0,0 @@
-#!/bin/bash
-
-if [ ! -d ./persistent ]; then
-    mkdir ./persistent
-fi
-
-if [ ! -f ./persistent/krita-appimage-deps.tar ]; then
-    (
-        cd ./persistent/
-        wget https://binary-factory.kde.org/job/Krita_Nightly_Appimage_Dependency_Build/lastSuccessfulBuild/artifact/krita-appimage-deps.tar || exit 1
-    )
-fi
-
-creator_major=4.6
-creator_minor=2
-creator_file=qt-creator-opensource-linux-x86_64-${creator_major}.${creator_minor}.run
-if [ ! -f ./persistent/${creator_file} ]; then
-    (
-        cd ./persistent/
-        wget http://download.qt.io/official_releases/qtcreator/${creator_major}/${creator_major}.${creator_minor}/${creator_file} || exit 1
-        chmod a+x ${creator_file}
-    )
-fi
diff --git a/build-tools/docker/bin/bootstrap-root.sh b/build-tools/docker/bin/bootstrap-root.sh
deleted file mode 100755
index ef810f3fe5..0000000000
--- a/build-tools/docker/bin/bootstrap-root.sh
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/bin/bash
-
-if [ -d ./persistent/krita ]; then
-   for i in 'bin default-home'; do
-       if [ ! -d "$i" ]; then
-          mkdir $i
-       fi
-   done
-
-   cp persistent/krita/build-tools/docker/bin/* ./bin/
-   cp persistent/krita/build-tools/docker/default-home/{,.}* ./default-home/
-   cp persistent/krita/build-tools/docker/Dockerfile ./
-   cp persistent/krita/build-tools/docker/README.md ./
-fi
diff --git a/build-tools/docker/bin/build_image b/build-tools/docker/bin/build_image
deleted file mode 100755
index 47f6772ebb..0000000000
--- a/build-tools/docker/bin/build_image
+++ /dev/null
@@ -1,8 +0,0 @@
-#!/bin/bash
-
-if [ "$#" -ne 1 ]; then
-  echo "Usage: $0 IMAGE_NAME" >&2
-  exit 1
-fi
-
-sudo docker build -t $1 .
diff --git a/build-tools/docker/bin/enter b/build-tools/docker/bin/enter
deleted file mode 100755
index 4ae54c6f62..0000000000
--- a/build-tools/docker/bin/enter
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/bin/bash
-
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-source ${DIR}/find_default_container_file.inc
-
-container_name=$(parseContainerArgs $*)
-if [ -z ${container_name} ]; then
-    exit 1
-fi
-
-sudo docker exec -ti ${container_name} sh -c "cd /home/appimage && /bin/bash -l"
diff --git a/build-tools/docker/bin/find_default_container_file.inc b/build-tools/docker/bin/find_default_container_file.inc
deleted file mode 100644
index 39b520a9bf..0000000000
--- a/build-tools/docker/bin/find_default_container_file.inc
+++ /dev/null
@@ -1,30 +0,0 @@
-#!/bin/bash
-
-function findContainerName {
-    DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-    container_file=`${DIR}/find_up ./ -name .container_name`
-
-    if [ ! -z ${container_file} ]; then
-        cat ${container_file}
-    fi
-}
-
-function parseContainerArgs {
-    container_name=
-
-    if [ "$#" -ne 1 ]; then
-        if [ "$#" -eq 0 ]; then
-            DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-            container_name=$(findContainerName)
-        fi
-
-        if [ -z ${container_name} ]; then
-            echo "Usage: $0 CONTAINER_NAME" >&2
-            exit 1
-        fi
-    else
-        container_name=$1
-    fi
-    echo ${container_name}
-}
-
diff --git a/build-tools/docker/bin/find_up b/build-tools/docker/bin/find_up
deleted file mode 100755
index 11d120290a..0000000000
--- a/build-tools/docker/bin/find_up
+++ /dev/null
@@ -1,10 +0,0 @@
-#!/bin/bash
-set -e
-path="$1"
-shift 1
-while [[ $path != / ]];
-do
-    find "$path" -maxdepth 1 -mindepth 1 "$@"
-    # Note: if you want to ignore symlinks, use "$(realpath -s "$path"/..)"
-    path="$(readlink -f "$path"/..)"
-done
diff --git a/build-tools/docker/bin/install_nvidia_drivers.sh b/build-tools/docker/bin/install_nvidia_drivers.sh
deleted file mode 100755
index 8e7e869e17..0000000000
--- a/build-tools/docker/bin/install_nvidia_drivers.sh
+++ /dev/null
@@ -1,33 +0,0 @@
-#!/bin/bash
-
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-source ${DIR}/find_default_container_file.inc
-
-container_name=$(parseContainerArgs $*)
-if [ -z ${container_name} ]; then
-    exit 1
-fi
-
-if [ ! -e /proc/driver/nvidia/version ]; then
-    echo "Cannot find NVIDIA bestion file: /proc/driver/nvidia/version"
-    exit 1
-fi
-
-nvidia_version=$(cat /proc/driver/nvidia/version | head -n 1 | awk '{ print $8 }')
-driver_file=NVIDIA-Linux-x86_64-${nvidia_version}.run
-driver_url=http://download.nvidia.com/XFree86/Linux-x86_64/${nvidia_version}/${driver_file}
-
-if [ ! -f persistent/${driver_file} ]; then
-    (
-        cd persistent
-        wget http://download.nvidia.com/XFree86/Linux-x86_64/${nvidia_version}/${driver_file} || exit 1
-        chmod a+x ${driver_file}
-    )
-fi
-
-if [ -f persistent/${driver_file} ]; then
-    sudo docker exec -ti -u root ${container_name} /home/appimage/persistent/${driver_file} -a -N --ui=none --no-kernel-module -s
-else
-    echo "Cannot find the driver file: ${driver_file}"
-    exit 1
-fi
diff --git a/build-tools/docker/bin/qtcreator b/build-tools/docker/bin/qtcreator
deleted file mode 100755
index 453169e057..0000000000
--- a/build-tools/docker/bin/qtcreator
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/bin/bash
-
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-source ${DIR}/find_default_container_file.inc
-
-container_name=$(parseContainerArgs $*)
-if [ -z ${container_name} ]; then
-    exit 1
-fi
-
-sudo docker exec -ti ${container_name} /bin/bash -c 'source /home/appimage/devenv.inc; /home/appimage/qtcreator/bin/qtcreator.sh'
diff --git a/build-tools/docker/bin/run_container b/build-tools/docker/bin/run_container
deleted file mode 100755
index d0eee8faba..0000000000
--- a/build-tools/docker/bin/run_container
+++ /dev/null
@@ -1,31 +0,0 @@
-#!/bin/bash
-
-if [ "$#" -ne 2 ]; then
-  echo "Usage: $0 IMAGE_NAME CONTAINER_NAME" >&2
-  exit 1
-fi
-
-NVIDIA_OPTS=
-if [ -e /dev/nvidiactl ]; then
-   NVIDIA_OPTS+="--device /dev/nvidia0 --device /dev/nvidiactl --device /dev/nvidia-uvm"
-fi
-
-sudo docker run -P -t -d \
-  -v $(pwd)/persistent/:/home/appimage/persistent/:rw \
-  -v /tmp/.X11-unix/:/tmp/.X11-unix \
-  -v /home/$USER/.Xauthority:/home/appimage/.Xauthority \
-  -v /etc/localtime:/etc/localtime:ro \
-  -e DISPLAY=$DISPLAY \
-  -h $HOSTNAME \
-  --cap-add=SYS_PTRACE \
-  --security-opt seccomp=unconfined \
-  --device /dev/dri \
-  --device /dev/snd \
-  $NVIDIA_OPTS \
-  --name $2 \
-  $1 || exit 1
-
-if [ ! -f .container_name ]; then
-    echo $2 > .container_name
-fi
-
diff --git a/build-tools/docker/bin/start b/build-tools/docker/bin/start
deleted file mode 100755
index 781b1a395b..0000000000
--- a/build-tools/docker/bin/start
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/bin/bash
-
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-source ${DIR}/find_default_container_file.inc
-
-container_name=$(parseContainerArgs $*)
-if [ -z ${container_name} ]; then
-    exit 1
-fi
-
-sudo docker start ${container_name}
diff --git a/build-tools/docker/bin/stop b/build-tools/docker/bin/stop
deleted file mode 100755
index eed1ec8474..0000000000
--- a/build-tools/docker/bin/stop
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/bin/bash
-
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-source ${DIR}/find_default_container_file.inc
-
-container_name=$(parseContainerArgs $*)
-if [ -z ${container_name} ]; then
-    exit 1
-fi
-
-sudo docker stop ${container_name}
diff --git a/build-tools/docker/bin/sudoenter b/build-tools/docker/bin/sudoenter
deleted file mode 100755
index 0c1bbc4ca2..0000000000
--- a/build-tools/docker/bin/sudoenter
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/bin/bash
-
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-source ${DIR}/find_default_container_file.inc
-
-container_name=$(parseContainerArgs $*)
-if [ -z ${container_name} ]; then
-    exit 1
-fi
-
-sudo docker exec -user root -ti ${container_name} sh -c "cd /home/appimage && /bin/bash -l"
diff --git a/build-tools/docker/default-home/.bash_aliases b/build-tools/docker/default-home/.bash_aliases
deleted file mode 100644
index 766e667f0e..0000000000
--- a/build-tools/docker/default-home/.bash_aliases
+++ /dev/null
@@ -1,38 +0,0 @@
-alias ll='ls -alF'
-alias la='ls -A'
-alias l='ls -CF'
-
-alias ..='cd ..'
-alias ...='cd ../..'
-alias ....='cd ../../..'
-
-alias gdba='gdb --args'
-alias gdbr='gdb --eval-command=r --args'
-alias gdbrk='gdb --eval-command=r --args krita'
-alias gdbatt='gdb --eval-command=cont --pid=$(pidof krita)'
-
-function tst {
-    make -j8 $1 && ./$1 $2 $3 $4 $5 $6 $7 $8
-}
-
-function tsti {
-    make -j8 -C .. && make -j1 -C .. install/fast && ./$1 $2 $3 $4 $5 $6 $7 $8
-}
-
-function tstfast {
-    make -j8 $1/fast && ./$1 $2 $3 $4 $5 $6 $7 $8
-}
-
-function mi {
-    make -j8 && make -j1 install/fast
-}
-
-function mik {
-    make -j8 && make -j1 install/fast && krita $*
-}
-
-function nmik {
-    nice make -j8 && nice make -j1 install/fast && krita $*
-}
-
-
diff --git a/build-tools/docker/default-home/devenv.inc b/build-tools/docker/default-home/devenv.inc
deleted file mode 100644
index d6acdca85f..0000000000
--- a/build-tools/docker/default-home/devenv.inc
+++ /dev/null
@@ -1,26 +0,0 @@
-prepend() { [ -d "$2" ] && eval $1=\"$2\$\{$1:+':'\$$1\}\" && export $1 ; }
-
-export KRITADIR=/home/appimage/appimage-workspace/krita-inst
-export DEPSDIR=/home/appimage/appimage-workspace/deps/usr
-
-
-prepend PATH $KRITADIR/bin
-prepend LD_LIBRARY_PATH $KRITADIR/lib64
-prepend LD_LIBRARY_PATH $KRITADIR/lib
-#prepend XDG_DATA_DIRS $KRITADIR/share
-prepend PKG_CONFIG_PATH $KRITADIR/lib64/pkgconfig
-prepend PKG_CONFIG_PATH $KRITADIR/lib/pkgconfig
-
-prepend PATH $DEPSDIR/bin
-prepend LD_LIBRARY_PATH $DEPSDIR/lib64
-prepend LD_LIBRARY_PATH $DEPSDIR/lib
-#prepend XDG_DATA_DIRS $DEPSDIR/share
-prepend PKG_CONFIG_PATH $DEPSDIR/lib64/pkgconfig
-prepend PKG_CONFIG_PATH $DEPSDIR/lib/pkgconfig
-
-prepend CMAKE_PREFIX_PATH $DEPSDIR
-
-#prepend PYTHONPATH $DEPSDIR/lib/python3.5/
-prepend PYTHONPATH $DEPSDIR/sip
-
-#prepend PYQT_SIP_DIR_OVERRIDE $DEPSDIR/share/sip
diff --git a/build-tools/docker/default-home/run_cmake.sh b/build-tools/docker/default-home/run_cmake.sh
deleted file mode 100755
index 8b8a7f6666..0000000000
--- a/build-tools/docker/default-home/run_cmake.sh
+++ /dev/null
@@ -1,8 +0,0 @@
-#!/bin/bash
-
-cmake -DCMAKE_INSTALL_PREFIX=${KRITADIR} \
-      -DCMAKE_BUILD_TYPE=RelWithDebInfo \
-      -DBUILD_TESTING=TRUE \
-      -DHIDE_SAFE_ASSERTS=FALSE \
-      -DPYQT_SIP_DIR_OVERRIDE=~/appimage-workspace/deps/usr/share/sip \
-      $@
diff --git a/cmake/modules/KritaAddBrokenUnitTest.cmake b/cmake/modules/KritaAddBrokenUnitTest.cmake
index c3c89a81b3..b7d0e8d852 100644
--- a/cmake/modules/KritaAddBrokenUnitTest.cmake
+++ b/cmake/modules/KritaAddBrokenUnitTest.cmake
@@ -1,53 +1,84 @@
 include(CMakeParseArguments)
 include(ECMMarkAsTest)
 include(ECMMarkNonGuiExecutable)
 
 
 # modified version of ECMAddTests.cmake in cmake-extra-modules
 function(KRITA_ADD_BROKEN_UNIT_TEST)
   set(options GUI)
   # TARGET_NAME_VAR and TEST_NAME_VAR are undocumented args used by
   # ecm_add_tests
   set(oneValueArgs TEST_NAME NAME_PREFIX TARGET_NAME_VAR TEST_NAME_VAR)
   set(multiValueArgs LINK_LIBRARIES)
   cmake_parse_arguments(ARG "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
   set(_sources ${ARG_UNPARSED_ARGUMENTS})
   list(LENGTH _sources _sourceCount)
   if(ARG_TEST_NAME)
     set(_targetname ${ARG_TEST_NAME})
   elseif(${_sourceCount} EQUAL "1")
     #use the source file name without extension as the testname
     get_filename_component(_targetname ${_sources} NAME_WE)
   else()
     #more than one source file passed, but no test name given -> error
     message(FATAL_ERROR "ecm_add_test() called with multiple source files but without setting \"TEST_NAME\"")
   endif()
 
   set(_testname ${ARG_NAME_PREFIX}${_targetname})
 
   # add test to the global list of disabled tests
   set(KRITA_BROKEN_TESTS ${KRITA_BROKEN_TESTS} ${_testname} CACHE INTERNAL "KRITA_BROKEN_TESTS")
 
   set(gui_args)
   if(ARG_GUI)
       set(gui_args WIN32 MACOSX_BUNDLE)
   endif()
   add_executable(${_targetname} ${gui_args} ${_sources})
   if(NOT ARG_GUI)
     ecm_mark_nongui_executable(${_targetname})
   endif()
 
   # do not add it as test, so make test skips it unless asked for it
   if(KRITA_ENABLE_BROKEN_TESTS)
     add_test(NAME ${_testname} COMMAND ${_targetname})
   endif()
 
   target_link_libraries(${_targetname} ${ARG_LINK_LIBRARIES})
   ecm_mark_as_test(${_targetname})
   if (ARG_TARGET_NAME_VAR)
     set(${ARG_TARGET_NAME_VAR} "${_targetname}" PARENT_SCOPE)
   endif()
   if (ARG_TEST_NAME_VAR)
     set(${ARG_TEST_NAME_VAR} "${_testname}" PARENT_SCOPE)
   endif()
 endfunction()
+
+function(KRITA_ADD_BROKEN_UNIT_TESTS)
+  set(options GUI)
+  set(oneValueArgs NAME_PREFIX TARGET_NAMES_VAR TEST_NAMES_VAR)
+  set(multiValueArgs LINK_LIBRARIES)
+  cmake_parse_arguments(ARG "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+  if(ARG_GUI)
+    set(_exe_type GUI)
+  else()
+    set(_exe_type "")
+  endif()
+  set(test_names)
+  set(target_names)
+  foreach(_test_source ${ARG_UNPARSED_ARGUMENTS})
+    KRITA_ADD_BROKEN_UNIT_TEST(${_test_source}
+      NAME_PREFIX ${ARG_NAME_PREFIX}
+      LINK_LIBRARIES ${ARG_LINK_LIBRARIES}
+      TARGET_NAME_VAR target_name
+      TEST_NAME_VAR test_name
+      ${_exe_type}
+    )
+    list(APPEND _test_names "${test_name}")
+    list(APPEND _target_names "${target_name}")
+  endforeach()
+  if (ARG_TARGET_NAMES_VAR)
+    set(${ARG_TARGET_NAMES_VAR} "${_target_names}" PARENT_SCOPE)
+  endif()
+  if (ARG_TEST_NAMES_VAR)
+    set(${ARG_TEST_NAMES_VAR} "${_test_names}" PARENT_SCOPE)
+  endif()
+endfunction()
diff --git a/krita/org.kde.krita.desktop b/krita/org.kde.krita.desktop
index 538e18c1d2..2db0c42745 100644
--- a/krita/org.kde.krita.desktop
+++ b/krita/org.kde.krita.desktop
@@ -1,151 +1,151 @@
 [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[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 %U
+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[lt]=Skaitmeninis piešimas
 GenericName[mr]=डिजिटल पेंटिंग
 GenericName[nb]=Digital maling
 GenericName[nl]=Digitaal schilderen
 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[lt]=Skaitmeninis piešimas
 Comment[mr]=डिजिटल पेंटिंग
 Comment[nb]=Digital maling
 Comment[nl]=Digitaal schilderen
 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
 Categories=Qt;KDE;Graphics;
 X-KDE-NativeMimeType=application/x-krita
 X-KDE-ExtraNativeMimeTypes=
 StartupNotify=true
 X-Krita-Version=28
diff --git a/libs/brush/tests/CMakeLists.txt b/libs/brush/tests/CMakeLists.txt
index df88d5d23e..c89ea12baa 100644
--- a/libs/brush/tests/CMakeLists.txt
+++ b/libs/brush/tests/CMakeLists.txt
@@ -1,30 +1,30 @@
 ########### next target ###############
 
 set( EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR} )
 include_directories(
     ${CMAKE_SOURCE_DIR}/libs/image/metadata
     ${CMAKE_SOURCE_DIR}/sdk/tests
 )
 include_directories(SYSTEM
     ${EIGEN3_INCLUDE_DIR}
 )
 
 if(HAVE_VC)
   include_directories(SYSTEM
       ${Vc_INCLUDE_DIR}
   )
 endif()
 
 macro_add_unittest_definitions()
 
 include(ECMAddTests)
 
 ecm_add_tests(
     kis_auto_brush_test.cpp
     kis_auto_brush_factory_test.cpp
     kis_gbr_brush_test.cpp
     kis_boundary_test.cpp
     kis_imagepipe_brush_test.cpp
-    NAME_PREFIX "krita-libbrush-"
+    NAME_PREFIX "libs-brush-"
     LINK_LIBRARIES kritaimage kritalibbrush Qt5::Test
 )
diff --git a/libs/flake/tests/CMakeLists.txt b/libs/flake/tests/CMakeLists.txt
index 0d56391469..f2a07a9033 100644
--- a/libs/flake/tests/CMakeLists.txt
+++ b/libs/flake/tests/CMakeLists.txt
@@ -1,116 +1,89 @@
 set( EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR} )
 
 include(ECMAddTests)
 include(KritaAddBrokenUnitTest)
 
 
 macro_add_unittest_definitions()
 
 ecm_add_tests(
     TestPosition.cpp
     TestSelection.cpp
     TestPathTool.cpp
     TestShapeAt.cpp
     TestShapePainting.cpp
     TestKoShapeFactory.cpp
     TestKoShapeRegistry.cpp
     TestShapeContainer.cpp
     TestShapeGroupCommand.cpp
     TestShapeReorderCommand.cpp
     TestImageCollection.cpp
     TestResourceManager.cpp
     TestShapeBackgroundCommand.cpp
     TestShapeStrokeCommand.cpp
     TestShapeShadowCommand.cpp
     TestInputDevice.cpp
     TestSnapStrategy.cpp
-    NAME_PREFIX "libs-kritaflake-"
-    LINK_LIBRARIES kritaflake Qt5::Test)
-
-ecm_add_test(TestPathShape.cpp
-    TEST_NAME libs-kritaflake-TestPathShape
-    LINK_LIBRARIES kritaflake Qt5::Test)
-
-ecm_add_test(TestControlPointMoveCommand.cpp
-    TEST_NAME libs-kritaflake-TestControlPointMoveCommand
-    LINK_LIBRARIES kritaflake Qt5::Test)
-
-ecm_add_test(TestPointTypeCommand.cpp
-    TEST_NAME libs-kritaflake-TestPointTypeCommand
-    LINK_LIBRARIES kritaflake Qt5::Test)
-
-ecm_add_test(TestPointRemoveCommand.cpp
-    TEST_NAME libs-kritaflake-TestPointRemoveCommand
-    LINK_LIBRARIES kritaflake Qt5::Test)
-
-ecm_add_test(TestRemoveSubpathCommand.cpp
-    TEST_NAME libs-kritaflake-TestRemoveSubpathCommand
-    LINK_LIBRARIES kritaflake Qt5::Test)
-
-ecm_add_test(TestPathSegment.cpp
-    TEST_NAME libs-kritaflake-TestPathSegment
-    LINK_LIBRARIES kritaflake Qt5::Test)
-
-ecm_add_test(TestSegmentTypeCommand.cpp
-    TEST_NAME libs-kritaflake-TestSegmentTypeCommand
-    LINK_LIBRARIES kritaflake Qt5::Test)
-
-krita_add_broken_unit_test(TestPointMergeCommand.cpp
-    TEST_NAME libs-kritaflake-TestPointMergeCommand
-    LINK_LIBRARIES kritaflake Qt5::Test)
-
-ecm_add_test(
+    TestPathShape.cpp
+    TestControlPointMoveCommand.cpp
+    TestPointTypeCommand.cpp
+    TestPointRemoveCommand.cpp
+    TestRemoveSubpathCommand.cpp
+    TestPathSegment.cpp
+    TestSegmentTypeCommand.cpp
     TestKoDrag.cpp
-    TEST_NAME libs-kritaflake-TestKoDrag
-    LINK_LIBRARIES kritaflake Qt5::Test
-)
-
-ecm_add_test(
     TestKoMarkerCollection.cpp
-    TEST_NAME libs-kritaflake-TestKoMarkerCollection
+
     LINK_LIBRARIES kritaflake Qt5::Test
-)
+    NAME_PREFIX "libs-flake-")
 
 ecm_add_test(
     TestSvgParser.cpp
-    TEST_NAME libs-kritaflake-TestSvgParser
+    TEST_NAME TestSvgParser
     LINK_LIBRARIES kritaflake Qt5::Test
-)
+    NAME_PREFIX "libs-flake-")
 
 ecm_add_test(
     TestSvgParser.cpp
-    TEST_NAME libs-kritaflake-TestSvgParserCloned
+    TEST_NAME TestSvgParserCloned
     LINK_LIBRARIES kritaflake Qt5::Test
-)
-set_property(TARGET libs-kritaflake-TestSvgParserCloned
+    NAME_PREFIX "libs-flake-")
+set_property(TARGET TestSvgParserCloned
              PROPERTY COMPILE_DEFINITIONS USE_CLONED_SHAPES)
 
 ecm_add_test(
     TestSvgParser.cpp
-    TEST_NAME libs-kritaflake-TestSvgParserRoundTrip
+    TEST_NAME TestSvgParserRoundTrip
     LINK_LIBRARIES kritaflake Qt5::Test
-)
-set_property(TARGET libs-kritaflake-TestSvgParserRoundTrip
+    NAME_PREFIX "libs-flake-")
+set_property(TARGET TestSvgParserRoundTrip
              PROPERTY COMPILE_DEFINITIONS USE_ROUND_TRIP)
 
-ecm_add_test(
+############## broken tests ###############
+
+krita_add_broken_unit_test(TestPointMergeCommand.cpp
+    TEST_NAME TestPointMergeCommand
+    LINK_LIBRARIES kritaflake Qt5::Test
+    NAME_PREFIX "libs-flake-")
+
+krita_add_broken_unit_test(
     TestSvgText.cpp
-    TEST_NAME libs-kritaflake-TestSvgText
+    TEST_NAME TestSvgText
     LINK_LIBRARIES kritaflake Qt5::Test
-)
+    NAME_PREFIX "libs-flake-")
 
-ecm_add_test(
+krita_add_broken_unit_test(
     TestSvgText.cpp
-    TEST_NAME libs-kritaflake-TestSvgTextCloned
+    TEST_NAME TestSvgTextCloned
     LINK_LIBRARIES kritaflake Qt5::Test
-)
-set_property(TARGET libs-kritaflake-TestSvgTextCloned
+    NAME_PREFIX "libs-flake-")
+set_property(TARGET TestSvgTextCloned
              PROPERTY COMPILE_DEFINITIONS USE_CLONED_SHAPES)
 
-ecm_add_test(
+krita_add_broken_unit_test(
     TestSvgText.cpp
-    TEST_NAME libs-kritaflake-TestSvgTextRoundTrip
+    TEST_NAME TestSvgTextRoundTrip
     LINK_LIBRARIES kritaflake Qt5::Test
-)
-set_property(TARGET libs-kritaflake-TestSvgTextRoundTrip
+    NAME_PREFIX "libs-flake-")
+set_property(TARGET TestSvgTextRoundTrip
              PROPERTY COMPILE_DEFINITIONS USE_ROUND_TRIP)
diff --git a/libs/flake/tests/TestShapePainting.cpp b/libs/flake/tests/TestShapePainting.cpp
index 4dc6a8cdd6..8faff819d1 100644
--- a/libs/flake/tests/TestShapePainting.cpp
+++ b/libs/flake/tests/TestShapePainting.cpp
@@ -1,323 +1,322 @@
 /*
  *  This file is part of Calligra tests
  *
  *  Copyright (C) 2006-2010 Thomas Zander <zander@kde.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "TestShapePainting.h"
 
 #include <QtGui>
 #include "KoShapeContainer.h"
 #include "KoShapeManager.h"
 #include "KoShapePaintingContext.h"
 #include "KoViewConverter.h"
 #include <sdk/tests/kistest.h>
 #include <MockShapes.h>
 
 #include <QTest>
 
 void TestShapePainting::testPaintShape()
 {
     MockShape *shape1 = new MockShape();
     MockShape *shape2 = new MockShape();
     QScopedPointer<MockContainer> container(new MockContainer());
 
     container->addShape(shape1);
     container->addShape(shape2);
     QCOMPARE(shape1->parent(), container.data());
     QCOMPARE(shape2->parent(), container.data());
     container->setClipped(shape1, false);
     container->setClipped(shape2, false);
     QCOMPARE(container->isClipped(shape1), false);
     QCOMPARE(container->isClipped(shape2), false);
 
     MockCanvas canvas;
     KoShapeManager manager(&canvas);
     manager.addShape(container.data());
     QCOMPARE(manager.shapes().count(), 3);
 
     QImage image(100, 100,  QImage::Format_Mono);
     QPainter painter(&image);
     KoViewConverter vc;
     manager.paint(painter, vc, false);
 
     // with the shape not being clipped, the shapeManager will paint it for us.
     QCOMPARE(shape1->paintedCount, 1);
     QCOMPARE(shape2->paintedCount, 1);
     QCOMPARE(container->paintedCount, 1);
 
     // the container should thus not paint the shape
     shape1->paintedCount = 0;
     shape2->paintedCount = 0;
     container->paintedCount = 0;
     KoShapePaintingContext paintContext;
     container->paint(painter, vc, paintContext);
     QCOMPARE(shape1->paintedCount, 0);
     QCOMPARE(shape2->paintedCount, 0);
     QCOMPARE(container->paintedCount, 1);
 
 
     container->setClipped(shape1, false);
     container->setClipped(shape2, true);
     QCOMPARE(container->isClipped(shape1), false);
     QCOMPARE(container->isClipped(shape2), true);
 
     shape1->paintedCount = 0;
     shape2->paintedCount = 0;
     container->paintedCount = 0;
     manager.paint(painter, vc, false);
 
 
     // with this shape not being clipped, the shapeManager will paint the container and this shape
     QCOMPARE(shape1->paintedCount, 1);
     // with this shape being clipped, the container will paint it for us.
     QCOMPARE(shape2->paintedCount, 1);
     QCOMPARE(container->paintedCount, 1);
 }
 
 void TestShapePainting::testPaintHiddenShape()
 {
     QScopedPointer<MockContainer> top(new MockContainer());
 
     MockShape *shape = new MockShape();
     MockContainer *fourth = new MockContainer();
     MockContainer *thirth = new MockContainer();
     MockContainer *second = new MockContainer();
 
 
     top->addShape(second);
     second->addShape(thirth);
     thirth->addShape(fourth);
     fourth->addShape(shape);
 
     second->setVisible(false);
 
     MockCanvas canvas;
     KoShapeManager manager(&canvas);
     manager.addShape(top.data());
     QCOMPARE(manager.shapes().count(), 5);
 
     QImage image(100, 100,  QImage::Format_Mono);
     QPainter painter(&image);
     KoViewConverter vc;
     manager.paint(painter, vc, false);
 
     QCOMPARE(top->paintedCount, 1);
     QCOMPARE(second->paintedCount, 0);
     QCOMPARE(thirth->paintedCount, 0);
     QCOMPARE(fourth->paintedCount, 0);
     QCOMPARE(shape->paintedCount, 0);
 }
 
 void TestShapePainting::testPaintOrder()
 {
     // the stacking order determines the painting order so things on top
     // get their paint called last.
     // Each shape has a zIndex and within the children a container has
     // it determines the stacking order. Its important to realize that
     // the zIndex is thus local to a container, if you have layer1 and layer2
     // with both various child shapes the stacking order of the layer shapes
     // is most important, then within this the child shape index is used.
 
     class OrderedMockShape : public MockShape {
     public:
         OrderedMockShape(QList<MockShape*> &list) : order(list) {}
         void paint(QPainter &painter, const KoViewConverter &converter, KoShapePaintingContext &paintcontext) override {
             order.append(this);
             MockShape::paint(painter, converter, paintcontext);
         }
         QList<MockShape*> &order;
     };
 
     QList<MockShape*> order;
 
     {
         QScopedPointer<MockContainer> top(new MockContainer());
         top->setZIndex(2);
         OrderedMockShape *shape1 = new OrderedMockShape(order);
         shape1->setZIndex(5);
         OrderedMockShape *shape2 = new OrderedMockShape(order);
         shape2->setZIndex(0);
         top->addShape(shape1);
         top->addShape(shape2);
 
         QScopedPointer<MockContainer> bottom(new MockContainer());
         bottom->setZIndex(1);
         OrderedMockShape *shape3 = new OrderedMockShape(order);
         shape3->setZIndex(-1);
         OrderedMockShape *shape4 = new OrderedMockShape(order);
         shape4->setZIndex(9);
         bottom->addShape(shape3);
         bottom->addShape(shape4);
 
         MockCanvas canvas;
         KoShapeManager manager(&canvas);
         manager.addShape(top.data());
         manager.addShape(bottom.data());
         QCOMPARE(manager.shapes().count(), 6);
 
         QImage image(100, 100,  QImage::Format_Mono);
         QPainter painter(&image);
         KoViewConverter vc;
         manager.paint(painter, vc, false);
         QCOMPARE(top->paintedCount, 1);
         QCOMPARE(bottom->paintedCount, 1);
         QCOMPARE(shape1->paintedCount, 1);
         QCOMPARE(shape2->paintedCount, 1);
         QCOMPARE(shape3->paintedCount, 1);
         QCOMPARE(shape4->paintedCount, 1);
 
         QCOMPARE(order.count(), 4);
         QVERIFY(order[0] == shape3); // lowest first
         QVERIFY(order[1] == shape4);
         QVERIFY(order[2] == shape2);
         QVERIFY(order[3] == shape1);
 
         // again, with clipping.
         order.clear();
         painter.setClipRect(0, 0, 100, 100);
         manager.paint(painter, vc, false);
         QCOMPARE(top->paintedCount, 2);
         QCOMPARE(bottom->paintedCount, 2);
         QCOMPARE(shape1->paintedCount, 2);
         QCOMPARE(shape2->paintedCount, 2);
         QCOMPARE(shape3->paintedCount, 2);
         QCOMPARE(shape4->paintedCount, 2);
 
         QCOMPARE(order.count(), 4);
         QVERIFY(order[0] == shape3); // lowest first
         QVERIFY(order[1] == shape4);
         QVERIFY(order[2] == shape2);
         QVERIFY(order[3] == shape1);
 
     }
 
     order.clear();
 
     {
         QScopedPointer<MockContainer> root(new MockContainer());
         root->setZIndex(0);
 
         MockContainer *branch1 = new MockContainer();
         branch1->setZIndex(1);
         OrderedMockShape *child1_1 = new OrderedMockShape(order);
         child1_1->setZIndex(1);
         OrderedMockShape *child1_2 = new OrderedMockShape(order);
         child1_2->setZIndex(2);
         branch1->addShape(child1_1);
         branch1->addShape(child1_2);
 
         MockContainer *branch2 = new MockContainer();
         branch2->setZIndex(2);
         OrderedMockShape *child2_1 = new OrderedMockShape(order);
         child2_1->setZIndex(1);
         OrderedMockShape *child2_2 = new OrderedMockShape(order);
         child2_2->setZIndex(2);
         branch2->addShape(child2_1);
         branch2->addShape(child2_2);
 
         root->addShape(branch1);
         root->addShape(branch2);
 
         QList<KoShape*> sortedShapes;
         sortedShapes.append(root.data());
         sortedShapes.append(branch1);
         sortedShapes.append(branch2);
         sortedShapes.append(branch1->shapes());
         sortedShapes.append(branch2->shapes());
 
         std::sort(sortedShapes.begin(), sortedShapes.end(), KoShape::compareShapeZIndex);
         QCOMPARE(sortedShapes.count(), 7);
         QVERIFY(sortedShapes[0] == root.data());
         QVERIFY(sortedShapes[1] == branch1);
         QVERIFY(sortedShapes[2] == child1_1);
         QVERIFY(sortedShapes[3] == child1_2);
         QVERIFY(sortedShapes[4] == branch2);
         QVERIFY(sortedShapes[5] == child2_1);
         QVERIFY(sortedShapes[6] == child2_2);
     }
 }
 #include <kundo2command.h>
 #include <KoShapeController.h>
 #include <KoShapeGroupCommand.h>
 #include <KoShapeUngroupCommand.h>
 #include "kis_debug.h"
 void TestShapePainting::testGroupUngroup()
 {
     QScopedPointer<MockContainer> shapesFakeLayer(new MockContainer);
     MockShape *shape1(new MockShape());
     MockShape *shape2(new MockShape());
     shape1->setName("shape1");
     shape2->setName("shape2");
     shape1->setParent(shapesFakeLayer.data());
     shape2->setParent(shapesFakeLayer.data());
 
     QList<KoShape*> groupedShapes = {shape1, shape2};
 
 
     MockShapeController controller;
     MockCanvas canvas(&controller);
     KoShapeManager *manager = canvas.shapeManager();
 
     controller.addShape(shape1);
     controller.addShape(shape2);
 
     QImage image(100, 100,  QImage::Format_Mono);
     QPainter painter(&image);
     painter.setClipRect(image.rect());
     KoViewConverter vc;
 
     for (int i = 0; i < 3; i++) {
         KoShapeGroup *group = new KoShapeGroup();
         group->setParent(shapesFakeLayer.data());
 
         {
             group->setName("group");
 
             KUndo2Command groupingCommand;
             canvas.shapeController()->addShapeDirect(group, 0, &groupingCommand);
             new KoShapeGroupCommand(group, groupedShapes, true, &groupingCommand);
 
             groupingCommand.redo();
 
             manager->paint(painter, vc, false);
 
             QCOMPARE(shape1->paintedCount, 2 * i + 1);
             QCOMPARE(shape2->paintedCount, 2 * i + 1);
             QCOMPARE(manager->shapes().size(), 3);
         }
 
         {
             KUndo2Command ungroupingCommand;
 
             new KoShapeUngroupCommand(group, group->shapes(), QList<KoShape*>(), &ungroupingCommand);
             canvas.shapeController()->removeShape(group, &ungroupingCommand);
+            // NOTE: group will be deleted in ungroupingCommand's d-tor
 
             ungroupingCommand.redo();
 
             manager->paint(painter, vc, false);
 
             QCOMPARE(shape1->paintedCount, 2 * i + 2);
             QCOMPARE(shape2->paintedCount, 2 * i + 2);
             QCOMPARE(manager->shapes().size(), 2);
         }
-
-        group->setParent(0);
     }
 }
 
 KISTEST_MAIN(TestShapePainting)
diff --git a/libs/flake/tools/KoShapeRubberSelectStrategy.cpp b/libs/flake/tools/KoShapeRubberSelectStrategy.cpp
index 83862e25d0..b6463dd161 100644
--- a/libs/flake/tools/KoShapeRubberSelectStrategy.cpp
+++ b/libs/flake/tools/KoShapeRubberSelectStrategy.cpp
@@ -1,122 +1,122 @@
 /* This file is part of the KDE project
 
    Copyright (C) 2006 Thorsten Zachmann <zachmann@kde.org>
    Copyright (C) 2006 Thomas Zander <zander@kde.org>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #include "KoShapeRubberSelectStrategy.h"
 #include "KoShapeRubberSelectStrategy_p.h"
 #include "KoViewConverter.h"
 
 #include <QPainter>
 
 #include "KoShapeManager.h"
 #include "KoSelection.h"
 #include "KoCanvasBase.h"
 
 KoShapeRubberSelectStrategy::KoShapeRubberSelectStrategy(KoToolBase *tool, const QPointF &clicked, bool useSnapToGrid)
     : KoInteractionStrategy(*(new KoShapeRubberSelectStrategyPrivate(tool)))
 {
     Q_D(KoShapeRubberSelectStrategy);
     d->snapGuide->enableSnapStrategies(KoSnapGuide::GridSnapping);
     d->snapGuide->enableSnapping(useSnapToGrid);
 
     d->selectRect = QRectF(d->snapGuide->snap(clicked, 0), QSizeF(0, 0));
 }
 
 void KoShapeRubberSelectStrategy::paint(QPainter &painter, const KoViewConverter &converter)
 {
     Q_D(KoShapeRubberSelectStrategy);
     painter.setRenderHint(QPainter::Antialiasing, false);
 
     const QColor crossingColor(80,130,8);
     const QColor coveringColor(8,60,167);
 
     QColor selectColor(
         currentMode() == CrossingSelection ?
         crossingColor : coveringColor);
 
     selectColor.setAlphaF(0.8);
     painter.setPen(QPen(selectColor, 0));
 
     selectColor.setAlphaF(0.4);
     const QBrush fillBrush(selectColor);
     painter.setBrush(fillBrush);
 
     QRectF paintRect = converter.documentToView(d->selectedRect());
     paintRect = paintRect.normalized();
 
     painter.drawRect(paintRect);
 }
 
 void KoShapeRubberSelectStrategy::handleMouseMove(const QPointF &p, Qt::KeyboardModifiers modifiers)
 {
     Q_D(KoShapeRubberSelectStrategy);
     QPointF point = d->snapGuide->snap(p, modifiers);
     if (modifiers & Qt::ControlModifier) {
         d->tool->canvas()->updateCanvas(d->selectedRect());
         d->selectRect.moveTopLeft(d->selectRect.topLeft() - (d->lastPos - point));
         d->lastPos = point;
         d->tool->canvas()->updateCanvas(d->selectedRect());
         return;
     }
     d->lastPos = point;
     QPointF old = d->selectRect.bottomRight();
     d->selectRect.setBottomRight(point);
     /*
         +---------------|--+
         |               |  |    We need to figure out rects A and B based on the two points. BUT
         |          old  | A|    we need to do that even if the points are switched places
         |             \ |  |    (i.e. the rect got smaller) and even if the rect is mirrored
         +---------------+  |    in either the horizontal or vertical axis.
         |       B          |
         +------------------+
                             `- point
     */
     QPointF x1 = old;
     x1.setY(d->selectRect.topLeft().y());
     qreal h1 = point.y() - x1.y();
     qreal h2 = old.y() - x1.y();
     QRectF A(x1, QSizeF(point.x() - x1.x(), point.y() < d->selectRect.top() ? qMin(h1, h2) : qMax(h1, h2)));
     A = A.normalized();
     d->tool->canvas()->updateCanvas(A);
 
     QPointF x2 = old;
     x2.setX(d->selectRect.topLeft().x());
     qreal w1 = point.x() - x2.x();
     qreal w2 = old.x() - x2.x();
     QRectF B(x2, QSizeF(point.x() < d->selectRect.left() ? qMin(w1, w2) : qMax(w1, w2), point.y() - x2.y()));
     B = B.normalized();
     d->tool->canvas()->updateCanvas(B);
 }
 
 KoShapeRubberSelectStrategy::SelectionMode KoShapeRubberSelectStrategy::currentMode() const
 {
     Q_D(const KoShapeRubberSelectStrategy);
     return d->selectRect.left() < d->selectRect.right() ? CoveringSelection : CrossingSelection;
 }
 
 KUndo2Command *KoShapeRubberSelectStrategy::createCommand()
 {
     return 0;
 }
 
 QRectF KoShapeRubberSelectStrategy::selectedRectangle() const {
     Q_D(const KoShapeRubberSelectStrategy);
     return d->selectedRect();
-}
\ No newline at end of file
+}
diff --git a/libs/global/tests/CMakeLists.txt b/libs/global/tests/CMakeLists.txt
index 3cc4776465..22d062e090 100644
--- a/libs/global/tests/CMakeLists.txt
+++ b/libs/global/tests/CMakeLists.txt
@@ -1,8 +1,8 @@
 include(ECMAddTests)
 include(KritaAddBrokenUnitTest)
 
 macro_add_unittest_definitions()
 
-ecm_add_test(KisSharedThreadPoolAdapterTest.cpp
-    TEST_NAME KisSharedThreadPoolAdapter
+ecm_add_tests(KisSharedThreadPoolAdapterTest.cpp
+    NAME_PREFIX libs-global-
     LINK_LIBRARIES kritaglobal Qt5::Test)
diff --git a/libs/image/brushengine/kis_paint_information.cc b/libs/image/brushengine/kis_paint_information.cc
index 2b2b919987..80edf3bcd7 100644
--- a/libs/image/brushengine/kis_paint_information.cc
+++ b/libs/image/brushengine/kis_paint_information.cc
@@ -1,635 +1,643 @@
 /*
  *  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;
         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};
     bool canvasMirroredH {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()
 {
-    p->d->unregisterDistanceInfo();
+    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)
 {
     KisPaintInformation info(pos,
                              pressure,
                              xTilt, yTilt,
                              rotation,
                              tangentialPressure,
                              perspective, 0, speed);
     info.d->isHoveringMode = true;
     info.d->canvasRotation = canvasrotation;
     info.d->canvasMirroredH = canvasMirroredH;
     return info;
 }
 
 
 int KisPaintInformation::canvasRotation() const
 {
     return d->canvasRotation;
 }
 
 void KisPaintInformation::setCanvasRotation(int rotation)
 {
     if (rotation < 0) {
         d->canvasRotation= 360- abs(rotation % 360);
     } else {
         d->canvasRotation= rotation % 360;
     }
 
 }
 
 bool KisPaintInformation::canvasMirroredH() const
 {
     return d->canvasMirroredH;
 }
 
 void KisPaintInformation::setCanvasHorizontalMirrorState(bool mir)
 {
     d->canvasMirroredH = mir;
 
 }
 
 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->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 5ec7d7ad38..bc1067d38d 100644
--- a/libs/image/brushengine/kis_paint_information.h
+++ b/libs/image/brushengine/kis_paint_information.h
@@ -1,309 +1,311 @@
 /*
  *  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);
     /**
      *Returns the canvas rotation if that has been given to the kispaintinformation.
      */
     int canvasRotation() const;
     /**
      *set the canvas rotation.
      */
     void setCanvasRotation(int rotation);
 
     /*
      *Whether the canvas is mirrored for the paint-operation.
      */
     bool canvasMirroredH() const;
 
     /*
      *Set whether the canvas is mirrored for the paint-operation.
      */
     void setCanvasHorizontalMirrorState(bool mir);
 
     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/filter/kis_filter.cc b/libs/image/filter/kis_filter.cc
index 28d18d2c20..8dd5bec546 100644
--- a/libs/image/filter/kis_filter.cc
+++ b/libs/image/filter/kis_filter.cc
@@ -1,133 +1,133 @@
 /*
  *  Copyright (c) 2004,2006-2007 Cyrille Berger <cberger@cberger.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "filter/kis_filter.h"
 
 #include <QString>
 
 #include <KoCompositeOpRegistry.h>
 #include "kis_bookmarked_configuration_manager.h"
 #include "filter/kis_filter_configuration.h"
 #include "kis_processing_information.h"
 #include "kis_transaction.h"
 #include "kis_paint_device.h"
 #include "kis_selection.h"
 #include "kis_types.h"
 #include <kis_painter.h>
 #include <KoUpdater.h>
 
 KisFilter::KisFilter(const KoID& _id, const KoID & category, const QString & entry)
     : KisBaseProcessor(_id, category, entry),
       m_supportsLevelOfDetail(false)
 {
     init(id() + "_filter_bookmarks");
 }
 
 KisFilter::~KisFilter()
 {
 }
 
 void KisFilter::process(KisPaintDeviceSP device,
                         const QRect& applyRect,
                         const KisFilterConfigurationSP config,
                         KoUpdater* progressUpdater) const
 {
     process(device, device, KisSelectionSP(), applyRect, config, progressUpdater);
 }
 
 void KisFilter::process(const KisPaintDeviceSP src,
                         KisPaintDeviceSP dst,
                         KisSelectionSP selection,
                         const QRect& applyRect,
                         const KisFilterConfigurationSP config,
                         KoUpdater* progressUpdater ) const
 {
     if (applyRect.isEmpty()) return;
     QRect needRect = neededRect(applyRect, config, src->defaultBounds()->currentLevelOfDetail());
 
     KisPaintDeviceSP temporary;
     KisTransaction *transaction = 0;
 
     bool weirdDstColorSpace =
         dst->colorSpace() != dst->compositionSourceColorSpace() &&
         *dst->colorSpace() != *dst->compositionSourceColorSpace();
 
     if(src == dst && !selection && !weirdDstColorSpace) {
         temporary = src;
     }
     else {
         temporary = dst->createCompositionSourceDevice(src, needRect);
         transaction = new KisTransaction(temporary);
     }
 
     try {
         QScopedPointer<KoUpdater> fakeUpdater;
 
         if (!progressUpdater) {
             // TODO: remove dependency on KoUpdater, depend on KoProgressProxy,
             //       it is more lightweight
             fakeUpdater.reset(new KoDummyUpdater());
             progressUpdater = fakeUpdater.data();
         }
 
         processImpl(temporary, applyRect, config, progressUpdater);
     }
-    catch (std::bad_alloc) {
+    catch (const std::bad_alloc&) {
         warnKrita << "Filter" << name() << "failed to allocate enough memory to run.";
     }
 
 
     if(transaction) {
         delete transaction;
         KisPainter::copyAreaOptimized(applyRect.topLeft(), temporary, dst, applyRect, selection);
     }
 }
 
 QRect KisFilter::neededRect(const QRect & rect, const KisFilterConfigurationSP c, int lod) const
 {
     Q_UNUSED(c);
     Q_UNUSED(lod);
     return rect;
 }
 
 QRect KisFilter::changedRect(const QRect & rect, const KisFilterConfigurationSP c, int lod) const
 {
     Q_UNUSED(c);
     Q_UNUSED(lod);
     return rect;
 }
 
 bool KisFilter::supportsLevelOfDetail(const KisFilterConfigurationSP config, int lod) const
 {
     Q_UNUSED(config);
     Q_UNUSED(lod);
     return m_supportsLevelOfDetail;
 }
 
 void KisFilter::setSupportsLevelOfDetail(bool value)
 {
     m_supportsLevelOfDetail = value;
 }
 
 bool KisFilter::needsTransparentPixels(const KisFilterConfigurationSP config, const KoColorSpace *cs) const
 {
     Q_UNUSED(config);
     Q_UNUSED(cs);
 
     return false;
 }
diff --git a/libs/image/kis_antialiasing_fade_maker.h b/libs/image/kis_antialiasing_fade_maker.h
index 552ef72d0a..86cf92911f 100644
--- a/libs/image/kis_antialiasing_fade_maker.h
+++ b/libs/image/kis_antialiasing_fade_maker.h
@@ -1,270 +1,269 @@
 /*
  *  Copyright (c) 2014 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KIS_ANTIALIASING_FADE_MAKER_H
 #define __KIS_ANTIALIASING_FADE_MAKER_H
 
 #include "kis_global.h"
 
 template <class BaseFade>
 class KisAntialiasingFadeMaker1D
 {
 public:
     KisAntialiasingFadeMaker1D(const BaseFade &baseFade, bool enableAntialiasing)
         : m_radius(0.0),
           m_fadeStartValue(0),
           m_antialiasingFadeStart(0),
           m_antialiasingFadeCoeff(0),
           m_enableAntialiasing(enableAntialiasing),
           m_baseFade(baseFade)
     {
     }
 
     KisAntialiasingFadeMaker1D(const KisAntialiasingFadeMaker1D &rhs, const BaseFade &baseFade)
         : m_radius(rhs.m_radius),
           m_fadeStartValue(rhs.m_fadeStartValue),
           m_antialiasingFadeStart(rhs.m_antialiasingFadeStart),
           m_antialiasingFadeCoeff(rhs.m_antialiasingFadeCoeff),
           m_enableAntialiasing(rhs.m_enableAntialiasing),
           m_baseFade(baseFade)
     {
     }
 
     void setSquareNormCoeffs(qreal xcoeff, qreal ycoeff) {
         m_radius = 1.0;
 
         qreal xf = qMax(0.0, ((1.0 / xcoeff) - 1.0) * xcoeff);
         qreal yf = qMax(0.0, ((1.0 / ycoeff) - 1.0) * ycoeff);
 
         m_antialiasingFadeStart = pow2(0.5 * (xf + yf));
 
         m_fadeStartValue = m_baseFade.value(m_antialiasingFadeStart);
         m_antialiasingFadeCoeff = qMax(0.0, 255.0 - m_fadeStartValue) / (m_radius - m_antialiasingFadeStart);
     }
 
     void setRadius(qreal radius) {
         m_radius = radius;
         m_antialiasingFadeStart = qMax(0.0, m_radius - 1.0);
 
         m_fadeStartValue = m_baseFade.value(m_antialiasingFadeStart);
         m_antialiasingFadeCoeff = qMax(0.0, 255.0 - m_fadeStartValue) / (m_radius - m_antialiasingFadeStart);
     }
 
     inline bool needFade(qreal dist, quint8 *value) {
         if (dist > m_radius) {
             *value = 255;
             return true;
         }
 
         if (!m_enableAntialiasing) {
             return false;
         }
 
         if (dist > m_antialiasingFadeStart) {
             *value = m_fadeStartValue + (dist - m_antialiasingFadeStart) * m_antialiasingFadeCoeff;
             return true;
         }
 
         return false;
     }
 
 #if defined HAVE_VC
     Vc::float_m needFade(Vc::float_v &dist) {
         const Vc::float_v vOne(Vc::One);
         const Vc::float_v vValMax(255.f);
 
         Vc::float_v vRadius(m_radius);
         Vc::float_v vFadeStartValue(m_fadeStartValue);
         Vc::float_v vAntialiasingFadeStart(m_antialiasingFadeStart);
         Vc::float_v vAntialiasingFadeCoeff(m_antialiasingFadeCoeff);
 
         Vc::float_m outsideMask = dist > vRadius;
         dist(outsideMask) = vOne;
 
         Vc::float_m fadeStartMask(false);
 
         if(m_enableAntialiasing){
             fadeStartMask = dist > vAntialiasingFadeStart;
             dist((outsideMask ^ fadeStartMask) & fadeStartMask) = (vFadeStartValue +
                                                                 (dist - vAntialiasingFadeStart) * vAntialiasingFadeCoeff) / vValMax;
         }
         return (outsideMask | fadeStartMask);
     }
 
 #endif /* defined HAVE_VC */
 
 private:
     qreal m_radius;
     quint8 m_fadeStartValue;
     qreal m_antialiasingFadeStart;
     qreal m_antialiasingFadeCoeff;
     bool m_enableAntialiasing;
     const BaseFade &m_baseFade;
 };
 
 template <class BaseFade>
 class KisAntialiasingFadeMaker2D
 {
 public:
     KisAntialiasingFadeMaker2D(const BaseFade &baseFade, bool enableAntialiasing)
         : m_xLimit(0),
           m_yLimit(0),
           m_xFadeLimitStart(0),
           m_yFadeLimitStart(0),
           m_xFadeCoeff(0),
           m_yFadeCoeff(0),
           m_enableAntialiasing(enableAntialiasing),
           m_baseFade(baseFade)
     {
     }
 
     KisAntialiasingFadeMaker2D(const KisAntialiasingFadeMaker2D &rhs, const BaseFade &baseFade)
         : m_xLimit(rhs.m_xLimit),
           m_yLimit(rhs.m_yLimit),
           m_xFadeLimitStart(rhs.m_xFadeLimitStart),
           m_yFadeLimitStart(rhs.m_yFadeLimitStart),
           m_xFadeCoeff(rhs.m_xFadeCoeff),
           m_yFadeCoeff(rhs.m_yFadeCoeff),
           m_enableAntialiasing(rhs.m_enableAntialiasing),
           m_baseFade(baseFade)
     {
     }
 
     void setLimits(qreal halfWidth, qreal halfHeight) {
         m_xLimit = halfWidth;
         m_yLimit = halfHeight;
 
         m_xFadeLimitStart = m_xLimit - 1.0;
         m_yFadeLimitStart = m_yLimit - 1.0;
 
         m_xFadeCoeff = 1.0 / (m_xLimit - m_xFadeLimitStart);
         m_yFadeCoeff = 1.0 / (m_yLimit - m_yFadeLimitStart);
     }
 
     inline bool needFade(qreal x, qreal y, quint8 *value) {
         x = qAbs(x);
         y = qAbs(y);
 
         if (x > m_xLimit) {
             *value = 255;
             return true;
         }
 
         if (y > m_yLimit) {
             *value = 255;
             return true;
         }
 
         if (!m_enableAntialiasing) {
             return false;
         }
 
         if (x > m_xFadeLimitStart) {
             quint8 baseValue = m_baseFade.value(x, y);
             *value = baseValue + (255.0 - baseValue) * (x - m_xFadeLimitStart) * m_xFadeCoeff;
 
             if (y > m_yFadeLimitStart && *value < 255) {
                 *value += (255.0 - *value) * (y - m_yFadeLimitStart) * m_yFadeCoeff;
             }
 
             return true;
         }
 
         if (y > m_yFadeLimitStart) {
             quint8 baseValue = m_baseFade.value(x, y);
             *value = baseValue + (255.0 - baseValue) * (y - m_yFadeLimitStart) * m_yFadeCoeff;
 
             if (x > m_xFadeLimitStart && *value < 255) {
                 *value += (255.0 - *value) * (x - m_xFadeLimitStart) * m_xFadeCoeff;
             }
 
             return true;
         }
 
         return false;
     }
 
 #if defined HAVE_VC
     Vc::float_m needFade(Vc::float_v &xr, Vc::float_v &yr) const {
 
         Vc::float_v vXLimit(m_xLimit);
         Vc::float_v vYLimit(m_yLimit);
 
-
-        Vc::float_m outXMask = xr > vXLimit;
-        Vc::float_m outYMask = yr > vYLimit;
+        Vc::float_m outXMask = Vc::abs(xr) > vXLimit;
+        Vc::float_m outYMask = Vc::abs(yr) > vYLimit;
 
         return (outXMask | outYMask);
     }
 
     // Apply fader separatedly to avoid calculating vValue twice.
     void apply2DFader(Vc::float_v &vValue, Vc::float_m &excludeMask, Vc::float_v &xr, Vc::float_v &yr) const {
         const Vc::float_v vValMax(255.f);
 
         if(m_enableAntialiasing){
             Vc::float_v vXFadeLimitStart(m_xFadeLimitStart);
             Vc::float_v vYFadeLimitStart(m_yFadeLimitStart);
             Vc::float_v vXFadeCoeff(m_xFadeCoeff);
             Vc::float_v vYFadeCoeff(m_yFadeCoeff);
 
             Vc::float_v xra = abs(xr);
             Vc::float_m fadeXStartMask(false);
             Vc::float_m fadeYStartMask(false);
 
             Vc::float_v fadeValue;
             Vc::SimdArray<quint16,Vc::float_v::size()> vBaseValue(vValue);
 
             fadeXStartMask = xra > vXFadeLimitStart;
             fadeXStartMask = (fadeXStartMask ^ excludeMask) & fadeXStartMask;
             if (!fadeXStartMask.isFull()) {
                 fadeValue = vBaseValue + (vValMax - vBaseValue) * (xra - vXFadeLimitStart) * vXFadeCoeff;
                 fadeValue(fadeXStartMask & ((yr > vYFadeLimitStart) & (fadeValue < vValMax)) ) =
                         fadeValue + (vValMax - fadeValue) * (yr - vYFadeLimitStart) * vYFadeCoeff;
                 vValue(fadeXStartMask) = fadeValue;
             }
 
             fadeYStartMask = yr > vYFadeLimitStart;
             fadeYStartMask = (fadeYStartMask ^ fadeXStartMask) & fadeYStartMask;
             if (!fadeYStartMask.isFull()) {
                 fadeValue = vBaseValue + (vValMax - vBaseValue) * (yr - vYFadeLimitStart) * vYFadeCoeff;
                 fadeValue(fadeYStartMask & ((xra > vXFadeLimitStart) & (fadeValue < vValMax)) ) =
                         fadeValue + (vValMax - fadeValue) * (xra - vXFadeLimitStart) * vXFadeCoeff;
                 vValue(fadeYStartMask) = fadeValue;
             }
         }
         return;
     }
 
 #endif /* defined HAVE_VC */
 
 private:
     qreal m_xLimit;
     qreal m_yLimit;
 
     qreal m_xFadeLimitStart;
     qreal m_yFadeLimitStart;
 
     qreal m_xFadeCoeff;
     qreal m_yFadeCoeff;
 
     bool m_enableAntialiasing;
 
     const BaseFade &m_baseFade;
 };
 
 #endif /* __KIS_ANTIALIASING_FADE_MAKER_H */
diff --git a/libs/image/kis_base_node.cpp b/libs/image/kis_base_node.cpp
index 7c3a70103d..a2f6b464f6 100644
--- a/libs/image/kis_base_node.cpp
+++ b/libs/image/kis_base_node.cpp
@@ -1,434 +1,434 @@
 /*
  *  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_base_node.h"
 #include <klocalizedstring.h>
 
 #include <kis_icon.h>
 #include <KoProperties.h>
 #include <KoColorSpace.h>
 #include <KoCompositeOpRegistry.h>
 #include "kis_paint_device.h"
 #include "kis_layer_properties_icons.h"
 
 #include "kis_scalar_keyframe_channel.h"
 
 struct Q_DECL_HIDDEN KisBaseNode::Private
 {
     QString compositeOp;
     KoProperties properties;
     KisBaseNode::Property hack_visible; //HACK
     QUuid id;
     QMap<QString, KisKeyframeChannel*> keyframeChannels;
     QScopedPointer<KisScalarKeyframeChannel> opacityChannel;
 
     bool systemLocked;
     bool collapsed;
     bool supportsLodMoves;
     bool animated;
     bool useInTimeline;
 
     Private()
         : id(QUuid::createUuid())
         , systemLocked(false)
         , collapsed(false)
         , supportsLodMoves(false)
         , animated(false)
         , useInTimeline(false)
     {
     }
 
     Private(const Private &rhs)
         : compositeOp(rhs.compositeOp),
           id(QUuid::createUuid()),
           systemLocked(false),
           collapsed(rhs.collapsed),
           supportsLodMoves(rhs.supportsLodMoves),
           animated(rhs.animated),
           useInTimeline(rhs.useInTimeline)
     {
         QMapIterator<QString, QVariant> iter = rhs.properties.propertyIterator();
         while (iter.hasNext()) {
             iter.next();
             properties.setProperty(iter.key(), iter.value());
         }
     }
 };
 
 KisBaseNode::KisBaseNode()
     : m_d(new Private())
 {
     /**
      * Be cautious! These two calls are vital to warm-up KoProperties.
      * We use it and its QMap in a threaded environment. This is not
      * officially supported by Qt, but our environment guarantees, that
      * there will be the only writer and several readers. Whilst the
      * value of the QMap is boolean and there are no implicit-sharing
      * calls provocated, it is safe to work with it in such an
      * environment.
      */
     setVisible(true, true);
     setUserLocked(false);
     setCollapsed(false);
     setSupportsLodMoves(true);
 
     m_d->compositeOp = COMPOSITE_OVER;
 }
 
 
 KisBaseNode::KisBaseNode(const KisBaseNode & rhs)
     : QObject()
     , KisShared()
     , m_d(new Private(*rhs.m_d))
 {
     if (rhs.m_d->opacityChannel) {
         m_d->opacityChannel.reset(new KisScalarKeyframeChannel(*rhs.m_d->opacityChannel, 0));
         m_d->keyframeChannels.insert(m_d->opacityChannel->id(), m_d->opacityChannel.data());
     }
 }
 
 KisBaseNode::~KisBaseNode()
 {
     delete m_d;
 }
 
 KisPaintDeviceSP KisBaseNode::colorPickSourceDevice() const
 {
     return projection();
 }
 
 quint8 KisBaseNode::opacity() const
 {
     if (m_d->opacityChannel) {
         qreal value = m_d->opacityChannel->currentValue();
 
         if (!qIsNaN(value)) {
             return value;
         }
     }
 
     return nodeProperties().intProperty("opacity", OPACITY_OPAQUE_U8);
 }
 
 void KisBaseNode::setOpacity(quint8 val)
 {
     if (m_d->opacityChannel) {
         KisKeyframeSP activeKeyframe = m_d->opacityChannel->currentlyActiveKeyframe();
 
         if (activeKeyframe) {
             m_d->opacityChannel->setScalarValue(activeKeyframe, val);
         }
     }
 
     if (opacity() == val) return;
 
     setNodeProperty("opacity", val);
 
     baseNodeInvalidateAllFramesCallback();
 }
 
 quint8 KisBaseNode::percentOpacity() const
 {
     return int(float(opacity() * 100) / 255 + 0.5);
 }
 
 void KisBaseNode::setPercentOpacity(quint8 val)
 {
     setOpacity(int(float(val * 255) / 100 + 0.5));
 }
 
 const QString& KisBaseNode::compositeOpId() const
 {
     return m_d->compositeOp;
 }
 
 void KisBaseNode::setCompositeOpId(const QString& compositeOp)
 {
     if (m_d->compositeOp == compositeOp) return;
 
     m_d->compositeOp = compositeOp;
     baseNodeChangedCallback();
     baseNodeInvalidateAllFramesCallback();
 }
 
 KisBaseNode::PropertyList KisBaseNode::sectionModelProperties() const
 {
     KisBaseNode::PropertyList l;
     l << KisLayerPropertiesIcons::getProperty(KisLayerPropertiesIcons::visible, visible(), m_d->hack_visible.isInStasis, m_d->hack_visible.stateInStasis);
     l << KisLayerPropertiesIcons::getProperty(KisLayerPropertiesIcons::locked, userLocked());
     return l;
 }
 
 void KisBaseNode::setSectionModelProperties(const KisBaseNode::PropertyList &properties)
 {
     setVisible(properties.at(0).state.toBool());
     m_d->hack_visible = properties.at(0);
     setUserLocked(properties.at(1).state.toBool());
 }
 
 const KoProperties & KisBaseNode::nodeProperties() const
 {
     return m_d->properties;
 }
 
 void KisBaseNode::setNodeProperty(const QString & name, const QVariant & value)
 {
     m_d->properties.setProperty(name, value);
     baseNodeChangedCallback();
 }
 
 void KisBaseNode::mergeNodeProperties(const KoProperties & properties)
 {
     QMapIterator<QString, QVariant> iter = properties.propertyIterator();
     while (iter.hasNext()) {
         iter.next();
         m_d->properties.setProperty(iter.key(), iter.value());
     }
     baseNodeChangedCallback();
     baseNodeInvalidateAllFramesCallback();
 }
 
 bool KisBaseNode::check(const KoProperties & properties) const
 {
     QMapIterator<QString, QVariant> iter = properties.propertyIterator();
     while (iter.hasNext()) {
         iter.next();
         if (m_d->properties.contains(iter.key())) {
             if (m_d->properties.value(iter.key()) != iter.value())
                 return false;
         }
     }
     return true;
 }
 
 
 QImage KisBaseNode::createThumbnail(qint32 w, qint32 h)
 {
     try {
         QImage image(w, h, QImage::Format_ARGB32);
         image.fill(0);
         return image;
-    } catch (std::bad_alloc) {
+    } catch (const std::bad_alloc&) {
         return QImage();
     }
 
 }
 
 QImage KisBaseNode::createThumbnailForFrame(qint32 w, qint32 h, int time)
 {
     Q_UNUSED(time)
     return createThumbnail(w, h);
 }
 
 bool KisBaseNode::visible(bool recursive) const
 {
     bool isVisible = m_d->properties.boolProperty(KisLayerPropertiesIcons::visible.id(), true);
     KisBaseNodeSP parentNode = parentCallback();
 
     return recursive && isVisible && parentNode ?
         parentNode->visible(recursive) : isVisible;
 }
 
 void KisBaseNode::setVisible(bool visible, bool loading)
 {
     const bool isVisible = m_d->properties.boolProperty(KisLayerPropertiesIcons::visible.id(), true);
     if (!loading && isVisible == visible) return;
 
     m_d->properties.setProperty(KisLayerPropertiesIcons::visible.id(), visible);
     notifyParentVisibilityChanged(visible);
 
     if (!loading) {
         emit visibilityChanged(visible);
         baseNodeChangedCallback();
         baseNodeInvalidateAllFramesCallback();
     }
 }
 
 bool KisBaseNode::userLocked() const
 {
     return m_d->properties.boolProperty(KisLayerPropertiesIcons::locked.id(), false);
 }
 
 void KisBaseNode::setUserLocked(bool locked)
 {
     const bool isLocked = m_d->properties.boolProperty(KisLayerPropertiesIcons::locked.id(), true);
     if (isLocked == locked) return;
 
     m_d->properties.setProperty(KisLayerPropertiesIcons::locked.id(), locked);
     emit userLockingChanged(locked);
     baseNodeChangedCallback();
 }
 
 bool KisBaseNode::isEditable(bool checkVisibility) const
 {
     bool editable = true;
     if (checkVisibility) {
         editable = (visible(false) && !userLocked());
     }
     else {
         editable = (!userLocked());
     }
 
     if (editable) {
         KisBaseNodeSP parentNode = parentCallback();
         if (parentNode && parentNode != this) {
             editable = parentNode->isEditable(checkVisibility);
         }
     }
     return editable;
 }
 
 bool KisBaseNode::hasEditablePaintDevice() const
 {
     return paintDevice() && isEditable();
 }
 
 void KisBaseNode::setCollapsed(bool collapsed)
 {
     m_d->collapsed = collapsed;
 }
 
 bool KisBaseNode::collapsed() const
 {
     return m_d->collapsed;
 }
 
 void KisBaseNode::setColorLabelIndex(int index)
 {
     const int currentLabel = colorLabelIndex();
 
     if (currentLabel == index) return;
 
     m_d->properties.setProperty(KisLayerPropertiesIcons::colorLabelIndex.id(), index);
     baseNodeChangedCallback();
 }
 
 int KisBaseNode::colorLabelIndex() const
 {
     return m_d->properties.intProperty(KisLayerPropertiesIcons::colorLabelIndex.id(), 0);
 }
 
 QUuid KisBaseNode::uuid() const
 {
     return m_d->id;
 }
 
 void KisBaseNode::setUuid(const QUuid& id)
 {
     m_d->id = id;
     baseNodeChangedCallback();
 }
 
 bool KisBaseNode::supportsLodMoves() const
 {
     return m_d->supportsLodMoves;
 }
 
 void KisBaseNode::setImage(KisImageWSP image)
 {
     Q_UNUSED(image);
 }
 
 void KisBaseNode::setSupportsLodMoves(bool value)
 {
     m_d->supportsLodMoves = value;
 }
 
 
 QMap<QString, KisKeyframeChannel*> KisBaseNode::keyframeChannels() const
 {
     return m_d->keyframeChannels;
 }
 
 KisKeyframeChannel * KisBaseNode::getKeyframeChannel(const QString &id) const
 {
     QMap<QString, KisKeyframeChannel*>::const_iterator i = m_d->keyframeChannels.constFind(id);
     if (i == m_d->keyframeChannels.constEnd()) {
         return 0;
     }
     return i.value();
 }
 
 KisKeyframeChannel * KisBaseNode::getKeyframeChannel(const QString &id, bool create)
 {
     KisKeyframeChannel *channel = getKeyframeChannel(id);
 
     if (!channel && create) {
         channel = requestKeyframeChannel(id);
 
         if (channel) {
             addKeyframeChannel(channel);
         }
     }
 
     return channel;
 }
 
 bool KisBaseNode::isAnimated() const
 {
     return m_d->animated;
 }
 
 void KisBaseNode::enableAnimation()
 {
     m_d->animated = true;
     baseNodeChangedCallback();
 }
 
 bool KisBaseNode::useInTimeline() const
 {
     return m_d->useInTimeline;
 }
 
 void KisBaseNode::setUseInTimeline(bool value)
 {
     if (value == m_d->useInTimeline) return;
 
     m_d->useInTimeline = value;
     baseNodeChangedCallback();
 }
 
 void KisBaseNode::addKeyframeChannel(KisKeyframeChannel *channel)
 {
     m_d->keyframeChannels.insert(channel->id(), channel);
     emit keyframeChannelAdded(channel);
 }
 
 KisKeyframeChannel *KisBaseNode::requestKeyframeChannel(const QString &id)
 {
     if (id == KisKeyframeChannel::Opacity.id()) {
         Q_ASSERT(m_d->opacityChannel.isNull());
 
         KisPaintDeviceSP device = original();
 
         if (device) {
             KisScalarKeyframeChannel * channel = new KisScalarKeyframeChannel(
                 KisKeyframeChannel::Opacity,
                 0, 255,
                 device->defaultBounds(),
                 KisKeyframe::Linear
             );
 
             m_d->opacityChannel.reset(channel);
 
             return channel;
         }
     }
 
     return 0;
 }
diff --git a/libs/image/kis_base_rects_walker.h b/libs/image/kis_base_rects_walker.h
index 1479315fc4..08fe8764f7 100644
--- a/libs/image/kis_base_rects_walker.h
+++ b/libs/image/kis_base_rects_walker.h
@@ -1,491 +1,491 @@
 /*
  *  Copyright (c) 2009 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KIS_BASE_RECTS_WALKER_H
 #define __KIS_BASE_RECTS_WALKER_H
 
 #include <QStack>
 
 #include "kis_layer.h"
 
 #include "kis_abstract_projection_plane.h"
 #include "kis_projection_leaf.h"
 
 
 class KisBaseRectsWalker;
 typedef KisSharedPtr<KisBaseRectsWalker> KisBaseRectsWalkerSP;
 
 class KRITAIMAGE_EXPORT KisBaseRectsWalker : public KisShared
 {
 public:
     enum UpdateType {
         UPDATE,
         UPDATE_NO_FILTHY,
         FULL_REFRESH,
         UNSUPPORTED
     };
 
 
     typedef qint32 NodePosition;
     enum NodePositionValues {
         /**
          * There are two different sets of values.
          * The first describes the position of the node to the graph,
          * the second shows the position to the filthy node
          */
 
         N_NORMAL     = 0x00,
         N_TOPMOST    = 0x01,
         N_BOTTOMMOST = 0x02,
         N_EXTRA      = 0x04,
 
         N_ABOVE_FILTHY = 0x08,
         N_FILTHY_ORIGINAL   = 0x10, // not used actually
         N_FILTHY_PROJECTION = 0x20,
         N_FILTHY = 0x40,
         N_BELOW_FILTHY = 0x80
     };
 
     #define GRAPH_POSITION_MASK     0x07
 
     static inline KisNode::PositionToFilthy convertPositionToFilthy(NodePosition position) {
         static const int positionToFilthyMask =
             N_ABOVE_FILTHY |
             N_FILTHY_PROJECTION |
             N_FILTHY |
             N_BELOW_FILTHY;
 
         qint32 positionToFilthy = position & N_EXTRA ? N_FILTHY : position & positionToFilthyMask;
         // We do not use N_FILTHY_ORIGINAL yet, so...
         Q_ASSERT(positionToFilthy);
 
         return static_cast<KisNode::PositionToFilthy>(positionToFilthy);
     }
 
     struct CloneNotification {
         CloneNotification() {}
         CloneNotification(KisNodeSP node, const QRect &dirtyRect)
             : m_layer(qobject_cast<KisLayer*>(node.data())),
               m_dirtyRect(dirtyRect) {}
 
         void notify() {
             Q_ASSERT(m_layer); // clones are possible for layers only
             m_layer->updateClones(m_dirtyRect);
         }
 
     private:
         friend class KisWalkersTest;
 
         KisLayerSP m_layer;
         QRect m_dirtyRect;
     };
 
     typedef QVector<CloneNotification> CloneNotificationsVector;
 
     struct JobItem {
         KisProjectionLeafSP m_leaf;
         NodePosition m_position;
 
         /**
          * The rect that should be prepared on this node.
          * E.g. area where the filter applies on filter layer
          * or an area of a paint layer that will be copied to
          * the projection.
          */
         QRect m_applyRect;
     };
 
     typedef QStack<JobItem> LeafStack;
 
 public:
     KisBaseRectsWalker()
         : m_levelOfDetail(0)
     {
     }
 
     virtual ~KisBaseRectsWalker() {
     }
 
     void collectRects(KisNodeSP node, const QRect& requestedRect) {
         clear();
 
         KisProjectionLeafSP startLeaf = node->projectionLeaf();
 
         m_nodeChecksum = calculateChecksum(startLeaf, requestedRect);
         m_graphChecksum = node->graphSequenceNumber();
         m_resultChangeRect = requestedRect;
         m_resultUncroppedChangeRect = requestedRect;
         m_requestedRect = requestedRect;
         m_startNode = node;
         m_levelOfDetail = getNodeLevelOfDetail(startLeaf);
         startTrip(startLeaf);
     }
 
     inline void recalculate(const QRect& requestedRect) {
-        Q_ASSERT(m_startNode);
+        KIS_SAFE_ASSERT_RECOVER_RETURN(m_startNode);
 
         KisProjectionLeafSP startLeaf = m_startNode->projectionLeaf();
 
         int calculatedLevelOfDetail = getNodeLevelOfDetail(startLeaf);
 
         if (m_levelOfDetail != calculatedLevelOfDetail) {
             qWarning() << "WARNING: KisBaseRectsWalker::recalculate()"
                        << "The levelOfDetail has changes with time,"
                        << "which couldn't have happened!"
                        << ppVar(m_levelOfDetail)
                        << ppVar(calculatedLevelOfDetail);
 
             m_levelOfDetail = calculatedLevelOfDetail;
         }
 
         if(startLeaf->isStillInGraph()) {
             collectRects(m_startNode, requestedRect);
         }
         else {
             clear();
             m_nodeChecksum = calculateChecksum(startLeaf, requestedRect);
             m_graphChecksum = m_startNode->graphSequenceNumber();
             m_resultChangeRect = QRect();
             m_resultUncroppedChangeRect = QRect();
         }
     }
 
     bool checksumValid() {
-        Q_ASSERT(m_startNode);
+        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(m_startNode, false);
         return
             m_nodeChecksum == calculateChecksum(m_startNode->projectionLeaf(), m_requestedRect) &&
             m_graphChecksum == m_startNode->graphSequenceNumber();
     }
 
     inline void setCropRect(QRect cropRect) {
         m_cropRect = cropRect;
     }
 
     inline QRect cropRect() const{
         return m_cropRect;
     }
 
     // return a reference for efficiency reasons
     inline LeafStack& leafStack() {
         return m_mergeTask;
     }
 
     // return a reference for efficiency reasons
     inline CloneNotificationsVector& cloneNotifications() {
         return m_cloneNotifications;
     }
 
     inline QRect accessRect() const {
         return m_resultAccessRect;
     }
 
     inline QRect changeRect() const {
         return m_resultChangeRect;
     }
 
     inline QRect uncroppedChangeRect() const {
         return m_resultUncroppedChangeRect;
     }
 
     inline bool needRectVaries() const {
         return m_needRectVaries;
     }
 
     inline bool changeRectVaries() const {
         return m_changeRectVaries;
     }
 
     inline KisNodeSP startNode() const {
         return m_startNode;
     }
 
     inline QRect requestedRect() const {
         return m_requestedRect;
     }
 
     inline int levelOfDetail() const {
         return m_levelOfDetail;
     }
 
     virtual UpdateType type() const = 0;
 
 protected:
 
     /**
      * Initiates collecting of rects.
      * Should be implemented in derived classes
      */
     virtual void startTrip(KisProjectionLeafSP startWith) = 0;
 
 protected:
 
     static inline qint32 getGraphPosition(qint32 position) {
         return position & GRAPH_POSITION_MASK;
     }
 
     static inline bool hasClones(KisNodeSP node) {
         KisLayer *layer = qobject_cast<KisLayer*>(node.data());
         return layer && layer->hasClones();
     }
 
     static inline NodePosition calculateNodePosition(KisProjectionLeafSP leaf) {
         KisProjectionLeafSP nextLeaf = leaf->nextSibling();
         while(nextLeaf && !nextLeaf->isLayer()) nextLeaf = nextLeaf->nextSibling();
         if (!nextLeaf) return N_TOPMOST;
 
         KisProjectionLeafSP prevLeaf = leaf->prevSibling();
         while(prevLeaf && !prevLeaf->isLayer()) prevLeaf = prevLeaf->prevSibling();
         if (!prevLeaf) return N_BOTTOMMOST;
 
         return N_NORMAL;
     }
 
     inline bool isStartLeaf(KisProjectionLeafSP leaf) const {
         return leaf->node() == m_startNode;
     }
 
     inline void clear() {
         m_resultAccessRect = m_resultNeedRect = /*m_resultChangeRect =*/
             m_childNeedRect = m_lastNeedRect = QRect();
 
         m_needRectVaries = m_changeRectVaries = false;
         m_mergeTask.clear();
         m_cloneNotifications.clear();
 
         // Not needed really. Think over removing.
         //m_startNode = 0;
         //m_requestedRect = QRect();
     }
 
     inline void pushJob(KisProjectionLeafSP leaf, NodePosition position, QRect applyRect) {
         JobItem item = {leaf, position, applyRect};
         m_mergeTask.push(item);
     }
 
     inline QRect cropThisRect(const QRect& rect) {
         return m_cropRect.isValid() ? rect & m_cropRect : rect;
     }
 
     /**
      * Used by KisFullRefreshWalker as it has a special changeRect strategy
      */
     inline void setExplicitChangeRect(const QRect &changeRect, bool changeRectVaries) {
         m_resultChangeRect = changeRect;
         m_resultUncroppedChangeRect = changeRect;
         m_changeRectVaries = changeRectVaries;
     }
 
     /**
      * Called for every node we meet on a forward way of the trip.
      */
     virtual void registerChangeRect(KisProjectionLeafSP leaf, NodePosition position) {
         // We do not work with masks here. It is KisLayer's job.
         if(!leaf->isLayer()) return;
         if(!(position & N_FILTHY) && !leaf->visible()) return;
 
         QRect currentChangeRect = leaf->projectionPlane()->changeRect(m_resultChangeRect,
                                                                       convertPositionToFilthy(position));
         currentChangeRect = cropThisRect(currentChangeRect);
 
         if(!m_changeRectVaries)
             m_changeRectVaries = currentChangeRect != m_resultChangeRect;
 
         m_resultChangeRect = currentChangeRect;
 
         m_resultUncroppedChangeRect = leaf->projectionPlane()->changeRect(m_resultUncroppedChangeRect,
                                                                           convertPositionToFilthy(position));
         registerCloneNotification(leaf->node(), position);
     }
 
     void registerCloneNotification(KisNodeSP node, NodePosition position) {
         /**
          * Note, we do not check for (N_ABOVE_FILTHY &&
          * dependOnLowerNodes(node)) because it may lead to an
          * infinite loop with filter layer. Activate it when it is
          * guaranteed that it is not possible to create a filter layer
          * avobe its own clone
          */
 
         if(hasClones(node) && position & (N_FILTHY | N_FILTHY_PROJECTION | N_EXTRA)) {
             m_cloneNotifications.append(
                 CloneNotification(node, m_resultUncroppedChangeRect));
         }
     }
 
     /**
      * Called for every node we meet on a backward way of the trip.
      */
     virtual void registerNeedRect(KisProjectionLeafSP leaf, NodePosition position) {
         // We do not work with masks here. It is KisLayer's job.
         if(!leaf->isLayer()) return;
 
         if(m_mergeTask.isEmpty())
             m_resultAccessRect = m_resultNeedRect = m_childNeedRect =
                 m_lastNeedRect = m_resultChangeRect;
 
         QRect currentNeedRect;
 
         if(position & N_TOPMOST)
             m_lastNeedRect = m_childNeedRect;
 
         if (!leaf->visible()) {
             if (!m_lastNeedRect.isEmpty()) {
                 // push a dumb job to fit state machine requirements
                 pushJob(leaf, position, m_lastNeedRect);
             }
         } else if(position & (N_FILTHY | N_ABOVE_FILTHY | N_EXTRA)) {
             if(!m_lastNeedRect.isEmpty())
                 pushJob(leaf, position, m_lastNeedRect);
             //else /* Why push empty rect? */;
 
             m_resultAccessRect |= leaf->projectionPlane()->accessRect(m_lastNeedRect,
                                                                       convertPositionToFilthy(position));
 
             m_lastNeedRect = leaf->projectionPlane()->needRect(m_lastNeedRect,
                                                                convertPositionToFilthy(position));
             m_lastNeedRect = cropThisRect(m_lastNeedRect);
             m_childNeedRect = m_lastNeedRect;
         }
         else if(position & (N_BELOW_FILTHY | N_FILTHY_PROJECTION)) {
             if(!m_lastNeedRect.isEmpty()) {
                 pushJob(leaf, position, m_lastNeedRect);
 
                 m_resultAccessRect |= leaf->projectionPlane()->accessRect(m_lastNeedRect,
                                                                           convertPositionToFilthy(position));
 
                 m_lastNeedRect = leaf->projectionPlane()->needRect(m_lastNeedRect,
                                                                    convertPositionToFilthy(position));
                 m_lastNeedRect = cropThisRect(m_lastNeedRect);
             }
         }
         else {
             // N_FILTHY_ORIGINAL is not used so it goes there
             qFatal("KisBaseRectsWalker: node position(%d) is out of range", position);
         }
 
         if(!m_needRectVaries)
             m_needRectVaries = m_resultNeedRect != m_lastNeedRect;
         m_resultNeedRect |= m_lastNeedRect;
     }
 
     virtual void adjustMasksChangeRect(KisProjectionLeafSP firstMask) {
         KisProjectionLeafSP currentLeaf = firstMask;
 
         while (currentLeaf) {
             /**
              * ATTENTION: we miss the first mask
              */
 
             do {
                 currentLeaf = currentLeaf->nextSibling();
             } while (currentLeaf &&
                      (!currentLeaf->isMask() || !currentLeaf->visible()));
 
             if(currentLeaf) {
                 QRect changeRect = currentLeaf->projectionPlane()->changeRect(m_resultChangeRect);
                 m_changeRectVaries |= changeRect != m_resultChangeRect;
                 m_resultChangeRect = changeRect;
                 m_resultUncroppedChangeRect = changeRect;
             }
         }
 
         KisProjectionLeafSP parentLayer = firstMask->parent();
         KIS_SAFE_ASSERT_RECOVER_RETURN(parentLayer);
 
         registerCloneNotification(parentLayer->node(), N_FILTHY_PROJECTION);
     }
 
     static qint32 calculateChecksum(KisProjectionLeafSP leaf, const QRect &requestedRect) {
         qint32 checksum = 0;
         qint32 x, y, w, h;
         QRect tempRect;
 
         tempRect = leaf->projectionPlane()->changeRect(requestedRect);
         tempRect.getRect(&x, &y, &w, &h);
         checksum += -x - y + w + h;
 
         tempRect = leaf->projectionPlane()->needRect(requestedRect);
         tempRect.getRect(&x, &y, &w, &h);
         checksum += -x - y + w + h;
 
 //        errKrita << leaf << requestedRect << "-->" << checksum;
 
         return checksum;
     }
 
 private:
     inline int getNodeLevelOfDetail(KisProjectionLeafSP leaf) {
         while (!leaf->projection()) {
             leaf = leaf->parent();
         }
 
         KIS_ASSERT_RECOVER(leaf->projection()) {
             return 0;
         }
 
         return leaf->projection()->defaultBounds()->currentLevelOfDetail();
     }
 
 private:
     /**
      * The result variables.
      * By the end of a recursion they will store a complete
      * data for a successful merge operation.
      */
     QRect m_resultAccessRect;
     QRect m_resultNeedRect;
     QRect m_resultChangeRect;
     QRect m_resultUncroppedChangeRect;
     bool m_needRectVaries;
     bool m_changeRectVaries;
     LeafStack m_mergeTask;
     CloneNotificationsVector m_cloneNotifications;
 
     /**
      * Used by update optimization framework
      */
     KisNodeSP m_startNode;
     QRect m_requestedRect;
 
     /**
      * Used for getting know whether the start node
      * properties have changed since the walker was
      * calculated
      */
     qint32 m_nodeChecksum;
 
     /**
      * Used for getting know whether the structure of
      * the graph has changed since the walker was
      * calculated
      */
     qint32 m_graphChecksum;
 
     /**
      * Temporary variables
      */
     QRect m_cropRect;
 
     QRect m_childNeedRect;
     QRect m_lastNeedRect;
 
     int m_levelOfDetail;
 };
 
 #endif /* __KIS_BASE_RECTS_WALKER_H */
 
diff --git a/libs/image/kis_brush_mask_applicator_factories.cpp b/libs/image/kis_brush_mask_applicator_factories.cpp
index d89ee70e15..a8e78690a5 100644
--- a/libs/image/kis_brush_mask_applicator_factories.cpp
+++ b/libs/image/kis_brush_mask_applicator_factories.cpp
@@ -1,654 +1,654 @@
 /*
  *  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_brush_mask_applicator_factories.h"
 #include "vc_extra_math.h"
 
 #include "kis_circle_mask_generator.h"
 #include "kis_circle_mask_generator_p.h"
 #include "kis_gauss_circle_mask_generator_p.h"
 #include "kis_curve_circle_mask_generator_p.h"
 #include "kis_gauss_rect_mask_generator_p.h"
 #include "kis_curve_rect_mask_generator_p.h"
 #include "kis_rect_mask_generator_p.h"
 
 #include "kis_brush_mask_applicators.h"
 #include "kis_brush_mask_applicator_base.h"
 
 #define a(_s) #_s
 #define b(_s) a(_s)
 
 template<>
 template<>
 MaskApplicatorFactory<KisMaskGenerator, KisBrushMaskScalarApplicator>::ReturnType
 MaskApplicatorFactory<KisMaskGenerator, KisBrushMaskScalarApplicator>::create<Vc::CurrentImplementation::current()>(ParamType maskGenerator)
 {
     return new KisBrushMaskScalarApplicator<KisMaskGenerator,Vc::CurrentImplementation::current()>(maskGenerator);
 }
 
 template<>
 template<>
 MaskApplicatorFactory<KisCircleMaskGenerator, KisBrushMaskVectorApplicator>::ReturnType
 MaskApplicatorFactory<KisCircleMaskGenerator, KisBrushMaskVectorApplicator>::create<Vc::CurrentImplementation::current()>(ParamType maskGenerator)
 {
     return new KisBrushMaskVectorApplicator<KisCircleMaskGenerator,Vc::CurrentImplementation::current()>(maskGenerator);
 }
 
 template<>
 template<>
 MaskApplicatorFactory<KisGaussCircleMaskGenerator, KisBrushMaskVectorApplicator>::ReturnType
 MaskApplicatorFactory<KisGaussCircleMaskGenerator, KisBrushMaskVectorApplicator>::create<Vc::CurrentImplementation::current()>(ParamType maskGenerator)
 {
     return new KisBrushMaskVectorApplicator<KisGaussCircleMaskGenerator,Vc::CurrentImplementation::current()>(maskGenerator);
 }
 
 template<>
 template<>
 MaskApplicatorFactory<KisCurveCircleMaskGenerator, KisBrushMaskVectorApplicator>::ReturnType
 MaskApplicatorFactory<KisCurveCircleMaskGenerator, KisBrushMaskVectorApplicator>::create<Vc::CurrentImplementation::current()>(ParamType maskGenerator)
 {
     return new KisBrushMaskVectorApplicator<KisCurveCircleMaskGenerator,Vc::CurrentImplementation::current()>(maskGenerator);
 }
 
 template<>
 template<>
 MaskApplicatorFactory<KisRectangleMaskGenerator, KisBrushMaskVectorApplicator>::ReturnType
 MaskApplicatorFactory<KisRectangleMaskGenerator, KisBrushMaskVectorApplicator>::create<Vc::CurrentImplementation::current()>(ParamType maskGenerator)
 {
     return new KisBrushMaskVectorApplicator<KisRectangleMaskGenerator,Vc::CurrentImplementation::current()>(maskGenerator);
 }
 
 template<>
 template<>
 MaskApplicatorFactory<KisGaussRectangleMaskGenerator, KisBrushMaskVectorApplicator>::ReturnType
 MaskApplicatorFactory<KisGaussRectangleMaskGenerator, KisBrushMaskVectorApplicator>::create<Vc::CurrentImplementation::current()>(ParamType maskGenerator)
 {
     return new KisBrushMaskVectorApplicator<KisGaussRectangleMaskGenerator,Vc::CurrentImplementation::current()>(maskGenerator);
 }
 
 template<>
 template<>
 MaskApplicatorFactory<KisCurveRectangleMaskGenerator, KisBrushMaskVectorApplicator>::ReturnType
 MaskApplicatorFactory<KisCurveRectangleMaskGenerator, KisBrushMaskVectorApplicator>::create<Vc::CurrentImplementation::current()>(ParamType maskGenerator)
 {
     return new KisBrushMaskVectorApplicator<KisCurveRectangleMaskGenerator,Vc::CurrentImplementation::current()>(maskGenerator);
 }
 
 
 #if defined HAVE_VC
 
 struct KisCircleMaskGenerator::FastRowProcessor
 {
     FastRowProcessor(KisCircleMaskGenerator *maskGenerator)
         : d(maskGenerator->d.data()) {}
 
     template<Vc::Implementation _impl>
     void process(float* buffer, int width, float y, float cosa, float sina,
                  float centerX, float centerY);
 
     KisCircleMaskGenerator::Private *d;
 };
 
 template<> void KisCircleMaskGenerator::
 FastRowProcessor::process<Vc::CurrentImplementation::current()>(float* buffer, int width, float y, float cosa, float sina,
                                    float centerX, float centerY)
 {
     const bool useSmoothing = d->copyOfAntialiasEdges;
     const bool noFading = d->noFading;
 
     float y_ = y - centerY;
     float sinay_ = sina * y_;
     float cosay_ = cosa * y_;
 
     float* bufferPointer = buffer;
 
     Vc::float_v currentIndices = Vc::float_v::IndexesFromZero();
 
     Vc::float_v increment((float)Vc::float_v::size());
     Vc::float_v vCenterX(centerX);
 
     Vc::float_v vCosa(cosa);
     Vc::float_v vSina(sina);
     Vc::float_v vCosaY_(cosay_);
     Vc::float_v vSinaY_(sinay_);
 
     Vc::float_v vXCoeff(d->xcoef);
     Vc::float_v vYCoeff(d->ycoef);
 
     Vc::float_v vTransformedFadeX(d->transformedFadeX);
     Vc::float_v vTransformedFadeY(d->transformedFadeY);
 
     Vc::float_v vOne(Vc::One);
 
     for (int i=0; i < width; i+= Vc::float_v::size()){
 
         Vc::float_v x_ = currentIndices - vCenterX;
 
         Vc::float_v xr = x_ * vCosa - vSinaY_;
         Vc::float_v yr = x_ * vSina + vCosaY_;
 
         Vc::float_v n = pow2(xr * vXCoeff) + pow2(yr * vYCoeff);
         Vc::float_m outsideMask = n > vOne;
 
         if (!outsideMask.isFull()) {
 
             if (noFading) {
                 Vc::float_v vFade(Vc::Zero);
                 vFade(outsideMask) = vOne;
                 vFade.store(bufferPointer, Vc::Aligned);
             } else {
                 if (useSmoothing) {
                     xr = Vc::abs(xr) + vOne;
                     yr = Vc::abs(yr) + vOne;
                 }
 
                 Vc::float_v vNormFade = pow2(xr * vTransformedFadeX) + pow2(yr * vTransformedFadeY);
 
                 //255 * n * (normeFade - 1) / (normeFade - n)
                 Vc::float_v vFade = n * (vNormFade - vOne) / (vNormFade - n);
 
                 // Mask in the inner circe of the mask
                 Vc::float_m mask = vNormFade < vOne;
                 vFade.setZero(mask);
 
                 // Mask out the outer circe of the mask
                 vFade(outsideMask) = vOne;
 
                 vFade.store(bufferPointer, Vc::Aligned);
             }
         } else {
             // Mask out everything outside the circle
             vOne.store(bufferPointer, Vc::Aligned);
         }
 
         currentIndices = currentIndices + increment;
 
         bufferPointer += Vc::float_v::size();
     }
 }
 
 
 struct KisGaussCircleMaskGenerator::FastRowProcessor
 {
     FastRowProcessor(KisGaussCircleMaskGenerator *maskGenerator)
         : d(maskGenerator->d.data()) {}
 
     template<Vc::Implementation _impl>
     void process(float* buffer, int width, float y, float cosa, float sina,
                  float centerX, float centerY);
 
     KisGaussCircleMaskGenerator::Private *d;
 };
 
 template<> void KisGaussCircleMaskGenerator::
 FastRowProcessor::process<Vc::CurrentImplementation::current()>(float* buffer, int width, float y, float cosa, float sina,
                                    float centerX, float centerY)
 {
     float y_ = y - centerY;
     float sinay_ = sina * y_;
     float cosay_ = cosa * y_;
 
     float* bufferPointer = buffer;
 
     Vc::float_v currentIndices = Vc::float_v::IndexesFromZero();
 
     Vc::float_v increment((float)Vc::float_v::size());
     Vc::float_v vCenterX(centerX);
     Vc::float_v vCenter(d->center);
 
     Vc::float_v vCosa(cosa);
     Vc::float_v vSina(sina);
     Vc::float_v vCosaY_(cosay_);
     Vc::float_v vSinaY_(sinay_);
 
     Vc::float_v vYCoeff(d->ycoef);
     Vc::float_v vDistfactor(d->distfactor);
     Vc::float_v vAlphafactor(d->alphafactor);
 
     Vc::float_v vZero(Vc::Zero);
     Vc::float_v vValMax(255.f);
 
     for (int i=0; i < width; i+= Vc::float_v::size()){
 
         Vc::float_v x_ = currentIndices - vCenterX;
 
         Vc::float_v xr = x_ * vCosa - vSinaY_;
         Vc::float_v yr = x_ * vSina + vCosaY_;
 
         Vc::float_v dist = sqrt(pow2(xr) + pow2(yr * vYCoeff));
 
         // Apply FadeMaker mask and operations
         Vc::float_m excludeMask = d->fadeMaker.needFade(dist);
 
         if (!excludeMask.isFull()) {
             Vc::float_v valDist = dist * vDistfactor;
             Vc::float_v fullFade = vAlphafactor * (  VcExtraMath::erf(valDist + vCenter) -  VcExtraMath::erf(valDist - vCenter));
 
             Vc::float_m mask;
             // Mask in the inner circe of the mask
             mask = fullFade < vZero;
             fullFade.setZero(mask);
 
             // Mask the outter circle
             mask = fullFade > 254.974f;
             fullFade(mask) = vValMax;
 
             // Mask (value - value), presicion errors.
             Vc::float_v vFade = (vValMax - fullFade) / vValMax;
 
             // return original dist values before vFade transform
             vFade(excludeMask) = dist;
             vFade.store(bufferPointer, Vc::Aligned);
 
         } else {
           dist.store(bufferPointer, Vc::Aligned);
       }
       currentIndices = currentIndices + increment;
 
       bufferPointer += Vc::float_v::size();
     }
 }
 
 struct KisCurveCircleMaskGenerator::FastRowProcessor
 {
     FastRowProcessor(KisCurveCircleMaskGenerator *maskGenerator)
         : d(maskGenerator->d.data()) {}
 
     template<Vc::Implementation _impl>
     void process(float* buffer, int width, float y, float cosa, float sina,
                  float centerX, float centerY);
 
     KisCurveCircleMaskGenerator::Private *d;
 };
 
 
 template<> void KisCurveCircleMaskGenerator::
 FastRowProcessor::process<Vc::CurrentImplementation::current()>(float* buffer, int width, float y, float cosa, float sina,
                                    float centerX, float centerY)
 {
     float y_ = y - centerY;
     float sinay_ = sina * y_;
     float cosay_ = cosa * y_;
 
     float* bufferPointer = buffer;
 
     qreal* curveDataPointer = d->curveData.data();
 
     Vc::float_v currentIndices = Vc::float_v::IndexesFromZero();
 
     Vc::float_v increment((float)Vc::float_v::size());
     Vc::float_v vCenterX(centerX);
 
     Vc::float_v vCosa(cosa);
     Vc::float_v vSina(sina);
     Vc::float_v vCosaY_(cosay_);
     Vc::float_v vSinaY_(sinay_);
 
     Vc::float_v vYCoeff(d->ycoef);
     Vc::float_v vXCoeff(d->xcoef);
     Vc::float_v vCurveResolution(d->curveResolution);
 
     Vc::float_v vCurvedData(Vc::Zero);
     Vc::float_v vCurvedData1(Vc::Zero);
 
     Vc::float_v vOne(Vc::One);
     Vc::float_v vZero(Vc::Zero);
 
     for (int i=0; i < width; i+= Vc::float_v::size()){
 
         Vc::float_v x_ = currentIndices - vCenterX;
 
         Vc::float_v xr = x_ * vCosa - vSinaY_;
         Vc::float_v yr = x_ * vSina + vCosaY_;
 
         Vc::float_v dist = pow2(xr * vXCoeff) + pow2(yr * vYCoeff);
 
         // Apply FadeMaker mask and operations
         Vc::float_m excludeMask = d->fadeMaker.needFade(dist);
 
         if (!excludeMask.isFull()) {
             Vc::float_v valDist = dist * vCurveResolution;
             // truncate
             Vc::float_v::IndexType vAlphaValue(valDist);
             Vc::float_v vFloatAlphaValue = vAlphaValue;
 
             Vc::float_v alphaValueF = valDist - vFloatAlphaValue;
 
             vCurvedData.gather(curveDataPointer,vAlphaValue);
             vCurvedData1.gather(curveDataPointer,vAlphaValue + 1);
 //            Vc::float_v vCurvedData1(curveDataPointer,vAlphaValue + 1);
 
             // vAlpha
             Vc::float_v fullFade = (
                 (vOne - alphaValueF) * vCurvedData +
                 alphaValueF * vCurvedData1);
 
             Vc::float_m mask;
             // Mask in the inner circe of the mask
             mask = fullFade < vZero;
             fullFade.setZero(mask);
 
             // Mask outer circle of mask
             mask = fullFade >= vOne;
             Vc::float_v vFade = (vOne - fullFade);
             vFade.setZero(mask);
 
             // return original dist values before vFade transform
             vFade(excludeMask) = dist;
             vFade.store(bufferPointer, Vc::Aligned);
 
         } else {
           dist.store(bufferPointer, Vc::Aligned);
       }
       currentIndices = currentIndices + increment;
 
       bufferPointer += Vc::float_v::size();
     }
 }
 
 struct KisGaussRectangleMaskGenerator::FastRowProcessor
 {
     FastRowProcessor(KisGaussRectangleMaskGenerator *maskGenerator)
         : d(maskGenerator->d.data()) {}
 
     template<Vc::Implementation _impl>
     void process(float* buffer, int width, float y, float cosa, float sina,
                  float centerX, float centerY);
 
     KisGaussRectangleMaskGenerator::Private *d;
 };
 
 struct KisRectangleMaskGenerator::FastRowProcessor
 {
     FastRowProcessor(KisRectangleMaskGenerator *maskGenerator)
         : d(maskGenerator->d.data()) {}
 
     template<Vc::Implementation _impl>
     void process(float* buffer, int width, float y, float cosa, float sina,
                  float centerX, float centerY);
 
     KisRectangleMaskGenerator::Private *d;
 };
 
 template<> void KisRectangleMaskGenerator::
 FastRowProcessor::process<Vc::CurrentImplementation::current()>(float* buffer, int width, float y, float cosa, float sina,
                                    float centerX, float centerY)
 {
     const bool useSmoothing = d->copyOfAntialiasEdges;
 
     float y_ = y - centerY;
     float sinay_ = sina * y_;
     float cosay_ = cosa * y_;
 
     float* bufferPointer = buffer;
 
     Vc::float_v currentIndices = Vc::float_v::IndexesFromZero();
 
     Vc::float_v increment((float)Vc::float_v::size());
     Vc::float_v vCenterX(centerX);
 
     Vc::float_v vCosa(cosa);
     Vc::float_v vSina(sina);
     Vc::float_v vCosaY_(cosay_);
     Vc::float_v vSinaY_(sinay_);
 
     Vc::float_v vXCoeff(d->xcoeff);
     Vc::float_v vYCoeff(d->ycoeff);
 
     Vc::float_v vTransformedFadeX(d->transformedFadeX);
     Vc::float_v vTransformedFadeY(d->transformedFadeY);
 
     Vc::float_v vOne(Vc::One);
     Vc::float_v vZero(Vc::Zero);
     Vc::float_v vTolerance(10000.f);
 
     for (int i=0; i < width; i+= Vc::float_v::size()){
 
         Vc::float_v x_ = currentIndices - vCenterX;
 
         Vc::float_v xr = Vc::abs(x_ * vCosa - vSinaY_);
         Vc::float_v yr = Vc::abs(x_ * vSina + vCosaY_);
 
         Vc::float_v nxr = xr * vXCoeff;
         Vc::float_v nyr = yr * vYCoeff;
 
         Vc::float_m outsideMask = (nxr > vOne) || (nyr > vOne);
 
         if (!outsideMask.isFull()) {
             if (useSmoothing) {
                 xr = Vc::abs(xr) + vOne;
                 yr = Vc::abs(yr) + vOne;
             }
 
             Vc::float_v fxr = xr * vTransformedFadeX;
             Vc::float_v fyr = yr * vTransformedFadeY;
 
             Vc::float_v fxrNorm = nxr * (fxr - vOne) / (fxr - nxr);
             Vc::float_v fyrNorm = nyr * (fyr - vOne) / (fyr - nyr);
 
             Vc::float_v vFade(vZero);
 
             Vc::float_v::IndexType fxrInt(fxr * vTolerance);
             Vc::float_v::IndexType fyrInt(fyr * vTolerance);
 
             Vc::float_m fadeXMask = (fxr > vOne) && ((fxrInt >= fyrInt) || fyr < vOne);
             Vc::float_m fadeYMask = (fyr > vOne) && ((fyrInt > fxrInt) || fxr < vOne);
 
             vFade(fadeXMask) = fxrNorm;
             vFade(!fadeXMask && fadeYMask) = fyrNorm;
 
             // Mask out the outer circe of the mask
             vFade(outsideMask) = vOne;
             vFade.store(bufferPointer, Vc::Aligned);
         } else {
             // Mask out everything outside the circle
             vOne.store(bufferPointer, Vc::Aligned);
         }
 
         currentIndices = currentIndices + increment;
 
         bufferPointer += Vc::float_v::size();
     }
 }
 
 
 template<> void KisGaussRectangleMaskGenerator::
 FastRowProcessor::process<Vc::CurrentImplementation::current()>(float* buffer, int width, float y, float cosa, float sina,
                                    float centerX, float centerY)
 {
     float y_ = y - centerY;
     float sinay_ = sina * y_;
     float cosay_ = cosa * y_;
 
     float* bufferPointer = buffer;
 
     Vc::float_v currentIndices = Vc::float_v::IndexesFromZero();
 
     Vc::float_v increment((float)Vc::float_v::size());
     Vc::float_v vCenterX(centerX);
 
     Vc::float_v vCosa(cosa);
     Vc::float_v vSina(sina);
     Vc::float_v vCosaY_(cosay_);
     Vc::float_v vSinaY_(sinay_);
 
     Vc::float_v vhalfWidth(d->halfWidth);
     Vc::float_v vhalfHeight(d->halfHeight);
     Vc::float_v vXFade(d->xfade);
     Vc::float_v vYFade(d->yfade);
 
     Vc::float_v vAlphafactor(d->alphafactor);
 
     Vc::float_v vOne(Vc::One);
     Vc::float_v vZero(Vc::Zero);
     Vc::float_v vValMax(255.f);
 
     for (int i=0; i < width; i+= Vc::float_v::size()){
 
         Vc::float_v x_ = currentIndices - vCenterX;
 
         Vc::float_v xr = x_ * vCosa - vSinaY_;
-        Vc::float_v yr = abs(x_ * vSina + vCosaY_);
+        Vc::float_v yr = Vc::abs(x_ * vSina + vCosaY_);
 
         Vc::float_v vValue;
 
         // check if we need to apply fader on values
         Vc::float_m excludeMask = d->fadeMaker.needFade(xr,yr);
         vValue(excludeMask) = vOne;
 
         if (!excludeMask.isFull()) {
             Vc::float_v fullFade = vValMax - (vAlphafactor * (VcExtraMath::erf((vhalfWidth + xr) * vXFade) + VcExtraMath::erf((vhalfWidth - xr) * vXFade))
                                         * (VcExtraMath::erf((vhalfHeight + yr) * vYFade) + VcExtraMath::erf((vhalfHeight - yr) * vYFade)));
 
             // apply antialias fader
             d->fadeMaker.apply2DFader(fullFade,excludeMask,xr,yr);
 
             Vc::float_m mask;
 
             // Mask in the inner circe of the mask
             mask = fullFade < vZero;
             fullFade.setZero(mask);
 
             // Mask the outter circle
             mask = fullFade > 254.974f;
             fullFade(mask) = vValMax;
 
             // Mask (value - value), presicion errors.
             Vc::float_v vFade = fullFade / vValMax;
 
             // return original vValue values before vFade transform
             vFade(excludeMask) = vValue;
             vFade.store(bufferPointer, Vc::Aligned);
 
         } else {
           vValue.store(bufferPointer, Vc::Aligned);
       }
       currentIndices = currentIndices + increment;
 
       bufferPointer += Vc::float_v::size();
     }
 }
 
 struct KisCurveRectangleMaskGenerator::FastRowProcessor
 {
     FastRowProcessor(KisCurveRectangleMaskGenerator *maskGenerator)
         : d(maskGenerator->d.data()) {}
 
     template<Vc::Implementation _impl>
     void process(float* buffer, int width, float y, float cosa, float sina,
                  float centerX, float centerY);
 
     KisCurveRectangleMaskGenerator::Private *d;
 };
 
 template<> void KisCurveRectangleMaskGenerator::
 FastRowProcessor::process<Vc::CurrentImplementation::current()>(float* buffer, int width, float y, float cosa, float sina,
                                    float centerX, float centerY)
 {
     float y_ = y - centerY;
     float sinay_ = sina * y_;
     float cosay_ = cosa * y_;
 
     float* bufferPointer = buffer;
 
     qreal* curveDataPointer = d->curveData.data();
 
     Vc::float_v currentIndices = Vc::float_v::IndexesFromZero();
 
     Vc::float_v increment((float)Vc::float_v::size());
     Vc::float_v vCenterX(centerX);
 
     Vc::float_v vCosa(cosa);
     Vc::float_v vSina(sina);
     Vc::float_v vCosaY_(cosay_);
     Vc::float_v vSinaY_(sinay_);
 
     Vc::float_v vYCoeff(d->ycoeff);
     Vc::float_v vXCoeff(d->xcoeff);
     Vc::float_v vCurveResolution(d->curveResolution);
 
     Vc::float_v vOne(Vc::One);
     Vc::float_v vZero(Vc::Zero);
     Vc::float_v vValMax(255.f);
 
     for (int i=0; i < width; i+= Vc::float_v::size()){
 
         Vc::float_v x_ = currentIndices - vCenterX;
 
         Vc::float_v xr = x_ * vCosa - vSinaY_;
-        Vc::float_v yr = abs(x_ * vSina + vCosaY_);
+        Vc::float_v yr = Vc::abs(x_ * vSina + vCosaY_);
 
         Vc::float_v vValue;
 
         // check if we need to apply fader on values
         Vc::float_m excludeMask = d->fadeMaker.needFade(xr,yr);
         vValue(excludeMask) = vOne;
 
         if (!excludeMask.isFull()) {
             // We need to mask the extra area given for aliniation
             // the next operation should never give values above 1
-            Vc::float_v preSIndex = abs(xr) * vXCoeff;
-            Vc::float_v preTIndex = abs(yr) * vYCoeff;
+            Vc::float_v preSIndex = Vc::abs(xr) * vXCoeff;
+            Vc::float_v preTIndex = Vc::abs(yr) * vYCoeff;
 
             preSIndex(preSIndex > vOne) = vOne;
             preTIndex(preTIndex > vOne) = vOne;
 
             Vc::float_v::IndexType sIndex( round(preSIndex * vCurveResolution));
             Vc::float_v::IndexType tIndex( round(preTIndex * vCurveResolution));
 
             Vc::float_v::IndexType sIndexInverted = vCurveResolution - sIndex;
             Vc::float_v::IndexType tIndexInverted = vCurveResolution - tIndex;
 
             Vc::float_v vCurvedDataSIndex(curveDataPointer, sIndex);
             Vc::float_v vCurvedDataTIndex(curveDataPointer, tIndex);
             Vc::float_v vCurvedDataSIndexInv(curveDataPointer, sIndexInverted);
             Vc::float_v vCurvedDataTIndexInv(curveDataPointer, tIndexInverted);
 
             Vc::float_v fullFade = vValMax * (vOne - (vCurvedDataSIndex * (vOne - vCurvedDataSIndexInv) *
                                     vCurvedDataTIndex * (vOne - vCurvedDataTIndexInv)));
 
             // apply antialias fader
             d->fadeMaker.apply2DFader(fullFade,excludeMask,xr,yr);
 
             Vc::float_m mask;
 
             // Mask in the inner circe of the mask
             mask = fullFade < vZero;
             fullFade.setZero(mask);
 
             // Mask the outter circle
             mask = fullFade > 254.974f;
             fullFade(mask) = vValMax;
 
             // Mask (value - value), presicion errors.
             Vc::float_v vFade = fullFade / vValMax;
 
             // return original vValue values before vFade transform
             vFade(excludeMask) = vValue;
             vFade.store(bufferPointer, Vc::Aligned);
 
         } else {
           vValue.store(bufferPointer, Vc::Aligned);
       }
       currentIndices = currentIndices + increment;
 
       bufferPointer += Vc::float_v::size();
     }
 }
 
 #endif /* defined HAVE_VC */
diff --git a/libs/image/kis_fixed_paint_device.cpp b/libs/image/kis_fixed_paint_device.cpp
index 4a551e51e6..f9e3325511 100644
--- a/libs/image/kis_fixed_paint_device.cpp
+++ b/libs/image/kis_fixed_paint_device.cpp
@@ -1,351 +1,351 @@
 /*
  *  Copyright (c) 2009 Boudewijn Rempt <boud@valdyas.org>
  *  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_fixed_paint_device.h"
 
 #include <KoColorSpaceRegistry.h>
 #include <KoColor.h>
 #include <KoColorModelStandardIds.h>
 #include "kis_debug.h"
 
 KisFixedPaintDevice::KisFixedPaintDevice(const KoColorSpace* colorSpace, KisOptimizedByteArray::MemoryAllocatorSP allocator)
         : m_colorSpace(colorSpace),
           m_data(allocator)
 {
 }
 
 KisFixedPaintDevice::~KisFixedPaintDevice()
 {
 }
 
 KisFixedPaintDevice::KisFixedPaintDevice(const KisFixedPaintDevice& rhs)
         : KisShared()
 {
     m_bounds = rhs.m_bounds;
     m_colorSpace = rhs.m_colorSpace;
     m_data = rhs.m_data;
 }
 
 KisFixedPaintDevice& KisFixedPaintDevice::operator=(const KisFixedPaintDevice& rhs)
 {
     m_bounds = rhs.m_bounds;
     m_colorSpace = rhs.m_colorSpace;
 
 
     const int referenceSize = m_bounds.height() * m_bounds.width() * pixelSize();
 
     if (m_data.size() >= referenceSize) {
         memcpy(m_data.data(), rhs.m_data.constData(), referenceSize);
     } else {
         m_data = rhs.m_data;
     }
 
     return *this;
 }
 
 void KisFixedPaintDevice::setRect(const QRect& rc)
 {
     m_bounds = rc;
 }
 
 
 QRect KisFixedPaintDevice::bounds() const
 {
     return m_bounds;
 }
 
 
 int KisFixedPaintDevice::allocatedPixels() const
 {
     return m_data.size() / m_colorSpace->pixelSize();
 }
 
 
 quint32 KisFixedPaintDevice::pixelSize() const
 {
     return m_colorSpace->pixelSize();
 }
 
 bool KisFixedPaintDevice::initialize(quint8 defaultValue)
 {
     m_data.fill(defaultValue, m_bounds.height() * m_bounds.width() * pixelSize());
 
     return true;
 }
 
 void KisFixedPaintDevice::reallocateBufferWithoutInitialization()
 {
     const int referenceSize = m_bounds.height() * m_bounds.width() * pixelSize();
 
     if (referenceSize != m_data.size()) {
         m_data.resize(m_bounds.height() * m_bounds.width() * pixelSize());
     }
 }
 
 void KisFixedPaintDevice::lazyGrowBufferWithoutInitialization()
 {
     const int referenceSize = m_bounds.height() * m_bounds.width() * pixelSize();
 
     if (m_data.size() < referenceSize) {
         m_data.resize(referenceSize);
     }
 }
 
 quint8* KisFixedPaintDevice::data()
 {
     return (quint8*) m_data.data();
 }
 
 const quint8 *KisFixedPaintDevice::constData() const
 {
     return (const quint8*) m_data.constData();
 }
 
 quint8* KisFixedPaintDevice::data() const
 {
     return const_cast<quint8*>(m_data.constData());
 }
 
 void KisFixedPaintDevice::convertTo(const KoColorSpace* dstColorSpace,
                                     KoColorConversionTransformation::Intent renderingIntent,
                                     KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     if (*m_colorSpace == *dstColorSpace) {
         return;
     }
     quint32 size = m_bounds.width() * m_bounds.height();
     KisOptimizedByteArray dstData(m_data.customMemoryAllocator());
 
     // make sure that we are not initializing the destination pixels!
     dstData.resize(size * dstColorSpace->pixelSize());
 
     m_colorSpace->convertPixelsTo(constData(), (quint8*)dstData.data(),
                                   dstColorSpace,
                                   size,
                                   renderingIntent,
                                   conversionFlags);
 
     m_colorSpace = dstColorSpace;
     m_data = dstData;
 }
 
 void KisFixedPaintDevice::convertFromQImage(const QImage& _image, const QString &srcProfileName)
 {
     QImage image = _image;
 
     if (image.format() != QImage::Format_ARGB32) {
         image = image.convertToFormat(QImage::Format_ARGB32);
     }
     setRect(image.rect());
     lazyGrowBufferWithoutInitialization();
 
     // Don't convert if not no profile is given and both paint dev and qimage are rgba.
     if (srcProfileName.isEmpty() && colorSpace()->id() == "RGBA") {
         memcpy(data(), image.constBits(), image.byteCount());
     } else {
         KoColorSpaceRegistry::instance()
             ->colorSpace( RGBAColorModelID.id(), Integer8BitsColorDepthID.id(), srcProfileName)
             ->convertPixelsTo(image.constBits(), data(), colorSpace(), image.width() * image.height(),
                               KoColorConversionTransformation::internalRenderingIntent(),
                               KoColorConversionTransformation::internalConversionFlags());
     }
 }
 
 QImage KisFixedPaintDevice::convertToQImage(const KoColorProfile *  dstProfile, KoColorConversionTransformation::Intent intent, KoColorConversionTransformation::ConversionFlags conversionFlags) const
 {
     qint32 x1;
     qint32 y1;
     qint32 w;
     qint32 h;
 
     x1 = m_bounds.x();
     y1 = m_bounds.y();
     w = m_bounds.width();
     h = m_bounds.height();
 
     return convertToQImage(dstProfile, x1, y1, w, h, intent, conversionFlags);
 }
 
 QImage KisFixedPaintDevice::convertToQImage(const KoColorProfile *  dstProfile, qint32 x1, qint32 y1, qint32 w, qint32 h, KoColorConversionTransformation::Intent intent, KoColorConversionTransformation::ConversionFlags conversionFlags) const
 {
     Q_ASSERT( m_bounds.contains(QRect(x1,y1,w,h)) );
 
     if (w < 0)
         return QImage();
 
     if (h < 0)
         return QImage();
 
     if (QRect(x1, y1, w, h) == m_bounds) {
         return colorSpace()->convertToQImage(constData(), w, h, dstProfile,
                                              intent, conversionFlags);
     } else {
         try {
             // XXX: fill the image row by row!
             const int pSize = pixelSize();
             const int deviceWidth = m_bounds.width();
             quint8* newData = new quint8[w * h * pSize];
             const quint8* srcPtr = constData() + x1 * pSize + y1 * deviceWidth * pSize;
             quint8* dstPtr = newData;
             // copy the right area out of the paint device into data
             for (int row = 0; row < h; row++) {
                 memcpy(dstPtr, srcPtr, w * pSize);
                 srcPtr += deviceWidth * pSize;
                 dstPtr += w * pSize;
             }
             QImage image = colorSpace()->convertToQImage(newData, w, h, dstProfile, intent, conversionFlags);
             return image;
         }
-        catch(std::bad_alloc) {
+        catch(const std::bad_alloc&) {
             return QImage();
         }
     }
 }
 
 void KisFixedPaintDevice::clear(const QRect & rc)
 {
     KoColor c(Qt::black, m_colorSpace);
     quint8* black = new quint8[pixelSize()];
     memcpy(black, c.data(), m_colorSpace->pixelSize());
     m_colorSpace->setOpacity(black, OPACITY_TRANSPARENT_U8, 1);
     fill(rc.x(), rc.y(), rc.width(), rc.height(), black);
     delete[] black;
 }
 
 void KisFixedPaintDevice::fill(const QRect &rc, const KoColor &color)
 {
     KoColor realColor(color);
     realColor.convertTo(colorSpace());
     fill(rc.x(), rc.y(), rc.width(), rc.height(), realColor.data());
 }
 
 void KisFixedPaintDevice::fill(qint32 x, qint32 y, qint32 w, qint32 h, const quint8 *fillPixel)
 {
     if (m_data.isEmpty() || m_bounds.isEmpty()) {
         setRect(QRect(x, y, w, h));
         reallocateBufferWithoutInitialization();
     }
 
     QRect rc(x, y, w, h);
     if (!m_bounds.contains(rc)) {
         rc = m_bounds;
     }
 
     quint8 pixelSize = m_colorSpace->pixelSize();
     quint8* dabPointer = data();
 
     if (rc.contains(m_bounds)) {
         for (int i = 0; i < w * h ; ++i) {
             memcpy(dabPointer, fillPixel, pixelSize);
             dabPointer += pixelSize;
         }
 
     } else {
         int deviceWidth = bounds().width();
         quint8* rowPointer = dabPointer + ((y - bounds().y()) * deviceWidth + (x - bounds().x())) * pixelSize;
         for (int row = 0; row < h; row++) {
             for (int col = 0; col < w; col++) {
                 memcpy(rowPointer + col * pixelSize , fillPixel, pixelSize);
             }
             rowPointer += deviceWidth * pixelSize;
         }
     }
 }
 
 
 void KisFixedPaintDevice::readBytes(quint8* dstData, qint32 x, qint32 y, qint32 w, qint32 h) const
 {
     if (m_data.isEmpty() || m_bounds.isEmpty()) {
         return;
     }
 
     QRect rc(x, y, w, h);
     if (!m_bounds.contains(rc)){
         return;
     }
 
     const int pixelSize = m_colorSpace->pixelSize();
     const quint8* dabPointer = constData();
 
     if (rc == m_bounds) {
         memcpy(dstData, dabPointer, pixelSize * w * h);
     } else {
         int deviceWidth = m_bounds.width();
         const quint8* rowPointer = dabPointer + ((y - bounds().y()) * deviceWidth + (x - bounds().x())) * pixelSize;
         for (int row = 0; row < h; row++) {
             memcpy(dstData, rowPointer, w * pixelSize);
             rowPointer += deviceWidth * pixelSize;
             dstData += w * pixelSize;
         }
     }
 }
 
 void KisFixedPaintDevice::mirror(bool horizontal, bool vertical)
 {
     if (!horizontal && !vertical){
         return;
     }
 
     int pixelSize = m_colorSpace->pixelSize();
     int w = m_bounds.width();
     int h = m_bounds.height();
 
     if (horizontal){
         int rowSize = pixelSize * w;
 
         quint8 * dabPointer = data();
         quint8 * row = new quint8[ rowSize ];
         quint8 * mirror = 0;
 
         for (int y = 0; y < h ; y++){
             // TODO: implement better flipping of the data
 
             memcpy(row, dabPointer, rowSize);
             mirror = row;
             mirror += (w-1) * pixelSize;
             for (int x = 0; x < w; x++){
                 memcpy(dabPointer,mirror,pixelSize);
                 dabPointer += pixelSize;
                 mirror -= pixelSize;
             }
         }
 
         delete [] row;
     }
 
     if (vertical){
         int rowsToMove = h / 2;
         int rowSize = pixelSize * w;
 
         quint8 * startRow = data();
         quint8 * endRow = data() + (h-1) * w * pixelSize;
         quint8 * row = new quint8[ rowSize ];
 
         for (int y = 0; y < rowsToMove; y++){
             memcpy(row, startRow, rowSize);
             memcpy(startRow, endRow, rowSize);
             memcpy(endRow, row, rowSize);
 
             startRow += rowSize;
             endRow -= rowSize;
         }
 
         delete [] row;
     }
 
 }
diff --git a/libs/image/kis_keyframe_channel.cpp b/libs/image/kis_keyframe_channel.cpp
index aadd9700a6..3cc4ebc682 100644
--- a/libs/image/kis_keyframe_channel.cpp
+++ b/libs/image/kis_keyframe_channel.cpp
@@ -1,638 +1,668 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_keyframe_channel.h"
 #include "KoID.h"
 #include "kis_global.h"
 #include "kis_node.h"
 #include "kis_time_range.h"
 #include "kundo2command.h"
 #include "kis_keyframe_commands.h"
 
 #include <QMap>
 
 const KoID KisKeyframeChannel::Content = KoID("content", ki18n("Content"));
 const KoID KisKeyframeChannel::Opacity = KoID("opacity", ki18n("Opacity"));
 const KoID KisKeyframeChannel::TransformArguments = KoID("transform_arguments", ki18n("Transform"));
 const KoID KisKeyframeChannel::TransformPositionX = KoID("transform_pos_x", ki18n("Position (X)"));
 const KoID KisKeyframeChannel::TransformPositionY = KoID("transform_pos_y", ki18n("Position (Y)"));
 const KoID KisKeyframeChannel::TransformScaleX = KoID("transform_scale_x", ki18n("Scale (X)"));
 const KoID KisKeyframeChannel::TransformScaleY = KoID("transform_scale_y", ki18n("Scale (Y)"));
 const KoID KisKeyframeChannel::TransformShearX = KoID("transform_shear_x", ki18n("Shear (X)"));
 const KoID KisKeyframeChannel::TransformShearY = KoID("transform_shear_y", ki18n("Shear (Y)"));
 const KoID KisKeyframeChannel::TransformRotationX = KoID("transform_rotation_x", ki18n("Rotation (X)"));
 const KoID KisKeyframeChannel::TransformRotationY = KoID("transform_rotation_y", ki18n("Rotation (Y)"));
 const KoID KisKeyframeChannel::TransformRotationZ = KoID("transform_rotation_z", ki18n("Rotation (Z)"));
 
 struct KisKeyframeChannel::Private
 {
     Private() {}
     Private(const Private &rhs, KisNodeWSP newParentNode) {
         node = newParentNode;
         id = rhs.id;
         defaultBounds = rhs.defaultBounds;
+        haveBrokenFrameTimeBug = rhs.haveBrokenFrameTimeBug;
     }
 
     KeyframesMap keys;
     KisNodeWSP node;
     KoID id;
     KisDefaultBoundsBaseSP defaultBounds;
+    bool haveBrokenFrameTimeBug = false;
 };
 
 KisKeyframeChannel::KisKeyframeChannel(const KoID &id, KisDefaultBoundsBaseSP defaultBounds)
     : m_d(new Private)
 {
     m_d->id = id;
     m_d->node = 0;
     m_d->defaultBounds = defaultBounds;
 }
 
 KisKeyframeChannel::KisKeyframeChannel(const KisKeyframeChannel &rhs, KisNode *newParentNode)
     : m_d(new Private(*rhs.m_d, newParentNode))
 {
     KIS_ASSERT_RECOVER_NOOP(&rhs != this);
 
     Q_FOREACH(KisKeyframeSP keyframe, rhs.m_d->keys) {
         m_d->keys.insert(keyframe->time(), keyframe->cloneFor(this));
     }
 }
 
 KisKeyframeChannel::~KisKeyframeChannel()
 {}
 
 QString KisKeyframeChannel::id() const
 {
     return m_d->id.id();
 }
 
 QString KisKeyframeChannel::name() const
 {
     return m_d->id.name();
 }
 
 void KisKeyframeChannel::setNode(KisNodeWSP node)
 {
     m_d->node = node;
 }
 
 KisNodeWSP KisKeyframeChannel::node() const
 {
     return m_d->node;
 }
 
 int KisKeyframeChannel::keyframeCount() const
 {
     return m_d->keys.count();
 }
 
 KisKeyframeChannel::KeyframesMap& KisKeyframeChannel::keys()
 {
     return m_d->keys;
 }
 
 const KisKeyframeChannel::KeyframesMap& KisKeyframeChannel::constKeys() const
 {
     return m_d->keys;
 }
 
 #define LAZY_INITIALIZE_PARENT_COMMAND(cmd)       \
     QScopedPointer<KUndo2Command> __tempCommand;  \
     if (!parentCommand) {                         \
         __tempCommand.reset(new KUndo2Command()); \
         cmd = __tempCommand.data();               \
     }
 
 KisKeyframeSP KisKeyframeChannel::addKeyframe(int time, KUndo2Command *parentCommand)
 {
     LAZY_INITIALIZE_PARENT_COMMAND(parentCommand);
     return insertKeyframe(time, KisKeyframeSP(), parentCommand);
 }
 
 KisKeyframeSP KisKeyframeChannel::copyKeyframe(const KisKeyframeSP keyframe, int newTime, KUndo2Command *parentCommand)
 {
     LAZY_INITIALIZE_PARENT_COMMAND(parentCommand);
     return insertKeyframe(newTime, keyframe, parentCommand);
 }
 
 KisKeyframeSP KisKeyframeChannel::insertKeyframe(int time, const KisKeyframeSP copySrc, KUndo2Command *parentCommand)
 {
     KisKeyframeSP keyframe = keyframeAt(time);
     if (keyframe) {
         deleteKeyframeImpl(keyframe, parentCommand, false);
     }
 
     Q_ASSERT(parentCommand);
     keyframe = createKeyframe(time, copySrc, parentCommand);
 
     KUndo2Command *cmd = new KisReplaceKeyframeCommand(this, keyframe->time(), keyframe, parentCommand);
     cmd->redo();
 
     return keyframe;
 }
 
 bool KisKeyframeChannel::deleteKeyframe(KisKeyframeSP keyframe, KUndo2Command *parentCommand)
 {
     return deleteKeyframeImpl(keyframe, parentCommand, true);
 }
 
 bool KisKeyframeChannel::moveKeyframe(KisKeyframeSP keyframe, int newTime, KUndo2Command *parentCommand)
 {
     LAZY_INITIALIZE_PARENT_COMMAND(parentCommand);
 
     if (newTime == keyframe->time()) return false;
 
     KisKeyframeSP other = keyframeAt(newTime);
     if (other) {
         deleteKeyframeImpl(other, parentCommand, false);
     }
 
     const int srcTime = keyframe->time();
 
     KUndo2Command *cmd = new KisMoveFrameCommand(this, keyframe, srcTime, newTime, parentCommand);
     cmd->redo();
 
     if (srcTime == 0) {
         addKeyframe(srcTime, parentCommand);
     }
 
     return true;
 }
 
 bool KisKeyframeChannel::swapFrames(int lhsTime, int rhsTime, KUndo2Command *parentCommand)
 {
     LAZY_INITIALIZE_PARENT_COMMAND(parentCommand);
 
     if (lhsTime == rhsTime) return false;
 
     KisKeyframeSP lhsFrame = keyframeAt(lhsTime);
     KisKeyframeSP rhsFrame = keyframeAt(rhsTime);
 
     if (!lhsFrame && !rhsFrame) return false;
 
     if (lhsFrame && !rhsFrame) {
         moveKeyframe(lhsFrame, rhsTime, parentCommand);
     } else if (!lhsFrame && rhsFrame) {
         moveKeyframe(rhsFrame, lhsTime, parentCommand);
     } else {
         KUndo2Command *cmd = new KisSwapFramesCommand(this, lhsFrame, rhsFrame, parentCommand);
         cmd->redo();
     }
 
     return true;
 }
 
 bool KisKeyframeChannel::deleteKeyframeImpl(KisKeyframeSP keyframe, KUndo2Command *parentCommand, bool recreate)
 {
     LAZY_INITIALIZE_PARENT_COMMAND(parentCommand);
 
     Q_ASSERT(parentCommand);
 
     KUndo2Command *cmd = new KisReplaceKeyframeCommand(this, keyframe->time(), KisKeyframeSP(), parentCommand);
     cmd->redo();
     destroyKeyframe(keyframe, parentCommand);
 
     if (recreate && keyframe->time() == 0) {
         addKeyframe(0, parentCommand);
     }
 
     return true;
 }
 
 void KisKeyframeChannel::moveKeyframeImpl(KisKeyframeSP keyframe, int newTime)
 {
     KIS_ASSERT_RECOVER_RETURN(keyframe);
     KIS_ASSERT_RECOVER_RETURN(!keyframeAt(newTime));
 
     KisTimeRange rangeSrc = affectedFrames(keyframe->time());
     QRect rectSrc = affectedRect(keyframe);
 
     emit sigKeyframeAboutToBeMoved(keyframe, newTime);
 
     m_d->keys.remove(keyframe->time());
     int oldTime = keyframe->time();
     keyframe->setTime(newTime);
     m_d->keys.insert(newTime, keyframe);
 
     emit sigKeyframeMoved(keyframe, oldTime);
 
     KisTimeRange rangeDst = affectedFrames(keyframe->time());
     QRect rectDst = affectedRect(keyframe);
 
     requestUpdate(rangeSrc, rectSrc);
     requestUpdate(rangeDst, rectDst);
 }
 
 void KisKeyframeChannel::swapKeyframesImpl(KisKeyframeSP lhsKeyframe, KisKeyframeSP rhsKeyframe)
 {
     KIS_ASSERT_RECOVER_RETURN(lhsKeyframe);
     KIS_ASSERT_RECOVER_RETURN(rhsKeyframe);
 
     KisTimeRange rangeLhs = affectedFrames(lhsKeyframe->time());
     KisTimeRange rangeRhs = affectedFrames(rhsKeyframe->time());
 
     const QRect rectLhsSrc = affectedRect(lhsKeyframe);
     const QRect rectRhsSrc = affectedRect(rhsKeyframe);
 
     const int lhsTime = lhsKeyframe->time();
     const int rhsTime = rhsKeyframe->time();
 
     emit sigKeyframeAboutToBeMoved(lhsKeyframe, rhsTime);
     emit sigKeyframeAboutToBeMoved(rhsKeyframe, lhsTime);
 
     m_d->keys.remove(lhsTime);
     m_d->keys.remove(rhsTime);
 
     rhsKeyframe->setTime(lhsTime);
     lhsKeyframe->setTime(rhsTime);
 
     m_d->keys.insert(lhsTime, rhsKeyframe);
     m_d->keys.insert(rhsTime, lhsKeyframe);
 
     emit sigKeyframeMoved(lhsKeyframe, lhsTime);
     emit sigKeyframeMoved(rhsKeyframe, rhsTime);
 
     const QRect rectLhsDst = affectedRect(lhsKeyframe);
     const QRect rectRhsDst = affectedRect(rhsKeyframe);
 
     requestUpdate(rangeLhs, rectLhsSrc | rectRhsDst);
     requestUpdate(rangeRhs, rectRhsSrc | rectLhsDst);
 }
 
 KisKeyframeSP KisKeyframeChannel::replaceKeyframeAt(int time, KisKeyframeSP newKeyframe)
 {
     Q_ASSERT(newKeyframe.isNull() || time == newKeyframe->time());
 
     KisKeyframeSP existingKeyframe = keyframeAt(time);
     if (!existingKeyframe.isNull()) {
         removeKeyframeLogical(existingKeyframe);
     }
 
     if (!newKeyframe.isNull()) {
         insertKeyframeLogical(newKeyframe);
     }
 
     return existingKeyframe;
 }
 
 void KisKeyframeChannel::insertKeyframeLogical(KisKeyframeSP keyframe)
 {
     const int time = keyframe->time();
 
     emit sigKeyframeAboutToBeAdded(keyframe);
     m_d->keys.insert(time, keyframe);
     emit sigKeyframeAdded(keyframe);
 
     QRect rect = affectedRect(keyframe);
     KisTimeRange range = affectedFrames(time);
     requestUpdate(range, rect);
 }
 
 void KisKeyframeChannel::removeKeyframeLogical(KisKeyframeSP keyframe)
 {
     QRect rect = affectedRect(keyframe);
     KisTimeRange range = affectedFrames(keyframe->time());
 
     emit sigKeyframeAboutToBeRemoved(keyframe);
     m_d->keys.remove(keyframe->time());
     emit sigKeyframeRemoved(keyframe);
 
     requestUpdate(range, rect);
 }
 
 KisKeyframeSP KisKeyframeChannel::keyframeAt(int time) const
 {
     KeyframesMap::const_iterator i = m_d->keys.constFind(time);
     if (i != m_d->keys.constEnd()) {
         return i.value();
     }
 
     return KisKeyframeSP();
 }
 
 KisKeyframeSP KisKeyframeChannel::activeKeyframeAt(int time) const
 {
     KeyframesMap::const_iterator i = activeKeyIterator(time);
     if (i != m_d->keys.constEnd()) {
         return i.value();
     }
 
     return KisKeyframeSP();
 }
 
 KisKeyframeSP KisKeyframeChannel::currentlyActiveKeyframe() const
 {
     return activeKeyframeAt(currentTime());
 }
 
 KisKeyframeSP KisKeyframeChannel::firstKeyframe() const
 {
     if (m_d->keys.isEmpty()) return KisKeyframeSP();
     return m_d->keys.first();
 }
 
 KisKeyframeSP KisKeyframeChannel::nextKeyframe(KisKeyframeSP keyframe) const
 {
     KeyframesMap::const_iterator i = m_d->keys.constFind(keyframe->time());
     if (i == m_d->keys.constEnd()) return KisKeyframeSP(0);
 
     i++;
 
     if (i == m_d->keys.constEnd()) return KisKeyframeSP(0);
     return i.value();
 }
 
 KisKeyframeSP KisKeyframeChannel::previousKeyframe(KisKeyframeSP keyframe) const
 {
     KeyframesMap::const_iterator i = m_d->keys.constFind(keyframe->time());
     if (i == m_d->keys.constBegin() || i == m_d->keys.constEnd()) return KisKeyframeSP(0);
     i--;
 
     return i.value();
 }
 
 KisKeyframeSP KisKeyframeChannel::lastKeyframe() const
 {
     if (m_d->keys.isEmpty()) return KisKeyframeSP(0);
 
     return (m_d->keys.end()-1).value();
 }
 
 int KisKeyframeChannel::framesHash() const
 {
     KeyframesMap::const_iterator it = m_d->keys.constBegin();
     KeyframesMap::const_iterator end = m_d->keys.constEnd();
 
     int hash = 0;
 
     while (it != end) {
         hash += it.key();
         ++it;
     }
 
     return hash;
 }
 
 QSet<int> KisKeyframeChannel::allKeyframeIds() const
 {
     QSet<int> frames;
 
     KeyframesMap::const_iterator it = m_d->keys.constBegin();
     KeyframesMap::const_iterator end = m_d->keys.constEnd();
 
     while (it != end) {
         frames.insert(it.key());
         ++it;
     }
 
     return frames;
 }
 
 KisTimeRange KisKeyframeChannel::affectedFrames(int time) const
 {
     if (m_d->keys.isEmpty()) return KisTimeRange::infinite(0);
 
     KeyframesMap::const_iterator active = activeKeyIterator(time);
     KeyframesMap::const_iterator next;
 
     int from;
 
     if (active == m_d->keys.constEnd()) {
         // No active keyframe, ie. time is before the first keyframe
         from = 0;
         next = m_d->keys.constBegin();
     } else {
         from = active.key();
         next = active + 1;
     }
 
     if (next == m_d->keys.constEnd()) {
         return KisTimeRange::infinite(from);
     } else {
         return KisTimeRange::fromTime(from, next.key() - 1);
     }
 }
 
 KisTimeRange KisKeyframeChannel::identicalFrames(int time) const
 {
     KeyframesMap::const_iterator active = activeKeyIterator(time);
 
     if (active != m_d->keys.constEnd() && (active+1) != m_d->keys.constEnd()) {
         if (active->data()->interpolationMode() != KisKeyframe::Constant) {
             return KisTimeRange::fromTime(time, time);
         }
     }
 
     return affectedFrames(time);
 }
 
 int KisKeyframeChannel::keyframeRowIndexOf(KisKeyframeSP keyframe) const
 {
     KeyframesMap::const_iterator it = m_d->keys.constBegin();
     KeyframesMap::const_iterator end = m_d->keys.constEnd();
 
     int row = 0;
 
     for (; it != end; ++it) {
         if (it.value().data() == keyframe) {
             return row;
         }
 
         row++;
     }
 
     return -1;
 }
 
 KisKeyframeSP KisKeyframeChannel::keyframeAtRow(int row) const
 {
     KeyframesMap::const_iterator it = m_d->keys.constBegin();
     KeyframesMap::const_iterator end = m_d->keys.constEnd();
 
     for (; it != end; ++it) {
         if (row <= 0) {
             return it.value();
         }
 
         row--;
     }
 
     return KisKeyframeSP();
 }
 
 int KisKeyframeChannel::keyframeInsertionRow(int time) const
 {
     KeyframesMap::const_iterator it = m_d->keys.constBegin();
     KeyframesMap::const_iterator end = m_d->keys.constEnd();
 
     int row = 0;
 
     for (; it != end; ++it) {
         if (it.value()->time() > time) {
             break;
         }
         row++;
     }
 
     return row;
 }
 
 QDomElement KisKeyframeChannel::toXML(QDomDocument doc, const QString &layerFilename)
 {
     QDomElement channelElement = doc.createElement("channel");
 
     channelElement.setAttribute("name", id());
 
     Q_FOREACH (KisKeyframeSP keyframe, m_d->keys.values()) {
         QDomElement keyframeElement = doc.createElement("keyframe");
         keyframeElement.setAttribute("time", keyframe->time());
         keyframeElement.setAttribute("color-label", keyframe->colorLabel());
 
         saveKeyframe(keyframe, keyframeElement, layerFilename);
 
         channelElement.appendChild(keyframeElement);
     }
 
     return channelElement;
 }
 
 void KisKeyframeChannel::loadXML(const QDomElement &channelNode)
 {
     for (QDomElement keyframeNode = channelNode.firstChildElement(); !keyframeNode.isNull(); keyframeNode = keyframeNode.nextSiblingElement()) {
         if (keyframeNode.nodeName().toUpper() != "KEYFRAME") continue;
 
         KisKeyframeSP keyframe = loadKeyframe(keyframeNode);
+        KIS_SAFE_ASSERT_RECOVER(keyframe) { continue; }
 
         if (keyframeNode.hasAttribute("color-label")) {
             keyframe->setColorLabel(keyframeNode.attribute("color-label").toUInt());
         }
 
         m_d->keys.insert(keyframe->time(), keyframe);
     }
 }
 
 bool KisKeyframeChannel::swapExternalKeyframe(KisKeyframeChannel *srcChannel, int srcTime, int dstTime, KUndo2Command *parentCommand)
 {
     if (srcChannel->id() != id()) {
         warnKrita << "Cannot copy frames from different ids:" << ppVar(srcChannel->id()) << ppVar(id());
         return KisKeyframeSP();
     }
 
     LAZY_INITIALIZE_PARENT_COMMAND(parentCommand);
 
     KisKeyframeSP srcFrame = srcChannel->keyframeAt(srcTime);
     KisKeyframeSP dstFrame = keyframeAt(dstTime);
 
     if (!dstFrame && srcFrame) {
         copyExternalKeyframe(srcChannel, srcTime, dstTime, parentCommand);
         srcChannel->deleteKeyframe(srcFrame, parentCommand);
     } else if (dstFrame && !srcFrame) {
         srcChannel->copyExternalKeyframe(this, dstTime, srcTime, parentCommand);
         deleteKeyframe(dstFrame, parentCommand);
     } else if (dstFrame && srcFrame) {
         const int fakeFrameTime = -1;
 
         KisKeyframeSP newKeyframe = createKeyframe(fakeFrameTime, KisKeyframeSP(), parentCommand);
         uploadExternalKeyframe(srcChannel, srcTime, newKeyframe);
 
         srcChannel->copyExternalKeyframe(this, dstTime, srcTime, parentCommand);
 
         // do not recreate frame!
         deleteKeyframeImpl(dstFrame, parentCommand, false);
 
         newKeyframe->setTime(dstTime);
 
         KUndo2Command *cmd = new KisReplaceKeyframeCommand(this, newKeyframe->time(), newKeyframe, parentCommand);
         cmd->redo();
     }
 
     return true;
 }
 
 
 KisKeyframeSP KisKeyframeChannel::copyExternalKeyframe(KisKeyframeChannel *srcChannel, int srcTime, int dstTime, KUndo2Command *parentCommand)
 {
     if (srcChannel->id() != id()) {
         warnKrita << "Cannot copy frames from different ids:" << ppVar(srcChannel->id()) << ppVar(id());
         return KisKeyframeSP();
     }
 
     LAZY_INITIALIZE_PARENT_COMMAND(parentCommand);
 
     KisKeyframeSP dstFrame = keyframeAt(dstTime);
     if (dstFrame) {
         deleteKeyframeImpl(dstFrame, parentCommand, false);
     }
 
     KisKeyframeSP newKeyframe = createKeyframe(dstTime, KisKeyframeSP(), parentCommand);
     uploadExternalKeyframe(srcChannel, srcTime, newKeyframe);
 
     KUndo2Command *cmd = new KisReplaceKeyframeCommand(this, newKeyframe->time(), newKeyframe, parentCommand);
     cmd->redo();
 
     return newKeyframe;
 }
 
 KisKeyframeChannel::KeyframesMap::const_iterator
 KisKeyframeChannel::activeKeyIterator(int time) const
 {
     KeyframesMap::const_iterator i = const_cast<const KeyframesMap*>(&m_d->keys)->upperBound(time);
 
     if (i == m_d->keys.constBegin()) return m_d->keys.constEnd();
     return --i;
 }
 
 void KisKeyframeChannel::requestUpdate(const KisTimeRange &range, const QRect &rect)
 {
     if (m_d->node) {
         m_d->node->invalidateFrames(range, rect);
 
         int currentTime = m_d->defaultBounds->currentTime();
         if (range.contains(currentTime)) {
             m_d->node->setDirty(rect);
         }
     }
 }
 
+void KisKeyframeChannel::workaroundBrokenFrameTimeBug(int *time)
+{
+    /**
+     * Between Krita 4.1 and 4.4 Krita had a bug which resulted in creating frames
+     * with negative time stamp. The bug has been fixed, but there might be some files
+     * still in the wild.
+     *
+     * TODO: remove this workaround in Krita 5.0, when no such file are left :)
+     */
+
+    if (*time < 0) {
+        qWarning() << "WARNING: Loading a file with negative animation frames!";
+        qWarning() << "         The file has been saved with a buggy version of Krita.";
+        qWarning() << "         All the frames with negative ids will be dropped!";
+        qWarning() << "         " << ppVar(this->id()) << ppVar(*time);
+
+        m_d->haveBrokenFrameTimeBug = true;
+        *time = 0;
+    }
+
+    if (m_d->haveBrokenFrameTimeBug) {
+        while (keyframeAt(*time)) {
+            (*time)++;
+        }
+    }
+}
+
 int KisKeyframeChannel::currentTime() const
 {
     return m_d->defaultBounds->currentTime();
 }
 
 qreal KisKeyframeChannel::minScalarValue() const
 {
     return 0;
 }
 
 qreal KisKeyframeChannel::maxScalarValue() const
 {
     return 0;
 }
 
 qreal KisKeyframeChannel::scalarValue(const KisKeyframeSP keyframe) const
 {
     Q_UNUSED(keyframe);
 
     return 0;
 }
 
 void KisKeyframeChannel::setScalarValue(KisKeyframeSP keyframe, qreal value, KUndo2Command *parentCommand)
 {
     Q_UNUSED(keyframe);
     Q_UNUSED(value);
     Q_UNUSED(parentCommand);
 }
diff --git a/libs/image/kis_keyframe_channel.h b/libs/image/kis_keyframe_channel.h
index 7e87abf386..9170fd22a1 100644
--- a/libs/image/kis_keyframe_channel.h
+++ b/libs/image/kis_keyframe_channel.h
@@ -1,170 +1,171 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_KEYFRAME_CHANNEL_H
 #define KIS_KEYFRAME_CHANNEL_H
 
 #include <QVariant>
 #include <QDomElement>
 #include <kundo2command.h>
 
 #include "kis_types.h"
 #include "KoID.h"
 #include "kritaimage_export.h"
 #include "kis_keyframe.h"
 #include "kis_default_bounds.h"
 
 class KisTimeRange;
 
 
 class KRITAIMAGE_EXPORT KisKeyframeChannel : public QObject
 {
     Q_OBJECT
 
 public:
     // Standard Keyframe Ids
 
     static const KoID Content;
     static const KoID Opacity;
     static const KoID TransformArguments;
     static const KoID TransformPositionX;
     static const KoID TransformPositionY;
 
     static const KoID TransformScaleX;
     static const KoID TransformScaleY;
     static const KoID TransformShearX;
     static const KoID TransformShearY;
     static const KoID TransformRotationX;
     static const KoID TransformRotationY;
     static const KoID TransformRotationZ;
 public:
     KisKeyframeChannel(const KoID& id, KisDefaultBoundsBaseSP defaultBounds);
     KisKeyframeChannel(const KisKeyframeChannel &rhs, KisNode *newParentNode);
     ~KisKeyframeChannel() override;
 
     QString id() const;
     QString name() const;
 
     void setNode(KisNodeWSP node);
     KisNodeWSP node() const;
 
     KisKeyframeSP addKeyframe(int time, KUndo2Command *parentCommand = 0);
     bool deleteKeyframe(KisKeyframeSP keyframe, KUndo2Command *parentCommand = 0);
     bool moveKeyframe(KisKeyframeSP keyframe, int newTime, KUndo2Command *parentCommand = 0);
     bool swapFrames(int lhsTime, int rhsTime, KUndo2Command *parentCommand = 0);
     KisKeyframeSP copyKeyframe(const KisKeyframeSP keyframe, int newTime, KUndo2Command *parentCommand = 0);
     KisKeyframeSP copyExternalKeyframe(KisKeyframeChannel *srcChannel, int srcTime, int dstTime, KUndo2Command *parentCommand = 0);
 
     bool swapExternalKeyframe(KisKeyframeChannel *srcChannel, int srcTime, int dstTime, KUndo2Command *parentCommand = 0);
 
     KisKeyframeSP keyframeAt(int time) const;
     KisKeyframeSP activeKeyframeAt(int time) const;
     KisKeyframeSP currentlyActiveKeyframe() const;
 
     KisKeyframeSP firstKeyframe() const;
     KisKeyframeSP nextKeyframe(KisKeyframeSP keyframe) const;
     KisKeyframeSP previousKeyframe(KisKeyframeSP keyframe) const;
     KisKeyframeSP lastKeyframe() const;
 
     /**
      * Calculates a pseudo-unique keyframes hash. The hash changes
      * every time any frame is added/removed/moved
      */
     int framesHash() const;
 
     QSet<int> allKeyframeIds() const;
     /**
      * Get the set of frames affected by any changes to the value
      * of the active keyframe at the given time.
      */
     KisTimeRange affectedFrames(int time) const;
 
     /**
      * Get a set of frames for which the channel gives identical
      * results, compared to the given frame.
      *
      * Note: this set may be different than the set of affected frames
      * due to interpolation.
      */
     KisTimeRange identicalFrames(int time) const;
 
     int keyframeCount() const;
 
     int keyframeRowIndexOf(KisKeyframeSP keyframe) const;
     KisKeyframeSP keyframeAtRow(int row) const;
 
     int keyframeInsertionRow(int time) const;
 
     virtual bool hasScalarValue() const = 0;
     virtual qreal minScalarValue() const;
     virtual qreal maxScalarValue() const;
     virtual qreal scalarValue(const KisKeyframeSP keyframe) const;
     virtual void setScalarValue(KisKeyframeSP keyframe, qreal value, KUndo2Command *parentCommand = 0);
 
     virtual QDomElement toXML(QDomDocument doc, const QString &layerFilename);
     virtual void loadXML(const QDomElement &channelNode);
 
     int currentTime() const;
 
 Q_SIGNALS:
     void sigKeyframeAboutToBeAdded(KisKeyframeSP keyframe);
     void sigKeyframeAdded(KisKeyframeSP keyframe);
     void sigKeyframeAboutToBeRemoved(KisKeyframeSP keyframe);
     void sigKeyframeRemoved(KisKeyframeSP keyframe);
     void sigKeyframeAboutToBeMoved(KisKeyframeSP keyframe, int toTime);
     void sigKeyframeMoved(KisKeyframeSP keyframe, int fromTime);
     void sigKeyframeChanged(KisKeyframeSP keyframe);
 
 protected:
     typedef QMap<int, KisKeyframeSP> KeyframesMap;
 
     KeyframesMap &keys();
     const KeyframesMap &constKeys() const;
     KeyframesMap::const_iterator activeKeyIterator(int time) const;
 
     virtual KisKeyframeSP createKeyframe(int time, const KisKeyframeSP copySrc, KUndo2Command *parentCommand) = 0;
     virtual void destroyKeyframe(KisKeyframeSP key, KUndo2Command *parentCommand) = 0;
     virtual void uploadExternalKeyframe(KisKeyframeChannel *srcChannel, int srcTime, KisKeyframeSP dstFrame) = 0;
 
     virtual QRect affectedRect(KisKeyframeSP key) = 0;
     virtual void requestUpdate(const KisTimeRange &range, const QRect &rect);
 
     virtual KisKeyframeSP loadKeyframe(const QDomElement &keyframeNode) = 0;
     virtual void saveKeyframe(KisKeyframeSP keyframe, QDomElement keyframeElement, const QString &layerFilename) = 0;
 
+    void workaroundBrokenFrameTimeBug(int *time);
 
 private:
     KisKeyframeSP replaceKeyframeAt(int time, KisKeyframeSP newKeyframe);
     void insertKeyframeLogical(KisKeyframeSP keyframe);
     void removeKeyframeLogical(KisKeyframeSP keyframe);
     bool deleteKeyframeImpl(KisKeyframeSP keyframe, KUndo2Command *parentCommand, bool recreate);
     void moveKeyframeImpl(KisKeyframeSP keyframe, int newTime);
     void swapKeyframesImpl(KisKeyframeSP lhsKeyframe, KisKeyframeSP rhsKeyframe);
 
     friend class KisMoveFrameCommand;
     friend class KisReplaceKeyframeCommand;
     friend class KisSwapFramesCommand;
 
 private:
     KisKeyframeSP insertKeyframe(int time, const KisKeyframeSP copySrc, KUndo2Command *parentCommand);
 
     struct Private;
     QScopedPointer<Private> m_d;
 };
 
 #endif // KIS_KEYFRAME_CHANNEL_H
diff --git a/libs/image/kis_outline_generator.cpp b/libs/image/kis_outline_generator.cpp
index 7529a181ff..d4609f1970 100644
--- a/libs/image/kis_outline_generator.cpp
+++ b/libs/image/kis_outline_generator.cpp
@@ -1,275 +1,275 @@
 /*
  *  Copyright (c) 2004 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2007,2010 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  Outline algorithm based of the limn of fontutils
  *  Copyright (c) 1992 Karl Berry <karl@cs.umb.edu>
  *  Copyright (c) 1992 Kathryn Hargreaves <letters@cs.umb.edu>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  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_outline_generator.h"
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 
 #include "kis_paint_device.h"
 #include <kis_iterator_ng.h>
 #include <kis_random_accessor_ng.h>
 
 class LinearStorage
 {
 public:
     typedef quint8* StorageType;
 public:
     LinearStorage(quint8 *buffer, int width, int height, int pixelSize)
         : m_buffer(buffer),
           m_width(width),
           m_pixelSize(pixelSize)
     {
         m_marks.reset(new quint8[width * height]);
         memset(m_marks.data(), 0, width * height);
     }
 
     quint8* pickPixel(int x, int y) {
         return m_buffer + (m_width * y + x) * m_pixelSize;
     }
 
     quint8* pickMark(int x, int y) {
         return m_marks.data() + m_width * y + x;
     }
 
 private:
     QScopedArrayPointer<quint8> m_marks;
     quint8 *m_buffer;
     int m_width;
     int m_pixelSize;
 };
 
 class PaintDeviceStorage
 {
 public:
     typedef const KisPaintDevice* StorageType;
 public:
     PaintDeviceStorage(const KisPaintDevice *device, int /*width*/, int /*height*/, int /*pixelSize*/)
         : m_device(device)
     {
         m_deviceIt = m_device->createRandomConstAccessorNG(0, 0);
 
         const KoColorSpace *alphaCs = KoColorSpaceRegistry::instance()->alpha8();
         m_marks = new KisPaintDevice(alphaCs);
         m_marksIt = m_marks->createRandomAccessorNG(0, 0);
     }
 
     const quint8* pickPixel(int x, int y) {
         m_deviceIt->moveTo(x, y);
         return m_deviceIt->rawDataConst();
     }
 
     quint8* pickMark(int x, int y) {
         m_marksIt->moveTo(x, y);
         return m_marksIt->rawData();
     }
 
 private:
     KisPaintDeviceSP m_marks;
     const KisPaintDevice *m_device;
     KisRandomConstAccessorSP m_deviceIt;
     KisRandomAccessorSP m_marksIt;
 };
 
 
 /******************* class KisOutlineGenerator *******************/
 
 KisOutlineGenerator::KisOutlineGenerator(const KoColorSpace* cs, quint8 defaultOpacity)
     : m_cs(cs), m_defaultOpacity(defaultOpacity), m_simple(false)
 {
 }
 
 template <class StorageStrategy>
 QVector<QPolygon> KisOutlineGenerator::outlineImpl(typename StorageStrategy::StorageType buffer,
                                                    qint32 xOffset, qint32 yOffset,
                                                    qint32 width, qint32 height)
 {
     QVector<QPolygon> paths;
 
     try {
         StorageStrategy storage(buffer, width, height, m_cs->pixelSize());
 
         for (qint32 y = 0; y < height; y++) {
             for (qint32 x = 0; x < width; x++) {
 
                 if (m_cs->opacityU8(storage.pickPixel(x, y)) == m_defaultOpacity)
                     continue;
 
                 EdgeType startEdge = TopEdge;
 
                 EdgeType edge = startEdge;
                 while (edge != NoEdge &&
                        (*storage.pickMark(x, y) & (1 << edge) ||
                         !isOutlineEdge(storage, edge, x, y, width, height))) {
 
                     edge = nextEdge(edge);
                     if (edge == startEdge)
                         edge = NoEdge;
                 }
 
                 if (edge != NoEdge) {
                     QPolygon path;
                     path << QPoint(x + xOffset, y + yOffset);
 
                     bool clockwise = edge == BottomEdge;
 
                     qint32 row = y, col = x;
                     EdgeType currentEdge = edge;
                     EdgeType lastEdge = currentEdge;
 
                     forever {
                         //While following a straight line no points need to be added
                         if (lastEdge != currentEdge) {
                             appendCoordinate(&path, col + xOffset, row + yOffset, currentEdge);
                             lastEdge = currentEdge;
                         }
 
                         *storage.pickMark(col, row) |= 1 << currentEdge;
                         nextOutlineEdge(storage, &currentEdge, &row, &col, width, height);
 
                         if (row == y && col == x && currentEdge == edge) {
                             // add last point of the polygon
                             appendCoordinate(&path, col + xOffset, row + yOffset, currentEdge);
                             break;
                         }
                     }
 
                     if(!m_simple || !clockwise)
                         paths.push_back(path);
                 }
             }
         }
     }
-    catch(std::bad_alloc) {
+    catch(const std::bad_alloc&) {
         warnKrita << "KisOutlineGenerator::outline ran out of memory allocating " <<  width << "*" << height << "marks";
     }
 
     return paths;
 }
 
 QVector<QPolygon> KisOutlineGenerator::outline(quint8* buffer, qint32 xOffset, qint32 yOffset, qint32 width, qint32 height)
 {
     return outlineImpl<LinearStorage>(buffer, xOffset, yOffset, width, height);
 }
 
 QVector<QPolygon> KisOutlineGenerator::outline(const KisPaintDevice *buffer, qint32 xOffset, qint32 yOffset, qint32 width, qint32 height)
 {
     return outlineImpl<PaintDeviceStorage>(buffer, xOffset, yOffset, width, height);
 }
 
 template <class StorageStrategy>
 bool KisOutlineGenerator::isOutlineEdge(StorageStrategy &storage, EdgeType edge, qint32 x, qint32 y, qint32 bufWidth, qint32 bufHeight)
 {
     if (m_cs->opacityU8(storage.pickPixel(x, y)) == m_defaultOpacity)
         return false;
 
     switch (edge) {
     case LeftEdge:
         return x == 0 || m_cs->opacityU8(storage.pickPixel(x - 1, y)) == m_defaultOpacity;
     case TopEdge:
         return y == 0 || m_cs->opacityU8(storage.pickPixel(x, y - 1)) == m_defaultOpacity;
     case RightEdge:
         return x == bufWidth - 1 || m_cs->opacityU8(storage.pickPixel(x + 1, y)) == m_defaultOpacity;
     case BottomEdge:
         return y == bufHeight - 1 || m_cs->opacityU8(storage.pickPixel(x, y + 1)) == m_defaultOpacity;
     case NoEdge:
         return false;
     }
     return false;
 }
 
 #define TRY_PIXEL(deltaRow, deltaCol, test_edge)                                                \
     {                                                                                               \
         int test_row = *row + deltaRow;                                                             \
         int test_col = *col + deltaCol;                                                             \
         if ( (0 <= (test_row) && (test_row) < height && 0 <= (test_col) && (test_col) < width) &&   \
              isOutlineEdge (storage, test_edge, test_col, test_row, width, height)) \
         {                                                                                           \
             *row = test_row;                                                                        \
             *col = test_col;                                                                        \
             *edge = test_edge;                                                                      \
             break;                                                                                  \
         }                                                                                       \
     }
 
 template <class StorageStrategy>
 void KisOutlineGenerator::nextOutlineEdge(StorageStrategy &storage, EdgeType *edge, qint32 *row, qint32 *col, qint32 width, qint32 height)
 {
     int original_row = *row;
     int original_col = *col;
 
     switch (*edge) {
     case RightEdge:
         TRY_PIXEL(-1, 0, RightEdge);
         TRY_PIXEL(-1, 1, BottomEdge);
         break;
 
     case TopEdge:
         TRY_PIXEL(0, -1, TopEdge);
         TRY_PIXEL(-1, -1, RightEdge);
         break;
 
     case LeftEdge:
         TRY_PIXEL(1, 0, LeftEdge);
         TRY_PIXEL(1, -1, TopEdge);
         break;
 
     case BottomEdge:
         TRY_PIXEL(0, 1, BottomEdge);
         TRY_PIXEL(1, 1, LeftEdge);
         break;
 
     default:
         break;
 
     }
 
     if (*row == original_row && *col == original_col)
         *edge = nextEdge(*edge);
 }
 
 void KisOutlineGenerator::appendCoordinate(QPolygon * path, int x, int y, EdgeType edge)
 {
     switch (edge) {
     case TopEdge:
         x++;
         break;
     case RightEdge:
         x++;
         y++;
         break;
     case BottomEdge:
         y++;
         break;
     case LeftEdge:
     case NoEdge:
         break;
 
     }
 
     *path << QPoint(x, y);
 }
 
 void KisOutlineGenerator::setSimpleOutline(bool simple)
 {
     m_simple = simple;
 }
diff --git a/libs/image/kis_paint_device.cc b/libs/image/kis_paint_device.cc
index a331359180..fe4a8a2b46 100644
--- a/libs/image/kis_paint_device.cc
+++ b/libs/image/kis_paint_device.cc
@@ -1,2208 +1,2208 @@
 /*
  *  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);
     KUndo2Command* convertColorSpace(const KoColorSpace * dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags);
     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(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(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(it.value().data(), true));
                     m_frames.insert(it.key(), data);
                 }
             }
             m_nextFreeFrameId = rhs->m_nextFreeFrameId;
         }
 
         if (rhs->m_lodData) {
             m_lodData.reset(new KisPaintDeviceData(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(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(srcData.data(), true));
         } else {
             DataSP srcData = m_frames.begin().value();
             data = toQShared(new Data(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(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(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(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)
 {
     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(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);
 }
 
 KUndo2Command* KisPaintDevice::Private::convertColorSpace(const KoColorSpace * dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
 
     class DeviceChangeColorSpaceCommand : public KUndo2Command
     {
     public:
         DeviceChangeColorSpaceCommand(KisPaintDeviceSP device)
             : 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;
     };
 
 
     KUndo2Command *parentCommand = new DeviceChangeColorSpaceCommand(q);
 
     QList<Data*> dataObjects = allDataObjects();
 
     Q_FOREACH (Data *data, dataObjects) {
         if (!data) continue;
 
         data->convertDataColorSpace(dstColorSpace, renderingIntent, conversionFlags, parentCommand);
     }
 
     if (!parentCommand->childCount()) {
         delete parentCommand;
         parentCommand = 0;
     } else {
         q->emitColorSpaceChanged();
     }
 
     return parentCommand;
 
 }
 
 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) {
         // 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());
 }
 
 KUndo2Command* KisPaintDevice::convertTo(const KoColorSpace * dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     KUndo2Command *command = m_d->convertColorSpace(dstColorSpace, renderingIntent, conversionFlags);
     return command;
 }
 
 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 (std::bad_alloc) {
+        } 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 (std::bad_alloc) {
+    } 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();
     QRect r = selection->selectedExactRect() & m_d->defaultBounds->bounds();
 
     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();
         }
         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
 {
     Q_ASSERT(m_d->contentChannel);
     return m_d->contentChannel.data();
 }
 
 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_painter.cc b/libs/image/kis_painter.cc
index fceecbeb0b..a8190c9efd 100644
--- a/libs/image/kis_painter.cc
+++ b/libs/image/kis_painter.cc
@@ -1,2981 +1,2981 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2004 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2004 Clarence Dang <dang@kde.org>
  *  Copyright (c) 2004 Adrian Page <adrian@pagenet.plus.com>
  *  Copyright (c) 2004 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2008-2010 Lukáš Tvrdý <lukast.dev@gmail.com>
  *  Copyright (c) 2010 José Luis Vergara Toloza <pentalis@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 "kis_painter.h"
 #include <stdlib.h>
 #include <string.h>
 #include <cfloat>
 #include <cmath>
 #include <climits>
 #ifndef Q_OS_WIN
 #include <strings.h>
 #endif
 
 #include <QImage>
 #include <QRect>
 #include <QString>
 #include <QStringList>
 #include <kundo2command.h>
 
 #include <kis_debug.h>
 #include <klocalizedstring.h>
 
 #include "kis_image.h"
 #include "filter/kis_filter.h"
 #include "kis_layer.h"
 #include "kis_paint_device.h"
 #include "kis_fixed_paint_device.h"
 #include "kis_transaction.h"
 #include "kis_vec.h"
 #include "kis_iterator_ng.h"
 #include "kis_random_accessor_ng.h"
 
 #include "filter/kis_filter_configuration.h"
 #include "kis_pixel_selection.h"
 #include <brushengine/kis_paint_information.h>
 #include "kis_paintop_registry.h"
 #include "kis_perspective_math.h"
 #include "tiles3/kis_random_accessor.h"
 #include <kis_distance_information.h>
 #include <KoColorSpaceMaths.h>
 #include "kis_lod_transform.h"
 #include "kis_algebra_2d.h"
 #include "krita_utils.h"
 
 
 // Maximum distance from a Bezier control point to the line through the start
 // and end points for the curve to be considered flat.
 #define BEZIER_FLATNESS_THRESHOLD 0.5
 
 #include "kis_painter_p.h"
 
 KisPainter::KisPainter()
     : d(new Private(this))
 {
     init();
 }
 
 KisPainter::KisPainter(KisPaintDeviceSP device)
     : d(new Private(this, device->colorSpace()))
 {
     init();
     Q_ASSERT(device);
     begin(device);
 }
 
 KisPainter::KisPainter(KisPaintDeviceSP device, KisSelectionSP selection)
     : d(new Private(this, device->colorSpace()))
 {
     init();
     Q_ASSERT(device);
     begin(device);
     d->selection = selection;
 }
 
 void KisPainter::init()
 {
     d->selection = 0 ;
     d->transaction = 0;
     d->paintOp = 0;
     d->pattern = 0;
     d->sourceLayer = 0;
     d->fillStyle = FillStyleNone;
     d->strokeStyle = StrokeStyleBrush;
     d->antiAliasPolygonFill = true;
     d->progressUpdater = 0;
     d->gradient = 0;
     d->maskPainter = 0;
     d->fillPainter = 0;
     d->maskImageWidth = 255;
     d->maskImageHeight = 255;
     d->mirrorHorizontally = false;
     d->mirrorVertically = false;
     d->isOpacityUnit = true;
     d->paramInfo = KoCompositeOp::ParameterInfo();
     d->renderingIntent = KoColorConversionTransformation::internalRenderingIntent();
     d->conversionFlags = KoColorConversionTransformation::internalConversionFlags();
 }
 
 KisPainter::~KisPainter()
 {
     // TODO: Maybe, don't be that strict?
     // deleteTransaction();
     end();
 
     delete d->paintOp;
     delete d->maskPainter;
     delete d->fillPainter;
     delete d;
 }
 
 template <bool useOldData>
 void copyAreaOptimizedImpl(const QPoint &dstPt,
                            KisPaintDeviceSP src,
                            KisPaintDeviceSP dst,
                            const QRect &srcRect)
 {
     const QRect dstRect(dstPt, srcRect.size());
 
     const QRect srcExtent = src->extent();
     const QRect dstExtent = dst->extent();
 
     const QRect srcSampleRect = srcExtent & srcRect;
     const QRect dstSampleRect = dstExtent & dstRect;
 
     const bool srcEmpty = srcSampleRect.isEmpty();
     const bool dstEmpty = dstSampleRect.isEmpty();
 
     if (!srcEmpty || !dstEmpty) {
         if (srcEmpty) {
             dst->clear(dstRect);
         } else {
             QRect srcCopyRect = srcRect;
             QRect dstCopyRect = dstRect;
 
             if (!srcExtent.contains(srcRect)) {
                 if (src->defaultPixel() == dst->defaultPixel()) {
                     const QRect dstSampleInSrcCoords = dstSampleRect.translated(srcRect.topLeft() - dstPt);
 
                     if (dstSampleInSrcCoords.isEmpty() || srcSampleRect.contains(dstSampleInSrcCoords)) {
                         srcCopyRect = srcSampleRect;
                     } else {
                         srcCopyRect = srcSampleRect | dstSampleInSrcCoords;
                     }
                     dstCopyRect = QRect(dstPt + srcCopyRect.topLeft() - srcRect.topLeft(), srcCopyRect.size());
                 }
             }
 
             KisPainter gc(dst);
             gc.setCompositeOp(dst->colorSpace()->compositeOp(COMPOSITE_COPY));
 
             if (useOldData) {
                 gc.bitBltOldData(dstCopyRect.topLeft(), src, srcCopyRect);
             } else {
                 gc.bitBlt(dstCopyRect.topLeft(), src, srcCopyRect);
             }
         }
     }
 }
 
 void KisPainter::copyAreaOptimized(const QPoint &dstPt,
                                    KisPaintDeviceSP src,
                                    KisPaintDeviceSP dst,
                                    const QRect &srcRect)
 {
     copyAreaOptimizedImpl<false>(dstPt, src, dst, srcRect);
 }
 
 void KisPainter::copyAreaOptimizedOldData(const QPoint &dstPt,
                                           KisPaintDeviceSP src,
                                           KisPaintDeviceSP dst,
                                           const QRect &srcRect)
 {
     copyAreaOptimizedImpl<true>(dstPt, src, dst, srcRect);
 }
 
 void KisPainter::copyAreaOptimized(const QPoint &dstPt,
                                    KisPaintDeviceSP src,
                                    KisPaintDeviceSP dst,
                                    const QRect &originalSrcRect,
                                    KisSelectionSP selection)
 {
     if (!selection) {
         copyAreaOptimized(dstPt, src, dst, originalSrcRect);
         return;
     }
 
     const QRect selectionRect = selection->selectedRect();
     const QRect srcRect = originalSrcRect & selectionRect;
     const QPoint dstOffset = srcRect.topLeft() - originalSrcRect.topLeft();
     const QRect dstRect = QRect(dstPt + dstOffset, srcRect.size());
 
     const bool srcEmpty = (src->extent() & srcRect).isEmpty();
     const bool dstEmpty = (dst->extent() & dstRect).isEmpty();
 
     if (!srcEmpty || !dstEmpty) {
         //if (srcEmpty) {
         // doesn't support dstRect
         // dst->clearSelection(selection);
         // } else */
         {
             KisPainter gc(dst);
             gc.setSelection(selection);
             gc.setCompositeOp(dst->colorSpace()->compositeOp(COMPOSITE_COPY));
             gc.bitBlt(dstRect.topLeft(), src, srcRect);
         }
     }
 }
 
 KisPaintDeviceSP KisPainter::convertToAlphaAsAlpha(KisPaintDeviceSP src)
 {
     const KoColorSpace *srcCS = src->colorSpace();
     const QRect processRect = src->extent();
     KisPaintDeviceSP dst(new KisPaintDevice(KoColorSpaceRegistry::instance()->alpha8()));
 
     if (processRect.isEmpty()) return dst;
 
     KisSequentialConstIterator srcIt(src, processRect);
     KisSequentialIterator dstIt(dst, processRect);
 
     while (srcIt.nextPixel() && dstIt.nextPixel()) {
         const quint8 *srcPtr = srcIt.rawDataConst();
         quint8 *alpha8Ptr = dstIt.rawData();
 
         const quint8 white = srcCS->intensity8(srcPtr);
         const quint8 alpha = srcCS->opacityU8(srcPtr);
 
         *alpha8Ptr = KoColorSpaceMaths<quint8>::multiply(alpha, KoColorSpaceMathsTraits<quint8>::unitValue - white);
     }
 
     return dst;
 }
 
 KisPaintDeviceSP KisPainter::convertToAlphaAsGray(KisPaintDeviceSP src)
 {
     const KoColorSpace *srcCS = src->colorSpace();
     const QRect processRect = src->extent();
     KisPaintDeviceSP dst(new KisPaintDevice(KoColorSpaceRegistry::instance()->alpha8()));
 
     if (processRect.isEmpty()) return dst;
 
     KisSequentialConstIterator srcIt(src, processRect);
     KisSequentialIterator dstIt(dst, processRect);
 
     while (srcIt.nextPixel() && dstIt.nextPixel()) {
         const quint8 *srcPtr = srcIt.rawDataConst();
         quint8 *alpha8Ptr = dstIt.rawData();
 
         *alpha8Ptr = srcCS->intensity8(srcPtr);
     }
 
     return dst;
 }
 
 bool KisPainter::checkDeviceHasTransparency(KisPaintDeviceSP dev)
 {
     const QRect deviceBounds = dev->exactBounds();
     const QRect imageBounds = dev->defaultBounds()->bounds();
 
     if (deviceBounds.isEmpty() ||
         (deviceBounds & imageBounds) != imageBounds) {
 
         return true;
     }
 
     const KoColorSpace *cs = dev->colorSpace();
     KisSequentialConstIterator it(dev, deviceBounds);
 
     while(it.nextPixel()) {
         if (cs->opacityU8(it.rawDataConst()) != OPACITY_OPAQUE_U8) {
             return true;
         }
     }
 
     return false;
 }
 
 void KisPainter::begin(KisPaintDeviceSP device)
 {
     begin(device, d->selection);
 }
 
 void KisPainter::begin(KisPaintDeviceSP device, KisSelectionSP selection)
 {
     if (!device) return;
     d->selection = selection;
     Q_ASSERT(device->colorSpace());
 
     end();
 
     d->device = device;
     d->colorSpace = device->colorSpace();
     d->compositeOp = d->colorSpace->compositeOp(COMPOSITE_OVER);
     d->pixelSize = device->pixelSize();
 }
 
 void KisPainter::end()
 {
     Q_ASSERT_X(!d->transaction, "KisPainter::end()",
                "end() was called for the painter having a transaction. "
                "Please use end/deleteTransaction() instead");
 }
 
 void KisPainter::beginTransaction(const KUndo2MagicString& transactionName,int timedID)
 {
     Q_ASSERT_X(!d->transaction, "KisPainter::beginTransaction()",
                "You asked for a new transaction while still having "
                "another one. Please finish the first one with "
                "end/deleteTransaction() first");
 
     d->transaction = new KisTransaction(transactionName, d->device);
     Q_CHECK_PTR(d->transaction);
     d->transaction->undoCommand()->setTimedID(timedID);
 }
 
 void KisPainter::revertTransaction()
 {
     Q_ASSERT_X(d->transaction, "KisPainter::revertTransaction()",
                "No transaction is in progress");
 
     d->transaction->revert();
     delete d->transaction;
     d->transaction = 0;
 }
 
 void KisPainter::endTransaction(KisUndoAdapter *undoAdapter)
 {
     Q_ASSERT_X(d->transaction, "KisPainter::endTransaction()",
                "No transaction is in progress");
 
     d->transaction->commit(undoAdapter);
     delete d->transaction;
     d->transaction = 0;
 }
 
 void KisPainter::endTransaction(KisPostExecutionUndoAdapter *undoAdapter)
 {
     Q_ASSERT_X(d->transaction, "KisPainter::endTransaction()",
                "No transaction is in progress");
 
     d->transaction->commit(undoAdapter);
     delete d->transaction;
     d->transaction = 0;
 }
 
 KUndo2Command* KisPainter::endAndTakeTransaction()
 {
     Q_ASSERT_X(d->transaction, "KisPainter::endTransaction()",
                "No transaction is in progress");
 
     KUndo2Command *transactionData = d->transaction->endAndTake();
     delete d->transaction;
     d->transaction = 0;
 
     return transactionData;
 }
 
 void KisPainter::deleteTransaction()
 {
     if (!d->transaction) return;
 
     delete d->transaction;
     d->transaction = 0;
 }
 
 void KisPainter::putTransaction(KisTransaction* transaction)
 {
     Q_ASSERT_X(!d->transaction, "KisPainter::putTransaction()",
                "You asked for a new transaction while still having "
                "another one. Please finish the first one with "
                "end/deleteTransaction() first");
 
     d->transaction = transaction;
 }
 
 KisTransaction* KisPainter::takeTransaction()
 {
     Q_ASSERT_X(d->transaction, "KisPainter::takeTransaction()",
                "No transaction is in progress");
     KisTransaction *temp = d->transaction;
     d->transaction = 0;
     return temp;
 }
 
 
 
 QVector<QRect> KisPainter::takeDirtyRegion()
 {
     QVector<QRect> vrect = d->dirtyRects;
     d->dirtyRects.clear();
     return vrect;
 }
 
 
 void KisPainter::addDirtyRect(const QRect & rc)
 {
     QRect r = rc.normalized();
     if (r.isValid()) {
         d->dirtyRects.append(rc);
     }
 }
 
 void KisPainter::addDirtyRects(const QVector<QRect> &rects)
 {
     d->dirtyRects.reserve(d->dirtyRects.size() + rects.size());
 
     Q_FOREACH (const QRect &rc, rects) {
         const QRect r = rc.normalized();
         if (r.isValid()) {
             d->dirtyRects.append(rc);
         }
     }
 }
 
 inline bool KisPainter::Private::tryReduceSourceRect(const KisPaintDevice *srcDev,
                                                      QRect *srcRect,
                                                      qint32 *srcX,
                                                      qint32 *srcY,
                                                      qint32 *srcWidth,
                                                      qint32 *srcHeight,
                                                      qint32 *dstX,
                                                      qint32 *dstY)
 {
     /**
      * In case of COMPOSITE_COPY and Wrap Around Mode even the pixels
      * outside the device extent matter, because they will be either
      * directly copied (former case) or cloned from another area of
      * the image.
      */
     if (compositeOp->id() != COMPOSITE_COPY &&
         compositeOp->id() != COMPOSITE_DESTINATION_IN  &&
         compositeOp->id() != COMPOSITE_DESTINATION_ATOP &&
         !srcDev->defaultBounds()->wrapAroundMode()) {
 
         /**
          * If srcDev->extent() (the area of the tiles containing
          * srcDev) is smaller than srcRect, then shrink srcRect to
          * that size. This is done as a speed optimization, useful for
          * stack recomposition in KisImage. srcRect won't grow if
          * srcDev->extent() is larger.
          */
         *srcRect &= srcDev->extent();
 
         if (srcRect->isEmpty()) return true;
 
         // Readjust the function paramenters to the new dimensions.
         *dstX += srcRect->x() - *srcX;    // This will only add, not subtract
         *dstY += srcRect->y() - *srcY;    // Idem
         srcRect->getRect(srcX, srcY, srcWidth, srcHeight);
     }
 
     return false;
 }
 
 void KisPainter::bitBltWithFixedSelection(qint32 dstX, qint32 dstY,
                                           const KisPaintDeviceSP srcDev,
                                           const KisFixedPaintDeviceSP selection,
                                           qint32 selX, qint32 selY,
                                           qint32 srcX, qint32 srcY,
                                           qint32 srcWidth, qint32 srcHeight)
 {
     // TODO: get selX and selY working as intended
 
     /* This check for nonsense ought to be a Q_ASSERT. However, when paintops are just
     initializing they perform some dummy passes with those parameters, and it must not crash */
     if (srcWidth == 0 || srcHeight == 0) return;
     if (srcDev.isNull()) return;
     if (d->device.isNull()) return;
 
     // Check that selection has an alpha colorspace, crash if false
     Q_ASSERT(selection->colorSpace() == KoColorSpaceRegistry::instance()->alpha8());
 
     QRect srcRect = QRect(srcX, srcY, srcWidth, srcHeight);
     QRect selRect = QRect(selX, selY, srcWidth, srcHeight);
 
     /* Trying to read outside a KisFixedPaintDevice is inherently wrong and shouldn't be done,
     so crash if someone attempts to do this. Don't resize YET as it would obfuscate the mistake. */
     Q_ASSERT(selection->bounds().contains(selRect));
     Q_UNUSED(selRect); // only used by the above Q_ASSERT
 
     /**
      * An optimization, which crops the source rect by the bounds of
      * the source device when it is possible
      */
     if (d->tryReduceSourceRect(srcDev, &srcRect,
                                &srcX, &srcY,
                                &srcWidth, &srcHeight,
                                &dstX, &dstY)) return;
 
     /* Create an intermediate byte array to hold information before it is written
     to the current paint device (d->device) */
     quint8* dstBytes = 0;
     try {
         dstBytes = new quint8[srcWidth * srcHeight * d->device->pixelSize()];
-    } catch (std::bad_alloc) {
+    } catch (const std::bad_alloc&) {
         warnKrita << "KisPainter::bitBltWithFixedSelection std::bad_alloc for " << srcWidth << " * " << srcHeight << " * " << d->device->pixelSize() << "dst bytes";
         return;
     }
 
     d->device->readBytes(dstBytes, dstX, dstY, srcWidth, srcHeight);
 
     // Copy the relevant bytes of raw data from srcDev
     quint8* srcBytes = 0;
     try {
         srcBytes = new quint8[srcWidth * srcHeight * srcDev->pixelSize()];
-    } catch (std::bad_alloc) {
+    } catch (const std::bad_alloc&) {
         warnKrita << "KisPainter::bitBltWithFixedSelection std::bad_alloc for " << srcWidth << " * " << srcHeight << " * " << d->device->pixelSize() << "src bytes";
         return;
     }
 
     srcDev->readBytes(srcBytes, srcX, srcY, srcWidth, srcHeight);
 
     QRect selBounds = selection->bounds();
     const quint8 *selRowStart = selection->data() +
         (selBounds.width() * (selY - selBounds.top()) + (selX - selBounds.left())) * selection->pixelSize();
 
     /*
      * This checks whether there is nothing selected.
      */
     if (!d->selection) {
         /* As there's nothing selected, blit to dstBytes (intermediary bit array),
           ignoring d->selection (the user selection)*/
         d->paramInfo.dstRowStart   = dstBytes;
         d->paramInfo.dstRowStride  = srcWidth * d->device->pixelSize();
         d->paramInfo.srcRowStart   = srcBytes;
         d->paramInfo.srcRowStride  = srcWidth * srcDev->pixelSize();
         d->paramInfo.maskRowStart  = selRowStart;
         d->paramInfo.maskRowStride = selBounds.width() * selection->pixelSize();
         d->paramInfo.rows          = srcHeight;
         d->paramInfo.cols          = srcWidth;
         d->colorSpace->bitBlt(srcDev->colorSpace(), d->paramInfo, d->compositeOp, d->renderingIntent, d->conversionFlags);
     }
     else {
         /* Read the user selection (d->selection) bytes into an array, ready
         to merge in the next block*/
         quint32 totalBytes = srcWidth * srcHeight * selection->pixelSize();
         quint8* mergedSelectionBytes = 0;
         try {
             mergedSelectionBytes = new quint8[ totalBytes ];
-        } catch (std::bad_alloc) {
+        } catch (const std::bad_alloc&) {
             warnKrita << "KisPainter::bitBltWithFixedSelection std::bad_alloc for " << srcWidth << " * " << srcHeight << " * " << d->device->pixelSize() << "total bytes";
             return;
         }
 
         d->selection->projection()->readBytes(mergedSelectionBytes, dstX, dstY, srcWidth, srcHeight);
 
         // Merge selections here by multiplying them - compositeOP(COMPOSITE_MULT)
         d->paramInfo.dstRowStart   = mergedSelectionBytes;
         d->paramInfo.dstRowStride  = srcWidth * selection->pixelSize();
         d->paramInfo.srcRowStart   = selRowStart;
         d->paramInfo.srcRowStride  = selBounds.width() * selection->pixelSize();
         d->paramInfo.maskRowStart  = 0;
         d->paramInfo.maskRowStride = 0;
         d->paramInfo.rows          = srcHeight;
         d->paramInfo.cols          = srcWidth;
         KoColorSpaceRegistry::instance()->alpha8()->compositeOp(COMPOSITE_MULT)->composite(d->paramInfo);
 
         // Blit to dstBytes (intermediary bit array)
         d->paramInfo.dstRowStart   = dstBytes;
         d->paramInfo.dstRowStride  = srcWidth * d->device->pixelSize();
         d->paramInfo.srcRowStart   = srcBytes;
         d->paramInfo.srcRowStride  = srcWidth * srcDev->pixelSize();
         d->paramInfo.maskRowStart  = mergedSelectionBytes;
         d->paramInfo.maskRowStride = srcWidth * selection->pixelSize();
         d->colorSpace->bitBlt(srcDev->colorSpace(), d->paramInfo, d->compositeOp, d->renderingIntent, d->conversionFlags);
         delete[] mergedSelectionBytes;
     }
 
     d->device->writeBytes(dstBytes, dstX, dstY, srcWidth, srcHeight);
 
     delete[] dstBytes;
     delete[] srcBytes;
 
     addDirtyRect(QRect(dstX, dstY, srcWidth, srcHeight));
 }
 
 
 void KisPainter::bitBltWithFixedSelection(qint32 dstX, qint32 dstY,
                                           const KisPaintDeviceSP srcDev,
                                           const KisFixedPaintDeviceSP selection,
                                           qint32 srcWidth, qint32 srcHeight)
 {
     bitBltWithFixedSelection(dstX, dstY, srcDev, selection, 0, 0, 0, 0, srcWidth, srcHeight);
 }
 
 template <bool useOldSrcData>
 void KisPainter::bitBltImpl(qint32 dstX, qint32 dstY,
                             const KisPaintDeviceSP srcDev,
                             qint32 srcX, qint32 srcY,
                             qint32 srcWidth, qint32 srcHeight)
 {
     /* This check for nonsense ought to be a Q_ASSERT. However, when paintops are just
     initializing they perform some dummy passes with those parameters, and it must not crash */
     if (srcWidth == 0 || srcHeight == 0) return;
     if (srcDev.isNull()) return;
     if (d->device.isNull()) return;
 
     QRect srcRect = QRect(srcX, srcY, srcWidth, srcHeight);
 
     if (d->compositeOp->id() == COMPOSITE_COPY) {
         if(!d->selection && d->isOpacityUnit &&
            srcX == dstX && srcY == dstY &&
            d->device->fastBitBltPossible(srcDev)) {
 
             if(useOldSrcData) {
                 d->device->fastBitBltOldData(srcDev, srcRect);
             } else {
                 d->device->fastBitBlt(srcDev, srcRect);
             }
 
             addDirtyRect(srcRect);
             return;
         }
     }
     else {
         /**
          * An optimization, which crops the source rect by the bounds of
          * the source device when it is possible
          */
         if (d->tryReduceSourceRect(srcDev, &srcRect,
                                    &srcX, &srcY,
                                    &srcWidth, &srcHeight,
                                    &dstX, &dstY)) return;
     }
 
     qint32 dstY_ = dstY;
     qint32 srcY_ = srcY;
     qint32 rowsRemaining = srcHeight;
 
     // Read below
     KisRandomConstAccessorSP srcIt = srcDev->createRandomConstAccessorNG(srcX, srcY);
     KisRandomAccessorSP dstIt = d->device->createRandomAccessorNG(dstX, dstY);
 
     /* Here be a huge block of verbose code that does roughly the same than
     the other bit blit operations. This one is longer than the rest in an effort to
     optimize speed and memory use */
     if (d->selection) {
         KisPaintDeviceSP selectionProjection(d->selection->projection());
         KisRandomConstAccessorSP maskIt = selectionProjection->createRandomConstAccessorNG(dstX, dstY);
 
         while (rowsRemaining > 0) {
 
             qint32 dstX_ = dstX;
             qint32 srcX_ = srcX;
             qint32 columnsRemaining = srcWidth;
             qint32 numContiguousDstRows = dstIt->numContiguousRows(dstY_);
             qint32 numContiguousSrcRows = srcIt->numContiguousRows(srcY_);
             qint32 numContiguousSelRows = maskIt->numContiguousRows(dstY_);
 
             qint32 rows = qMin(numContiguousDstRows, numContiguousSrcRows);
             rows = qMin(rows, numContiguousSelRows);
             rows = qMin(rows, rowsRemaining);
 
             while (columnsRemaining > 0) {
 
                 qint32 numContiguousDstColumns = dstIt->numContiguousColumns(dstX_);
                 qint32 numContiguousSrcColumns = srcIt->numContiguousColumns(srcX_);
                 qint32 numContiguousSelColumns = maskIt->numContiguousColumns(dstX_);
 
                 qint32 columns = qMin(numContiguousDstColumns, numContiguousSrcColumns);
                 columns = qMin(columns, numContiguousSelColumns);
                 columns = qMin(columns, columnsRemaining);
 
                 qint32 srcRowStride = srcIt->rowStride(srcX_, srcY_);
                 srcIt->moveTo(srcX_, srcY_);
 
                 qint32 dstRowStride = dstIt->rowStride(dstX_, dstY_);
                 dstIt->moveTo(dstX_, dstY_);
 
                 qint32 maskRowStride = maskIt->rowStride(dstX_, dstY_);
                 maskIt->moveTo(dstX_, dstY_);
 
                 d->paramInfo.dstRowStart   = dstIt->rawData();
                 d->paramInfo.dstRowStride  = dstRowStride;
                 // if we don't use the oldRawData, we need to access the rawData of the source device.
                 d->paramInfo.srcRowStart   = useOldSrcData ? srcIt->oldRawData() : static_cast<KisRandomAccessor2*>(srcIt.data())->rawData();
                 d->paramInfo.srcRowStride  = srcRowStride;
                 d->paramInfo.maskRowStart  = static_cast<KisRandomAccessor2*>(maskIt.data())->rawData();
                 d->paramInfo.maskRowStride = maskRowStride;
                 d->paramInfo.rows          = rows;
                 d->paramInfo.cols          = columns;
                 d->colorSpace->bitBlt(srcDev->colorSpace(), d->paramInfo, d->compositeOp, d->renderingIntent, d->conversionFlags);
 
                 srcX_ += columns;
                 dstX_ += columns;
                 columnsRemaining -= columns;
             }
 
             srcY_ += rows;
             dstY_ += rows;
             rowsRemaining -= rows;
         }
     }
     else {
 
         while (rowsRemaining > 0) {
 
             qint32 dstX_ = dstX;
             qint32 srcX_ = srcX;
             qint32 columnsRemaining = srcWidth;
             qint32 numContiguousDstRows = dstIt->numContiguousRows(dstY_);
             qint32 numContiguousSrcRows = srcIt->numContiguousRows(srcY_);
 
             qint32 rows = qMin(numContiguousDstRows, numContiguousSrcRows);
             rows = qMin(rows, rowsRemaining);
 
             while (columnsRemaining > 0) {
 
                 qint32 numContiguousDstColumns = dstIt->numContiguousColumns(dstX_);
                 qint32 numContiguousSrcColumns = srcIt->numContiguousColumns(srcX_);
 
                 qint32 columns = qMin(numContiguousDstColumns, numContiguousSrcColumns);
                 columns = qMin(columns, columnsRemaining);
 
                 qint32 srcRowStride = srcIt->rowStride(srcX_, srcY_);
                 srcIt->moveTo(srcX_, srcY_);
 
                 qint32 dstRowStride = dstIt->rowStride(dstX_, dstY_);
                 dstIt->moveTo(dstX_, dstY_);
 
                 d->paramInfo.dstRowStart   = dstIt->rawData();
                 d->paramInfo.dstRowStride  = dstRowStride;
                 // if we don't use the oldRawData, we need to access the rawData of the source device.
                 d->paramInfo.srcRowStart   = useOldSrcData ? srcIt->oldRawData() : static_cast<KisRandomAccessor2*>(srcIt.data())->rawData();
                 d->paramInfo.srcRowStride  = srcRowStride;
                 d->paramInfo.maskRowStart  = 0;
                 d->paramInfo.maskRowStride = 0;
                 d->paramInfo.rows          = rows;
                 d->paramInfo.cols          = columns;
                 d->colorSpace->bitBlt(srcDev->colorSpace(), d->paramInfo, d->compositeOp, d->renderingIntent, d->conversionFlags);
 
                 srcX_ += columns;
                 dstX_ += columns;
                 columnsRemaining -= columns;
             }
 
             srcY_ += rows;
             dstY_ += rows;
             rowsRemaining -= rows;
         }
     }
 
     addDirtyRect(QRect(dstX, dstY, srcWidth, srcHeight));
 
 }
 
 void KisPainter::bitBlt(qint32 dstX, qint32 dstY,
                         const KisPaintDeviceSP srcDev,
                         qint32 srcX, qint32 srcY,
                         qint32 srcWidth, qint32 srcHeight)
 {
     bitBltImpl<false>(dstX, dstY, srcDev, srcX, srcY, srcWidth, srcHeight);
 }
 
 
 void KisPainter::bitBlt(const QPoint & pos, const KisPaintDeviceSP srcDev, const QRect & srcRect)
 {
     bitBlt(pos.x(), pos.y(), srcDev, srcRect.x(), srcRect.y(), srcRect.width(), srcRect.height());
 }
 
 void KisPainter::bitBltOldData(qint32 dstX, qint32 dstY,
                                const KisPaintDeviceSP srcDev,
                                qint32 srcX, qint32 srcY,
                                qint32 srcWidth, qint32 srcHeight)
 {
     bitBltImpl<true>(dstX, dstY, srcDev, srcX, srcY, srcWidth, srcHeight);
 }
 
 
 void KisPainter::bitBltOldData(const QPoint & pos, const KisPaintDeviceSP srcDev, const QRect & srcRect)
 {
     bitBltOldData(pos.x(), pos.y(), srcDev, srcRect.x(), srcRect.y(), srcRect.width(), srcRect.height());
 }
 
 
 void KisPainter::fill(qint32 x, qint32 y, qint32 width, qint32 height, const KoColor& color)
 {
     /* This check for nonsense ought to be a Q_ASSERT. However, when paintops are just
      * initializing they perform some dummy passes with those parameters, and it must not crash */
     if(width == 0 || height == 0 || d->device.isNull())
         return;
 
     KoColor srcColor(color, d->device->compositionSourceColorSpace());
     qint32  dstY          = y;
     qint32  rowsRemaining = height;
 
     KisRandomAccessorSP dstIt = d->device->createRandomAccessorNG(x, y);
 
     if(d->selection) {
         KisPaintDeviceSP selectionProjection(d->selection->projection());
         KisRandomConstAccessorSP maskIt = selectionProjection->createRandomConstAccessorNG(x, y);
 
         while(rowsRemaining > 0) {
 
             qint32 dstX                 = x;
             qint32 columnsRemaining     = width;
             qint32 numContiguousDstRows = dstIt->numContiguousRows(dstY);
             qint32 numContiguousSelRows = maskIt->numContiguousRows(dstY);
             qint32 rows = qMin(numContiguousDstRows, numContiguousSelRows);
             rows = qMin(rows, rowsRemaining);
 
             while (columnsRemaining > 0) {
 
                 qint32 numContiguousDstColumns = dstIt->numContiguousColumns(dstX);
                 qint32 numContiguousSelColumns = maskIt->numContiguousColumns(dstX);
 
                 qint32 columns = qMin(numContiguousDstColumns, numContiguousSelColumns);
                 columns = qMin(columns, columnsRemaining);
 
                 qint32 dstRowStride = dstIt->rowStride(dstX, dstY);
                 dstIt->moveTo(dstX, dstY);
                 qint32 maskRowStride = maskIt->rowStride(dstX, dstY);
 
                 maskIt->moveTo(dstX, dstY);
 
                 d->paramInfo.dstRowStart   = dstIt->rawData();
                 d->paramInfo.dstRowStride  = dstRowStride;
                 d->paramInfo.srcRowStart   = srcColor.data();
                 d->paramInfo.srcRowStride  = 0; // srcRowStride is set to zero to use the compositeOp with only a single color pixel
                 d->paramInfo.maskRowStart  = maskIt->oldRawData();
                 d->paramInfo.maskRowStride = maskRowStride;
                 d->paramInfo.rows          = rows;
                 d->paramInfo.cols          = columns;
                 d->colorSpace->bitBlt(srcColor.colorSpace(), d->paramInfo, d->compositeOp, d->renderingIntent, d->conversionFlags);
 
                 dstX             += columns;
                 columnsRemaining -= columns;
             }
 
             dstY          += rows;
             rowsRemaining -= rows;
         }
     }
     else {
 
         while(rowsRemaining > 0) {
 
             qint32 dstX                 = x;
             qint32 columnsRemaining     = width;
             qint32 numContiguousDstRows = dstIt->numContiguousRows(dstY);
             qint32 rows                 = qMin(numContiguousDstRows, rowsRemaining);
 
             while(columnsRemaining > 0) {
 
                 qint32 numContiguousDstColumns = dstIt->numContiguousColumns(dstX);
                 qint32 columns                 = qMin(numContiguousDstColumns, columnsRemaining);
                 qint32 dstRowStride            = dstIt->rowStride(dstX, dstY);
                 dstIt->moveTo(dstX, dstY);
 
                 d->paramInfo.dstRowStart   = dstIt->rawData();
                 d->paramInfo.dstRowStride  = dstRowStride;
                 d->paramInfo.srcRowStart   = srcColor.data();
                 d->paramInfo.srcRowStride  = 0; // srcRowStride is set to zero to use the compositeOp with only a single color pixel
                 d->paramInfo.maskRowStart  = 0;
                 d->paramInfo.maskRowStride = 0;
                 d->paramInfo.rows          = rows;
                 d->paramInfo.cols          = columns;
                 d->colorSpace->bitBlt(srcColor.colorSpace(), d->paramInfo, d->compositeOp, d->renderingIntent, d->conversionFlags);
 
                 dstX             += columns;
                 columnsRemaining -= columns;
             }
 
             dstY          += rows;
             rowsRemaining -= rows;
         }
     }
 
     addDirtyRect(QRect(x, y, width, height));
 }
 
 
 void KisPainter::bltFixed(qint32 dstX, qint32 dstY,
                           const KisFixedPaintDeviceSP srcDev,
                           qint32 srcX, qint32 srcY,
                           qint32 srcWidth, qint32 srcHeight)
 {
     /* This check for nonsense ought to be a Q_ASSERT. However, when paintops are just
     initializing they perform some dummy passes with those parameters, and it must not crash */
     if (srcWidth == 0 || srcHeight == 0) return;
     if (srcDev.isNull()) return;
     if (d->device.isNull()) return;
 
     QRect srcRect = QRect(srcX, srcY, srcWidth, srcHeight);
     QRect srcBounds = srcDev->bounds();
 
     /* Trying to read outside a KisFixedPaintDevice is inherently wrong and shouldn't be done,
     so crash if someone attempts to do this. Don't resize as it would obfuscate the mistake. */
     KIS_SAFE_ASSERT_RECOVER_RETURN(srcBounds.contains(srcRect));
     Q_UNUSED(srcRect); // only used in above assertion
 
     /* Create an intermediate byte array to hold information before it is written
     to the current paint device (aka: d->device) */
     quint8* dstBytes = 0;
     try {
          dstBytes = new quint8[srcWidth * srcHeight * d->device->pixelSize()];
-    } catch (std::bad_alloc) {
+    } catch (const std::bad_alloc&) {
         warnKrita << "KisPainter::bltFixed std::bad_alloc for " << srcWidth << " * " << srcHeight << " * " << d->device->pixelSize() << "total bytes";
         return;
     }
     d->device->readBytes(dstBytes, dstX, dstY, srcWidth, srcHeight);
 
     const quint8 *srcRowStart = srcDev->data() +
         (srcBounds.width() * (srcY - srcBounds.top()) + (srcX - srcBounds.left())) * srcDev->pixelSize();
 
     d->paramInfo.dstRowStart   = dstBytes;
     d->paramInfo.dstRowStride  = srcWidth * d->device->pixelSize();
     d->paramInfo.srcRowStart   = srcRowStart;
     d->paramInfo.srcRowStride  = srcBounds.width() * srcDev->pixelSize();
     d->paramInfo.maskRowStart  = 0;
     d->paramInfo.maskRowStride = 0;
     d->paramInfo.rows          = srcHeight;
     d->paramInfo.cols          = srcWidth;
 
     if (d->selection) {
         /* d->selection is a KisPaintDevice, so first a readBytes is performed to
         get the area of interest... */
         KisPaintDeviceSP selectionProjection(d->selection->projection());
         quint8* selBytes = 0;
         try {
             selBytes = new quint8[srcWidth * srcHeight * selectionProjection->pixelSize()];
         }
-        catch (std::bad_alloc) {
+        catch (const std::bad_alloc&) {
             delete[] dstBytes;
             return;
         }
 
         selectionProjection->readBytes(selBytes, dstX, dstY, srcWidth, srcHeight);
         d->paramInfo.maskRowStart = selBytes;
         d->paramInfo.maskRowStride = srcWidth * selectionProjection->pixelSize();
     }
 
     // ...and then blit.
     d->colorSpace->bitBlt(srcDev->colorSpace(), d->paramInfo, d->compositeOp, d->renderingIntent, d->conversionFlags);
     d->device->writeBytes(dstBytes, dstX, dstY, srcWidth, srcHeight);
 
     delete[] d->paramInfo.maskRowStart;
     delete[] dstBytes;
 
     addDirtyRect(QRect(dstX, dstY, srcWidth, srcHeight));
 }
 
 void KisPainter::bltFixed(const QPoint & pos, const KisFixedPaintDeviceSP srcDev, const QRect & srcRect)
 {
     bltFixed(pos.x(), pos.y(), srcDev, srcRect.x(), srcRect.y(), srcRect.width(), srcRect.height());
 }
 
 void KisPainter::bltFixedWithFixedSelection(qint32 dstX, qint32 dstY,
                                             const KisFixedPaintDeviceSP srcDev,
                                             const KisFixedPaintDeviceSP selection,
                                             qint32 selX, qint32 selY,
                                             qint32 srcX, qint32 srcY,
                                             quint32 srcWidth, quint32 srcHeight)
 {
     // TODO: get selX and selY working as intended
 
     /* This check for nonsense ought to be a Q_ASSERT. However, when paintops are just
     initializing they perform some dummy passes with those parameters, and it must not crash */
     if (srcWidth == 0 || srcHeight == 0) return;
     if (srcDev.isNull()) return;
     if (d->device.isNull()) return;
 
      // Check that selection has an alpha colorspace, crash if false
     Q_ASSERT(selection->colorSpace() == KoColorSpaceRegistry::instance()->alpha8());
 
     QRect srcRect = QRect(srcX, srcY, srcWidth, srcHeight);
     QRect selRect = QRect(selX, selY, srcWidth, srcHeight);
 
     QRect srcBounds = srcDev->bounds();
     QRect selBounds = selection->bounds();
 
     /* Trying to read outside a KisFixedPaintDevice is inherently wrong and shouldn't be done,
     so crash if someone attempts to do this. Don't resize as it would obfuscate the mistake. */
     Q_ASSERT(srcBounds.contains(srcRect));
     Q_UNUSED(srcRect); // only used in above assertion
     Q_ASSERT(selBounds.contains(selRect));
     Q_UNUSED(selRect); // only used in above assertion
 
     /* Create an intermediate byte array to hold information before it is written
     to the current paint device (aka: d->device) */
     quint8* dstBytes = 0;
     try {
         dstBytes = new quint8[srcWidth * srcHeight * d->device->pixelSize()];
-    } catch (std::bad_alloc) {
+    } catch (const std::bad_alloc&) {
         warnKrita << "KisPainter::bltFixedWithFixedSelection std::bad_alloc for " << srcWidth << " * " << srcHeight << " * " << d->device->pixelSize() << "total bytes";
         return;
     }
     d->device->readBytes(dstBytes, dstX, dstY, srcWidth, srcHeight);
 
     const quint8 *srcRowStart = srcDev->data() +
         (srcBounds.width() * (srcY - srcBounds.top()) + (srcX - srcBounds.left())) * srcDev->pixelSize();
     const quint8 *selRowStart = selection->data() +
         (selBounds.width() * (selY - selBounds.top()) + (selX - selBounds.left())) * selection->pixelSize();
 
     if (!d->selection) {
         /* As there's nothing selected, blit to dstBytes (intermediary bit array),
           ignoring d->selection (the user selection)*/
         d->paramInfo.dstRowStart   = dstBytes;
         d->paramInfo.dstRowStride  = srcWidth * d->device->pixelSize();
         d->paramInfo.srcRowStart   = srcRowStart;
         d->paramInfo.srcRowStride  = srcBounds.width() * srcDev->pixelSize();
         d->paramInfo.maskRowStart  = selRowStart;
         d->paramInfo.maskRowStride = selBounds.width() * selection->pixelSize();
         d->paramInfo.rows          = srcHeight;
         d->paramInfo.cols          = srcWidth;
         d->colorSpace->bitBlt(srcDev->colorSpace(), d->paramInfo, d->compositeOp, d->renderingIntent, d->conversionFlags);
     }
     else {
         /* Read the user selection (d->selection) bytes into an array, ready
         to merge in the next block*/
         quint32 totalBytes = srcWidth * srcHeight * selection->pixelSize();
         quint8 * mergedSelectionBytes = 0;
         try {
             mergedSelectionBytes = new quint8[ totalBytes ];
-        } catch (std::bad_alloc) {
+        } catch (const std::bad_alloc&) {
             warnKrita << "KisPainter::bltFixedWithFixedSelection std::bad_alloc for " << totalBytes << "total bytes";
             delete[] dstBytes;
             return;
         }
         d->selection->projection()->readBytes(mergedSelectionBytes, dstX, dstY, srcWidth, srcHeight);
 
         // Merge selections here by multiplying them - compositeOp(COMPOSITE_MULT)
         d->paramInfo.dstRowStart   = mergedSelectionBytes;
         d->paramInfo.dstRowStride  = srcWidth * selection->pixelSize();
         d->paramInfo.srcRowStart   = selRowStart;
         d->paramInfo.srcRowStride  = selBounds.width() * selection->pixelSize();
         d->paramInfo.maskRowStart  = 0;
         d->paramInfo.maskRowStride = 0;
         d->paramInfo.rows          = srcHeight;
         d->paramInfo.cols          = srcWidth;
         KoColorSpaceRegistry::instance()->alpha8()->compositeOp(COMPOSITE_MULT)->composite(d->paramInfo);
 
         // Blit to dstBytes (intermediary bit array)
         d->paramInfo.dstRowStart   = dstBytes;
         d->paramInfo.dstRowStride  = srcWidth * d->device->pixelSize();
         d->paramInfo.srcRowStart   = srcRowStart;
         d->paramInfo.srcRowStride  = srcBounds.width() * srcDev->pixelSize();
         d->paramInfo.maskRowStart  = mergedSelectionBytes;
         d->paramInfo.maskRowStride = srcWidth * selection->pixelSize();
         d->colorSpace->bitBlt(srcDev->colorSpace(), d->paramInfo, d->compositeOp, d->renderingIntent, d->conversionFlags);
 
         delete[] mergedSelectionBytes;
     }
 
     d->device->writeBytes(dstBytes, dstX, dstY, srcWidth, srcHeight);
 
     delete[] dstBytes;
 
     addDirtyRect(QRect(dstX, dstY, srcWidth, srcHeight));
 }
 
 void KisPainter::bltFixedWithFixedSelection(qint32 dstX, qint32 dstY,
                                             const KisFixedPaintDeviceSP srcDev,
                                             const KisFixedPaintDeviceSP selection,
                                             quint32 srcWidth, quint32 srcHeight)
 {
     bltFixedWithFixedSelection(dstX, dstY, srcDev, selection, 0, 0, 0, 0, srcWidth, srcHeight);
 }
 
 
 
 
 
 void KisPainter::paintLine(const KisPaintInformation &pi1,
                            const KisPaintInformation &pi2,
                            KisDistanceInformation *currentDistance)
 {
     if (d->device && d->paintOp && d->paintOp->canPaint()) {
         d->paintOp->paintLine(pi1, pi2, currentDistance);
     }
 }
 
 
 void KisPainter::paintPolyline(const vQPointF &points,
                                int index, int numPoints)
 {
     if (index >= points.count())
         return;
 
     if (numPoints < 0)
         numPoints = points.count();
 
     if (index + numPoints > points.count())
         numPoints = points.count() - index;
 
     if (numPoints > 1) {
         KisDistanceInformation saveDist(points[0],
                                         KisAlgebra2D::directionBetweenPoints(points[0], points[1], 0.0));
         for (int i = index; i < index + numPoints - 1; i++) {
             paintLine(points [i], points [i + 1], &saveDist);
         }
     }
 }
 
 static void getBezierCurvePoints(const KisVector2D &pos1,
                                  const KisVector2D &control1,
                                  const KisVector2D &control2,
                                  const KisVector2D &pos2,
                                  vQPointF& points)
 {
     LineEquation line = LineEquation::Through(pos1, pos2);
     qreal d1 = line.absDistance(control1);
     qreal d2 = line.absDistance(control2);
 
     if (d1 < BEZIER_FLATNESS_THRESHOLD && d2 < BEZIER_FLATNESS_THRESHOLD) {
         points.push_back(toQPointF(pos1));
     } else {
         // Midpoint subdivision. See Foley & Van Dam Computer Graphics P.508
 
         KisVector2D l2 = (pos1 + control1) / 2;
         KisVector2D h = (control1 + control2) / 2;
         KisVector2D l3 = (l2 + h) / 2;
         KisVector2D r3 = (control2 + pos2) / 2;
         KisVector2D r2 = (h + r3) / 2;
         KisVector2D l4 = (l3 + r2) / 2;
 
         getBezierCurvePoints(pos1, l2, l3, l4, points);
         getBezierCurvePoints(l4, r2, r3, pos2, points);
     }
 }
 
 void KisPainter::getBezierCurvePoints(const QPointF &pos1,
                                       const QPointF &control1,
                                       const QPointF &control2,
                                       const QPointF &pos2,
                                       vQPointF& points) const
 {
     ::getBezierCurvePoints(toKisVector2D(pos1), toKisVector2D(control1), toKisVector2D(control2), toKisVector2D(pos2), points);
 }
 
 void KisPainter::paintBezierCurve(const KisPaintInformation &pi1,
                                   const QPointF &control1,
                                   const QPointF &control2,
                                   const KisPaintInformation &pi2,
                                   KisDistanceInformation *currentDistance)
 {
     if (d->paintOp && d->paintOp->canPaint()) {
         d->paintOp->paintBezierCurve(pi1, control1, control2, pi2, currentDistance);
     }
 }
 
 void KisPainter::paintRect(const QRectF &rect)
 {
     QRectF normalizedRect = rect.normalized();
 
     vQPointF points;
 
     points.push_back(normalizedRect.topLeft());
     points.push_back(normalizedRect.bottomLeft());
     points.push_back(normalizedRect.bottomRight());
     points.push_back(normalizedRect.topRight());
 
     paintPolygon(points);
 }
 
 void KisPainter::paintRect(const qreal x,
                            const qreal y,
                            const qreal w,
                            const qreal h)
 {
     paintRect(QRectF(x, y, w, h));
 }
 
 void KisPainter::paintEllipse(const QRectF &rect)
 {
     QRectF r = rect.normalized(); // normalize before checking as negative width and height are empty too
     if (r.isEmpty()) return;
 
     // See http://www.whizkidtech.redprince.net/bezier/circle/ for explanation.
     // kappa = (4/3*(sqrt(2)-1))
     const qreal kappa = 0.5522847498;
     const qreal lx = (r.width() / 2) * kappa;
     const qreal ly = (r.height() / 2) * kappa;
 
     QPointF center = r.center();
 
     QPointF p0(r.left(), center.y());
     QPointF p1(r.left(), center.y() - ly);
     QPointF p2(center.x() - lx, r.top());
     QPointF p3(center.x(), r.top());
 
     vQPointF points;
 
     getBezierCurvePoints(p0, p1, p2, p3, points);
 
     QPointF p4(center.x() + lx, r.top());
     QPointF p5(r.right(), center.y() - ly);
     QPointF p6(r.right(), center.y());
 
     getBezierCurvePoints(p3, p4, p5, p6, points);
 
     QPointF p7(r.right(), center.y() + ly);
     QPointF p8(center.x() + lx, r.bottom());
     QPointF p9(center.x(), r.bottom());
 
     getBezierCurvePoints(p6, p7, p8, p9, points);
 
     QPointF p10(center.x() - lx, r.bottom());
     QPointF p11(r.left(), center.y() + ly);
 
     getBezierCurvePoints(p9, p10, p11, p0, points);
 
     paintPolygon(points);
 }
 
 void KisPainter::paintEllipse(const qreal x,
                               const qreal y,
                               const qreal w,
                               const qreal h)
 {
     paintEllipse(QRectF(x, y, w, h));
 }
 
 void KisPainter::paintAt(const KisPaintInformation& pi,
                          KisDistanceInformation *savedDist)
 {
     if (d->paintOp && d->paintOp->canPaint()) {
         d->paintOp->paintAt(pi, savedDist);
     }
 }
 
 void KisPainter::fillPolygon(const vQPointF& points, FillStyle fillStyle)
 {
     if (points.count() < 3) {
         return;
     }
 
     if (fillStyle == FillStyleNone) {
         return;
     }
 
     QPainterPath polygonPath;
 
     polygonPath.moveTo(points.at(0));
 
     for (int pointIndex = 1; pointIndex < points.count(); pointIndex++) {
         polygonPath.lineTo(points.at(pointIndex));
     }
 
     polygonPath.closeSubpath();
 
     d->fillStyle = fillStyle;
     fillPainterPath(polygonPath);
 }
 
 void KisPainter::paintPolygon(const vQPointF& points)
 {
     if (d->fillStyle != FillStyleNone) {
         fillPolygon(points, d->fillStyle);
     }
 
     if (d->strokeStyle != StrokeStyleNone) {
         if (points.count() > 1) {
             KisDistanceInformation distance(points[0],
                                             KisAlgebra2D::directionBetweenPoints(points[0], points[1], 0.0));
 
             for (int i = 0; i < points.count() - 1; i++) {
                 paintLine(KisPaintInformation(points[i]), KisPaintInformation(points[i + 1]), &distance);
             }
             paintLine(points[points.count() - 1], points[0], &distance);
         }
     }
 }
 
 void KisPainter::paintPainterPath(const QPainterPath& path)
 {
     if (d->fillStyle != FillStyleNone) {
         fillPainterPath(path);
     }
 
     if (d->strokeStyle == StrokeStyleNone) return;
 
     QPointF lastPoint, nextPoint;
     int elementCount = path.elementCount();
     KisDistanceInformation saveDist;
     for (int i = 0; i < elementCount; i++) {
         QPainterPath::Element element = path.elementAt(i);
         switch (element.type) {
         case QPainterPath::MoveToElement:
             lastPoint =  QPointF(element.x, element.y);
             break;
         case QPainterPath::LineToElement:
             nextPoint =  QPointF(element.x, element.y);
             paintLine(KisPaintInformation(lastPoint), KisPaintInformation(nextPoint), &saveDist);
             lastPoint = nextPoint;
             break;
         case QPainterPath::CurveToElement:
             nextPoint =  QPointF(path.elementAt(i + 2).x, path.elementAt(i + 2).y);
             paintBezierCurve(KisPaintInformation(lastPoint),
                              QPointF(path.elementAt(i).x, path.elementAt(i).y),
                              QPointF(path.elementAt(i + 1).x, path.elementAt(i + 1).y),
                              KisPaintInformation(nextPoint), &saveDist);
             lastPoint = nextPoint;
             break;
         default:
             continue;
         }
     }
 }
 
 void KisPainter::fillPainterPath(const QPainterPath& path)
 {
     fillPainterPath(path, QRect());
 }
 
 void KisPainter::fillPainterPath(const QPainterPath& path, const QRect &requestedRect)
 {
     if (d->mirrorHorizontally || d->mirrorVertically) {
         KisLodTransform lod(d->device);
         QPointF effectiveAxesCenter = lod.map(d->axesCenter);
 
         QTransform C1 = QTransform::fromTranslate(-effectiveAxesCenter.x(), -effectiveAxesCenter.y());
         QTransform C2 = QTransform::fromTranslate(effectiveAxesCenter.x(), effectiveAxesCenter.y());
 
         QTransform t;
         QPainterPath newPath;
         QRect newRect;
 
         if (d->mirrorHorizontally) {
             t = C1 * QTransform::fromScale(-1,1) * C2;
             newPath = t.map(path);
             newRect = t.mapRect(requestedRect);
             d->fillPainterPathImpl(newPath, newRect);
         }
 
         if (d->mirrorVertically) {
             t = C1 * QTransform::fromScale(1,-1) * C2;
             newPath = t.map(path);
             newRect = t.mapRect(requestedRect);
             d->fillPainterPathImpl(newPath, newRect);
         }
 
         if (d->mirrorHorizontally && d->mirrorVertically) {
             t = C1 * QTransform::fromScale(-1,-1) * C2;
             newPath = t.map(path);
             newRect = t.mapRect(requestedRect);
             d->fillPainterPathImpl(newPath, newRect);
         }
     }
 
     d->fillPainterPathImpl(path, requestedRect);
 }
 
 void KisPainter::Private::fillPainterPathImpl(const QPainterPath& path, const QRect &requestedRect)
 {
     if (fillStyle == FillStyleNone) {
         return;
     }
 
     // Fill the polygon bounding rectangle with the required contents then we'll
     // create a mask for the actual polygon coverage.
 
     if (!fillPainter) {
         polygon = device->createCompositionSourceDevice();
         fillPainter = new KisFillPainter(polygon);
     } else {
         polygon->clear();
     }
 
     Q_CHECK_PTR(polygon);
 
     QRectF boundingRect = path.boundingRect();
     QRect fillRect = boundingRect.toAlignedRect();
 
     // Expand the rectangle to allow for anti-aliasing.
     fillRect.adjust(-1, -1, 1, 1);
 
     if (requestedRect.isValid()) {
         fillRect &= requestedRect;
     }
 
     switch (fillStyle) {
     default:
         /* Falls through. */
     case FillStyleGradient:
         // Currently unsupported
         /* Falls through. */
     case FillStyleStrokes:
         // Currently unsupported
         warnImage << "Unknown or unsupported fill style in fillPolygon\n";
         /* Falls through. */
     case FillStyleForegroundColor:
         fillPainter->fillRect(fillRect, q->paintColor(), OPACITY_OPAQUE_U8);
         break;
     case FillStyleBackgroundColor:
         fillPainter->fillRect(fillRect, q->backgroundColor(), OPACITY_OPAQUE_U8);
         break;
     case FillStylePattern:
         if (pattern) { // if the user hasn't got any patterns installed, we shouldn't crash...
             fillPainter->fillRect(fillRect, pattern);
         }
         break;
     case FillStyleGenerator:
         if (generator) { // if the user hasn't got any generators, we shouldn't crash...
             fillPainter->fillRect(fillRect.x(), fillRect.y(), fillRect.width(), fillRect.height(), q->generator());
         }
         break;
     }
 
     if (polygonMaskImage.isNull() || (maskPainter == 0)) {
         polygonMaskImage = QImage(maskImageWidth, maskImageHeight, QImage::Format_ARGB32_Premultiplied);
         maskPainter = new QPainter(&polygonMaskImage);
         maskPainter->setRenderHint(QPainter::Antialiasing, q->antiAliasPolygonFill());
     }
 
     // Break the mask up into chunks so we don't have to allocate a potentially very large QImage.
     const QColor black(Qt::black);
     const QBrush brush(Qt::white);
     for (qint32 x = fillRect.x(); x < fillRect.x() + fillRect.width(); x += maskImageWidth) {
         for (qint32 y = fillRect.y(); y < fillRect.y() + fillRect.height(); y += maskImageHeight) {
 
             polygonMaskImage.fill(black.rgb());
             maskPainter->translate(-x, -y);
             maskPainter->fillPath(path, brush);
             maskPainter->translate(x, y);
 
             qint32 rectWidth = qMin(fillRect.x() + fillRect.width() - x, maskImageWidth);
             qint32 rectHeight = qMin(fillRect.y() + fillRect.height() - y, maskImageHeight);
 
             KisHLineIteratorSP lineIt = polygon->createHLineIteratorNG(x, y, rectWidth);
 
             quint8 tmp;
             for (int row = y; row < y + rectHeight; row++) {
                 QRgb* line = reinterpret_cast<QRgb*>(polygonMaskImage.scanLine(row - y));
                 do {
                     tmp = qRed(line[lineIt->x() - x]);
                     polygon->colorSpace()->applyAlphaU8Mask(lineIt->rawData(), &tmp, 1);
                 } while (lineIt->nextPixel());
                 lineIt->nextRow();
             }
 
         }
     }
 
     QRect bltRect = !requestedRect.isEmpty() ? requestedRect : fillRect;
     q->bitBlt(bltRect.x(), bltRect.y(), polygon, bltRect.x(), bltRect.y(), bltRect.width(), bltRect.height());
 }
 
 void KisPainter::drawPainterPath(const QPainterPath& path, const QPen& pen)
 {
     drawPainterPath(path, pen, QRect());
 }
 
 void KisPainter::drawPainterPath(const QPainterPath& path, const QPen& pen, const QRect &requestedRect)
 {
     // we are drawing mask, it has to be white
     // color of the path is given by paintColor()
     Q_ASSERT(pen.color() == Qt::white);
 
     if (!d->fillPainter) {
         d->polygon = d->device->createCompositionSourceDevice();
         d->fillPainter = new KisFillPainter(d->polygon);
     } else {
         d->polygon->clear();
     }
 
     Q_CHECK_PTR(d->polygon);
 
     QRectF boundingRect = path.boundingRect();
     QRect fillRect = boundingRect.toAlignedRect();
 
     // take width of the pen into account
     int penWidth = qRound(pen.widthF());
     fillRect.adjust(-penWidth, -penWidth, penWidth, penWidth);
 
     // Expand the rectangle to allow for anti-aliasing.
     fillRect.adjust(-1, -1, 1, 1);
 
     if (!requestedRect.isNull()) {
         fillRect &= requestedRect;
     }
 
     d->fillPainter->fillRect(fillRect, paintColor(), OPACITY_OPAQUE_U8);
 
     if (d->polygonMaskImage.isNull() || (d->maskPainter == 0)) {
         d->polygonMaskImage = QImage(d->maskImageWidth, d->maskImageHeight, QImage::Format_ARGB32_Premultiplied);
         d->maskPainter = new QPainter(&d->polygonMaskImage);
         d->maskPainter->setRenderHint(QPainter::Antialiasing, antiAliasPolygonFill());
     }
 
     // Break the mask up into chunks so we don't have to allocate a potentially very large QImage.
     const QColor black(Qt::black);
     QPen oldPen = d->maskPainter->pen();
     d->maskPainter->setPen(pen);
 
     for (qint32 x = fillRect.x(); x < fillRect.x() + fillRect.width(); x += d->maskImageWidth) {
         for (qint32 y = fillRect.y(); y < fillRect.y() + fillRect.height(); y += d->maskImageHeight) {
 
             d->polygonMaskImage.fill(black.rgb());
             d->maskPainter->translate(-x, -y);
             d->maskPainter->drawPath(path);
             d->maskPainter->translate(x, y);
 
             qint32 rectWidth = qMin(fillRect.x() + fillRect.width() - x, d->maskImageWidth);
             qint32 rectHeight = qMin(fillRect.y() + fillRect.height() - y, d->maskImageHeight);
 
             KisHLineIteratorSP lineIt = d->polygon->createHLineIteratorNG(x, y, rectWidth);
 
             quint8 tmp;
             for (int row = y; row < y + rectHeight; row++) {
                 QRgb* line = reinterpret_cast<QRgb*>(d->polygonMaskImage.scanLine(row - y));
                 do {
                     tmp = qRed(line[lineIt->x() - x]);
                     d->polygon->colorSpace()->applyAlphaU8Mask(lineIt->rawData(), &tmp, 1);
                 } while (lineIt->nextPixel());
                 lineIt->nextRow();
             }
 
         }
     }
 
     d->maskPainter->setPen(oldPen);
     QRect r = d->polygon->extent();
 
     bitBlt(r.x(), r.y(), d->polygon, r.x(), r.y(), r.width(), r.height());
 }
 
 inline void KisPainter::compositeOnePixel(quint8 *dst, const KoColor &color)
 {
     d->paramInfo.dstRowStart = dst;
     d->paramInfo.dstRowStride = 0;
     d->paramInfo.srcRowStart = color.data();
     d->paramInfo.srcRowStride = 0;
     d->paramInfo.maskRowStart = 0;
     d->paramInfo.maskRowStride = 0;
     d->paramInfo.rows = 1;
     d->paramInfo.cols = 1;
 
     d->colorSpace->bitBlt(color.colorSpace(), d->paramInfo, d->compositeOp,
                           d->renderingIntent,
                           d->conversionFlags);
 }
 
 /**/
 void KisPainter::drawLine(const QPointF& start, const QPointF& end, qreal width, bool antialias){
     int x1 = qFloor(start.x());
     int y1 = qFloor(start.y());
     int x2 = qFloor(end.x());
     int y2 = qFloor(end.y());
 
     if ((x2 == x1 ) && (y2 == y1)) return;
 
     int dstX = x2-x1;
     int dstY = y2-y1;
 
     qreal uniC = dstX*y1 - dstY*x1;
     qreal projectionDenominator = 1.0 / (pow((double)dstX, 2) + pow((double)dstY, 2));
 
     qreal subPixel;
     if (qAbs(dstX) > qAbs(dstY)){
         subPixel = start.x() - x1;
     }else{
         subPixel = start.y() - y1;
     }
 
     qreal halfWidth = width * 0.5 + subPixel;
     int W_ = qRound(halfWidth) + 1;
 
     // save the state
     int X1_ = x1;
     int Y1_ = y1;
     int X2_ = x2;
     int Y2_ = y2;
 
     if (x2<x1) std::swap(x1,x2);
     if (y2<y1) std::swap(y1,y2);
 
     qreal denominator = sqrt(pow((double)dstY,2) + pow((double)dstX,2));
     if (denominator == 0.0) {
         denominator = 1.0;
     }
     denominator = 1.0/denominator;
 
     qreal projection,scanX,scanY,AA_;
     KisRandomAccessorSP accessor = d->device->createRandomAccessorNG(x1, y1);
     KisRandomConstAccessorSP selectionAccessor;
     if (d->selection) {
         selectionAccessor = d->selection->projection()->createRandomConstAccessorNG(x1, y1);
     }
 
     for (int y = y1-W_; y < y2+W_ ; y++){
         for (int x = x1-W_; x < x2+W_; x++){
 
             projection = ( (x-X1_)* dstX + (y-Y1_)*dstY ) * projectionDenominator;
             scanX = X1_ + projection * dstX;
             scanY = Y1_ + projection * dstY;
 
             if (((scanX < x1) || (scanX > x2)) || ((scanY < y1) || (scanY > y2))) {
                 AA_ = qMin( sqrt( pow((double)x - X1_, 2) + pow((double)y - Y1_, 2) ),
                             sqrt( pow((double)x - X2_, 2) + pow((double)y - Y2_, 2) ));
             }else{
                 AA_ = qAbs(dstY*x - dstX*y + uniC) * denominator;
             }
 
             if (AA_>halfWidth) {
                 continue;
             }
 
             accessor->moveTo(x, y);
             if (selectionAccessor) selectionAccessor->moveTo(x,y);
 
             if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                 KoColor mycolor = d->paintColor;
 
                 if (antialias && AA_ > halfWidth-1.0) {
                     mycolor.colorSpace()->multiplyAlpha(mycolor.data(), 1.0 - (AA_-(halfWidth-1.0)), 1);
                 }
 
                 compositeOnePixel(accessor->rawData(), mycolor);
             }
         }
     }
 }
 
 /**/
 
 void KisPainter::drawLine(const QPointF & start, const QPointF & end)
 {
     drawThickLine(start, end, 1, 1);
 }
 
 
 void KisPainter::drawDDALine(const QPointF & start, const QPointF & end)
 {
     int x = qFloor(start.x());
     int y = qFloor(start.y());
 
     int x2 = qFloor(end.x());
     int y2 = qFloor(end.y());
 
     // Width and height of the line
     int xd = x2 - x;
     int yd = y2 - y;
 
     float m = (float)yd / (float)xd;
 
     float fx = x;
     float fy = y;
     int inc;
 
     KisRandomAccessorSP accessor = d->device->createRandomAccessorNG(x, y);
     KisRandomConstAccessorSP selectionAccessor;
     if (d->selection) {
         selectionAccessor = d->selection->projection()->createRandomConstAccessorNG(x, y);
     }
 
 
     accessor->moveTo(x, y);
     if (selectionAccessor) selectionAccessor->moveTo(x,y);
 
     if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
         compositeOnePixel(accessor->rawData(), d->paintColor);
     }
 
     if (fabs(m) > 1.0f) {
         inc = (yd > 0) ? 1 : -1;
         m = 1.0f / m;
         m *= inc;
         while (y != y2) {
             y = y + inc;
             fx = fx + m;
             x = qRound(fx);
 
             accessor->moveTo(x, y);
             if (selectionAccessor) selectionAccessor->moveTo(x, y);
 
             if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                 compositeOnePixel(accessor->rawData(), d->paintColor);
             }
         }
     } else {
         inc = (xd > 0) ? 1 : -1;
         m *= inc;
         while (x != x2) {
             x = x + inc;
             fy = fy + m;
             y = qRound(fy);
 
             accessor->moveTo(x, y);
             if (selectionAccessor) selectionAccessor->moveTo(x, y);
 
             if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                 compositeOnePixel(accessor->rawData(), d->paintColor);
             }
         }
     }
 }
 
 void KisPainter::drawWobblyLine(const QPointF & start, const QPointF & end)
 {
     KoColor mycolor(d->paintColor);
 
     int x1 = qFloor(start.x());
     int y1 = qFloor(start.y());
     int x2 = qFloor(end.x());
     int y2 = qFloor(end.y());
 
     KisRandomAccessorSP accessor = d->device->createRandomAccessorNG(x1, y1);
     KisRandomConstAccessorSP selectionAccessor;
     if (d->selection) {
         selectionAccessor = d->selection->projection()->createRandomConstAccessorNG(x1, y1);
     }
 
     // Width and height of the line
     int xd = (x2 - x1);
     int yd = (y2 - y1);
 
     int x;
     int y;
     float fx = (x = x1);
     float fy = (y = y1);
     float m = (float)yd / (float)xd;
     int inc;
 
     if (fabs(m) > 1) {
         inc = (yd > 0) ? 1 : -1;
         m = 1.0f / m;
         m *= inc;
         while (y != y2) {
             fx = fx + m;
             y = y + inc;
             x = qRound(fx);
 
             float br1 = qFloor(fx + 1) - fx;
             float br2 = fx - qFloor(fx);
 
             accessor->moveTo(x, y);
             if (selectionAccessor) selectionAccessor->moveTo(x, y);
 
             if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                 mycolor.setOpacity((quint8)(255*br1));
                 compositeOnePixel(accessor->rawData(), mycolor);
             }
 
             accessor->moveTo(x + 1, y);
             if (selectionAccessor) selectionAccessor->moveTo(x + 1, y);
 
             if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                 mycolor.setOpacity((quint8)(255*br2));
                 compositeOnePixel(accessor->rawData(), mycolor);
             }
         }
     } else {
         inc = (xd > 0) ? 1 : -1;
         m *= inc;
         while (x != x2) {
             fy = fy + m;
             x = x + inc;
             y = qRound(fy);
 
             float br1 = qFloor(fy + 1) - fy;
             float br2 = fy - qFloor(fy);
 
             accessor->moveTo(x, y);
             if (selectionAccessor) selectionAccessor->moveTo(x, y);
 
             if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                 mycolor.setOpacity((quint8)(255*br1));
                 compositeOnePixel(accessor->rawData(), mycolor);
             }
 
             accessor->moveTo(x, y + 1);
             if (selectionAccessor) selectionAccessor->moveTo(x, y + 1);
 
             if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                 mycolor.setOpacity((quint8)(255*br2));
                 compositeOnePixel(accessor->rawData(), mycolor);
             }
         }
     }
 
 }
 
 void KisPainter::drawWuLine(const QPointF & start, const QPointF & end)
 {
     KoColor lineColor(d->paintColor);
 
     int x1 = qFloor(start.x());
     int y1 = qFloor(start.y());
     int x2 = qFloor(end.x());
     int y2 = qFloor(end.y());
 
     KisRandomAccessorSP accessor = d->device->createRandomAccessorNG(x1, y1);
     KisRandomConstAccessorSP selectionAccessor;
     if (d->selection) {
         selectionAccessor = d->selection->projection()->createRandomConstAccessorNG(x1, y1);
     }
 
     float grad, xd, yd;
     float xgap, ygap, xend, yend, yf, xf;
     float brightness1, brightness2;
 
     int ix1, ix2, iy1, iy2;
     quint8 c1, c2;
 
     // gradient of line
     xd = (x2 - x1);
     yd = (y2 - y1);
 
     if (yd == 0) {
         /* Horizontal line */
         int incr = (x1 < x2) ? 1 : -1;
         ix1 = x1;
         ix2 = x2;
         iy1 = y1;
         while (ix1 != ix2) {
             ix1 = ix1 + incr;
 
             accessor->moveTo(ix1, iy1);
             if (selectionAccessor) selectionAccessor->moveTo(ix1, iy1);
 
             if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                 compositeOnePixel(accessor->rawData(), lineColor);
             }
         }
         return;
     }
 
     if (xd == 0) {
         /* Vertical line */
         int incr = (y1 < y2) ? 1 : -1;
         iy1 = y1;
         iy2 = y2;
         ix1 = x1;
         while (iy1 != iy2) {
             iy1 = iy1 + incr;
 
             accessor->moveTo(ix1, iy1);
             if (selectionAccessor) selectionAccessor->moveTo(ix1, iy1);
 
             if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                 compositeOnePixel(accessor->rawData(), lineColor);
             }
         }
         return;
     }
 
     if (fabs(xd) > fabs(yd)) {
         // horizontal line
         // line have to be paint from left to right
         if (x1 > x2) {
             std::swap(x1, x2);
             std::swap(y1, y2);
             xd = (x2 - x1);
             yd = (y2 - y1);
         }
         grad = yd / xd;
         // nearest X,Y integer coordinates
         xend = x1;
         yend = y1 + grad * (xend - x1);
 
         xgap = invertFrac(x1 + 0.5f);
 
         ix1 = x1;
         iy1 = qFloor(yend);
 
         // calc the intensity of the other end point pixel pair.
         brightness1 = invertFrac(yend) * xgap;
         brightness2 =       frac(yend) * xgap;
 
         c1 = (int)(brightness1 * OPACITY_OPAQUE_U8);
         c2 = (int)(brightness2 * OPACITY_OPAQUE_U8);
 
         accessor->moveTo(ix1, iy1);
         if (selectionAccessor) selectionAccessor->moveTo(ix1, iy1);
 
         if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
             lineColor.setOpacity(c1);
             compositeOnePixel(accessor->rawData(), lineColor);
         }
 
         accessor->moveTo(ix1, iy1 + 1);
         if (selectionAccessor) selectionAccessor->moveTo(ix1, iy1 + 1);
 
         if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
             lineColor.setOpacity(c2);
             compositeOnePixel(accessor->rawData(), lineColor);
         }
 
         // calc first Y-intersection for main loop
         yf = yend + grad;
 
         xend = x2;
         yend = y2 + grad * (xend - x2);
 
         xgap = invertFrac(x2 - 0.5f);
 
         ix2 = x2;
         iy2 = qFloor(yend);
 
         brightness1 = invertFrac(yend) * xgap;
         brightness2 =    frac(yend) * xgap;
 
         c1 = (int)(brightness1 * OPACITY_OPAQUE_U8);
         c2 = (int)(brightness2 * OPACITY_OPAQUE_U8);
 
         accessor->moveTo(ix2, iy2);
         if (selectionAccessor) selectionAccessor->moveTo(ix2, iy2);
 
         if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
             lineColor.setOpacity(c1);
             compositeOnePixel(accessor->rawData(), lineColor);
         }
 
         accessor->moveTo(ix2, iy2 + 1);
         if (selectionAccessor) selectionAccessor->moveTo(ix2, iy2 + 1);
 
         if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
             lineColor.setOpacity(c2);
             compositeOnePixel(accessor->rawData(), lineColor);
         }
 
         // main loop
         for (int x = ix1 + 1; x <= ix2 - 1; x++) {
             brightness1 = invertFrac(yf);
             brightness2 =    frac(yf);
             c1 = (int)(brightness1 * OPACITY_OPAQUE_U8);
             c2 = (int)(brightness2 * OPACITY_OPAQUE_U8);
 
             accessor->moveTo(x, qFloor(yf));
             if (selectionAccessor) selectionAccessor->moveTo(x, qFloor(yf));
 
             if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                 lineColor.setOpacity(c1);
                 compositeOnePixel(accessor->rawData(), lineColor);
             }
 
             accessor->moveTo(x, qFloor(yf) + 1);
             if (selectionAccessor) selectionAccessor->moveTo(x, qFloor(yf) + 1);
 
             if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                 lineColor.setOpacity(c2);
                 compositeOnePixel(accessor->rawData(), lineColor);
             }
 
             yf = yf + grad;
         }
     } else {
         //vertical
         // line have to be painted from left to right
         if (y1 > y2) {
             std::swap(x1, x2);
             std::swap(y1, y2);
             xd = (x2 - x1);
             yd = (y2 - y1);
         }
 
         grad = xd / yd;
 
         // nearest X,Y integer coordinates
         yend = y1;
         xend = x1 + grad * (yend - y1);
 
         ygap = y1;
 
         ix1 = qFloor(xend);
         iy1 = y1;
 
         // calc the intensity of the other end point pixel pair.
         brightness1 = invertFrac(xend) * ygap;
         brightness2 =       frac(xend) * ygap;
 
         c1 = (int)(brightness1 * OPACITY_OPAQUE_U8);
         c2 = (int)(brightness2 * OPACITY_OPAQUE_U8);
 
         accessor->moveTo(ix1, iy1);
         if (selectionAccessor) selectionAccessor->moveTo(ix1, iy1);
 
         if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
             lineColor.setOpacity(c1);
             compositeOnePixel(accessor->rawData(), lineColor);
         }
 
         accessor->moveTo(x1 + 1, y1);
         if (selectionAccessor) selectionAccessor->moveTo(x1 + 1, y1);
 
         if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
             lineColor.setOpacity(c2);
             compositeOnePixel(accessor->rawData(), lineColor);
         }
 
         // calc first Y-intersection for main loop
         xf = xend + grad;
 
         yend = y2;
         xend = x2 + grad * (yend - y2);
 
         ygap = invertFrac(y2 - 0.5f);
 
         ix2 = qFloor(xend);
         iy2 = y2;
 
         brightness1 = invertFrac(xend) * ygap;
         brightness2 =    frac(xend) * ygap;
 
         c1 = (int)(brightness1 * OPACITY_OPAQUE_U8);
         c2 = (int)(brightness2 * OPACITY_OPAQUE_U8);
 
         accessor->moveTo(ix2, iy2);
         if (selectionAccessor) selectionAccessor->moveTo(ix2, iy2);
 
         if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
             lineColor.setOpacity(c1);
             compositeOnePixel(accessor->rawData(), lineColor);
         }
 
         accessor->moveTo(ix2 + 1, iy2);
         if (selectionAccessor) selectionAccessor->moveTo(ix2 + 1, iy2);
 
         if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
             lineColor.setOpacity(c2);
             compositeOnePixel(accessor->rawData(), lineColor);
         }
 
         // main loop
         for (int y = iy1 + 1; y <= iy2 - 1; y++) {
             brightness1 = invertFrac(xf);
             brightness2 =    frac(xf);
             c1 = (int)(brightness1 * OPACITY_OPAQUE_U8);
             c2 = (int)(brightness2 * OPACITY_OPAQUE_U8);
 
             accessor->moveTo(qFloor(xf), y);
             if (selectionAccessor) selectionAccessor->moveTo(qFloor(xf), y);
 
             if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                 lineColor.setOpacity(c1);
                 compositeOnePixel(accessor->rawData(), lineColor);
             }
 
             accessor->moveTo(qFloor(xf) + 1, y);
             if (selectionAccessor) selectionAccessor->moveTo(qFloor(xf) + 1, y);
 
             if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                 lineColor.setOpacity(c2);
                 compositeOnePixel(accessor->rawData(), lineColor);
             }
 
             xf = xf + grad;
         }
     }//end-of-else
 
 }
 
 void KisPainter::drawThickLine(const QPointF & start, const QPointF & end, int startWidth, int endWidth)
 {
 
     KisRandomAccessorSP accessor = d->device->createRandomAccessorNG(start.x(), start.y());
     KisRandomConstAccessorSP selectionAccessor;
     if (d->selection) {
         selectionAccessor = d->selection->projection()->createRandomConstAccessorNG(start.x(), start.y());
     }
 
     const KoColorSpace *cs = d->device->colorSpace();
 
     KoColor c1(d->paintColor);
     KoColor c2(d->paintColor);
     KoColor c3(d->paintColor);
     KoColor col1(c1);
     KoColor col2(c1);
 
     float grada, gradb, dxa, dxb, dya, dyb, fraca, fracb,
     xfa, yfa, xfb, yfb, b1a, b2a, b1b, b2b, dstX, dstY;
     int x, y, ix1, ix2, iy1, iy2;
 
     int x0a, y0a, x1a, y1a, x0b, y0b, x1b, y1b;
     int tp0, tn0, tp1, tn1;
 
     int horizontal = 0;
     float opacity = 1.0;
 
     tp0 = startWidth / 2;
     tn0 = startWidth / 2;
     if (startWidth % 2 == 0) // even width startWidth
         tn0--;
 
     tp1 = endWidth / 2;
     tn1 = endWidth / 2;
     if (endWidth % 2 == 0) // even width endWidth
         tn1--;
 
     int x0 = qRound(start.x());
     int y0 = qRound(start.y());
     int x1 = qRound(end.x());
     int y1 = qRound(end.y());
 
     dstX = x1 - x0; // run of general line
     dstY = y1 - y0; // rise of general line
 
     if (dstY < 0) dstY = -dstY;
     if (dstX < 0) dstX = -dstX;
 
     if (dstX > dstY) { // horizontalish
         horizontal = 1;
         x0a = x0;   y0a = y0 - tn0;
         x0b = x0;   y0b = y0 + tp0;
         x1a = x1;   y1a = y1 - tn1;
         x1b = x1;   y1b = y1 + tp1;
     } else {
         x0a = x0 - tn0;   y0a = y0;
         x0b = x0 + tp0;   y0b = y0;
         x1a = x1 - tn1;   y1a = y1;
         x1b = x1 + tp1;   y1b = y1;
     }
 
     if (horizontal) { // draw endpoints
         for (int i = y0a; i <= y0b; i++) {
 
             accessor->moveTo(x0, i);
             if (selectionAccessor) selectionAccessor->moveTo(x0, i);
 
             if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                 compositeOnePixel(accessor->rawData(), c1);
             }
         }
         for (int i = y1a; i <= y1b; i++) {
 
             accessor->moveTo(x1, i);
             if (selectionAccessor) selectionAccessor->moveTo(x1, i);
 
             if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                 compositeOnePixel(accessor->rawData(), c1);
             }
         }
 
     } else {
         for (int i = x0a; i <= x0b; i++) {
 
             accessor->moveTo(i, y0);
             if (selectionAccessor) selectionAccessor->moveTo(i, y0);
 
             if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                 compositeOnePixel(accessor->rawData(), c1);
             }
         }
         for (int i = x1a; i <= x1b; i++) {
             accessor->moveTo(i, y1);
             if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                 compositeOnePixel(accessor->rawData(), c1);
             }
         }
     }
 
     //antialias endpoints
     if (x1 != x0 && y1 != y0) {
         if (horizontal) {
 
             accessor->moveTo(x0a, y0a - 1);
             if (selectionAccessor) selectionAccessor->moveTo(x0a, y0a - 1);
 
             if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                 qreal alpha = cs->opacityF(accessor->rawData());
                 opacity = .25 * c1.opacityF() + (1 - .25) * alpha;
                 col1.setOpacity(opacity);
                 compositeOnePixel(accessor->rawData(), col1);
             }
 
             accessor->moveTo(x1b, y1b + 1);
             if (selectionAccessor) selectionAccessor->moveTo(x1b, y1b + 1);
 
             if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                 qreal alpha = cs->opacityF(accessor->rawData());
                 opacity = .25 * c2.opacityF() + (1 - .25) * alpha;
                 col1.setOpacity(opacity);
                 compositeOnePixel(accessor->rawData(), col1);
             }
 
         } else {
 
             accessor->moveTo(x0a - 1, y0a);
             if (selectionAccessor) selectionAccessor->moveTo(x0a - 1, y0a);
 
             if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                 qreal alpha = cs->opacityF(accessor->rawData());
                 opacity = .25 * c1.opacityF() + (1 - .25) * alpha;
                 col1.setOpacity(opacity);
                 compositeOnePixel(accessor->rawData(), col1);
             }
 
             accessor->moveTo(x1b + 1, y1b);
             if (selectionAccessor) selectionAccessor->moveTo(x1b + 1, y1b);
 
             if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                 qreal alpha = cs->opacityF(accessor->rawData());
                 opacity = .25 * c2.opacityF() + (1 - .25) * alpha;
                 col1.setOpacity(opacity);
                 compositeOnePixel(accessor->rawData(), col1);
             }
         }
     }
 
     dxa = x1a - x0a; // run of a
     dya = y1a - y0a; // rise of a
     dxb = x1b - x0b; // run of b
     dyb = y1b - y0b; // rise of b
 
     if (horizontal) { // horizontal-ish lines
         if (x1 < x0) {
             int xt, yt, wt;
             KoColor tmp;
             xt = x1a;     x1a = x0a;    x0a = xt;
             yt = y1a;     y1a = y0a;    y0a = yt;
             xt = x1b;     x1b = x0b;    x0b = xt;
             yt = y1b;     y1b = y0b;    y0b = yt;
             xt = x1;      x1 = x0;      x0 = xt;
             yt = y1;      y1 = y0;      y0 = yt;
 
             tmp = c1; c1 = c2; c2 = tmp;
             wt = startWidth;      startWidth = endWidth;      endWidth = wt;
         }
 
         grada = dya / dxa;
         gradb = dyb / dxb;
 
         ix1 = x0;   iy1 = y0;
         ix2 = x1;   iy2 = y1;
 
         yfa = y0a + grada;
         yfb = y0b + gradb;
 
         for (x = ix1 + 1; x <= ix2 - 1; x++) {
             fraca = yfa - qFloor(yfa);
             b1a = 1 - fraca;
             b2a = fraca;
 
             fracb = yfb - qFloor(yfb);
             b1b = 1 - fracb;
             b2b = fracb;
 
             // color first pixel of bottom line
             opacity = ((x - ix1) / dstX) * c2.opacityF() + (1 - (x - ix1) / dstX) * c1.opacityF();
             c3.setOpacity(opacity);
 
             accessor->moveTo(x, qFloor(yfa));
             if (selectionAccessor) selectionAccessor->moveTo(x, qFloor(yfa));
 
             if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                 qreal alpha = cs->opacityF(accessor->rawData());
                 opacity = b1a * c3.opacityF() + (1 - b1a) * alpha;
                 col1.setOpacity(opacity);
                 compositeOnePixel(accessor->rawData(), col1);
             }
 
             // color first pixel of top line
             if (!(startWidth == 1 && endWidth == 1)) {
                 accessor->moveTo(x, qFloor(yfb));
                 if (selectionAccessor) selectionAccessor->moveTo(x, qFloor(yfb));
 
                 if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                     qreal alpha = cs->opacityF(accessor->rawData());
                     opacity = b1b * c3.opacityF() + (1 - b1b) * alpha;
                     col1.setOpacity(opacity);
                     compositeOnePixel(accessor->rawData(), col1);
                 }
             }
 
             // color second pixel of bottom line
             if (grada != 0 && grada != 1) { // if not flat or exact diagonal
 
                 accessor->moveTo(x, qFloor(yfa) + 1);
                 if (selectionAccessor) selectionAccessor->moveTo(x, qFloor(yfa) + 1);
 
                 if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                     qreal alpha = cs->opacityF(accessor->rawData());
                     opacity = b2a * c3.opacityF() + (1 - b2a)  * alpha;
                     col2.setOpacity(opacity);
                     compositeOnePixel(accessor->rawData(), col2);
                 }
 
             }
 
             // color second pixel of top line
             if (gradb != 0 && gradb != 1 && !(startWidth == 1 && endWidth == 1)) {
 
                 accessor->moveTo(x, qFloor(yfb) + 1);
                 if (selectionAccessor) selectionAccessor->moveTo(x, qFloor(yfb) + 1);
 
                 if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                     qreal alpha = cs->opacityF(accessor->rawData());
                     opacity = b2b * c3.opacityF() + (1 - b2b) * alpha;
                     col2.setOpacity(opacity);
                     compositeOnePixel(accessor->rawData(), col2);
                 }
 
             }
 
             // fill remaining pixels
             if (!(startWidth == 1 && endWidth == 1)) {
                 if (yfa < yfb)
                     for (int i = qFloor(yfa) + 1; i <= qFloor(yfb); i++) {
 
                         accessor->moveTo(x, i);
                         if (selectionAccessor) selectionAccessor->moveTo(x, i);
 
                         if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                             compositeOnePixel(accessor->rawData(), c3);
                         }
                     }
                 else
                     for (int i = qFloor(yfa) + 1; i >= qFloor(yfb); i--) {
 
                         accessor->moveTo(x, i);
                         if (selectionAccessor) selectionAccessor->moveTo(x, i);
 
                         if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                             compositeOnePixel(accessor->rawData(), c3);
                         }
                     }
 
             }
 
             yfa += grada;
             yfb += gradb;
         }
     } else { // vertical-ish lines
         if (y1 < y0) {
             int xt, yt, wt;
             xt = x1a;     x1a = x0a;    x0a = xt;
             yt = y1a;     y1a = y0a;    y0a = yt;
             xt = x1b;     x1b = x0b;    x0b = xt;
             yt = y1b;     y1b = y0b;    y0b = yt;
             xt = x1;      x1 = x0;      x0 = xt;
             yt = y1;      y1 = y0;      y0 = yt;
 
             KoColor tmp;
             tmp = c1; c1 = c2; c2 = tmp;
             wt = startWidth;      startWidth = endWidth;      endWidth = wt;
         }
 
         grada = dxa / dya;
         gradb = dxb / dyb;
 
         ix1 = x0;   iy1 = y0;
         ix2 = x1;   iy2 = y1;
 
         xfa = x0a + grada;
         xfb = x0b + gradb;
 
         for (y = iy1 + 1; y <= iy2 - 1; y++) {
             fraca = xfa - qFloor(xfa);
             b1a = 1 - fraca;
             b2a = fraca;
 
             fracb = xfb - qFloor(xfb);
             b1b = 1 - fracb;
             b2b = fracb;
 
             // color first pixel of left line
             opacity = ((y - iy1) / dstY) * c2.opacityF() + (1 - (y - iy1) / dstY) * c1.opacityF();
             c3.setOpacity(opacity);
 
             accessor->moveTo(qFloor(xfa), y);
             if (selectionAccessor) selectionAccessor->moveTo(qFloor(xfa), y);
 
             if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                 qreal alpha = cs->opacityF(accessor->rawData());
                 opacity = b1a * c3.opacityF() + (1 - b1a) * alpha;
                 col1.setOpacity(opacity);
                 compositeOnePixel(accessor->rawData(), col1);
             }
 
             // color first pixel of right line
             if (!(startWidth == 1 && endWidth == 1)) {
 
                 accessor->moveTo(qFloor(xfb), y);
                 if (selectionAccessor) selectionAccessor->moveTo(qFloor(xfb), y);
 
                 if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                     qreal alpha = cs->opacityF(accessor->rawData());
                     opacity = b1b * c3.opacityF() + (1 - b1b)  * alpha;
                     col1.setOpacity(opacity);
                     compositeOnePixel(accessor->rawData(), col1);
                 }
             }
 
             // color second pixel of left line
             if (grada != 0 && grada != 1) { // if not flat or exact diagonal
 
                 accessor->moveTo(qFloor(xfa) + 1, y);
                 if (selectionAccessor) selectionAccessor->moveTo(qFloor(xfa) + 1, y);
 
                 if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                     qreal alpha = cs->opacityF(accessor->rawData());
                     opacity = b2a * c3.opacityF() + (1 - b2a) * alpha;
                     col2.setOpacity(opacity);
                     compositeOnePixel(accessor->rawData(), col2);
                 }
 
             }
 
             // color second pixel of right line
             if (gradb != 0 && gradb != 1 && !(startWidth == 1 && endWidth == 1)) {
 
                 accessor->moveTo(qFloor(xfb) + 1, y);
                 if (selectionAccessor) selectionAccessor->moveTo(qFloor(xfb) + 1, y);
 
                 if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                     qreal alpha = cs->opacityF(accessor->rawData());
                     opacity = b2b * c3.opacityF() + (1 - b2b) * alpha;
                     col2.setOpacity(opacity);
                     compositeOnePixel(accessor->rawData(), col2);
                 }
             }
 
             // fill remaining pixels between current xfa,xfb
             if (!(startWidth == 1 && endWidth == 1)) {
                 if (xfa < xfb)
                     for (int i = qFloor(xfa) + 1; i <= qFloor(xfb); i++) {
 
                         accessor->moveTo(i, y);
                         if (selectionAccessor) selectionAccessor->moveTo(i, y);
 
                         if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                             compositeOnePixel(accessor->rawData(), c3);
                         }
                     }
                 else
                     for (int i = qFloor(xfb); i <= qFloor(xfa) + 1; i++) {
 
                         accessor->moveTo(i, y);
                         if (selectionAccessor) selectionAccessor->moveTo(i, y);
 
                         if (!selectionAccessor || *selectionAccessor->oldRawData() > SELECTION_THRESHOLD) {
                             compositeOnePixel(accessor->rawData(), c3);
                         }
                     }
             }
 
             xfa += grada;
             xfb += gradb;
         }
     }
 
 }
 
 
 
 void KisPainter::setProgress(KoUpdater * progressUpdater)
 {
     d->progressUpdater = progressUpdater;
 }
 
 const KisPaintDeviceSP KisPainter::device() const
 {
     return d->device;
 }
 KisPaintDeviceSP KisPainter::device()
 {
     return d->device;
 }
 
 void KisPainter::setChannelFlags(QBitArray channelFlags)
 {
     Q_ASSERT(channelFlags.isEmpty() || quint32(channelFlags.size()) == d->colorSpace->channelCount());
     // Now, if all bits in the channelflags are true, pass an empty channel flags bitarray
     // because otherwise the compositeops cannot optimize.
     d->paramInfo.channelFlags = channelFlags;
 
     if (!channelFlags.isEmpty() && channelFlags == QBitArray(channelFlags.size(), true)) {
         d->paramInfo.channelFlags = QBitArray();
     }
 }
 
 QBitArray KisPainter::channelFlags()
 {
     return d->paramInfo.channelFlags;
 }
 
 void KisPainter::setPattern(const KoPattern * pattern)
 {
     d->pattern = pattern;
 }
 
 const KoPattern * KisPainter::pattern() const
 {
     return d->pattern;
 }
 
 void KisPainter::setPaintColor(const KoColor& color)
 {
     d->paintColor = color;
     if (d->device) {
         d->paintColor.convertTo(d->device->compositionSourceColorSpace());
     }
 }
 
 const KoColor &KisPainter::paintColor() const
 {
     return d->paintColor;
 }
 
 void KisPainter::setBackgroundColor(const KoColor& color)
 {
     d->backgroundColor = color;
     if (d->device) {
         d->backgroundColor.convertTo(d->device->compositionSourceColorSpace());
     }
 }
 
 const KoColor &KisPainter::backgroundColor() const
 {
     return d->backgroundColor;
 }
 
 void KisPainter::setGenerator(KisFilterConfigurationSP  generator)
 {
     d->generator = generator;
 }
 
 const KisFilterConfigurationSP  KisPainter::generator() const
 {
     return d->generator;
 }
 
 void KisPainter::setFillStyle(FillStyle fillStyle)
 {
     d->fillStyle = fillStyle;
 }
 
 KisPainter::FillStyle KisPainter::fillStyle() const
 {
     return d->fillStyle;
 }
 
 void KisPainter::setAntiAliasPolygonFill(bool antiAliasPolygonFill)
 {
     d->antiAliasPolygonFill = antiAliasPolygonFill;
 }
 
 bool KisPainter::antiAliasPolygonFill()
 {
     return d->antiAliasPolygonFill;
 }
 
 void KisPainter::setStrokeStyle(KisPainter::StrokeStyle strokeStyle)
 {
     d->strokeStyle = strokeStyle;
 }
 KisPainter::StrokeStyle KisPainter::strokeStyle() const
 {
     return d->strokeStyle;
 }
 
 void KisPainter::setFlow(quint8 flow)
 {
     d->paramInfo.flow = float(flow) / 255.0f;
 }
 
 quint8 KisPainter::flow() const
 {
     return quint8(d->paramInfo.flow * 255.0f);
 }
 
 void KisPainter::setOpacityUpdateAverage(quint8 opacity)
 {
     d->isOpacityUnit = opacity == OPACITY_OPAQUE_U8;
     d->paramInfo.updateOpacityAndAverage(float(opacity) / 255.0f);
 }
 
 void KisPainter::setAverageOpacity(qreal averageOpacity)
 {
     d->paramInfo.setOpacityAndAverage(d->paramInfo.opacity, averageOpacity);
 }
 
 qreal KisPainter::blendAverageOpacity(qreal opacity, qreal averageOpacity)
 {
     const float exponent = 0.1;
 
     return averageOpacity < opacity ?
         opacity :
         exponent * opacity + (1.0 - exponent) * (averageOpacity);
 }
 
 void KisPainter::setOpacity(quint8 opacity)
 {
     d->isOpacityUnit = opacity == OPACITY_OPAQUE_U8;
     d->paramInfo.opacity = float(opacity) / 255.0f;
 }
 
 quint8 KisPainter::opacity() const
 {
     return quint8(d->paramInfo.opacity * 255.0f);
 }
 
 void KisPainter::setCompositeOp(const KoCompositeOp * op)
 {
     d->compositeOp = op;
 }
 
 const KoCompositeOp * KisPainter::compositeOp()
 {
     return d->compositeOp;
 }
 
 /**
  * TODO: Rename this setCompositeOpId().  See KoCompositeOpRegistry.h
  */
 void KisPainter::setCompositeOp(const QString& op)
 {
     d->compositeOp = d->colorSpace->compositeOp(op);
 }
 
 void KisPainter::setSelection(KisSelectionSP selection)
 {
     d->selection = selection;
 }
 
 KisSelectionSP KisPainter::selection()
 {
     return d->selection;
 }
 
 KoUpdater * KisPainter::progressUpdater()
 {
     return d->progressUpdater;
 }
 
 void KisPainter::setGradient(const KoAbstractGradient* gradient)
 {
     d->gradient = gradient;
 }
 
 const KoAbstractGradient* KisPainter::gradient() const
 {
     return d->gradient;
 }
 
 void KisPainter::setPaintOpPreset(KisPaintOpPresetSP preset, KisNodeSP node, KisImageSP image)
 {
     d->paintOpPreset = preset;
     KisPaintOp *paintop = KisPaintOpRegistry::instance()->paintOp(preset, this, node, image);
     Q_ASSERT(paintop);
     if (paintop) {
         delete d->paintOp;
         d->paintOp = paintop;
     }
     else {
         warnKrita << "Could not create paintop for preset " << preset->name();
     }
 }
 
 KisPaintOpPresetSP KisPainter::preset() const
 {
     return d->paintOpPreset;
 }
 
 KisPaintOp* KisPainter::paintOp() const
 {
     return d->paintOp;
 }
 
 void KisPainter::setMirrorInformation(const QPointF& axesCenter, bool mirrorHorizontally, bool mirrorVertically)
 {
     d->axesCenter = axesCenter;
     d->mirrorHorizontally = mirrorHorizontally;
     d->mirrorVertically = mirrorVertically;
 }
 
 void KisPainter::copyMirrorInformationFrom(const KisPainter *other)
 {
     d->axesCenter = other->d->axesCenter;
     d->mirrorHorizontally = other->d->mirrorHorizontally;
     d->mirrorVertically = other->d->mirrorVertically;
 }
 
 bool KisPainter::hasMirroring() const
 {
     return d->mirrorHorizontally || d->mirrorVertically;
 }
 
 bool KisPainter::hasHorizontalMirroring() const
 {
     return d->mirrorHorizontally;
 }
 
 bool KisPainter::hasVerticalMirroring() const
 {
     return d->mirrorVertically;
 }
 
 void KisPainter::setMaskImageSize(qint32 width, qint32 height)
 {
 
     d->maskImageWidth = qBound(1, width, 256);
     d->maskImageHeight = qBound(1, height, 256);
     d->fillPainter = 0;
     d->polygonMaskImage = QImage();
 }
 
 //void KisPainter::setLockAlpha(bool protect)
 //{
 //    if(d->paramInfo.channelFlags.isEmpty()) {
 //        d->paramInfo.channelFlags = d->colorSpace->channelFlags(true, true);
 //    }
 
 //    QBitArray switcher =
 //        d->colorSpace->channelFlags(protect, !protect);
 
 //    if(protect) {
 //        d->paramInfo.channelFlags &= switcher;
 //    }
 //    else {
 //        d->paramInfo.channelFlags |= switcher;
 //    }
 
 //    Q_ASSERT(quint32(d->paramInfo.channelFlags.size()) == d->colorSpace->channelCount());
 //}
 
 //bool KisPainter::alphaLocked() const
 //{
 //    QBitArray switcher = d->colorSpace->channelFlags(false, true);
 //    return !(d->paramInfo.channelFlags & switcher).count(true);
 //}
 
 void KisPainter::setRenderingIntent(KoColorConversionTransformation::Intent intent)
 {
     d->renderingIntent = intent;
 }
 
 void KisPainter::setColorConversionFlags(KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     d->conversionFlags = conversionFlags;
 }
 
 void KisPainter::setRunnableStrokeJobsInterface(KisRunnableStrokeJobsInterface *interface)
 {
     d->runnableStrokeJobsInterface = interface;
 }
 
 KisRunnableStrokeJobsInterface *KisPainter::runnableStrokeJobsInterface() const
 {
     if (!d->runnableStrokeJobsInterface) {
         if (!d->fakeRunnableStrokeJobsInterface) {
             d->fakeRunnableStrokeJobsInterface.reset(new KisFakeRunnableStrokeJobsExecutor());
         }
         return d->fakeRunnableStrokeJobsInterface.data();
     }
 
     return d->runnableStrokeJobsInterface;
 }
 
 void KisPainter::renderMirrorMaskSafe(QRect rc, KisFixedPaintDeviceSP dab, bool preserveDab)
 {
     if (!d->mirrorHorizontally && !d->mirrorVertically) return;
 
     KisFixedPaintDeviceSP dabToProcess = dab;
     if (preserveDab) {
         dabToProcess = new KisFixedPaintDevice(*dab);
     }
     renderMirrorMask(rc, dabToProcess);
 }
 
 void KisPainter::renderMirrorMaskSafe(QRect rc, KisPaintDeviceSP dab, int sx, int sy, KisFixedPaintDeviceSP mask, bool preserveMask)
 {
     if (!d->mirrorHorizontally && !d->mirrorVertically) return;
 
     KisFixedPaintDeviceSP maskToProcess = mask;
     if (preserveMask) {
         maskToProcess = new KisFixedPaintDevice(*mask);
     }
     renderMirrorMask(rc, dab, sx, sy, maskToProcess);
 }
 
 void KisPainter::renderMirrorMask(QRect rc, KisFixedPaintDeviceSP dab)
 {
     int x = rc.topLeft().x();
     int y = rc.topLeft().y();
 
     KisLodTransform t(d->device);
     QPoint effectiveAxesCenter = t.map(d->axesCenter).toPoint();
 
     int mirrorX = -((x+rc.width()) - effectiveAxesCenter.x()) + effectiveAxesCenter.x();
     int mirrorY = -((y+rc.height()) - effectiveAxesCenter.y()) + effectiveAxesCenter.y();
 
     if (d->mirrorHorizontally && d->mirrorVertically){
         dab->mirror(true, false);
         bltFixed(mirrorX, y, dab, 0,0,rc.width(),rc.height());
         dab->mirror(false,true);
         bltFixed(mirrorX, mirrorY, dab, 0,0,rc.width(),rc.height());
         dab->mirror(true, false);
         bltFixed(x, mirrorY, dab, 0,0,rc.width(),rc.height());
 
     }
     else if (d->mirrorHorizontally){
         dab->mirror(true, false);
         bltFixed(mirrorX, y, dab, 0,0,rc.width(),rc.height());
     }
     else if (d->mirrorVertically){
         dab->mirror(false, true);
         bltFixed(x, mirrorY, dab, 0,0,rc.width(),rc.height());
     }
 
 }
 
 void KisPainter::renderMirrorMask(QRect rc, KisFixedPaintDeviceSP dab, KisFixedPaintDeviceSP mask)
 {
     int x = rc.topLeft().x();
     int y = rc.topLeft().y();
 
     KisLodTransform t(d->device);
     QPoint effectiveAxesCenter = t.map(d->axesCenter).toPoint();
 
     int mirrorX = -((x+rc.width()) - effectiveAxesCenter.x()) + effectiveAxesCenter.x();
     int mirrorY = -((y+rc.height()) - effectiveAxesCenter.y()) + effectiveAxesCenter.y();
 
     if (d->mirrorHorizontally && d->mirrorVertically){
         dab->mirror(true, false);
         mask->mirror(true, false);
         bltFixedWithFixedSelection(mirrorX,y, dab, mask, rc.width() ,rc.height() );
 
         dab->mirror(false,true);
         mask->mirror(false, true);
         bltFixedWithFixedSelection(mirrorX,mirrorY, dab, mask, rc.width() ,rc.height() );
 
         dab->mirror(true, false);
         mask->mirror(true, false);
         bltFixedWithFixedSelection(x,mirrorY, dab, mask, rc.width() ,rc.height() );
 
     }else if (d->mirrorHorizontally){
         dab->mirror(true, false);
         mask->mirror(true, false);
         bltFixedWithFixedSelection(mirrorX,y, dab, mask, rc.width() ,rc.height() );
 
     }else if (d->mirrorVertically){
         dab->mirror(false, true);
         mask->mirror(false, true);
         bltFixedWithFixedSelection(x,mirrorY, dab, mask, rc.width() ,rc.height() );
     }
 
 }
 
 
 void KisPainter::renderMirrorMask(QRect rc, KisPaintDeviceSP dab){
     if (d->mirrorHorizontally || d->mirrorVertically){
         KisFixedPaintDeviceSP mirrorDab(new KisFixedPaintDevice(dab->colorSpace()));
         QRect dabRc( QPoint(0,0), QSize(rc.width(),rc.height()) );
         mirrorDab->setRect(dabRc);
         mirrorDab->lazyGrowBufferWithoutInitialization();
 
         dab->readBytes(mirrorDab->data(),rc);
 
         renderMirrorMask( QRect(rc.topLeft(),dabRc.size()), mirrorDab);
     }
 }
 
 void KisPainter::renderMirrorMask(QRect rc, KisPaintDeviceSP dab, int sx, int sy, KisFixedPaintDeviceSP mask)
 {
     if (d->mirrorHorizontally || d->mirrorVertically){
         KisFixedPaintDeviceSP mirrorDab(new KisFixedPaintDevice(dab->colorSpace()));
         QRect dabRc( QPoint(0,0), QSize(rc.width(),rc.height()) );
         mirrorDab->setRect(dabRc);
         mirrorDab->lazyGrowBufferWithoutInitialization();
         dab->readBytes(mirrorDab->data(),QRect(QPoint(sx,sy),rc.size()));
         renderMirrorMask(rc, mirrorDab, mask);
     }
 }
 
 void KisPainter::renderDabWithMirroringNonIncremental(QRect rc, KisPaintDeviceSP dab)
 {
     QVector<QRect> rects;
 
     int x = rc.topLeft().x();
     int y = rc.topLeft().y();
 
     KisLodTransform t(d->device);
     QPoint effectiveAxesCenter = t.map(d->axesCenter).toPoint();
 
     int mirrorX = -((x+rc.width()) - effectiveAxesCenter.x()) + effectiveAxesCenter.x();
     int mirrorY = -((y+rc.height()) - effectiveAxesCenter.y()) + effectiveAxesCenter.y();
 
     rects << rc;
 
     if (d->mirrorHorizontally && d->mirrorVertically){
         rects << QRect(mirrorX, y, rc.width(), rc.height());
         rects << QRect(mirrorX, mirrorY, rc.width(), rc.height());
         rects << QRect(x, mirrorY, rc.width(), rc.height());
     } else if (d->mirrorHorizontally) {
         rects << QRect(mirrorX, y, rc.width(), rc.height());
     } else if (d->mirrorVertically) {
         rects << QRect(x, mirrorY, rc.width(), rc.height());
     }
 
     Q_FOREACH (const QRect &rc, rects) {
         d->device->clear(rc);
     }
 
     QRect resultRect = dab->extent() | rc;
     bool intersects = false;
 
     for (int i = 1; i < rects.size(); i++) {
         if (rects[i].intersects(resultRect)) {
             intersects = true;
             break;
         }
     }
 
     /**
      * If there are no cross-intersections, we can use a fast path
      * and do no cycling recompositioning
      */
     if (!intersects) {
         rects.resize(1);
     }
 
     Q_FOREACH (const QRect &rc, rects) {
         bitBlt(rc.topLeft(), dab, rc);
     }
 
     Q_FOREACH (const QRect &rc, rects) {
         renderMirrorMask(rc, dab);
     }
 }
 
 bool KisPainter::hasDirtyRegion() const
 {
     return !d->dirtyRects.isEmpty();
 }
 
 void KisPainter::mirrorRect(Qt::Orientation direction, QRect *rc) const
 {
     KisLodTransform t(d->device);
     QPoint effectiveAxesCenter = t.map(d->axesCenter).toPoint();
 
     KritaUtils::mirrorRect(direction, effectiveAxesCenter, rc);
 }
 
 void KisPainter::mirrorDab(Qt::Orientation direction, KisRenderedDab *dab) const
 {
     KisLodTransform t(d->device);
     QPoint effectiveAxesCenter = t.map(d->axesCenter).toPoint();
 
     KritaUtils::mirrorDab(direction, effectiveAxesCenter, dab);
 }
 
 const QVector<QRect> KisPainter::calculateAllMirroredRects(const QRect &rc)
 {
     QVector<QRect> rects;
 
     KisLodTransform t(d->device);
     QPoint effectiveAxesCenter = t.map(d->axesCenter).toPoint();
 
     QRect baseRect = rc;
     rects << baseRect;
 
     if (d->mirrorHorizontally && d->mirrorVertically){
         KritaUtils::mirrorRect(Qt::Horizontal, effectiveAxesCenter, &baseRect);
         rects << baseRect;
         KritaUtils::mirrorRect(Qt::Vertical, effectiveAxesCenter, &baseRect);
         rects << baseRect;
         KritaUtils::mirrorRect(Qt::Horizontal, effectiveAxesCenter, &baseRect);
         rects << baseRect;
     } else if (d->mirrorHorizontally) {
         KritaUtils::mirrorRect(Qt::Horizontal, effectiveAxesCenter, &baseRect);
         rects << baseRect;
     } else if (d->mirrorVertically) {
         KritaUtils::mirrorRect(Qt::Vertical, effectiveAxesCenter, &baseRect);
         rects << baseRect;
     }
 
     return rects;
 }
diff --git a/libs/image/kis_pixel_selection.cpp b/libs/image/kis_pixel_selection.cpp
index a0bcb0ed0e..01dfc98500 100644
--- a/libs/image/kis_pixel_selection.cpp
+++ b/libs/image/kis_pixel_selection.cpp
@@ -1,556 +1,556 @@
 /*
  *  Copyright (c) 2004 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2007 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_pixel_selection.h"
 
 
 #include <QImage>
 #include <QVector>
 
 #include <QMutex>
 #include <QPoint>
 #include <QPolygon>
 
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorModelStandardIds.h>
 #include <KoIntegerMaths.h>
 #include <KoCompositeOpRegistry.h>
 
 #include "kis_layer.h"
 #include "kis_debug.h"
 #include "kis_image.h"
 #include "kis_fill_painter.h"
 #include "kis_outline_generator.h"
 #include <kis_iterator_ng.h>
 #include "kis_lod_transform.h"
 
 
 struct Q_DECL_HIDDEN KisPixelSelection::Private {
     KisSelectionWSP parentSelection;
 
     QPainterPath outlineCache;
     bool outlineCacheValid;
     QMutex outlineCacheMutex;
 
     bool thumbnailImageValid;
     QImage thumbnailImage;
     QTransform thumbnailImageTransform;
 
     QPoint lod0CachesOffset;
 
     void invalidateThumbnailImage() {
         thumbnailImageValid = false;
         thumbnailImage = QImage();
         thumbnailImageTransform = QTransform();
     }
 };
 
 KisPixelSelection::KisPixelSelection(KisDefaultBoundsBaseSP defaultBounds, KisSelectionWSP parentSelection)
         : KisPaintDevice(0, KoColorSpaceRegistry::instance()->alpha8(), defaultBounds)
         , m_d(new Private)
 {
     m_d->outlineCacheValid = true;
     m_d->invalidateThumbnailImage();
 
     m_d->parentSelection = parentSelection;
 }
 
 KisPixelSelection::KisPixelSelection(const KisPixelSelection& rhs, KritaUtils::DeviceCopyMode copyMode)
         : KisPaintDevice(rhs, copyMode)
         , KisSelectionComponent(rhs)
         , m_d(new Private)
 {
     // parent selection is not supposed to be shared
     m_d->outlineCache = rhs.m_d->outlineCache;
     m_d->outlineCacheValid = rhs.m_d->outlineCacheValid;
 
     m_d->thumbnailImageValid = rhs.m_d->thumbnailImageValid;
     m_d->thumbnailImage = rhs.m_d->thumbnailImage;
     m_d->thumbnailImageTransform = rhs.m_d->thumbnailImageTransform;
 }
 
 KisSelectionComponent* KisPixelSelection::clone(KisSelection*)
 {
     return new KisPixelSelection(*this);
 }
 
 KisPixelSelection::~KisPixelSelection()
 {
     delete m_d;
 }
 
 const KoColorSpace *KisPixelSelection::compositionSourceColorSpace() const
 {
     return KoColorSpaceRegistry::instance()->
         colorSpace(GrayAColorModelID.id(),
                    Integer8BitsColorDepthID.id(),
                    QString());
 }
 
 bool KisPixelSelection::read(QIODevice *stream)
 {
     bool retval = KisPaintDevice::read(stream);
     m_d->outlineCacheValid = false;
     m_d->invalidateThumbnailImage();
     return retval;
 }
 
 void KisPixelSelection::select(const QRect & rc, quint8 selectedness)
 {
     QRect r = rc.normalized();
     if (r.isEmpty()) return;
 
     KisFillPainter painter(KisPaintDeviceSP(this));
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     painter.fillRect(r, KoColor(Qt::white, cs), selectedness);
 
     if (m_d->outlineCacheValid) {
         QPainterPath path;
         path.addRect(r);
 
         if (selectedness != MIN_SELECTED) {
             m_d->outlineCache += path;
         } else {
             m_d->outlineCache -= path;
         }
     }
     m_d->invalidateThumbnailImage();
 }
 
 void KisPixelSelection::applySelection(KisPixelSelectionSP selection, SelectionAction action)
 {
     switch (action) {
     case SELECTION_REPLACE:
         clear();
         addSelection(selection);
         break;
     case SELECTION_ADD:
         addSelection(selection);
         break;
     case SELECTION_SUBTRACT:
         subtractSelection(selection);
         break;
     case SELECTION_INTERSECT:
         intersectSelection(selection);
         break;
     default:
         break;
     }
 }
 
 void KisPixelSelection::copyAlphaFrom(KisPaintDeviceSP src, const QRect &processRect)
 {
     const KoColorSpace *srcCS = src->colorSpace();
 
     KisSequentialConstIterator srcIt(src, processRect);
     KisSequentialIterator dstIt(this, processRect);
 
     while (srcIt.nextPixel() && dstIt.nextPixel()) {
         const quint8 *srcPtr = srcIt.rawDataConst();
         quint8 *alpha8Ptr = dstIt.rawData();
 
         *alpha8Ptr = srcCS->opacityU8(srcPtr);
     }
 
     m_d->outlineCacheValid = false;
     m_d->outlineCache = QPainterPath();
     m_d->invalidateThumbnailImage();
 }
 
 void KisPixelSelection::addSelection(KisPixelSelectionSP selection)
 {
     QRect r = selection->selectedRect();
     if (r.isEmpty()) return;
 
     KisHLineIteratorSP dst = createHLineIteratorNG(r.x(), r.y(), r.width());
     KisHLineConstIteratorSP src = selection->createHLineConstIteratorNG(r.x(), r.y(), r.width());
     for (int i = 0; i < r.height(); ++i) {
         do {
             if (*src->oldRawData() + *dst->rawData() < MAX_SELECTED)
                 *dst->rawData() = *src->oldRawData() + *dst->rawData();
             else
                 *dst->rawData() = MAX_SELECTED;
 
         } while (src->nextPixel() && dst->nextPixel());
         dst->nextRow();
         src->nextRow();
     }
 
     m_d->outlineCacheValid &= selection->outlineCacheValid();
 
     if (m_d->outlineCacheValid) {
         m_d->outlineCache += selection->outlineCache();
     }
 
     m_d->invalidateThumbnailImage();
 }
 
 void KisPixelSelection::subtractSelection(KisPixelSelectionSP selection)
 {
     QRect r = selection->selectedRect();
     if (r.isEmpty()) return;
 
 
     KisHLineIteratorSP dst = createHLineIteratorNG(r.x(), r.y(), r.width());
     KisHLineConstIteratorSP src = selection->createHLineConstIteratorNG(r.x(), r.y(), r.width());
     for (int i = 0; i < r.height(); ++i) {
         do {
             if (*dst->rawData() - *src->oldRawData() > MIN_SELECTED)
                 *dst->rawData() = *dst->rawData() - *src->oldRawData();
             else
                 *dst->rawData() = MIN_SELECTED;
 
         } while (src->nextPixel() && dst->nextPixel());
         dst->nextRow();
         src->nextRow();
     }
 
     m_d->outlineCacheValid &= selection->outlineCacheValid();
 
     if (m_d->outlineCacheValid) {
         m_d->outlineCache -= selection->outlineCache();
     }
 
     m_d->invalidateThumbnailImage();
 }
 
 void KisPixelSelection::intersectSelection(KisPixelSelectionSP selection)
 {
     QRect r = selection->selectedRect().united(selectedRect());
     if (r.isEmpty()) return;
 
     KisHLineIteratorSP dst = createHLineIteratorNG(r.x(), r.y(), r.width());
     KisHLineConstIteratorSP src = selection->createHLineConstIteratorNG(r.x(), r.y(), r.width());
     for (int i = 0; i < r.height(); ++i) {
         do {
             *dst->rawData() = qMin(*dst->rawData(), *src->oldRawData());
         }  while (src->nextPixel() && dst->nextPixel());
         dst->nextRow();
         src->nextRow();
     }
 
     m_d->outlineCacheValid &= selection->outlineCacheValid();
 
     if (m_d->outlineCacheValid) {
         m_d->outlineCache &= selection->outlineCache();
     }
 
     m_d->invalidateThumbnailImage();
 }
 
 void KisPixelSelection::clear(const QRect & r)
 {
     if (*defaultPixel().data() != MIN_SELECTED) {
         KisFillPainter painter(KisPaintDeviceSP(this));
         const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
         painter.fillRect(r, KoColor(Qt::white, cs), MIN_SELECTED);
     } else {
         KisPaintDevice::clear(r);
     }
 
     if (m_d->outlineCacheValid) {
         QPainterPath path;
         path.addRect(r);
 
         m_d->outlineCache -= path;
     }
 
     m_d->invalidateThumbnailImage();
 }
 
 void KisPixelSelection::clear()
 {
     setDefaultPixel(KoColor(Qt::transparent, colorSpace()));
     KisPaintDevice::clear();
 
     m_d->outlineCacheValid = true;
     m_d->outlineCache = QPainterPath();
 
     // Empty the thumbnail image. It is a valid state.
     m_d->invalidateThumbnailImage();
     m_d->thumbnailImageValid = true;
 }
 
 void KisPixelSelection::invert()
 {
     // Region is needed here (not exactBounds or extent), because
     // unselected but existing pixels need to be inverted too
     QRect rc = region().boundingRect();
 
     if (!rc.isEmpty()) {
         KisSequentialIterator it(this, rc);
         while(it.nextPixel()) {
             *(it.rawData()) = MAX_SELECTED - *(it.rawData());
         }
     }
     quint8 defPixel = MAX_SELECTED - *defaultPixel().data();
     setDefaultPixel(KoColor(&defPixel, colorSpace()));
 
     if (m_d->outlineCacheValid) {
         QPainterPath path;
         path.addRect(defaultBounds()->bounds());
 
         m_d->outlineCache = path - m_d->outlineCache;
     }
 
     m_d->invalidateThumbnailImage();
 }
 
 void KisPixelSelection::moveTo(const QPoint &pt)
 {
     const int lod = defaultBounds()->currentLevelOfDetail();
     const QPoint lod0Point = !lod ? pt :
         pt * KisLodTransform::lodToInvScale(lod);
 
     const QPoint offset = lod0Point - m_d->lod0CachesOffset;
 
     if (m_d->outlineCacheValid) {
         m_d->outlineCache.translate(offset);
     }
 
     if (m_d->thumbnailImageValid) {
         m_d->thumbnailImageTransform =
             QTransform::fromTranslate(offset.x(), offset.y()) *
             m_d->thumbnailImageTransform;
     }
 
     m_d->lod0CachesOffset = lod0Point;
 
     KisPaintDevice::moveTo(pt);
 }
 
 bool KisPixelSelection::isTotallyUnselected(const QRect & r) const
 {
     if (*defaultPixel().data() != MIN_SELECTED)
         return false;
     QRect sr = selectedExactRect();
     return ! r.intersects(sr);
 }
 
 QRect KisPixelSelection::selectedRect() const
 {
     return extent();
 }
 
 QRect KisPixelSelection::selectedExactRect() const
 {
     return exactBounds();
 }
 
 QVector<QPolygon> KisPixelSelection::outline() const
 {
     QRect selectionExtent = selectedExactRect();
 
     /**
      * When the default pixel is not fully transarent, the
      * exactBounds() return extent of the device instead. To make this
      * value sane we should limit the calculated area by the bounds of
      * the image.
      */
     if (*defaultPixel().data() != MIN_SELECTED) {
         selectionExtent &= defaultBounds()->bounds();
     }
 
     qint32 xOffset = selectionExtent.x();
     qint32 yOffset = selectionExtent.y();
     qint32 width = selectionExtent.width();
     qint32 height = selectionExtent.height();
 
     KisOutlineGenerator generator(colorSpace(), MIN_SELECTED);
     // If the selection is small using a buffer is much faster
     try {
         quint8* buffer = new quint8[width*height];
         readBytes(buffer, xOffset, yOffset, width, height);
 
         QVector<QPolygon> paths = generator.outline(buffer, xOffset, yOffset, width, height);
 
         delete[] buffer;
         return paths;
     }
-    catch(std::bad_alloc) {
+    catch(const std::bad_alloc&) {
         // Allocating so much memory failed, so we fall through to the slow option.
         warnKrita << "KisPixelSelection::outline ran out of memory allocating" << width << "*" << height << "bytes.";
     }
 
     return generator.outline(this, xOffset, yOffset, width, height);
 }
 
 bool KisPixelSelection::isEmpty() const
 {
     return *defaultPixel().data() == MIN_SELECTED && selectedRect().isEmpty();
 }
 
 QPainterPath KisPixelSelection::outlineCache() const
 {
     QMutexLocker locker(&m_d->outlineCacheMutex);
     return m_d->outlineCache;
 }
 
 void KisPixelSelection::setOutlineCache(const QPainterPath &cache)
 {
     QMutexLocker locker(&m_d->outlineCacheMutex);
     m_d->outlineCache = cache;
     m_d->outlineCacheValid = true;
     m_d->thumbnailImageValid = false;
 }
 
 bool KisPixelSelection::outlineCacheValid() const
 {
     QMutexLocker locker(&m_d->outlineCacheMutex);
     return m_d->outlineCacheValid;
 }
 
 void KisPixelSelection::invalidateOutlineCache()
 {
     QMutexLocker locker(&m_d->outlineCacheMutex);
     m_d->outlineCacheValid = false;
     m_d->thumbnailImageValid = false;
 }
 
 void KisPixelSelection::recalculateOutlineCache()
 {
     QMutexLocker locker(&m_d->outlineCacheMutex);
 
     m_d->outlineCache = QPainterPath();
 
     Q_FOREACH (const QPolygon &polygon, outline()) {
         m_d->outlineCache.addPolygon(polygon);
 
         /**
          * The outline generation algorithm has a small bug, which
          * results in the starting point be repeated twice in the
          * beginning of the path, instead of being put to the
          * end. Here we just explicitly close the path to workaround
          * it.
          *
          * \see KisSelectionTest::testOutlineGeneration()
          */
         m_d->outlineCache.closeSubpath();
     }
 
     m_d->outlineCacheValid = true;
 }
 
 bool KisPixelSelection::thumbnailImageValid() const
 {
     return m_d->thumbnailImageValid;
 }
 
 QImage KisPixelSelection::thumbnailImage() const
 {
     return m_d->thumbnailImage;
 }
 
 QTransform KisPixelSelection::thumbnailImageTransform() const
 {
     return m_d->thumbnailImageTransform;
 }
 
 QImage deviceToQImage(KisPaintDeviceSP device,
                       const QRect &rc,
                       const QColor &maskColor)
 {
     QImage image(rc.size(), QImage::Format_ARGB32);
 
     QColor color = maskColor;
     const qreal alphaScale = maskColor.alphaF();
 
     KisSequentialConstIterator it(device, rc);
     while(it.nextPixel()) {
         quint8 value = (MAX_SELECTED - *(it.rawDataConst())) * alphaScale;
         color.setAlpha(value);
 
         QPoint pt(it.x(), it.y());
         pt -= rc.topLeft();
 
         image.setPixel(pt.x(), pt.y(), color.rgba());
     }
 
     return image;
 }
 
 void KisPixelSelection::recalculateThumbnailImage(const QColor &maskColor)
 {
     QRect rc = selectedExactRect();
     const int maxPreviewSize = 2000;
 
     if (rc.isEmpty()) {
         m_d->thumbnailImageTransform = QTransform();
         m_d->thumbnailImage = QImage();
         return;
     }
 
 
     if (rc.width() > maxPreviewSize ||
         rc.height() > maxPreviewSize) {
 
         qreal factor = 1.0;
 
         if (rc.width() > rc.height()) {
             factor = qreal(maxPreviewSize) / rc.width();
         } else {
             factor = qreal(maxPreviewSize) / rc.height();
         }
 
         int newWidth = qRound(rc.width() * factor);
         int newHeight = qRound(rc.height() * factor);
 
         m_d->thumbnailImageTransform =
             QTransform::fromScale(qreal(rc.width()) / newWidth,
                                   qreal(rc.height()) / newHeight) *
             QTransform::fromTranslate(rc.x(), rc.y());
 
         KisPaintDeviceSP thumbDevice =
             createThumbnailDevice(newWidth, newHeight, rc);
 
         QRect thumbRect(0, 0, newWidth, newHeight);
         m_d->thumbnailImage = deviceToQImage(thumbDevice, thumbRect, maskColor);
 
     } else {
         m_d->thumbnailImageTransform = QTransform::fromTranslate(rc.x(), rc.y());
         m_d->thumbnailImage = deviceToQImage(this, rc, maskColor);
     }
 
     m_d->thumbnailImageValid = true;
 }
 
 void KisPixelSelection::setParentSelection(KisSelectionWSP selection)
 {
     m_d->parentSelection = selection;
 }
 
 KisSelectionWSP KisPixelSelection::parentSelection() const
 {
     return m_d->parentSelection;
 }
 
 void KisPixelSelection::renderToProjection(KisPaintDeviceSP projection)
 {
     renderToProjection(projection, selectedExactRect());
 }
 
 void KisPixelSelection::renderToProjection(KisPaintDeviceSP projection, const QRect& rc)
 {
     QRect updateRect = rc & selectedExactRect();
 
     if (updateRect.isValid()) {
         KisPainter::copyAreaOptimized(updateRect.topLeft(), KisPaintDeviceSP(this), projection, updateRect);
     }
 }
diff --git a/libs/image/kis_raster_keyframe_channel.cpp b/libs/image/kis_raster_keyframe_channel.cpp
index 8fbc73df2f..c53465827e 100644
--- a/libs/image/kis_raster_keyframe_channel.cpp
+++ b/libs/image/kis_raster_keyframe_channel.cpp
@@ -1,312 +1,313 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "kis_raster_keyframe_channel.h"
 #include "kis_node.h"
 #include "kis_dom_utils.h"
 
 #include "kis_global.h"
 #include "kis_paint_device.h"
 #include "kis_paint_device_frames_interface.h"
 #include "kis_time_range.h"
 #include "kundo2command.h"
 #include "kis_onion_skin_compositor.h"
 
 struct KisRasterKeyframe : public KisKeyframe
 {
     KisRasterKeyframe(KisRasterKeyframeChannel *channel, int time, int frameId)
         : KisKeyframe(channel, time)
         , frameId(frameId)
     {}
 
     KisRasterKeyframe(const KisRasterKeyframe *rhs, KisKeyframeChannel *channel)
         : KisKeyframe(rhs, channel)
         , frameId(rhs->frameId)
     {}
 
     int frameId;
 
     KisKeyframeSP cloneFor(KisKeyframeChannel *channel) const override
     {
         return toQShared(new KisRasterKeyframe(this, channel));
     }
 
     bool hasContent() const override {
         KisRasterKeyframeChannel *channel = dynamic_cast<KisRasterKeyframeChannel*>(this->channel());
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(channel, true);
 
         return channel->keyframeHasContent(this);
     }
 };
 
 struct KisRasterKeyframeChannel::Private
 {
   Private(KisPaintDeviceWSP paintDevice, const QString filenameSuffix)
       : paintDevice(paintDevice),
         filenameSuffix(filenameSuffix),
         onionSkinsEnabled(false)
   {}
 
   KisPaintDeviceWSP paintDevice;
   QMap<int, QString> frameFilenames;
   QString filenameSuffix;
   bool onionSkinsEnabled;
 };
 
 KisRasterKeyframeChannel::KisRasterKeyframeChannel(const KoID &id, const KisPaintDeviceWSP paintDevice, KisDefaultBoundsBaseSP defaultBounds)
     : KisKeyframeChannel(id, defaultBounds),
       m_d(new Private(paintDevice, QString()))
 {
 }
 
 KisRasterKeyframeChannel::KisRasterKeyframeChannel(const KisRasterKeyframeChannel &rhs, KisNode *newParentNode, const KisPaintDeviceWSP newPaintDevice)
     : KisKeyframeChannel(rhs, newParentNode),
       m_d(new Private(newPaintDevice, rhs.m_d->filenameSuffix))
 {
     KIS_ASSERT_RECOVER_NOOP(&rhs != this);
 
     m_d->frameFilenames = rhs.m_d->frameFilenames;
     m_d->onionSkinsEnabled = rhs.m_d->onionSkinsEnabled;
 }
 
 KisRasterKeyframeChannel::~KisRasterKeyframeChannel()
 {
 }
 
 int KisRasterKeyframeChannel::frameId(KisKeyframeSP keyframe) const
 {
     return frameId(keyframe.data());
 }
 
 int KisRasterKeyframeChannel::frameId(const KisKeyframe *keyframe) const
 {
     const KisRasterKeyframe *key = dynamic_cast<const KisRasterKeyframe*>(keyframe);
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(key, -1);
     return key->frameId;
 }
 
 int KisRasterKeyframeChannel::frameIdAt(int time) const
 {
     KisKeyframeSP activeKey = activeKeyframeAt(time);
     if (activeKey.isNull()) return -1;
     return frameId(activeKey);
 }
 
 void KisRasterKeyframeChannel::fetchFrame(KisKeyframeSP keyframe, KisPaintDeviceSP targetDevice)
 {
     m_d->paintDevice->framesInterface()->fetchFrame(frameId(keyframe), targetDevice);
 }
 
 void KisRasterKeyframeChannel::importFrame(int time, KisPaintDeviceSP sourceDevice, KUndo2Command *parentCommand)
 {
     KisKeyframeSP keyframe = addKeyframe(time, parentCommand);
 
     const int frame = frameId(keyframe);
 
     m_d->paintDevice->framesInterface()->uploadFrame(frame, sourceDevice);
 }
 
 QRect KisRasterKeyframeChannel::frameExtents(KisKeyframeSP keyframe)
 {
     return m_d->paintDevice->framesInterface()->frameBounds(frameId(keyframe));
 }
 
 QString KisRasterKeyframeChannel::frameFilename(int frameId) const
 {
     return m_d->frameFilenames.value(frameId, QString());
 }
 
 void KisRasterKeyframeChannel::setFilenameSuffix(const QString &suffix)
 {
     m_d->filenameSuffix = suffix;
 }
 
 void KisRasterKeyframeChannel::setFrameFilename(int frameId, const QString &filename)
 {
     Q_ASSERT(!m_d->frameFilenames.contains(frameId));
     m_d->frameFilenames.insert(frameId, filename);
 }
 
 QString KisRasterKeyframeChannel::chooseFrameFilename(int frameId, const QString &layerFilename)
 {
     QString filename;
 
     if (m_d->frameFilenames.isEmpty()) {
         // Use legacy naming convention for first keyframe
         filename = layerFilename + m_d->filenameSuffix;
     } else {
         filename = layerFilename + m_d->filenameSuffix + ".f" + QString::number(frameId);
     }
 
     setFrameFilename(frameId, filename);
 
     return filename;
 }
 
 KisKeyframeSP KisRasterKeyframeChannel::createKeyframe(int time, const KisKeyframeSP copySrc, KUndo2Command *parentCommand)
 {
     KisRasterKeyframe *keyframe;
 
     if (!copySrc) {
         int frameId = m_d->paintDevice->framesInterface()->createFrame(false, 0, QPoint(), parentCommand);
         keyframe = new KisRasterKeyframe(this, time, frameId);
     } else {
         int srcFrame = frameId(copySrc);
         int frameId = m_d->paintDevice->framesInterface()->createFrame(true, srcFrame, QPoint(), parentCommand);
 
         KisRasterKeyframe *srcKeyframe = dynamic_cast<KisRasterKeyframe*>(copySrc.data());
         Q_ASSERT(srcKeyframe);
         keyframe = new KisRasterKeyframe(srcKeyframe, this);
 
         keyframe->setTime(time);
         keyframe->frameId = frameId;
     }
 
     return toQShared(keyframe);
 }
 
 void KisRasterKeyframeChannel::destroyKeyframe(KisKeyframeSP key, KUndo2Command *parentCommand)
 {
     m_d->paintDevice->framesInterface()->deleteFrame(frameId(key), parentCommand);
 }
 
 void KisRasterKeyframeChannel::uploadExternalKeyframe(KisKeyframeChannel *srcChannel, int srcTime, KisKeyframeSP dstFrame)
 {
     KisRasterKeyframeChannel *srcRasterChannel = dynamic_cast<KisRasterKeyframeChannel*>(srcChannel);
     KIS_ASSERT_RECOVER_RETURN(srcRasterChannel);
 
     const int srcId = srcRasterChannel->frameIdAt(srcTime);
     const int dstId = frameId(dstFrame);
 
     m_d->paintDevice->framesInterface()->
         uploadFrame(srcId,
                     dstId,
                     srcRasterChannel->m_d->paintDevice);
 }
 
 QRect KisRasterKeyframeChannel::affectedRect(KisKeyframeSP key)
 {
     KeyframesMap::iterator it = keys().find(key->time());
     QRect rect;
 
     // Calculate changed area as the union of the current and previous keyframe.
     // This makes sure there are no artifacts left over from the previous frame
     // where the new one doesn't cover the area.
 
     if (it == keys().begin()) {
         // Using the *next* keyframe at the start of the timeline avoids artifacts
         // when deleting or moving the first key
         it++;
     } else {
         it--;
     }
 
     if (it != keys().end()) {
         rect = m_d->paintDevice->framesInterface()->frameBounds(frameId(it.value()));
     }
 
     rect |= m_d->paintDevice->framesInterface()->frameBounds(frameId(key));
 
     if (m_d->onionSkinsEnabled) {
         const QRect dirtyOnionSkinsRect =
             KisOnionSkinCompositor::instance()->calculateFullExtent(m_d->paintDevice);
         rect |= dirtyOnionSkinsRect;
     }
 
     return rect;
 }
 
 QDomElement KisRasterKeyframeChannel::toXML(QDomDocument doc, const QString &layerFilename)
 {
     m_d->frameFilenames.clear();
 
     return KisKeyframeChannel::toXML(doc, layerFilename);
 }
 
 void KisRasterKeyframeChannel::loadXML(const QDomElement &channelNode)
 {
     m_d->frameFilenames.clear();
 
     KisKeyframeChannel::loadXML(channelNode);
 }
 
 void KisRasterKeyframeChannel::saveKeyframe(KisKeyframeSP keyframe, QDomElement keyframeElement, const QString &layerFilename)
 {
     int frame = frameId(keyframe);
 
     QString filename = frameFilename(frame);
     if (filename.isEmpty()) {
         filename = chooseFrameFilename(frame, layerFilename);
     }
     keyframeElement.setAttribute("frame", filename);
 
     QPoint offset = m_d->paintDevice->framesInterface()->frameOffset(frame);
     KisDomUtils::saveValue(&keyframeElement, "offset", offset);
 }
 
 KisKeyframeSP KisRasterKeyframeChannel::loadKeyframe(const QDomElement &keyframeNode)
 {
-    int time = keyframeNode.attribute("time").toUInt();
+    int time = keyframeNode.attribute("time").toInt();
+    workaroundBrokenFrameTimeBug(&time);
 
     QPoint offset;
     KisDomUtils::loadValue(keyframeNode, "offset", &offset);
     QString frameFilename = keyframeNode.attribute("frame");
 
     KisKeyframeSP keyframe;
 
     if (m_d->frameFilenames.isEmpty()) {
         // First keyframe loaded: use the existing frame
 
-        Q_ASSERT(keyframeCount() == 1);
+        KIS_SAFE_ASSERT_RECOVER_NOOP(keyframeCount() == 1);
         keyframe = constKeys().begin().value();
 
         // Remove from keys. It will get reinserted with new time once we return
         keys().remove(keyframe->time());
 
         keyframe->setTime(time);
         m_d->paintDevice->framesInterface()->setFrameOffset(frameId(keyframe), offset);
     } else {
         KUndo2Command tempCommand;
         int frameId = m_d->paintDevice->framesInterface()->createFrame(false, 0, offset, &tempCommand);
 
         keyframe = toQShared(new KisRasterKeyframe(this, time, frameId));
     }
 
     setFrameFilename(frameId(keyframe), frameFilename);
 
     return keyframe;
 }
 
 bool KisRasterKeyframeChannel::keyframeHasContent(const KisKeyframe *keyframe) const
 {
     return !m_d->paintDevice->framesInterface()->frameBounds(frameId(keyframe)).isEmpty();
 }
 
 bool KisRasterKeyframeChannel::hasScalarValue() const
 {
     return false;
 }
 
 void KisRasterKeyframeChannel::setOnionSkinsEnabled(bool value)
 {
     m_d->onionSkinsEnabled = value;
 }
 
 bool KisRasterKeyframeChannel::onionSkinsEnabled() const
 {
     return m_d->onionSkinsEnabled;
 }
diff --git a/libs/image/kis_scalar_keyframe_channel.cpp b/libs/image/kis_scalar_keyframe_channel.cpp
index 6721e1f471..ba73be65d7 100644
--- a/libs/image/kis_scalar_keyframe_channel.cpp
+++ b/libs/image/kis_scalar_keyframe_channel.cpp
@@ -1,485 +1,487 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_scalar_keyframe_channel.h"
 #include "kis_node.h"
 #include "kundo2command.h"
 #include "kis_time_range.h"
 
 #include <kis_global.h>
 #include <kis_dom_utils.h>
 
 struct KisScalarKeyframe : public KisKeyframe
 {
     KisScalarKeyframe(KisKeyframeChannel *channel, int time, qreal value)
         : KisKeyframe(channel, time)
         , value(value)
     {}
 
     KisScalarKeyframe(const KisScalarKeyframe *rhs, KisKeyframeChannel *channel)
         : KisKeyframe(rhs, channel)
         , value(rhs->value)
     {}
 
     qreal value;
 
     KisKeyframeSP cloneFor(KisKeyframeChannel *channel) const override
     {
         return toQShared(new KisScalarKeyframe(this, channel));
     }
 };
 
 
 KisScalarKeyframeChannel::AddKeyframeCommand::AddKeyframeCommand(KisScalarKeyframeChannel *channel, int time, qreal value, KUndo2Command *parentCommand)
     : KisReplaceKeyframeCommand(channel, time, channel->createKeyframe(time, value, parentCommand), parentCommand)
 {}
 
 struct KisScalarKeyframeChannel::Private
 {
 public:
     Private(qreal min, qreal max, KisKeyframe::InterpolationMode defaultInterpolation)
         : minValue(min), maxValue(max), firstFreeIndex(0), defaultInterpolation(defaultInterpolation)
     {}
 
     Private(const Private &rhs)
         : minValue(rhs.minValue),
           maxValue(rhs.maxValue),
           firstFreeIndex(rhs.firstFreeIndex),
           defaultInterpolation(rhs.defaultInterpolation)
     {}
 
     qreal minValue;
     qreal maxValue;
     int firstFreeIndex;
 
     KisKeyframe::InterpolationMode defaultInterpolation;
 
     struct SetValueCommand;
     struct SetTangentsCommand;
     struct SetInterpolationModeCommand;
 };
 
 KisScalarKeyframeChannel::KisScalarKeyframeChannel(const KoID &id, qreal minValue, qreal maxValue, KisDefaultBoundsBaseSP defaultBounds, KisKeyframe::InterpolationMode defaultInterpolation)
     : KisKeyframeChannel(id, defaultBounds),
       m_d(new Private(minValue, maxValue, defaultInterpolation))
 {
 }
 
 KisScalarKeyframeChannel::KisScalarKeyframeChannel(const KisScalarKeyframeChannel &rhs, KisNode *newParentNode)
     : KisKeyframeChannel(rhs, newParentNode),
       m_d(new Private(*rhs.m_d))
 {
 }
 
 KisScalarKeyframeChannel::~KisScalarKeyframeChannel()
 {}
 
 bool KisScalarKeyframeChannel::hasScalarValue() const
 {
     return true;
 }
 
 qreal KisScalarKeyframeChannel::minScalarValue() const
 {
     return m_d->minValue;
 }
 
 qreal KisScalarKeyframeChannel::maxScalarValue() const
 {
     return m_d->maxValue;
 }
 
 qreal KisScalarKeyframeChannel::scalarValue(const KisKeyframeSP keyframe) const
 {
     KisScalarKeyframe *key = dynamic_cast<KisScalarKeyframe*>(keyframe.data());
     Q_ASSERT(key != 0);
     return key->value;
 }
 
 struct KisScalarKeyframeChannel::Private::SetValueCommand : public KUndo2Command
 {
     SetValueCommand(KisScalarKeyframeChannel *channel, KisKeyframeSP keyframe, qreal oldValue, qreal newValue, KUndo2Command *parentCommand)
         : KUndo2Command(parentCommand),
           m_channel(channel),
           m_keyframe(keyframe),
           m_oldValue(oldValue),
           m_newValue(newValue)
     {
     }
 
     void redo() override {
         setValue(m_newValue);
     }
 
     void undo() override {
         setValue(m_oldValue);
     }
 
     void setValue(qreal value) {
         KisScalarKeyframe *key = dynamic_cast<KisScalarKeyframe*>(m_keyframe.data());
         Q_ASSERT(key != 0);
         key->value = value;
         m_channel->notifyKeyframeChanged(m_keyframe);
     }
 
 private:
     KisScalarKeyframeChannel *m_channel;
     KisKeyframeSP m_keyframe;
     qreal m_oldValue;
     qreal m_newValue;
 };
 
 struct KisScalarKeyframeChannel::Private::SetTangentsCommand : public KUndo2Command
 {
     SetTangentsCommand(KisScalarKeyframeChannel *channel, KisKeyframeSP keyframe,
                        KisKeyframe::InterpolationTangentsMode oldMode, QPointF oldLeftTangent, QPointF oldRightTangent,
                        KisKeyframe::InterpolationTangentsMode newMode, QPointF newLeftTangent, QPointF newRightTangent,
                        KUndo2Command *parentCommand)
         : KUndo2Command(parentCommand),
           m_channel(channel),
           m_keyframe(keyframe),
           m_oldMode(oldMode),
           m_oldLeftTangent(oldLeftTangent),
           m_oldRightTangent(oldRightTangent),
           m_newMode(newMode),
           m_newLeftTangent(newLeftTangent),
           m_newRightTangent(newRightTangent)
     {
     }
 
     void redo() override {
         m_keyframe->setTangentsMode(m_newMode);
         m_keyframe->setInterpolationTangents(m_newLeftTangent, m_newRightTangent);
         m_channel->notifyKeyframeChanged(m_keyframe);
     }
 
     void undo() override {
         m_keyframe->setTangentsMode(m_oldMode);
         m_keyframe->setInterpolationTangents(m_oldLeftTangent, m_oldRightTangent);
         m_channel->notifyKeyframeChanged(m_keyframe);
     }
 
 private:
     KisScalarKeyframeChannel *m_channel;
     KisKeyframeSP m_keyframe;
     KisKeyframe::InterpolationTangentsMode m_oldMode;
     QPointF m_oldLeftTangent;
     QPointF m_oldRightTangent;
     KisKeyframe::InterpolationTangentsMode m_newMode;
     QPointF m_newLeftTangent;
     QPointF m_newRightTangent;
 };
 
 struct KisScalarKeyframeChannel::Private::SetInterpolationModeCommand : public KUndo2Command
 {
     SetInterpolationModeCommand(KisScalarKeyframeChannel *channel, KisKeyframeSP keyframe, KisKeyframe::InterpolationMode oldMode, KisKeyframe::InterpolationMode newMode, KUndo2Command *parentCommand)
         : KUndo2Command(parentCommand),
           m_channel(channel),
           m_keyframe(keyframe),
           m_oldMode(oldMode),
           m_newMode(newMode)
     {
     }
 
     void redo() override {
         m_keyframe->setInterpolationMode(m_newMode);
         m_channel->notifyKeyframeChanged(m_keyframe);
     }
 
     void undo() override {
         m_keyframe->setInterpolationMode(m_oldMode);
         m_channel->notifyKeyframeChanged(m_keyframe);
     }
 
 private:
     KisScalarKeyframeChannel *m_channel;
     KisKeyframeSP m_keyframe;
     KisKeyframe::InterpolationMode m_oldMode;
     KisKeyframe::InterpolationMode m_newMode;
 };
 
 void KisScalarKeyframeChannel::setScalarValue(KisKeyframeSP keyframe, qreal value, KUndo2Command *parentCommand)
 {
     QScopedPointer<KUndo2Command> tempCommand;
     if (!parentCommand) {
         tempCommand.reset(new KUndo2Command());
         parentCommand = tempCommand.data();
     }
 
     qreal oldValue = scalarValue(keyframe);
     KUndo2Command *cmd = new Private::SetValueCommand(this, keyframe, oldValue, value, parentCommand);
     cmd->redo();
 }
 
 void KisScalarKeyframeChannel::setInterpolationMode(KisKeyframeSP keyframe, KisKeyframe::InterpolationMode mode, KUndo2Command *parentCommand)
 {
     QScopedPointer<KUndo2Command> tempCommand;
     if (!parentCommand) {
         tempCommand.reset(new KUndo2Command());
         parentCommand = tempCommand.data();
     }
 
     KisKeyframe::InterpolationMode oldMode = keyframe->interpolationMode();
 
     KUndo2Command *cmd = new Private::SetInterpolationModeCommand(this, keyframe, oldMode, mode, parentCommand);
     cmd->redo();
 }
 
 void KisScalarKeyframeChannel::setInterpolationTangents(KisKeyframeSP keyframe, KisKeyframe::InterpolationTangentsMode mode, QPointF leftTangent, QPointF rightTangent, KUndo2Command *parentCommand)
 {
     QScopedPointer<KUndo2Command> tempCommand;
     if (!parentCommand) {
         tempCommand.reset(new KUndo2Command());
         parentCommand = tempCommand.data();
     }
 
     KisKeyframe::InterpolationTangentsMode oldMode = keyframe->tangentsMode();
     QPointF oldLeftTangent = keyframe->leftTangent();
     QPointF oldRightTangent = keyframe->rightTangent();
 
     KUndo2Command *cmd = new Private::SetTangentsCommand(this, keyframe, oldMode, oldLeftTangent, oldRightTangent, mode, leftTangent, rightTangent, parentCommand);
     cmd->redo();
 }
 
 qreal cubicBezier(qreal p0, qreal delta1, qreal delta2, qreal p3, qreal t) {
     qreal p1 = p0 + delta1;
     qreal p2 = p3 + delta2;
 
     qreal c = 1-t;
     return c*c*c * p0 + 3*c*c*t * p1 + 3*c*t*t * p2 + t*t*t * p3;
 }
 
 void normalizeTangents(const QPointF point1, QPointF &rightTangent, QPointF &leftTangent, const QPointF point2)
 {
     // To ensure that the curve is monotonic wrt time,
     // check that control points lie between the endpoints.
     // If not, force them into range by scaling down the tangents
 
     float interval = point2.x() - point1.x();
     if (rightTangent.x() < 0) rightTangent *= 0;
     if (leftTangent.x() > 0) leftTangent *= 0;
 
     if (rightTangent.x() > interval) {
         rightTangent *= interval / rightTangent.x();
     }
     if (leftTangent.x() < -interval) {
         leftTangent *= interval / -leftTangent.x();
     }
 }
 
 QPointF KisScalarKeyframeChannel::interpolate(QPointF point1, QPointF rightTangent, QPointF leftTangent, QPointF point2, qreal t)
 {
     normalizeTangents(point1, rightTangent, leftTangent, point2);
 
     qreal x = cubicBezier(point1.x(), rightTangent.x(), leftTangent.x(), point2.x(), t);
     qreal y = cubicBezier(point1.y(), rightTangent.y(), leftTangent.y(), point2.y(), t);
 
     return QPointF(x,y);
 }
 
 qreal findCubicCurveParameter(int time0, qreal delta0, qreal delta1, int time1, int time)
 {
     if (time == time0) return 0.0;
     if (time == time1) return 1.0;
 
     qreal min_t = 0.0;
     qreal max_t = 1.0;
 
     while (true) {
         qreal t = (max_t + min_t) / 2;
         qreal time_t = cubicBezier(time0, delta0, delta1, time1, t);
 
         if (time_t < time - 0.05) {
             min_t = t;
         } else if (time_t > time + 0.05) {
             max_t = t;
         } else {
             // Close enough
             return t;
         }
     }
 }
 
 qreal KisScalarKeyframeChannel::interpolatedValue(int time) const
 {
     KisKeyframeSP activeKey = activeKeyframeAt(time);
     if (activeKey.isNull()) return qQNaN();
 
     KisKeyframeSP nextKey = nextKeyframe(activeKey);
 
     qreal result = qQNaN();
     if (time == activeKey->time() || nextKey.isNull()) {
         result = scalarValue(activeKey);
     } else {
         switch (activeKey->interpolationMode()) {
         case KisKeyframe::Constant:
             result = scalarValue(activeKey);
             break;
         case KisKeyframe::Linear:
         {
             int time0 = activeKey->time();
             int time1 = nextKey->time();
             qreal value0 = scalarValue(activeKey);
             qreal value1 = scalarValue(nextKey);
             result = value0 + (value1 - value0) * (time - time0) / (time1 - time0);
         }
             break;
         case KisKeyframe::Bezier:
         {
             QPointF point0 = QPointF(activeKey->time(), scalarValue(activeKey));
             QPointF point1 = QPointF(nextKey->time(), scalarValue(nextKey));
 
             QPointF tangent0 = activeKey->rightTangent();
             QPointF tangent1 = nextKey->leftTangent();
 
             normalizeTangents(point0, tangent0, tangent1, point1);
             qreal t = findCubicCurveParameter(point0.x(), tangent0.x(), tangent1.x(), point1.x(), time);
             result = interpolate(point0, tangent0, tangent1, point1, t).y();
         }
             break;
         default:
             KIS_ASSERT_RECOVER_BREAK(false);
             break;
         }
     }
 
     if (result > m_d->maxValue) return m_d->maxValue;
     if (result < m_d->minValue) return m_d->minValue;
 
     return result;
 }
 
 qreal KisScalarKeyframeChannel::currentValue() const
 {
     return interpolatedValue(currentTime());
 }
 
 KisKeyframeSP KisScalarKeyframeChannel::createKeyframe(int time, const KisKeyframeSP copySrc, KUndo2Command *parentCommand)
 {
     if (copySrc) {
         KisScalarKeyframe *srcKeyframe = dynamic_cast<KisScalarKeyframe*>(copySrc.data());
         Q_ASSERT(srcKeyframe);
         KisScalarKeyframe *keyframe = new KisScalarKeyframe(srcKeyframe, this);
         keyframe->setTime(time);
         return toQShared(keyframe);
     } else {
         return createKeyframe(time, 0, parentCommand);
     }
 }
 
 KisKeyframeSP KisScalarKeyframeChannel::createKeyframe(int time, qreal value, KUndo2Command *parentCommand)
 {
     Q_UNUSED(parentCommand);
     KisScalarKeyframe *keyframe = new KisScalarKeyframe(this, time, value);
     keyframe->setInterpolationMode(m_d->defaultInterpolation);
     return toQShared(keyframe);
 }
 
 void KisScalarKeyframeChannel::destroyKeyframe(KisKeyframeSP key, KUndo2Command *parentCommand)
 {
     Q_UNUSED(parentCommand);
     Q_UNUSED(key);
 }
 
 void KisScalarKeyframeChannel::uploadExternalKeyframe(KisKeyframeChannel *srcChannel, int srcTime, KisKeyframeSP dstFrame)
 {
     KisScalarKeyframeChannel *srcScalarChannel = dynamic_cast<KisScalarKeyframeChannel*>(srcChannel);
     KIS_ASSERT_RECOVER_RETURN(srcScalarChannel);
 
     KisKeyframeSP srcFrame = srcScalarChannel->keyframeAt(srcTime);
     KIS_ASSERT_RECOVER_RETURN(srcFrame);
 
     KisScalarKeyframe *dstKey = dynamic_cast<KisScalarKeyframe*>(dstFrame.data());
     dstKey->value = srcChannel->scalarValue(srcFrame);
     notifyKeyframeChanged(dstFrame);
 }
 
 QRect KisScalarKeyframeChannel::affectedRect(KisKeyframeSP key)
 {
     Q_UNUSED(key);
 
     if (node()) {
         return node()->extent();
     } else {
         return QRect();
     }
 }
 
 void KisScalarKeyframeChannel::saveKeyframe(KisKeyframeSP keyframe, QDomElement keyframeElement, const QString &layerFilename)
 {
     Q_UNUSED(layerFilename);
     keyframeElement.setAttribute("value", KisDomUtils::toString(scalarValue(keyframe)));
 
     QString interpolationMode;
     if (keyframe->interpolationMode() == KisKeyframe::Constant) interpolationMode = "constant";
     if (keyframe->interpolationMode() == KisKeyframe::Linear) interpolationMode = "linear";
     if (keyframe->interpolationMode() == KisKeyframe::Bezier) interpolationMode = "bezier";
 
     QString tangentsMode;
     if (keyframe->tangentsMode() == KisKeyframe::Smooth) tangentsMode = "smooth";
     if (keyframe->tangentsMode() == KisKeyframe::Sharp) tangentsMode = "sharp";
 
     keyframeElement.setAttribute("interpolation", interpolationMode);
     keyframeElement.setAttribute("tangents", tangentsMode);
     KisDomUtils::saveValue(&keyframeElement, "leftTangent", keyframe->leftTangent());
     KisDomUtils::saveValue(&keyframeElement, "rightTangent", keyframe->rightTangent());
 }
 
 KisKeyframeSP KisScalarKeyframeChannel::loadKeyframe(const QDomElement &keyframeNode)
 {
-    int time = keyframeNode.toElement().attribute("time").toUInt();
+    int time = keyframeNode.toElement().attribute("time").toInt();
+    workaroundBrokenFrameTimeBug(&time);
+
     qreal value = KisDomUtils::toDouble(keyframeNode.toElement().attribute("value"));
 
     KUndo2Command tempParentCommand;
     KisKeyframeSP keyframe = createKeyframe(time, KisKeyframeSP(), &tempParentCommand);
     setScalarValue(keyframe, value);
 
     QString interpolationMode = keyframeNode.toElement().attribute("interpolation");
     if (interpolationMode == "constant") {
         keyframe->setInterpolationMode(KisKeyframe::Constant);
     } else if (interpolationMode == "linear") {
         keyframe->setInterpolationMode(KisKeyframe::Linear);
     } else if (interpolationMode == "bezier") {
         keyframe->setInterpolationMode(KisKeyframe::Bezier);
     }
 
     QString tangentsMode = keyframeNode.toElement().attribute("tangents");
     if (tangentsMode == "smooth") {
         keyframe->setTangentsMode(KisKeyframe::Smooth);
     } else if (tangentsMode == "sharp") {
         keyframe->setTangentsMode(KisKeyframe::Sharp);
     }
 
     QPointF leftTangent;
     QPointF rightTangent;
     KisDomUtils::loadValue(keyframeNode, "leftTangent", &leftTangent);
     KisDomUtils::loadValue(keyframeNode, "rightTangent", &rightTangent);
     keyframe->setInterpolationTangents(leftTangent, rightTangent);
 
     return keyframe;
 }
 
 void KisScalarKeyframeChannel::notifyKeyframeChanged(KisKeyframeSP keyframe)
 {
     QRect rect = affectedRect(keyframe);
     KisTimeRange range = affectedFrames(keyframe->time());
 
     requestUpdate(range, rect);
 
     emit sigKeyframeChanged(keyframe);
 }
diff --git a/libs/image/kis_selection_based_layer.cpp b/libs/image/kis_selection_based_layer.cpp
index ea1eb6c2a0..7a785d17e7 100644
--- a/libs/image/kis_selection_based_layer.cpp
+++ b/libs/image/kis_selection_based_layer.cpp
@@ -1,353 +1,353 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2005 C. Boemann <cbo@boemann.dk>
  *  Copyright (c) 2009 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_selection_based_layer.h"
 
 #include <klocalizedstring.h>
 #include "kis_debug.h"
 
 #include <KoCompositeOpRegistry.h>
 
 #include "kis_image.h"
 #include "kis_painter.h"
 #include "kis_default_bounds.h"
 
 #include "kis_selection.h"
 #include "kis_pixel_selection.h"
 #include "filter/kis_filter_configuration.h"
 #include "filter/kis_filter_registry.h"
 #include "filter/kis_filter.h"
 
 #include "kis_raster_keyframe_channel.h"
 
 
 struct Q_DECL_HIDDEN KisSelectionBasedLayer::Private
 {
 public:
     Private() : useSelectionInProjection(true) {}
     Private(const Private &rhs) : useSelectionInProjection(rhs.useSelectionInProjection) {}
 
     KisSelectionSP selection;
     KisPaintDeviceSP paintDevice;
     bool useSelectionInProjection;
 };
 
 
 KisSelectionBasedLayer::KisSelectionBasedLayer(KisImageWSP image,
         const QString &name,
         KisSelectionSP selection,
         KisFilterConfigurationSP filterConfig,
         bool useGeneratorRegistry)
         : KisLayer(image.data(), name, OPACITY_OPAQUE_U8),
           KisNodeFilterInterface(filterConfig, useGeneratorRegistry),
           m_d(new Private())
 {
     if (!selection) {
         initSelection();
     } else {
         setInternalSelection(selection);
     }
 
     KisImageSP imageSP = image.toStrongRef();
     if (!imageSP) {
         return;
     }
     m_d->paintDevice = KisPaintDeviceSP(new KisPaintDevice(this, imageSP->colorSpace(), KisDefaultBoundsSP(new KisDefaultBounds(image))));
     connect(imageSP.data(), SIGNAL(sigSizeChanged(QPointF,QPointF)), SLOT(slotImageSizeChanged()));
 }
 
 KisSelectionBasedLayer::KisSelectionBasedLayer(const KisSelectionBasedLayer& rhs)
         : KisLayer(rhs)
         , KisIndirectPaintingSupport()
         , KisNodeFilterInterface(rhs)
         , m_d(new Private(*rhs.m_d))
 {
     setInternalSelection(rhs.m_d->selection);
 
     m_d->paintDevice = new KisPaintDevice(*rhs.m_d->paintDevice.data());
 }
 
 
 KisSelectionBasedLayer::~KisSelectionBasedLayer()
 {
     delete m_d;
 }
 
 void KisSelectionBasedLayer::initSelection()
 {
     m_d->selection = KisSelectionSP(new KisSelection(KisDefaultBoundsSP(new KisDefaultBounds(image()))));
     m_d->selection->pixelSelection()->setDefaultPixel(KoColor(Qt::white, m_d->selection->pixelSelection()->colorSpace()));
     m_d->selection->setParentNode(this);
     m_d->selection->updateProjection();
 }
 
 void KisSelectionBasedLayer::slotImageSizeChanged()
 {
     if (m_d->selection) {
         /**
          * Make sure exactBounds() of the selection got recalculated after
          * the image changed
          */
         m_d->selection->pixelSelection()->setDirty();
         setDirty();
     }
 }
 
 void KisSelectionBasedLayer::setImage(KisImageWSP image)
 {
     m_d->paintDevice->setDefaultBounds(KisDefaultBoundsSP(new KisDefaultBounds(image)));
     KisLayer::setImage(image);
 
     connect(image.data(), SIGNAL(sigSizeChanged(QPointF,QPointF)), SLOT(slotImageSizeChanged()));
 }
 
 bool KisSelectionBasedLayer::allowAsChild(KisNodeSP node) const
 {
     return node->inherits("KisMask");
 }
 
 
 KisPaintDeviceSP KisSelectionBasedLayer::original() const
 {
     return m_d->paintDevice;
 }
 KisPaintDeviceSP KisSelectionBasedLayer::paintDevice() const
 {
     return m_d->selection->pixelSelection();
 }
 
 
 bool KisSelectionBasedLayer::needProjection() const
 {
     return m_d->selection;
 }
 
 void KisSelectionBasedLayer::setUseSelectionInProjection(bool value) const
 {
     m_d->useSelectionInProjection = value;
 }
 
 KisSelectionSP KisSelectionBasedLayer::fetchComposedInternalSelection(const QRect &rect) const
 {
     if (!m_d->selection) return KisSelectionSP();
     m_d->selection->updateProjection(rect);
 
     KisSelectionSP tempSelection = m_d->selection;
 
     KisIndirectPaintingSupport::ReadLocker l(this);
 
     if (hasTemporaryTarget()) {
         /**
          * Cloning a selection with COW
          * FIXME: check whether it's faster than usual bitBlt'ing
          */
         tempSelection = new KisSelection(*tempSelection);
 
         KisPainter gc2(tempSelection->pixelSelection());
         setupTemporaryPainter(&gc2);
         gc2.bitBlt(rect.topLeft(), temporaryTarget(), rect);
     }
 
     return tempSelection;
 }
 
 void KisSelectionBasedLayer::copyOriginalToProjection(const KisPaintDeviceSP original,
         KisPaintDeviceSP projection,
         const QRect& rect) const
 {
     KisSelectionSP tempSelection;
 
     if (m_d->useSelectionInProjection) {
         tempSelection = fetchComposedInternalSelection(rect);
 
         /**
          * When we paint with a selection, the deselected areas will *not* be
          * overwritten by copyAreaOptimized(), so we need to clear them beforehand
          */
         projection->clear(rect);
     }
 
     KisPainter::copyAreaOptimized(rect.topLeft(), original, projection, rect, tempSelection);
 }
 
 QRect KisSelectionBasedLayer::cropChangeRectBySelection(const QRect &rect) const
 {
     return m_d->selection ?
         rect & m_d->selection->selectedRect() :
         rect;
 }
 
 QRect KisSelectionBasedLayer::needRect(const QRect &rect, PositionToFilthy pos) const
 {
     Q_UNUSED(pos);
     return rect;
 }
 
 void KisSelectionBasedLayer::resetCache()
 {
     KisImageSP imageSP = image().toStrongRef();
     if (!imageSP) {
         return;
     }
 
     if (!m_d->paintDevice || *m_d->paintDevice->colorSpace() != *imageSP->colorSpace()) {
         m_d->paintDevice = KisPaintDeviceSP(new KisPaintDevice(KisNodeWSP(this), imageSP->colorSpace(), new KisDefaultBounds(image())));
     } else {
         m_d->paintDevice->clear();
     }
 }
 
 KisSelectionSP KisSelectionBasedLayer::internalSelection() const
 {
     return m_d->selection;
 }
 
 void KisSelectionBasedLayer::setInternalSelection(KisSelectionSP selection)
 {
     if (selection) {
         m_d->selection = new KisSelection(*selection.data());
         m_d->selection->setParentNode(this);
+        m_d->selection->setDefaultBounds(new KisDefaultBounds(image()));
         m_d->selection->updateProjection();
 
         KisPixelSelectionSP pixelSelection = m_d->selection->pixelSelection();
         if (pixelSelection->framesInterface()) {
             addKeyframeChannel(pixelSelection->keyframeChannel());
             enableAnimation();
         }
 
+        KisImageSP imageSP = image().toStrongRef();
+        KIS_SAFE_ASSERT_RECOVER_RETURN(imageSP);
+
+        if (m_d->selection->pixelSelection()->defaultBounds()->bounds() != imageSP->bounds()) {
+            qWarning() << "WARNING: KisSelectionBasedLayer::setInternalSelection"
+                       << "New selection has suspicious default bounds";
+            qWarning() << "WARNING:" << ppVar(m_d->selection->pixelSelection()->defaultBounds()->bounds());
+            qWarning() << "WARNING:" << ppVar(imageSP->bounds());
+        }
+
     } else {
         m_d->selection = 0;
     }
-
-    KisImageSP imageSP = image().toStrongRef();
-    if (!imageSP) {
-        return;
-    }
-    if (selection->pixelSelection()->defaultBounds()->bounds() != imageSP->bounds()) {
-        qWarning() << "WARNING: KisSelectionBasedLayer::setInternalSelection"
-                   << "New selection has suspicious default bounds";
-        qWarning() << "WARNING:" << ppVar(selection->pixelSelection()->defaultBounds()->bounds());
-        qWarning() << "WARNING:" << ppVar(imageSP->bounds());
-    }
 }
 
 qint32 KisSelectionBasedLayer::x() const
 {
     return m_d->selection ? m_d->selection->x() : 0;
 }
 
 qint32 KisSelectionBasedLayer::y() const
 {
     return m_d->selection ? m_d->selection->y() : 0;
 }
 
 void KisSelectionBasedLayer::setX(qint32 x)
 {
     if (m_d->selection) {
         m_d->selection->setX(x);
     }
 }
 
 void KisSelectionBasedLayer::setY(qint32 y)
 {
     if (m_d->selection) {
         m_d->selection->setY(y);
     }
 }
 
 KisKeyframeChannel *KisSelectionBasedLayer::requestKeyframeChannel(const QString &id)
 {
     if (id == KisKeyframeChannel::Content.id()) {
         KisRasterKeyframeChannel *contentChannel = m_d->selection->pixelSelection()->createKeyframeChannel(KisKeyframeChannel::Content);
         contentChannel->setFilenameSuffix(".pixelselection");
         return contentChannel;
     }
 
     return KisLayer::requestKeyframeChannel(id);
 }
 
 void KisSelectionBasedLayer::setDirty()
 {
     Q_ASSERT(image());
     KisImageSP imageSP = image().toStrongRef();
     if (!imageSP) {
         return;
     }
     setDirty(imageSP->bounds());
 }
 
 QRect KisSelectionBasedLayer::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 {
         KisImageSP image = this->image().toStrongRef();
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(image, QRect());
         resultRect = image->bounds();
     }
 
     return resultRect;
 }
 
 QRect KisSelectionBasedLayer::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 {
         KisImageSP image = this->image().toStrongRef();
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(image, QRect());
         resultRect = image->bounds();
     }
 
     return resultRect;
 }
 
 QImage KisSelectionBasedLayer::createThumbnail(qint32 w, qint32 h)
 {
     KisSelectionSP originalSelection = internalSelection();
     KisPaintDeviceSP originalDevice = original();
 
     return originalDevice && originalSelection ?
            originalDevice->createThumbnail(w, h, 1,
                                            KoColorConversionTransformation::internalRenderingIntent(),
                                            KoColorConversionTransformation::internalConversionFlags()) :
            QImage();
 }
 
diff --git a/libs/image/kis_update_job_item.h b/libs/image/kis_update_job_item.h
index 01f7947545..a00ef67c75 100644
--- a/libs/image/kis_update_job_item.h
+++ b/libs/image/kis_update_job_item.h
@@ -1,258 +1,251 @@
 /*
  *  Copyright (c) 2011 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KIS_UPDATE_JOB_ITEM_H
 #define __KIS_UPDATE_JOB_ITEM_H
 
 #include <atomic>
 
 #include <QRunnable>
 #include <QReadWriteLock>
 
 #include "kis_stroke_job.h"
 #include "kis_spontaneous_job.h"
 #include "kis_base_rects_walker.h"
 #include "kis_async_merger.h"
+#include "kis_updater_context.h"
 
 
 class KisUpdateJobItem :  public QObject, public QRunnable
 {
     Q_OBJECT
 public:
     enum class Type : int {
         EMPTY = 0,
         WAITING,
         MERGE,
         STROKE,
         SPONTANEOUS
     };
 
 public:
-    KisUpdateJobItem(QReadWriteLock *exclusiveJobLock)
-        : m_exclusiveJobLock(exclusiveJobLock),
+    KisUpdateJobItem(KisUpdaterContext *updaterContext)
+        : m_updaterContext(updaterContext),
           m_atomicType(Type::EMPTY),
           m_runnableJob(0)
     {
         setAutoDelete(false);
         KIS_SAFE_ASSERT_RECOVER_NOOP(m_atomicType.is_lock_free());
     }
     ~KisUpdateJobItem() override
     {
         delete m_runnableJob;
     }
 
     void run() override {
         if (!isRunning()) return;
 
         /**
          * Here we break the idea of QThreadPool a bit. Ideally, we should split the
          * jobs into distinct QRunnable objects and pass all of them to QThreadPool.
          * That is a nice idea, but it doesn't work well when the jobs are small enough
          * and the number of available cores is high (>4 cores). It this case the
          * threads just tend to execute the job very quickly and go to sleep, which is
          * an expensive operation.
          *
          * To overcome this problem we try to bulk-process the jobs. In sigJobFinished()
          * signal (which is DirectConnection), the context may add the job to ourselves(!!!),
          * so we switch from "done" state into "running" again.
          */
 
         while (1) {
             KIS_SAFE_ASSERT_RECOVER_RETURN(isRunning());
 
             if(m_exclusive) {
-                m_exclusiveJobLock->lockForWrite();
+                m_updaterContext->m_exclusiveJobLock.lockForWrite();
             } else {
-                m_exclusiveJobLock->lockForRead();
+                m_updaterContext->m_exclusiveJobLock.lockForRead();
             }
 
             if(m_atomicType == Type::MERGE) {
                 runMergeJob();
             } else {
                 KIS_ASSERT(m_atomicType == Type::STROKE ||
                            m_atomicType == Type::SPONTANEOUS);
 
                 m_runnableJob->run();
             }
 
             setDone();
 
 
-            emit sigDoSomeUsefulWork();
+            m_updaterContext->doSomeUsefulWork();
 
             // may flip the current state from Waiting -> Running again
-            emit sigJobFinished();
+            m_updaterContext->jobFinished();
 
-            m_exclusiveJobLock->unlock();
+            m_updaterContext->m_exclusiveJobLock.unlock();
 
             // try to exit the loop. Please note, that no one can flip the state from
             // WAITING to EMPTY except ourselves!
             Type expectedValue = Type::WAITING;
             if (m_atomicType.compare_exchange_strong(expectedValue, Type::EMPTY)) {
                 break;
             }
         }
     }
 
     inline void runMergeJob() {
         KIS_SAFE_ASSERT_RECOVER_RETURN(m_atomicType == Type::MERGE);
         KIS_SAFE_ASSERT_RECOVER_RETURN(m_walker);
         // dbgKrita << "Executing merge job" << m_walker->changeRect()
         //          << "on thread" << QThread::currentThreadId();
         m_merger.startMerge(*m_walker);
 
         QRect changeRect = m_walker->changeRect();
-        emit sigContinueUpdate(changeRect);
+        m_updaterContext->continueUpdate(changeRect);
     }
 
     // return true if the thread should actually be started
     inline bool setWalker(KisBaseRectsWalkerSP walker) {
         KIS_ASSERT(m_atomicType <= Type::WAITING);
 
         m_accessRect = walker->accessRect();
         m_changeRect = walker->changeRect();
         m_walker = walker;
 
         m_exclusive = false;
         m_runnableJob = 0;
 
         const Type oldState = m_atomicType.exchange(Type::MERGE);
         return oldState == Type::EMPTY;
     }
 
     // return true if the thread should actually be started
     inline bool setStrokeJob(KisStrokeJob *strokeJob) {
         KIS_ASSERT(m_atomicType <= Type::WAITING);
 
         m_runnableJob = strokeJob;
         m_strokeJobSequentiality = strokeJob->sequentiality();
 
         m_exclusive = strokeJob->isExclusive();
         m_walker = 0;
         m_accessRect = m_changeRect = QRect();
 
         const Type oldState = m_atomicType.exchange(Type::STROKE);
         return oldState == Type::EMPTY;
     }
 
     // return true if the thread should actually be started
     inline bool setSpontaneousJob(KisSpontaneousJob *spontaneousJob) {
         KIS_ASSERT(m_atomicType <= Type::WAITING);
 
         m_runnableJob = spontaneousJob;
 
         m_exclusive = spontaneousJob->isExclusive();
         m_walker = 0;
         m_accessRect = m_changeRect = QRect();
 
         const Type oldState = m_atomicType.exchange(Type::SPONTANEOUS);
         return oldState == Type::EMPTY;
     }
 
     inline void setDone() {
         m_walker = 0;
         delete m_runnableJob;
         m_runnableJob = 0;
         m_atomicType = Type::WAITING;
     }
 
     inline bool isRunning() const {
         return m_atomicType >= Type::MERGE;
     }
 
     inline Type type() const {
         return m_atomicType;
     }
 
     inline const QRect& accessRect() const {
         return m_accessRect;
     }
 
     inline const QRect& changeRect() const {
         return m_changeRect;
     }
 
     inline KisStrokeJobData::Sequentiality strokeJobSequentiality() const {
         return m_strokeJobSequentiality;
     }
 
-Q_SIGNALS:
-    void sigContinueUpdate(const QRect& rc);
-    void sigDoSomeUsefulWork();
-    void sigJobFinished();
-
 private:
     /**
      * Open walker and stroke job for the testing suite.
      * Please, do not use it in production code.
      */
     friend class KisSimpleUpdateQueueTest;
     friend class KisStrokesQueueTest;
     friend class KisUpdateSchedulerTest;
     friend class KisTestableUpdaterContext;
 
     inline KisBaseRectsWalkerSP walker() const {
         return m_walker;
     }
 
     inline KisStrokeJob* strokeJob() const {
         KisStrokeJob *job = dynamic_cast<KisStrokeJob*>(m_runnableJob);
         Q_ASSERT(job);
 
         return job;
     }
 
     inline void testingSetDone() {
         setDone();
     }
 
 private:
-    /**
-     * \see KisUpdaterContext::m_exclusiveJobLock
-     */
-    QReadWriteLock *m_exclusiveJobLock;
+    KisUpdaterContext *m_updaterContext;
 
     bool m_exclusive;
 
     std::atomic<Type> m_atomicType;
 
     volatile KisStrokeJobData::Sequentiality m_strokeJobSequentiality;
 
     /**
      * Runnable jobs part
      * The job is owned by the context and deleted after completion
      */
     KisRunnable *m_runnableJob;
 
     /**
      * Merge jobs part
      */
 
     KisBaseRectsWalkerSP m_walker;
     KisAsyncMerger m_merger;
 
     /**
      * These rects cache actual values from the walker
      * to eliminate concurrent access to a walker structure
      */
     QRect m_accessRect;
     QRect m_changeRect;
 };
 
 
 #endif /* __KIS_UPDATE_JOB_ITEM_H */
diff --git a/libs/image/kis_update_scheduler.cpp b/libs/image/kis_update_scheduler.cpp
index 68b5568ff7..3c1e3534da 100644
--- a/libs/image/kis_update_scheduler.cpp
+++ b/libs/image/kis_update_scheduler.cpp
@@ -1,503 +1,493 @@
 /*
  *  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(&m_d->updaterContext, SIGNAL(sigContinueUpdate(const QRect&)),
-            SLOT(continueUpdate(const QRect&)),
-            Qt::DirectConnection);
-
-    connect(&m_d->updaterContext, SIGNAL(sigDoSomeUsefulWork()),
-            SLOT(doSomeUsefulWork()), Qt::DirectConnection);
-
-    connect(&m_d->updaterContext, SIGNAL(sigSpareThreadAppeared()),
-            SLOT(spareThreadAppeared()), Qt::DirectConnection);
-
     connect(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();
 }
 
 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();
     // m_d->updaterContext = new KisTestableUpdaterContext(threadCount);
 
     connectSignals();
 }
 
 KisTestableUpdaterContext* KisTestableUpdateScheduler::updaterContext()
 {
     return dynamic_cast<KisTestableUpdaterContext*>(&m_d->updaterContext);
 }
 
 KisTestableSimpleUpdateQueue* KisTestableUpdateScheduler::updateQueue()
 {
     return dynamic_cast<KisTestableSimpleUpdateQueue*>(&m_d->updatesQueue);
 }
diff --git a/libs/image/kis_update_scheduler.h b/libs/image/kis_update_scheduler.h
index 85fcc204a5..5b08e619c3 100644
--- a/libs/image/kis_update_scheduler.h
+++ b/libs/image/kis_update_scheduler.h
@@ -1,253 +1,252 @@
 /*
  *  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);
 
     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 Q_SLOTS:
-    void continueUpdate(const QRect &rect);
-    void doSomeUsefulWork();
-    void spareThreadAppeared();
-
 private:
     friend class UpdatesBlockTester;
     bool haveUpdatesRunning();
     void tryProcessUpdatesQueue();
     void wakeUpWaitingThreads();
 
     void progressUpdate();
 
 protected:
     struct Private;
     Private * const m_d;
 };
 
 
 class KisTestableUpdaterContext;
 class KisTestableSimpleUpdateQueue;
 
 class KRITAIMAGE_EXPORT KisTestableUpdateScheduler : public KisUpdateScheduler
 {
 public:
     KisTestableUpdateScheduler(KisProjectionUpdateListener *projectionUpdateListener,
                                qint32 threadCount);
 
     KisTestableUpdaterContext* updaterContext();
     KisTestableSimpleUpdateQueue* updateQueue();
     using KisUpdateScheduler::processQueues;
 };
 
 #endif /* __KIS_UPDATE_SCHEDULER_H */
 
diff --git a/libs/image/kis_updater_context.cpp b/libs/image/kis_updater_context.cpp
index 222f95d68c..0de8cdc89f 100644
--- a/libs/image/kis_updater_context.cpp
+++ b/libs/image/kis_updater_context.cpp
@@ -1,322 +1,321 @@
 /*
  *  Copyright (c) 2010 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_updater_context.h"
 
 #include <QThread>
 #include <QThreadPool>
 
 #include "kis_update_job_item.h"
 #include "kis_stroke_job.h"
 
 const int KisUpdaterContext::useIdealThreadCountTag = -1;
 
 KisUpdaterContext::KisUpdaterContext(qint32 threadCount, QObject *parent)
-    : QObject(parent)
+    : QObject(parent), m_scheduler(qobject_cast<KisUpdateScheduler *>(parent))
 {
     if(threadCount <= 0) {
         threadCount = QThread::idealThreadCount();
         threadCount = threadCount > 0 ? threadCount : 1;
     }
 
     setThreadsLimit(threadCount);
 }
 
 KisUpdaterContext::~KisUpdaterContext()
 {
     m_threadPool.waitForDone();
     for(qint32 i = 0; i < m_jobs.size(); i++)
         delete m_jobs[i];
 }
 
 void KisUpdaterContext::getJobsSnapshot(qint32 &numMergeJobs,
                                         qint32 &numStrokeJobs)
 {
     numMergeJobs = 0;
     numStrokeJobs = 0;
 
     Q_FOREACH (const KisUpdateJobItem *item, m_jobs) {
         if(item->type() == KisUpdateJobItem::Type::MERGE ||
            item->type() == KisUpdateJobItem::Type::SPONTANEOUS) {
             numMergeJobs++;
         }
         else if(item->type() == KisUpdateJobItem::Type::STROKE) {
             numStrokeJobs++;
         }
     }
 }
 
 KisUpdaterContextSnapshotEx KisUpdaterContext::getContextSnapshotEx() const
 {
     KisUpdaterContextSnapshotEx state = ContextEmpty;
 
     Q_FOREACH (const KisUpdateJobItem *item, m_jobs) {
         if (item->type() == KisUpdateJobItem::Type::MERGE ||
             item->type() == KisUpdateJobItem::Type::SPONTANEOUS) {
             state |= HasMergeJob;
         } else if(item->type() == KisUpdateJobItem::Type::STROKE) {
             switch (item->strokeJobSequentiality()) {
             case KisStrokeJobData::SEQUENTIAL:
                 state |= HasSequentialJob;
                 break;
             case KisStrokeJobData::CONCURRENT:
                 state |= HasConcurrentJob;
                 break;
             case KisStrokeJobData::BARRIER:
                 state |= HasBarrierJob;
                 break;
             case KisStrokeJobData::UNIQUELY_CONCURRENT:
                 state |= HasUniquelyConcurrentJob;
                 break;
             }
         }
     }
 
     return state;
 }
 
 int KisUpdaterContext::currentLevelOfDetail() const
 {
     return m_lodCounter.readLod();
 }
 
 bool KisUpdaterContext::hasSpareThread()
 {
     bool found = false;
 
     Q_FOREACH (const KisUpdateJobItem *item, m_jobs) {
         if(!item->isRunning()) {
             found = true;
             break;
         }
     }
     return found;
 }
 
 bool KisUpdaterContext::isJobAllowed(KisBaseRectsWalkerSP walker)
 {
     int lod = this->currentLevelOfDetail();
     if (lod >= 0 && walker->levelOfDetail() != lod) return false;
 
     bool intersects = false;
 
     Q_FOREACH (const KisUpdateJobItem *item, m_jobs) {
         if(item->isRunning() && walkerIntersectsJob(walker, item)) {
             intersects = true;
             break;
         }
     }
 
     return !intersects;
 }
 
 /**
  * NOTE: In theory, isJobAllowed() and addMergeJob() should be merged into
  * one atomic method like `bool push()`, because this implementation
  * of KisUpdaterContext will not work in case of multiple
  * producers. But currently we have only one producer (one thread
  * in a time), that is guaranteed by the lock()/unlock() pair in
  * KisAbstractUpdateQueue::processQueue.
  */
 void KisUpdaterContext::addMergeJob(KisBaseRectsWalkerSP walker)
 {
     m_lodCounter.addLod(walker->levelOfDetail());
     qint32 jobIndex = findSpareThread();
     Q_ASSERT(jobIndex >= 0);
 
     const bool shouldStartThread = m_jobs[jobIndex]->setWalker(walker);
 
     // it might happen that we call this function from within
     // the thread itself, right when it finished its work
     if (shouldStartThread) {
         m_threadPool.start(m_jobs[jobIndex]);
     }
 }
 
 /**
  * This variant is for use in a testing suite only
  */
 void KisTestableUpdaterContext::addMergeJob(KisBaseRectsWalkerSP walker)
 {
     m_lodCounter.addLod(walker->levelOfDetail());
     qint32 jobIndex = findSpareThread();
     Q_ASSERT(jobIndex >= 0);
 
     const bool shouldStartThread = m_jobs[jobIndex]->setWalker(walker);
 
     // HINT: Not calling start() here
     Q_UNUSED(shouldStartThread);
 }
 
 void KisUpdaterContext::addStrokeJob(KisStrokeJob *strokeJob)
 {
     m_lodCounter.addLod(strokeJob->levelOfDetail());
     qint32 jobIndex = findSpareThread();
     Q_ASSERT(jobIndex >= 0);
 
     const bool shouldStartThread = m_jobs[jobIndex]->setStrokeJob(strokeJob);
 
     // it might happen that we call this function from within
     // the thread itself, right when it finished its work
     if (shouldStartThread) {
         m_threadPool.start(m_jobs[jobIndex]);
     }
 }
 
 /**
  * This variant is for use in a testing suite only
  */
 void KisTestableUpdaterContext::addStrokeJob(KisStrokeJob *strokeJob)
 {
     m_lodCounter.addLod(strokeJob->levelOfDetail());
     qint32 jobIndex = findSpareThread();
     Q_ASSERT(jobIndex >= 0);
 
     const bool shouldStartThread = m_jobs[jobIndex]->setStrokeJob(strokeJob);
 
     // HINT: Not calling start() here
     Q_UNUSED(shouldStartThread);
 }
 
 void KisUpdaterContext::addSpontaneousJob(KisSpontaneousJob *spontaneousJob)
 {
     m_lodCounter.addLod(spontaneousJob->levelOfDetail());
     qint32 jobIndex = findSpareThread();
     Q_ASSERT(jobIndex >= 0);
 
     const bool shouldStartThread = m_jobs[jobIndex]->setSpontaneousJob(spontaneousJob);
 
     // it might happen that we call this function from within
     // the thread itself, right when it finished its work
     if (shouldStartThread) {
         m_threadPool.start(m_jobs[jobIndex]);
     }
 }
 
 /**
  * This variant is for use in a testing suite only
  */
 void KisTestableUpdaterContext::addSpontaneousJob(KisSpontaneousJob *spontaneousJob)
 {
     m_lodCounter.addLod(spontaneousJob->levelOfDetail());
     qint32 jobIndex = findSpareThread();
     Q_ASSERT(jobIndex >= 0);
 
     const bool shouldStartThread = m_jobs[jobIndex]->setSpontaneousJob(spontaneousJob);
 
     // HINT: Not calling start() here
     Q_UNUSED(shouldStartThread);
 }
 
 void KisUpdaterContext::waitForDone()
 {
     m_threadPool.waitForDone();
 }
 
 bool KisUpdaterContext::walkerIntersectsJob(KisBaseRectsWalkerSP walker,
                                             const KisUpdateJobItem* job)
 {
     return (walker->accessRect().intersects(job->changeRect())) ||
         (job->accessRect().intersects(walker->changeRect()));
 }
 
 qint32 KisUpdaterContext::findSpareThread()
 {
     for(qint32 i=0; i < m_jobs.size(); i++)
         if(!m_jobs[i]->isRunning())
             return i;
 
     return -1;
 }
 
-void KisUpdaterContext::slotJobFinished()
-{
-    m_lodCounter.removeLod();
-
-    // Be careful. This slot can be called asynchronously without locks.
-    emit sigSpareThreadAppeared();
-}
-
 void KisUpdaterContext::lock()
 {
     m_lock.lock();
 }
 
 void KisUpdaterContext::unlock()
 {
     m_lock.unlock();
 }
 
 void KisUpdaterContext::setThreadsLimit(int value)
 {
     m_threadPool.setMaxThreadCount(value);
 
     for (int i = 0; i < m_jobs.size(); i++) {
         KIS_SAFE_ASSERT_RECOVER_RETURN(!m_jobs[i]->isRunning());
         // don't delete the jobs until all of them are checked!
     }
 
     for (int i = 0; i < m_jobs.size(); i++) {
         delete m_jobs[i];
     }
 
     m_jobs.resize(value);
 
     for(qint32 i = 0; i < m_jobs.size(); i++) {
-        m_jobs[i] = new KisUpdateJobItem(&m_exclusiveJobLock);
-        connect(m_jobs[i], SIGNAL(sigContinueUpdate(const QRect&)),
-                SIGNAL(sigContinueUpdate(const QRect&)),
-                Qt::DirectConnection);
-
-        connect(m_jobs[i], SIGNAL(sigDoSomeUsefulWork()),
-                SIGNAL(sigDoSomeUsefulWork()), Qt::DirectConnection);
-
-        connect(m_jobs[i], SIGNAL(sigJobFinished()),
-                SLOT(slotJobFinished()), Qt::DirectConnection);
+        m_jobs[i] = new KisUpdateJobItem(this);
     }
 }
 
 int KisUpdaterContext::threadsLimit() const
 {
     KIS_SAFE_ASSERT_RECOVER_NOOP(m_jobs.size() == m_threadPool.maxThreadCount());
     return m_jobs.size();
 }
 
+void KisUpdaterContext::continueUpdate(const QRect& rc)
+{
+    if (m_scheduler) m_scheduler->continueUpdate(rc);
+}
+
+void KisUpdaterContext::doSomeUsefulWork()
+{
+    if (m_scheduler) m_scheduler->doSomeUsefulWork();
+}
+
+void KisUpdaterContext::jobFinished()
+{
+    m_lodCounter.removeLod();
+    if (m_scheduler) m_scheduler->spareThreadAppeared();
+}
+
 KisTestableUpdaterContext::KisTestableUpdaterContext(qint32 threadCount)
     : KisUpdaterContext(threadCount)
 {
 }
 
 KisTestableUpdaterContext::~KisTestableUpdaterContext() {
     clear();
 }
 
 const QVector<KisUpdateJobItem*> KisTestableUpdaterContext::getJobs()
 {
     return m_jobs;
 }
 
 void KisTestableUpdaterContext::clear()
 {
     Q_FOREACH (KisUpdateJobItem *item, m_jobs) {
         item->testingSetDone();
     }
 
     m_lodCounter.testingClear();
 }
 
diff --git a/libs/image/kis_updater_context.h b/libs/image/kis_updater_context.h
index 15421d6516..2e6b4c7d29 100644
--- a/libs/image/kis_updater_context.h
+++ b/libs/image/kis_updater_context.h
@@ -1,195 +1,196 @@
 /*
  *  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_UPDATER_CONTEXT_H
 #define __KIS_UPDATER_CONTEXT_H
 
 #include <QObject>
 #include <QMutex>
 #include <QReadWriteLock>
 #include <QThreadPool>
 
 #include "kis_base_rects_walker.h"
 #include "kis_async_merger.h"
 #include "kis_lock_free_lod_counter.h"
 
 #include "KisUpdaterContextSnapshotEx.h"
+#include "kis_update_scheduler.h"
 
 class KisUpdateJobItem;
 class KisSpontaneousJob;
 class KisStrokeJob;
 
 class KRITAIMAGE_EXPORT KisUpdaterContext : public QObject
 {
     Q_OBJECT
 public:
     static const int useIdealThreadCountTag;
 
 public:
     KisUpdaterContext(qint32 threadCount = useIdealThreadCountTag, QObject *parent = 0);
     ~KisUpdaterContext() override;
 
 
     /**
      * Returns the number of currently running jobs of each type.
      * To use this information you should lock the context beforehand.
      *
      * \see lock()
      */
     void getJobsSnapshot(qint32 &numMergeJobs, qint32 &numStrokeJobs);
 
     KisUpdaterContextSnapshotEx getContextSnapshotEx() const;
 
     /**
      * Returns the current level of detail of all the running jobs in the
      * context. If there are no jobs, returns -1.
      */
     int currentLevelOfDetail() const;
 
     /**
      * Check whether there is a spare thread for running
      * one more job
      */
     bool hasSpareThread();
 
     /**
      * Checks whether the walker intersects with any
      * of currently executing walkers. If it does,
      * it is not allowed to go in. It should be called
      * with the lock held.
      *
      * \see lock()
      */
     bool isJobAllowed(KisBaseRectsWalkerSP walker);
 
     /**
      * Registers the job and starts executing it.
      * The caller must ensure that the context is locked
      * with lock(), job is allowed with isWalkerAllowed() and
      * there is a spare thread for running it with hasSpareThread()
      *
      * \see lock()
      * \see isWalkerAllowed()
      * \see hasSpareThread()
      */
     virtual void addMergeJob(KisBaseRectsWalkerSP walker);
 
     /**
      * Adds a stroke job to the context. The prerequisites are
      * the same as for addMergeJob()
      * \see addMergeJob()
      */
     virtual void addStrokeJob(KisStrokeJob *strokeJob);
 
 
     /**
      * Adds a spontaneous job to the context. The prerequisites are
      * the same as for addMergeJob()
      * \see addMergeJob()
      */
     virtual void addSpontaneousJob(KisSpontaneousJob *spontaneousJob);
 
     /**
      * Block execution of the caller until all the jobs are finished
      */
     void waitForDone();
 
     /**
      * Locks the context to guarantee an exclusive access
      * to the context
      */
     void lock();
 
     /**
      * Unlocks the context
      *
      * \see lock()
      */
     void unlock();
 
     /**
      * Set the number of threads available for this updater context
      * WARNING: one cannot change the number of threads if there is
      *          at least one job running in the context! So before
      *          calling this method make sure you do two things:
      *          1) barrierLock() the update scheduler
      *          2) lock() the context
      */
     void setThreadsLimit(int value);
 
     /**
      * Return the number of available threads in the context. Make sure you
      * lock the context before calling this function!
      */
     int threadsLimit() const;
 
+    void continueUpdate(const QRect& rc);
+    void doSomeUsefulWork();
+    void jobFinished();
 
-Q_SIGNALS:
-    void sigContinueUpdate(const QRect& rc);
-    void sigDoSomeUsefulWork();
-    void sigSpareThreadAppeared();
-
-protected Q_SLOTS:
-    void slotJobFinished();
+    friend class KisUpdateJobItem;
 
 protected:
     static bool walkerIntersectsJob(KisBaseRectsWalkerSP walker,
                                     const KisUpdateJobItem* job);
     qint32 findSpareThread();
 
 protected:
     /**
      * The lock is shared by all the child update job items.
      * When an item wants to run a usual (non-exclusive) job,
      * it locks the lock for read access. When an exclusive
      * access is requested, it locks it for write
      */
     QReadWriteLock m_exclusiveJobLock;
 
     QMutex m_lock;
     QVector<KisUpdateJobItem*> m_jobs;
     QThreadPool m_threadPool;
     KisLockFreeLodCounter m_lodCounter;
+    KisUpdateScheduler *m_scheduler;
 };
 
 class KRITAIMAGE_EXPORT KisTestableUpdaterContext : public KisUpdaterContext
 {
 public:
     /**
      * Creates an explicit number of threads
      */
     KisTestableUpdaterContext(qint32 threadCount);
     ~KisTestableUpdaterContext() override;
 
     /**
      * The only difference - it doesn't start execution
      * of the job
      */
     void addMergeJob(KisBaseRectsWalkerSP walker) override;
     void addStrokeJob(KisStrokeJob *strokeJob) override;
     void addSpontaneousJob(KisSpontaneousJob *spontaneousJob) override;
 
     const QVector<KisUpdateJobItem*> getJobs();
     void clear();
+
+    friend class KisUpdateJobItem;
 };
 
 
 
 
 #endif /* __KIS_UPDATER_CONTEXT_H */
 
diff --git a/libs/image/krita_utils.cpp b/libs/image/krita_utils.cpp
index 736cf27d2e..b1cf8e713a 100644
--- a/libs/image/krita_utils.cpp
+++ b/libs/image/krita_utils.cpp
@@ -1,478 +1,509 @@
 /*
  *  Copyright (c) 2011 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "krita_utils.h"
 
 #include <QtCore/qmath.h>
 
 #include <QRect>
 #include <QRegion>
 #include <QPainterPath>
 #include <QPolygonF>
 #include <QPen>
 #include <QPainter>
 
 #include "kis_algebra_2d.h"
 
 #include <KoColorSpaceRegistry.h>
 
 #include "kis_image_config.h"
 #include "kis_debug.h"
 #include "kis_node.h"
 #include "kis_sequential_iterator.h"
 #include "kis_random_accessor_ng.h"
 
 #include <KisRenderedDab.h>
 
 
 namespace KritaUtils
 {
 
     QSize optimalPatchSize()
     {
         KisImageConfig cfg(true);
         return QSize(cfg.updatePatchWidth(),
                      cfg.updatePatchHeight());
     }
 
     QVector<QRect> splitRectIntoPatches(const QRect &rc, const QSize &patchSize)
     {
         using namespace KisAlgebra2D;
 
 
         QVector<QRect> patches;
 
         const qint32 firstCol = divideFloor(rc.x(), patchSize.width());
         const qint32 firstRow = divideFloor(rc.y(), patchSize.height());
 
         // TODO: check if -1 is needed here
         const qint32 lastCol = divideFloor(rc.x() + rc.width(), patchSize.width());
         const qint32 lastRow = divideFloor(rc.y() + rc.height(), patchSize.height());
 
         for(qint32 i = firstRow; i <= lastRow; i++) {
             for(qint32 j = firstCol; j <= lastCol; j++) {
                 QRect maxPatchRect(j * patchSize.width(), i * patchSize.height(),
                                    patchSize.width(), patchSize.height());
                 QRect patchRect = rc & maxPatchRect;
 
                 if (!patchRect.isEmpty()) {
                     patches.append(patchRect);
                 }
             }
         }
 
         return patches;
     }
 
     QVector<QRect> splitRegionIntoPatches(const QRegion &region, const QSize &patchSize)
     {
         QVector<QRect> patches;
 
         Q_FOREACH (const QRect rect, region.rects()) {
             patches << KritaUtils::splitRectIntoPatches(rect, patchSize);
         }
 
         return patches;
     }
 
     bool checkInTriangle(const QRectF &rect,
                          const QPolygonF &triangle)
     {
         return triangle.intersected(rect).boundingRect().isValid();
     }
 
 
     QRegion KRITAIMAGE_EXPORT splitTriangles(const QPointF &center,
                                              const QVector<QPointF> &points)
     {
 
         Q_ASSERT(points.size());
         Q_ASSERT(!(points.size() & 1));
 
         QVector<QPolygonF> triangles;
         QRect totalRect;
 
         for (int i = 0; i < points.size(); i += 2) {
             QPolygonF triangle;
             triangle << center;
             triangle << points[i];
             triangle << points[i+1];
 
             totalRect |= triangle.boundingRect().toAlignedRect();
             triangles << triangle;
         }
 
 
         const int step = 64;
         const int right = totalRect.x() + totalRect.width();
         const int bottom = totalRect.y() + totalRect.height();
 
         QRegion dirtyRegion;
 
         for (int y = totalRect.y(); y < bottom;) {
             int nextY = qMin((y + step) & ~(step-1), bottom);
 
             for (int x = totalRect.x(); x < right;) {
                 int nextX = qMin((x + step) & ~(step-1), right);
 
                 QRect rect(x, y, nextX - x, nextY - y);
 
                 Q_FOREACH (const QPolygonF &triangle, triangles) {
                     if(checkInTriangle(rect, triangle)) {
                         dirtyRegion |= rect;
                         break;
                     }
                 }
 
                 x = nextX;
             }
             y = nextY;
         }
         return dirtyRegion;
     }
 
     QRegion KRITAIMAGE_EXPORT splitPath(const QPainterPath &path)
     {
         QRect totalRect = path.boundingRect().toAlignedRect();
 
         // adjust the rect for antialiasing to work
         totalRect = totalRect.adjusted(-1,-1,1,1);
 
         const int step = 64;
         const int right = totalRect.x() + totalRect.width();
         const int bottom = totalRect.y() + totalRect.height();
 
         QRegion dirtyRegion;
 
 
         for (int y = totalRect.y(); y < bottom;) {
             int nextY = qMin((y + step) & ~(step-1), bottom);
 
             for (int x = totalRect.x(); x < right;) {
                 int nextX = qMin((x + step) & ~(step-1), right);
 
                 QRect rect(x, y, nextX - x, nextY - y);
 
                 if(path.intersects(rect)) {
                     dirtyRegion |= rect;
                 }
 
                 x = nextX;
             }
             y = nextY;
         }
 
         return dirtyRegion;
     }
 
     QString KRITAIMAGE_EXPORT prettyFormatReal(qreal value)
     {
         return QString("%1").arg(value, 6, 'f', 1);
     }
 
     qreal KRITAIMAGE_EXPORT maxDimensionPortion(const QRectF &bounds, qreal portion, qreal minValue)
     {
         qreal maxDimension = qMax(bounds.width(), bounds.height());
         return qMax(portion * maxDimension, minValue);
     }
 
     bool tryMergePoints(QPainterPath &path,
                         const QPointF &startPoint,
                         const QPointF &endPoint,
                         qreal &distance,
                         qreal distanceThreshold,
                         bool lastSegment)
     {
         qreal length = (endPoint - startPoint).manhattanLength();
 
         if (lastSegment || length > distanceThreshold) {
             if (lastSegment) {
                 qreal wrappedLength =
                     (endPoint - QPointF(path.elementAt(0))).manhattanLength();
 
                 if (length < distanceThreshold ||
                     wrappedLength < distanceThreshold) {
 
                     return true;
                 }
             }
 
             distance = 0;
             return false;
         }
 
         distance += length;
 
         if (distance > distanceThreshold) {
             path.lineTo(endPoint);
             distance = 0;
         }
 
         return true;
     }
 
     QPainterPath trySimplifyPath(const QPainterPath &path, qreal lengthThreshold)
     {
         QPainterPath newPath;
         QPointF startPoint;
         qreal distance = 0;
 
         int count = path.elementCount();
         for (int i = 0; i < count; i++) {
             QPainterPath::Element e = path.elementAt(i);
             QPointF endPoint = QPointF(e.x, e.y);
 
             switch (e.type) {
             case QPainterPath::MoveToElement:
                 newPath.moveTo(endPoint);
                 break;
             case QPainterPath::LineToElement:
                 if (!tryMergePoints(newPath, startPoint, endPoint,
                                     distance, lengthThreshold, i == count - 1)) {
 
                     newPath.lineTo(endPoint);
                 }
                 break;
             case QPainterPath::CurveToElement: {
                 Q_ASSERT(i + 2 < count);
 
                 if (!tryMergePoints(newPath, startPoint, endPoint,
                                     distance, lengthThreshold, i == count - 1)) {
 
                     e = path.elementAt(i + 1);
                     Q_ASSERT(e.type == QPainterPath::CurveToDataElement);
                     QPointF ctrl1 = QPointF(e.x, e.y);
                     e = path.elementAt(i + 2);
                     Q_ASSERT(e.type == QPainterPath::CurveToDataElement);
                     QPointF ctrl2 = QPointF(e.x, e.y);
                     newPath.cubicTo(ctrl1, ctrl2, endPoint);
                 }
 
                 i += 2;
             }
             default:
                 ;
             }
             startPoint = endPoint;
         }
 
         return newPath;
     }
 
     QList<QPainterPath> splitDisjointPaths(const QPainterPath &path)
     {
         QList<QPainterPath> resultList;
         QList<QPolygonF> inputPolygons = path.toSubpathPolygons();
 
         Q_FOREACH (const QPolygonF &poly, inputPolygons) {
             QPainterPath testPath;
             testPath.addPolygon(poly);
 
             if (resultList.isEmpty()) {
                 resultList.append(testPath);
                 continue;
             }
 
             QPainterPath mergedPath = testPath;
 
             for (auto it = resultList.begin(); it != resultList.end(); /*noop*/) {
                 if (it->intersects(testPath)) {
                     mergedPath.addPath(*it);
                     it = resultList.erase(it);
                 } else {
                     ++it;
                 }
             }
 
             resultList.append(mergedPath);
         }
 
         return resultList;
     }
 
     quint8 mergeOpacity(quint8 opacity, quint8 parentOpacity)
     {
         if (parentOpacity != OPACITY_OPAQUE_U8) {
             opacity = (int(opacity) * parentOpacity) / OPACITY_OPAQUE_U8;
         }
         return opacity;
     }
 
     QBitArray mergeChannelFlags(const QBitArray &childFlags, const QBitArray &parentFlags)
     {
         QBitArray flags = childFlags;
 
         if (!flags.isEmpty() &&
             !parentFlags.isEmpty() &&
             flags.size() == parentFlags.size()) {
 
             flags &= parentFlags;
 
         } else if (!parentFlags.isEmpty()) {
             flags = parentFlags;
         }
 
         return flags;
     }
 
     bool compareChannelFlags(QBitArray f1, QBitArray f2)
     {
         if (f1.isNull() && f2.isNull()) return true;
 
         if (f1.isNull()) {
             f1.fill(true, f2.size());
         }
 
         if (f2.isNull()) {
             f2.fill(true, f1.size());
         }
 
         return f1 == f2;
     }
 
     QString KRITAIMAGE_EXPORT toLocalizedOnOff(bool value) {
         return value ? i18n("on") : i18n("off");
     }
 
     KisNodeSP nearestNodeAfterRemoval(KisNodeSP node)
     {
         KisNodeSP newNode = node->nextSibling();
 
         if (!newNode) {
             newNode = node->prevSibling();
         }
 
         if (!newNode) {
             newNode = node->parent();
         }
 
         return newNode;
     }
 
     void renderExactRect(QPainter *p, const QRect &rc)
     {
         p->drawRect(rc.adjusted(0,0,-1,-1));
     }
 
     void renderExactRect(QPainter *p, const QRect &rc, const QPen &pen)
     {
         QPen oldPen = p->pen();
         p->setPen(pen);
         renderExactRect(p, rc);
         p->setPen(oldPen);
     }
 
     QImage convertQImageToGrayA(const QImage &image)
     {
         QImage dstImage(image.size(), QImage::Format_ARGB32);
 
         // TODO: if someone feel bored, a more optimized version of this would be welcome
         const QSize size = image.size();
         for(int y = 0; y < size.height(); ++y) {
             for(int x = 0; x < size.width(); ++x) {
                 const QRgb pixel = image.pixel(x,y);
                 const int gray = qGray(pixel);
                 dstImage.setPixel(x, y, qRgba(gray, gray, gray, qAlpha(pixel)));
             }
         }
 
         return dstImage;
     }
 
     QColor blendColors(const QColor &c1, const QColor &c2, qreal r1)
     {
         const qreal r2 = 1.0 - r1;
 
         return QColor::fromRgbF(
             c1.redF() * r1 + c2.redF() * r2,
             c1.greenF() * r1 + c2.greenF() * r2,
             c1.blueF() * r1 + c2.blueF() * r2);
     }
 
     void applyToAlpha8Device(KisPaintDeviceSP dev, const QRect &rc, std::function<void(quint8)> func) {
         KisSequentialConstIterator dstIt(dev, rc);
         while (dstIt.nextPixel()) {
             const quint8 *dstPtr = dstIt.rawDataConst();
             func(*dstPtr);
         }
     }
 
     void filterAlpha8Device(KisPaintDeviceSP dev, const QRect &rc, std::function<quint8(quint8)> func) {
         KisSequentialIterator dstIt(dev, rc);
         while (dstIt.nextPixel()) {
             quint8 *dstPtr = dstIt.rawData();
             *dstPtr = func(*dstPtr);
         }
     }
 
     qreal estimatePortionOfTransparentPixels(KisPaintDeviceSP dev, const QRect &rect, qreal samplePortion) {
         const KoColorSpace *cs = dev->colorSpace();
 
         const qreal linearPortion = std::sqrt(samplePortion);
         const qreal ratio = qreal(rect.width()) / rect.height();
         const int xStep = qMax(1, qRound(1.0 / linearPortion * ratio));
         const int yStep = qMax(1, qRound(1.0 / linearPortion / ratio));
 
         int numTransparentPixels = 0;
         int numPixels = 0;
 
         KisRandomConstAccessorSP it = dev->createRandomConstAccessorNG(rect.x(), rect.y());
         for (int y = rect.y(); y <= rect.bottom(); y += yStep) {
             for (int x = rect.x(); x <= rect.right(); x += xStep) {
                 it->moveTo(x, y);
                 const quint8 alpha = cs->opacityU8(it->rawDataConst());
 
                 if (alpha != OPACITY_OPAQUE_U8) {
                     numTransparentPixels++;
                 }
 
                 numPixels++;
             }
         }
 
         return qreal(numTransparentPixels) / numPixels;
     }
 
     void mirrorDab(Qt::Orientation dir, const QPoint &center, KisRenderedDab *dab)
     {
         const QRect rc = dab->realBounds();
 
         if (dir == Qt::Horizontal) {
             const int mirrorX = -((rc.x() + rc.width()) - center.x()) + center.x();
 
             dab->device->mirror(true, false);
             dab->offset.rx() = mirrorX;
         } else /* if (dir == Qt::Vertical) */ {
             const int mirrorY = -((rc.y() + rc.height()) - center.y()) + center.y();
 
             dab->device->mirror(false, true);
             dab->offset.ry() = mirrorY;
         }
     }
 
     void mirrorRect(Qt::Orientation dir, const QPoint &center, QRect *rc)
     {
         if (dir == Qt::Horizontal) {
             const int mirrorX = -((rc->x() + rc->width()) - center.x()) + center.x();
             rc->moveLeft(mirrorX);
         } else /* if (dir == Qt::Vertical) */ {
             const int mirrorY = -((rc->y() + rc->height()) - center.y()) + center.y();
             rc->moveTop(mirrorY);
         }
     }
+
+    qreal colorDifference(const QColor &c1, const QColor &c2)
+    {
+        const qreal dr = c1.redF() - c2.redF();
+        const qreal dg = c1.greenF() - c2.greenF();
+        const qreal db = c1.blueF() - c2.blueF();
+
+        return std::sqrt(2 * pow2(dr) + 4 * pow2(dg) + 3 * pow2(db));
+    }
+
+    void dragColor(QColor *color, const QColor &baseColor, qreal threshold)
+    {
+        while (colorDifference(*color, baseColor) < threshold) {
+
+            QColor newColor = *color;
+
+            if (newColor.lightnessF() > baseColor.lightnessF()) {
+                newColor = newColor.lighter(120);
+            } else {
+                newColor = newColor.darker(120);
+            }
+
+            if (newColor == *color) {
+                break;
+            }
+
+            *color = newColor;
+        }
+    }
+
+
 }
diff --git a/libs/image/krita_utils.h b/libs/image/krita_utils.h
index cc3e04d740..34108af377 100644
--- a/libs/image/krita_utils.h
+++ b/libs/image/krita_utils.h
@@ -1,105 +1,119 @@
 /*
  *  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 __KRITA_UTILS_H
 #define __KRITA_UTILS_H
 
 class QRect;
 class QRectF;
 class QSize;
 class QPen;
 class QPointF;
 class QPainterPath;
 class QBitArray;
 class QPainter;
 class KisRenderedDab;
 
 #include <QVector>
 #include "kritaimage_export.h"
 #include "kis_types.h"
 #include "krita_container_utils.h"
 #include <functional>
 
 
 namespace KritaUtils
 {
     QSize KRITAIMAGE_EXPORT optimalPatchSize();
 
     QVector<QRect> KRITAIMAGE_EXPORT splitRectIntoPatches(const QRect &rc, const QSize &patchSize);
     QVector<QRect> KRITAIMAGE_EXPORT splitRegionIntoPatches(const QRegion &region, const QSize &patchSize);
 
     QRegion KRITAIMAGE_EXPORT splitTriangles(const QPointF &center,
                                              const QVector<QPointF> &points);
     QRegion KRITAIMAGE_EXPORT splitPath(const QPainterPath &path);
 
     QString KRITAIMAGE_EXPORT prettyFormatReal(qreal value);
 
     qreal KRITAIMAGE_EXPORT maxDimensionPortion(const QRectF &bounds, qreal portion, qreal minValue);
     QPainterPath KRITAIMAGE_EXPORT trySimplifyPath(const QPainterPath &path, qreal lengthThreshold);
 
     /**
      * Split a path \p path into a set of disjoint (non-intersectable)
      * paths if possible.
      *
      * It tries to follow odd-even fill rule, but has a small problem:
      * If you have three selections included into each other twice,
      * then the smallest selection will be included into the final subpath,
      * although it shouldn't according to odd-even-fill rule. It is still
      * to be fixed.
      */
     QList<QPainterPath> KRITAIMAGE_EXPORT splitDisjointPaths(const QPainterPath &path);
 
 
     quint8 KRITAIMAGE_EXPORT mergeOpacity(quint8 opacity, quint8 parentOpacity);
     QBitArray KRITAIMAGE_EXPORT mergeChannelFlags(const QBitArray &flags, const QBitArray &parentFlags);
 
     bool KRITAIMAGE_EXPORT compareChannelFlags(QBitArray f1, QBitArray f2);
     QString KRITAIMAGE_EXPORT toLocalizedOnOff(bool value);
 
     KisNodeSP KRITAIMAGE_EXPORT nearestNodeAfterRemoval(KisNodeSP node);
 
     /**
      * When drawing a rect Qt uses quite a weird algorithm. It
      * draws 4 lines:
      *  o at X-es: rect.x() and rect.right() + 1
      *  o at Y-s: rect.y() and rect.bottom() + 1
      *
      *  Which means that bottom and right lines of the rect are painted
      *  outside the virtual rectangle the rect defines. This methods overcome this issue by
      *  painting the adjusted rect.
      */
     void KRITAIMAGE_EXPORT renderExactRect(QPainter *p, const QRect &rc);
 
     /**
      * \see renderExactRect(QPainter *p, const QRect &rc)
      */
     void KRITAIMAGE_EXPORT renderExactRect(QPainter *p, const QRect &rc, const QPen &pen);
 
     QImage KRITAIMAGE_EXPORT convertQImageToGrayA(const QImage &image);
     QColor KRITAIMAGE_EXPORT blendColors(const QColor &c1, const QColor &c2, qreal r1);
 
+    /**
+     * \return an approximate difference between \p c1 and \p c2
+     *         in a (nonlinear) range [0, 3]
+     *
+     * The colors are compared using the formula:
+     *     difference = sqrt(2 * diff_R^2 + 4 * diff_G^2 + 3 * diff_B^2)
+     */
+    qreal KRITAIMAGE_EXPORT colorDifference(const QColor &c1, const QColor &c2);
+
+    /**
+     * Make the color \p color differ from \p baseColor for at least \p threshold value
+     */
+    void KRITAIMAGE_EXPORT dragColor(QColor *color, const QColor &baseColor, qreal threshold);
+
     void KRITAIMAGE_EXPORT applyToAlpha8Device(KisPaintDeviceSP dev, const QRect &rc, std::function<void(quint8)> func);
     void KRITAIMAGE_EXPORT filterAlpha8Device(KisPaintDeviceSP dev, const QRect &rc, std::function<quint8(quint8)> func);
 
     qreal KRITAIMAGE_EXPORT estimatePortionOfTransparentPixels(KisPaintDeviceSP dev, const QRect &rect, qreal samplePortion);
 
     void KRITAIMAGE_EXPORT mirrorDab(Qt::Orientation dir, const QPoint &center, KisRenderedDab *dab);
     void KRITAIMAGE_EXPORT mirrorRect(Qt::Orientation dir, const QPoint &center, QRect *rc);
 }
 
 #endif /* __KRITA_UTILS_H */
diff --git a/libs/image/metadata/kis_meta_data_type_info.cc b/libs/image/metadata/kis_meta_data_type_info.cc
index abb6ab19ec..5b37f9fc40 100644
--- a/libs/image/metadata/kis_meta_data_type_info.cc
+++ b/libs/image/metadata/kis_meta_data_type_info.cc
@@ -1,289 +1,290 @@
 /*
  *  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; either version 2.1 of the License, or
  *  (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_meta_data_type_info.h"
 
 #include <QVariant>
 
 #include "kis_meta_data_parser_p.h"
 #include "kis_meta_data_type_info_p.h"
 #include "kis_meta_data_value.h"
 #include "kis_meta_data_schema.h"
 
 using namespace KisMetaData;
 
 QHash< const TypeInfo*, const TypeInfo*> TypeInfo::Private::orderedArrays;
 QHash< const TypeInfo*, const TypeInfo*> TypeInfo::Private::unorderedArrays;
 QHash< const TypeInfo*, const TypeInfo*> TypeInfo::Private::alternativeArrays;
 
 const TypeInfo* TypeInfo::Private::Boolean = new TypeInfo(TypeInfo::BooleanType);
 const TypeInfo* TypeInfo::Private::Integer = new TypeInfo(TypeInfo::IntegerType);
 const TypeInfo* TypeInfo::Private::Date = new TypeInfo(TypeInfo::DateType);
 const TypeInfo* TypeInfo::Private::Text = new TypeInfo(TypeInfo::TextType);
 const TypeInfo* TypeInfo::Private::Rational = new TypeInfo(TypeInfo::RationalType);
 const TypeInfo* TypeInfo::Private::GPSCoordinate = new TypeInfo(TypeInfo::GPSCoordinateType);
 
 const TypeInfo* TypeInfo::Private::orderedArray(const TypeInfo* _typeInfo)
 {
     if (Private::orderedArrays.contains(_typeInfo)) {
         return Private::orderedArrays[ _typeInfo ];
     }
     const TypeInfo* info = new TypeInfo(TypeInfo::OrderedArrayType, _typeInfo);
     Private::orderedArrays[ _typeInfo ] = info;
     return info;
 }
 
 const TypeInfo* TypeInfo::Private::unorderedArray(const TypeInfo* _typeInfo)
 {
     if (Private::unorderedArrays.contains(_typeInfo)) {
         return Private::unorderedArrays[ _typeInfo ];
     }
     const TypeInfo* info = new TypeInfo(TypeInfo::UnorderedArrayType, _typeInfo);
     Private::unorderedArrays[ _typeInfo ] = info;
     return info;
 }
 
 const TypeInfo* TypeInfo::Private::alternativeArray(const TypeInfo* _typeInfo)
 {
     if (Private::alternativeArrays.contains(_typeInfo)) {
         return Private::alternativeArrays[ _typeInfo ];
     }
     const TypeInfo* info = new TypeInfo(TypeInfo::AlternativeArrayType, _typeInfo);
     Private::alternativeArrays[ _typeInfo ] = info;
     return info;
 }
 
 const TypeInfo* TypeInfo::Private::createChoice(PropertyType _propertiesType, const TypeInfo* _embedded, const QList< Choice >& _choices)
 {
     return new TypeInfo(_propertiesType, _embedded, _choices);
 }
 
 const TypeInfo* TypeInfo::Private::createStructure(Schema* _structureSchema, const QString& name)
 {
     return new TypeInfo(_structureSchema, name);
 }
 
 const TypeInfo* TypeInfo::Private::LangArray = new TypeInfo(TypeInfo::LangArrayType);
 
 TypeInfo::TypeInfo(TypeInfo::PropertyType _propertyType) : d(new Private)
 {
     d->propertyType = _propertyType;
     if (d->propertyType == TypeInfo::LangArrayType) {
         d->embeddedTypeInfo = TypeInfo::Private::Text;
     }
     switch (d->propertyType) {
     case IntegerType:
         d->parser = new IntegerParser;
         break;
     case TextType:
         d->parser = new TextParser;
         break;
     case DateType:
         d->parser = new DateParser;
         break;
     case RationalType:
         d->parser = new RationalParser;
         break;
     default:
         ;
     }
 }
 
 struct Q_DECL_HIDDEN TypeInfo::Choice::Private {
     Value value;
     QString hint;
 };
 
 TypeInfo::Choice::Choice(const Value& value, const QString& hint) : d(new Private)
 {
     d->value = value;
     d->hint = hint;
 }
 
 TypeInfo::Choice::Choice(const Choice& _rhs) : d(new Private(*_rhs.d))
 {
 }
 
 TypeInfo::Choice& TypeInfo::Choice::operator=(const Choice & _rhs)
 {
     *d = *_rhs.d;
     return *this;
 }
 
 TypeInfo::Choice::~Choice()
 {
     delete d;
 }
 const Value& TypeInfo::Choice::value() const
 {
     return d->value;
 }
 
 const QString& TypeInfo::Choice::hint() const
 {
     return d->hint;
 }
 
 TypeInfo::TypeInfo(PropertyType _propertyType, const TypeInfo* _embedded) : d(new Private)
 {
     Q_ASSERT(_propertyType == OrderedArrayType || _propertyType == UnorderedArrayType || _propertyType == AlternativeArrayType);
     d->propertyType = _propertyType;
     d->embeddedTypeInfo = _embedded;
 }
 
 TypeInfo::TypeInfo(PropertyType _propertyType, const TypeInfo* _embedded, const QList< Choice >& _choices) : d(new Private)
 {
     Q_ASSERT(_propertyType == ClosedChoice || _propertyType == OpenedChoice);
     d->propertyType = _propertyType;
     d->embeddedTypeInfo = _embedded;
     d->parser = _embedded->parser();
     d->choices = _choices;
 }
 
 TypeInfo::TypeInfo(Schema* _structureSchema, const QString& name) : d(new Private)
 {
     d->propertyType = TypeInfo::StructureType;
     d->structureSchema = _structureSchema;
     d->structureName = name;
 }
 
 TypeInfo::~TypeInfo()
 {
     delete d->parser;
     delete d;
 }
 
 TypeInfo::PropertyType TypeInfo::propertyType() const
 {
     return d->propertyType;
 }
 
 const TypeInfo* TypeInfo::embeddedPropertyType() const
 {
     return d->embeddedTypeInfo;
 }
 
 const QList< TypeInfo::Choice >& TypeInfo::choices() const
 {
     return d->choices;
 }
 
 Schema* TypeInfo::structureSchema() const
 {
     return d->structureSchema;
 }
 
 const QString& TypeInfo::structureName() const
 {
     return d->structureName;
 }
 
 const Parser* TypeInfo::parser() const
 {
     return d->parser;
 }
 
 bool checkArray(const Value& value, const TypeInfo* typeInfo)
 {
     QList< Value > values = value.asArray();
     Q_FOREACH (const Value& val, values) {
         if (!typeInfo->hasCorrectType(val)) {
             return false;
         }
     }
     return true;
 }
 
 bool TypeInfo::hasCorrectType(const Value& value) const
 {
     switch (d->propertyType) {
     case BooleanType:
         return value.type() == Value::Variant && value.asVariant().type() == QVariant::Bool;
     case IntegerType:
         return value.type() == Value::Variant && value.asVariant().type() == QVariant::Int;
     case DateType:
         return value.type() == Value::Variant && value.asVariant().type() == QVariant::DateTime;
     case GPSCoordinateType:
     case TextType:
         return value.type() == Value::Variant && value.asVariant().type() == QVariant::String;
     case OrderedArrayType:
         if (value.type() == Value::OrderedArray) {
             return checkArray(value, d->embeddedTypeInfo);
         } else {
             return false;
         }
     case UnorderedArrayType:
         if (value.type() == Value::UnorderedArray) {
             return checkArray(value, d->embeddedTypeInfo);
         } else {
             return false;
         }
     case AlternativeArrayType:
         if (value.type() == Value::AlternativeArray) {
             return checkArray(value, d->embeddedTypeInfo);
         } else {
             return false;
         }
     case LangArrayType:
         if (value.type() == Value::LangArray) {
             QList< Value > values = value.asArray();
             Q_FOREACH (const Value& vallang, values) {
                 if (!Private::Text->hasCorrectType(vallang) ||
                         !Private::Text->hasCorrectType(vallang.propertyQualifiers()["xml:lang"])) {
                     return false;
                 }
             }
+            return true;
         } else {
             return false;
         }
     case StructureType:
         if (value.type() == Value::Structure) {
             QMap<QString, KisMetaData::Value> structure = value.asStructure();
             for (QMap<QString, KisMetaData::Value>::iterator it = structure.begin();
                     it != structure.end(); ++it) {
                 const TypeInfo* typeInfo = d->structureSchema->propertyType(it.key());
                 if (!typeInfo || !typeInfo->hasCorrectType(it.value())) {
                     return false;
                 }
             }
             return true;
         } else {
             return false;
         }
     case RationalType:
         return value.type() == Value::Rational;
     case OpenedChoice:
     case ClosedChoice:
         return d->embeddedTypeInfo->hasCorrectType(value);
     }
     return false;
 }
 
 bool TypeInfo::hasCorrectValue(const Value& value) const
 {
     if (d->propertyType == ClosedChoice) {
         Q_FOREACH (const Choice& choice, d->choices) {
             if (choice.value() == value) {
                 return true;
             }
         }
         return false;
     } else {
         return true;
     }
 }
diff --git a/libs/image/metadata/kis_meta_data_value.cc b/libs/image/metadata/kis_meta_data_value.cc
index 39413171b8..26f471b6ef 100644
--- a/libs/image/metadata/kis_meta_data_value.cc
+++ b/libs/image/metadata/kis_meta_data_value.cc
@@ -1,454 +1,459 @@
 /*
  *  Copyright (c) 2007,2010 Cyrille Berger <cberger@cberger.net>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; either version 2.1 of the License, or
  *  (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_meta_data_value.h"
 #include <QPoint>
 #include <QPointF>
 #include <QRegExp>
 #include <QTime>
 #include <QVariant>
 #include <QStringList>
 
 #include <klocalizedstring.h>
 
 #include <kis_debug.h>
 
 using namespace KisMetaData;
 
 struct Q_DECL_HIDDEN Value::Private {
     Private() : type(Invalid) {}
     union {
         QVariant* variant;
         QList<Value>* array;
         QMap<QString, Value>* structure;
         KisMetaData::Rational* rational;
     } value;
     ValueType type;
     QMap<QString, Value> propertyQualifiers;
 };
 
 Value::Value() : d(new Private)
 {
     d->type = Invalid;
 }
 
 
 Value::Value(const QVariant& variant) : d(new Private)
 {
     d->type = Value::Variant;
     d->value.variant = new QVariant(variant);
 }
 
 Value::Value(const QList<Value>& array, ValueType type) : d(new Private)
 {
     Q_ASSERT(type == OrderedArray || type == UnorderedArray || type == AlternativeArray || type == LangArray);
     d->value.array = new QList<Value>(array);
     d->type = type; // TODO: I am hesitating about LangArray to keep them as array or convert them to maps
 }
 
 Value::Value(const QMap<QString, Value>& structure) : d(new Private)
 {
     d->type = Structure;
     d->value.structure = new QMap<QString, Value>(structure);
 }
 
 Value::Value(const KisMetaData::Rational& signedRational) : d(new Private)
 {
     d->type = Value::Rational;
     d->value.rational = new KisMetaData::Rational(signedRational);
 }
 
 
 Value::Value(const Value& v) : d(new Private)
 {
     d->type = Invalid;
     *this = v;
 }
 
 Value& Value::operator=(const Value & v)
 {
     d->type = v.d->type;
     d->propertyQualifiers = v.d->propertyQualifiers;
     switch (d->type) {
     case Invalid:
         break;
     case Variant:
         d->value.variant = new QVariant(*v.d->value.variant);
         break;
     case OrderedArray:
     case UnorderedArray:
     case AlternativeArray:
     case LangArray:
         d->value.array = new QList<Value>(*v.d->value.array);
         break;
     case Structure:
         d->value.structure = new QMap<QString, Value>(*v.d->value.structure);
         break;
     case Rational:
         d->value.rational = new KisMetaData::Rational(*v.d->value.rational);
     }
     return *this;
 }
 
 
 Value::~Value()
 {
     delete d;
 }
 
 void Value::addPropertyQualifier(const QString& _name, const Value& _value)
 {
     d->propertyQualifiers[_name] = _value;
 }
 
 const QMap<QString, Value>& Value::propertyQualifiers() const
 {
     return d->propertyQualifiers;
 }
 
 Value::ValueType Value::type() const
 {
     return d->type;
 }
 
 double Value::asDouble() const
 {
     switch (type()) {
     case Variant:
         return d->value.variant->toDouble(0);
     case Rational:
         return d->value.rational->numerator / (double)d->value.rational->denominator;
     default:
         return 0.0;
     }
     return 0.0;
 }
 
 int Value::asInteger() const
 {
     switch (type()) {
     case Variant:
         return d->value.variant->toInt(0);
     case Rational:
         return d->value.rational->numerator / d->value.rational->denominator;
     default:
         return 0;
     }
     return 0;
 }
 
 QVariant Value::asVariant() const
 {
     switch (type()) {
     case Variant:
         return *d->value.variant;
     case Rational:
         return QVariant(QString("%1 / %2").arg(d->value.rational->numerator).arg(d->value.rational->denominator));
     default: break;
     }
     return QVariant();
 }
 
 bool Value::setVariant(const QVariant& variant)
 {
     switch (type()) {
     case KisMetaData::Value::Invalid:
         *this = KisMetaData::Value(variant);
         return true;
     case Rational: {
         QRegExp rx("([^\\/]*)\\/([^\\/]*)");
         rx.indexIn(variant.toString());
+        // TODO: erm... did someone forgot to write actual code here?
+
+        // for now just safe assert and return a failure
+        KIS_SAFE_ASSERT_RECOVER_NOOP(0 && "Rational metadata values are not implemented!");
+        return false;
     }
     case KisMetaData::Value::Variant: {
         if (d->value.variant->type() == variant.type()) {
             *d->value.variant = variant;
             return true;
         }
     }
     return true;
     default:
         break;
     }
     return false;
 }
 
 bool Value::setStructureVariant(const QString& fieldNAme, const QVariant& variant)
 {
     if (type() == Structure) {
         return (*d->value.structure)[fieldNAme].setVariant(variant);
     }
     return false;
 }
 
 bool Value::setArrayVariant(int index, const QVariant& variant)
 {
     if (isArray()) {
         for (int i = d->value.array->size(); i <= index; ++i) {
             d->value.array->append(Value());
         }
         (*d->value.array)[index].setVariant(variant);
     }
     return false;
 }
 
 KisMetaData::Rational Value::asRational() const
 {
     if (d->type == Rational) {
         return *d->value.rational;
     }
     return KisMetaData::Rational();
 }
 
 QList<Value> Value::asArray() const
 {
     if (isArray()) {
         return *d->value.array;
     }
     return QList<Value>();
 }
 
 
 bool Value::isArray() const
 {
     return type() == OrderedArray || type() == UnorderedArray || type() == AlternativeArray;
 }
 
 QMap<QString, KisMetaData::Value> Value::asStructure() const
 {
     if (type() == Structure) {
         return *d->value.structure;
     }
     return QMap<QString, KisMetaData::Value>();
 }
 
 QDebug operator<<(QDebug debug, const Value &v)
 {
     switch (v.type()) {
     case Value::Invalid:
         debug.nospace() << "invalid value";
         break;
     case Value::Variant:
         debug.nospace() << "Variant: " << v.asVariant();
         break;
     case Value::OrderedArray:
     case Value::UnorderedArray:
     case Value::AlternativeArray:
     case Value::LangArray:
         debug.nospace() << "Array: " << v.asArray();
         break;
     case Value::Structure:
         debug.nospace() << "Structure: " << v.asStructure();
         break;
     case Value::Rational:
         debug.nospace() << "Rational: " << v.asRational().numerator << " / " << v.asRational().denominator;
         break;
     }
     return debug.space();
 }
 
 bool Value::operator==(const Value& rhs) const
 {
     if (d->type != rhs.d->type) return false;
     switch (d->type) {
     case Value::Invalid:
         return true;
     case Value::Variant:
         return asVariant() == rhs.asVariant();
     case Value::OrderedArray:
     case Value::UnorderedArray:
     case Value::AlternativeArray:
     case Value::LangArray:
         return asArray() == rhs.asArray();
     case Value::Structure:
         return asStructure() == rhs.asStructure();
     case Value::Rational:
         return asRational() == rhs.asRational();
     }
     return false;
 }
 
 Value& Value::operator+=(const Value & v)
 {
     switch (d->type) {
     case Value::Invalid:
         Q_ASSERT(v.type() == Value::Invalid);
         break;
     case Value::Variant:
         Q_ASSERT(v.type() == Value::Variant);
         {
             QVariant v1 = *d->value.variant;
             QVariant v2 = *v.d->value.variant;
             Q_ASSERT(v2.canConvert(v1.type()));
             switch (v1.type()) {
             default:
                 warnMetaData << "KisMetaData: Merging metadata of type" << v1.type() << "is unsupported!";
                 break;
             case QVariant::Date:
                 *d->value.variant = qMax(v1.toDate(), v2.toDate());
                 break;
             case QVariant::DateTime:
                 *d->value.variant = qMax(v1.toDate(), v2.toDate());
                 break;
             case QVariant::Double:
                 *d->value.variant = v1.toDouble() + v2.toDouble();
                 break;
             case QVariant::Int:
                 *d->value.variant = v1.toInt() + v2.toInt();
                 break;
             case QVariant::List:
                 *d->value.variant = v1.toList() + v2.toList();
                 break;
             case QVariant::LongLong:
                 *d->value.variant = v1.toLongLong() + v2.toLongLong();
                 break;
             case QVariant::Point:
                 *d->value.variant = v1.toPoint() + v2.toPoint();
                 break;
             case QVariant::PointF:
                 *d->value.variant = v1.toPointF() + v2.toPointF();
                 break;
             case QVariant::String:
                 *d->value.variant = QVariant(v1.toString() + v2.toString());
                 break;
             case QVariant::StringList:
                 *d->value.variant = v1.toStringList() + v2.toStringList();
                 break;
             case QVariant::Time: {
                 QTime t1 = v1.toTime();
                 QTime t2 = v2.toTime();
                 int h = t1.hour() + t2.hour();
                 int m = t1.minute() + t2.minute();
                 int s = t1.second() + t2.second();
                 int ms = t1.msec() + t2.msec();
                 if (ms > 999) {
                     ms -= 999; s++;
                 }
                 if (s > 60) {
                     s -= 60; m++;
                 }
                 if (m > 60) {
                     m -= 60; h++;
                 }
                 if (h > 24) {
                     h -= 24;
                 }
                 *d->value.variant = QTime(h, m, s, ms);
             }
             break;
             case QVariant::UInt:
                 *d->value.variant = v1.toUInt() + v2.toUInt();
                 break;
             case QVariant::ULongLong:
                 *d->value.variant = v1.toULongLong() + v2.toULongLong();
                 break;
             }
 
         }
         break;
     case Value::OrderedArray:
     case Value::UnorderedArray:
     case Value::AlternativeArray: {
         if (v.isArray()) {
             *(d->value.array) += *(v.d->value.array);
         } else {
             d->value.array->append(v);
         }
     }
     break;
     case Value::LangArray: {
         Q_ASSERT(v.type() == Value::LangArray);
     }
     break;
     case Value::Structure: {
         Q_ASSERT(v.type() == Value::Structure);
         break;
     }
     case Value::Rational: {
         Q_ASSERT(v.type() == Value::Rational);
         d->value.rational->numerator =
             (d->value.rational->numerator
              * v.d->value.rational->denominator)
             + (v.d->value.rational->numerator
                * d->value.rational->denominator);
         d->value.rational->denominator *= v.d->value.rational->denominator;
         break;
     }
     }
     return *this;
 }
 
 QMap<QString, KisMetaData::Value> Value::asLangArray() const
 {
     Q_ASSERT(d->type == LangArray);
     QMap<QString, KisMetaData::Value> langArray;
     Q_FOREACH (const KisMetaData::Value& val, *d->value.array) {
         Q_ASSERT(val.d->propertyQualifiers.contains("xml:lang"));  // TODO probably worth to have an assert for this in the constructor as well
         KisMetaData::Value valKeyVal = val.d->propertyQualifiers.value("xml:lang");
         Q_ASSERT(valKeyVal.type() == Variant);
         QVariant valKeyVar = valKeyVal.asVariant();
         Q_ASSERT(valKeyVar.type() == QVariant::String);
         langArray[valKeyVar.toString()] = val;
     }
     return langArray;
 }
 
 QString Value::toString() const
 {
     switch (type()) {
     case Value::Invalid:
         return i18n("Invalid value.");
     case Value::Variant:
         return d->value.variant->toString();
         break;
     case Value::OrderedArray:
     case Value::UnorderedArray:
     case Value::AlternativeArray:
     case Value::LangArray: {
         QString r = QString("[%1]{ ").arg(d->value.array->size());
         for (int i = 0; i < d->value.array->size(); ++i) {
             const Value& val = d->value.array->at(i);
             r += val.toString();
             if (i != d->value.array->size() - 1) {
                 r += ',';
             }
             r += ' ';
         }
         r += '}';
         return r;
     }
     case Value::Structure: {
         QString r = "{ ";
         QList<QString> fields = d->value.structure->keys();
         for (int i = 0; i < fields.count(); ++i) {
             const QString& field = fields[i];
             const Value& val = d->value.structure->value(field);
             r += field + " => " + val.toString();
             if (i != d->value.array->size() - 1) {
                 r += ',';
             }
             r += ' ';
         }
         r += '}';
         return r;
     }
     break;
     case Value::Rational:
         return QString("%1 / %2").arg(d->value.rational->numerator).arg(d->value.rational->denominator);
     }
     return i18n("Invalid value.");
 }
diff --git a/libs/image/tests/CMakeLists.txt b/libs/image/tests/CMakeLists.txt
index 87eb8fe297..a5d0999413 100644
--- a/libs/image/tests/CMakeLists.txt
+++ b/libs/image/tests/CMakeLists.txt
@@ -1,239 +1,172 @@
 # cmake in some versions for some not yet known reasons fails to run automoc
 # on random targets (changing target names already has an effect)
 # As temporary workaround skipping build of tests on these versions for now
 # See https://mail.kde.org/pipermail/kde-buildsystem/2015-June/010819.html
 # extend range of affected cmake versions as needed
 if(NOT ${CMAKE_VERSION} VERSION_LESS 3.1.3 AND
    NOT ${CMAKE_VERSION} VERSION_GREATER 3.2.3)
     message(WARNING "Skipping krita/image/tests, CMake in at least versions 3.1.3 - 3.2.3 seems to have a problem with automoc.  \n(FRIENDLY REMINDER: PLEASE DON'T BREAK THE TESTS!)")
     set (HAVE_FAILING_CMAKE TRUE)
 else()
     set (HAVE_FAILING_CMAKE FALSE)
 endif()
 
 include_directories(
     ${CMAKE_SOURCE_DIR}/libs/image/metadata
     ${CMAKE_BINARY_DIR}/libs/image/
     ${CMAKE_SOURCE_DIR}/libs/image/
     ${CMAKE_SOURCE_DIR}/libs/image/brushengine
     ${CMAKE_SOURCE_DIR}/libs/image/tiles3
     ${CMAKE_SOURCE_DIR}/libs/image/tiles3/swap
     ${CMAKE_SOURCE_DIR}/sdk/tests
 )
 
 include_Directories(SYSTEM
     ${EIGEN3_INCLUDE_DIR}
 )
 
 if(HAVE_VC)
   include_directories(${Vc_INCLUDE_DIR})
 endif()
 
 include(ECMAddTests)
 include(KritaAddBrokenUnitTest)
 
 macro_add_unittest_definitions()
 
 set(KisRandomGeneratorDemoSources kis_random_generator_demo.cpp kimageframe.cpp)
 ki18n_wrap_ui(KisRandomGeneratorDemoSources kis_random_generator_demo.ui)
 add_executable(KisRandomGeneratorDemo ${KisRandomGeneratorDemoSources})
 target_link_libraries(KisRandomGeneratorDemo kritaimage)
 ecm_mark_as_test(KisRandomGeneratorDemo)
 
 ecm_add_tests(
     kis_base_node_test.cpp
     kis_fast_math_test.cpp
     kis_node_test.cpp
     kis_node_facade_test.cpp
     kis_fixed_paint_device_test.cpp
     kis_layer_test.cpp
     kis_effect_mask_test.cpp
     kis_iterator_test.cpp
     kis_painter_test.cpp
     kis_selection_test.cpp
     kis_count_visitor_test.cpp
     kis_projection_test.cpp
     kis_properties_configuration_test.cpp
     kis_transaction_test.cpp
     kis_pixel_selection_test.cpp
     kis_group_layer_test.cpp
     kis_paint_layer_test.cpp
     kis_adjustment_layer_test.cpp
     kis_annotation_test.cpp
     kis_change_profile_visitor_test.cpp
     kis_clone_layer_test.cpp
     kis_colorspace_convert_visitor_test.cpp
     kis_convolution_painter_test.cpp
     kis_crop_processing_visitor_test.cpp
     kis_processing_applicator_test.cpp
     kis_datamanager_test.cpp
     kis_fill_painter_test.cpp
     kis_filter_configuration_test.cpp
     kis_filter_test.cpp
     kis_filter_processing_information_test.cpp
     kis_filter_registry_test.cpp
     kis_filter_strategy_test.cpp
     kis_gradient_painter_test.cpp
     kis_image_commands_test.cpp
     kis_image_test.cpp
     kis_image_signal_router_test.cpp
     kis_iterators_ng_test.cpp
     kis_iterator_benchmark.cpp
     kis_updater_context_test.cpp
     kis_simple_update_queue_test.cpp
     kis_stroke_test.cpp
     kis_simple_stroke_strategy_test.cpp
     kis_stroke_strategy_undo_command_based_test.cpp
     kis_strokes_queue_test.cpp
     kis_mask_test.cpp
     kis_math_toolbox_test.cpp
     kis_name_server_test.cpp
     kis_node_commands_test.cpp
     kis_node_graph_listener_test.cpp
     kis_node_visitor_test.cpp
     kis_paint_information_test.cpp
     kis_distance_information_test.cpp
     kis_paintop_test.cpp
     kis_pattern_test.cpp
     kis_selection_mask_test.cpp
     kis_shared_ptr_test.cpp
     kis_bsplines_test.cpp
     kis_warp_transform_worker_test.cpp
     kis_liquify_transform_worker_test.cpp
     kis_transparency_mask_test.cpp
     kis_types_test.cpp
     kis_vec_test.cpp
     kis_filter_config_widget_test.cpp
     kis_mask_generator_test.cpp
     kis_cubic_curve_test.cpp
     kis_fixed_point_maths_test.cpp
     kis_node_query_path_test.cpp
     kis_filter_weights_buffer_test.cpp
     kis_filter_weights_applicator_test.cpp
     kis_fill_interval_test.cpp
     kis_fill_interval_map_test.cpp
     kis_scanline_fill_test.cpp
     kis_psd_layer_style_test.cpp
     kis_layer_style_projection_plane_test.cpp
     kis_lod_capable_layer_offset_test.cpp
     kis_algebra_2d_test.cpp
     kis_marker_painter_test.cpp
     kis_lazy_brush_test.cpp
     kis_colorize_mask_test.cpp
     kis_mask_similarity_test.cpp
     KisMaskGeneratorBenchmark.cpp
-
-    NAME_PREFIX "krita-image-"
-    LINK_LIBRARIES kritaimage Qt5::Test)
-
-
-ecm_add_test(kis_layer_style_filter_environment_test.cpp
-    TEST_NAME kritaimage-layer_style_filter_environment_test
-    LINK_LIBRARIES ${KDE4_KDEUI_LIBS} kritaimage Qt5::Test)
-
-ecm_add_test(kis_asl_parser_test.cpp
-    TEST_NAME kritalibpsd-asl_parser_test
-    LINK_LIBRARIES kritapsd kritapigment kritawidgetutils kritacommand Qt5::Xml Qt5::Test)
-
-ecm_add_test(KisPerStrokeRandomSourceTest.cpp
-    TEST_NAME KisPerStrokeRandomSourceTest
-    LINK_LIBRARIES kritaimage Qt5::Test)
-
-ecm_add_test(KisWatershedWorkerTest.cpp
-    TEST_NAME KisWatershedWorkerTest
-    LINK_LIBRARIES kritaimage Qt5::Test)
-
-
-ecm_add_test(kis_dom_utils_test.cpp
-   TEST_NAME krita-image-KisDomUtilsTest
-   LINK_LIBRARIES kritaimage Qt5::Test)
-
-ecm_add_test(kis_transform_worker_test.cpp
-    TEST_NAME krita-image-KisTransformWorkerTest
-    LINK_LIBRARIES kritaimage Qt5::Test)
-
-ecm_add_test(kis_perspective_transform_worker_test.cpp
-    TEST_NAME krita-image-KisPerspectiveTransformWorkerTest
-    LINK_LIBRARIES kritaimage Qt5::Test)
-
-ecm_add_test(kis_cs_conversion_test.cpp
-    TEST_NAME krita-image-KisCsConversionTest
-    LINK_LIBRARIES kritaimage Qt5::Test)
-
-ecm_add_test(kis_processings_test.cpp
-    TEST_NAME krita-image-KisProcessingsTest
-    LINK_LIBRARIES kritaimage Qt5::Test)
-
-ecm_add_test(kis_projection_leaf_test.cpp
-    TEST_NAME KisProjectionLeafTest
-    LINK_LIBRARIES kritaimage Qt5::Test)
-
+    kis_layer_style_filter_environment_test.cpp
+    kis_asl_parser_test.cpp
+    KisPerStrokeRandomSourceTest.cpp
+    KisWatershedWorkerTest.cpp
+    kis_dom_utils_test.cpp
+    kis_transform_worker_test.cpp
+    kis_perspective_transform_worker_test.cpp
+    kis_cs_conversion_test.cpp
+    kis_processings_test.cpp
+    kis_projection_leaf_test.cpp
+    kis_histogram_test.cpp
+    kis_onion_skin_compositor_test.cpp
+
+    LINK_LIBRARIES kritaimage Qt5::Test
+    NAME_PREFIX "libs-image-")
 
 
 if (NOT HAVE_FAILING_CMAKE)
   krita_add_broken_unit_test(kis_paint_device_test.cpp
-      TEST_NAME krita-image-KisPaintDeviceTest
-      LINK_LIBRARIES kritaimage kritaodf Qt5::Test)
+      LINK_LIBRARIES kritaimage kritaodf Qt5::Test
+      NAME_PREFIX "libs-image-")
 else()
   message(WARNING "Skipping KisPaintDeviceTest!!!!!!!!!!!!!!")
 endif()
 
 if (NOT HAVE_FAILING_CMAKE)
   krita_add_broken_unit_test(kis_filter_mask_test.cpp
-      TEST_NAME krita-image-KisFilterMaskTest
-      LINK_LIBRARIES kritaimage Qt5::Test)
+      LINK_LIBRARIES kritaimage Qt5::Test
+      NAME_PREFIX "libs-image-")
 else()
   message(WARNING "Skipping KisFilterMaskTest!!!!!!!!!!!!!!")
 endif()
 
-krita_add_broken_unit_test(kis_transform_mask_test.cpp
-    TEST_NAME krita-image-KisTransformMaskTest
-    LINK_LIBRARIES kritaimage Qt5::Test)
-
-ecm_add_test(kis_histogram_test.cpp
-    TEST_NAME krita-image-KisHistogramTest
-    LINK_LIBRARIES kritaimage Qt5::Test)
-
-krita_add_broken_unit_test(kis_walkers_test.cpp
-    TEST_NAME krita-image-KisWalkersTest
-    LINK_LIBRARIES kritaimage Qt5::Test)
-
-#krita_add_broken_unit_test(kis_async_merger_test.cpp
-#    TEST_NAME krita-image-KisAsyncMergerTest
-#    LINK_LIBRARIES kritaimage Qt5::Test)
-
-krita_add_broken_unit_test(kis_update_scheduler_test.cpp
-    TEST_NAME krita-image-KisUpdateSchedulerTest
-    LINK_LIBRARIES kritaimage Qt5::Test)
-
-krita_add_broken_unit_test(kis_queues_progress_updater_test.cpp
-    TEST_NAME krita-image-KisQueuesProgressUpdaterTest
-    LINK_LIBRARIES kritaimage Qt5::Test)
-
-krita_add_broken_unit_test(kis_cage_transform_worker_test.cpp
-    TEST_NAME krita-image-KisCageTransformWorkerTest
-    LINK_LIBRARIES kritaimage Qt5::Test)
-
-krita_add_broken_unit_test(kis_meta_data_test.cpp
-    TEST_NAME krita-image-KisMetaDataTest
-    LINK_LIBRARIES kritaimage Qt5::Test)
-
-krita_add_broken_unit_test(kis_random_generator_test.cpp
-    TEST_NAME krita-image-KisRandomGeneratorTest
-    LINK_LIBRARIES kritaimage Qt5::Test)
-
-krita_add_broken_unit_test(kis_keyframing_test.cpp
-    TEST_NAME krita-image-Keyframing-Test
-    LINK_LIBRARIES kritaimage Qt5::Test)
-
-krita_add_broken_unit_test(kis_image_animation_interface_test.cpp
-    TEST_NAME krita-image-ImageAnimationInterface-Test
-    LINK_LIBRARIES ${KDE4_KDEUI_LIBS} kritaimage Qt5::Test)
-
-ecm_add_test(kis_onion_skin_compositor_test.cpp
-    TEST_NAME krita-image-OnionSkinCompositor-Test
-    LINK_LIBRARIES ${KDE4_KDEUI_LIBS} kritaimage Qt5::Test)
-
-krita_add_broken_unit_test(kis_layer_styles_test.cpp
-    TEST_NAME krita-image-LayerStylesTest
-    LINK_LIBRARIES kritaimage Qt5::Test)
+krita_add_broken_unit_tests(
+    kis_transform_mask_test.cpp
+    kis_walkers_test.cpp
+    kis_update_scheduler_test.cpp
+    ##kis_async_merger_test.cpp
+    kis_queues_progress_updater_test.cpp
+    kis_cage_transform_worker_test.cpp
+    kis_meta_data_test.cpp
+    kis_random_generator_test.cpp
+    kis_keyframing_test.cpp
+    kis_image_animation_interface_test.cpp
+    kis_layer_styles_test.cpp
+
+    LINK_LIBRARIES kritaimage Qt5::Test
+    NAME_PREFIX "libs-image-")
diff --git a/libs/image/tests/kis_adjustment_layer_test.cpp b/libs/image/tests/kis_adjustment_layer_test.cpp
index 97814f4be1..1a3add9126 100644
--- a/libs/image/tests/kis_adjustment_layer_test.cpp
+++ b/libs/image/tests/kis_adjustment_layer_test.cpp
@@ -1,117 +1,117 @@
 /*
  *  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_adjustment_layer_test.h"
 
 #include <QTest>
 
 
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 
 #include "kis_adjustment_layer.h"
 #include "filter/kis_filter_configuration.h"
 #include "filter/kis_filter.h"
 #include "filter/kis_filter_registry.h"
 #include "kis_image.h"
 #include "kis_selection.h"
 #include "kis_types.h"
 #include "kis_datamanager.h"
 #include "kis_pixel_selection.h"
 #include "testutil.h"
 
 void KisAdjustmentLayerTest::testCreation()
 {
     const KoColorSpace * colorSpace = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(0, 512, 512, colorSpace, "adj layer test");
     KisFilterSP f = KisFilterRegistry::instance()->value("invert");
     Q_ASSERT(f);
     KisFilterConfigurationSP  kfc = f->defaultConfiguration();
     Q_ASSERT(kfc);
 
     KisAdjustmentLayerSP test = new KisAdjustmentLayer(image, "test", kfc, 0);
 }
 
 void KisAdjustmentLayerTest::testSetSelection()
 {
     KisSelectionSP sel = new KisSelection();
     const KoColorSpace * colorSpace = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(0, 512, 512, colorSpace, "adj layer test");
     KisFilterSP f = KisFilterRegistry::instance()->value("invert");
     Q_ASSERT(f);
     KisFilterConfigurationSP  kfc = f->defaultConfiguration();
     Q_ASSERT(kfc);
     sel->pixelSelection()->select(QRect(10, 10, 200, 200), 128);
     KisAdjustmentLayerSP l1 = new KisAdjustmentLayer(image, "bla", kfc, sel);
     QCOMPARE(sel->selectedExactRect(), l1->internalSelection()->selectedExactRect());
 }
 
 void KisAdjustmentLayerTest::testInverted()
 {
     const KoColorSpace * colorSpace = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(0, 512, 512, colorSpace, "adj layer test");
     KisFilterSP f = KisFilterRegistry::instance()->value("invert");
     Q_ASSERT(f);
     KisFilterConfigurationSP  kfc = f->defaultConfiguration();
     Q_ASSERT(kfc);
 
     KisSelectionSP sel2 = new KisSelection();
     sel2->pixelSelection()->invert();
     KisAdjustmentLayerSP l2 = new KisAdjustmentLayer(image, "bla", kfc, sel2);
-    QCOMPARE(sel2->selectedExactRect(), l2->internalSelection()->selectedExactRect());
+    QCOMPARE(l2->internalSelection()->selectedExactRect(), image->bounds());
 
     KisSelectionSP sel3 = new KisSelection();
     sel3->pixelSelection()->select(QRect(50, -10, 800, 30), 128);
     l2->setInternalSelection(sel3);
 
 }
 
 void KisAdjustmentLayerTest::testSelectionParent()
 {
     const KoColorSpace * colorSpace = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(0, 512, 512, colorSpace, "adj layer test");
     KisFilterSP f = KisFilterRegistry::instance()->value("invert");
     Q_ASSERT(f);
 
     {
         KisAdjustmentLayerSP adjLayer =
             new KisAdjustmentLayer(image, "bla", f->defaultConfiguration(), 0);
 
         QCOMPARE(adjLayer->internalSelection()->parentNode(), KisNodeWSP(adjLayer));
     }
 
     {
         KisSelectionSP selection = new KisSelection();
         KisAdjustmentLayerSP adjLayer =
             new KisAdjustmentLayer(image, "bla", f->defaultConfiguration(), selection);
 
         QCOMPARE(adjLayer->internalSelection()->parentNode(), KisNodeWSP(adjLayer));
     }
 
     {
         KisAdjustmentLayerSP adjLayer =
             new KisAdjustmentLayer(image, "bla", f->defaultConfiguration(), 0);
 
         KisSelectionSP selection = new KisSelection();
         adjLayer->setInternalSelection(selection);
 
         QCOMPARE(adjLayer->internalSelection()->parentNode(), KisNodeWSP(adjLayer));
     }
 }
 
 QTEST_MAIN(KisAdjustmentLayerTest)
diff --git a/libs/image/tests/kis_painter_test.cpp b/libs/image/tests/kis_painter_test.cpp
index 2050370899..f5b8ae264b 100644
--- a/libs/image/tests/kis_painter_test.cpp
+++ b/libs/image/tests/kis_painter_test.cpp
@@ -1,688 +1,688 @@
 /*
  *  Copyright (c) 2007 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_painter_test.h"
 #include <QTest>
 
 
 #include <kis_debug.h>
 #include <QRect>
 #include <QTime>
 #include <QtXml>
 
 #include <KoChannelInfo.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoCompositeOpRegistry.h>
 
 #include "kis_datamanager.h"
 #include "kis_types.h"
 #include "kis_paint_device.h"
 #include "kis_painter.h"
 #include "kis_pixel_selection.h"
 #include "kis_fill_painter.h"
 #include <kis_fixed_paint_device.h>
 #include "testutil.h"
 #include <kis_iterator_ng.h>
 
 void KisPainterTest::allCsApplicator(void (KisPainterTest::* funcPtr)(const KoColorSpace*cs))
 {
     qDebug() << qAppName();
 
     QList<const KoColorSpace*> colorspaces = KoColorSpaceRegistry::instance()->allColorSpaces(KoColorSpaceRegistry::AllColorSpaces, KoColorSpaceRegistry::OnlyDefaultProfile);
 
     Q_FOREACH (const KoColorSpace* cs, colorspaces) {
 
         QString csId = cs->id();
         // ALL THESE COLORSPACES ARE BROKEN: WE NEED UNITTESTS FOR COLORSPACES!
         if (csId.startsWith("KS")) continue;
         if (csId.startsWith("Xyz")) continue;
         if (csId.startsWith('Y')) continue;
         if (csId.contains("AF")) continue;
         if (csId == "GRAYU16") continue; // No point in testing bounds with a cs without alpha
         if (csId == "GRAYU8") continue; // No point in testing bounds with a cs without alpha
 
         dbgKrita << "Testing with cs" << csId;
 
         if (cs && cs->compositeOp(COMPOSITE_OVER) != 0) {
             (this->*funcPtr)(cs);
         } else {
             dbgKrita << "Cannot bitBlt for cs" << csId;
         }
     }
 }
 
 void KisPainterTest::testSimpleBlt(const KoColorSpace * cs)
 {
 
     KisPaintDeviceSP dst = new KisPaintDevice(cs);
     KisPaintDeviceSP src = new KisPaintDevice(cs);
     KoColor c(Qt::red, cs);
     c.setOpacity(quint8(128));
     src->fill(20, 20, 20, 20, c.data());
 
     QCOMPARE(src->exactBounds(), QRect(20, 20, 20, 20));
 
     const KoCompositeOp* op;
 
     {
         op = cs->compositeOp(COMPOSITE_OVER);
         KisPainter painter(dst);
         painter.setCompositeOp(op);
         painter.bitBlt(50, 50, src, 20, 20, 20, 20);
         painter.end();
         QCOMPARE(dst->exactBounds(), QRect(50,50,20,20));
     }
 
     dst->clear();
 
     {
         op = cs->compositeOp(COMPOSITE_COPY);
         KisPainter painter(dst);
         painter.setCompositeOp(op);
         painter.bitBlt(50, 50, src, 20, 20, 20, 20);
         painter.end();
         QCOMPARE(dst->exactBounds(), QRect(50,50,20,20));
     }
 }
 
 void KisPainterTest::testSimpleBlt()
 {
     allCsApplicator(&KisPainterTest::testSimpleBlt);
 }
 
 /*
 
 Note: the bltSelection tests assume the following geometry:
 
 0,0               0,30
   +---------+------+
   |  10,10  |      |
   |    +----+      |
   |    |####|      |
   |    |####|      |
   +----+----+      |
   |       20,20    |
   |                |
   |                |
   +----------------+
                   30,30
  */
 void KisPainterTest::testPaintDeviceBltSelection(const KoColorSpace * cs)
 {
 
     KisPaintDeviceSP dst = new KisPaintDevice(cs);
 
     KisPaintDeviceSP src = new KisPaintDevice(cs);
     KoColor c(Qt::red, cs);
     c.setOpacity(quint8(128));
     src->fill(0, 0, 20, 20, c.data());
 
     QCOMPARE(src->exactBounds(), QRect(0, 0, 20, 20));
 
     KisSelectionSP selection = new KisSelection();
     selection->pixelSelection()->select(QRect(10, 10, 20, 20));
     selection->updateProjection();
     QCOMPARE(selection->selectedExactRect(), QRect(10, 10, 20, 20));
 
     KisPainter painter(dst);
     painter.setSelection(selection);
 
     painter.bitBlt(0, 0, src, 0, 0, 30, 30);
     painter.end();
 
     QImage image = dst->convertToQImage(0);
     image.save("blt_Selection_" + cs->name() + ".png");
 
     QCOMPARE(dst->exactBounds(), QRect(10, 10, 10, 10));
 
     const KoCompositeOp* op = cs->compositeOp(COMPOSITE_SUBTRACT);
     if (op->id() == COMPOSITE_SUBTRACT) {
 
         KisPaintDeviceSP dst2 = new KisPaintDevice(cs);
         KisPainter painter2(dst2);
         painter2.setSelection(selection);
         painter2.setCompositeOp(op);
         painter2.bitBlt(0, 0, src, 0, 0, 30, 30);
         painter2.end();
 
         QCOMPARE(dst2->exactBounds(), QRect(10, 10, 10, 10));
     }
 }
 
 void KisPainterTest::testPaintDeviceBltSelection()
 {
     allCsApplicator(&KisPainterTest::testPaintDeviceBltSelection);
 }
 
 void KisPainterTest::testPaintDeviceBltSelectionIrregular(const KoColorSpace * cs)
 {
 
     KisPaintDeviceSP dst = new KisPaintDevice(cs);
     KisPaintDeviceSP src = new KisPaintDevice(cs);
     KisFillPainter gc(src);
     gc.fillRect(0, 0, 20, 20, KoColor(Qt::red, cs));
     gc.end();
 
     QCOMPARE(src->exactBounds(), QRect(0, 0, 20, 20));
 
     KisSelectionSP sel = new KisSelection();
 
     KisPixelSelectionSP psel = sel->pixelSelection();
     psel->select(QRect(10, 15, 20, 15));
     psel->select(QRect(15, 10, 15, 5));
 
     QCOMPARE(psel->selectedExactRect(), QRect(10, 10, 20, 20));
     QCOMPARE(TestUtil::alphaDevicePixel(psel, 13, 13), MIN_SELECTED);
 
     KisPainter painter(dst);
     painter.setSelection(sel);
     painter.bitBlt(0, 0, src, 0, 0, 30, 30);
     painter.end();
 
     QImage image = dst->convertToQImage(0);
     image.save("blt_Selection_irregular" + cs->name() + ".png");
 
     QCOMPARE(dst->exactBounds(), QRect(10, 10, 10, 10));
     Q_FOREACH (KoChannelInfo * channel, cs->channels()) {
         // Only compare alpha if there actually is an alpha channel in
         // this colorspace
         if (channel->channelType() == KoChannelInfo::ALPHA) {
             QColor c;
 
             dst->pixel(13, 13, &c);
 
             QCOMPARE((int) c.alpha(), (int) OPACITY_TRANSPARENT_U8);
         }
     }
 }
 
 
 void KisPainterTest::testPaintDeviceBltSelectionIrregular()
 {
     allCsApplicator(&KisPainterTest::testPaintDeviceBltSelectionIrregular);
 }
 
 void KisPainterTest::testPaintDeviceBltSelectionInverted(const KoColorSpace * cs)
 {
 
     KisPaintDeviceSP dst = new KisPaintDevice(cs);
     KisPaintDeviceSP src = new KisPaintDevice(cs);
     KisFillPainter gc(src);
     gc.fillRect(0, 0, 30, 30, KoColor(Qt::red, cs));
     gc.end();
     QCOMPARE(src->exactBounds(), QRect(0, 0, 30, 30));
 
     KisSelectionSP sel = new KisSelection();
     KisPixelSelectionSP psel = sel->pixelSelection();
     psel->select(QRect(10, 10, 20, 20));
     psel->invert();
     sel->updateProjection();
 
     KisPainter painter(dst);
     painter.setSelection(sel);
     painter.bitBlt(0, 0, src, 0, 0, 30, 30);
     painter.end();
     QCOMPARE(dst->exactBounds(), QRect(0, 0, 30, 30));
 }
 
 void KisPainterTest::testPaintDeviceBltSelectionInverted()
 {
     allCsApplicator(&KisPainterTest::testPaintDeviceBltSelectionInverted);
 }
 
 
 void KisPainterTest::testSelectionBltSelection()
 {
     KisPixelSelectionSP src = new KisPixelSelection();
     src->select(QRect(0, 0, 20, 20));
     QCOMPARE(src->selectedExactRect(), QRect(0, 0, 20, 20));
 
     KisSelectionSP sel = new KisSelection();
 
     KisPixelSelectionSP Selection = sel->pixelSelection();
     Selection->select(QRect(10, 10, 20, 20));
     QCOMPARE(Selection->selectedExactRect(), QRect(10, 10, 20, 20));
 
     sel->updateProjection();
     KisPixelSelectionSP dst = new KisPixelSelection();
     KisPainter painter(dst);
     painter.setSelection(sel);
     painter.bitBlt(0, 0, src, 0, 0, 30, 30);
     painter.end();
 
     QCOMPARE(dst->selectedExactRect(), QRect(10, 10, 10, 10));
 
     KisSequentialConstIterator it(dst, QRect(10, 10, 10, 10));
     while (it.nextPixel()) {
         // These are selections, so only one channel and it should
         // be totally selected
         QCOMPARE(it.oldRawData()[0], MAX_SELECTED);
     }
 }
 
 /*
 
 Test with non-square selection
 
 0,0               0,30
   +-----------+------+
   |    13,13  |      |
   |      x +--+      |
   |     +--+##|      |
   |     |#####|      |
   +-----+-----+      |
   |         20,20    |
   |                  |
   |                  |
   +------------------+
                   30,30
  */
 void KisPainterTest::testSelectionBltSelectionIrregular()
 {
 
     KisPaintDeviceSP dev = new KisPaintDevice(KoColorSpaceRegistry::instance()->rgb8());
 
     KisPixelSelectionSP src = new KisPixelSelection();
     src->select(QRect(0, 0, 20, 20));
     QCOMPARE(src->selectedExactRect(), QRect(0, 0, 20, 20));
 
     KisSelectionSP sel = new KisSelection();
 
     KisPixelSelectionSP Selection = sel->pixelSelection();
     Selection->select(QRect(10, 15, 20, 15));
     Selection->select(QRect(15, 10, 15, 5));
     QCOMPARE(Selection->selectedExactRect(), QRect(10, 10, 20, 20));
     QCOMPARE(TestUtil::alphaDevicePixel(Selection, 13, 13), MIN_SELECTED);
 
     sel->updateProjection();
 
     KisPixelSelectionSP dst = new KisPixelSelection();
     KisPainter painter(dst);
     painter.setSelection(sel);
     painter.bitBlt(0, 0, src, 0, 0, 30, 30);
     painter.end();
 
     QCOMPARE(dst->selectedExactRect(), QRect(10, 10, 10, 10));
     QCOMPARE(TestUtil::alphaDevicePixel(dst, 13, 13), MIN_SELECTED);
 }
 
 void KisPainterTest::testSelectionBitBltFixedSelection()
 {
     const KoColorSpace* cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dst = new KisPaintDevice(cs);
 
     KisPaintDeviceSP src = new KisPaintDevice(cs);
     KoColor c(Qt::red, cs);
     c.setOpacity(quint8(128));
     src->fill(0, 0, 20, 20, c.data());
 
     QCOMPARE(src->exactBounds(), QRect(0, 0, 20, 20));
 
     KisFixedPaintDeviceSP fixedSelection = new KisFixedPaintDevice(cs);
     fixedSelection->setRect(QRect(0, 0, 20, 20));
     fixedSelection->initialize();
     KoColor fill(Qt::white, cs);
     fixedSelection->fill(5, 5, 10, 10, fill.data());
     fixedSelection->convertTo(KoColorSpaceRegistry::instance()->alpha8());
 
     KisPainter painter(dst);
 
     painter.bitBltWithFixedSelection(0, 0, src, fixedSelection, 20, 20);
     painter.end();
 
     QCOMPARE(dst->exactBounds(), QRect(5, 5, 10, 10));
     /*
 dbgKrita << "canary1.5";
     dst->clear();
     painter.begin(dst);
 
     painter.bitBltWithFixedSelection(0, 0, src, fixedSelection, 10, 20);
     painter.end();
 dbgKrita << "canary2";
     QCOMPARE(dst->exactBounds(), QRect(5, 5, 5, 10));
 
     dst->clear();
     painter.begin(dst);
 
     painter.bitBltWithFixedSelection(0, 0, src, fixedSelection, 5, 5, 5, 5, 10, 20);
     painter.end();
 dbgKrita << "canary3";
     QCOMPARE(dst->exactBounds(), QRect(5, 5, 5, 10));
 
     dst->clear();
     painter.begin(dst);
 
     painter.bitBltWithFixedSelection(5, 5, src, fixedSelection, 10, 20);
     painter.end();
 dbgKrita << "canary4";
     QCOMPARE(dst->exactBounds(), QRect(10, 10, 5, 10));
     */
 }
 
 void KisPainterTest::testSelectionBitBltEraseCompositeOp()
 {
     const KoColorSpace* cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dst = new KisPaintDevice(cs);
     KoColor c(Qt::red, cs);
     dst->fill(0, 0, 150, 150, c.data());
 
     KisPaintDeviceSP src = new KisPaintDevice(cs);
     KoColor c2(Qt::black, cs);
     src->fill(50, 50, 50, 50, c2.data());
 
     KisSelectionSP sel = new KisSelection();
     KisPixelSelectionSP selection = sel->pixelSelection();
     selection->select(QRect(25, 25, 100, 100));
     sel->updateProjection();
 
     const KoCompositeOp* op = cs->compositeOp(COMPOSITE_ERASE);
     KisPainter painter(dst);
     painter.setSelection(sel);
     painter.setCompositeOp(op);
     painter.bitBlt(0, 0, src, 0, 0, 150, 150);
     painter.end();
 
     //dst->convertToQImage(0).save("result.png");
 
     QRect erasedRect(50, 50, 50, 50);
     KisSequentialConstIterator it(dst, QRect(0, 0, 150, 150));
     while (it.nextPixel()) {
         if(!erasedRect.contains(it.x(), it.y())) {
              QVERIFY(memcmp(it.oldRawData(), c.data(), cs->pixelSize()) == 0);
         }
     }
 
 }
 
 void KisPainterTest::testSimpleAlphaCopy()
 {
     KisPaintDeviceSP src = new KisPaintDevice(KoColorSpaceRegistry::instance()->alpha8());
     KisPaintDeviceSP dst = new KisPaintDevice(KoColorSpaceRegistry::instance()->alpha8());
     quint8 p = 128;
     src->fill(0, 0, 100, 100, &p);
     QVERIFY(src->exactBounds() == QRect(0, 0, 100, 100));
     KisPainter gc(dst);
     gc.setCompositeOp(KoColorSpaceRegistry::instance()->alpha8()->compositeOp(COMPOSITE_COPY));
     gc.bitBlt(QPoint(0, 0), src, src->exactBounds());
     gc.end();
     QCOMPARE(dst->exactBounds(), QRect(0, 0, 100, 100));
 
 }
 
 void KisPainterTest::checkPerformance()
 {
     KisPaintDeviceSP src = new KisPaintDevice(KoColorSpaceRegistry::instance()->alpha8());
     KisPaintDeviceSP dst = new KisPaintDevice(KoColorSpaceRegistry::instance()->alpha8());
     quint8 p = 128;
     src->fill(0, 0, 10000, 5000, &p);
     KisSelectionSP sel = new KisSelection();
     sel->pixelSelection()->select(QRect(0, 0, 10000, 5000), 128);
     sel->updateProjection();
 
     QTime t;
     t.start();
     for (int i = 0; i < 10; ++i) {
         KisPainter gc(dst);
         gc.bitBlt(0, 0, src, 0, 0, 10000, 5000);
     }
 
     t.restart();
     for (int i = 0; i < 10; ++i) {
         KisPainter gc(dst, sel);
         gc.bitBlt(0, 0, src, 0, 0, 10000, 5000);
     }
 }
 
 void KisPainterTest::testBitBltOldData()
 {
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->alpha8();
 
     KisPaintDeviceSP src = new KisPaintDevice(cs);
     KisPaintDeviceSP dst = new KisPaintDevice(cs);
 
     quint8 defaultPixel = 0;
     quint8 p1 = 128;
     quint8 p2 = 129;
     quint8 p3 = 130;
     KoColor defaultColor(&defaultPixel, cs);
     KoColor color1(&p1, cs);
     KoColor color2(&p2, cs);
     KoColor color3(&p3, cs);
     QRect fillRect(0,0,5000,5000);
 
     src->fill(fillRect, color1);
 
     KisPainter srcGc(src);
     srcGc.beginTransaction();
     src->fill(fillRect, color2);
 
     KisPainter dstGc(dst);
     dstGc.bitBltOldData(QPoint(), src, fillRect);
 
     QVERIFY(TestUtil::checkAlphaDeviceFilledWithPixel(dst, fillRect, p1));
 
     dstGc.end();
     srcGc.deleteTransaction();
 }
 
 #include "kis_paint_device_debug_utils.h"
 #include "KisRenderedDab.h"
 
 void testMassiveBltFixedImpl(int numRects, bool varyOpacity = false, bool useSelection = false)
 {
     const KoColorSpace* cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dst = new KisPaintDevice(cs);
 
     QList<QColor> colors;
     colors << Qt::red;
     colors << Qt::green;
     colors << Qt::blue;
 
     QRect devicesRect;
     QList<KisRenderedDab> devices;
 
     for (int i = 0; i < numRects; i++) {
         const QRect rc(10 + i * 10, 10 + i * 10, 30, 30);
         KisFixedPaintDeviceSP dev = new KisFixedPaintDevice(cs);
         dev->setRect(rc);
         dev->initialize();
         dev->fill(rc, KoColor(colors[i % 3], cs));
         dev->fill(kisGrowRect(rc, -5), KoColor(Qt::white, cs));
 
         KisRenderedDab dab;
         dab.device = dev;
         dab.offset = dev->bounds().topLeft();
         dab.opacity = varyOpacity ? qreal(1 + i) / numRects : 1.0;
         dab.flow = 1.0;
 
         devices << dab;
         devicesRect |= rc;
     }
 
     KisSelectionSP selection;
 
     if (useSelection) {
         selection = new KisSelection();
         selection->pixelSelection()->select(kisGrowRect(devicesRect, -7));
     }
 
     const QString opacityPostfix = varyOpacity ? "_varyop" : "";
     const QString selectionPostfix = useSelection ? "_sel" : "";
 
     const QRect fullRect = kisGrowRect(devicesRect, 10);
 
     {
         KisPainter painter(dst);
         painter.setSelection(selection);
         painter.bltFixed(fullRect, devices);
         painter.end();
         QVERIFY(TestUtil::checkQImage(dst->convertToQImage(0, fullRect),
                                       "kispainter_test",
                                       "massive_bitblt",
                                       QString("full_update_%1%2%3")
                                           .arg(numRects)
                                           .arg(opacityPostfix)
                                           .arg(selectionPostfix), 1, 1));
     }
 
     dst->clear();
 
     {
         KisPainter painter(dst);
         painter.setSelection(selection);
 
         for (int i = fullRect.x(); i <= fullRect.center().x(); i += 10) {
             const QRect rc(i, fullRect.y(), 10, fullRect.height());
             painter.bltFixed(rc, devices);
         }
 
         painter.end();
 
         QVERIFY(TestUtil::checkQImage(dst->convertToQImage(0, fullRect),
                                       "kispainter_test",
                                       "massive_bitblt",
                                       QString("partial_update_%1%2%3")
                                           .arg(numRects)
                                           .arg(opacityPostfix)
-                                          .arg(selectionPostfix)));
+                                          .arg(selectionPostfix), 1, 1));
 
     }
 }
 
 void KisPainterTest::testMassiveBltFixedSingleTile()
 {
     testMassiveBltFixedImpl(3);
 }
 
 void KisPainterTest::testMassiveBltFixedMultiTile()
 {
     testMassiveBltFixedImpl(6);
 }
 
 void KisPainterTest::testMassiveBltFixedMultiTileWithOpacity()
 {
     testMassiveBltFixedImpl(6, true);
 }
 
 void KisPainterTest::testMassiveBltFixedMultiTileWithSelection()
 {
     testMassiveBltFixedImpl(6, false, true);
 }
 
 void KisPainterTest::testMassiveBltFixedCornerCases()
 {
     const KoColorSpace* cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP dst = new KisPaintDevice(cs);
 
     QList<KisRenderedDab> devices;
 
     QVERIFY(dst->extent().isEmpty());
 
     {
         // empty devices, shouldn't crash
         KisPainter painter(dst);
         painter.bltFixed(QRect(60,60,20,20), devices);
         painter.end();
     }
 
     QVERIFY(dst->extent().isEmpty());
 
     const QRect rc(10,10,20,20);
     KisFixedPaintDeviceSP dev = new KisFixedPaintDevice(cs);
     dev->setRect(rc);
     dev->initialize();
     dev->fill(rc, KoColor(Qt::white, cs));
 
     devices.append(KisRenderedDab(dev));
 
     {
         // rect outside the devices bounds, shouldn't crash
         KisPainter painter(dst);
         painter.bltFixed(QRect(60,60,20,20), devices);
         painter.end();
     }
 
     QVERIFY(dst->extent().isEmpty());
 }
 
 
 #include "kis_lod_transform.h"
 
 inline QRect extentifyRect(const QRect &rc)
 {
     return KisLodTransform::alignedRect(rc, 6);
 }
 
 void testOptimizedCopyingImpl(const QRect &srcRect,
                               const QRect &dstRect,
                               const QRect &srcCopyRect,
                               const QPoint &dstPt,
                               const QRect &expectedDstBounds)
 {
     const QRect expectedDstExtent = extentifyRect(expectedDstBounds);
 
     const KoColorSpace* cs = KoColorSpaceRegistry::instance()->rgb8();
     KisPaintDeviceSP src = new KisPaintDevice(cs);
     KisPaintDeviceSP dst = new KisPaintDevice(cs);
 
     const KoColor color1(Qt::red, cs);
     const KoColor color2(Qt::blue, cs);
 
     src->fill(srcRect, color1);
     dst->fill(dstRect, color2);
 
     KisPainter::copyAreaOptimized(dstPt, src, dst, srcCopyRect);
 
     //KIS_DUMP_DEVICE_2(dst, QRect(0,0,5000,5000), "dst", "dd");
 
     QCOMPARE(dst->exactBounds(), expectedDstBounds);
     QCOMPARE(dst->extent(), expectedDstExtent);
 }
 
 void KisPainterTest::testOptimizedCopying()
 {
     const QRect srcRect(1000, 1000, 1000, 1000);
     const QRect srcCopyRect(0, 0, 5000, 5000);
 
 
     testOptimizedCopyingImpl(srcRect, QRect(6000, 500, 1000,1000),
                              srcCopyRect, srcCopyRect.topLeft(),
                              QRect(1000, 500, 6000, 1500));
 
     testOptimizedCopyingImpl(srcRect, QRect(4500, 1500, 1000, 1000),
                              srcCopyRect, srcCopyRect.topLeft(),
                              QRect(1000, 1000, 4500, 1500));
 
     testOptimizedCopyingImpl(srcRect, QRect(2500, 2500, 1000, 1000),
                              srcCopyRect, srcCopyRect.topLeft(),
                              srcRect);
 
     testOptimizedCopyingImpl(srcRect, QRect(1200, 1200, 600, 1600),
                              srcCopyRect, srcCopyRect.topLeft(),
                              srcRect);
 
     testOptimizedCopyingImpl(srcRect, QRect(1200, 1200, 600, 600),
                              srcCopyRect, srcCopyRect.topLeft(),
                              srcRect);
 
 }
 
 KISTEST_MAIN(KisPainterTest)
 
 
diff --git a/libs/image/tests/kis_selection_test.cpp b/libs/image/tests/kis_selection_test.cpp
index 78faffc2e1..e4f98411b0 100644
--- a/libs/image/tests/kis_selection_test.cpp
+++ b/libs/image/tests/kis_selection_test.cpp
@@ -1,340 +1,340 @@
 /*
  *  Copyright (c) 2007 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_selection_test.h"
 #include <QTest>
 
 
 #include <kis_debug.h>
 #include <QRect>
 
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoCompositeOpRegistry.h>
 
 #include "kis_datamanager.h"
 #include "kis_pixel_selection.h"
 #include "kis_selection.h"
 #include "kis_fill_painter.h"
 #include "kis_mask.h"
 #include "kis_image.h"
 #include "kis_transparency_mask.h"
 #include "testutil.h"
 
 #include <KoColorModelStandardIds.h>
 
 void KisSelectionTest::testGrayColorspaceConversion()
 {
     const KoColorSpace *csA =
         KoColorSpaceRegistry::instance()->
         colorSpace(GrayAColorModelID.id(),
                    Integer8BitsColorDepthID.id(),
                    QString());
 
     const KoColorSpace *csNoA =
         KoColorSpaceRegistry::instance()->alpha8();
 
     QVERIFY(csA);
     QVERIFY(csNoA);
 
     QCOMPARE(csA->pixelSize(), 2U);
     QCOMPARE(csNoA->pixelSize(), 1U);
 
     quint8 color1[1] = {128};
     quint8 color2[2] = {64,32};
 
     csA->convertPixelsTo(color2, color1, csNoA, 1,
                          KoColorConversionTransformation::internalRenderingIntent(),
                          KoColorConversionTransformation::internalConversionFlags());
 
     QCOMPARE((int)color1[0], 8);
 
     csNoA->convertPixelsTo(color1, color2, csA, 1,
                            KoColorConversionTransformation::internalRenderingIntent(),
                            KoColorConversionTransformation::internalConversionFlags());
 
     QCOMPARE((int)color2[0], 8);
     QCOMPARE((int)color2[1], 255);
 }
 
 void KisSelectionTest::testGrayColorspaceOverComposition()
 {
     const KoColorSpace *csA =
         KoColorSpaceRegistry::instance()->
         colorSpace(GrayAColorModelID.id(),
                    Integer8BitsColorDepthID.id(),
                    QString());
     const KoColorSpace *csNoA =
         KoColorSpaceRegistry::instance()->alpha8();
 
     QVERIFY(csA);
     QVERIFY(csNoA);
 
     QCOMPARE(csA->pixelSize(), 2U);
     QCOMPARE(csNoA->pixelSize(), 1U);
 
     quint8 color0[2] = {32,255};
     quint8 color1[2] = {128,64};
     quint8 color3[1] = {32};
 
     KoCompositeOp::ParameterInfo params;
     params.dstRowStart = color0;
     params.dstRowStride = 0;
     params.srcRowStart = color1;
     params.srcRowStride = 0;
     params.maskRowStart = 0;
     params.maskRowStride = 0;
     params.rows = 1;
     params.cols = 1;
     params.opacity = 1.0;
     params.flow = 1.0;
 
     csA->bitBlt(csA, params, csA->compositeOp(COMPOSITE_OVER),
                 KoColorConversionTransformation::internalRenderingIntent(),
                 KoColorConversionTransformation::internalConversionFlags());
 
     QCOMPARE((int)color0[0], 56);
     QCOMPARE((int)color0[1], 255);
 
     params.dstRowStart = color3;
 
     csNoA->bitBlt(csA, params, csNoA->compositeOp(COMPOSITE_OVER),
                   KoColorConversionTransformation::internalRenderingIntent(),
                   KoColorConversionTransformation::internalConversionFlags());
 
     QCOMPARE((int)color3[0], 56);
 }
 
 void KisSelectionTest::testSelectionComponents()
 {
     KisSelectionSP selection = new KisSelection();
 
     QCOMPARE(selection->hasPixelSelection(), false);
     QCOMPARE(selection->hasShapeSelection(), false);
     QCOMPARE(selection->shapeSelection(), (void*)0);
 
     selection->pixelSelection()->select(QRect(10,10,10,10));
     QCOMPARE(selection->hasPixelSelection(), true);
     QCOMPARE(selection->selectedExactRect(), QRect(10,10,10,10));
 }
 
 void KisSelectionTest::testSelectionActions()
 {
     KisSelectionSP selection = new KisSelection();
     QVERIFY(selection->hasPixelSelection() == false);
     QVERIFY(selection->hasShapeSelection() == false);
 
     KisPixelSelectionSP pixelSelection = selection->pixelSelection();
     pixelSelection->select(QRect(0, 0, 20, 20));
 
     KisPixelSelectionSP tmpSel = new KisPixelSelection();
     tmpSel->select(QRect(10, 0, 20, 20));
 
     pixelSelection->applySelection(tmpSel, SELECTION_ADD);
     QCOMPARE(pixelSelection->selectedExactRect(), QRect(0, 0, 30, 20));
     QCOMPARE(selection->selectedExactRect(), QRect(0, 0, 30, 20));
 
     pixelSelection->clear();
     pixelSelection->select(QRect(0, 0, 20, 20));
 
     pixelSelection->applySelection(tmpSel, SELECTION_SUBTRACT);
     QCOMPARE(pixelSelection->selectedExactRect(), QRect(0, 0, 10, 20));
     QCOMPARE(selection->selectedExactRect(), QRect(0, 0, 10, 20));
 
     pixelSelection->clear();
     pixelSelection->select(QRect(0, 0, 20, 20));
 
     pixelSelection->applySelection(tmpSel, SELECTION_INTERSECT);
     QCOMPARE(pixelSelection->selectedExactRect(), QRect(10, 0, 10, 20));
     QCOMPARE(selection->selectedExactRect(), QRect(10, 0, 10, 20));
 }
 
 void KisSelectionTest::testInvertSelection()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(0, 1024, 1024, cs, "stest");
 
     KisSelectionSP selection = new KisSelection(new KisDefaultBounds(image));
     KisPixelSelectionSP pixelSelection = selection->pixelSelection();
     pixelSelection->select(QRect(20, 20, 20, 20));
 
     QCOMPARE(TestUtil::alphaDevicePixel(pixelSelection, 30, 30), MAX_SELECTED);
     QCOMPARE(TestUtil::alphaDevicePixel(pixelSelection, 0, 0), MIN_SELECTED);
     QCOMPARE(TestUtil::alphaDevicePixel(pixelSelection, 512, 512), MIN_SELECTED);
     QCOMPARE(pixelSelection->selectedExactRect(), QRect(20, 20, 20, 20));
 
     pixelSelection->invert();
 
     QCOMPARE(TestUtil::alphaDevicePixel(pixelSelection, 100, 100), MAX_SELECTED);
     QCOMPARE(TestUtil::alphaDevicePixel(pixelSelection, 22, 22), MIN_SELECTED);
     QCOMPARE(TestUtil::alphaDevicePixel(pixelSelection, 0, 0), MAX_SELECTED);
     QCOMPARE(TestUtil::alphaDevicePixel(pixelSelection, 512, 512), MAX_SELECTED);
     QCOMPARE(pixelSelection->selectedExactRect(), QRect(0,0,1024,1024));
     QCOMPARE(pixelSelection->selectedRect(), QRect(0,0,1024,1024));
 
     selection->updateProjection();
 
     QCOMPARE(selection->selectedExactRect(), QRect(0,0,1024,1024));
     QCOMPARE(selection->selectedRect(), QRect(0,0,1024,1024));
 
     QCOMPARE(TestUtil::alphaDevicePixel(selection->projection(), 100, 100), MAX_SELECTED);
     QCOMPARE(TestUtil::alphaDevicePixel(selection->projection(), 22, 22), MIN_SELECTED);
     QCOMPARE(TestUtil::alphaDevicePixel(selection->projection(), 10, 10), MAX_SELECTED);
     QCOMPARE(TestUtil::alphaDevicePixel(selection->projection(), 0, 0), MAX_SELECTED);
     QCOMPARE(TestUtil::alphaDevicePixel(selection->projection(), 512, 512), MAX_SELECTED);
 }
 
 void KisSelectionTest::testInvertSelectionSemi()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(0, 1024, 1024, cs, "stest");
 
     KisSelectionSP selection = new KisSelection(new KisDefaultBounds(image));
     KisPixelSelectionSP pixelSelection = selection->pixelSelection();
     quint8 selectedness = 42;
     pixelSelection->select(QRect(20, 20, 20, 20), selectedness);
 
     QCOMPARE(TestUtil::alphaDevicePixel(pixelSelection, 30, 30), selectedness);
     QCOMPARE(TestUtil::alphaDevicePixel(pixelSelection, 0, 0), MIN_SELECTED);
     QCOMPARE(pixelSelection->selectedExactRect(), QRect(20, 20, 20, 20));
 
     pixelSelection->invert();
 
     quint8 invertedSelectedness = MAX_SELECTED - selectedness;
     QCOMPARE(TestUtil::alphaDevicePixel(pixelSelection, 30, 30), invertedSelectedness);
     QCOMPARE(TestUtil::alphaDevicePixel(pixelSelection, 0, 0), MAX_SELECTED);
     QCOMPARE(pixelSelection->selectedExactRect(), QRect(0,0,1024,1024));
     QCOMPARE(pixelSelection->selectedRect(), QRect(0,0,1024,1024));
 
     selection->updateProjection();
 
     QCOMPARE(selection->selectedExactRect(), QRect(0,0,1024,1024));
     QCOMPARE(selection->selectedRect(), QRect(0,0,1024,1024));
 
     QCOMPARE(TestUtil::alphaDevicePixel(selection->projection(), 30, 30), invertedSelectedness);
     QCOMPARE(TestUtil::alphaDevicePixel(selection->projection(), 0, 0), MAX_SELECTED);
 }
 
 void KisSelectionTest::testCopy()
 {
     KisSelectionSP sel = new KisSelection();
     sel->pixelSelection()->select(QRect(10, 10, 200, 200), 128);
 
     sel->updateProjection();
 
     KisSelectionSP sel2 = new KisSelection(*sel.data());
     QCOMPARE(sel2->selectedExactRect(), sel->selectedExactRect());
 
     QPoint errpoint;
     if (!TestUtil::comparePaintDevices(errpoint, sel->projection(), sel2->projection())) {
         sel2->projection()->convertToQImage(0, 0, 0, 200, 200).save("merge_visitor6.png");
         QFAIL(QString("Failed to copy selection, first different pixel: %1,%2 ")
               .arg(errpoint.x())
               .arg(errpoint.y())
               .toLatin1());
     }
 }
 
 void KisSelectionTest::testSelectionExactBounds()
 {
     QRect referenceImageRect(0,0,1000,1000);
     QRect referenceDeviceRect(100,100,1040,1040);
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
 
     KisImageSP image = new KisImage(0, referenceImageRect.width(),
                                     referenceImageRect.height(),
                                     cs, "stest");
 
     KisPaintDeviceSP device = new KisPaintDevice(cs);
     device->fill(referenceDeviceRect, KoColor(Qt::white, cs));
 
     QCOMPARE(device->exactBounds(), referenceDeviceRect);
 
     KisSelectionSP selection = new KisSelection(new KisSelectionDefaultBounds(device, image));
 
     quint8 defaultPixel = MAX_SELECTED;
     selection->pixelSelection()->setDefaultPixel(KoColor(&defaultPixel, selection->pixelSelection()->colorSpace()));
 
     // the selection uses device's extent only for performance reasons
     // \see bug 320213
     QCOMPARE(selection->selectedExactRect(), device->extent() | referenceImageRect);
 }
 
 void KisSelectionTest::testSetParentNodeAfterCreation()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(0, 100, 100, cs, "stest");
     KisSelectionSP selection = new KisSelection();
     KisPixelSelectionSP pixelSelection = selection->pixelSelection();
 
     QCOMPARE(selection->parentNode(), KisNodeWSP(0));
     QCOMPARE(selection->pixelSelection()->parentNode(), KisNodeWSP(0));
 
     selection->setParentNode(image->root());
 
     QCOMPARE(selection->parentNode(), KisNodeWSP(image->root()));
     QCOMPARE(selection->pixelSelection()->parentNode(), KisNodeWSP(image->root()));
 }
 
 void KisSelectionTest::testSetParentNodeBeforeCreation()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(0, 100, 100, cs, "stest");
     KisSelectionSP selection = new KisSelection();
 
     selection->setParentNode(image->root());
 
     KisPixelSelectionSP pixelSelection = selection->pixelSelection();
 
     QCOMPARE(selection->parentNode(), KisNodeWSP(image->root()));
     QCOMPARE(selection->pixelSelection()->parentNode(), KisNodeWSP(image->root()));
 }
 
 void KisSelectionTest::testOutlineGeneration()
 {
     KisSelectionSP sel = new KisSelection();
     sel->pixelSelection()->select(QRect(428,436, 430,211), 128);
 
     QVERIFY(sel->outlineCacheValid());
 
     QPainterPath originalOutline = sel->outlineCache();
 
     sel->pixelSelection()->invalidateOutlineCache();
     sel->recalculateOutlineCache();
 
     QPainterPath calculatedOutline = sel->outlineCache();
 
     QPainterPath closedSubPath = calculatedOutline;
     closedSubPath.closeSubpath();
 
     /**
      * Our outline generation code has a small problem: it can
      * generate a polygon, which isn't closed (it'll repeat the first
      * point instead). There is a special workaround for it in
      * KisPixelSelection::recalculateOutlineCache(), which explicitly
      * closes the path, so here we just check it.
      */
 
     bool isClosed = closedSubPath == calculatedOutline;
     QVERIFY(isClosed);
 }
 
-QTEST_MAIN(KisSelectionTest)
+KISTEST_MAIN(KisSelectionTest)
 
 
diff --git a/libs/image/tests/kis_strokes_queue_test.cpp b/libs/image/tests/kis_strokes_queue_test.cpp
index 59c91e13ee..55ac7a8de2 100644
--- a/libs/image/tests/kis_strokes_queue_test.cpp
+++ b/libs/image/tests/kis_strokes_queue_test.cpp
@@ -1,838 +1,839 @@
 /*
  *  Copyright (c) 2011 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_strokes_queue_test.h"
 #include <QTest>
 
 #include "scheduler_utils.h"
 #include "kis_strokes_queue.h"
 #include "kis_updater_context.h"
 #include "kis_update_job_item.h"
 #include "kis_merge_walker.h"
 
 
 void KisStrokesQueueTest::testSequentialJobs()
 {
     KisStrokesQueue queue;
     KisStrokeId id = queue.startStroke(new KisTestingStrokeStrategy("tri_", false));
     queue.addJob(id, new KisStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.addJob(id, new KisStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.addJob(id, new KisStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.endStroke(id);
 
     KisTestableUpdaterContext context(2);
     QVector<KisUpdateJobItem*> jobs;
 
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "tri_init");
     VERIFY_EMPTY(jobs[1]);
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "tri_dab");
     COMPARE_NAME(jobs[1], "tri_dab");
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "tri_dab");
     VERIFY_EMPTY(jobs[1]);
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "tri_finish");
     VERIFY_EMPTY(jobs[1]);
 }
 
 void KisStrokesQueueTest::testConcurrentSequentialBarrier()
 {
     KisStrokesQueue queue;
     KisStrokeId id = queue.startStroke(new KisTestingStrokeStrategy("tri_", false));
     queue.addJob(id, new KisStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.addJob(id, new KisStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.endStroke(id);
 
     // make the number of threads higher
     KisTestableUpdaterContext context(3);
     QVector<KisUpdateJobItem*> jobs;
 
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "tri_init");
     VERIFY_EMPTY(jobs[1]);
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "tri_dab");
     COMPARE_NAME(jobs[1], "tri_dab");
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "tri_finish");
     VERIFY_EMPTY(jobs[1]);
 }
 
 void KisStrokesQueueTest::testExclusiveStrokes()
 {
     KisStrokesQueue queue;
     KisStrokeId id = queue.startStroke(new KisTestingStrokeStrategy("excl_", true));
     queue.addJob(id, new KisStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.addJob(id, new KisStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.addJob(id, new KisStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.endStroke(id);
 
     // well, this walker is not initialized... but who cares?
     KisBaseRectsWalkerSP walker = new KisMergeWalker(QRect());
 
     KisTestableUpdaterContext context(2);
     QVector<KisUpdateJobItem*> jobs;
 
     context.addMergeJob(walker);
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_WALKER(jobs[0], walker);
     VERIFY_EMPTY(jobs[1]);
     QCOMPARE(queue.needsExclusiveAccess(), true);
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "excl_init");
     VERIFY_EMPTY(jobs[1]);
     QCOMPARE(queue.needsExclusiveAccess(), true);
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "excl_dab");
     COMPARE_NAME(jobs[1], "excl_dab");
     QCOMPARE(queue.needsExclusiveAccess(), true);
 
     context.clear();
     context.addMergeJob(walker);
     queue.processQueue(context, false);
 
     COMPARE_WALKER(jobs[0], walker);
     VERIFY_EMPTY(jobs[1]);
     QCOMPARE(queue.needsExclusiveAccess(), true);
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "excl_dab");
     VERIFY_EMPTY(jobs[1]);
     QCOMPARE(queue.needsExclusiveAccess(), true);
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "excl_finish");
     VERIFY_EMPTY(jobs[1]);
     QCOMPARE(queue.needsExclusiveAccess(), true);
 
     context.clear();
     queue.processQueue(context, false);
 
     QCOMPARE(queue.needsExclusiveAccess(), false);
 }
 
 void KisStrokesQueueTest::testBarrierStrokeJobs()
 {
     KisStrokesQueue queue;
     KisStrokeId id = queue.startStroke(new KisTestingStrokeStrategy("nor_", false));
     queue.addJob(id, new KisStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.addJob(id, new KisStrokeJobData(KisStrokeJobData::BARRIER));
     queue.addJob(id, new KisStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.endStroke(id);
 
     // yes, this walker is not initialized again... but who cares?
     KisBaseRectsWalkerSP walker = new KisMergeWalker(QRect());
     bool externalJobsPending = false;
 
     KisTestableUpdaterContext context(3);
     QVector<KisUpdateJobItem*> jobs;
 
     queue.processQueue(context, externalJobsPending);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "nor_init");
     VERIFY_EMPTY(jobs[1]);
     VERIFY_EMPTY(jobs[2]);
 
     context.clear();
 
     queue.processQueue(context, externalJobsPending);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "nor_dab");
     VERIFY_EMPTY(jobs[1]);
     VERIFY_EMPTY(jobs[2]);
 
     // Now some updates has come...
     context.addMergeJob(walker);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "nor_dab");
     COMPARE_WALKER(jobs[1], walker);
     VERIFY_EMPTY(jobs[2]);
 
     // No difference for the queue
     queue.processQueue(context, externalJobsPending);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "nor_dab");
     COMPARE_WALKER(jobs[1], walker);
     VERIFY_EMPTY(jobs[2]);
 
     // Even more updates has come...
     externalJobsPending = true;
 
     // Still no difference for the queue
     queue.processQueue(context, externalJobsPending);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "nor_dab");
     COMPARE_WALKER(jobs[1], walker);
     VERIFY_EMPTY(jobs[2]);
 
     // Now clear the context
     context.clear();
 
     // And still no difference for the queue
     queue.processQueue(context, externalJobsPending);
 
     jobs = context.getJobs();
     VERIFY_EMPTY(jobs[0]);
     VERIFY_EMPTY(jobs[1]);
     VERIFY_EMPTY(jobs[2]);
 
     // Process the last update...
     context.addMergeJob(walker);
     externalJobsPending = false;
 
     // Yep, the queue is still waiting
     queue.processQueue(context, externalJobsPending);
 
     jobs = context.getJobs();
     COMPARE_WALKER(jobs[0], walker);
     VERIFY_EMPTY(jobs[1]);
     VERIFY_EMPTY(jobs[2]);
 
     context.clear();
 
     // Finally, we can do our work. Barrier job is executed alone
     queue.processQueue(context, externalJobsPending);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "nor_dab");
     VERIFY_EMPTY(jobs[1]);
     VERIFY_EMPTY(jobs[2]);
 
     // Barrier job has finished
     context.clear();
 
     jobs = context.getJobs();
     VERIFY_EMPTY(jobs[0]);
     VERIFY_EMPTY(jobs[1]);
     VERIFY_EMPTY(jobs[2]);
 
     // fetch the last (concurrent) one
     queue.processQueue(context, externalJobsPending);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "nor_dab");
     VERIFY_EMPTY(jobs[1]);
     VERIFY_EMPTY(jobs[2]);
 
     context.clear();
 
     // finish the stroke
     queue.processQueue(context, externalJobsPending);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "nor_finish");
     VERIFY_EMPTY(jobs[1]);
     VERIFY_EMPTY(jobs[2]);
 
     context.clear();
 }
 
 void KisStrokesQueueTest::testStrokesOverlapping()
 {
     KisStrokesQueue queue;
     KisStrokeId id = queue.startStroke(new KisTestingStrokeStrategy("1_", false, true));
     queue.addJob(id, 0);
 
     // comment out this line to catch an assert
     queue.endStroke(id);
 
     id = queue.startStroke(new KisTestingStrokeStrategy("2_", false, true));
     queue.addJob(id, 0);
     queue.endStroke(id);
 
     // uncomment this line to catch an assert
     // queue.addJob(id, 0);
 
     KisTestableUpdaterContext context(2);
     QVector<KisUpdateJobItem*> jobs;
 
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "1_dab");
     VERIFY_EMPTY(jobs[1]);
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "2_dab");
     VERIFY_EMPTY(jobs[1]);
 }
 
 void KisStrokesQueueTest::testImmediateCancel()
 {
     KisStrokesQueue queue;
     KisTestableUpdaterContext context(2);
 
     KisStrokeId id = queue.startStroke(new KisTestingStrokeStrategy("1_", false, false));
     queue.cancelStroke(id);
 
     // this should not crash
     queue.processQueue(context, false);
 }
 
 void KisStrokesQueueTest::testOpenedStrokeCounter()
 {
     KisStrokesQueue queue;
 
     QVERIFY(!queue.hasOpenedStrokes());
     KisStrokeId id0 = queue.startStroke(new KisTestingStrokeStrategy("0"));
     QVERIFY(queue.hasOpenedStrokes());
     KisStrokeId id1 = queue.startStroke(new KisTestingStrokeStrategy("1"));
     QVERIFY(queue.hasOpenedStrokes());
     queue.endStroke(id0);
     QVERIFY(queue.hasOpenedStrokes());
     queue.endStroke(id1);
     QVERIFY(!queue.hasOpenedStrokes());
 
     KisTestableUpdaterContext context(2);
     queue.processQueue(context, false); context.clear();
     queue.processQueue(context, false); context.clear();
     queue.processQueue(context, false); context.clear();
     queue.processQueue(context, false); context.clear();
 }
 
 void KisStrokesQueueTest::testAsyncCancelWhileOpenedStroke()
 {
     KisStrokesQueue queue;
     KisStrokeId id = queue.startStroke(new KisTestingStrokeStrategy("nor_", false));
     queue.addJob(id, 0);
     queue.addJob(id, 0);
     queue.addJob(id, 0);
 
     // no async cancelling until the stroke is ended by the owner
     QVERIFY(!queue.tryCancelCurrentStrokeAsync());
 
     queue.endStroke(id);
 
     QVERIFY(queue.tryCancelCurrentStrokeAsync());
 
     bool externalJobsPending = false;
 
     KisTestableUpdaterContext context(3);
     QVector<KisUpdateJobItem*> jobs;
 
     queue.processQueue(context, externalJobsPending);
 
     // no? really?
     jobs = context.getJobs();
     VERIFY_EMPTY(jobs[0]);
     VERIFY_EMPTY(jobs[1]);
     VERIFY_EMPTY(jobs[2]);
 }
 
 struct KisStrokesQueueTest::LodStrokesQueueTester {
 
     LodStrokesQueueTester(bool real = false)
         : fakeContext(2),
           realContext(2),
           context(!real ? fakeContext : realContext)
     {
         queue.setSuspendUpdatesStrokeStrategyFactory(
             []() {
                 return KisSuspendResumePair(
                     new KisTestingStrokeStrategy("susp_u_", false, true, true),
                     QList<KisStrokeJobData*>());
             });
 
         queue.setResumeUpdatesStrokeStrategyFactory(
             []() {
                 return KisSuspendResumePair(
                     new KisTestingStrokeStrategy("resu_u_", false, true, true),
                     QList<KisStrokeJobData*>());
             });
         queue.setLod0ToNStrokeStrategyFactory(
             [](bool forgettable) {
                 Q_UNUSED(forgettable);
                 return KisSuspendResumePair(
                     new KisTestingStrokeStrategy("sync_u_", false, true, true),
                     QList<KisStrokeJobData*>());
             });
     }
 
     KisStrokesQueue queue;
 
     KisTestableUpdaterContext fakeContext;
     KisUpdaterContext realContext;
     KisUpdaterContext &context;
     QVector<KisUpdateJobItem*> jobs;
 
     void processQueueNoAdd() {
         if (&context != &fakeContext) return;
 
         fakeContext.clear();
 
         jobs = fakeContext.getJobs();
         VERIFY_EMPTY(jobs[0]);
         VERIFY_EMPTY(jobs[1]);
     }
 
     void processQueueNoContextClear() {
         queue.processQueue(context, false);
 
         if (&context == &realContext) {
             context.waitForDone();
         }
     }
 
     void processQueue() {
         processQueueNoAdd();
         queue.processQueue(context, false);
 
         if (&context == &realContext) {
             context.waitForDone();
         }
     }
 
     void checkNothing() {
         KIS_ASSERT(&context == &fakeContext);
 
         jobs = fakeContext.getJobs();
         VERIFY_EMPTY(jobs[0]);
         VERIFY_EMPTY(jobs[1]);
     }
 
     void checkJobs(const QStringList &list) {
         KIS_ASSERT(&context == &fakeContext);
 
         jobs = fakeContext.getJobs();
 
         for (int i = 0; i < 2; i++) {
             if (list.size() <= i) {
                 VERIFY_EMPTY(jobs[i]);
             } else {
                 QVERIFY(jobs[i]->isRunning());
                 COMPARE_NAME(jobs[i], list[i]);
             }
         }
 
         QCOMPARE(queue.needsExclusiveAccess(), false);
     }
 
     void checkOnlyJob(const QString &name) {
         KIS_ASSERT(&context == &fakeContext);
 
         jobs = fakeContext.getJobs();
         COMPARE_NAME(jobs[0], name);
         VERIFY_EMPTY(jobs[1]);
         QCOMPARE(queue.needsExclusiveAccess(), false);
     }
 
     void checkOnlyExecutedJob(const QString &name) {
         realContext.waitForDone();
         QVERIFY(!globalExecutedDabs.isEmpty());
         QCOMPARE(globalExecutedDabs[0], name);
 
         QCOMPARE(globalExecutedDabs.size(), 1);
         globalExecutedDabs.clear();
     }
 
     void checkExecutedJobs(const QStringList &list) {
         realContext.waitForDone();
 
         QCOMPARE(globalExecutedDabs, list);
         globalExecutedDabs.clear();
     }
 
     void checkNothingExecuted() {
         realContext.waitForDone();
         QVERIFY(globalExecutedDabs.isEmpty());
     }
 };
 
 
 void KisStrokesQueueTest::testStrokesLevelOfDetail()
 {
     LodStrokesQueueTester t;
     KisStrokesQueue &queue = t.queue;
 
     // create a stroke with LOD0 + LOD2
     queue.setDesiredLevelOfDetail(2);
 
     // process sync-lodn-planes stroke
     t.processQueue();
     t.checkOnlyJob("sync_u_init");
 
     KisStrokeId id2 = queue.startStroke(new KisTestingStrokeStrategy("lod_", false, true));
     queue.addJob(id2, new KisTestingStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.endStroke(id2);
 
     // create a update with LOD == 0 (default one)
     // well, this walker is not initialized... but who cares?
     KisBaseRectsWalkerSP walker = new KisMergeWalker(QRect());
 
     KisTestableUpdaterContext context(2);
     QVector<KisUpdateJobItem*> jobs;
 
     context.addMergeJob(walker);
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_WALKER(jobs[0], walker);
     VERIFY_EMPTY(jobs[1]);
     QCOMPARE(queue.needsExclusiveAccess(), false);
 
     context.clear();
 
     jobs = context.getJobs();
     VERIFY_EMPTY(jobs[0]);
     VERIFY_EMPTY(jobs[1]);
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "clone2_lod_dab");
     VERIFY_EMPTY(jobs[1]);
     QCOMPARE(queue.needsExclusiveAccess(), false);
 
     // walker of a different LOD must not be allowed
     QCOMPARE(context.isJobAllowed(walker), false);
 
     context.clear();
     context.addMergeJob(walker);
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_WALKER(jobs[0], walker);
     COMPARE_NAME(jobs[1], "susp_u_init");
     QCOMPARE(queue.needsExclusiveAccess(), false);
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "lod_dab");
     VERIFY_EMPTY(jobs[1]);
     QCOMPARE(queue.needsExclusiveAccess(), false);
 
     context.clear();
     queue.processQueue(context, false);
 
     jobs = context.getJobs();
     COMPARE_NAME(jobs[0], "resu_u_init");
     VERIFY_EMPTY(jobs[1]);
     QCOMPARE(queue.needsExclusiveAccess(), false);
 
     context.clear();
 }
 
 #include <kundo2command.h>
 #include <kis_post_execution_undo_adapter.h>
 struct TestUndoCommand : public KUndo2Command
 {
     TestUndoCommand(const QString &text) : KUndo2Command(kundo2_noi18n(text)) {}
 
     void undo() override {
         ENTER_FUNCTION();
         undoCount++;
     }
 
     void redo() override {
         ENTER_FUNCTION();
         redoCount++;
     }
 
     int undoCount = 0;
     int redoCount = 0;
 };
 
 void KisStrokesQueueTest::testLodUndoBase()
 {
     LodStrokesQueueTester t;
     KisStrokesQueue &queue = t.queue;
 
     // create a stroke with LOD0 + LOD2
     queue.setDesiredLevelOfDetail(2);
 
     // process sync-lodn-planes stroke
     t.processQueue();
     t.checkOnlyJob("sync_u_init");
 
     KisStrokeId id1 = queue.startStroke(new KisTestingStrokeStrategy("str1_", false, true));
     queue.addJob(id1, new KisTestingStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.endStroke(id1);
 
     KisStrokeId id2 = queue.startStroke(new KisTestingStrokeStrategy("str2_", false, true));
     queue.addJob(id2, new KisTestingStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.endStroke(id2);
 
     t.processQueue();
     t.checkOnlyJob("clone2_str1_dab");
 
 
     QSharedPointer<TestUndoCommand> undoStr1(new TestUndoCommand("str1_undo"));
     queue.lodNPostExecutionUndoAdapter()->addCommand(undoStr1);
 
     t.processQueue();
     t.checkOnlyJob("clone2_str2_dab");
 
     QSharedPointer<TestUndoCommand> undoStr2(new TestUndoCommand("str2_undo"));
     queue.lodNPostExecutionUndoAdapter()->addCommand(undoStr2);
 
     t.processQueue();
     t.checkOnlyJob("susp_u_init");
 
     t.processQueue();
     t.checkOnlyJob("str1_dab");
 
     t.processQueue();
     t.checkOnlyJob("str2_dab");
 
     t.processQueue();
     t.checkOnlyJob("resu_u_init");
 }
 
 void KisStrokesQueueTest::testLodUndoBase2()
 {
     LodStrokesQueueTester t(true);
     KisStrokesQueue &queue = t.queue;
 
     // create a stroke with LOD0 + LOD2
     queue.setDesiredLevelOfDetail(2);
     KisStrokeId id1 = queue.startStroke(new KisTestingStrokeStrategy("str1_", false, true, false, true));
     queue.addJob(id1, new KisTestingStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.endStroke(id1);
 
     KisStrokeId id2 = queue.startStroke(new KisTestingStrokeStrategy("str2_", false, true, false, true));
     queue.addJob(id2, new KisTestingStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.endStroke(id2);
 
     t.processQueue();
     t.checkOnlyExecutedJob("sync_u_init");
 
     t.processQueue();
     t.checkOnlyExecutedJob("clone2_str1_dab");
 
     QSharedPointer<TestUndoCommand> undoStr1(new TestUndoCommand("str1_undo"));
     queue.lodNPostExecutionUndoAdapter()->addCommand(undoStr1);
 
     t.processQueue();
     t.checkOnlyExecutedJob("clone2_str2_dab");
 
     QSharedPointer<TestUndoCommand> undoStr2(new TestUndoCommand("str2_undo"));
     queue.lodNPostExecutionUndoAdapter()->addCommand(undoStr2);
 
     t.processQueue();
     t.checkOnlyExecutedJob("susp_u_init");
 
     queue.tryUndoLastStrokeAsync();
     t.processQueue();
 
     while (queue.currentStrokeName() == kundo2_noi18n("str2_undo")) {
         //queue.debugPrintStrokes();
         t.processQueue();
     }
 
     QCOMPARE(undoStr2->undoCount, 1);
 
     t.checkOnlyExecutedJob("str1_dab");
 
     t.processQueue();
     t.checkOnlyExecutedJob("str2_cancel");
 
     t.processQueue();
     t.checkOnlyExecutedJob("resu_u_init");
 }
 
 void KisStrokesQueueTest::testMutatedJobs()
 {
     LodStrokesQueueTester t(true);
     KisStrokesQueue &queue = t.queue;
 
     KisStrokeId id1 = queue.startStroke(new KisTestingStrokeStrategy("str1_", false, true, false, true));
 
     queue.addJob(id1,
                  new KisTestingStrokeJobData(
                      KisStrokeJobData::CONCURRENT,
                      KisStrokeJobData::NORMAL,
                      true, "1"));
 
     queue.addJob(id1,
                  new KisTestingStrokeJobData(
                      KisStrokeJobData::SEQUENTIAL,
                      KisStrokeJobData::NORMAL,
                      false, "2"));
 
     queue.endStroke(id1);
 
     t.processQueue();
 
     t.checkOnlyExecutedJob("str1_dab_1");
 
     t.processQueue();
 
     QStringList refList;
     refList << "str1_dab_mutated" << "str1_dab_mutated";
     t.checkExecutedJobs(refList);
 
     t.processQueue();
     t.checkOnlyExecutedJob("str1_dab_mutated");
 
     t.processQueue();
     t.checkOnlyExecutedJob("str1_dab_2");
 
     t.processQueue();
     t.checkNothingExecuted();
 }
 
 QString sequentialityToString(KisStrokeJobData::Sequentiality seq) {
     QString result = "<unknown>";
 
     switch (seq) {
     case KisStrokeJobData::SEQUENTIAL:
         result = "SEQUENTIAL";
         break;
     case KisStrokeJobData::UNIQUELY_CONCURRENT:
         result = "UNIQUELY_CONCURRENT";
         break;
     case KisStrokeJobData::BARRIER:
         result = "BARRIER";
         break;
     case KisStrokeJobData::CONCURRENT:
         result = "CONCURRENT";
         break;
     }
 
     return result;
 }
 
 void KisStrokesQueueTest::checkJobsOverlapping(LodStrokesQueueTester &t,
                                                KisStrokeId id,
                                                KisStrokeJobData::Sequentiality first,
                                                KisStrokeJobData::Sequentiality second,
                                                bool allowed)
 {
     t.queue.addJob(id, new KisTestingStrokeJobData(first,
                                                    KisStrokeJobData::NORMAL, false, "first"));
     t.processQueue();
     t.checkJobs({"str1_dab_first"});
 
     t.queue.addJob(id, new KisTestingStrokeJobData(second,
                                                    KisStrokeJobData::NORMAL, false, "second"));
 
     qDebug() << QString("  test %1 after %2 allowed: %3 ")
                 .arg(sequentialityToString(second), 24)
                 .arg(sequentialityToString(first), 24)
                 .arg(allowed);
 
     if (allowed) {
         t.processQueueNoContextClear();
         t.checkJobs({"str1_dab_first", "str1_dab_second"});
     } else {
         t.processQueueNoContextClear();
         t.checkJobs({"str1_dab_first"});
 
         t.processQueue();
         t.checkJobs({"str1_dab_second"});
     }
 
     t.processQueueNoAdd();
     t.checkNothing();
 }
 
 void KisStrokesQueueTest::testUniquelyConcurrentJobs()
 {
     LodStrokesQueueTester t;
     KisStrokesQueue &queue = t.queue;
 
     KisStrokeId id1 = queue.startStroke(new KisTestingStrokeStrategy("str1_", false, true));
     queue.addJob(id1, new KisTestingStrokeJobData(KisStrokeJobData::CONCURRENT));
     queue.addJob(id1, new KisTestingStrokeJobData(KisStrokeJobData::CONCURRENT));
-    queue.endStroke(id1);
 
     { // manual test
         t.processQueue();
         t.checkJobs({"str1_dab", "str1_dab"});
 
         queue.addJob(id1, new KisTestingStrokeJobData(KisStrokeJobData::CONCURRENT));
         t.processQueue();
         t.checkJobs({"str1_dab"});
 
         queue.addJob(id1, new KisTestingStrokeJobData(KisStrokeJobData::UNIQUELY_CONCURRENT,
                                                   KisStrokeJobData::NORMAL, false, "ucon"));
         t.processQueueNoContextClear();
         t.checkJobs({"str1_dab", "str1_dab_ucon"});
 
         t.processQueueNoAdd();
         t.checkNothing();
     }
 
     // Test various cases of overlapping
 
     checkJobsOverlapping(t, id1, KisStrokeJobData::UNIQUELY_CONCURRENT, KisStrokeJobData::CONCURRENT, true);
     checkJobsOverlapping(t, id1, KisStrokeJobData::UNIQUELY_CONCURRENT, KisStrokeJobData::UNIQUELY_CONCURRENT, false);
     checkJobsOverlapping(t, id1, KisStrokeJobData::UNIQUELY_CONCURRENT, KisStrokeJobData::SEQUENTIAL, false);
     checkJobsOverlapping(t, id1, KisStrokeJobData::UNIQUELY_CONCURRENT, KisStrokeJobData::BARRIER, false);
 
     checkJobsOverlapping(t, id1, KisStrokeJobData::CONCURRENT, KisStrokeJobData::UNIQUELY_CONCURRENT , true);
     checkJobsOverlapping(t, id1, KisStrokeJobData::UNIQUELY_CONCURRENT, KisStrokeJobData::UNIQUELY_CONCURRENT, false);
     checkJobsOverlapping(t, id1, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::UNIQUELY_CONCURRENT, false);
     checkJobsOverlapping(t, id1, KisStrokeJobData::BARRIER, KisStrokeJobData::UNIQUELY_CONCURRENT, false);
+
+    queue.endStroke(id1);
 }
 
 
 QTEST_MAIN(KisStrokesQueueTest)
diff --git a/libs/image/tiles3/KisTiledExtentManager.cpp b/libs/image/tiles3/KisTiledExtentManager.cpp
index 4844a005ac..66f85a0327 100644
--- a/libs/image/tiles3/KisTiledExtentManager.cpp
+++ b/libs/image/tiles3/KisTiledExtentManager.cpp
@@ -1,322 +1,328 @@
 /*
  *  Copyright (c) 2017 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.
  */
 
 #include "KisTiledExtentManager.h"
 
 #include <QMutex>
 #include <QVector>
 #include "kis_tile_data_interface.h"
 #include "kis_assert.h"
 #include "kis_global.h"
 #include "kis_debug.h"
 
 KisTiledExtentManager::Data::Data()
     : m_min(qint32_MAX), m_max(qint32_MIN), m_count(0)
 {
     QWriteLocker lock(&m_migrationLock);
     m_capacity = InitialBufferSize;
     m_offset = 1;
     m_buffer = new QAtomicInt[m_capacity];
 }
 
 KisTiledExtentManager::Data::~Data()
 {
     QWriteLocker lock(&m_migrationLock);
     delete[] m_buffer;
 }
 
 inline bool KisTiledExtentManager::Data::add(qint32 index)
 {
     QReadLocker lock(&m_migrationLock);
     qint32 currentIndex = m_offset + index;
 
     if (currentIndex < 0 || currentIndex >= m_capacity) {
         lock.unlock();
         migrate(index);
         lock.relock();
         currentIndex = m_offset + index;
     }
 
     KIS_ASSERT_RECOVER_NOOP(m_buffer[currentIndex].loadAcquire() >= 0);
     bool needsUpdateExtent = false;
     QReadLocker rl(&m_extentLock);
 
     if (!m_buffer[currentIndex].loadAcquire()) {
         rl.unlock();
         QWriteLocker wl(&m_extentLock);
 
         if (!m_buffer[currentIndex].load()) {
             m_buffer[currentIndex].store(1);
 
             if (m_min > index) m_min = index;
             if (m_max < index) m_max = index;
 
             ++m_count;
             needsUpdateExtent = true;
         } else {
             m_buffer[currentIndex].ref();
         }
     } else {
         m_buffer[currentIndex].ref();
     }
 
     return needsUpdateExtent;
 }
 
 inline bool KisTiledExtentManager::Data::remove(qint32 index)
 {
     QReadLocker lock(&m_migrationLock);
     qint32 currentIndex = m_offset + index;
 
     KIS_ASSERT_RECOVER_NOOP(m_buffer[currentIndex].loadAcquire() > 0);
     bool needsUpdateExtent = false;
     QReadLocker rl(&m_extentLock);
 
     if (m_buffer[currentIndex].loadAcquire() == 1) {
         rl.unlock();
         QWriteLocker wl(&m_extentLock);
 
         if (m_buffer[currentIndex].load() == 1) {
             m_buffer[currentIndex].store(0);
 
             if (m_min == index) updateMin();
             if (m_max == index) updateMax();
 
             --m_count;
             needsUpdateExtent = true;
         } else {
-            KIS_ASSERT_RECOVER_NOOP(0 && "sanity check failed: the tile has already been removed!");
+            m_buffer[currentIndex].deref();
         }
     } else {
         m_buffer[currentIndex].deref();
     }
 
     return needsUpdateExtent;
 }
 
 void KisTiledExtentManager::Data::replace(const QVector<qint32> &indexes)
 {
     QWriteLocker lock(&m_migrationLock);
     QWriteLocker l(&m_extentLock);
 
     for (qint32 i = 0; i < m_capacity; ++i) {
         m_buffer[i].store(0);
     }
 
     m_min = qint32_MAX;
     m_max = qint32_MIN;
     m_count = 0;
 
     Q_FOREACH (const qint32 index, indexes) {
         unsafeAdd(index);
     }
 }
 
 void KisTiledExtentManager::Data::clear()
 {
     QWriteLocker lock(&m_migrationLock);
     QWriteLocker l(&m_extentLock);
 
     for (qint32 i = 0; i < m_capacity; ++i) {
         m_buffer[i].store(0);
     }
 
     m_min = qint32_MAX;
     m_max = qint32_MIN;
     m_count = 0;
 }
 
 bool KisTiledExtentManager::Data::isEmpty()
 {
     return m_count == 0;
 }
 
 qint32 KisTiledExtentManager::Data::min()
 {
     return m_min;
 }
 
 qint32 KisTiledExtentManager::Data::max()
 {
     return m_max;
 }
 
 void KisTiledExtentManager::Data::unsafeAdd(qint32 index)
 {
     qint32 currentIndex = m_offset + index;
 
     if (currentIndex < 0 || currentIndex >= m_capacity) {
         unsafeMigrate(index);
         currentIndex = m_offset + index;
     }
 
     if (!m_buffer[currentIndex].fetchAndAddRelaxed(1)) {
         if (m_min > index) m_min = index;
         if (m_max < index) m_max = index;
         ++m_count;
     }
 }
 
 void KisTiledExtentManager::Data::unsafeMigrate(qint32 index)
 {
     qint32 oldCapacity = m_capacity;
     qint32 oldOffset = m_offset;
     qint32 currentIndex = m_offset + index;
 
     while (currentIndex < 0 || currentIndex >= m_capacity) {
         m_capacity <<= 1;
 
         if (currentIndex < 0) {
             m_offset <<= 1;
             currentIndex = m_offset + index;
         }
     }
 
     if (m_capacity != oldCapacity) {
         QAtomicInt *newBuffer = new QAtomicInt[m_capacity];
         qint32 start = m_offset - oldOffset;
 
         for (qint32 i = 0; i < oldCapacity; ++i) {
             newBuffer[start + i].store(m_buffer[i].load());
         }
 
         delete[] m_buffer;
         m_buffer = newBuffer;
     }
 }
 
 void KisTiledExtentManager::Data::migrate(qint32 index)
 {
     QWriteLocker lock(&m_migrationLock);
     unsafeMigrate(index);
 }
 
 void KisTiledExtentManager::Data::updateMin()
 {
     qint32 start = m_min + m_offset;
 
     for (qint32 i = start; i < m_capacity; ++i) {
         qint32 current = m_buffer[i].load();
 
         if (current > 0) {
             m_min = i - m_offset;
             break;
         }
     }
 }
 
 void KisTiledExtentManager::Data::updateMax()
 {
     qint32 start = m_max + m_offset;
 
     for (qint32 i = start; i >= 0; --i) {
         qint32 current = m_buffer[i].load();
 
         if (current > 0) {
             m_max = i - m_offset;
             break;
         }
     }
 }
 
 KisTiledExtentManager::KisTiledExtentManager()
 {
     QWriteLocker l(&m_extentLock);
     m_currentExtent = QRect(qint32_MAX, qint32_MAX, 0, 0);
 }
 
 void KisTiledExtentManager::notifyTileAdded(qint32 col, qint32 row)
 {
     bool needsUpdateExtent = false;
 
     needsUpdateExtent |= m_colsData.add(col);
     needsUpdateExtent |= m_rowsData.add(row);
 
     if (needsUpdateExtent) {
         updateExtent();
     }
 }
 
 void KisTiledExtentManager::notifyTileRemoved(qint32 col, qint32 row)
 {
     bool needsUpdateExtent = false;
 
     needsUpdateExtent |= m_colsData.remove(col);
     needsUpdateExtent |= m_rowsData.remove(row);
 
     if (needsUpdateExtent) {
         updateExtent();
     }
 }
 
 void KisTiledExtentManager::replaceTileStats(const QVector<QPoint> &indexes)
 {
     QVector<qint32> colsIndexes;
     QVector<qint32> rowsIndexes;
 
     Q_FOREACH (const QPoint &index, indexes) {
         colsIndexes.append(index.x());
         rowsIndexes.append(index.y());
     }
 
     m_colsData.replace(colsIndexes);
     m_rowsData.replace(rowsIndexes);
     updateExtent();
 }
 
 void KisTiledExtentManager::clear()
 {
     m_colsData.clear();
     m_rowsData.clear();
 
     QWriteLocker lock(&m_extentLock);
     m_currentExtent = QRect(qint32_MAX, qint32_MAX, 0, 0);
 }
 
 QRect KisTiledExtentManager::extent() const
 {
     QReadLocker lock(&m_extentLock);
     return m_currentExtent;
 }
 
 void KisTiledExtentManager::updateExtent()
 {
-    QReadLocker cl(&m_colsData.m_extentLock);
-    QReadLocker rl(&m_rowsData.m_extentLock);
+    qint32 minX, maxX, minY, maxY;
 
-    bool colsEmpty = m_colsData.isEmpty();
-    bool rowsEmpty = m_rowsData.isEmpty();
-    KIS_ASSERT_RECOVER_RETURN(colsEmpty == rowsEmpty);
+    {
+        QReadLocker cl(&m_colsData.m_extentLock);
 
-    if (colsEmpty && rowsEmpty) {
-        QWriteLocker lock(&m_extentLock);
-        m_currentExtent = QRect(qint32_MAX, qint32_MAX, 0, 0);
-    } else {
-        const qint32 minX = m_colsData.min() * KisTileData::WIDTH;
-        const qint32 maxPlusOneX = (m_colsData.max() + 1) * KisTileData::WIDTH;
-        const qint32 minY = m_rowsData.min() * KisTileData::HEIGHT;
-        const qint32 maxPlusOneY = (m_rowsData.max() + 1) * KisTileData::HEIGHT;
-
-        QWriteLocker lock(&m_extentLock);
-        m_currentExtent =
-            QRect(minX, minY,
-                  maxPlusOneX - minX,
-                  maxPlusOneY - minY);
+        if (m_colsData.isEmpty()) {
+            minX = qint32_MAX;
+            maxX = 0;
+        } else {
+            minX = m_colsData.min() * KisTileData::WIDTH;
+            maxX = (m_colsData.max() + 1) * KisTileData::WIDTH - minX;
+        }
+    }
+
+    {
+        QReadLocker rl(&m_rowsData.m_extentLock);
+
+        if (m_rowsData.isEmpty()) {
+            minY = qint32_MAX;
+            maxY = 0;
+        } else {
+            minY = m_rowsData.min() * KisTileData::HEIGHT;
+            maxY = (m_rowsData.max() + 1) * KisTileData::HEIGHT - minY;
+        }
     }
+
+    QWriteLocker lock(&m_extentLock);
+    m_currentExtent = QRect(minX, minY, maxX, maxY);
 }
diff --git a/libs/image/tiles3/kis_tile_data_interface.h b/libs/image/tiles3/kis_tile_data_interface.h
index 5251477ed0..2874a59b56 100644
--- a/libs/image/tiles3/kis_tile_data_interface.h
+++ b/libs/image/tiles3/kis_tile_data_interface.h
@@ -1,327 +1,327 @@
 /*
  *  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.
  */
 
 #ifndef KIS_TILE_DATA_INTERFACE_H_
 #define KIS_TILE_DATA_INTERFACE_H_
 
 #include <QReadWriteLock>
 #include <QAtomicInt>
 
 #include "kis_lockless_stack.h"
 #include "swap/kis_chunk_allocator.h"
 
 class KisTileData;
 class KisTileDataStore;
 
 /**
  * WARNING: Those definitions for internal use only!
  * Please use KisTileData::WIDTH/HEIGHT instead
  */
 #define __TILE_DATA_WIDTH 64
 #define __TILE_DATA_HEIGHT 64
 
 typedef KisLocklessStack<KisTileData*> KisTileDataCache;
 
 typedef QLinkedList<KisTileData*> KisTileDataList;
 typedef KisTileDataList::iterator KisTileDataListIterator;
 typedef KisTileDataList::const_iterator KisTileDataListConstIterator;
 
 
 class SimpleCache
 {
 public:
     SimpleCache() = default;
     ~SimpleCache();
 
     bool push(int pixelSize, quint8 *&ptr)
     {
         QReadLocker l(&m_cacheLock);
         switch (pixelSize) {
         case 4:
             m_4Pool.push(ptr);
             break;
         case 8:
             m_8Pool.push(ptr);
             break;
         case 16:
             m_16Pool.push(ptr);
             break;
         default:
             return false;
         }
 
         return true;
     }
 
     bool pop(int pixelSize, quint8 *&ptr)
     {
         QReadLocker l(&m_cacheLock);
         switch (pixelSize) {
         case 4:
             return m_4Pool.pop(ptr);
         case 8:
             return m_8Pool.pop(ptr);
         case 16:
             return m_16Pool.pop(ptr);
         default:
             return false;
         }
     }
 
     void clear();
 
 private:
     QReadWriteLock m_cacheLock;
     KisLocklessStack<quint8*> m_4Pool;
     KisLocklessStack<quint8*> m_8Pool;
     KisLocklessStack<quint8*> m_16Pool;
 };
 
 
 /**
  * Stores actual tile's data
  */
-class KisTileData
+class KRITAIMAGE_EXPORT KisTileData
 {
 public:
     KisTileData(qint32 pixelSize, const quint8 *defPixel, KisTileDataStore *store, bool checkFreeMemory = true);
 
 private:
     KisTileData(const KisTileData& rhs, bool checkFreeMemory = true);
 
 public:
     ~KisTileData();
 
     enum EnumTileDataState {
         NORMAL = 0,
         COMPRESSED,
         SWAPPED
     };
 
     /**
      * Information about data stored
      */
     inline quint8* data() const;
     inline void setData(const quint8 *data);
     inline quint32 pixelSize() const;
 
     /**
      * Increments usersCount of a TD and refs shared pointer counter
      * Used by KisTile for COW
      */
     inline bool acquire();
 
     /**
      * Decrements usersCount of a TD and derefs shared pointer counter
      * Used by KisTile for COW
      */
     inline bool release();
 
     /**
      * Only refs shared pointer counter.
      * Used only by KisMementoManager without
      * consideration of COW.
      */
     inline bool ref() const;
 
     /**
      * Only refs shared pointer counter.
      * Used only by KisMementoManager without
      * consideration of COW.
      */
     inline bool deref();
 
     /**
      * Creates a clone of the tile data safely.
      * It will try to use the cached clones.
      */
     inline KisTileData* clone();
 
     /**
      * Control the access of swapper to the tile data
      */
     inline void blockSwapping();
     inline void unblockSwapping();
 
     /**
      * The position of the tile data in a swap file
      */
     inline KisChunk swapChunk() const;
     inline void setSwapChunk(KisChunk chunk);
 
     /**
      * Show whether a tile data is a part of history
      */
     inline bool mementoed() const;
     inline void setMementoed(bool value);
 
     /**
      * Controlling methods for setting 'age' marks
      */
     inline int age() const;
     inline void resetAge();
     inline void markOld();
 
     /**
      * Returns number of tiles (or memento items),
      * referencing the tile data.
      */
     inline qint32 numUsers() const;
 
     /**
      * Conveniece method. Returns true iff the tile data is linked to
      * information only and therefore can be swapped out easily.
      *
      * Effectively equivalent to: (mementoed() && numUsers() <= 1)
      */
     inline bool historical() const;
 
     /**
      * Used for swapping purposes only.
      * Frees the memory occupied by the tile data.
      * (the caller must save the data beforehand)
      */
     void releaseMemory();
 
     /**
      * Used for swapping purposes only.
      * Allocates memory for the tile data after
      * it has been freed in releaseMemory().
      * NOTE: the new data can be not-initialized
      *       and you must fill it yourself!
      *
      * \see releaseMemory()
      */
     void allocateMemory();
 
     /**
      * Releases internal pools, which keep blobs where the tiles are
      * stored.  The point is that we don't allocate the tiles from
      * glibc directly, but use pools (implemented via boost) to
      * allocate bigger chunks. This method should be called when one
      * knows that we have just free'd quite a lot of memory and we
      * won't need it anymore. E.g. when a document has been closed.
      */
     static void releaseInternalPools();
 
 private:
     void fillWithPixel(const quint8 *defPixel);
 
     static quint8* allocateData(const qint32 pixelSize);
     static void freeData(quint8 *ptr, const qint32 pixelSize);
 private:
     friend class KisTileDataPooler;
     friend class KisTileDataPoolerTest;
     /**
      * A list of pre-duplicated tiledatas.
      * To make a COW faster, KisTileDataPooler thread duplicates
      * a tile beforehand and stores clones here, in this stack
      */
     KisTileDataCache m_clonesStack;
 
 private:
     friend class KisTile;
     friend class KisTileDataStore;
 
     friend class KisTileDataStoreIterator;
     friend class KisTileDataStoreReverseIterator;
     friend class KisTileDataStoreClockIterator;
 
     /**
      * The state of the tile.
      * Filled in by tileDataStore and
      * checked in KisTile::acquireFor*
      * see also: comment for @m_data
      */
     mutable EnumTileDataState m_state;
 
     /**
      * Iterator that points to a position in the list
      * where the tile data is stored
      */
     int m_tileNumber = -1;
 
 private:
     /**
      * The chunk of the swap file, that corresponds
      * to this tile data. Used by KisSwappedDataStore.
      */
     KisChunk m_swapChunk;
 
 
     /**
      * The flag is set by KisMementoItem to show this
      * tile data is going down in history.
      *
      * (m_mementoFlag && m_usersCount == 1) means that
      * the only user of tile data is a memento manager.
      */
     qint32 m_mementoFlag;
 
     /**
      * Counts up time after last access to the tile data.
      * 0 - recently accessed
      * 1+ - not recently accessed
      */
     //FIXME: make memory aligned
     int m_age;
 
 
     /**
      * The primitive for controlling swapping of the tile.
      * lockForRead() - used by regular threads to ensure swapper
      *                 won't touch this tile data.
      * tryLockForWrite() - used by swapper to check no-one reads
      *                     this tile data
      */
     QReadWriteLock m_swapLock;
 
 private:
     friend class KisLowMemoryTests;
 
     /**
      * FIXME: We should be able to work in const environment
      * even when actual data is swapped out to disk
      */
     mutable quint8* m_data;
 
     /**
      * How many tiles/mementoes use
      * this tiledata through COW?
      */
     mutable QAtomicInt m_usersCount;
 
     /**
      * Shared pointer counter
      */
     mutable QAtomicInt m_refCount;
 
 
     qint32 m_pixelSize;
     //qint32 m_timeStamp;
 
     KisTileDataStore *m_store;
     static SimpleCache m_cache;
 
 public:
     static const qint32 WIDTH;
     static const qint32 HEIGHT;
 };
 
 #endif /* KIS_TILE_DATA_INTERFACE_H_ */
diff --git a/libs/image/tiles3/kis_tile_data_pooler.h b/libs/image/tiles3/kis_tile_data_pooler.h
index 130b8b3287..fea06fa8de 100644
--- a/libs/image/tiles3/kis_tile_data_pooler.h
+++ b/libs/image/tiles3/kis_tile_data_pooler.h
@@ -1,101 +1,103 @@
 /*
  *  Copyright (c) 2009 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef KIS_TILE_DATA_POOLER_H_
 #define KIS_TILE_DATA_POOLER_H_
 
 #include <QObject>
 #include <QThread>
 #include <QSemaphore>
 
+#include "kritaimage_export.h"
+
 class KisTileDataStore;
 class KisTileData;
 
 
-class KisTileDataPooler : public QThread
+class KRITAIMAGE_EXPORT KisTileDataPooler : public QThread
 {
     Q_OBJECT
 
 public:
 
     KisTileDataPooler(KisTileDataStore *store, qint32 memoryLimit = -1);
     ~KisTileDataPooler() override;
 
     void kick();
     void terminatePooler();
 
     void testingRereadConfig();
 
     qint64 lastPoolMemoryMetric() const;
     qint64 lastRealMemoryMetric() const;
     qint64 lastHistoricalMemoryMetric() const;
 
 
     /**
      * Is case the pooler thread is not running, the user might force
      * recalculation of the memory statistics explicitly.
      */
     void forceUpdateMemoryStats();
 
 protected:
     static const qint32 MAX_NUM_CLONES;
     static const qint32 MAX_TIMEOUT;
     static const qint32 MIN_TIMEOUT;
     static const qint32 TIMEOUT_FACTOR;
 
     void waitForWork();
     qint32 numClonesNeeded(KisTileData *td) const;
     void cloneTileData(KisTileData *td, qint32 numClones) const;
     void run() override;
 
     inline int clonesMetric(KisTileData *td, int numClones);
     inline int clonesMetric(KisTileData *td);
 
     inline void tryFreeOrphanedClones(KisTileData *td);
     inline qint32 needMemory(KisTileData *td);
     inline qint32 canDonorMemory(KisTileData *td);
     qint32 tryGetMemory(QList<KisTileData*> &donors, qint32 memoryMetric);
 
     template<class Iter>
         void getLists(Iter *iter, QList<KisTileData*> &beggers,
                       QList<KisTileData*> &donors,
                       qint32 &memoryOccupied,
                       qint32 &statRealMemory,
                       qint32 &statHistoricalMemory);
 
     bool processLists(QList<KisTileData*> &beggers,
                       QList<KisTileData*> &donors,
                       qint32 &memoryOccupied);
 
 private:
     void debugTileStatistics();
 protected:
     QSemaphore m_semaphore;
     QAtomicInt m_shouldExitFlag;
     KisTileDataStore *m_store;
     qint32 m_timeout;
     bool m_lastCycleHadWork;
     qint32 m_memoryLimit;
     qint32 m_lastPoolMemoryMetric;
     qint32 m_lastRealMemoryMetric;
     qint32 m_lastHistoricalMemoryMetric;
 };
 
 
 
 #endif /* KIS_TILE_DATA_POOLER_H_ */
 
diff --git a/libs/image/tiles3/kis_tile_hash_table2.h b/libs/image/tiles3/kis_tile_hash_table2.h
index c1abcd7db3..52da906ba9 100644
--- a/libs/image/tiles3/kis_tile_hash_table2.h
+++ b/libs/image/tiles3/kis_tile_hash_table2.h
@@ -1,410 +1,431 @@
 /*
  *  Copyright (c) 2018 Andrey Kamakin <a.kamakin@icloud.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_TILEHASHTABLE_2_H
 #define KIS_TILEHASHTABLE_2_H
 
 #include "kis_shared.h"
 #include "kis_shared_ptr.h"
 #include "3rdparty/lock_free_map/concurrent_map.h"
 #include "kis_tile.h"
+#include "kis_debug.h"
 
 #define SANITY_CHECK
 
 /**
  * This is a  template for a hash table that stores  tiles (or some other
  * objects  resembling tiles).   Actually, this  object should  only have
- * col()/row() methods and be able to answer setNext()/next() requests to
+ * col()/row() methods and be able to answer notifyDead() requests to
  * be   stored   here.    It   is   used   in   KisTiledDataManager   and
  * KisMementoManager.
  *
  * How to use:
  *   1) each hash must be unique, otherwise tiles would rewrite each-other
  *   2) 0 key is reserved, so can't be used
  *   3) col and row must be less than 0x7FFF to guarantee uniqueness of hash for each pair
  */
 
 template <class T>
 class KisTileHashTableIteratorTraits2;
 
 template <class T>
 class KisTileHashTableTraits2
 {
     static constexpr bool isInherited = std::is_convertible<T*, KisShared*>::value;
     Q_STATIC_ASSERT_X(isInherited, "Template must inherit KisShared");
 
 public:
     typedef T TileType;
     typedef KisSharedPtr<T> TileTypeSP;
     typedef KisWeakSharedPtr<T> TileTypeWSP;
 
     KisTileHashTableTraits2(KisMementoManager *mm);
     KisTileHashTableTraits2(const KisTileHashTableTraits2<T> &ht, KisMementoManager *mm);
     ~KisTileHashTableTraits2();
 
     bool isEmpty()
     {
         return !m_numTiles.load();
     }
 
     bool tileExists(qint32 col, qint32 row);
 
     /**
      * Returns a tile in position (col,row). If no tile exists,
      * returns null.
      * \param col column of the tile
      * \param row row of the tile
      */
     TileTypeSP getExistingTile(qint32 col, qint32 row);
 
     /**
      * Returns a tile in position (col,row). If no tile exists,
      * creates a new one, attaches it to the list and returns.
      * \param col column of the tile
      * \param row row of the tile
      * \param newTile out-parameter, returns true if a new tile
      *                was created
      */
     TileTypeSP getTileLazy(qint32 col, qint32 row, bool& newTile);
 
     /**
      * Returns a tile in position (col,row). If no tile exists,
      * creates nothing, but returns shared default tile object
      * of the table. Be careful, this object has column and row
      * parameters set to (qint32_MIN, qint32_MIN).
      * \param col column of the tile
      * \param row row of the tile
      * \param existingTile returns true if the tile actually exists in the table
      *                     and it is not a lazily created default wrapper tile
      */
     TileTypeSP getReadOnlyTileLazy(qint32 col, qint32 row, bool &existingTile);
     void addTile(TileTypeSP tile);
     bool deleteTile(TileTypeSP tile);
     bool deleteTile(qint32 col, qint32 row);
 
     void clear();
 
     void setDefaultTileData(KisTileData *defaultTileData);
     KisTileData* defaultTileData();
 
     qint32 numTiles()
     {
         return m_numTiles.load();
     }
 
     void debugPrintInfo();
     void debugMaxListLength(qint32 &min, qint32 &max);
 
     friend class KisTileHashTableIteratorTraits2<T>;
 
 private:
     struct MemoryReclaimer {
         MemoryReclaimer(TileType *data) : d(data) {}
 
         void destroy()
         {
+            d->notifyDead();
             TileTypeSP::deref(reinterpret_cast<TileTypeSP*>(this), d);
             this->MemoryReclaimer::~MemoryReclaimer();
             delete this;
         }
 
     private:
         TileType *d;
     };
 
     inline quint32 calculateHash(qint32 col, qint32 row)
     {
 #ifdef SANITY_CHECK
         KIS_ASSERT_RECOVER_NOOP(row < 0x7FFF && col < 0x7FFF)
 #endif // SANITY_CHECK
 
         if (col == 0 && row == 0) {
             col = 0x7FFF;
             row = 0x7FFF;
         }
 
         return ((static_cast<quint32>(row) << 16) | (static_cast<quint32>(col) & 0xFFFF));
     }
 
-    inline void insert(quint32 key, TileTypeSP value)
+    inline void insert(quint32 idx, TileTypeSP item)
     {
-        QReadLocker l(&m_iteratorLock);
-        TileTypeSP::ref(&value, value.data());
-        TileType *result = m_map.assign(key, value.data());
+        TileTypeSP::ref(&item, item.data());
+        TileType *tile = 0;
 
-        if (result) {
-            m_map.getGC().enqueue(&MemoryReclaimer::destroy, new MemoryReclaimer(result));
+        {
+            QReadLocker locker(&m_iteratorLock);
+            tile = m_map.assign(idx, item.data());
+        }
+
+        if (tile) {
+            m_map.getGC().enqueue(&MemoryReclaimer::destroy, new MemoryReclaimer(tile));
         } else {
             m_numTiles.fetchAndAddRelaxed(1);
         }
 
         m_map.getGC().update(m_map.migrationInProcess());
     }
 
-    inline bool erase(quint32 key)
+    inline bool erase(quint32 idx)
     {
         bool wasDeleted = false;
-        TileType *result = m_map.erase(key);
+        TileType *tile = m_map.erase(idx);
 
-        if (result) {
+        if (tile) {
             wasDeleted = true;
-            result->notifyDead();
             m_numTiles.fetchAndSubRelaxed(1);
-            m_map.getGC().enqueue(&MemoryReclaimer::destroy, new MemoryReclaimer(result));
+            m_map.getGC().enqueue(&MemoryReclaimer::destroy, new MemoryReclaimer(tile));
         }
 
         m_map.getGC().update(m_map.migrationInProcess());
         return wasDeleted;
     }
 
 private:
-    ConcurrentMap<quint32, TileType*> m_map;
+    mutable ConcurrentMap<quint32, TileType*> m_map;
 
     /**
      * We still need something to guard changes in m_defaultTileData,
      * otherwise there will be concurrent read/writes, resulting in broken memory.
      */
     QReadWriteLock m_defaultPixelDataLock;
-    QReadWriteLock m_iteratorLock;
+    mutable QReadWriteLock m_iteratorLock;
+    std::atomic_flag m_lazyLock = ATOMIC_FLAG_INIT;
 
     QAtomicInt m_numTiles;
     KisTileData *m_defaultTileData;
     KisMementoManager *m_mementoManager;
 };
 
 template <class T>
 class KisTileHashTableIteratorTraits2
 {
 public:
     typedef T TileType;
     typedef KisSharedPtr<T> TileTypeSP;
     typedef typename ConcurrentMap<quint32, TileType*>::Iterator Iterator;
 
     KisTileHashTableIteratorTraits2(KisTileHashTableTraits2<T> *ht) : m_ht(ht)
     {
         m_ht->m_iteratorLock.lockForWrite();
         m_iter.setMap(m_ht->m_map);
     }
 
     ~KisTileHashTableIteratorTraits2()
     {
         m_ht->m_iteratorLock.unlock();
     }
 
     void next()
     {
         m_iter.next();
     }
 
     TileTypeSP tile() const
     {
         return TileTypeSP(m_iter.getValue());
     }
 
     bool isDone() const
     {
         return !m_iter.isValid();
     }
 
     void deleteCurrent()
     {
         m_ht->erase(m_iter.getKey());
         next();
     }
 
     void moveCurrentToHashTable(KisTileHashTableTraits2<T> *newHashTable)
     {
         TileTypeSP tile = m_iter.getValue();
         next();
-        m_ht->deleteTile(tile);
-        newHashTable->addTile(tile);
+
+        quint32 idx = m_ht->calculateHash(tile->col(), tile->row());
+        m_ht->erase(idx);
+        newHashTable->insert(idx, tile);
     }
 
 private:
     KisTileHashTableTraits2<T> *m_ht;
     Iterator m_iter;
 };
 
 template <class T>
 KisTileHashTableTraits2<T>::KisTileHashTableTraits2(KisMementoManager *mm)
     : m_numTiles(0), m_defaultTileData(0), m_mementoManager(mm)
 {
 }
 
 template <class T>
 KisTileHashTableTraits2<T>::KisTileHashTableTraits2(const KisTileHashTableTraits2<T> &ht, KisMementoManager *mm)
     : KisTileHashTableTraits2(mm)
 {
     setDefaultTileData(ht.m_defaultTileData);
-    QWriteLocker l(const_cast<QReadWriteLock *>(&ht.m_iteratorLock));
-    typename ConcurrentMap<quint32, TileType*>::Iterator iter(const_cast<ConcurrentMap<quint32, TileType*> &>(ht.m_map));
+
+    QWriteLocker locker(&ht.m_iteratorLock);
+    typename ConcurrentMap<quint32, TileType*>::Iterator iter(ht.m_map);
 
     while (iter.isValid()) {
-        insert(iter.getKey(), iter.getValue());
+        TileTypeSP tile = new TileType(*iter.getValue(), m_mementoManager);
+        insert(iter.getKey(), tile);
         iter.next();
     }
 }
 
 template <class T>
 KisTileHashTableTraits2<T>::~KisTileHashTableTraits2()
 {
     clear();
-    m_map.getGC().flush();
     setDefaultTileData(0);
 }
 
 template<class T>
 bool KisTileHashTableTraits2<T>::tileExists(qint32 col, qint32 row)
 {
     return getExistingTile(col, row);
 }
 
 template <class T>
 typename KisTileHashTableTraits2<T>::TileTypeSP KisTileHashTableTraits2<T>::getExistingTile(qint32 col, qint32 row)
 {
     quint32 idx = calculateHash(col, row);
-    TileTypeSP result = m_map.get(idx);
+    TileTypeSP tile = m_map.get(idx);
     m_map.getGC().update(m_map.migrationInProcess());
-    return result;
+    return tile;
 }
 
 template <class T>
 typename KisTileHashTableTraits2<T>::TileTypeSP KisTileHashTableTraits2<T>::getTileLazy(qint32 col, qint32 row, bool &newTile)
 {
-    QReadLocker l(&m_iteratorLock);
     newTile = false;
-    TileTypeSP tile;
     quint32 idx = calculateHash(col, row);
-    typename ConcurrentMap<quint32, TileType*>::Mutator mutator = m_map.insertOrFind(idx);
+    TileTypeSP tile = m_map.get(idx);
 
-    if (!mutator.getValue()) {
-        {
-            QReadLocker guard(&m_defaultPixelDataLock);
-            tile = new TileType(col, row, m_defaultTileData, m_mementoManager);
-        }
-        TileTypeSP::ref(&tile, tile.data());
-        TileType *result = mutator.exchangeValue(tile.data());
+    if (!tile) {
+        while (m_lazyLock.test_and_set(std::memory_order_acquire));
 
-        if (result) {
-            m_map.getGC().enqueue(&MemoryReclaimer::destroy, new MemoryReclaimer(result));
-        } else {
-            newTile = true;
-            m_numTiles.fetchAndAddRelaxed(1);
+        if (!(tile = m_map.get(idx))) {
+            {
+                QReadLocker locker(&m_defaultPixelDataLock);
+                tile = new TileType(col, row, m_defaultTileData, m_mementoManager);
+            }
+
+            TileTypeSP::ref(&tile, tile.data());
+            TileType *item = 0;
+
+            {
+                QReadLocker locker(&m_iteratorLock);
+                item = m_map.assign(idx, tile.data());
+            }
+
+            if (item) {
+                m_map.getGC().enqueue(&MemoryReclaimer::destroy, new MemoryReclaimer(item));
+            } else {
+                newTile = true;
+                m_numTiles.fetchAndAddRelaxed(1);
+            }
+
+            tile = m_map.get(idx);
         }
 
-        tile = m_map.get(idx);
-    } else {
-        tile = mutator.getValue();
+        m_lazyLock.clear(std::memory_order_release);
     }
 
     m_map.getGC().update(m_map.migrationInProcess());
     return tile;
 }
 
 template <class T>
 typename KisTileHashTableTraits2<T>::TileTypeSP KisTileHashTableTraits2<T>::getReadOnlyTileLazy(qint32 col, qint32 row, bool &existingTile)
 {
     quint32 idx = calculateHash(col, row);
     TileTypeSP tile = m_map.get(idx);
     existingTile = tile;
 
     if (!existingTile) {
-        QReadLocker guard(&m_defaultPixelDataLock);
+        QReadLocker locker(&m_defaultPixelDataLock);
         tile = new TileType(col, row, m_defaultTileData, 0);
     }
 
     m_map.getGC().update(m_map.migrationInProcess());
     return tile;
 }
 
 template <class T>
 void KisTileHashTableTraits2<T>::addTile(TileTypeSP tile)
 {
     quint32 idx = calculateHash(tile->col(), tile->row());
     insert(idx, tile);
 }
 
 template <class T>
 bool KisTileHashTableTraits2<T>::deleteTile(TileTypeSP tile)
 {
     return deleteTile(tile->col(), tile->row());
 }
 
 template <class T>
 bool KisTileHashTableTraits2<T>::deleteTile(qint32 col, qint32 row)
 {
     quint32 idx = calculateHash(col, row);
     return erase(idx);
 }
 
 template<class T>
 void KisTileHashTableTraits2<T>::clear()
 {
-    QWriteLocker l(&m_iteratorLock);
+    QWriteLocker locker(&m_iteratorLock);
+
     typename ConcurrentMap<quint32, TileType*>::Iterator iter(m_map);
     TileType *tile = 0;
 
     while (iter.isValid()) {
         tile = m_map.erase(iter.getKey());
-        tile->notifyDead();
-        m_map.getGC().enqueue(&MemoryReclaimer::destroy, new MemoryReclaimer(tile));
+
+        if (tile) {
+            m_map.getGC().enqueue(&MemoryReclaimer::destroy, new MemoryReclaimer(tile));
+        }
+
         iter.next();
     }
 
     m_numTiles.store(0);
     m_map.getGC().update(false);
 }
 
 template <class T>
 inline void KisTileHashTableTraits2<T>::setDefaultTileData(KisTileData *defaultTileData)
 {
-    QWriteLocker guard(&m_defaultPixelDataLock);
+    QWriteLocker locker(&m_defaultPixelDataLock);
 
     if (m_defaultTileData) {
         m_defaultTileData->release();
         m_defaultTileData = 0;
     }
 
     if (defaultTileData) {
         defaultTileData->acquire();
         m_defaultTileData = defaultTileData;
     }
 }
 
 template <class T>
 inline KisTileData* KisTileHashTableTraits2<T>::defaultTileData()
 {
-    QReadLocker guard(&m_defaultPixelDataLock);
+    QReadLocker locker(&m_defaultPixelDataLock);
     return m_defaultTileData;
 }
 
 template <class T>
 void KisTileHashTableTraits2<T>::debugPrintInfo()
 {
 }
 
 template <class T>
 void KisTileHashTableTraits2<T>::debugMaxListLength(qint32 &min, qint32 &max)
 {
 }
 
 typedef KisTileHashTableTraits2<KisTile> KisTileHashTable;
 typedef KisTileHashTableIteratorTraits2<KisTile> KisTileHashTableIterator;
 typedef KisTileHashTableIteratorTraits2<KisTile> KisTileHashTableConstIterator;
 
 #endif // KIS_TILEHASHTABLE_2_H
diff --git a/libs/image/tiles3/swap/kis_chunk_allocator.h b/libs/image/tiles3/swap/kis_chunk_allocator.h
index 34eae8063a..f120a99b29 100644
--- a/libs/image/tiles3/swap/kis_chunk_allocator.h
+++ b/libs/image/tiles3/swap/kis_chunk_allocator.h
@@ -1,162 +1,163 @@
 /*
  *  Copyright (c) 2010 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KIS_CHUNK_LIST_H
 #define __KIS_CHUNK_LIST_H
 
 #include <QLinkedList>
+#include "kritaimage_export.h"
 
 #define MiB (1ULL << 20)
 
 #define DEFAULT_STORE_SIZE (4096*MiB)
 #define DEFAULT_SLAB_SIZE (64*MiB)
 
 
 //#define DEBUG_SLAB_FAILS
 
 #ifdef DEBUG_SLAB_FAILS
 
 #define WINDOW_SIZE 2000
 #define DECLARE_FAIL_COUNTER() quint64 __failCount
 #define INIT_FAIL_COUNTER() __failCount = 0
 #define START_COUNTING() quint64 __numSteps = 0
 #define REGISTER_STEP() if(++__numSteps > WINDOW_SIZE) {__numSteps=0; __failCount++;}
 #define REGISTER_FAIL() __failCount++
 #define DEBUG_FAIL_COUNTER() qInfo() << "Slab fail count:\t" << __failCount
 
 #else
 
 #define DECLARE_FAIL_COUNTER()
 #define INIT_FAIL_COUNTER()
 #define START_COUNTING()
 #define REGISTER_STEP()
 #define REGISTER_FAIL()
 #define DEBUG_FAIL_COUNTER()
 
 #endif /* DEBUG_SLAB_FAILS */
 
 
 
 class KisChunkData;
 
 typedef QLinkedList<KisChunkData> KisChunkDataList;
 typedef KisChunkDataList::iterator KisChunkDataListIterator;
 
-class KisChunkData
+class KRITAIMAGE_EXPORT KisChunkData
 {
 public:
     KisChunkData(quint64 begin, quint64 size)
     {
         setChunk(begin, size);
     }
 
     inline void setChunk(quint64 begin, quint64 size) {
         m_begin = begin;
         m_end = begin + size - 1;
     }
 
     inline quint64 size() const {
         return m_end - m_begin +1;
     }
 
     bool operator== (const KisChunkData& other) const
     {
         Q_ASSERT(m_begin!=other.m_begin || m_end==other.m_end);
 
         /**
          * Chunks cannot overlap, so it is enough to check
          * the beginning of the interval only
          */
         return m_begin == other.m_begin;
     }
 
     quint64 m_begin;
     quint64 m_end;
 };
 
-class KisChunk
+class KRITAIMAGE_EXPORT KisChunk
 {
 public:
     KisChunk() {}
 
     KisChunk(KisChunkDataListIterator iterator)
         : m_iterator(iterator)
     {
     }
 
     inline quint64 begin() const {
         return m_iterator->m_begin;
     }
 
     inline quint64 end() const {
         return m_iterator->m_end;
     }
 
     inline quint64 size() const {
         return m_iterator->size();
     }
 
     inline KisChunkDataListIterator position() {
         return m_iterator;
     }
 
     inline const KisChunkData& data() {
         return *m_iterator;
     }
 
 private:
     KisChunkDataListIterator m_iterator;
 };
 
 
-class KisChunkAllocator
+class KRITAIMAGE_EXPORT KisChunkAllocator
 {
 public:
     KisChunkAllocator(quint64 slabSize = DEFAULT_SLAB_SIZE,
                       quint64 storeSize = DEFAULT_STORE_SIZE);
     ~KisChunkAllocator();
 
     inline quint64 numChunks() const {
         return m_list.size();
     }
 
     KisChunk getChunk(quint64 size);
     void freeChunk(KisChunk chunk);
 
     void debugChunks();
     bool sanityCheck(bool pleaseCrash = true);
     qreal debugFragmentation(bool toStderr = true);
 
 private:
     bool tryInsertChunk(KisChunkDataList &list,
                         KisChunkDataListIterator &iterator,
                         quint64 size);
 
 private:
     quint64 m_storeMaxSize;
     quint64 m_storeSlabSize;
 
 
     KisChunkDataList m_list;
     KisChunkDataListIterator m_iterator;
     quint64 m_storeSize;
     DECLARE_FAIL_COUNTER()
 };
 
 #endif /* __KIS_CHUNK_ALLOCATOR_H */
 
diff --git a/libs/image/tiles3/swap/kis_memory_window.h b/libs/image/tiles3/swap/kis_memory_window.h
index 4a80fab833..8e4fa29190 100644
--- a/libs/image/tiles3/swap/kis_memory_window.h
+++ b/libs/image/tiles3/swap/kis_memory_window.h
@@ -1,82 +1,82 @@
 /*
  *  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_MEMORY_WINDOW_H
 #define __KIS_MEMORY_WINDOW_H
 
 #include <QTemporaryFile>
 
 #include "kis_chunk_allocator.h"
 
 
 #define DEFAULT_WINDOW_SIZE (16*MiB)
 
-class KisMemoryWindow
+class KRITAIMAGE_EXPORT KisMemoryWindow
 {
 public:
     /**
      * @param swapDir. If the dir doesn't exist, it'll be created, if it's empty QDir::tempPath will be used.
      */
     KisMemoryWindow(const QString &swapDir, quint64 writeWindowSize = DEFAULT_WINDOW_SIZE);
     ~KisMemoryWindow();
 
     inline quint8* getReadChunkPtr(KisChunk readChunk) {
         return getReadChunkPtr(readChunk.data());
     }
 
     inline quint8* getWriteChunkPtr(KisChunk writeChunk) {
         return getWriteChunkPtr(writeChunk.data());
     }
 
     quint8* getReadChunkPtr(const KisChunkData &readChunk);
     quint8* getWriteChunkPtr(const KisChunkData &writeChunk);
 
 private:
     struct MappingWindow {
         MappingWindow(quint64 _defaultSize)
             : chunk(0,0),
               window(0),
               defaultSize(_defaultSize)
         {
         }
 
         quint8* calculatePointer(const KisChunkData &other) const {
             return window + other.m_begin - chunk.m_begin;
         }
 
         KisChunkData chunk;
         quint8 *window;
         const quint64 defaultSize;
     };
 
 
 private:
     bool adjustWindow(const KisChunkData &requestedChunk,
                       MappingWindow *adjustingWindow,
                       MappingWindow *otherWindow);
 
 private:
     QTemporaryFile m_file;
 
     bool m_valid;
     MappingWindow m_readWindowEx;
     MappingWindow m_writeWindowEx;
 };
 
 #endif /* __KIS_MEMORY_WINDOW_H */
 
diff --git a/libs/image/tiles3/tests/CMakeLists.txt b/libs/image/tiles3/tests/CMakeLists.txt
index 9a5fd5ac03..b82dce0633 100644
--- a/libs/image/tiles3/tests/CMakeLists.txt
+++ b/libs/image/tiles3/tests/CMakeLists.txt
@@ -1,50 +1,33 @@
 set( EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR} )
 include_directories(   
     ${CMAKE_BINARY_DIR}/libs/image
 )
 
 include_directories(SYSTEM
     ${EIGEN3_INCLUDE_DIR}
 )
 
 
 macro_add_unittest_definitions()
 
 ecm_add_tests(
     kis_tiled_data_manager_test.cpp
     kis_low_memory_tests.cpp
     kis_lockless_stack_test.cpp
-    NAME_PREFIX "krita-image-tiles3-"
-    LINK_LIBRARIES kritaimage Qt5::Test)
-
-set_tests_properties(krita-image-tiles3-kis_low_memory_tests PROPERTIES TIMEOUT 180)
-
-ecm_add_test(
-    kis_chunk_allocator_test.cpp ../swap/kis_chunk_allocator.cpp
-    TEST_NAME krita-image-KisChunkAllocatorTest
-    LINK_LIBRARIES kritaglobal Qt5::Test)
-
-ecm_add_test(
-    kis_memory_window_test.cpp ../swap/kis_memory_window.cpp
-    TEST_NAME krita-image-KisMemoryWindowTest
-    LINK_LIBRARIES kritaglobal Qt5::Test)
-
-########### next target ###############
-krita_add_broken_unit_test(kis_swapped_data_store_test.cpp ../kis_tile_data.cc
-    TEST_NAME krita-image-KisSwappedDataStoreTest
-    LINK_LIBRARIES kritaimage Qt5::Test ${Boost_SYSTEM_LIBRARY})
-
-########### next target ###############
-krita_add_broken_unit_test(kis_tile_data_store_test.cpp ../kis_tile_data.cc
-    TEST_NAME krita-image-KisTileDataStoreTest
-    LINK_LIBRARIES kritaimage Qt5::Test ${Boost_SYSTEM_LIBRARY})
-
-########### next target ###############
-krita_add_broken_unit_test(kis_store_limits_test.cpp ../kis_tile_data.cc
-    TEST_NAME krita-image-KisStoreLimitsTest
-    LINK_LIBRARIES kritaimage Qt5::Test ${Boost_SYSTEM_LIBRARY})
-
-########### next target ###############
-krita_add_broken_unit_test(kis_tile_data_pooler_test.cpp ../kis_tile_data.cc ../kis_tile_data_pooler.cc
-    TEST_NAME krita-image-KisTileDataPoolerTest
-    LINK_LIBRARIES kritaimage Qt5::Test ${Boost_SYSTEM_LIBRARY})
+    kis_chunk_allocator_test.cpp
+    kis_memory_window_test.cpp
+
+    LINK_LIBRARIES kritaimage Qt5::Test
+    NAME_PREFIX "libs-image-tiles3-")
+
+set_tests_properties(libs-image-tiles3-kis_low_memory_tests PROPERTIES TIMEOUT 180)
+
+########### broken tests ###############
+krita_add_broken_unit_tests(
+    kis_swapped_data_store_test.cpp
+    kis_tile_data_store_test.cpp
+    kis_store_limits_test.cpp
+    kis_tile_data_pooler_test.cpp
+
+    LINK_LIBRARIES kritaimage Qt5::Test
+    NAME_PREFIX "libs-image-tiles3-")
diff --git a/libs/image/tiles3/tests/kis_tiled_data_manager_test.cpp b/libs/image/tiles3/tests/kis_tiled_data_manager_test.cpp
index cd8d2eaa69..f2a008facc 100644
--- a/libs/image/tiles3/tests/kis_tiled_data_manager_test.cpp
+++ b/libs/image/tiles3/tests/kis_tiled_data_manager_test.cpp
@@ -1,820 +1,820 @@
 /*
  *  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_tiled_data_manager_test.h"
 #include <QTest>
 
 #include "tiles3/kis_tiled_data_manager.h"
 
 #include "tiles_test_utils.h"
 #include "config-limit-long-tests.h"
 
 bool KisTiledDataManagerTest::checkHole(quint8* buffer,
                                         quint8 holeColor, QRect holeRect,
                                         quint8 backgroundColor, QRect backgroundRect)
 {
     for(qint32 y = backgroundRect.y(); y <= backgroundRect.bottom(); y++) {
         for(qint32 x = backgroundRect.x(); x <= backgroundRect.right(); x++) {
             quint8 expectedColor = holeRect.contains(x,y) ? holeColor : backgroundColor;
 
             if(*buffer != expectedColor) {
-                dbgKrita << "Expected" << expectedColor << "but found" << *buffer;
+                qDebug() << "Expected" << expectedColor << "but found" << *buffer;
                 return false;
             }
 
             buffer++;
         }
     }
     return true;
 }
 
 bool KisTiledDataManagerTest::checkTilesShared(KisTiledDataManager *srcDM,
                                                KisTiledDataManager *dstDM,
                                                bool takeOldSrc,
                                                bool takeOldDst,
                                                QRect tilesRect)
 {
     for(qint32 row = tilesRect.y(); row <= tilesRect.bottom(); row++) {
         for(qint32 col = tilesRect.x(); col <= tilesRect.right(); col++) {
             KisTileSP srcTile = takeOldSrc ? srcDM->getOldTile(col, row)
                 : srcDM->getTile(col, row, false);
             KisTileSP dstTile = takeOldDst ? dstDM->getOldTile(col, row)
                 : dstDM->getTile(col, row, false);
 
             if(srcTile->tileData() != dstTile->tileData()) {
-                dbgKrita << "Expected tile data (" << col << row << ")"
+                qDebug() << "Expected tile data (" << col << row << ")"
                          << srcTile->extent()
                          << srcTile->tileData()
                          << "but found" << dstTile->tileData();
-                dbgKrita << "Expected" << srcTile->data()[0] << "but found" << dstTile->data()[0];
+                qDebug() << "Expected" << srcTile->data()[0] << "but found" << dstTile->data()[0];
                 return false;
             }
         }
     }
     return true;
 }
 
 bool KisTiledDataManagerTest::checkTilesNotShared(KisTiledDataManager *srcDM,
                                                   KisTiledDataManager *dstDM,
                                                   bool takeOldSrc,
                                                   bool takeOldDst,
                                                   QRect tilesRect)
 {
     for(qint32 row = tilesRect.y(); row <= tilesRect.bottom(); row++) {
         for(qint32 col = tilesRect.x(); col <= tilesRect.right(); col++) {
             KisTileSP srcTile = takeOldSrc ? srcDM->getOldTile(col, row)
                 : srcDM->getTile(col, row, false);
             KisTileSP dstTile = takeOldDst ? dstDM->getOldTile(col, row)
                 : dstDM->getTile(col, row, false);
 
             if(srcTile->tileData() == dstTile->tileData()) {
-                dbgKrita << "Expected tiles not be shared:"<< srcTile->extent();
+                qDebug() << "Expected tiles not be shared:"<< srcTile->extent();
                 return false;
             }
         }
     }
     return true;
 }
 
 void KisTiledDataManagerTest::testUndoingNewTiles()
 {
     // "growing extent bug"
 
     const QRect nullRect(qint32_MAX,qint32_MAX,0,0);
 
     quint8 defaultPixel = 0;
     KisTiledDataManager srcDM(1, &defaultPixel);
 
     KisTileSP emptyTile = srcDM.getTile(0, 0, false);
 
     QCOMPARE(srcDM.extent(), nullRect);
 
     KisMementoSP memento0 = srcDM.getMemento();
     KisTileSP createdTile = srcDM.getTile(0, 0, true);
     srcDM.commit();
 
     QCOMPARE(srcDM.extent(), QRect(0,0,64,64));
 
     srcDM.rollback(memento0);
     QCOMPARE(srcDM.extent(), nullRect);
 }
 
 void KisTiledDataManagerTest::testPurgedAndEmptyTransactions()
 {
     quint8 defaultPixel = 0;
     KisTiledDataManager srcDM(1, &defaultPixel);
 
     quint8 oddPixel1 = 128;
 
     QRect rect(0,0,512,512);
     QRect clearRect1(50,50,100,100);
     QRect clearRect2(150,50,100,100);
 
     quint8 *buffer = new quint8[rect.width()*rect.height()];
 
     // purged transaction
 
     KisMementoSP memento0 = srcDM.getMemento();
     srcDM.clear(clearRect1, &oddPixel1);
     srcDM.purgeHistory(memento0);
     memento0 = 0;
 
     srcDM.readBytes(buffer, rect.x(), rect.y(), rect.width(), rect.height());
     QVERIFY(checkHole(buffer, oddPixel1, clearRect1,
                       defaultPixel, rect));
 
     // one more purged transaction
 
     KisMementoSP memento1 = srcDM.getMemento();
     srcDM.clear(clearRect2, &oddPixel1);
 
     srcDM.readBytes(buffer, rect.x(), rect.y(), rect.width(), rect.height());
     QVERIFY(checkHole(buffer, oddPixel1, clearRect1 | clearRect2,
                       defaultPixel, rect));
 
     srcDM.purgeHistory(memento1);
     memento1 = 0;
 
     srcDM.readBytes(buffer, rect.x(), rect.y(), rect.width(), rect.height());
     QVERIFY(checkHole(buffer, oddPixel1, clearRect1 | clearRect2,
                       defaultPixel, rect));
 
     // empty one
 
     KisMementoSP memento2 = srcDM.getMemento();
     srcDM.commit();
     srcDM.rollback(memento2);
 
     srcDM.readBytes(buffer, rect.x(), rect.y(), rect.width(), rect.height());
     QVERIFY(checkHole(buffer, oddPixel1, clearRect1 | clearRect2,
                       defaultPixel, rect));
 
 
     // now check that everything works still
 
     KisMementoSP memento3 = srcDM.getMemento();
     srcDM.setExtent(clearRect2);
     srcDM.commit();
 
     srcDM.readBytes(buffer, rect.x(), rect.y(), rect.width(), rect.height());
     QVERIFY(checkHole(buffer, oddPixel1, clearRect2,
                       defaultPixel, rect));
 
     srcDM.rollback(memento3);
 
     srcDM.readBytes(buffer, rect.x(), rect.y(), rect.width(), rect.height());
     QVERIFY(checkHole(buffer, oddPixel1, clearRect1 | clearRect2,
                       defaultPixel, rect));
 
 
 }
 void KisTiledDataManagerTest::testUnversionedBitBlt()
 {
     quint8 defaultPixel = 0;
     KisTiledDataManager srcDM(1, &defaultPixel);
     KisTiledDataManager dstDM(1, &defaultPixel);
 
     quint8 oddPixel1 = 128;
     quint8 oddPixel2 = 129;
 
     QRect rect(0,0,512,512);
     QRect cloneRect(81,80,250,250);
     QRect tilesRect(2,2,3,3);
 
     srcDM.clear(rect, &oddPixel1);
     dstDM.clear(rect, &oddPixel2);
 
     dstDM.bitBlt(&srcDM, cloneRect);
 
     quint8 *buffer = new quint8[rect.width()*rect.height()];
 
     dstDM.readBytes(buffer, rect.x(), rect.y(), rect.width(), rect.height());
 
     QVERIFY(checkHole(buffer, oddPixel1, cloneRect,
                       oddPixel2, rect));
 
     delete[] buffer;
 
     // Test whether tiles became shared
     QVERIFY(checkTilesShared(&srcDM, &dstDM, false, false, tilesRect));
 }
 
 void KisTiledDataManagerTest::testVersionedBitBlt()
 {
     quint8 defaultPixel = 0;
     KisTiledDataManager srcDM1(1, &defaultPixel);
     KisTiledDataManager srcDM2(1, &defaultPixel);
     KisTiledDataManager dstDM(1, &defaultPixel);
 
     quint8 oddPixel1 = 128;
     quint8 oddPixel2 = 129;
     quint8 oddPixel3 = 130;
 
     quint8 oddPixel4 = 131;
 
     QRect rect(0,0,512,512);
     QRect cloneRect(81,80,250,250);
     QRect tilesRect(2,2,3,3);
 
 
     KisMementoSP memento1 = srcDM1.getMemento();
     srcDM1.clear(rect, &oddPixel1);
 
     srcDM2.clear(rect, &oddPixel2);
     dstDM.clear(rect, &oddPixel3);
 
     KisMementoSP memento2 = dstDM.getMemento();
     dstDM.bitBlt(&srcDM1, cloneRect);
 
     QVERIFY(checkTilesShared(&srcDM1, &dstDM, false, false, tilesRect));
     QVERIFY(checkTilesNotShared(&srcDM1, &srcDM1, true, false, tilesRect));
     QVERIFY(checkTilesNotShared(&dstDM, &dstDM, true, false, tilesRect));
 
     dstDM.commit();
     QVERIFY(checkTilesShared(&dstDM, &dstDM, true, false, tilesRect));
 
     KisMementoSP memento3 = srcDM2.getMemento();
     srcDM2.clear(rect, &oddPixel4);
 
     KisMementoSP memento4 = dstDM.getMemento();
     dstDM.bitBlt(&srcDM2, cloneRect);
 
     QVERIFY(checkTilesShared(&srcDM2, &dstDM, false, false, tilesRect));
     QVERIFY(checkTilesNotShared(&srcDM2, &srcDM2, true, false, tilesRect));
     QVERIFY(checkTilesNotShared(&dstDM, &dstDM, true, false, tilesRect));
 
     dstDM.commit();
     QVERIFY(checkTilesShared(&dstDM, &dstDM, true, false, tilesRect));
 
     dstDM.rollback(memento4);
     QVERIFY(checkTilesShared(&srcDM1, &dstDM, false, false, tilesRect));
     QVERIFY(checkTilesShared(&dstDM, &dstDM, true, false, tilesRect));
     QVERIFY(checkTilesNotShared(&srcDM1, &srcDM1, true, false, tilesRect));
 
     dstDM.rollforward(memento4);
     QVERIFY(checkTilesShared(&srcDM2, &dstDM, false, false, tilesRect));
     QVERIFY(checkTilesShared(&dstDM, &dstDM, true, false, tilesRect));
     QVERIFY(checkTilesNotShared(&srcDM1, &srcDM1, true, false, tilesRect));
 }
 
 void KisTiledDataManagerTest::testBitBltOldData()
 {
     quint8 defaultPixel = 0;
     KisTiledDataManager srcDM(1, &defaultPixel);
     KisTiledDataManager dstDM(1, &defaultPixel);
 
     quint8 oddPixel1 = 128;
     quint8 oddPixel2 = 129;
 
     QRect rect(0,0,512,512);
     QRect cloneRect(81,80,250,250);
     QRect tilesRect(2,2,3,3);
 
     quint8 *buffer = new quint8[rect.width()*rect.height()];
 
     KisMementoSP memento1 = srcDM.getMemento();
     srcDM.clear(rect, &oddPixel1);
     srcDM.commit();
 
     dstDM.bitBltOldData(&srcDM, cloneRect);
     dstDM.readBytes(buffer, rect.x(), rect.y(), rect.width(), rect.height());
     QVERIFY(checkHole(buffer, oddPixel1, cloneRect,
                       defaultPixel, rect));
 
     KisMementoSP memento2 = srcDM.getMemento();
     srcDM.clear(rect, &oddPixel2);
     dstDM.bitBltOldData(&srcDM, cloneRect);
     srcDM.commit();
 
     dstDM.readBytes(buffer, rect.x(), rect.y(), rect.width(), rect.height());
     QVERIFY(checkHole(buffer, oddPixel1, cloneRect,
                       defaultPixel, rect));
 
     delete[] buffer;
 }
 
 void KisTiledDataManagerTest::testBitBltRough()
 {
     quint8 defaultPixel = 0;
     KisTiledDataManager srcDM(1, &defaultPixel);
     KisTiledDataManager dstDM(1, &defaultPixel);
 
     quint8 oddPixel1 = 128;
     quint8 oddPixel2 = 129;
     quint8 oddPixel3 = 130;
 
     QRect rect(0,0,512,512);
     QRect cloneRect(81,80,250,250);
     QRect actualCloneRect(64,64,320,320);
     QRect tilesRect(1,1,4,4);
 
     srcDM.clear(rect, &oddPixel1);
     dstDM.clear(rect, &oddPixel2);
 
     dstDM.bitBltRough(&srcDM, cloneRect);
 
     quint8 *buffer = new quint8[rect.width()*rect.height()];
 
     dstDM.readBytes(buffer, rect.x(), rect.y(), rect.width(), rect.height());
 
     QVERIFY(checkHole(buffer, oddPixel1, actualCloneRect,
                       oddPixel2, rect));
 
     // Test whether tiles became shared
     QVERIFY(checkTilesShared(&srcDM, &dstDM, false, false, tilesRect));
 
     // check bitBltRoughOldData
     KisMementoSP memento1 = srcDM.getMemento();
     srcDM.clear(rect, &oddPixel3);
     dstDM.bitBltRoughOldData(&srcDM, cloneRect);
     srcDM.commit();
     dstDM.readBytes(buffer, rect.x(), rect.y(), rect.width(), rect.height());
     QVERIFY(checkHole(buffer, oddPixel1, actualCloneRect,
                       oddPixel2, rect));
 
     delete[] buffer;
 }
 
 void KisTiledDataManagerTest::testTransactions()
 {
     quint8 defaultPixel = 0;
     KisTiledDataManager dm(1, &defaultPixel);
 
     quint8 oddPixel1 = 128;
     quint8 oddPixel2 = 129;
     quint8 oddPixel3 = 130;
 
     KisTileSP tile00;
     KisTileSP oldTile00;
 
     // Create a named transaction: versioning is enabled
     KisMementoSP memento1 = dm.getMemento();
     dm.clear(0, 0, 64, 64, &oddPixel1);
 
     tile00 = dm.getTile(0, 0, false);
     oldTile00 = dm.getOldTile(0, 0);
     QVERIFY(memoryIsFilled(oddPixel1, tile00->data(), TILESIZE));
     QVERIFY(memoryIsFilled(defaultPixel, oldTile00->data(), TILESIZE));
     tile00 = oldTile00 = 0;
 
     // Create an anonymous transaction: versioning is disabled
     dm.commit();
     tile00 = dm.getTile(0, 0, false);
     oldTile00 = dm.getOldTile(0, 0);
     QVERIFY(memoryIsFilled(oddPixel1, tile00->data(), TILESIZE));
     QVERIFY(memoryIsFilled(oddPixel1, oldTile00->data(), TILESIZE));
     tile00 = oldTile00 = 0;
 
     dm.clear(0, 0, 64, 64, &oddPixel2);
 
     // Versioning is disabled, i said! >:)
     tile00 = dm.getTile(0, 0, false);
     oldTile00 = dm.getOldTile(0, 0);
     QVERIFY(memoryIsFilled(oddPixel2, tile00->data(), TILESIZE));
     QVERIFY(memoryIsFilled(oddPixel2, oldTile00->data(), TILESIZE));
     tile00 = oldTile00 = 0;
 
     // And the last round: named transaction:
     KisMementoSP memento2 = dm.getMemento();
     dm.clear(0, 0, 64, 64, &oddPixel3);
 
     tile00 = dm.getTile(0, 0, false);
     oldTile00 = dm.getOldTile(0, 0);
     QVERIFY(memoryIsFilled(oddPixel3, tile00->data(), TILESIZE));
     QVERIFY(memoryIsFilled(oddPixel2, oldTile00->data(), TILESIZE));
     tile00 = oldTile00 = 0;
 
 }
 
 void KisTiledDataManagerTest::testPurgeHistory()
 {
     quint8 defaultPixel = 0;
     KisTiledDataManager dm(1, &defaultPixel);
 
     quint8 oddPixel1 = 128;
     quint8 oddPixel2 = 129;
     quint8 oddPixel3 = 130;
     quint8 oddPixel4 = 131;
 
     KisMementoSP memento1 = dm.getMemento();
     dm.clear(0, 0, 64, 64, &oddPixel1);
     dm.commit();
 
     KisMementoSP memento2 = dm.getMemento();
     dm.clear(0, 0, 64, 64, &oddPixel2);
 
     KisTileSP tile00;
     KisTileSP oldTile00;
 
     tile00 = dm.getTile(0, 0, false);
     oldTile00 = dm.getOldTile(0, 0);
     QVERIFY(memoryIsFilled(oddPixel2, tile00->data(), TILESIZE));
     QVERIFY(memoryIsFilled(oddPixel1, oldTile00->data(), TILESIZE));
     tile00 = oldTile00 = 0;
 
     dm.purgeHistory(memento1);
 
     /**
      * Nothing nas changed in the visible state of the data manager
      */
 
     tile00 = dm.getTile(0, 0, false);
     oldTile00 = dm.getOldTile(0, 0);
     QVERIFY(memoryIsFilled(oddPixel2, tile00->data(), TILESIZE));
     QVERIFY(memoryIsFilled(oddPixel1, oldTile00->data(), TILESIZE));
     tile00 = oldTile00 = 0;
 
     dm.commit();
 
     dm.purgeHistory(memento2);
 
     /**
      * We've removed all the history of the device, so it
      * became "unversioned".
      * NOTE: the return value for getOldTile() when there is no
      * history present is a subject for change
      */
 
     tile00 = dm.getTile(0, 0, false);
     oldTile00 = dm.getOldTile(0, 0);
     QVERIFY(memoryIsFilled(oddPixel2, tile00->data(), TILESIZE));
     QVERIFY(memoryIsFilled(oddPixel2, oldTile00->data(), TILESIZE));
     tile00 = oldTile00 = 0;
 
     /**
      * Just test we won't crash when the memento is not
      * present in history anymore
      */
 
     KisMementoSP memento3 = dm.getMemento();
     dm.clear(0, 0, 64, 64, &oddPixel3);
     dm.commit();
 
     KisMementoSP memento4 = dm.getMemento();
     dm.clear(0, 0, 64, 64, &oddPixel4);
     dm.commit();
 
     dm.rollback(memento4);
 
     dm.purgeHistory(memento3);
     dm.purgeHistory(memento4);
 }
 
 void KisTiledDataManagerTest::testUndoSetDefaultPixel()
 {
     quint8 defaultPixel = 0;
     KisTiledDataManager dm(1, &defaultPixel);
 
     quint8 oddPixel1 = 128;
     quint8 oddPixel2 = 129;
 
     QRect fillRect(0,0,64,64);
 
     KisTileSP tile00;
     KisTileSP tile10;
 
     tile00 = dm.getTile(0, 0, false);
     tile10 = dm.getTile(1, 0, false);
     QVERIFY(memoryIsFilled(defaultPixel, tile00->data(), TILESIZE));
     QVERIFY(memoryIsFilled(defaultPixel, tile10->data(), TILESIZE));
 
     KisMementoSP memento1 = dm.getMemento();
     dm.clear(fillRect, &oddPixel1);
     dm.commit();
 
     tile00 = dm.getTile(0, 0, false);
     tile10 = dm.getTile(1, 0, false);
     QVERIFY(memoryIsFilled(oddPixel1, tile00->data(), TILESIZE));
     QVERIFY(memoryIsFilled(defaultPixel, tile10->data(), TILESIZE));
 
     KisMementoSP memento2 = dm.getMemento();
     dm.setDefaultPixel(&oddPixel2);
     dm.commit();
 
     tile00 = dm.getTile(0, 0, false);
     tile10 = dm.getTile(1, 0, false);
     QVERIFY(memoryIsFilled(oddPixel1, tile00->data(), TILESIZE));
     QVERIFY(memoryIsFilled(oddPixel2, tile10->data(), TILESIZE));
 
     dm.rollback(memento2);
 
     tile00 = dm.getTile(0, 0, false);
     tile10 = dm.getTile(1, 0, false);
     QVERIFY(memoryIsFilled(oddPixel1, tile00->data(), TILESIZE));
     QVERIFY(memoryIsFilled(defaultPixel, tile10->data(), TILESIZE));
 
     dm.rollback(memento1);
 
     tile00 = dm.getTile(0, 0, false);
     tile10 = dm.getTile(1, 0, false);
     QVERIFY(memoryIsFilled(defaultPixel, tile00->data(), TILESIZE));
     QVERIFY(memoryIsFilled(defaultPixel, tile10->data(), TILESIZE));
 
     dm.rollforward(memento1);
 
     tile00 = dm.getTile(0, 0, false);
     tile10 = dm.getTile(1, 0, false);
     QVERIFY(memoryIsFilled(oddPixel1, tile00->data(), TILESIZE));
     QVERIFY(memoryIsFilled(defaultPixel, tile10->data(), TILESIZE));
 
     dm.rollforward(memento2);
 
     tile00 = dm.getTile(0, 0, false);
     tile10 = dm.getTile(1, 0, false);
     QVERIFY(memoryIsFilled(oddPixel1, tile00->data(), TILESIZE));
     QVERIFY(memoryIsFilled(oddPixel2, tile10->data(), TILESIZE));
 }
 
 //#include <valgrind/callgrind.h>
 
 void KisTiledDataManagerTest::benchmarkReadOnlyTileLazy()
 {
     quint8 defaultPixel = 0;
     KisTiledDataManager dm(1, &defaultPixel);
 
     /*
      * See KisTileHashTableTraits2 for more details
      */
 
     const qint32 numTilesToTest = 0x7fff;
 
     //CALLGRIND_START_INSTRUMENTATION;
 
     QBENCHMARK_ONCE {
         for(qint32 i = 0; i < numTilesToTest; i++) {
             KisTileSP tile = dm.getTile(i, i, false);
         }
     }
 
     //CALLGRIND_STOP_INSTRUMENTATION;
 }
 
 class KisSimpleClass : public KisShared
 {
     qint64 m_int;
 public:
     KisSimpleClass() {
         Q_UNUSED(m_int);
     }
 };
 
 typedef KisSharedPtr<KisSimpleClass> KisSimpleClassSP;
 void KisTiledDataManagerTest::benchmarkSharedPointers()
 {
     const qint32 numIterations = 2 * 1000000;
 
     //CALLGRIND_START_INSTRUMENTATION;
 
     QBENCHMARK_ONCE {
         for(qint32 i = 0; i < numIterations; i++) {
             KisSimpleClassSP pointer = new KisSimpleClass;
             pointer = 0;
         }
     }
 
     //CALLGRIND_STOP_INSTRUMENTATION;
 }
 
 void KisTiledDataManagerTest::benchmarkCOWImpl()
 {
     const int pixelSize = 8;
     quint8 defaultPixel[pixelSize];
     memset(defaultPixel, 1, pixelSize);
 
     KisTiledDataManager dm(pixelSize, defaultPixel);
 
 
     KisMementoSP memento1 = dm.getMemento();
 
     /**
      * Imagine a regular image of 4096x2048 pixels
      * (64x32 tiles)
      */
     for (int i = 0; i < 32; i++) {
         for (int j = 0; j < 64; j++) {
             KisTileSP tile = dm.getTile(j, i, true);
             tile->lockForWrite();
             tile->unlock();
         }
     }
 
     dm.commit();
 
     QTest::qSleep(200);
 
     KisMementoSP memento2 = dm.getMemento();
     QTest::qSleep(200);
     QBENCHMARK_ONCE {
 
         for (int i = 0; i < 32; i++) {
             for (int j = 0; j < 64; j++) {
                 KisTileSP tile = dm.getTile(j, i, true);
                 tile->lockForWrite();
                 tile->unlock();
             }
         }
 
     }
     dm.commit();
 }
 
 void KisTiledDataManagerTest::benchmarkCOWNoPooler()
 {
     KisTileDataStore::instance()->testingSuspendPooler();
     QTest::qSleep(200);
 
     benchmarkCOWImpl();
 
     KisTileDataStore::instance()->testingResumePooler();
     QTest::qSleep(200);
 }
 
 void KisTiledDataManagerTest::benchmarkCOWWithPooler()
 {
     benchmarkCOWImpl();
 }
 
 /******************* Stress job ***********************/
 
 #ifdef LIMIT_LONG_TESTS
 #define NUM_CYCLES 10000
 #else
 #define NUM_CYCLES 100000
 #endif
 
 #define NUM_TYPES 12
 
 #define TILE_DIMENSION 64
 
 
 /**
  * The data manager has partial guarantees of reentrancy. That is
  * you can call any arbitrary number of methods concurrently as long
  * as their access areas do not intersect.
  *
  * Though the rule can be quite tricky -- some of the methods always
  * use entire image as their access area, so they cannot be called
  * concurrently in any circumstances.
  * The examples are: clear(), commit(), rollback() and etc...
  */
 
 #define run_exclusive(lock, _i) for(_i = 0, (lock).lockForWrite(); _i < 1; _i++, (lock).unlock())
 #define run_concurrent(lock, _i) for(_i = 0, (lock).lockForRead(); _i < 1; _i++, (lock).unlock())
 //#define run_exclusive(lock, _i) while(0)
 //#define run_concurrent(lock, _i) while(0)
 
 
 class KisStressJob : public QRunnable
 {
 public:
     KisStressJob(KisTiledDataManager &dataManager, QRect rect, QReadWriteLock &_lock)
         : m_accessRect(rect), dm(dataManager), lock(_lock)
     {
     }
 
     void run() override {
         qsrand(QTime::currentTime().msec());
         for(qint32 i = 0; i < NUM_CYCLES; i++) {
             qint32 type = qrand() % NUM_TYPES;
 
             qint32 t;
 
             switch(type) {
             case 0:
                 run_concurrent(lock,t) {
                     quint8 *buf;
                     buf = new quint8[dm.pixelSize()];
                     memcpy(buf, dm.defaultPixel(), dm.pixelSize());
                     dm.setDefaultPixel(buf);
                     delete[] buf;
                 }
                 break;
             case 1:
             case 2:
                 run_concurrent(lock,t) {
                     KisTileSP tile;
 
                     tile = dm.getTile(m_accessRect.x() / TILE_DIMENSION,
                                       m_accessRect.y() / TILE_DIMENSION, false);
                     tile->lockForRead();
                     tile->unlock();
                     tile = dm.getTile(m_accessRect.x() / TILE_DIMENSION,
                                       m_accessRect.y() / TILE_DIMENSION, true);
                     tile->lockForWrite();
                     tile->unlock();
 
                     tile = dm.getOldTile(m_accessRect.x() / TILE_DIMENSION,
                                          m_accessRect.y() / TILE_DIMENSION);
                     tile->lockForRead();
                     tile->unlock();
                 }
                 break;
             case 3:
                 run_concurrent(lock,t) {
                     QRect newRect = dm.extent();
 		    Q_UNUSED(newRect);
                 }
                 break;
             case 4:
                 run_concurrent(lock,t) {
                     dm.clear(m_accessRect.x(), m_accessRect.y(),
                              m_accessRect.width(), m_accessRect.height(), 4);
                 }
                 break;
             case 5:
                 run_concurrent(lock,t) {
                     quint8 *buf;
 
                     buf = new quint8[m_accessRect.width() * m_accessRect.height() *
                                      dm.pixelSize()];
                     dm.readBytes(buf, m_accessRect.x(), m_accessRect.y(),
                                  m_accessRect.width(), m_accessRect.height());
                     dm.writeBytes(buf, m_accessRect.x(), m_accessRect.y(),
                                   m_accessRect.width(), m_accessRect.height());
                     delete[] buf;
                     }
                 break;
             case 6:
                 run_concurrent(lock,t) {
                     quint8 oddPixel = 13;
                     KisTiledDataManager srcDM(1, &oddPixel);
                     dm.bitBlt(&srcDM, m_accessRect);
                 }
                 break;
             case 7:
             case 8:
                 run_exclusive(lock,t) {
                     m_memento = dm.getMemento();
                     dm.clear(m_accessRect.x(), m_accessRect.y(),
                              m_accessRect.width(), m_accessRect.height(), 2);
                     dm.commit();
 
                     dm.rollback(m_memento);
                     dm.rollforward(m_memento);
 
                     dm.purgeHistory(m_memento);
                     m_memento = 0;
                 }
                 break;
             case 9:
                 run_exclusive(lock,t) {
                     bool b = dm.hasCurrentMemento();
                     Q_UNUSED(b);
                 }
                 break;
             case 10:
                 run_exclusive(lock,t) {
                     dm.clear();
                 }
                 break;
             case 11:
                 run_exclusive(lock,t) {
                     dm.setExtent(m_accessRect);
                 }
                 break;
             }
         }
     }
 
 private:
     KisMementoSP m_memento;
     QRect m_accessRect;
     KisTiledDataManager &dm;
     QReadWriteLock &lock;
 };
 
 void KisTiledDataManagerTest::stressTest()
 {
     quint8 defaultPixel = 0;
     KisTiledDataManager dm(1, &defaultPixel);
     QReadWriteLock lock;
 
     QThreadPool pool;
     pool.setMaxThreadCount(NUM_TYPES);
 
     QRect accessRect(0,0,100,100);
     for(qint32 i = 0; i < NUM_TYPES; i++) {
         KisStressJob *job = new KisStressJob(dm, accessRect, lock);
         pool.start(job);
         accessRect.translate(100, 0);
     }
     pool.waitForDone();
 }
 
 QTEST_MAIN(KisTiledDataManagerTest)
 
diff --git a/libs/libkis/Document.cpp b/libs/libkis/Document.cpp
index 48ebdf39db..e646e4a0b1 100644
--- a/libs/libkis/Document.cpp
+++ b/libs/libkis/Document.cpp
@@ -1,826 +1,832 @@
 /*
  *  Copyright (c) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "Document.h"
 #include <QPointer>
 #include <QUrl>
 #include <QDomDocument>
 
 #include <KoColorSpaceConstants.h>
 #include <KoXmlReader.h>
 #include <KisDocument.h>
 #include <kis_colorspace_convert_visitor.h>
 #include <kis_image.h>
 #include <KisPart.h>
 #include <kis_paint_device.h>
 #include <KisMainWindow.h>
 #include <kis_node_manager.h>
 #include <kis_node_selection_adapter.h>
 #include <KisViewManager.h>
 #include <kis_file_layer.h>
 #include <kis_adjustment_layer.h>
 #include <kis_mask.h>
 #include <kis_clone_layer.h>
 #include <kis_group_layer.h>
 #include <kis_filter_mask.h>
 #include <kis_transform_mask.h>
 #include <kis_transparency_mask.h>
 #include <kis_selection_mask.h>
 #include <kis_effect_mask.h>
 #include <kis_paint_layer.h>
 #include <kis_generator_layer.h>
 #include <kis_generator_registry.h>
 #include <kis_shape_layer.h>
 #include <kis_filter_configuration.h>
 #include <kis_filter_registry.h>
 #include <kis_selection.h>
 #include <KisMimeDatabase.h>
 #include <kis_filter_strategy.h>
 #include <kis_guides_config.h>
 #include <kis_coordinates_converter.h>
 
 #include <KoColor.h>
 #include <KoColorSpace.h>
 #include <KoColorProfile.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorConversionTransformation.h>
 #include <KoDocumentInfo.h>
 
 #include <InfoObject.h>
 #include <Node.h>
 #include <Selection.h>
 #include <LibKisUtils.h>
 
 struct Document::Private {
     Private() {}
     QPointer<KisDocument> document;
 };
 
 Document::Document(KisDocument *document, QObject *parent)
     : QObject(parent)
     , d(new Private)
 {
     d->document = document;
 }
 
 Document::~Document()
 {
     delete d;
 }
 
 bool Document::operator==(const Document &other) const
 {
     return (d->document == other.d->document);
 }
 
 bool Document::operator!=(const Document &other) const
 {
     return !(operator==(other));
 }
 
 bool Document::batchmode() const
 {
     if (!d->document) return false;
     return d->document->fileBatchMode();
 }
 
 void Document::setBatchmode(bool value)
 {
     if (!d->document) return;
     d->document->setFileBatchMode(value);
 }
 
 Node *Document::activeNode() const
 {
     QList<KisNodeSP> activeNodes;
     Q_FOREACH(QPointer<KisView> view, KisPart::instance()->views()) {
         if (view && view->document() == d->document) {
             activeNodes << view->currentNode();
         }
     }
     if (activeNodes.size() > 0) {
         QList<Node*> nodes = LibKisUtils::createNodeList(activeNodes, d->document->image());
         return nodes.first();
     }
     return 0;
 }
 
 void Document::setActiveNode(Node* value)
 {
     if (!value->node()) return;
     KisMainWindow *mainWin = KisPart::instance()->currentMainwindow();
     if (!mainWin) return;
     KisViewManager *viewManager = mainWin->viewManager();
     if (!viewManager) return;
     if (viewManager->document() != d->document) return;
     KisNodeManager *nodeManager = viewManager->nodeManager();
     if (!nodeManager) return;
     KisNodeSelectionAdapter *selectionAdapter = nodeManager->nodeSelectionAdapter();
     if (!selectionAdapter) return;
     selectionAdapter->setActiveNode(value->node());
 
 }
 
 QList<Node *> Document::topLevelNodes() const
 {
     if (!d->document) return QList<Node *>();
     Node n(d->document->image(), d->document->image()->rootLayer());
     return n.childNodes();
 }
 
 
 Node *Document::nodeByName(const QString &name) const
 {
     if (!d->document) return 0;
     KisNodeSP node = d->document->image()->rootLayer()->findChildByName(name);
     return new Node(d->document->image(), node);
 }
 
 
 QString Document::colorDepth() const
 {
     if (!d->document) return "";
     return d->document->image()->colorSpace()->colorDepthId().id();
 }
 
 QString Document::colorModel() const
 {
     if (!d->document) return "";
     return d->document->image()->colorSpace()->colorModelId().id();
 }
 
 QString Document::colorProfile() const
 {
     if (!d->document) return "";
     return d->document->image()->colorSpace()->profile()->name();
 }
 
 bool Document::setColorProfile(const QString &value)
 {
     if (!d->document) return false;
     if (!d->document->image()) return false;
     const KoColorProfile *profile = KoColorSpaceRegistry::instance()->profileByName(value);
     if (!profile) return false;
     bool retval = d->document->image()->assignImageProfile(profile);
     d->document->image()->setModified();
     d->document->image()->initialRefreshGraph();
     return retval;
 }
 
 bool Document::setColorSpace(const QString &colorModel, const QString &colorDepth, const QString &colorProfile)
 {
     if (!d->document) return false;
     if (!d->document->image()) return false;
     const KoColorSpace *colorSpace = KoColorSpaceRegistry::instance()->colorSpace(colorModel, colorDepth, colorProfile);
     if (!colorSpace) return false;
 
     d->document->image()->convertImageColorSpace(colorSpace,
                                                  KoColorConversionTransformation::IntentPerceptual,
                                                  KoColorConversionTransformation::HighQuality | KoColorConversionTransformation::NoOptimization);
 
     d->document->image()->setModified();
     d->document->image()->initialRefreshGraph();
     return true;
 }
 
 QColor Document::backgroundColor()
 {
     if (!d->document) return QColor();
     if (!d->document->image()) return QColor();
 
     const KoColor color = d->document->image()->defaultProjectionColor();
     return color.toQColor();
 }
 
 bool Document::setBackgroundColor(const QColor &color)
 {
     if (!d->document) return false;
     if (!d->document->image()) return false;
 
     KoColor background = KoColor(color, d->document->image()->colorSpace());
     d->document->image()->setDefaultProjectionColor(background);
 
     d->document->image()->setModified();
     d->document->image()->initialRefreshGraph();
 
     return true;
 }
 
 QString Document::documentInfo() const
 {
     QDomDocument doc = KisDocument::createDomDocument("document-info"
                                                       /*DTD name*/, "document-info" /*tag name*/, "1.1");
     doc = d->document->documentInfo()->save(doc);
     return doc.toString();
 }
 
 void Document::setDocumentInfo(const QString &document)
 {
     KoXmlDocument doc;
     QString errorMsg;
     int errorLine, errorColumn;
     doc.setContent(document, &errorMsg, &errorLine, &errorColumn);
     d->document->documentInfo()->load(doc);
 }
 
 
 QString Document::fileName() const
 {
     if (!d->document) return QString();
     return d->document->url().toLocalFile();
 }
 
 void Document::setFileName(QString value)
 {
     if (!d->document) return;
     QString mimeType = KisMimeDatabase::mimeTypeForFile(value, false);
     d->document->setMimeType(mimeType.toLatin1());
     d->document->setUrl(QUrl::fromLocalFile(value));
 }
 
 int Document::height() const
 {
     if (!d->document) return 0;
     KisImageSP image = d->document->image();
     if (!image) return 0;
     return image->height();
 }
 
 void Document::setHeight(int value)
 {
     if (!d->document) return;
     if (!d->document->image()) return;
     resizeImage(d->document->image()->bounds().x(),
                 d->document->image()->bounds().y(),
                 d->document->image()->width(),
                 value);
 }
 
 
 QString Document::name() const
 {
     if (!d->document) return "";
     return d->document->documentInfo()->aboutInfo("title");
 }
 
 void Document::setName(QString value)
 {
     if (!d->document) return;
     d->document->documentInfo()->setAboutInfo("title", value);
 }
 
 
 int Document::resolution() const
 {
     if (!d->document) return 0;
     KisImageSP image = d->document->image();
     if (!image) return 0;
 
     return qRound(d->document->image()->xRes() * 72);
 }
 
 void Document::setResolution(int value)
 {
     if (!d->document) return;
     KisImageSP image = d->document->image();
     if (!image) return;
 
     d->document->image()->setResolution(value / 72.0, value / 72.0);
 }
 
 
 Node *Document::rootNode() const
 {
     if (!d->document) return 0;
     KisImageSP image = d->document->image();
     if (!image) return 0;
 
     return new Node(image, image->root());
 }
 
 Selection *Document::selection() const
 {
     if (!d->document) return 0;
     if (!d->document->image()) return 0;
     if (!d->document->image()->globalSelection()) return 0;
     return new Selection(d->document->image()->globalSelection());
 }
 
 void Document::setSelection(Selection* value)
 {
     if (!d->document) return;
     if (!d->document->image()) return;
     if (value) {
         d->document->image()->setGlobalSelection(value->selection());
     }
     else {
         d->document->image()->setGlobalSelection(0);
     }
 }
 
 
 int Document::width() const
 {
     if (!d->document) return 0;
     KisImageSP image = d->document->image();
     if (!image) return 0;
     return image->width();
 }
 
 void Document::setWidth(int value)
 {
     if (!d->document) return;
     if (!d->document->image()) return;
     resizeImage(d->document->image()->bounds().x(),
                 d->document->image()->bounds().y(),
                 value,
                 d->document->image()->height());
 }
 
 
 int Document::xOffset() const
 {
     if (!d->document) return 0;
     KisImageSP image = d->document->image();
     if (!image) return 0;
     return image->bounds().x();
 }
 
 void Document::setXOffset(int x)
 {
     if (!d->document) return;
     if (!d->document->image()) return;
     resizeImage(x,
                 d->document->image()->bounds().y(),
                 d->document->image()->width(),
                 d->document->image()->height());
 }
 
 
 int Document::yOffset() const
 {
     if (!d->document) return 0;
     KisImageSP image = d->document->image();
     if (!image) return 0;
     return image->bounds().y();
 }
 
 void Document::setYOffset(int y)
 {
     if (!d->document) return;
     if (!d->document->image()) return;
     resizeImage(d->document->image()->bounds().x(),
                 y,
                 d->document->image()->width(),
                 d->document->image()->height());
 }
 
 
 double Document::xRes() const
 {
     if (!d->document) return 0.0;
     if (!d->document->image()) return 0.0;
     return d->document->image()->xRes()*72.0;
 }
 
 void Document::setXRes(double xRes) const
 {
     if (!d->document) return;
     if (!d->document->image()) return;
     d->document->image()->setResolution(xRes/72.0, d->document->image()->yRes());
 }
 
 double Document::yRes() const
 {
     if (!d->document) return 0.0;
     if (!d->document->image()) return 0.0;
     return d->document->image()->yRes()*72.0;
 }
 
 void Document::setYRes(double yRes) const
 {
     if (!d->document) return;
     if (!d->document->image()) return;
     d->document->image()->setResolution(d->document->image()->xRes(), yRes/72.0);
 }
 
 
 QByteArray Document::pixelData(int x, int y, int w, int h) const
 {
     QByteArray ba;
 
     if (!d->document) return ba;
     KisImageSP image = d->document->image();
     if (!image) return ba;
 
     KisPaintDeviceSP dev = image->projection();
     ba.resize(w * h * dev->pixelSize());
     dev->readBytes(reinterpret_cast<quint8*>(ba.data()), x, y, w, h);
     return ba;
 }
 
 bool Document::close()
 {
     bool retval = d->document->closeUrl(false);
     Q_FOREACH(KisView *view, KisPart::instance()->views()) {
         if (view->document() == d->document) {
             view->close();
             view->closeView();
             view->deleteLater();
         }
     }
 
     KisPart::instance()->removeDocument(d->document);
     d->document = 0;
     return retval;
 }
 
 void Document::crop(int x, int y, int w, int h)
 {
     if (!d->document) return;
     KisImageSP image = d->document->image();
     if (!image) return;
     QRect rc(x, y, w, h);
     image->cropImage(rc);
 }
 
 bool Document::exportImage(const QString &filename, const InfoObject &exportConfiguration)
 {
     if (!d->document) return false;
 
     const QString outputFormatString = KisMimeDatabase::mimeTypeForFile(filename, false);
     const QByteArray outputFormat = outputFormatString.toLatin1();
 
     return d->document->exportDocumentSync(QUrl::fromLocalFile(filename), outputFormat, exportConfiguration.configuration());
 }
 
 void Document::flatten()
 {
     if (!d->document) return;
     if (!d->document->image()) return;
     d->document->image()->flatten();
 }
 
 void Document::resizeImage(int x, int y, int w, int h)
 {
     if (!d->document) return;
     KisImageSP image = d->document->image();
     if (!image) return;
     QRect rc;
     rc.setX(x);
     rc.setY(y);
     rc.setWidth(w);
     rc.setHeight(h);
 
     image->resizeImage(rc);
 }
 
 void Document::scaleImage(int w, int h, int xres, int yres, QString strategy)
 {
     if (!d->document) return;
     KisImageSP image = d->document->image();
     if (!image) return;
     QRect rc = image->bounds();
     rc.setWidth(w);
     rc.setHeight(h);
 
     KisFilterStrategy *actualStrategy = KisFilterStrategyRegistry::instance()->get(strategy);
     if (!actualStrategy) actualStrategy = KisFilterStrategyRegistry::instance()->get("Bicubic");
 
     image->scaleImage(rc.size(), xres/72, yres/72, actualStrategy);
 }
 
 void Document::rotateImage(double radians)
 {
     if (!d->document) return;
     KisImageSP image = d->document->image();
     if (!image) return;
     image->rotateImage(radians);
 }
 
 void Document::shearImage(double angleX, double angleY)
 {
     if (!d->document) return;
     KisImageSP image = d->document->image();
     if (!image) return;
     image->shear(angleX, angleY);
 }
 
 bool Document::save()
 {
     if (!d->document) return false;
     if (d->document->url().isEmpty()) return false;
 
     bool retval = d->document->save(true, 0);
     d->document->waitForSavingToComplete();
 
     return retval;
 }
 
 bool Document::saveAs(const QString &filename)
 {
     if (!d->document) return false;
 
     const QString outputFormatString = KisMimeDatabase::mimeTypeForFile(filename, false);
     const QByteArray outputFormat = outputFormatString.toLatin1();
     QUrl oldUrl = d->document->url();
     d->document->setUrl(QUrl::fromLocalFile(filename));
     bool retval = d->document->saveAs(QUrl::fromLocalFile(filename), outputFormat, true);
     d->document->waitForSavingToComplete();
     d->document->setUrl(oldUrl);
 
     return retval;
 }
 
 Node* Document::createNode(const QString &name, const QString &nodeType)
 {
     if (!d->document) return 0;
     if (!d->document->image()) return 0;
     KisImageSP image = d->document->image();
 
     Node *node = 0;
 
     if (nodeType.toLower()== "paintlayer") {
         node = new Node(image, new KisPaintLayer(image, name, OPACITY_OPAQUE_U8));
     }
     else if (nodeType.toLower()  == "grouplayer") {
         node = new Node(image, new KisGroupLayer(image, name, OPACITY_OPAQUE_U8));
     }
     else if (nodeType.toLower()  == "filelayer") {
         node = new Node(image, new KisFileLayer(image, name, OPACITY_OPAQUE_U8));
     }
     else if (nodeType.toLower()  == "filterlayer") {
         node = new Node(image, new KisAdjustmentLayer(image, name, 0, 0));
     }
     else if (nodeType.toLower()  == "filllayer") {
         node = new Node(image, new KisGeneratorLayer(image, name, 0, 0));
     }
     else if (nodeType.toLower()  == "clonelayer") {
         node = new Node(image, new KisCloneLayer(0, image, name, OPACITY_OPAQUE_U8));
     }
     else if (nodeType.toLower()  == "vectorlayer") {
         node = new Node(image, new KisShapeLayer(d->document->shapeController(), image, name, OPACITY_OPAQUE_U8));
     }
     else if (nodeType.toLower()  == "transparencymask") {
         node = new Node(image, new KisTransparencyMask());
     }
     else if (nodeType.toLower()  == "filtermask") {
         node = new Node(image, new KisFilterMask());
     }
     else if (nodeType.toLower()  == "transformmask") {
         node = new Node(image, new KisTransformMask());
     }
     else if (nodeType.toLower()  == "selectionmask") {
         node = new Node(image, new KisSelectionMask(image));
     }
     return node;
 }
 
 GroupLayer *Document::createGroupLayer(const QString &name)
 {
     if (!d->document) return 0;
     if (!d->document->image()) return 0;
     KisImageSP image = d->document->image();
 
     return new GroupLayer(image, name);
 }
 
 FileLayer *Document::createFileLayer(const QString &name, const QString fileName, const QString scalingMethod)
 {
     if (!d->document) return 0;
     if (!d->document->image()) return 0;
     KisImageSP image = d->document->image();
 
     return new FileLayer(image, name, this->fileName(), fileName, scalingMethod);
 }
 
 FilterLayer *Document::createFilterLayer(const QString &name, Filter &filter, Selection &selection)
 {
     if (!d->document) return 0;
     if (!d->document->image()) return 0;
     KisImageSP image = d->document->image();
 
     return new FilterLayer(image, name, filter, selection);
 }
 
 FillLayer *Document::createFillLayer(const QString &name, const QString generatorName, InfoObject &configuration, Selection &selection)
 {
     if (!d->document) return 0;
     if (!d->document->image()) return 0;
     KisImageSP image = d->document->image();
 
     KisGeneratorSP generator = KisGeneratorRegistry::instance()->value(generatorName);
     if (generator) {
 
         KisFilterConfigurationSP config = generator->defaultConfiguration();
         Q_FOREACH(const QString property, configuration.properties().keys()) {
             config->setProperty(property, configuration.property(property));
         }
 
         return new FillLayer(image, name, config, selection);
     }
     return 0;
 }
 
 CloneLayer *Document::createCloneLayer(const QString &name, const Node *source)
 {
     if (!d->document) return 0;
     if (!d->document->image()) return 0;
     KisImageSP image = d->document->image();
     KisLayerSP layer = qobject_cast<KisLayer*>(source->node().data());
 
     return new CloneLayer(image, name, layer);
 }
 
 VectorLayer *Document::createVectorLayer(const QString &name)
 {
     if (!d->document) return 0;
     if (!d->document->image()) return 0;
     KisImageSP image = d->document->image();
 
     return new VectorLayer(d->document->shapeController(), image, name);
 }
 
 FilterMask *Document::createFilterMask(const QString &name, Filter &filter)
 {
     if (!d->document) return 0;
     if (!d->document->image()) return 0;
     KisImageSP image = d->document->image();
 
     return new FilterMask(image, name, filter);
 }
 
 SelectionMask *Document::createSelectionMask(const QString &name)
 {
     if (!d->document) return 0;
     if (!d->document->image()) return 0;
     KisImageSP image = d->document->image();
 
     return new SelectionMask(image, name);
 }
 
 
 QImage Document::projection(int x, int y, int w, int h) const
 {
     if (!d->document || !d->document->image()) return QImage();
     return d->document->image()->convertToQImage(x, y, w, h, 0);
 }
 
 QImage Document::thumbnail(int w, int h) const
 {
     if (!d->document || !d->document->image()) return QImage();
     return d->document->generatePreview(QSize(w, h)).toImage();
 }
 
 
 void Document::lock()
 {
     if (!d->document || !d->document->image()) return;
     d->document->image()->barrierLock();
 }
 
 void Document::unlock()
 {
     if (!d->document || !d->document->image()) return;
     d->document->image()->unlock();
 }
 
 void Document::waitForDone()
 {
     if (!d->document || !d->document->image()) return;
     d->document->image()->waitForDone();
 }
 
 bool Document::tryBarrierLock()
 {
     if (!d->document || !d->document->image()) return false;
     return d->document->image()->tryBarrierLock();
 }
 
 bool Document::isIdle()
 {
     if (!d->document || !d->document->image()) return false;
     return d->document->image()->isIdle();
 }
 
 void Document::refreshProjection()
 {
     if (!d->document || !d->document->image()) return;
     d->document->image()->refreshGraph();
 }
 
 QList<qreal> Document::horizontalGuides() const
 {
     QList<qreal> lines;
     if (!d->document || !d->document->image()) return lines;
     KisCoordinatesConverter converter;
     converter.setImage(d->document->image());
     QTransform transform = converter.imageToDocumentTransform().inverted();
     QList<qreal> untransformedLines = d->document->guidesConfig().horizontalGuideLines();
     for (int i = 0; i< untransformedLines.size(); i++) {
         qreal line = untransformedLines[i];
         lines.append(transform.map(QPointF(line, line)).x());
     }
     return lines;
 }
 
 QList<qreal> Document::verticalGuides() const
 {
     QList<qreal> lines;
     if (!d->document || !d->document->image()) return lines;
     KisCoordinatesConverter converter;
     converter.setImage(d->document->image());
     QTransform transform = converter.imageToDocumentTransform().inverted();
     QList<qreal> untransformedLines = d->document->guidesConfig().verticalGuideLines();
     for (int i = 0; i< untransformedLines.size(); i++) {
         qreal line = untransformedLines[i];
         lines.append(transform.map(QPointF(line, line)).y());
     }
     return lines;
 }
 
 bool Document::guidesVisible() const
 {
     return d->document->guidesConfig().lockGuides();
 }
 
 bool Document::guidesLocked() const
 {
     return d->document->guidesConfig().showGuides();
 }
 
 Document *Document::clone() const
 {
     if (!d->document) return 0;
     QPointer<KisDocument> clone = d->document->clone();
     Document * d = new Document(clone);
     clone->setParent(d); // It's owned by the document, not KisPart
     return d;
 }
 
 void Document::setHorizontalGuides(const QList<qreal> &lines)
 {
     if (!d->document) return;
     KisGuidesConfig config = d->document->guidesConfig();
     KisCoordinatesConverter converter;
     converter.setImage(d->document->image());
     QTransform transform = converter.imageToDocumentTransform();
     QList<qreal> transformedLines;
     for (int i = 0; i< lines.size(); i++) {
         qreal line = lines[i];
         transformedLines.append(transform.map(QPointF(line, line)).x());
     }
     config.setHorizontalGuideLines(transformedLines);
     d->document->setGuidesConfig(config);
 }
 
 void Document::setVerticalGuides(const QList<qreal> &lines)
 {
     if (!d->document) return;
     KisGuidesConfig config = d->document->guidesConfig();
     KisCoordinatesConverter converter;
     converter.setImage(d->document->image());
     QTransform transform = converter.imageToDocumentTransform();
     QList<qreal> transformedLines;
     for (int i = 0; i< lines.size(); i++) {
         qreal line = lines[i];
         transformedLines.append(transform.map(QPointF(line, line)).y());
     }
     config.setVerticalGuideLines(transformedLines);
     d->document->setGuidesConfig(config);
 }
 
 void Document::setGuidesVisible(bool visible)
 {
     if (!d->document) return;
     KisGuidesConfig config = d->document->guidesConfig();
     config.setShowGuides(visible);
     d->document->setGuidesConfig(config);
 }
 
 void Document::setGuidesLocked(bool locked)
 {
     if (!d->document) return;
     KisGuidesConfig config = d->document->guidesConfig();
     config.setLockGuides(locked);
     d->document->setGuidesConfig(config);
 }
 
+bool Document::modified() const
+{
+    if (!d->document) return false;
+    return d->document->isModified();
+}
+
 QPointer<KisDocument> Document::document() const
 {
     return d->document;
 }
diff --git a/libs/libkis/Document.h b/libs/libkis/Document.h
index def3b9931e..2bb15c0c0e 100644
--- a/libs/libkis/Document.h
+++ b/libs/libkis/Document.h
@@ -1,752 +1,757 @@
 /*
  *  Copyright (c) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef LIBKIS_DOCUMENT_H
 #define LIBKIS_DOCUMENT_H
 
 #include <QObject>
 
 #include "kritalibkis_export.h"
 #include "libkis.h"
 
 #include "GroupLayer.h"
 #include "CloneLayer.h"
 #include "FileLayer.h"
 #include "FilterLayer.h"
 #include "FillLayer.h"
 #include "VectorLayer.h"
 #include "FilterMask.h"
 #include "SelectionMask.h"
 
 class KisDocument;
 
 /**
  * The Document class encapsulates a Krita Document/Image. A Krita document is an Image with
  * a filename. Libkis does not differentiate between a document and an image, like Krita does
  * internally.
  */
 class KRITALIBKIS_EXPORT Document : public QObject
 {
     Q_OBJECT
     Q_DISABLE_COPY(Document)
 
 public:
     explicit Document(KisDocument *document, QObject *parent = 0);
     ~Document() override;
 
     bool operator==(const Document &other) const;
     bool operator!=(const Document &other) const;
 
     /**
      * @brief horizontalGuides
      * The horizontal guides.
      * @return a list of the horizontal positions of guides.
      */
     QList<qreal> horizontalGuides() const;
     /**
      * @brief verticalGuides
      * The vertical guide lines.
      * @return a list of vertical guides.
      */
     QList<qreal> verticalGuides() const;
 
     /**
      * @brief guidesVisible
      * Returns guide visiiblity.
      * @return whether the guides are visible.
      */
     bool guidesVisible() const;
     /**
      * @brief guidesLocked
      * Returns guide lockedness.
      * @return whether the guides are locked.
      */
     bool guidesLocked() const;
 
 public Q_SLOTS:
 
     /**
      * @brief clone create a shallow clone of this document.
      * @return a new Document that should be identical to this one in every respect.
      */
     Document *clone() const;
 
     /**
      * Batchmode means that no actions on the document should show dialogs or popups.
      * @return true if the document is in batchmode.
      */
     bool batchmode() const;
 
     /**
      * Set batchmode to @param value. If batchmode is true, then there should be no popups
      * or dialogs shown to the user.
      */
     void setBatchmode(bool value);
 
     /**
      * @brief activeNode retrieve the node that is currently active in the currently active window
      * @return the active node. If there is no active window, the first child node is returned.
      */
     Node* activeNode() const;
 
     /**
      * @brief setActiveNode make the given node active in the currently active view and window
      * @param value the node to make active.
      */
     void setActiveNode(Node* value);
 
     /**
      * @brief toplevelNodes return a list with all top level nodes in the image graph
      */
     QList<Node*> topLevelNodes() const;
 
     /**
      * @brief nodeByName searches the node tree for a node with the given name and returns it
      * @param name the name of the node
      * @return the first node with the given name or 0 if no node is found
      */
     Node *nodeByName(const QString &name) const;
 
     /**
      * colorDepth A string describing the color depth of the image:
      * <ul>
      * <li>U8: unsigned 8 bits integer, the most common type</li>
      * <li>U16: unsigned 16 bits integer</li>
      * <li>F16: half, 16 bits floating point. Only available if Krita was built with OpenEXR</li>
      * <li>F32: 32 bits floating point</li>
      * </ul>
      * @return the color depth.
      */
     QString colorDepth() const;
 
     /**
      * @brief colorModel retrieve the current color model of this document:
      * <ul>
      * <li>A: Alpha mask</li>
      * <li>RGBA: RGB with alpha channel (The actual order of channels is most often BGR!)</li>
      * <li>XYZA: XYZ with alpha channel</li>
      * <li>LABA: LAB with alpha channel</li>
      * <li>CMYKA: CMYK with alpha channel</li>
      * <li>GRAYA: Gray with alpha channel</li>
      * <li>YCbCrA: YCbCr with alpha channel</li>
      * </ul>
      * @return the internal color model string.
      */
     QString colorModel() const;
 
     /**
      * @return the name of the current color profile
      */
     QString colorProfile() const;
 
     /**
      * @brief setColorProfile set the color profile of the image to the given profile. The profile has to
      * be registered with krita and be compatible with the current color model and depth; the image data
      * is <i>not</i> converted.
      * @param colorProfile
      * @return false if the colorProfile name does not correspond to to a registered profile or if assigning
      * the profile failed.
      */
     bool setColorProfile(const QString &colorProfile);
 
     /**
      * @brief setColorSpace convert the nodes and the image to the given colorspace. The conversion is
      * done with Perceptual as intent, High Quality and No LCMS Optimizations as flags and no blackpoint
      * compensation.
      *
      * @param colorModel A string describing the color model of the image:
      * <ul>
      * <li>A: Alpha mask</li>
      * <li>RGBA: RGB with alpha channel (The actual order of channels is most often BGR!)</li>
      * <li>XYZA: XYZ with alpha channel</li>
      * <li>LABA: LAB with alpha channel</li>
      * <li>CMYKA: CMYK with alpha channel</li>
      * <li>GRAYA: Gray with alpha channel</li>
      * <li>YCbCrA: YCbCr with alpha channel</li>
      * </ul>
      * @param colorDepth A string describing the color depth of the image:
      * <ul>
      * <li>U8: unsigned 8 bits integer, the most common type</li>
      * <li>U16: unsigned 16 bits integer</li>
      * <li>F16: half, 16 bits floating point. Only available if Krita was built with OpenEXR</li>
      * <li>F32: 32 bits floating point</li>
      * </ul>
      * @param colorProfile a valid color profile for this color model and color depth combination.
      * @return false the combination of these arguments does not correspond to a colorspace.
      */
     bool setColorSpace(const QString &colorModel, const QString &colorDepth, const QString &colorProfile);
 
     /**
      * @brief backgroundColor returns the current background color of the document. The color will
      * also include the opacity.
      *
      * @return QColor
      */
     QColor backgroundColor();
 
     /**
      * @brief setBackgroundColor sets the background color of the document. It will trigger a projection
      * update.
      *
      * @param color A QColor. The color will be converted from sRGB.
      * @return bool
      */
     bool setBackgroundColor(const QColor &color);
 
     /**
      * @brief documentInfo creates and XML document representing document and author information.
      * @return a string containing a valid XML document with the right information about the document
      * and author. The DTD can be found here:
      *
      * https://phabricator.kde.org/source/krita/browse/master/krita/dtd/
      *
      * @code
      * <?xml version="1.0" encoding="UTF-8"?>
      * <!DOCTYPE document-info PUBLIC '-//KDE//DTD document-info 1.1//EN' 'http://www.calligra.org/DTD/document-info-1.1.dtd'>
      * <document-info xmlns="http://www.calligra.org/DTD/document-info">
      * <about>
      *  <title>My Document</title>
      *   <description></description>
      *   <subject></subject>
      *   <abstract><![CDATA[]]></abstract>
      *   <keyword></keyword>
      *   <initial-creator>Unknown</initial-creator>
      *   <editing-cycles>1</editing-cycles>
      *   <editing-time>35</editing-time>
      *   <date>2017-02-27T20:15:09</date>
      *   <creation-date>2017-02-27T20:14:33</creation-date>
      *   <language></language>
      *  </about>
      *  <author>
      *   <full-name>Boudewijn Rempt</full-name>
      *   <initial></initial>
      *   <author-title></author-title>
      *   <email></email>
      *   <telephone></telephone>
      *   <telephone-work></telephone-work>
      *   <fax></fax>
      *   <country></country>
      *   <postal-code></postal-code>
      *   <city></city>
      *   <street></street>
      *   <position></position>
      *   <company></company>
      *  </author>
      * </document-info>
      * @endcode
      *
      */
     QString documentInfo() const;
 
     /**
      * @brief setDocumentInfo set the Document information to the information contained in document
      * @param document A string containing a valid XML document that conforms to the document-info DTD
      * that can be found here:
      *
      * https://phabricator.kde.org/source/krita/browse/master/krita/dtd/
      */
     void setDocumentInfo(const QString &document);
 
     /**
      * @return the full path to the document, if it has been set.
      */
     QString fileName() const;
 
     /**
      * @brief setFileName set the full path of the document to @param value
      */
     void setFileName(QString value);
 
     /**
      * @return the height of the image in pixels
      */
     int height() const;
 
     /**
      * @brief setHeight resize the document to @param value height. This is a canvas resize, not a scale.
      */
     void setHeight(int value);
 
     /**
      * @return the name of the document. This is the title field in the @see documentInfo
      */
     QString name() const;
 
     /**
      * @brief setName sets the name of the document to @param value. This is the title field in the @see documentInfo
      */
     void setName(QString value);
 
     /**
      * @return the resolution in pixels per inch
      */
     int resolution() const;
     /**
      * @brief setResolution set the resolution of the image; this does not scale the image
      * @param value the resolution in pixels per inch
      */
     void setResolution(int value);
 
     /**
      * @brief rootNode the root node is the invisible group layer that contains the entire node
      * hierarchy.
      * @return the root of the image
      */
     Node* rootNode() const;
 
     /**
      * @brief selection Create a Selection object around the global selection, if there is one.
      * @return the global selection or None if there is no global selection.
      */
     Selection* selection() const;
 
     /**
      * @brief setSelection set or replace the global selection
      * @param value a valid selection object.
      */
     void setSelection(Selection* value);
 
     /**
      * @return the width of the image in pixels.
      */
     int width() const;
 
     /**
      * @brief setWidth resize the document to @param value width. This is a canvas resize, not a scale.
      */
     void setWidth(int value);
 
     /**
      * @return the left edge of the canvas in pixels.
      */
     int xOffset() const;
 
     /**
      * @brief setXOffset sets the left edge of the canvas to @param x.
      */
     void setXOffset(int x);
 
     /**
      * @return the top edge of the canvas in pixels.
      */
     int yOffset() const;
 
     /**
      * @brief setYOffset sets the top edge of the canvas to @param y.
      */
     void setYOffset(int y);
 
     /**
      * @return xRes the horizontal resolution of the image in pixels per pt (there are 72 pts to an inch)
      */
 
     double xRes() const;
 
     /**
      * @brief setXRes set the horizontal resolution of the image to xRes in pixels per pt. (there are 72 pts to an inch)
      */
     void setXRes(double xRes) const;
 
     /**
      * @return yRes the vertical resolution of the image in pixels per pt (there are 72 pts to an inch)
      */
     double yRes() const;
 
     /**
      * @brief setYRes set the vertical resolution of the image to yRes in pixels per pt. (there are 72 pts to an inch)
      */
     void setYRes(double yRes) const;
 
     /**
      * @brief pixelData reads the given rectangle from the image projection and returns it as a byte
      * array. The pixel data starts top-left, and is ordered row-first.
      *
      * The byte array can be interpreted as follows: 8 bits images have one byte per channel,
      * and as many bytes as there are channels. 16 bits integer images have two bytes per channel,
      * representing an unsigned short. 16 bits float images have two bytes per channel, representing
      * a half, or 16 bits float. 32 bits float images have four bytes per channel, representing a
      * float.
      *
      * You can read outside the image boundaries; those pixels will be transparent black.
      *
      * The order of channels is:
      *
      * <ul>
      * <li>Integer RGBA: Blue, Green, Red, Alpha
      * <li>Float RGBA: Red, Green, Blue, Alpha
      * <li>LabA: L, a, b, Alpha
      * <li>CMYKA: Cyan, Magenta, Yellow, Key, Alpha
      * <li>XYZA: X, Y, Z, A
      * <li>YCbCrA: Y, Cb, Cr, Alpha
      * </ul>
      *
      * The byte array is a copy of the original image data. In Python, you can use bytes, bytearray
      * and the struct module to interpret the data and construct, for instance, a Pillow Image object.
      *
      * @param x x position from where to start reading
      * @param y y position from where to start reading
      * @param w row length to read
      * @param h number of rows to read
      * @return a QByteArray with the pixel data. The byte array may be empty.
      */
     QByteArray pixelData(int x, int y, int w, int h) const;
 
     /**
      * @brief close Close the document: remove it from Krita's internal list of documents and
      * close all views. If the document is modified, you should save it first. There will be
      * no prompt for saving.
      *
      * After closing the document it becomes invalid.
      *
      * @return true if the document is closed.
      */
     bool close();
 
     /**
      * @brief crop the image to rectangle described by @param x, @param y,
      * @param w and @param h
      */
     void crop(int x, int y, int w, int h);
 
     /**
      * @brief exportImage export the image, without changing its URL to the given path.
      * @param filename the full path to which the image is to be saved
      * @param exportConfiguration a configuration object appropriate to the file format.
      * An InfoObject will used to that configuration.
      *
      * The supported formats have specific configurations that must be used when in
      * batchmode. They are described below:
      *
      *\b png
      * <ul>
      * <li>alpha: bool (True or False)
      * <li>compression: int (1 to 9)
      * <li>forceSRGB: bool (True or False)
      * <li>indexed: bool (True or False)
      * <li>interlaced: bool (True or False)
      * <li>saveSRGBProfile: bool (True or False)
      * <li>transparencyFillcolor: rgb (Ex:[255,255,255])
      * </ul>
      *
      *\b jpeg
      * <ul>
      * <li>baseline: bool (True or False)
      * <li>exif: bool (True or False)
      * <li>filters: bool (['ToolInfo', 'Anonymizer'])
      * <li>forceSRGB: bool (True or False)
      * <li>iptc: bool (True or False)
      * <li>is_sRGB: bool (True or False)
      * <li>optimize: bool (True or False)
      * <li>progressive: bool (True or False)
      * <li>quality: int (0 to 100)
      * <li>saveProfile: bool (True or False)
      * <li>smoothing: int (0 to 100)
      * <li>subsampling: int (0 to 3)
      * <li>transparencyFillcolor: rgb (Ex:[255,255,255])
      * <li>xmp: bool (True or False)
      * </ul>
      * @return true if the export succeeded, false if it failed.
      */
     bool exportImage(const QString &filename, const InfoObject &exportConfiguration);
 
     /**
      * @brief flatten all layers in the image
      */
     void flatten();
 
     /**
      * @brief resizeImage resizes the canvas to the given left edge, top edge, width and height.
      * Note: This doesn't scale, use scale image for that.
      * @param x the new left edge
      * @param y the new top edge
      * @param w the new width
      * @param h the new height
      */
     void resizeImage(int x, int y, int w, int h);
 
     /**
     * @brief scaleImage
     * @param w the new width
     * @param h the new height
     * @param xres the new xres
     * @param yres the new yres
     * @param strategy the scaling strategy. There's several ones amongst these that aren't available in the regular UI.
     * The list of filters is extensible and can be retrieved with Krita::filter
     * <ul>
     * <li>Hermite</li>
     * <li>Bicubic - Adds pixels using the color of surrounding pixels. Produces smoother tonal gradations than Bilinear.</li>
     * <li>Box - Replicate pixels in the image. Preserves all the original detail, but can produce jagged effects.</li>
     * <li>Bilinear - Adds pixels averaging the color values of surrounding pixels. Produces medium quality results when the image is scaled from half to two times the original size.</li>
     * <li>Bell</li>
     * <li>BSpline</li>
     * <li>Kanczos3 - Offers similar results than Bicubic, but maybe a little bit sharper. Can produce light and dark halos along strong edges.</li>
     * <li>Mitchell</li>
     * </ul>
     */
    void scaleImage(int w, int h, int xres, int yres, QString strategy);
 
    /**
     * @brief rotateImage
     * Rotate the image by the given radians.
     * @param radians the amount you wish to rotate the image in radians
     */
    void rotateImage(double radians);
 
    /**
     * @brief shearImage shear the whole image.
     * @param angleX the X-angle in degrees to shear by
     * @param angleY the Y-angle in degrees to shear by
     */
    void shearImage(double angleX, double angleY);
 
     /**
      * @brief save the image to its currently set path. The modified flag of the
      * document will be reset
      * @return true if saving succeeded, false otherwise.
      */
     bool save();
 
     /**
      * @brief saveAs save the document under the @param filename. The document's
      * filename will be reset to @param filename.
      * @param filename the new filename (full path) for the document
      * @return true if saving succeeded, false otherwise.
      */
     bool saveAs(const QString &filename);
 
     /**
      * @brief createNode create a new node of the given type. The node is not added
      * to the node hierarchy; you need to do that by finding the right parent node,
      * getting its list of child nodes and adding the node in the right place, then
      * calling Node::SetChildNodes
      *
      * @param name The name of the node
      *
      * @param nodeType The type of the node. Valid types are:
      * <ul>
      *  <li>paintlayer
      *  <li>grouplayer
      *  <li>filelayer
      *  <li>filterlayer
      *  <li>filllayer
      *  <li>clonelayer
      *  <li>vectorlayer
      *  <li>transparencymask
      *  <li>filtermask
      *  <li>transformmask
      *  <li>selectionmask
      * </ul>
      *
      * When relevant, the new Node will have the colorspace of the image by default;
      * that can be changed with Node::setColorSpace.
      *
      * The settings and selections for relevant layer and mask types can also be set
      * after the Node has been created.
      *
 @code
 d = Application.createDocument(1000, 1000, "Test", "RGBA", "U8", "", 120.0)
 root = d.rootNode();
 print(root.childNodes())
 l2 = d.createNode("layer2", "paintLayer")
 print(l2)
 root.addChildNode(l2, None)
 print(root.childNodes())
 @endcode
      *
      *
      * @return the new Node.
      */
     Node* createNode(const QString &name, const QString &nodeType);
     /**
      * @brief createGroupLayer
      * Returns a grouplayer object. Grouplayers are nodes that can have
      * other layers as children and have the passthrough mode.
      * @param name the name of the layer.
      * @return a GroupLayer object.
      */
     GroupLayer* createGroupLayer(const QString &name);
     /**
      * @brief createFileLayer returns a layer that shows an external image.
      * @param name name of the file layer.
      * @param fileName the absolute filename of the file referenced. Symlinks will be resolved.
      * @param scalingMethod how the dimensions of the file are interpreted
      *        can be either "None", "ImageToSize" or "ImageToPPI"
      * @return a FileLayer
      */
     FileLayer* createFileLayer(const QString &name, const QString fileName, const QString scalingMethod);
 
     /**
      * @brief createFilterLayer creates a filter layer, which is a layer that represents a filter
      * applied non-destructively.
      * @param name name of the filterLayer
      * @param filter the filter that this filter layer will us.
      * @param selection the selection.
      * @return a filter layer object.
      */
     FilterLayer* createFilterLayer(const QString &name, Filter &filter, Selection &selection);
 
     /**
      * @brief createFillLayer creates a fill layer object, which is a layer
      * @param name
      * @param generatorName - name of the generation filter.
      * @param configuration - the configuration for the generation filter.
      * @param selection - the selection.
      * @return a filllayer object.
      *
      * @code
      * from krita import *
      * d = Krita.instance().activeDocument()
      * i = InfoObject();
      * i.setProperty("pattern", "Cross01.pat")
      * s = Selection();
      * s.select(0, 0, d.width(), d.height(), 255)
      * n = d.createFillLayer("test", "pattern", i, s)
      * r = d.rootNode();
      * c = r.childNodes();
      * r.addChildNode(n, c[0])
      * d.refreshProjection()
      * @endcode
      */
     FillLayer* createFillLayer(const QString &name, const QString generatorName, InfoObject &configuration, Selection &selection);
 
     /**
      * @brief createCloneLayer
      * @param name
      * @param source
      * @return
      */
     CloneLayer* createCloneLayer(const QString &name, const Node* source);
 
     /**
      * @brief createVectorLayer
      * Creates a vector layer that can contain vector shapes.
      * @param name the name of this layer.
      * @return a VectorLayer.
      */
     VectorLayer* createVectorLayer(const QString &name);
 
     /**
      * @brief createFilterMask
      * Creates a filter mask object that much like a filterlayer can apply a filter non-destructively.
      * @param name the name of the layer.
      * @param filter the filter assigned.
      * @return a FilterMask
      */
     FilterMask* createFilterMask(const QString &name, Filter &filter);
 
     /**
      * @brief createSelectionMask
      * Creates a selection mask, which can be used to store selections.
      * @param name - the name of the layer.
      * @return a SelectionMask
      */
     SelectionMask* createSelectionMask(const QString &name);
 
 
     /**
      * @brief projection creates a QImage from the rendered image or
      * a cutout rectangle.
      */
     QImage projection(int x = 0, int y = 0, int w = 0, int h = 0) const;
 
     /**
      * @brief thumbnail create a thumbnail of the given dimensions.
      *
      * If the requested size is too big a null QImage is created.
      *
      * @return a QImage representing the layer contents.
      */
     QImage thumbnail(int w, int h) const;
 
 
     /**
      * Why this should be used, When it should be used, How it should be used,
      * and warnings about when not.
      */
     void lock();
 
     /**
      * Why this should be used, When it should be used, How it should be used,
      * and warnings about when not.
      */
     void unlock();
 
     /**
      * Why this should be used, When it should be used, How it should be used,
      * and warnings about when not.
      */
     void waitForDone();
 
     /**
      * Why this should be used, When it should be used, How it should be used,
      * and warnings about when not.
      */
     bool tryBarrierLock();
 
     /**
      * Why this should be used, When it should be used, How it should be used,
      * and warnings about when not.
      */
     bool isIdle();
 
     /**
      * Starts a synchronous recomposition of the projection: everything will
      * wait until the image is fully recomputed.
      */
     void refreshProjection();
     /**
      * @brief setHorizontalGuides
      * replace all existing horizontal guides with the entries in the list.
      * @param list a list of floats containing the new guides.
      */
     void setHorizontalGuides(const QList<qreal> &lines);
     /**
      * @brief setVerticalGuides
      * replace all existing horizontal guides with the entries in the list.
      * @param list a list of floats containing the new guides.
      */
     void setVerticalGuides(const QList<qreal> &lines);
 
     /**
      * @brief setGuidesVisible
      * set guides visible on this document.
      * @param visible whether or not the guides are visible.
      */
     void setGuidesVisible(bool visible);
 
     /**
      * @brief setGuidesLocked
      * set guides locked on this document
      * @param locked whether or not to lock the guides on this document.
      */
     void setGuidesLocked(bool locked);
 
+    /**
+     * @brief modified returns true if the document has unsaved modifications.
+     */
+    bool modified() const;
+
 private:
 
     friend class Krita;
     friend class Window;
     friend class Filter;
     QPointer<KisDocument> document() const;
 
 
 private:
     struct Private;
     Private *const d;
 
 };
 
 #endif // LIBKIS_DOCUMENT_H
diff --git a/libs/libkis/Filter.cpp b/libs/libkis/Filter.cpp
index 56d6c7c3a2..6c945e09ee 100644
--- a/libs/libkis/Filter.cpp
+++ b/libs/libkis/Filter.cpp
@@ -1,173 +1,174 @@
 /*
  *  Copyright (c) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "Filter.h"
 
 #include <KoCanvasResourceManager.h>
 
 #include <kis_canvas_resource_provider.h>
 #include <kis_filter.h>
 #include <kis_properties_configuration.h>
 #include <kis_filter_configuration.h>
 #include <kis_filter_manager.h>
 #include <kis_filter_registry.h>
 #include <KisPart.h>
 #include <KisView.h>
 
 #include <strokes/kis_filter_stroke_strategy.h>
 #include <krita_utils.h>
 
 #include "Krita.h"
 #include "Document.h"
 #include "InfoObject.h"
 #include "Node.h"
 
 struct Filter::Private {
     Private() {}
     QString name;
     InfoObject *configuration {0};
 };
 
 Filter::Filter()
     : QObject(0)
     , d(new Private)
 {
 }
 
 Filter::~Filter()
 {
     delete d->configuration;
     delete d;
 }
 
 bool Filter::operator==(const Filter &other) const
 {
     return (d->name == other.d->name
             && d->configuration == other.d->configuration);
 }
 
 bool Filter::operator!=(const Filter &other) const
 {
     return !(operator==(other));
 }
 
 
 QString Filter::name() const
 {
     return d->name;
 }
 
 void Filter::setName(const QString &name)
 {
     d->name = name;
     delete d->configuration;
 
     KisFilterSP filter = KisFilterRegistry::instance()->value(d->name);
     d->configuration = new InfoObject(filter->defaultConfiguration());
 }
 
 InfoObject* Filter::configuration() const
 {
     return d->configuration;
 }
 
 void Filter::setConfiguration(InfoObject* value)
 {
     d->configuration = value;
 }
 
 bool Filter::apply(Node *node, int x, int y, int w, int h)
 {
     if (node->locked()) return false;
 
     KisFilterSP filter = KisFilterRegistry::instance()->value(d->name);
     if (!filter) return false;
 
     KisPaintDeviceSP dev = node->paintDevice();
     if (!dev) return false;
 
     QRect applyRect = QRect(x, y, w, h);
     KisFilterConfigurationSP config = static_cast<KisFilterConfiguration*>(d->configuration->configuration().data());
     filter->process(dev, applyRect, config);
     return true;
 }
 
 bool Filter::startFilter(Node *node, int x, int y, int w, int h)
 {
     if (node->locked()) return false;
 
     KisFilterSP filter = KisFilterRegistry::instance()->value(d->name);
     if (!filter) return false;
 
     KisImageWSP image = node->image();
     if (!image) return false;
 
     KisFilterConfigurationSP filterConfig = static_cast<KisFilterConfiguration*>(d->configuration->configuration().data());
 
     image->waitForDone();
     QRect initialApplyRect = QRect(x, y, w, h);
 
     QRect applyRect = initialApplyRect;
 
     KisPaintDeviceSP paintDevice = node->paintDevice();
     if (paintDevice && filter->needsTransparentPixels(filterConfig.data(), paintDevice->colorSpace())) {
         applyRect |= image->bounds();
     }
 
     KisResourcesSnapshotSP resources = new KisResourcesSnapshot(image, node->node());
 
     Document *document = Krita::instance()->activeDocument();
     if (document && KisPart::instance()->viewCount(document->document()) > 0) {
         Q_FOREACH (QPointer<KisView> view, KisPart::instance()->views()) {
             if (view && view->document() == document->document()) {
                 resources = new KisResourcesSnapshot(image, node->node(), view->resourceProvider()->resourceManager());
                 break;
             }
         }
     }
     delete document;
 
     KisStrokeId currentStrokeId = image->startStroke(new KisFilterStrokeStrategy(filter,
                                                                                  KisFilterConfigurationSP(filterConfig),
                                                                                  resources));
 
     QRect processRect = filter->changedRect(applyRect, filterConfig.data(), 0);
     processRect &= image->bounds();
 
     if (filter->supportsThreading()) {
         QSize size = KritaUtils::optimalPatchSize();
         QVector<QRect> rects = KritaUtils::splitRectIntoPatches(processRect, size);
         Q_FOREACH (const QRect &rc, rects) {
             image->addJob(currentStrokeId, new KisFilterStrokeStrategy::Data(rc, true));
         }
     } else {
         image->addJob(currentStrokeId, new KisFilterStrokeStrategy::Data(processRect, false));
     }
 
     image->endStroke(currentStrokeId);
+    image->waitForDone();
 
     return true;
 }
 
 KisFilterConfigurationSP Filter::filterConfig()
 {
     KisFilterConfigurationSP config = KisFilterRegistry::instance()->get(d->name)->defaultConfiguration();
     Q_FOREACH(const QString property, d->configuration->properties().keys()) {
         config->setProperty(property, d->configuration->property(property));
     }
     return config;
 }
diff --git a/libs/libkis/Node.h b/libs/libkis/Node.h
index ea1d4feee2..790ee974c6 100644
--- a/libs/libkis/Node.h
+++ b/libs/libkis/Node.h
@@ -1,548 +1,550 @@
 /*
  *  Copyright (c) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef LIBKIS_NODE_H
 #define LIBKIS_NODE_H
 
 #include <QObject>
 
 #include <kis_types.h>
 
 #include "kritalibkis_export.h"
 #include "libkis.h"
 
 /**
  * Node represents a layer or mask in a Krita image's Node hierarchy. Group layers can contain
  * other layers and masks; layers can contain masks.
  *
  */
 class KRITALIBKIS_EXPORT Node : public QObject
 {
     Q_OBJECT
     Q_DISABLE_COPY(Node)
 
 public:
     explicit Node(KisImageSP image, KisNodeSP node, QObject *parent = 0);
     ~Node() override;
     bool operator==(const Node &other) const;
     bool operator!=(const Node &other) const;
 
 public Q_SLOTS:
 
     /**
      * @brief clone clone the current node. The node is not associated with any image.
      */
     Node *clone() const;
 
     /**
      * @brief alphaLocked checks whether the node is a paint layer and returns whether it is alpha locked
      * @return whether the paint layer is alpha locked, or false if the node is not a paint layer
      */
     bool alphaLocked() const;
 
     /**
      * @brief setAlphaLocked set the layer to value if the node is paint layer.
      */
     void setAlphaLocked(bool value);
 
     /**
      * @return the blending mode of the layer. The values of the blending modes are defined in @see KoCompositeOpRegistry.h
      */
     QString blendingMode() const;
 
     /**
      * @brief setBlendingMode set the blending mode of the node to the given value
      * @param value one of the string values from @see KoCompositeOpRegistry.h
      */
     void setBlendingMode(QString value);
 
     /**
      * @brief channels creates a list of Channel objects that can be used individually to
      * show or hide certain channels, and to retrieve the contents of each channel in a
      * node separately.
      *
      * Only layers have channels, masks do not, and calling channels on a Node that is a mask
      * will return an empty list.
      *
      * @return the list of channels ordered in by position of the channels in pixel position
      */
     QList<Channel*> channels() const;
 
     /**
      * Return a list of child nodes of the current node. The nodes are ordered from the bottommost up.
      * The function is not recursive.
      */
     QList<Node*> childNodes() const;
 
     /**
      * @brief addChildNode adds the given node in the list of children.
      * @param child the node to be added
      * @param above the node above which this node will be placed
      * @return false if adding the node failed
      */
     bool addChildNode(Node *child, Node *above);
 
     /**
      * @brief removeChildNode removes the given node from the list of children.
      * @param child the node to be removed
      */
     bool removeChildNode(Node *child);
 
     /**
      * @brief setChildNodes this replaces the existing set of child nodes with the new set.
      * @param nodes The list of nodes that will become children, bottom-up -- the first node,
      * is the bottom-most node in the stack.
      */
     void setChildNodes(QList<Node*> nodes);
 
     /**
      * colorDepth A string describing the color depth of the image:
      * <ul>
      * <li>U8: unsigned 8 bits integer, the most common type</li>
      * <li>U16: unsigned 16 bits integer</li>
      * <li>F16: half, 16 bits floating point. Only available if Krita was built with OpenEXR</li>
      * <li>F32: 32 bits floating point</li>
      * </ul>
      * @return the color depth.
      */
     QString colorDepth() const;
 
     /**
      * @brief colorModel retrieve the current color model of this document:
      * <ul>
      * <li>A: Alpha mask</li>
      * <li>RGBA: RGB with alpha channel (The actual order of channels is most often BGR!)</li>
      * <li>XYZA: XYZ with alpha channel</li>
      * <li>LABA: LAB with alpha channel</li>
      * <li>CMYKA: CMYK with alpha channel</li>
      * <li>GRAYA: Gray with alpha channel</li>
      * <li>YCbCrA: YCbCr with alpha channel</li>
      * </ul>
      * @return the internal color model string.
      */
     QString colorModel() const;
 
     /**
      * @return the name of the current color profile
      */
     QString colorProfile() const;
 
     /**
      * @brief setColorProfile set the color profile of the image to the given profile. The profile has to
      * be registered with krita and be compatible with the current color model and depth; the image data
      * is <i>not</i> converted.
      * @param colorProfile
      * @return if assigining the colorprofiel worked
      */
     bool setColorProfile(const QString &colorProfile);
 
     /**
      * @brief setColorSpace convert the node to the given colorspace
      * @param colorModel A string describing the color model of the node:
      * <ul>
      * <li>A: Alpha mask</li>
      * <li>RGBA: RGB with alpha channel (The actual order of channels is most often BGR!)</li>
      * <li>XYZA: XYZ with alpha channel</li>
      * <li>LABA: LAB with alpha channel</li>
      * <li>CMYKA: CMYK with alpha channel</li>
      * <li>GRAYA: Gray with alpha channel</li>
      * <li>YCbCrA: YCbCr with alpha channel</li>
      * </ul>
      * @param colorDepth A string describing the color depth of the image:
      * <ul>
      * <li>U8: unsigned 8 bits integer, the most common type</li>
      * <li>U16: unsigned 16 bits integer</li>
      * <li>F16: half, 16 bits floating point. Only available if Krita was built with OpenEXR</li>
      * <li>F32: 32 bits floating point</li>
      * </ul>
      * @param colorProfile a valid color profile for this color model and color depth combination.
      */
     bool setColorSpace(const QString &colorModel, const QString &colorDepth, const QString &colorProfile);
 
     /**
      * @brief Krita layers can be animated, i.e., have frames.
      * @return return true if the layer has frames. Currently, the scripting framework
      * does not give access to the animation features.
      */
     bool animated() const;
 
     /**
      * @brief enableAnimation make the current layer animated, so it can have frames.
      */
     void enableAnimation() const;
 
     /**
      * Sets the state of the node to the value of @param collapsed
      */
     void setCollapsed(bool collapsed);
 
     /**
      * returns the collapsed state of this node
      */
     bool collapsed() const;
 
     /**
      * Sets a color label index associated to the layer.  The actual
      * color of the label and the number of available colors is
      * defined by Krita GUI configuration.
      */
     int colorLabel() const;
 
     /**
      * @brief setColorLabel sets a color label index associated to the layer.  The actual
      * color of the label and the number of available colors is
      * defined by Krita GUI configuration.
      * @param index an integer corresponding to the set of available color labels.
      */
     void setColorLabel(int index);
 
     /**
      * @brief inheritAlpha checks whether this node has the inherits alpha flag set
      * @return true if the Inherit Alpha is set
      */
     bool inheritAlpha() const;
 
     /**
      * set the Inherit Alpha flag to the given value
      */
     void setInheritAlpha(bool value);
 
     /**
      * @brief locked checks whether the Node is locked. A locked node cannot be changed.
      * @return true if the Node is locked, false if it hasn't been locked.
      */
     bool locked() const;
 
     /**
      * set the Locked flag to the give value
      */
     void setLocked(bool value);
 
     /**
      * @brief does the node have any content in it?
      * @return if node has any content in it
      */
     bool hasExtents();
 
 
     /**
      * @return the user-visible name of this node.
      */
     QString name() const;
 
     /**
      * rename the Node to the given name
      */
     void setName(QString name);
 
     /**
      * return the opacity of the Node. The opacity is a value between 0 and 255.
      */
     int opacity() const;
 
     /**
      * set the opacity of the Node to the given value. The opacity is a value between 0 and 255.
      */
     void setOpacity(int value);
 
     /**
      * return the Node that is the parent of the current Node, or 0 if this is the root Node.
      */
     Node* parentNode() const;
 
     /**
      * @brief type Krita has several types of nodes, split in layers and masks. Group
      * layers can contain other layers, any layer can contain masks.
      *
      * @return The type of the node. Valid types are:
      * <ul>
      *  <li>paintlayer
      *  <li>grouplayer
      *  <li>filelayer
      *  <li>filterlayer
      *  <li>filllayer
      *  <li>clonelayer
      *  <li>vectorlayer
      *  <li>transparencymask
      *  <li>filtermask
      *  <li>transformmask
      *  <li>selectionmask
      *  <li>colorizemask
      * </ul>
      *
      * If the Node object isn't wrapping a valid Krita layer or mask object, and
      * empty string is returned.
      */
     virtual QString type() const;
 
     /**
      * @brief icon
      * @return the icon associated with the layer.
      */
     QIcon icon() const;
 
     /**
      * Check whether the current Node is visible in the layer stack
      */
     bool visible() const;
 
     /**
      * Set the visibility of the current node to @param visible
      */
     void setVisible(bool visible);
 
     /**
      * @brief pixelData reads the given rectangle from the Node's paintable pixels, if those
      * exist, and returns it as a byte array. The pixel data starts top-left, and is ordered row-first.
      *
      * The byte array can be interpreted as follows: 8 bits images have one byte per channel,
      * and as many bytes as there are channels. 16 bits integer images have two bytes per channel,
      * representing an unsigned short. 16 bits float images have two bytes per channel, representing
      * a half, or 16 bits float. 32 bits float images have four bytes per channel, representing a
      * float.
      *
      * You can read outside the node boundaries; those pixels will be transparent black.
      *
      * The order of channels is:
      *
      * <ul>
      * <li>Integer RGBA: Blue, Green, Red, Alpha
      * <li>Float RGBA: Red, Green, Blue, Alpha
      * <li>GrayA: Gray, Alpha
      * <li>Selection: selectedness
      * <li>LabA: L, a, b, Alpha
      * <li>CMYKA: Cyan, Magenta, Yellow, Key, Alpha
      * <li>XYZA: X, Y, Z, A
      * <li>YCbCrA: Y, Cb, Cr, Alpha
      * </ul>
      *
      * The byte array is a copy of the original node data. In Python, you can use bytes, bytearray
      * and the struct module to interpret the data and construct, for instance, a Pillow Image object.
      *
      * If you read the pixeldata of a mask, a filter or generator layer, you get the selection bytes,
      * which is one channel with values in the range from 0..255.
      *
      * If you want to change the pixels of a node you can write the pixels back after manipulation
      * with setPixelData(). This will only succeed on nodes with writable pixel data, e.g not on groups
      * or file layers.
      *
      * @param x x position from where to start reading
      * @param y y position from where to start reading
      * @param w row length to read
      * @param h number of rows to read
      * @return a QByteArray with the pixel data. The byte array may be empty.
 
      */
     QByteArray pixelData(int x, int y, int w, int h) const;
 
     /**
      * @brief pixelDataAtTime a basic function to get pixeldata from an animated node at a given time.
      * @param x the position from the left to start reading.
      * @param y the position from the top to start reader
      * @param w the row length to read
      * @param h the number of rows to read
      * @param time the frame number
      * @return a QByteArray with the pixel data. The byte array may be empty.
      */
     QByteArray pixelDataAtTime(int x, int y, int w, int h, int time) const;
 
     /**
      * @brief projectionPixelData reads the given rectangle from the Node's projection (that is, what the node
      * looks like after all sub-Nodes (like layers in a group or masks on a layer) have been applied,
      * and returns it as a byte array. The pixel data starts top-left, and is ordered row-first.
      *
      * The byte array can be interpreted as follows: 8 bits images have one byte per channel,
      * and as many bytes as there are channels. 16 bits integer images have two bytes per channel,
      * representing an unsigned short. 16 bits float images have two bytes per channel, representing
      * a half, or 16 bits float. 32 bits float images have four bytes per channel, representing a
      * float.
      *
      * You can read outside the node boundaries; those pixels will be transparent black.
      *
      * The order of channels is:
      *
      * <ul>
      * <li>Integer RGBA: Blue, Green, Red, Alpha
      * <li>Float RGBA: Red, Green, Blue, Alpha
      * <li>GrayA: Gray, Alpha
      * <li>Selection: selectedness
      * <li>LabA: L, a, b, Alpha
      * <li>CMYKA: Cyan, Magenta, Yellow, Key, Alpha
      * <li>XYZA: X, Y, Z, A
      * <li>YCbCrA: Y, Cb, Cr, Alpha
      * </ul>
      *
      * The byte array is a copy of the original node data. In Python, you can use bytes, bytearray
      * and the struct module to interpret the data and construct, for instance, a Pillow Image object.
      *
      * If you read the projection of a mask, you get the selection bytes, which is one channel with
      * values in the range from 0..255.
      *
      * If you want to change the pixels of a node you can write the pixels back after manipulation
      * with setPixelData(). This will only succeed on nodes with writable pixel data, e.g not on groups
      * or file layers.
      *
      * @param x x position from where to start reading
      * @param y y position from where to start reading
      * @param w row length to read
      * @param h number of rows to read
      * @return a QByteArray with the pixel data. The byte array may be empty.
      */
     QByteArray projectionPixelData(int x, int y, int w, int h) const;
 
     /**
      * @brief setPixelData writes the given bytes, of which there must be enough, into the
      * Node, if the Node has writable pixel data:
      *
      * <ul>
      * <li>paint layer: the layer's original pixels are overwritten
      * <li>filter layer, generator layer, any mask: the embedded selection's pixels are overwritten.
      * <b>Note:</b> for these
      * </ul>
      *
      * File layers, Group layers, Clone layers cannot be written to. Calling setPixelData on
      * those layer types will silently do nothing.
      *
      * @param value the byte array representing the pixels. There must be enough bytes available.
      * Krita will take the raw pointer from the QByteArray and start reading, not stopping before
      * (number of channels * size of channel * w * h) bytes are read.
      *
      * @param x the x position to start writing from
      * @param y the y position to start writing from
      * @param w the width of each row
      * @param h the number of rows to write
      */
     void setPixelData(QByteArray value, int x, int y, int w, int h);
 
     /**
      * @brief bounds return the exact bounds of the node's paint device
      * @return the bounds, or an empty QRect if the node has no paint device or is empty.
      */
     QRect bounds() const;
 
     /**
      *  move the pixels to the given x, y location in the image coordinate space.
      */
     void move(int x, int y);
 
     /**
-     * @brief position returns the position of the paint device of this node
+     * @brief position returns the position of the paint device of this node. The position is
+     * always 0,0 unless the layer has been moved. If you want to know the topleft position of
+     * the rectangle around the actual non-transparent pixels in the node, use bounds().
      * @return the top-left position of the node
      */
     QPoint position() const;
 
     /**
      * @brief remove removes this node from its parent image.
      */
     bool remove();
 
     /**
      * @brief duplicate returns a full copy of the current node. The node is not inserted in the graphc
      * @return a valid Node object or 0 if the node couldn't be duplicated.
      */
     Node* duplicate();
 
     /**
      * @brief save exports the given node with this filename. The extension of the filename determines the filetype.
      * @param filename the filename including extension
      * @param xRes the horizontal resolution in pixels per pt (there are 72 pts in an inch)
      * @param yRes the horizontal resolution in pixels per pt (there are 72 pts in an inch)
      * @return true if saving succeeded, false if it failed.
      */
     bool save(const QString &filename, double xRes, double yRes);
 
     /**
      * @brief mergeDown merges the given node with the first visible node underneath this node in the layerstack.
      * This will drop all per-layer metadata.
      */
     Node *mergeDown();
 
     /**
      * @brief scaleNode
      * @param width
      * @param height
      * @param strategy the scaling strategy. There's several ones amongst these that aren't available in the regular UI.
      * <ul>
      * <li>Hermite</li>
      * <li>Bicubic - Adds pixels using the color of surrounding pixels. Produces smoother tonal gradations than Bilinear.</li>
      * <li>Box - Replicate pixels in the image. Preserves all the original detail, but can produce jagged effects.</li>
      * <li>Bilinear - Adds pixels averaging the color values of surrounding pixels. Produces medium quality results when the image is scaled from half to two times the original size.</li>
      * <li>Bell</li>
      * <li>BSpline</li>
      * <li>Lanczos3 - Offers similar results than Bicubic, but maybe a little bit sharper. Can produce light and dark halos along strong edges.</li>
      * <li>Mitchell</li>
      * </ul>
      */
     void scaleNode(int width, int height, QString strategy);
 
     /**
      * @brief rotateNode rotate this layer by the given radians.
      * @param radians amount the layer should be rotated in, in radians.
      */
     void rotateNode(double radians);
 
     /**
      * @brief cropNode crop this layer.
      * @param x the left edge of the cropping rectangle.
      * @param y the top edge of the cropping rectangle
      * @param w the right edge of the cropping rectangle
      * @param h the bottom edge of the cropping rectangle
      */
     void cropNode(int x, int y, int w, int h);
 
     /**
      * @brief shearNode perform a shear operation on this node.
      * @param angleX the X-angle in degrees to shear by
      * @param angleY the Y-angle in degrees to shear by
      */
     void shearNode(double angleX, double angleY);
 
     /**
      * @brief thumbnail create a thumbnail of the given dimensions. The thumbnail is sized according
      * to the layer dimensions, not the image dimensions. If the requested size is too big a null
      * QImage is created. If the current node cannot generate a thumbnail, a transparent QImage of the
      * requested size is generated.
      * @return a QImage representing the layer contents.
      */
     QImage thumbnail(int w, int h);
 
 private:
 
     friend class Filter;
     friend class Document;
     friend class Selection;
     friend class GroupLayer;
     friend class FileLayer;
     friend class FilterLayer;
     friend class FillLayer;
     friend class VectorLayer;
     friend class FilterMask;
     friend class SelectionMask;
     /**
      * @brief paintDevice gives access to the internal paint device of this Node
      * @return the paintdevice or 0 if the node does not have an editable paint device.
      */
     KisPaintDeviceSP paintDevice() const;
     KisImageSP image() const;
     KisNodeSP node() const;
 
     struct Private;
     Private *const d;
 
 };
 
 #endif // LIBKIS_NODE_H
diff --git a/libs/libkis/tests/CMakeLists.txt b/libs/libkis/tests/CMakeLists.txt
index a37b723f7e..6015e8bb78 100644
--- a/libs/libkis/tests/CMakeLists.txt
+++ b/libs/libkis/tests/CMakeLists.txt
@@ -1,17 +1,17 @@
 set( EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR} )
 
 include(ECMAddTests)
 include(KritaAddBrokenUnitTest)
 
 macro_add_unittest_definitions()
 
 ecm_add_tests(
     #TestKrita.cpp
     TestChannel.cpp
     TestDocument.cpp
     TestNode.cpp
     TestFilter.cpp
     TestManagedColor.cpp
     TestNotifier
-    NAME_PREFIX "libs-kritalibkis-"
+    NAME_PREFIX "libs-libkis-"
     LINK_LIBRARIES kritalibkis Qt5::Test)
diff --git a/libs/libkis/tests/TestChannel.cpp b/libs/libkis/tests/TestChannel.cpp
index 9ac6ec50e4..da7eaf0b41 100644
--- a/libs/libkis/tests/TestChannel.cpp
+++ b/libs/libkis/tests/TestChannel.cpp
@@ -1,91 +1,93 @@
 /* Copyright (C) 2017 Boudewijn Rempt <boud@valdyas.org>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU 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 "TestChannel.h"
 #include <QTest>
 #include <QColor>
 #include <QDataStream>
 
 #include <KritaVersionWrapper.h>
 #include <Node.h>
 #include <Channel.h>
 #include <Krita.h>
 
 #include <KoColorSpaceRegistry.h>
 #include <KoColorProfile.h>
 #include <KoColor.h>
 
 #include <kis_image.h>
 #include <kis_fill_painter.h>
 #include <kis_paint_layer.h>
+#include "sdk/tests/kistest.h"
+
 
 void TestChannel::testPixelDataU8()
 {
     KisImageSP image = new KisImage(0, 100, 100, KoColorSpaceRegistry::instance()->rgb8(), "test");
     KisNodeSP layer = new KisPaintLayer(image, "test1", 255);
     KisFillPainter gc(layer->paintDevice());
     gc.fillRect(0, 0, 100, 100, KoColor(Qt::red, layer->colorSpace()));
     Node node(image, layer);
     QList<Channel*> channels = node.channels();
     Q_FOREACH(Channel *channel, channels) {
         QVERIFY(channel->channelSize() == 1);
     }
 
 }
 
 void TestChannel::testPixelDataU16()
 {
     KisImageSP image = new KisImage(0, 100, 100, KoColorSpaceRegistry::instance()->rgb16(), "test");
     KisNodeSP layer = new KisPaintLayer(image, "test1", 255);
     KisFillPainter gc(layer->paintDevice());
     gc.fillRect(0, 0, 100, 100, KoColor(Qt::red, layer->colorSpace()));
     Node node(image, layer);
     QList<Channel*> channels = node.channels();
     Q_FOREACH(Channel *channel, channels) {
         QVERIFY(channel->channelSize() == 2);
     }
 }
 
 void TestChannel::testPixelDataF16()
 {
     KisImageSP image = new KisImage(0, 100, 100, KoColorSpaceRegistry::instance()->colorSpace("RGBA", "F16", ""), "test");
     KisNodeSP layer = new KisPaintLayer(image, "test1", 255);
     KisFillPainter gc(layer->paintDevice());
     gc.fillRect(0, 0, 100, 100, KoColor(Qt::red, layer->colorSpace()));
     Node node(image, layer);
     QList<Channel*> channels = node.channels();
     Q_FOREACH(Channel *channel, channels) {
         QVERIFY(channel->channelSize() == 2);
     }
 }
 
 void TestChannel::testPixelDataF32()
 {
     KisImageSP image = new KisImage(0, 100, 100, KoColorSpaceRegistry::instance()->colorSpace("RGBA", "F32", ""), "test");
     KisNodeSP layer = new KisPaintLayer(image, "test1", 255);
     KisFillPainter gc(layer->paintDevice());
     gc.fillRect(0, 0, 100, 100, KoColor(Qt::red, layer->colorSpace()));
     Node node(image, layer);
     QList<Channel*> channels = node.channels();
     Q_FOREACH(Channel *channel, channels) {
         QVERIFY(channel->channelSize() == 4);
     }
 }
 
 
-QTEST_MAIN(TestChannel)
+KISTEST_MAIN(TestChannel)
 
diff --git a/libs/pigment/KoColor.cpp b/libs/pigment/KoColor.cpp
index 33c95e2977..983e501ddc 100644
--- a/libs/pigment/KoColor.cpp
+++ b/libs/pigment/KoColor.cpp
@@ -1,423 +1,427 @@
 /*
  *  Copyright (c) 2005 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (C) 2007 Thomas Zander <zander@kde.org>
  *  Copyright (C) 2007 Cyrille Berger <cberger@cberger.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #include "KoColor.h"
 
 #include <QColor>
 
 #include <QDomDocument>
 
 #include "DebugPigment.h"
 
 #include "KoColorModelStandardIds.h"
 #include "KoColorProfile.h"
 #include "KoColorSpace.h"
 #include "KoColorSpaceRegistry.h"
 #include "KoChannelInfo.h"
 #include "kis_assert.h"
 
 #include <QGlobalStatic>
 
 #include <KoConfig.h>
 #ifdef HAVE_OPENEXR
 #include <half.h>
 #endif
 
 namespace {
 
 struct DefaultKoColorInitializer
 {
     DefaultKoColorInitializer() {
         const KoColorSpace *defaultColorSpace = KoColorSpaceRegistry::instance()->rgb16(0);
         KIS_ASSERT(defaultColorSpace);
 
         value = new KoColor(Qt::black, defaultColorSpace);
 #ifndef NODEBUG
 #ifndef QT_NO_DEBUG
         // warn about rather expensive checks in assertPermanentColorspace().
         qWarning() << "KoColor debug runtime checks are active.";
 #endif
 #endif
     }
 
     KoColor *value = 0;
 };
 
 Q_GLOBAL_STATIC(DefaultKoColorInitializer, s_defaultKoColor);
 
 }
 
 
 KoColor::KoColor() {
     *this = *s_defaultKoColor->value;
 }
 
 KoColor::KoColor(const KoColorSpace * colorSpace)
 {
     Q_ASSERT(colorSpace);
     m_colorSpace = KoColorSpaceRegistry::instance()->permanentColorspace(colorSpace);
     m_size = m_colorSpace->pixelSize();
     Q_ASSERT(m_size <= MAX_PIXEL_SIZE);
     memset(m_data, 0, m_size);
 }
 
 KoColor::KoColor(const QColor & color, const KoColorSpace * colorSpace)
 {
     Q_ASSERT(color.isValid());
     Q_ASSERT(colorSpace);
     m_colorSpace = KoColorSpaceRegistry::instance()->permanentColorspace(colorSpace);
 
     m_size = m_colorSpace->pixelSize();
     Q_ASSERT(m_size <= MAX_PIXEL_SIZE);
     memset(m_data, 0, m_size);
 
     m_colorSpace->fromQColor(color, m_data);
 }
 
 KoColor::KoColor(const quint8 * data, const KoColorSpace * colorSpace)
 {
     Q_ASSERT(colorSpace);
     Q_ASSERT(data);
     m_colorSpace = KoColorSpaceRegistry::instance()->permanentColorspace(colorSpace);
     m_size = m_colorSpace->pixelSize();
     Q_ASSERT(m_size <= MAX_PIXEL_SIZE);
     memmove(m_data, data, m_size);
 }
 
 
 KoColor::KoColor(const KoColor &src, const KoColorSpace * colorSpace)
 {
     Q_ASSERT(colorSpace);
     m_colorSpace = KoColorSpaceRegistry::instance()->permanentColorspace(colorSpace);
     m_size = m_colorSpace->pixelSize();
     Q_ASSERT(m_size <= MAX_PIXEL_SIZE);
     memset(m_data, 0, m_size);
 
     src.colorSpace()->convertPixelsTo(src.m_data, m_data, colorSpace, 1, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
 }
 
 void KoColor::convertTo(const KoColorSpace * cs, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     //dbgPigment <<"Our colormodel:" << d->colorSpace->id().name()
     //      << ", new colormodel: " << cs->id().name() << "\n";
 
     if (*m_colorSpace == *cs)
         return;
 
     quint8 data[MAX_PIXEL_SIZE];
     const size_t size = cs->pixelSize();
     Q_ASSERT(size <= MAX_PIXEL_SIZE);
     memset(data, 0, size);
 
     m_colorSpace->convertPixelsTo(m_data, data, cs, 1, renderingIntent, conversionFlags);
 
     memcpy(m_data, data, size);
     m_size = size;
     m_colorSpace = KoColorSpaceRegistry::instance()->permanentColorspace(cs);
 }
 
 void KoColor::convertTo(const KoColorSpace * cs)
 {
     convertTo(cs,
               KoColorConversionTransformation::internalRenderingIntent(),
               KoColorConversionTransformation::internalConversionFlags());
 }
 
 KoColor KoColor::convertedTo(const KoColorSpace *cs, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags) const
 {
     KoColor result(*this);
     result.convertTo(cs, renderingIntent, conversionFlags);
     return result;
 }
 
 KoColor KoColor::convertedTo(const KoColorSpace *cs) const
 {
     return convertedTo(cs,
                        KoColorConversionTransformation::internalRenderingIntent(),
                        KoColorConversionTransformation::internalConversionFlags());
 }
 
 void KoColor::setProfile(const KoColorProfile *profile)
 {
     const KoColorSpace *dstColorSpace =
             KoColorSpaceRegistry::instance()->colorSpace(colorSpace()->colorModelId().id(), colorSpace()->colorDepthId().id(), profile);
     if (!dstColorSpace) return;
 
     m_colorSpace = KoColorSpaceRegistry::instance()->permanentColorspace(dstColorSpace);
 }
 
 void KoColor::setColor(const quint8 * data, const KoColorSpace * colorSpace)
 {
     Q_ASSERT(colorSpace);
 
     const size_t size = colorSpace->pixelSize();
     Q_ASSERT(size <= MAX_PIXEL_SIZE);
 
     memcpy(m_data, data, size);
     m_colorSpace = KoColorSpaceRegistry::instance()->permanentColorspace(colorSpace);
 }
 
 // To save the user the trouble of doing color->colorSpace()->toQColor(color->data(), &c, &a, profile
 void KoColor::toQColor(QColor *c) const
 {
     Q_ASSERT(c);
     if (m_colorSpace) {
         m_colorSpace->toQColor(m_data, c);
     }
 }
 
 QColor KoColor::toQColor() const
 {
     QColor c;
     toQColor(&c);
     return c;
 }
 
 void KoColor::fromQColor(const QColor& c)
 {
     if (m_colorSpace) {
         m_colorSpace->fromQColor(c, m_data);
     }
 }
 
 void KoColor::subtract(const KoColor &value)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(*m_colorSpace == *value.colorSpace());
 
     QVector<float> channels1(m_colorSpace->channelCount());
     QVector<float> channels2(m_colorSpace->channelCount());
 
     m_colorSpace->normalisedChannelsValue(m_data, channels1);
     m_colorSpace->normalisedChannelsValue(value.data(), channels2);
 
     for (int i = 0; i < channels1.size(); i++) {
         channels1[i] -= channels2[i];
     }
 
     m_colorSpace->fromNormalisedChannelsValue(m_data, channels1);
 }
 
 KoColor KoColor::subtracted(const KoColor &value) const
 {
     KoColor result(*this);
     result.subtract(value);
     return result;
 }
 
 void KoColor::add(const KoColor &value)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(*m_colorSpace == *value.colorSpace());
 
     QVector<float> channels1(m_colorSpace->channelCount());
     QVector<float> channels2(m_colorSpace->channelCount());
 
     m_colorSpace->normalisedChannelsValue(m_data, channels1);
     m_colorSpace->normalisedChannelsValue(value.data(), channels2);
 
     for (int i = 0; i < channels1.size(); i++) {
         channels1[i] += channels2[i];
     }
 
     m_colorSpace->fromNormalisedChannelsValue(m_data, channels1);
 }
 
 KoColor KoColor::added(const KoColor &value) const
 {
     KoColor result(*this);
     result.add(value);
     return result;
 }
 
 #ifndef NDEBUG
 void KoColor::dump() const
 {
     dbgPigment <<"KoColor (" << this <<")," << m_colorSpace->id() <<"";
     QList<KoChannelInfo *> channels = m_colorSpace->channels();
 
     QList<KoChannelInfo *>::const_iterator begin = channels.constBegin();
     QList<KoChannelInfo *>::const_iterator end = channels.constEnd();
 
     for (QList<KoChannelInfo *>::const_iterator it = begin; it != end; ++it) {
         KoChannelInfo * ch = (*it);
         // XXX: setNum always takes a byte.
         if (ch->size() == sizeof(quint8)) {
             // Byte
             dbgPigment <<"Channel (byte):" << ch->name() <<":" << QString().setNum(m_data[ch->pos()]) <<"";
         } else if (ch->size() == sizeof(quint16)) {
             // Short (may also by an nvidia half)
             dbgPigment <<"Channel (short):" << ch->name() <<":" << QString().setNum(*((const quint16 *)(m_data+ch->pos())))  <<"";
         } else if (ch->size() == sizeof(quint32)) {
             // Integer (may also be float... Find out how to distinguish these!)
             dbgPigment <<"Channel (int):" << ch->name() <<":" << QString().setNum(*((const quint32 *)(m_data+ch->pos())))  <<"";
         }
     }
 }
 #endif
 
 void KoColor::fromKoColor(const KoColor& src)
 {
     src.colorSpace()->convertPixelsTo(src.m_data, m_data, colorSpace(), 1, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
 }
 
 const KoColorProfile *KoColor::profile() const
 {
     return m_colorSpace->profile();
 }
 
 void KoColor::toXML(QDomDocument& doc, QDomElement& colorElt) const
 {
     m_colorSpace->colorToXML(m_data, doc, colorElt);
 }
 
 void KoColor::setOpacity(quint8 alpha)
 {
     m_colorSpace->setOpacity(m_data, alpha, 1);
 }
 void KoColor::setOpacity(qreal alpha)
 {
     m_colorSpace->setOpacity(m_data, alpha, 1);
 }
 quint8 KoColor::opacityU8() const
 {
     return m_colorSpace->opacityU8(m_data);
 }
 qreal KoColor::opacityF() const
 {
     return m_colorSpace->opacityF(m_data);
 }
 
 KoColor KoColor::fromXML(const QDomElement& elt, const QString& bitDepthId)
 {
     bool ok;
     return fromXML(elt, bitDepthId, &ok);
 }
 
 KoColor KoColor::fromXML(const QDomElement& elt, const QString& bitDepthId, bool* ok)
 {
     *ok = true;
     QString modelId;
     if (elt.tagName() == "CMYK") {
         modelId = CMYKAColorModelID.id();
     } else if (elt.tagName() == "RGB") {
         modelId = RGBAColorModelID.id();
     } else if (elt.tagName() == "sRGB") {
         modelId = RGBAColorModelID.id();
     } else if (elt.tagName() == "Lab") {
         modelId = LABAColorModelID.id();
     } else if (elt.tagName() == "XYZ") {
         modelId = XYZAColorModelID.id();
     } else if (elt.tagName() == "Gray") {
         modelId = GrayAColorModelID.id();
     } else if (elt.tagName() == "YCbCr") {
         modelId = YCbCrAColorModelID.id();
     }
     QString profileName;
     if (elt.tagName() != "sRGB") {
         profileName = elt.attribute("space", "");
         if (!KoColorSpaceRegistry::instance()->profileByName(profileName)) {
             profileName.clear();
         }
     }
     const KoColorSpace* cs = KoColorSpaceRegistry::instance()->colorSpace(modelId, bitDepthId, profileName);
     if (cs == 0) {
         QList<KoID> list =  KoColorSpaceRegistry::instance()->colorDepthList(modelId, KoColorSpaceRegistry::AllColorSpaces);
         if (!list.empty()) {
             cs = KoColorSpaceRegistry::instance()->colorSpace(modelId, list[0].id(), profileName);
         }
     }
     if (cs) {
         KoColor c(cs);
         // TODO: Provide a way for colorFromXML() to notify the caller if parsing failed. Currently it returns default values on failure.
         cs->colorFromXML(c.data(), elt);
         return c;
     } else {
         *ok = false;
         return KoColor();
     }
 }
 
 QString KoColor::toQString(const KoColor &color)
 {
     QStringList ls;
     Q_FOREACH (KoChannelInfo *channel, KoChannelInfo::displayOrderSorted(color.colorSpace()->channels())) {
         int realIndex = KoChannelInfo::displayPositionToChannelIndex(channel->displayPosition(), color.colorSpace()->channels());
         ls << channel->name();
         ls << color.colorSpace()->channelValueText(color.data(), realIndex);
     }
     return ls.join(" ");
 }
 
 QDebug operator<<(QDebug dbg, const KoColor &color)
 {
     dbg.nospace() << "KoColor (" << color.colorSpace()->id();
 
     QList<KoChannelInfo*> channels = color.colorSpace()->channels();
     for (auto it = channels.constBegin(); it != channels.constEnd(); ++it) {
 
         KoChannelInfo *ch = (*it);
 
         dbg.nospace() << ", " << ch->name() << ":";
 
         switch (ch->channelValueType()) {
         case KoChannelInfo::UINT8: {
             const quint8 *ptr = reinterpret_cast<const quint8*>(color.data() + ch->pos());
             dbg.nospace() << *ptr;
             break;
         } case KoChannelInfo::UINT16: {
             const quint16 *ptr = reinterpret_cast<const quint16*>(color.data() + ch->pos());
             dbg.nospace() << *ptr;
             break;
         } case KoChannelInfo::UINT32: {
             const quint32 *ptr = reinterpret_cast<const quint32*>(color.data() + ch->pos());
             dbg.nospace() << *ptr;
             break;
-#ifdef HAVE_OPENEXR
         } case KoChannelInfo::FLOAT16: {
+
+#ifdef HAVE_OPENEXR
             const half *ptr = reinterpret_cast<const half*>(color.data() + ch->pos());
             dbg.nospace() << *ptr;
-            break;
+#else
+            const quint16 *ptr = reinterpret_cast<const quint16*>(color.data() + ch->pos());
+            dbg.nospace() << "UNSUPPORTED_F16(" << *ptr << ")";
 #endif
+            break;
         } case KoChannelInfo::FLOAT32: {
             const float *ptr = reinterpret_cast<const float*>(color.data() + ch->pos());
             dbg.nospace() << *ptr;
             break;
         } case KoChannelInfo::FLOAT64: {
             const double *ptr = reinterpret_cast<const double*>(color.data() + ch->pos());
             dbg.nospace() << *ptr;
             break;
         } case KoChannelInfo::INT8: {
             const qint8 *ptr = reinterpret_cast<const qint8*>(color.data() + ch->pos());
             dbg.nospace() << *ptr;
             break;
         } case KoChannelInfo::INT16: {
             const qint16 *ptr = reinterpret_cast<const qint16*>(color.data() + ch->pos());
             dbg.nospace() << *ptr;
             break;
         } case KoChannelInfo::OTHER: {
             const quint8 *ptr = reinterpret_cast<const quint8*>(color.data() + ch->pos());
             dbg.nospace() << "undef(" << *ptr << ")";
             break;
         }
         }
     }
     dbg.nospace() << ")";
     return dbg.space();
 }
diff --git a/libs/pigment/KoColorProfile.cpp b/libs/pigment/KoColorProfile.cpp
index c22aa40524..20c7d2db10 100644
--- a/libs/pigment/KoColorProfile.cpp
+++ b/libs/pigment/KoColorProfile.cpp
@@ -1,101 +1,101 @@
 /*
  *  Copyright (c) 2007 Cyrille Berger <cberger@cberger.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #include "KoColorProfile.h"
 #include "DebugPigment.h"
 
 struct Q_DECL_HIDDEN KoColorProfile::Private {
     QString name;
     QString info;
     QString fileName;
     QString manufacturer;
     QString copyright;
 };
 
 KoColorProfile::KoColorProfile(const QString &fileName) : d(new Private)
 {
 //     dbgPigment <<" Profile filename =" << fileName;
     d->fileName = fileName;
 }
 
 KoColorProfile::KoColorProfile(const KoColorProfile& profile)
     : d(new Private(*profile.d))
 {
 }
 
 KoColorProfile::~KoColorProfile()
 {
     delete d;
 }
 
 bool KoColorProfile::load()
 {
     return false;
 }
 
 bool KoColorProfile::save(const QString & filename)
 {
     Q_UNUSED(filename);
     return false;
 }
 
 
 QString KoColorProfile::name() const
 {
     return d->name;
 }
 
 QString KoColorProfile::info() const
 {
     return d->info;
 }
 QString KoColorProfile::manufacturer() const
 {
     return d->manufacturer;
 }
 QString KoColorProfile::copyright() const
 {
     return d->copyright;
 }
 QString KoColorProfile::fileName() const
 {
     return d->fileName;
 }
 
 void KoColorProfile::setFileName(const QString &f)
 {
     d->fileName = f;
 }
 
 void KoColorProfile::setName(const QString &name)
 {
     d->name = name;
 }
 void KoColorProfile::setInfo(const QString &info)
 {
     d->info = info;
 }
 void KoColorProfile::setManufacturer(const QString &manufacturer)
 {
     d->manufacturer = manufacturer;
 }
 void KoColorProfile::setCopyright(const QString &copyright)
 {
     d->copyright = copyright;
-}
\ No newline at end of file
+}
diff --git a/libs/pigment/KoColorSpace.cpp b/libs/pigment/KoColorSpace.cpp
index fce965ed3f..728f0c5d29 100644
--- a/libs/pigment/KoColorSpace.cpp
+++ b/libs/pigment/KoColorSpace.cpp
@@ -1,820 +1,816 @@
 /*
  *  Copyright (c) 2005 Boudewijn Rempt <boud@valdyas.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #include "KoColorSpace.h"
 #include "KoColorSpace_p.h"
 
 #include "KoChannelInfo.h"
 #include "DebugPigment.h"
 #include "KoCompositeOp.h"
 #include "KoColorTransformation.h"
 #include "KoColorTransformationFactory.h"
 #include "KoColorTransformationFactoryRegistry.h"
 #include "KoColorConversionCache.h"
 #include "KoColorConversionSystem.h"
 #include "KoColorSpaceRegistry.h"
 #include "KoColorProfile.h"
 #include "KoCopyColorConversionTransformation.h"
 #include "KoFallBackColorTransformation.h"
 #include "KoUniqueNumberForIdServer.h"
 #include "KoMixColorsOp.h"
 #include "KoConvolutionOp.h"
 #include "KoCompositeOpRegistry.h"
 #include "KoColorSpaceEngine.h"
 
 #include <QThreadStorage>
 #include <QByteArray>
 #include <QBitArray>
 #include <QPolygonF>
 #include <QPointF>
 
 #include <math.h>
 
 KoColorSpace::KoColorSpace()
-        : d(new Private())
+    : d(new Private())
 {
 }
 
 KoColorSpace::KoColorSpace(const QString &id, const QString &name, KoMixColorsOp* mixColorsOp, KoConvolutionOp* convolutionOp)
-        : d(new Private())
+    : d(new Private())
 {
     d->id = id;
     d->idNumber = KoUniqueNumberForIdServer::instance()->numberForId(d->id);
     d->name = name;
     d->mixColorsOp = mixColorsOp;
     d->convolutionOp = convolutionOp;
     d->transfoToRGBA16 = 0;
     d->transfoFromRGBA16 = 0;
     d->transfoToLABA16 = 0;
     d->transfoFromLABA16 = 0;
     d->gamutXYY = QPolygonF();
     d->TRCXYY = QPolygonF();
     d->colorants = QVector <qreal> (0);
     d->lumaCoefficients = QVector <qreal> (0);
     d->iccEngine = 0;
     d->deletability = NotOwnedByRegistry;
 }
 
 KoColorSpace::~KoColorSpace()
 {
     Q_ASSERT(d->deletability != OwnedByRegistryDoNotDelete);
 
     qDeleteAll(d->compositeOps);
     Q_FOREACH (KoChannelInfo * channel, d->channels) {
         delete channel;
     }
     if (d->deletability == NotOwnedByRegistry) {
         KoColorConversionCache* cache = KoColorSpaceRegistry::instance()->colorConversionCache();
         if (cache) {
             cache->colorSpaceIsDestroyed(this);
         }
     }
     delete d->mixColorsOp;
     delete d->convolutionOp;
     delete d->transfoToRGBA16;
     delete d->transfoFromRGBA16;
     delete d->transfoToLABA16;
     delete d->transfoFromLABA16;
     delete d;
 }
 
 bool KoColorSpace::operator==(const KoColorSpace& rhs) const
 {
     const KoColorProfile* p1 = rhs.profile();
     const KoColorProfile* p2 = profile();
     return d->idNumber == rhs.d->idNumber && ((p1 == p2) || (*p1 == *p2));
 }
 
 QString KoColorSpace::id() const
 {
     return d->id;
 }
 
 QString KoColorSpace::name() const
 {
     return d->name;
 }
 
 //Color space info stuff.
 QPolygonF KoColorSpace::gamutXYY() const
 {
     if (d->gamutXYY.empty()) {
         //now, let's decide on the boundary. This is a bit tricky because icc profiles can be both matrix-shaper and cLUT at once if the maker so pleases.
         //first make a list of colors.
         qreal max = 1.0;
         if ((colorModelId().id()=="CMYKA" || colorModelId().id()=="LABA") && colorDepthId().id()=="F32") {
             //boundaries for cmyka/laba have trouble getting the max values for Float, and are pretty awkward in general.
             max = this->channels()[0]->getUIMax();
 
         }
         int samples = 5;//amount of samples in our color space.
         const KoColorSpace* xyzColorSpace = KoColorSpaceRegistry::instance()->colorSpace("XYZA", "F32");
         quint8 *data = new quint8[pixelSize()];
         quint8 data2[16]; // xyza f32 is 4 floats, that is 16 bytes per pixel.
         //QVector <qreal> sampleCoordinates(pow(colorChannelCount(),samples));
         //sampleCoordinates.fill(0.0);
 
         // This is fixed to 5 since the maximum number of channels are 5 for CMYKA
         QVector <float> channelValuesF(5);//for getting the coordinates.
 
         for(int x=0;x<samples;x++){
             if (colorChannelCount()==1) {//gray
                 channelValuesF[0]=(max/(samples-1))*(x);
                 channelValuesF[1]=max;
                 fromNormalisedChannelsValue(data, channelValuesF);
                 convertPixelsTo(data, data2, xyzColorSpace, 1, KoColorConversionTransformation::IntentAbsoluteColorimetric, KoColorConversionTransformation::adjustmentConversionFlags());
                 xyzColorSpace->normalisedChannelsValue(data2, channelValuesF);
                 qreal x = channelValuesF[0]/(channelValuesF[0]+channelValuesF[1]+channelValuesF[2]);
                 qreal y = channelValuesF[1]/(channelValuesF[0]+channelValuesF[1]+channelValuesF[2]);
                 d->gamutXYY << QPointF(x,y);
             } else {
                 for(int y=0;y<samples;y++){
                     for(int z=0;z<samples;z++){
                         if (colorChannelCount()==4) {
                             for(int k=0;k<samples;k++){
                                 channelValuesF[0] = (max / (samples - 1)) * (x);
                                 channelValuesF[1] = (max / (samples - 1)) * (y);
                                 channelValuesF[2] = (max / (samples - 1)) * (z);
                                 channelValuesF[3] = (max / (samples - 1)) * (k);
                                 channelValuesF[4] = max;
                                 fromNormalisedChannelsValue(data, channelValuesF);
                                 convertPixelsTo(data, data2, xyzColorSpace, 1, KoColorConversionTransformation::IntentAbsoluteColorimetric, KoColorConversionTransformation::adjustmentConversionFlags());
                                 xyzColorSpace->normalisedChannelsValue(data2, channelValuesF);
                                 qreal x = channelValuesF[0] / (channelValuesF[0] + channelValuesF[1] + channelValuesF[2]);
                                 qreal y = channelValuesF[1] / (channelValuesF[0] + channelValuesF[1] + channelValuesF[2]);
                                 d->gamutXYY<< QPointF(x,y);
                             }
                         } else {
                             channelValuesF[0]=(max/(samples-1))*(x);
                             channelValuesF[1]=(max/(samples-1))*(y);
                             channelValuesF[2]=(max/(samples-1))*(z);
                             channelValuesF[3]=max;
                             if (colorModelId().id()!="XYZA") { //no need for conversion when using xyz.
                                 fromNormalisedChannelsValue(data, channelValuesF);
                                 convertPixelsTo(data, data2, xyzColorSpace, 1, KoColorConversionTransformation::IntentAbsoluteColorimetric,         KoColorConversionTransformation::adjustmentConversionFlags());
                                 xyzColorSpace->normalisedChannelsValue(data2,channelValuesF);
                             }
                             qreal x = channelValuesF[0]/(channelValuesF[0]+channelValuesF[1]+channelValuesF[2]);
                             qreal y = channelValuesF[1]/(channelValuesF[0]+channelValuesF[1]+channelValuesF[2]);
                             d->gamutXYY<< QPointF(x,y);
                         }
                     }
                 }
 
             }
         }
         delete[] data;
         //if we ever implement a boundary-checking thing I'd add it here.
         return d->gamutXYY;
     } else {
         return d->gamutXYY;
     }
 }
 
 QPolygonF KoColorSpace::estimatedTRCXYY() const
 {
     if (d->TRCXYY.empty()){
         qreal max = 1.0;
         if ((colorModelId().id()=="CMYKA" || colorModelId().id()=="LABA") && colorDepthId().id()=="F32") {
             //boundaries for cmyka/laba have trouble getting the max values for Float, and are pretty awkward in general.
             max = this->channels()[0]->getUIMax();
         }
         const KoColorSpace* xyzColorSpace = KoColorSpaceRegistry::instance()->colorSpace("XYZA", "F32");
         quint8 *data = new quint8[pixelSize()];
         quint8 *data2 = new quint8[xyzColorSpace->pixelSize()];
 
         // This is fixed to 5 since the maximum number of channels are 5 for CMYKA
         QVector <float> channelValuesF(5);//for getting the coordinates.
 
         for (quint32 i=0; i<colorChannelCount(); i++) {
             qreal colorantY=1.0;
             if (colorModelId().id()!="CMYKA") {
                 for (int j=5; j>0; j--){
                     channelValuesF.fill(0.0);
                     channelValuesF[i] = ((max/4)*(5-j));
 
                     if (colorModelId().id()!="XYZA") { //no need for conversion when using xyz.
                         fromNormalisedChannelsValue(data, channelValuesF);
                         convertPixelsTo(data, data2, xyzColorSpace, 1, KoColorConversionTransformation::IntentAbsoluteColorimetric,         KoColorConversionTransformation::adjustmentConversionFlags());
                         xyzColorSpace->normalisedChannelsValue(data2,channelValuesF);
                     }
 
                     if (j==0) {
                         colorantY = channelValuesF[1];
                         if (d->colorants.size()<2){
                             d->colorants.resize(3*colorChannelCount());
                             d->colorants[i]  = channelValuesF[0]/(channelValuesF[0]+channelValuesF[1]+channelValuesF[2]);
                             d->colorants[i+1]= channelValuesF[1]/(channelValuesF[0]+channelValuesF[1]+channelValuesF[2]);
                             d->colorants[i+2]= channelValuesF[1];
                         }
                     }
                     d->TRCXYY << QPointF(channelValuesF[1]/colorantY, ((1.0/4)*(5-j)));
                 }
             } else {
                 for (int j=0; j<5; j++){
                     channelValuesF.fill(0.0);
                     channelValuesF[i] = ((max/4)*(j));
 
                     fromNormalisedChannelsValue(data, channelValuesF);
 
                     convertPixelsTo(data, data2, xyzColorSpace, 1, KoColorConversionTransformation::IntentAbsoluteColorimetric,         KoColorConversionTransformation::adjustmentConversionFlags());
 
                     xyzColorSpace->normalisedChannelsValue(data2,channelValuesF);
 
                     if (j==0) {
                         colorantY = channelValuesF[1];
                         if (d->colorants.size()<2){
                             d->colorants.resize(3*colorChannelCount());
                             d->colorants[i]  = channelValuesF[0]/(channelValuesF[0]+channelValuesF[1]+channelValuesF[2]);
                             d->colorants[i+1]= channelValuesF[1]/(channelValuesF[0]+channelValuesF[1]+channelValuesF[2]);
                             d->colorants[i+2]= channelValuesF[1];
                         }
                     }
                     d->TRCXYY << QPointF(channelValuesF[1]/colorantY, ((1.0/4)*(j)));
                 }
             }
         }
 
         delete[] data;
         delete[] data2;
         return d->TRCXYY;
     } else {
         return d->TRCXYY;
     }
 }
 
-QVector <qreal> KoColorSpace::colorants() const
-{
-    if (d->colorants.size()>1){
-        return d->colorants;
-    } else if (profile() && profile()->hasColorants()) {
-        d->colorants.resize(3*colorChannelCount());
-        d->colorants = profile()->getColorantsxyY();
-        return d->colorants;
-    } else {
-        estimatedTRCXYY();
-        return d->colorants;
-    }
-}
 QVector <qreal> KoColorSpace::lumaCoefficients() const
 {
     if (d->lumaCoefficients.size()>1){
         return d->lumaCoefficients;
     } else {
         d->lumaCoefficients.resize(3);
         if (colorModelId().id()!="RGBA") {
             d->lumaCoefficients.fill(0.33);
         } else {
-            colorants();
+            if (d->colorants.size() <= 0) {
+                if (profile() && profile()->hasColorants()) {
+                    d->colorants.resize(3 * colorChannelCount());
+                    d->colorants = profile()->getColorantsxyY();
+                }
+                else {
+                    QPolygonF p = estimatedTRCXYY();
+                    Q_UNUSED(p);
+                }
+            }
             if (d->colorants[2]<0 || d->colorants[5]<0 || d->colorants[8]<0) {
                 d->lumaCoefficients[0]=0.2126;
                 d->lumaCoefficients[1]=0.7152;
                 d->lumaCoefficients[2]=0.0722;
             } else {
                 d->lumaCoefficients[0]=d->colorants[2];
                 d->lumaCoefficients[1]=d->colorants[5];
                 d->lumaCoefficients[2]=d->colorants[8];
             }
         }
         return d->lumaCoefficients;
     }
 }
 
 QList<KoChannelInfo *> KoColorSpace::channels() const
 {
     return d->channels;
 }
 
 QBitArray KoColorSpace::channelFlags(bool color, bool alpha) const
 {
     QBitArray ba(d->channels.size());
     if (!color && !alpha) return ba;
 
     for (int i = 0; i < d->channels.size(); ++i) {
         KoChannelInfo * channel = d->channels.at(i);
         if ((color && channel->channelType() == KoChannelInfo::COLOR) ||
                 (alpha && channel->channelType() == KoChannelInfo::ALPHA))
             ba.setBit(i, true);
     }
     return ba;
 }
 
 void KoColorSpace::addChannel(KoChannelInfo * ci)
 {
     d->channels.push_back(ci);
 }
 bool KoColorSpace::hasCompositeOp(const QString& id) const
 {
     return d->compositeOps.contains(id);
 }
 
 QList<KoCompositeOp*> KoColorSpace::compositeOps() const
 {
     return d->compositeOps.values();
 }
 
 KoMixColorsOp* KoColorSpace::mixColorsOp() const
 {
     return d->mixColorsOp;
 }
 
 
 KoConvolutionOp* KoColorSpace::convolutionOp() const
 {
     return d->convolutionOp;
 }
 
 const KoCompositeOp * KoColorSpace::compositeOp(const QString & id) const
 {
     const QHash<QString, KoCompositeOp*>::ConstIterator it = d->compositeOps.constFind(id);
     if (it != d->compositeOps.constEnd()) {
         return it.value();
     }
     else {
         warnPigment << "Asking for non-existent composite operation " << id << ", returning " << COMPOSITE_OVER;
         return d->compositeOps.value(COMPOSITE_OVER);
     }
 }
 
 void KoColorSpace::addCompositeOp(const KoCompositeOp * op)
 {
     if (op->colorSpace()->id() == id()) {
         d->compositeOps.insert(op->id(), const_cast<KoCompositeOp*>(op));
     }
 }
 
 const KoColorConversionTransformation* KoColorSpace::toLabA16Converter() const
 {
     if (!d->transfoToLABA16) {
         d->transfoToLABA16 = KoColorSpaceRegistry::instance()->createColorConverter(this, KoColorSpaceRegistry::instance()->lab16(), KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags()) ;
     }
     return d->transfoToLABA16;
 }
 
 const KoColorConversionTransformation* KoColorSpace::fromLabA16Converter() const
 {
     if (!d->transfoFromLABA16) {
         d->transfoFromLABA16 = KoColorSpaceRegistry::instance()->createColorConverter(KoColorSpaceRegistry::instance()->lab16(), this, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags()) ;
     }
     return d->transfoFromLABA16;
 }
 const KoColorConversionTransformation* KoColorSpace::toRgbA16Converter() const
 {
     if (!d->transfoToRGBA16) {
         d->transfoToRGBA16 = KoColorSpaceRegistry::instance()->createColorConverter(this, KoColorSpaceRegistry::instance()->rgb16(), KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags()) ;
     }
     return d->transfoToRGBA16;
 }
 const KoColorConversionTransformation* KoColorSpace::fromRgbA16Converter() const
 {
     if (!d->transfoFromRGBA16) {
         d->transfoFromRGBA16 = KoColorSpaceRegistry::instance()->createColorConverter(KoColorSpaceRegistry::instance()->rgb16() , this, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags()) ;
     }
     return d->transfoFromRGBA16;
 }
 
 void KoColorSpace::toLabA16(const quint8 * src, quint8 * dst, quint32 nPixels) const
 {
     toLabA16Converter()->transform(src, dst, nPixels);
 }
 
 void KoColorSpace::fromLabA16(const quint8 * src, quint8 * dst, quint32 nPixels) const
 {
     fromLabA16Converter()->transform(src, dst, nPixels);
 }
 
 void KoColorSpace::toRgbA16(const quint8 * src, quint8 * dst, quint32 nPixels) const
 {
     toRgbA16Converter()->transform(src, dst, nPixels);
 }
 
 void KoColorSpace::fromRgbA16(const quint8 * src, quint8 * dst, quint32 nPixels) const
 {
     fromRgbA16Converter()->transform(src, dst, nPixels);
 }
 
 KoColorConversionTransformation* KoColorSpace::createColorConverter(const KoColorSpace * dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags) const
 {
     if (*this == *dstColorSpace) {
         return new KoCopyColorConversionTransformation(this);
     } else {
         return KoColorSpaceRegistry::instance()->createColorConverter(this, dstColorSpace, renderingIntent, conversionFlags);
     }
 }
 
 bool KoColorSpace::convertPixelsTo(const quint8 * src,
                                    quint8 * dst,
                                    const KoColorSpace * dstColorSpace,
                                    quint32 numPixels,
                                    KoColorConversionTransformation::Intent renderingIntent,
                                    KoColorConversionTransformation::ConversionFlags conversionFlags) const
 {
     if (*this == *dstColorSpace) {
         if (src != dst) {
             memcpy(dst, src, numPixels * sizeof(quint8) * pixelSize());
         }
     } else {
         KoCachedColorConversionTransformation cct = KoColorSpaceRegistry::instance()->colorConversionCache()->cachedConverter(this, dstColorSpace, renderingIntent, conversionFlags);
         cct.transformation()->transform(src, dst, numPixels);
     }
     return true;
 }
 
 KoColorConversionTransformation * KoColorSpace::createProofingTransform(const KoColorSpace *dstColorSpace, const KoColorSpace *proofingSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::Intent proofingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags, quint8 *gamutWarning, double adaptationState) const
 {
     if (!d->iccEngine) {
         d->iccEngine = KoColorSpaceEngineRegistry::instance()->get("icc");
     }
     if (!d->iccEngine) return 0;
 
     return d->iccEngine->createColorProofingTransformation(this, dstColorSpace, proofingSpace, renderingIntent, proofingIntent, conversionFlags, gamutWarning, adaptationState);
 }
 
 bool KoColorSpace::proofPixelsTo(const quint8 *src,
                                  quint8 *dst,
                                  quint32 numPixels,
                                  KoColorConversionTransformation *proofingTransform) const
 {
     proofingTransform->transform(src, dst, numPixels);
 
     //the transform is deleted in the destructor.
     return true;
 }
 
 void KoColorSpace::bitBlt(const KoColorSpace* srcSpace, const KoCompositeOp::ParameterInfo& params, const KoCompositeOp* op,
                           KoColorConversionTransformation::Intent renderingIntent,
                           KoColorConversionTransformation::ConversionFlags conversionFlags) const
 {
     Q_ASSERT_X(*op->colorSpace() == *this, "KoColorSpace::bitBlt", QString("Composite op is for color space %1 (%2) while this is %3 (%4)").arg(op->colorSpace()->id()).arg(op->colorSpace()->profile()->name()).arg(id()).arg(profile()->name()).toLatin1());
 
     if(params.rows <= 0 || params.cols <= 0)
         return;
 
     if(!(*this == *srcSpace)) {
-         if (preferCompositionInSourceColorSpace() &&
-             srcSpace->hasCompositeOp(op->id())) {
+        if (preferCompositionInSourceColorSpace() &&
+                srcSpace->hasCompositeOp(op->id())) {
 
-             quint32           conversionDstBufferStride = params.cols * srcSpace->pixelSize();
-             QVector<quint8> * conversionDstCache        = threadLocalConversionCache(params.rows * conversionDstBufferStride);
-             quint8*           conversionDstData         = conversionDstCache->data();
+            quint32           conversionDstBufferStride = params.cols * srcSpace->pixelSize();
+            QVector<quint8> * conversionDstCache        = threadLocalConversionCache(params.rows * conversionDstBufferStride);
+            quint8*           conversionDstData         = conversionDstCache->data();
 
-             for(qint32 row=0; row<params.rows; row++) {
-                 convertPixelsTo(params.dstRowStart + row * params.dstRowStride,
-                                 conversionDstData  + row * conversionDstBufferStride, srcSpace, params.cols,
-                                 renderingIntent, conversionFlags);
-             }
+            for(qint32 row=0; row<params.rows; row++) {
+                convertPixelsTo(params.dstRowStart + row * params.dstRowStride,
+                                conversionDstData  + row * conversionDstBufferStride, srcSpace, params.cols,
+                                renderingIntent, conversionFlags);
+            }
 
-             // FIXME: do not calculate the otherOp every time
-             const KoCompositeOp *otherOp = srcSpace->compositeOp(op->id());
+            // FIXME: do not calculate the otherOp every time
+            const KoCompositeOp *otherOp = srcSpace->compositeOp(op->id());
 
-             KoCompositeOp::ParameterInfo paramInfo(params);
-             paramInfo.dstRowStart  = conversionDstData;
-             paramInfo.dstRowStride = conversionDstBufferStride;
-             otherOp->composite(paramInfo);
+            KoCompositeOp::ParameterInfo paramInfo(params);
+            paramInfo.dstRowStart  = conversionDstData;
+            paramInfo.dstRowStride = conversionDstBufferStride;
+            otherOp->composite(paramInfo);
 
-             for(qint32 row=0; row<params.rows; row++) {
-                 srcSpace->convertPixelsTo(conversionDstData  + row * conversionDstBufferStride,
-                                           params.dstRowStart + row * params.dstRowStride, this, params.cols,
-                                           renderingIntent, conversionFlags);
-             }
+            for(qint32 row=0; row<params.rows; row++) {
+                srcSpace->convertPixelsTo(conversionDstData  + row * conversionDstBufferStride,
+                                          params.dstRowStart + row * params.dstRowStride, this, params.cols,
+                                          renderingIntent, conversionFlags);
+            }
 
         } else {
             quint32           conversionBufferStride = params.cols * pixelSize();
             QVector<quint8> * conversionCache        = threadLocalConversionCache(params.rows * conversionBufferStride);
             quint8*           conversionData         = conversionCache->data();
 
             for(qint32 row=0; row<params.rows; row++) {
                 srcSpace->convertPixelsTo(params.srcRowStart + row * params.srcRowStride,
                                           conversionData     + row * conversionBufferStride, this, params.cols,
                                           renderingIntent, conversionFlags);
             }
 
             KoCompositeOp::ParameterInfo paramInfo(params);
             paramInfo.srcRowStart  = conversionData;
             paramInfo.srcRowStride = conversionBufferStride;
             op->composite(paramInfo);
         }
     }
     else {
         op->composite(params);
     }
 }
 
 
 QVector<quint8> * KoColorSpace::threadLocalConversionCache(quint32 size) const
 {
     QVector<quint8> * ba = 0;
     if (!d->conversionCache.hasLocalData()) {
         ba = new QVector<quint8>(size, '0');
         d->conversionCache.setLocalData(ba);
     } else {
         ba = d->conversionCache.localData();
         if ((quint8)ba->size() < size)
             ba->resize(size);
     }
     return ba;
 }
 
 KoColorTransformation* KoColorSpace::createColorTransformation(const QString & id, const QHash<QString, QVariant> & parameters) const
 {
     KoColorTransformationFactory* factory = KoColorTransformationFactoryRegistry::instance()->get(id);
     if (!factory) return 0;
     QPair<KoID, KoID> model(colorModelId(), colorDepthId());
     QList< QPair<KoID, KoID> > models = factory->supportedModels();
     if (models.isEmpty() || models.contains(model)) {
         return factory->createTransformation(this, parameters);
     } else {
         // Find the best solution
         // TODO use the color conversion cache
         KoColorConversionTransformation* csToFallBack = 0;
         KoColorConversionTransformation* fallBackToCs = 0;
         KoColorSpaceRegistry::instance()->createColorConverters(this, models, csToFallBack, fallBackToCs);
         Q_ASSERT(csToFallBack);
         Q_ASSERT(fallBackToCs);
         KoColorTransformation* transfo = factory->createTransformation(fallBackToCs->srcColorSpace(), parameters);
         return new KoFallBackColorTransformation(csToFallBack, fallBackToCs, transfo);
     }
 }
 
 void KoColorSpace::increaseLuminosity(quint8 * pixel, qreal step) const{
     int channelnumber = channelCount();
     QVector <double> channelValues(channelnumber);
     QVector <float> channelValuesF(channelnumber);
     normalisedChannelsValue(pixel, channelValuesF);
     for (int i=0;i<channelnumber;i++){
         channelValues[i]=channelValuesF[i];
     }
     if (profile()->hasTRC()){
         //only linearise and crunch the luma if there's a TRC
         profile()->linearizeFloatValue(channelValues);
         qreal hue, sat, luma = 0.0;
         toHSY(channelValues, &hue, &sat, &luma);
         luma = pow(luma, 1/2.2);
         luma = qMin(1.0, luma + step);
         luma = pow(luma, 2.2);
         channelValues = fromHSY(&hue, &sat, &luma);
-    profile()->delinearizeFloatValue(channelValues);
+        profile()->delinearizeFloatValue(channelValues);
     } else {
         qreal hue, sat, luma = 0.0;
         toHSY(channelValues, &hue, &sat, &luma);
         luma = qMin(1.0, luma + step);
         channelValues = fromHSY(&hue, &sat, &luma);
     }
     for (int i=0;i<channelnumber;i++){
         channelValuesF[i]=channelValues[i];
     }
     fromNormalisedChannelsValue(pixel, channelValuesF);
     setOpacity(pixel, 1.0, 1);
 }
 void KoColorSpace::decreaseLuminosity(quint8 * pixel, qreal step) const {
     int channelnumber = channelCount();
     QVector <double> channelValues(channelnumber);
     QVector <float> channelValuesF(channelnumber);
     normalisedChannelsValue(pixel, channelValuesF);
     for (int i=0;i<channelnumber;i++){
         channelValues[i]=channelValuesF[i];
     }
     if (profile()->hasTRC()){
         //only linearise and crunch the luma if there's a TRC
         profile()->linearizeFloatValue(channelValues);
         qreal hue, sat, luma = 0.0;
         toHSY(channelValues, &hue, &sat, &luma);
         luma = pow(luma, 1/2.2);
         if (luma-step<0.0) {
             luma=0.0;
         } else {
             luma -= step;
         }
         luma = pow(luma, 2.2);
         channelValues = fromHSY(&hue, &sat, &luma);
         profile()->delinearizeFloatValue(channelValues);
     } else {
         qreal hue, sat, luma = 0.0;
         toHSY(channelValues, &hue, &sat, &luma);
         if (luma-step<0.0) {
             luma=0.0;
         } else {
             luma -= step;
         }
         channelValues = fromHSY(&hue, &sat, &luma);
     }
     for (int i=0;i<channelnumber;i++){
         channelValuesF[i]=channelValues[i];
     }
     fromNormalisedChannelsValue(pixel, channelValuesF);
     setOpacity(pixel, 1.0, 1);
 }
 void KoColorSpace::increaseSaturation(quint8 * pixel, qreal step) const{
     int channelnumber = channelCount();
     QVector <double> channelValues(channelnumber);
     QVector <float> channelValuesF(channelnumber);
     normalisedChannelsValue(pixel, channelValuesF);
     for (int i=0;i<channelnumber;i++){
         channelValues[i]=channelValuesF[i];
     }
     profile()->linearizeFloatValue(channelValues);
     qreal hue, sat, luma = 0.0;
     toHSY(channelValues, &hue, &sat, &luma);
     sat += step;
     sat = qBound(0.0, sat, 1.0);
     channelValues = fromHSY(&hue, &sat, &luma);
     profile()->delinearizeFloatValue(channelValues);
     for (int i=0;i<channelnumber;i++){
         channelValuesF[i]=channelValues[i];
     }
     fromNormalisedChannelsValue(pixel, channelValuesF);
     setOpacity(pixel, 1.0, 1);
 }
 void KoColorSpace::decreaseSaturation(quint8 * pixel, qreal step) const{
     int channelnumber = channelCount();
     QVector <double> channelValues(channelnumber);
     QVector <float> channelValuesF(channelnumber);
     normalisedChannelsValue(pixel, channelValuesF);
     for (int i=0;i<channelnumber;i++){
         channelValues[i]=channelValuesF[i];
     }
     profile()->linearizeFloatValue(channelValues);
     qreal hue, sat, luma = 0.0;
     toHSY(channelValues, &hue, &sat, &luma);
     sat -= step;
     sat = qBound(0.0, sat, 1.0);
     channelValues = fromHSY(&hue, &sat, &luma);
     profile()->delinearizeFloatValue(channelValues);
     for (int i=0;i<channelnumber;i++){
         channelValuesF[i]=channelValues[i];
     }
     fromNormalisedChannelsValue(pixel, channelValuesF);
     setOpacity(pixel, 1.0, 1);
 }
 void KoColorSpace::increaseHue(quint8 * pixel, qreal step) const{
     int channelnumber = channelCount(); //doesn't work for cmyka...
     QVector <double> channelValues(channelnumber);
     QVector <float> channelValuesF(channelnumber);
     normalisedChannelsValue(pixel, channelValuesF);
     for (int i=0;i<channelnumber;i++){
         channelValues[i]=channelValuesF[i];
     }
     profile()->linearizeFloatValue(channelValues);
     qreal hue, sat, luma = 0.0;
     toHSY(channelValues, &hue, &sat, &luma);
     if (hue+step>1.0){
         hue=(hue+step)- 1.0;
     } else {
         hue += step;
     }
     channelValues = fromHSY(&hue, &sat, &luma);
     profile()->delinearizeFloatValue(channelValues);
     for (int i=0;i<channelnumber;i++){
         channelValuesF[i]=channelValues[i];
     }
     fromNormalisedChannelsValue(pixel, channelValuesF);
     setOpacity(pixel, 1.0, 1);
 }
 void KoColorSpace::decreaseHue(quint8 * pixel, qreal step) const{
     int channelnumber = channelCount();
     QVector <double> channelValues(channelnumber);
     QVector <float> channelValuesF(channelnumber);
     normalisedChannelsValue(pixel, channelValuesF);
     for (int i=0;i<channelnumber;i++){
         channelValues[i]=channelValuesF[i];
     }
     profile()->linearizeFloatValue(channelValues);
     qreal hue, sat, luma = 0.0;
     toHSY(channelValues, &hue, &sat, &luma);
     if (hue-step<0.0){
         hue=1.0-(step-hue);
     } else {
         hue -= step;
     }
     channelValues = fromHSY(&hue, &sat, &luma);
     profile()->delinearizeFloatValue(channelValues);
     for (int i=0;i<channelnumber;i++){
         channelValuesF[i]=channelValues[i];
     }
     fromNormalisedChannelsValue(pixel, channelValuesF);
     setOpacity(pixel, 1.0, 1);
 }
 
 void KoColorSpace::increaseRed(quint8 * pixel, qreal step) const{
     int channelnumber = channelCount();
     QVector <double> channelValues(channelnumber);
     QVector <float> channelValuesF(channelnumber);
     normalisedChannelsValue(pixel, channelValuesF);
     for (int i=0;i<channelnumber;i++){
         channelValues[i]=channelValuesF[i];
     }
     profile()->linearizeFloatValue(channelValues);
     qreal y, u, v = 0.0;
     toYUV(channelValues, &y, &u, &v);
     u += step;
     u = qBound(0.0, u, 1.0);
     channelValues = fromYUV(&y, &u, &v);
     profile()->delinearizeFloatValue(channelValues);
     for (int i=0;i<channelnumber;i++){
         channelValuesF[i]=channelValues[i];
     }
     fromNormalisedChannelsValue(pixel, channelValuesF);
     setOpacity(pixel, 1.0, 1);
 }
 void KoColorSpace::increaseGreen(quint8 * pixel, qreal step) const{
     int channelnumber = channelCount();
     QVector <double> channelValues(channelnumber);
     QVector <float> channelValuesF(channelnumber);
     normalisedChannelsValue(pixel, channelValuesF);
     for (int i=0;i<channelnumber;i++){
         channelValues[i]=channelValuesF[i];
     }
     profile()->linearizeFloatValue(channelValues);
     qreal y, u, v = 0.0;
     toYUV(channelValues, &y, &u, &v);
     u -= step;
     u = qBound(0.0, u, 1.0);
     channelValues = fromYUV(&y, &u, &v);
     profile()->delinearizeFloatValue(channelValues);
     for (int i=0;i<channelnumber;i++){
         channelValuesF[i]=channelValues[i];
     }
     fromNormalisedChannelsValue(pixel, channelValuesF);
     setOpacity(pixel, 1.0, 1);
 }
 
 void KoColorSpace::increaseBlue(quint8 * pixel, qreal step) const{
     int channelnumber = channelCount();
     QVector <double> channelValues(channelnumber);
     QVector <float> channelValuesF(channelnumber);
     normalisedChannelsValue(pixel, channelValuesF);
     for (int i=0;i<channelnumber;i++){
         channelValues[i]=channelValuesF[i];
     }
     profile()->linearizeFloatValue(channelValues);
     qreal y, u, v = 0.0;
     toYUV(channelValues, &y, &u, &v);
     v += step;
     v = qBound(0.0, v, 1.0);
     channelValues = fromYUV(&y, &u, &v);
     profile()->delinearizeFloatValue(channelValues);
     for (int i=0;i<channelnumber;i++){
         channelValuesF[i]=channelValues[i];
     }
     fromNormalisedChannelsValue(pixel, channelValuesF);
     setOpacity(pixel, 1.0, 1);
 }
 
 void KoColorSpace::increaseYellow(quint8 * pixel, qreal step) const{
     int channelnumber = channelCount();
     QVector <double> channelValues(channelnumber);
     QVector <float> channelValuesF(channelnumber);
     normalisedChannelsValue(pixel, channelValuesF);
     for (int i=0;i<channelnumber;i++){
         channelValues[i]=channelValuesF[i];
     }
     profile()->linearizeFloatValue(channelValues);
     qreal y, u, v = 0.0;
     toYUV(channelValues, &y, &u, &v);
     v -= step;
     v = qBound(0.0, v, 1.0);
     channelValues = fromYUV(&y, &u, &v);
     profile()->delinearizeFloatValue(channelValues);
     for (int i=0;i<channelnumber;i++){
         channelValuesF[i]=channelValues[i];
     }
     fromNormalisedChannelsValue(pixel, channelValuesF);
     setOpacity(pixel, 1.0, 1);
 }
 
 QImage KoColorSpace::convertToQImage(const quint8 *data, qint32 width, qint32 height,
                                      const KoColorProfile *dstProfile,
                                      KoColorConversionTransformation::Intent renderingIntent,
                                      KoColorConversionTransformation::ConversionFlags conversionFlags) const
 
 {
     QImage img = QImage(width, height, QImage::Format_ARGB32);
 
     const KoColorSpace * dstCS = KoColorSpaceRegistry::instance()->rgb8(dstProfile);
 
     if (data)
         this->convertPixelsTo(const_cast<quint8 *>(data), img.bits(), dstCS, width * height, renderingIntent, conversionFlags);
 
     return img;
 }
 
 bool KoColorSpace::preferCompositionInSourceColorSpace() const
 {
     return false;
 }
diff --git a/libs/pigment/KoColorSpace.h b/libs/pigment/KoColorSpace.h
index 5caca665c8..67fa12d938 100644
--- a/libs/pigment/KoColorSpace.h
+++ b/libs/pigment/KoColorSpace.h
@@ -1,645 +1,644 @@
 /*
  *  Copyright (c) 2005 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2006-2007 Cyrille Berger <cberger@cberger.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 #ifndef KOCOLORSPACE_H
 #define KOCOLORSPACE_H
 
 #include <limits.h>
 
 #include <QImage>
 #include <QHash>
 #include <QVector>
 #include <QList>
 
 #include <boost/operators.hpp>
 #include "KoColorSpaceConstants.h"
 #include "KoColorConversionTransformation.h"
 #include "KoColorProofingConversionTransformation.h"
 #include "KoCompositeOp.h"
 #include <KoID.h>
 #include "kritapigment_export.h"
 
 class QDomDocument;
 class QDomElement;
 class KoChannelInfo;
 class KoColorProfile;
 class KoColorTransformation;
 class QBitArray;
 
 enum Deletability {
     OwnedByRegistryDoNotDelete,
     OwnedByRegistryRegistryDeletes,
     NotOwnedByRegistry
 };
 
 enum ColorSpaceIndependence {
     FULLY_INDEPENDENT,
     TO_LAB16,
     TO_RGBA8,
     TO_RGBA16
 };
 
 class KoMixColorsOp;
 class KoConvolutionOp;
 
 /**
  * A KoColorSpace is the definition of a certain color space.
  *
  * A color model and a color space are two related concepts. A color
  * model is more general in that it describes the channels involved and
  * how they in broad terms combine to describe a color. Examples are
  * RGB, HSV, CMYK.
  *
  * A color space is more specific in that it also describes exactly how
  * the channels are combined. So for each color model there can be a
  * number of specific color spaces. So RGB is the model and sRGB,
  * adobeRGB, etc are colorspaces.
  *
  * In Pigment KoColorSpace acts as both a color model and a color space.
  * You can think of the class definition as the color model, but the
  * instance of the class as representing a colorspace.
  *
  * A third concept is the profile represented by KoColorProfile. It
  * represents the info needed to specialize a color model into a color
  * space.
  *
  * KoColorSpace is an abstract class serving as an interface.
  *
  * Subclasses implement actual color spaces
  * Some subclasses implement only some parts and are named Traits
  *
  */
 class KRITAPIGMENT_EXPORT KoColorSpace : public boost::equality_comparable<KoColorSpace>
 {
     friend class KoColorSpaceRegistry;
     friend class KoColorSpaceFactory;
 protected:
     /// Only for use by classes that serve as baseclass for real color spaces
     KoColorSpace();
 
 public:
 
     /// Should be called by real color spaces
     KoColorSpace(const QString &id, const QString &name, KoMixColorsOp* mixColorsOp, KoConvolutionOp* convolutionOp);
 
     virtual bool operator==(const KoColorSpace& rhs) const;
 protected:
     virtual ~KoColorSpace();
 
 public:
     //========== Gamut and other basic info ===================================//
     /*
      * @returns QPolygonF with 5*channel samples converted to xyY.
      * maybe convert to 3d space in future?
      */
     QPolygonF gamutXYY() const;
 
     /*
      * @returns a polygon with 5 samples per channel converted to xyY, but unlike
      * gamutxyY it focuses on the luminance. This then can be used to visualise
      * the approximate trc of a given colorspace.
      */
     QPolygonF estimatedTRCXYY() const;
 
-    QVector <qreal> colorants() const;
     QVector <qreal> lumaCoefficients() const;
 
     //========== Channels =====================================================//
 
     /// Return a list describing all the channels this color model has. The order
     /// of the channels in the list is the order of channels in the pixel. To find
     /// out the preferred display position, use KoChannelInfo::displayPosition.
     QList<KoChannelInfo *> channels() const;
 
     /**
      * The total number of channels for a single pixel in this color model
      */
     virtual quint32 channelCount() const = 0;
 
     /**
      * The total number of color channels (excludes alpha) for a single
      * pixel in this color model.
      */
     virtual quint32 colorChannelCount() const = 0;
 
     /**
      * returns a QBitArray that contains true for the specified
      * channel types:
      *
      * @param color if true, set all color channels to true
      * @param alpha if true, set all alpha channels to true
      *
      * The order of channels is the colorspace descriptive order,
      * not the pixel order.
      */
     QBitArray channelFlags(bool color = true, bool alpha = false) const;
 
     /**
      * The size in bytes of a single pixel in this color model
      */
     virtual quint32 pixelSize() const = 0;
 
     /**
      * Return a string with the channel's value suitable for display in the gui.
      */
     virtual QString channelValueText(const quint8 *pixel, quint32 channelIndex) const = 0;
 
     /**
      * Return a string with the channel's value with integer
      * channels normalised to the floating point range 0 to 1, if
      * appropriate.
      */
     virtual QString normalisedChannelValueText(const quint8 *pixel, quint32 channelIndex) const = 0;
 
     /**
      * Return a QVector of floats with channels' values normalized
      * to floating point range 0 to 1.
      */
     virtual void normalisedChannelsValue(const quint8 *pixel, QVector<float> &channels) const = 0;
 
     /**
      * Write in the pixel the value from the normalized vector.
      */
     virtual void fromNormalisedChannelsValue(quint8 *pixel, const QVector<float> &values) const = 0;
 
     /**
      * Convert the value of the channel at the specified position into
      * an 8-bit value. The position is not the number of bytes, but
      * the position of the channel as defined in the channel info list.
      */
     virtual quint8 scaleToU8(const quint8 * srcPixel, qint32 channelPos) const = 0;
 
     /**
      * Set dstPixel to the pixel containing only the given channel of srcPixel. The remaining channels
      * should be set to whatever makes sense for 'empty' channels of this color space,
      * with the intent being that the pixel should look like it only has the given channel.
      */
     virtual void singleChannelPixel(quint8 *dstPixel, const quint8 *srcPixel, quint32 channelIndex) const = 0;
 
     //========== Identification ===============================================//
 
     /**
      * ID for use in files and internally: unchanging name. As the id must be unique
      * it is usually the concatenation of the id of the color model and of the color
      * depth, for instance "RGBA8" or "CMYKA16" or "XYZA32f".
      */
     QString id() const;
 
     /**
      * User visible name which contains the name of the color model and of the color depth.
      * For instance "RGBA (8-bits)" or "CMYKA (16-bits)".
      */
     QString name() const;
 
     /**
      * @return a string that identify the color model (for instance "RGB" or "CMYK" ...)
      * @see KoColorModelStandardIds.h
      */
     virtual KoID colorModelId() const = 0;
     /**
      * @return a string that identify the bit depth (for instance "U8" or "F16" ...)
      * @see KoColorModelStandardIds.h
      */
     virtual KoID colorDepthId() const = 0;
 
     /**
      * @return true if the profile given in argument can be used by this color space
      */
     virtual bool profileIsCompatible(const KoColorProfile* profile) const = 0;
 
     /**
      * If false, images in this colorspace will degrade considerably by
      * functions, tools and filters that have the given measure of colorspace
      * independence.
      *
      * @param independence the measure to which this colorspace will suffer
      *                     from the manipulations of the tool or filter asking
      * @return false if no degradation will take place, true if degradation will
      *         take place
      */
     virtual bool willDegrade(ColorSpaceIndependence independence) const = 0;
 
     //========== Capabilities =================================================//
 
     /**
      * Tests if the colorspace offers the specific composite op.
      */
     virtual bool hasCompositeOp(const QString & id) const;
 
     /**
      * Returns the list of user-visible composite ops supported by this colorspace.
      */
     virtual QList<KoCompositeOp*> compositeOps() const;
 
     /**
      * Retrieve a single composite op from the ones this colorspace offers.
      * If the requeste composite op does not exist, COMPOSITE_OVER is returned.
      */
     const KoCompositeOp * compositeOp(const QString & id) const;
 
     /**
      * add a composite op to this colorspace.
      */
     virtual void addCompositeOp(const KoCompositeOp * op);
 
     /**
      * Returns true if the colorspace supports channel values outside the
      * (normalised) range 0 to 1.
      */
     virtual bool hasHighDynamicRange() const = 0;
 
 
 //========== Display profiles =============================================//
 
     /**
      * Return the profile of this color space.
      */
     virtual const KoColorProfile * profile() const = 0;
 
 
 //================= Conversion functions ==================================//
 
 
     /**
      * The fromQColor methods take a given color defined as an RGB QColor
      * and fills a byte array with the corresponding color in the
      * the colorspace managed by this strategy.
      *
      * @param color the QColor that will be used to fill dst
      * @param dst a pointer to a pixel
      * @param profile the optional profile that describes the color values of QColor
      */
     virtual void fromQColor(const QColor& color, quint8 *dst, const KoColorProfile * profile = 0) const = 0;
 
     /**
      * The toQColor methods take a byte array that is at least pixelSize() long
      * and converts the contents to a QColor, using the given profile as a source
      * profile and the optional profile as a destination profile.
      *
      * @param src a pointer to the source pixel
      * @param c the QColor that will be filled with the color at src
      * @param profile the optional profile that describes the color in c, for instance the monitor profile
      */
     virtual void toQColor(const quint8 *src, QColor *c, const KoColorProfile * profile = 0) const = 0;
 
     /**
      * Convert the pixels in data to (8-bit BGRA) QImage using the specified profiles.
      *
      * @param data A pointer to a contiguous memory region containing width * height pixels
      * @param width in pixels
      * @param height in pixels
      * @param dstProfile destination profile
      * @param renderingIntent the rendering intent
      */
     virtual QImage convertToQImage(const quint8 *data, qint32 width, qint32 height,
                                    const KoColorProfile *  dstProfile,
                                    KoColorConversionTransformation::Intent renderingIntent,
                                    KoColorConversionTransformation::ConversionFlags conversionFlags) const;
 
     /**
      * Convert the specified data to Lab (D50). All colorspaces are guaranteed to support this
      *
      * @param src the source data
      * @param dst the destination data
      * @param nPixels the number of source pixels
      */
     virtual void toLabA16(const quint8 * src, quint8 * dst, quint32 nPixels) const;
 
     /**
      * Convert the specified data from Lab (D50). to this colorspace. All colorspaces are
      * guaranteed to support this.
      *
      * @param src the pixels in 16 bit lab format
      * @param dst the destination data
      * @param nPixels the number of pixels in the array
      */
     virtual void fromLabA16(const quint8 * src, quint8 * dst, quint32 nPixels) const;
 
     /**
      * Convert the specified data to sRGB 16 bits. All colorspaces are guaranteed to support this
      *
      * @param src the source data
      * @param dst the destination data
      * @param nPixels the number of source pixels
      */
     virtual void toRgbA16(const quint8 * src, quint8 * dst, quint32 nPixels) const;
 
     /**
      * Convert the specified data from sRGB 16 bits. to this colorspace. All colorspaces are
      * guaranteed to support this.
      *
      * @param src the pixels in 16 bit rgb format
      * @param dst the destination data
      * @param nPixels the number of pixels in the array
      */
     virtual void fromRgbA16(const quint8 * src, quint8 * dst, quint32 nPixels) const;
 
     /**
      * Create a color conversion transformation.
      */
     virtual KoColorConversionTransformation* createColorConverter(const KoColorSpace * dstColorSpace,
                                                                   KoColorConversionTransformation::Intent renderingIntent,
                                                                   KoColorConversionTransformation::ConversionFlags conversionFlags) const;
 
     /**
      * Convert a byte array of srcLen pixels *src to the specified color space
      * and put the converted bytes into the prepared byte array *dst.
      *
      * Returns false if the conversion failed, true if it succeeded
      *
      * This function is not thread-safe. If you want to apply multiple conversion
      * in different threads at the same time, you need to create one color converter
      * per-thread using createColorConverter.
      */
     virtual bool convertPixelsTo(const quint8 * src,
                                  quint8 * dst, const KoColorSpace * dstColorSpace,
                                  quint32 numPixels,
                                  KoColorConversionTransformation::Intent renderingIntent,
                                  KoColorConversionTransformation::ConversionFlags conversionFlags) const;
 
     virtual KoColorConversionTransformation *createProofingTransform(const KoColorSpace * dstColorSpace,
                                                              const KoColorSpace * proofingSpace,
                                                              KoColorConversionTransformation::Intent renderingIntent,
                                                              KoColorConversionTransformation::Intent proofingIntent,
                                                              KoColorConversionTransformation::ConversionFlags conversionFlags,
                                                              quint8 *gamutWarning, double adaptationState) const;
     /**
      * @brief proofPixelsTo
      * @param src
      * @param dst
      * @param dstColorSpace the colorspace to which we go to.
      * @param proofingSpace the proofing space.
      * @param numPixels the amount of pixels.
      * @param renderingIntent the rendering intent used for rendering.
      * @param proofingIntent the intent used for proofing.
      * @param conversionFlags the conversion flags.
      * @param gamutWarning the data() of a KoColor.
      * @param adaptationState the state of adaptation, only affects absolute colorimetric.
      * @return
      */
     virtual bool proofPixelsTo(const quint8 * src,
                                quint8 * dst,
                                quint32 numPixels,
                                KoColorConversionTransformation *proofingTransform) const;
 
 //============================== Manipulation functions ==========================//
 
 
 //
 // The manipulation functions have default implementations that _convert_ the pixel
 // to a QColor and back. Reimplement these methods in your color strategy!
 //
 
     /**
      * Get the alpha value of the given pixel, downscaled to an 8-bit value.
      */
     virtual quint8 opacityU8(const quint8 * pixel) const = 0;
     virtual qreal opacityF(const quint8 * pixel) const = 0;
 
     /**
      * Set the alpha channel of the given run of pixels to the given value.
      *
      * pixels -- a pointer to the pixels that will have their alpha set to this value
      * alpha --  a downscaled 8-bit value for opacity
      * nPixels -- the number of pixels
      *
      */
     virtual void setOpacity(quint8 * pixels, quint8 alpha, qint32 nPixels) const = 0;
     virtual void setOpacity(quint8 * pixels, qreal alpha, qint32 nPixels) const = 0;
 
     /**
      * Multiply the alpha channel of the given run of pixels by the given value.
      *
      * pixels -- a pointer to the pixels that will have their alpha set to this value
      * alpha --  a downscaled 8-bit value for opacity
      * nPixels -- the number of pixels
      *
      */
     virtual void multiplyAlpha(quint8 * pixels, quint8 alpha, qint32 nPixels) const = 0;
 
     /**
      * Applies the specified 8-bit alpha mask to the pixels. We assume that there are just
      * as many alpha values as pixels but we do not check this; the alpha values
      * are assumed to be 8-bits.
      */
     virtual void applyAlphaU8Mask(quint8 * pixels, const quint8 * alpha, qint32 nPixels) const = 0;
 
     /**
      * Applies the inverted 8-bit alpha mask to the pixels. We assume that there are just
      * as many alpha values as pixels but we do not check this; the alpha values
      * are assumed to be 8-bits.
      */
     virtual void applyInverseAlphaU8Mask(quint8 * pixels, const quint8 * alpha, qint32 nPixels) const = 0;
 
     /**
      * Applies the specified float alpha mask to the pixels. We assume that there are just
      * as many alpha values as pixels but we do not check this; alpha values have to be between 0.0 and 1.0
      */
     virtual void applyAlphaNormedFloatMask(quint8 * pixels, const float * alpha, qint32 nPixels) const = 0;
 
     /**
      * Applies the inverted specified float alpha mask to the pixels. We assume that there are just
      * as many alpha values as pixels but we do not check this; alpha values have to be between 0.0 and 1.0
      */
     virtual void applyInverseNormedFloatMask(quint8 * pixels, const float * alpha, qint32 nPixels) const = 0;
 
     /**
      * Create an adjustment object for adjusting the brightness and contrast
      * transferValues is a 256 bins array with values from 0 to 0xFFFF
      * This function is thread-safe, but you need to create one KoColorTransformation per thread.
      */
     virtual KoColorTransformation *createBrightnessContrastAdjustment(const quint16 *transferValues) const = 0;
 
     /**
      * Create an adjustment object for adjusting individual channels
      * transferValues is an array of colorChannelCount number of 256 bins array with values from 0 to 0xFFFF
      * This function is thread-safe, but you need to create one KoColorTransformation per thread.
      *
      * The layout of the channels must be the following:
      *
      * 0..N-2 - color channels of the pixel;
      * N-1 - alpha channel of the pixel (if exists)
      */
     virtual KoColorTransformation *createPerChannelAdjustment(const quint16 * const* transferValues) const = 0;
 
     /**
      * Darken all color channels with the given amount. If compensate is true,
      * the compensation factor will be used to limit the darkening.
      *
      */
     virtual KoColorTransformation *createDarkenAdjustment(qint32 shade, bool compensate, qreal compensation) const = 0;
 
     /**
      * Invert color channels of the given pixels
      * This function is thread-safe, but you need to create one KoColorTransformation per thread.
      */
     virtual KoColorTransformation *createInvertTransformation() const = 0;
 
     /**
      * Get the difference between 2 colors, normalized in the range (0,255). Only completely
      * opaque and completely transparent are taken into account when computing the difference;
      * other transparency levels are not regarded when finding the difference.
      */
     virtual quint8 difference(const quint8* src1, const quint8* src2) const = 0;
 
     /**
      * Get the difference between 2 colors, normalized in the range (0,255). This function
      * takes the Alpha channel of the pixel into account. Alpha channel has the same
      * weight as Lightness channel.
      */
     virtual quint8 differenceA(const quint8* src1, const quint8* src2) const = 0;
 
     /**
      * @return the mix color operation of this colorspace (do not delete it locally, it's deleted by the colorspace).
      */
     virtual KoMixColorsOp* mixColorsOp() const;
 
     /**
      * @return the convolution operation of this colorspace (do not delete it locally, it's deleted by the colorspace).
      */
     virtual KoConvolutionOp* convolutionOp() const;
 
     /**
      * Calculate the intensity of the given pixel, scaled down to the range 0-255. XXX: Maybe this should be more flexible
      */
     virtual quint8 intensity8(const quint8 * src) const = 0;
 
     /*
      *increase luminosity by step
      */
     virtual void increaseLuminosity(quint8 * pixel, qreal step) const;
     virtual void decreaseLuminosity(quint8 * pixel, qreal step) const;
     virtual void increaseSaturation(quint8 * pixel, qreal step) const;
     virtual void decreaseSaturation(quint8 * pixel, qreal step) const;
     virtual void increaseHue(quint8 * pixel, qreal step) const;
     virtual void decreaseHue(quint8 * pixel, qreal step) const;
     virtual void increaseRed(quint8 * pixel, qreal step) const;
     virtual void increaseGreen(quint8 * pixel, qreal step) const;
     virtual void increaseBlue(quint8 * pixel, qreal step) const;
     virtual void increaseYellow(quint8 * pixel, qreal step) const;
     virtual void toHSY(const QVector<double> &channelValues, qreal *hue, qreal *sat, qreal *luma) const = 0;
     virtual QVector <double> fromHSY(qreal *hue, qreal *sat, qreal *luma) const = 0;
     virtual void toYUV(const QVector<double> &channelValues, qreal *y, qreal *u, qreal *v) const = 0;
     virtual QVector <double> fromYUV(qreal *y, qreal *u, qreal *v) const = 0;
     /**
      * Compose two arrays of pixels together. If source and target
      * are not the same color model, the source pixels will be
      * converted to the target model. We're "dst" -- "dst" pixels are always in _this_
      * colorspace.
      *
      * @param srcSpace the colorspace of the source pixels that will be composited onto "us"
      * @param param the information needed for blitting e.g. the source and destination pixel data,
      *        the opacity and flow, ...
      * @param op the composition operator to use, e.g. COPY_OVER
      *
      */
     virtual void bitBlt(const KoColorSpace* srcSpace, const KoCompositeOp::ParameterInfo& params, const KoCompositeOp* op,
                         KoColorConversionTransformation::Intent renderingIntent,
                         KoColorConversionTransformation::ConversionFlags conversionFlags) const;
 
     /**
      * Serialize this color following Create's swatch color specification available
      * at http://create.freedesktop.org/wiki/index.php/Swatches_-_colour_file_format
      *
      * This function doesn't create the <color /> element but rather the <CMYK />,
      * <sRGB />, <RGB /> ... elements. It is assumed that colorElt is the <color />
      * element.
      *
      * @param pixel buffer to serialized
      * @param colorElt root element for the serialization, it is assumed that this
      *                 element is <color />
      * @param doc is the document containing colorElt
      */
     virtual void colorToXML(const quint8* pixel, QDomDocument& doc, QDomElement& colorElt) const = 0;
 
     /**
      * Unserialize a color following Create's swatch color specification available
      * at http://create.freedesktop.org/wiki/index.php/Swatches_-_colour_file_format
      *
      * @param pixel buffer where the color will be unserialized
      * @param elt the element to unserialize (<CMYK />, <sRGB />, <RGB />)
      * @return the unserialize color, or an empty color object if the function failed
      *         to unserialize the color
      */
     virtual void colorFromXML(quint8* pixel, const QDomElement& elt) const = 0;
 
     KoColorTransformation* createColorTransformation(const QString & id, const QHash<QString, QVariant> & parameters) const;
 
 protected:
 
     /**
      * Use this function in the constructor of your colorspace to add the information about a channel.
      * @param ci a pointer to the information about a channel
      */
     virtual void addChannel(KoChannelInfo * ci);
     const KoColorConversionTransformation* toLabA16Converter() const;
     const KoColorConversionTransformation* fromLabA16Converter() const;
     const KoColorConversionTransformation* toRgbA16Converter() const;
     const KoColorConversionTransformation* fromRgbA16Converter() const;
 
     /**
      * Returns the thread-local conversion cache. If it doesn't exist
      * yet, it is created. If it is currently too small, it is resized.
      */
     QVector<quint8> * threadLocalConversionCache(quint32 size) const;
 
     /**
      * This function defines the behavior of the bitBlt function
      * when the composition of pixels in different colorspaces is
      * requested, that is in case:
      *
      * srcCS == any
      * dstCS == this
      *
      * 1) preferCompositionInSourceColorSpace() == false,
      *
      *    the source pixels are first converted to *this color space
      *    and then composition is performed.
      *
      * 2)  preferCompositionInSourceColorSpace() == true,
      *
      *    the destination pixels are first converted into *srcCS color
      *    space, then the composition is done, and the result is finally
      *    converted into *this colorspace.
      *
      *    This is used by alpha8() color space mostly, because it has
      *    weaker representation of the color, so the composition
      *    should be done in CS with richer functionality.
      */
     virtual bool preferCompositionInSourceColorSpace() const;
 
 
     struct Private;
     Private * const d;
 
 };
 
 inline QDebug operator<<(QDebug dbg, const KoColorSpace *cs)
 {
     if (cs) {
         dbg.nospace() << cs->name() << " (" << cs->colorModelId().id() << "," << cs->colorDepthId().id() << " )";
     } else {
         dbg.nospace() << "0x0";
     }
 
     return dbg.space();
 }
 
 
 #endif // KOCOLORSPACE_H
diff --git a/libs/pigment/tests/TestColorConversionSystem.cpp b/libs/pigment/tests/TestColorConversionSystem.cpp
index 0bf1a75fae..d52d8f3e0c 100644
--- a/libs/pigment/tests/TestColorConversionSystem.cpp
+++ b/libs/pigment/tests/TestColorConversionSystem.cpp
@@ -1,237 +1,239 @@
 /*
  *  Copyright (c) 2007 Cyrille Berger <cberger@cberger.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #include "TestColorConversionSystem.h"
 
 #include <QTest>
 
 #include <DebugPigment.h>
 #include <KoColorProfile.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorConversionSystem.h>
 #include <KoColorModelStandardIds.h>
+#include <sdk/tests/kistest.h>
 
 TestColorConversionSystem::TestColorConversionSystem()
 {
     Q_FOREACH (const KoID& modelId, KoColorSpaceRegistry::instance()->colorModelsList(KoColorSpaceRegistry::AllColorSpaces)) {
         Q_FOREACH (const KoID& depthId, KoColorSpaceRegistry::instance()->colorDepthList(modelId, KoColorSpaceRegistry::AllColorSpaces)) {
             QList< const KoColorProfile * > profiles =
                 KoColorSpaceRegistry::instance()->profilesFor(
                     KoColorSpaceRegistry::instance()->colorSpaceId(modelId, depthId));
             Q_FOREACH (const KoColorProfile * profile, profiles) {
                 listModels.append(ModelDepthProfile(modelId.id(), depthId.id(), profile->name()));
             }
         }
     }
     //listModels.append(ModelDepthProfile(AlphaColorModelID.id(), Integer8BitsColorDepthID.id(), ""));
 }
 
 void TestColorConversionSystem::testConnections()
 {
     Q_FOREACH (const ModelDepthProfile& srcCS, listModels) {
         Q_FOREACH (const ModelDepthProfile& dstCS, listModels) {
             QVERIFY2(KoColorSpaceRegistry::instance()->colorConversionSystem()->existsPath(srcCS.model, srcCS.depth, srcCS.profile, dstCS.model, dstCS.depth, dstCS.profile) , QString("No path between %1 / %2 and %3 / %4").arg(srcCS.model).arg(srcCS.depth).arg(dstCS.model).arg(dstCS.depth).toLatin1());
         }
     }
 }
 
 void TestColorConversionSystem::testGoodConnections()
 {
     int countFail = 0;
     Q_FOREACH (const ModelDepthProfile& srcCS, listModels) {
         Q_FOREACH (const ModelDepthProfile& dstCS, listModels) {
             if (!KoColorSpaceRegistry::instance()->colorConversionSystem()->existsGoodPath(srcCS.model, srcCS.depth, srcCS.profile , dstCS.model, dstCS.depth, dstCS.profile)) {
                 ++countFail;
                 dbgPigment << "No good path between \"" << srcCS.model << " " << srcCS.depth << " " << srcCS.profile << "\" \"" << dstCS.model << " " << dstCS.depth << " " << dstCS.profile << "\"";
             }
         }
     }
     int failed = 0;
     if (!KoColorSpaceRegistry::instance()->colorSpace( RGBAColorModelID.id(), Float32BitsColorDepthID.id(), 0) && KoColorSpaceRegistry::instance()->colorSpace( "KS6", Float32BitsColorDepthID.id(), 0) ) {
         failed = 42;
     }
     QVERIFY2(countFail == failed, QString("%1 tests have fails (it should have been %2)").arg(countFail).arg(failed).toLatin1());
 }
 
 #include <KoColor.h>
 
 void TestColorConversionSystem::testAlphaConversions()
 {
     const KoColorSpace *alpha8 = KoColorSpaceRegistry::instance()->alpha8();
     const KoColorSpace *rgb8 = KoColorSpaceRegistry::instance()->rgb8();
     const KoColorSpace *rgb16 = KoColorSpaceRegistry::instance()->rgb16();
 
     {
         KoColor c(QColor(255,255,255,255), alpha8);
         QCOMPARE(c.opacityU8(), quint8(255));
         c.convertTo(rgb8);
         QCOMPARE(c.toQColor(), QColor(255,255,255));
         c.convertTo(alpha8);
         QCOMPARE(c.opacityU8(), quint8(255));
     }
 
     {
         KoColor c(QColor(255,255,255,0), alpha8);
         c.convertTo(rgb8);
         QCOMPARE(c.toQColor(), QColor(0,0,0,255));
         c.convertTo(alpha8);
         QCOMPARE(c.opacityU8(), quint8(0));
     }
 
     {
         KoColor c(QColor(255,255,255,128), alpha8);
         c.convertTo(rgb8);
-        QCOMPARE(c.toQColor(), QColor(129,129,129,255));
+        QCOMPARE(c.toQColor(), QColor(128,128,128,255));
         c.convertTo(alpha8);
-        QCOMPARE(c.opacityU8(), quint8(138));
+        QCOMPARE(c.opacityU8(), quint8(137)); // alpha is linear, so the value increases
     }
 
     {
         KoColor c(QColor(255,255,255,255), alpha8);
         QCOMPARE(c.opacityU8(), quint8(255));
         c.convertTo(rgb16);
         QCOMPARE(c.toQColor(), QColor(255,255,255));
         c.convertTo(alpha8);
         QCOMPARE(c.opacityU8(), quint8(255));
     }
 
     {
         KoColor c(QColor(255,255,255,0), alpha8);
         c.convertTo(rgb16);
         QCOMPARE(c.toQColor(), QColor(0,0,0,255));
         c.convertTo(alpha8);
         QCOMPARE(c.opacityU8(), quint8(0));
     }
 
     {
         KoColor c(QColor(255,255,255,128), alpha8);
         c.convertTo(rgb16);
-        QCOMPARE(c.toQColor(), QColor(129,129,129,255));
+        QCOMPARE(c.toQColor(), QColor(128,128,128,255));
         c.convertTo(alpha8);
-        QCOMPARE(c.opacityU8(), quint8(138));
+        QCOMPARE(c.opacityU8(), quint8(137));  // alpha is linear, so the value increases
     }
 }
 
 void TestColorConversionSystem::testAlphaU16Conversions()
 {
     KoColorSpaceRegistry::instance();
     const KoColorSpace *alpha16 = KoColorSpaceRegistry::instance()->alpha16();
     const KoColorSpace *rgb8 = KoColorSpaceRegistry::instance()->rgb8();
     const KoColorSpace *rgb16 = KoColorSpaceRegistry::instance()->rgb16();
 
     {
         KoColor c(QColor(255,255,255,255), alpha16);
         QCOMPARE(c.opacityU8(), quint8(255));
         c.convertTo(rgb8);
         QCOMPARE(c.toQColor(), QColor(255,255,255));
         c.convertTo(alpha16);
         QCOMPARE(c.opacityU8(), quint8(255));
     }
 
     {
         KoColor c(QColor(255,255,255,0), alpha16);
         c.convertTo(rgb8);
         QCOMPARE(c.toQColor(), QColor(0,0,0,255));
         c.convertTo(alpha16);
         QCOMPARE(c.opacityU8(), quint8(0));
     }
 
     {
         KoColor c(QColor(255,255,255,128), alpha16);
         c.convertTo(rgb8);
-        QCOMPARE(c.toQColor(), QColor(129,129,129,255));
+        QCOMPARE(c.toQColor(), QColor(128,128,128,255));
         c.convertTo(alpha16);
-        QCOMPARE(c.opacityU8(), quint8(138));
+        QCOMPARE(c.opacityU8(), quint8(137)); // alpha is linear, so the value increases
     }
 
     {
         KoColor c(QColor(255,255,255,255), alpha16);
         QCOMPARE(c.opacityU8(), quint8(255));
         c.convertTo(rgb16);
         QCOMPARE(c.toQColor(), QColor(254,255,255));
         c.convertTo(alpha16);
         QCOMPARE(c.opacityU8(), quint8(255));
     }
 
     {
         KoColor c(QColor(255,255,255,0), alpha16);
         c.convertTo(rgb16);
         QCOMPARE(c.toQColor(), QColor(0,0,1,255));
         c.convertTo(alpha16);
         QCOMPARE(c.opacityU8(), quint8(0));
     }
 
     {
         KoColor c(QColor(255,255,255,128), alpha16);
         c.convertTo(rgb16);
         QCOMPARE(c.toQColor(), QColor(118,120,120,255));
         c.convertTo(alpha16);
         QCOMPARE(c.opacityU8(), quint8(128));
     }
 }
 
 void TestColorConversionSystem::benchmarkAlphaToRgbConversion()
 {
     const KoColorSpace *alpha8 = KoColorSpaceRegistry::instance()->alpha8();
     const KoColorSpace *rgb8 = KoColorSpaceRegistry::instance()->rgb8();
 
     const int numPixels = 1024 * 4096;
     QByteArray srcBuf(numPixels * alpha8->pixelSize(), '\0');
     QByteArray dstBuf(numPixels * rgb8->pixelSize(), '\0');
 
     qsrand(1);
     for (int i = 0; i < srcBuf.size(); i++) {
         srcBuf[i] = qrand() & 0xFF;
     }
 
     QBENCHMARK {
         alpha8->convertPixelsTo((quint8*)srcBuf.data(),
                                 (quint8*)dstBuf.data(),
                                 rgb8,
                                 numPixels,
                                 KoColorConversionTransformation::IntentPerceptual,
                                 KoColorConversionTransformation::Empty);
     }
 }
 
 void TestColorConversionSystem::benchmarkRgbToAlphaConversion()
 {
     const KoColorSpace *alpha8 = KoColorSpaceRegistry::instance()->alpha8();
     const KoColorSpace *rgb8 = KoColorSpaceRegistry::instance()->rgb8();
 
     const int numPixels = 1024 * 4096;
     QByteArray srcBuf(numPixels * rgb8->pixelSize(), '\0');
     QByteArray dstBuf(numPixels * alpha8->pixelSize(), '\0');
 
     qsrand(1);
     for (int i = 0; i < srcBuf.size(); i++) {
         srcBuf[i] = qrand() & 0xFF;
     }
 
     QBENCHMARK {
         rgb8->convertPixelsTo((quint8*)srcBuf.data(),
                               (quint8*)dstBuf.data(),
                               alpha8,
                               numPixels,
                               KoColorConversionTransformation::IntentPerceptual,
                               KoColorConversionTransformation::Empty);
     }
 }
 
-QTEST_GUILESS_MAIN(TestColorConversionSystem)
+
+KISTEST_MAIN(TestColorConversionSystem)
diff --git a/libs/store/tests/CMakeLists.txt b/libs/store/tests/CMakeLists.txt
index c2a00e7d0f..8305778539 100644
--- a/libs/store/tests/CMakeLists.txt
+++ b/libs/store/tests/CMakeLists.txt
@@ -1,19 +1,21 @@
 set( EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR} )
 
 include(ECMAddTests)
 
 ecm_add_test(
     ../KoLZF.cpp TestKoLZF.cpp
-    TEST_NAME libs-odf-TestKoLZF
-    LINK_LIBRARIES kritastore Qt5::Test)
+    TEST_NAME TestKoLZF
+    LINK_LIBRARIES kritastore Qt5::Test
+    NAME_PREFIX "libs-odf")
 
 ecm_add_test(
     ../KoLZF.cpp TestKoXmlVector.cpp
-    TEST_NAME libs-odf-TestKoXmlVector
-    LINK_LIBRARIES kritastore Qt5::Test)
+    TEST_NAME TestKoXmlVector
+    LINK_LIBRARIES kritastore Qt5::Test
+    NAME_PREFIX "libs-odf")
 
 ########### manual test for file contents ###############
 
 add_executable(storedroptest storedroptest.cpp)
 target_link_libraries(storedroptest kritastore Qt5::Widgets)
 ecm_mark_as_test(storedroptest)
diff --git a/libs/ui/KisReferenceImagesDecoration.cpp b/libs/ui/KisReferenceImagesDecoration.cpp
index a9c6899217..2ac834dbee 100644
--- a/libs/ui/KisReferenceImagesDecoration.cpp
+++ b/libs/ui/KisReferenceImagesDecoration.cpp
@@ -1,164 +1,173 @@
 /*
  * 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 "KisReferenceImagesDecoration.h"
 
 #include "KoShapeManager.h"
 
 #include "kis_algebra_2d.h"
 #include "KisDocument.h"
 #include "KisReferenceImagesLayer.h"
 
 struct KisReferenceImagesDecoration::Private {
     struct Buffer
     {
         /// Top left corner of the buffer relative to the viewport
         QPointF position;
         QImage image;
 
         QRectF bounds() const
         {
             return QRectF(position, image.size());
         }
     };
 
     KisReferenceImagesDecoration *q;
 
     KisWeakSharedPtr<KisReferenceImagesLayer> layer;
     Buffer buffer;
     QTransform previousTransform;
+    QSizeF previousViewSize;
 
     explicit Private(KisReferenceImagesDecoration *q)
         : q(q)
     {}
 
     void updateBufferByImageCoordinates(const QRectF &dirtyImageRect)
     {
         QRectF dirtyWidgetRect = q->view()->viewConverter()->imageToWidget(dirtyImageRect);
         updateBuffer(dirtyWidgetRect, dirtyImageRect);
     }
 
     void updateBufferByWidgetCoordinates(const QRectF &dirtyWidgetRect)
     {
         QRectF dirtyImageRect = q->view()->viewConverter()->widgetToImage(dirtyWidgetRect);
         updateBuffer(dirtyWidgetRect, dirtyImageRect);
     }
 
 private:
     void updateBuffer(QRectF widgetRect, QRectF imageRect)
     {
         KisCoordinatesConverter *viewConverter = q->view()->viewConverter();
         QTransform transform = viewConverter->imageToWidgetTransform();
 
         if (buffer.image.isNull() || !buffer.bounds().contains(widgetRect)) {
             const QRectF boundingImageRect = layer->boundingImageRect();
             const QRectF boundingWidgetRect = q->view()->viewConverter()->imageToWidget(boundingImageRect);
             widgetRect = boundingWidgetRect.intersected(q->view()->rect());
 
             if (widgetRect.isNull()) return;
 
             buffer.position = widgetRect.topLeft();
             buffer.image = QImage(widgetRect.size().toSize(), QImage::Format_ARGB32);
             buffer.image.fill(Qt::transparent);
 
             imageRect = q->view()->viewConverter()->widgetToImage(widgetRect);
         }
 
         QPainter gc(&buffer.image);
 
         gc.translate(-buffer.position);
         gc.setTransform(transform, true);
 
         gc.save();
         gc.setCompositionMode(QPainter::CompositionMode_Source);
         gc.fillRect(imageRect, Qt::transparent);
         gc.restore();
 
         gc.setClipRect(imageRect);
         layer->paintReferences(gc);
     }
 };
 
 KisReferenceImagesDecoration::KisReferenceImagesDecoration(QPointer<KisView> parent, KisDocument *document)
     : KisCanvasDecoration("referenceImagesDecoration", parent)
     , d(new Private(this))
 {
     connect(document->image().data(), SIGNAL(sigNodeAddedAsync(KisNodeSP)), this, SLOT(slotNodeAdded(KisNodeSP)));
 
     auto referenceImageLayer = document->referenceImagesLayer();
     if (referenceImageLayer) {
         setReferenceImageLayer(referenceImageLayer);
     }
 }
 
 KisReferenceImagesDecoration::~KisReferenceImagesDecoration()
 {}
 
 void KisReferenceImagesDecoration::addReferenceImage(KisReferenceImage *referenceImage)
 {
     KisDocument *document = view()->document();
     KUndo2Command *cmd = KisReferenceImagesLayer::addReferenceImages(document, {referenceImage});
     document->addCommand(cmd);
 }
 
 bool KisReferenceImagesDecoration::documentHasReferenceImages() const
 {
     return view()->document()->referenceImagesLayer() != nullptr;
 }
 
-void KisReferenceImagesDecoration::drawDecoration(QPainter &gc, const QRectF &updateRect, const KisCoordinatesConverter */*converter*/, KisCanvas2 */*canvas*/)
+void KisReferenceImagesDecoration::drawDecoration(QPainter &gc, const QRectF &/*updateRect*/, const KisCoordinatesConverter *converter, KisCanvas2 */*canvas*/)
 {
+    // TODO: can we use partial updates here?
+
     KisSharedPtr<KisReferenceImagesLayer> layer = d->layer.toStrongRef();
 
     if (!layer.isNull()) {
-        QTransform transform = view()->viewConverter()->imageToWidgetTransform();
-        if (!KisAlgebra2D::fuzzyMatrixCompare(transform, d->previousTransform, 1e-4)) {
+        QSizeF viewSize = view()->size();
+
+        QTransform transform = converter->imageToWidgetTransform();
+        if (d->previousViewSize != viewSize || !KisAlgebra2D::fuzzyMatrixCompare(transform, d->previousTransform, 1e-4)) {
+            d->previousViewSize = viewSize;
             d->previousTransform = transform;
-            d->updateBufferByWidgetCoordinates(QRectF(0, 0, view()->width(), view()->height()));
+            d->buffer.image = QImage();
+            d->updateBufferByWidgetCoordinates(QRectF(QPointF(0,0), viewSize));
         }
 
-        gc.drawImage(d->buffer.position, d->buffer.image);
+        if (!d->buffer.image.isNull()) {
+            gc.drawImage(d->buffer.position, d->buffer.image);
+        }
     }
 }
 
 void KisReferenceImagesDecoration::slotNodeAdded(KisNodeSP node)
 {
     auto *referenceImagesLayer = dynamic_cast<KisReferenceImagesLayer*>(node.data());
 
     if (referenceImagesLayer) {
         setReferenceImageLayer(referenceImagesLayer);
     }
 }
 
 void KisReferenceImagesDecoration::slotReferenceImagesChanged(const QRectF &dirtyRect)
 {
     d->updateBufferByImageCoordinates(dirtyRect);
 
     QRectF documentRect = view()->viewConverter()->imageToDocument(dirtyRect);
     view()->canvasBase()->updateCanvas(documentRect);
 }
 
 void KisReferenceImagesDecoration::setReferenceImageLayer(KisSharedPtr<KisReferenceImagesLayer> layer)
 {
     d->layer = layer;
     connect(
             layer.data(), SIGNAL(sigUpdateCanvas(const QRectF&)),
             this, SLOT(slotReferenceImagesChanged(const QRectF&))
     );
 }
diff --git a/libs/ui/KisSessionResource.h b/libs/ui/KisSessionResource.h
index 257bccb9b7..6ae173bcc7 100644
--- a/libs/ui/KisSessionResource.h
+++ b/libs/ui/KisSessionResource.h
@@ -1,46 +1,46 @@
 /*
  *  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 KISSESSIONRESOURCE_H
 #define KISSESSIONRESOURCE_H
 
 #include "KisWindowLayoutResource.h"
 
 class KisSessionResource : public KisWindowLayoutResource
 {
 public:
     KisSessionResource(const QString &filename);
     ~KisSessionResource();
 
     void storeCurrentWindows();
     void restore();
 
     QString defaultFileExtension() const override;
 
 protected:
     void saveXml(QDomDocument &doc, QDomElement &root) const override;
 
     void loadXml(const QDomElement &root) const override;
 
 private:
     struct Private;
     QScopedPointer<Private> d;
 };
 
 
-#endif
\ No newline at end of file
+#endif
diff --git a/libs/ui/KisWindowLayoutResource.h b/libs/ui/KisWindowLayoutResource.h
index ef50b0903b..7ca38ccc8e 100644
--- a/libs/ui/KisWindowLayoutResource.h
+++ b/libs/ui/KisWindowLayoutResource.h
@@ -1,61 +1,61 @@
 /*
  *  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 KISWINDOWLAYOUTRESOURCE_H
 #define KISWINDOWLAYOUTRESOURCE_H
 
 #include <KoResource.h>
 #include <KisMainWindow.h>
 
 class KisWindowLayoutResource : public KoResource
 {
 public:
     explicit KisWindowLayoutResource(const QString &filename);
     ~KisWindowLayoutResource() override;
 
     static KisWindowLayoutResource * fromCurrentWindows(
         const QString &filename, const QList<QPointer<KisMainWindow>> &mainWindows,
         bool showImageInAllWindows,
         bool primaryWorkspaceFollowsFocus,
         KisMainWindow *primaryWindow
     );
 
     void applyLayout();
 
     bool save() override;
     bool load() override;
 
     bool saveToDevice(QIODevice *dev) const override;
     bool loadFromDevice(QIODevice *dev) override;
 
     QString defaultFileExtension() const override;
 
 protected:
     void setWindows(const QList<QPointer<KisMainWindow>> &mainWindows);
 
     virtual void saveXml(QDomDocument &doc, QDomElement &root) const;
 
     virtual void loadXml(const QDomElement &root) const;
 
 private:
     struct Private;
 
     QScopedPointer<Private> d;
 };
 
-#endif
\ No newline at end of file
+#endif
diff --git a/libs/ui/dialogs/KisNewWindowLayoutDialog.h b/libs/ui/dialogs/KisNewWindowLayoutDialog.h
index 1266d8c296..3608dc441d 100644
--- a/libs/ui/dialogs/KisNewWindowLayoutDialog.h
+++ b/libs/ui/dialogs/KisNewWindowLayoutDialog.h
@@ -1,36 +1,36 @@
 /*
  *  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 KISNEWWINDOWLAYOUTDIALOG_H
 #define KISNEWWINDOWLAYOUTDIALOG_H
 
 #include <QDialog>
 #include "ui_wdgnewwindowlayout.h"
 
 class KisNewWindowLayoutDialog : public QDialog, Ui::DlgNewWindowLayout
 {
 public:
     KisNewWindowLayoutDialog(QWidget *parent = 0);
 
     void setName(const QString &name);
     QString name() const;
     bool showImageInAllWindows() const;
     bool primaryWorkspaceFollowsFocus() const;
 };
 
-#endif
\ No newline at end of file
+#endif
diff --git a/libs/ui/dialogs/KisSessionManagerDialog.h b/libs/ui/dialogs/KisSessionManagerDialog.h
index a3e400daed..5ba4566f92 100644
--- a/libs/ui/dialogs/KisSessionManagerDialog.h
+++ b/libs/ui/dialogs/KisSessionManagerDialog.h
@@ -1,50 +1,50 @@
 /*
  *  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 KISSESSIONMANAGERDIALOG_H
 #define KISSESSIONMANAGERDIALOG_H
 
 #include <QDialog>
 
 #include "ui_wdgsessionmanager.h"
 
 class KisSessionResource;
 
 class KisSessionManagerDialog : public QDialog, Ui::DlgSessionManager
 {
     Q_OBJECT
 
 public:
     explicit KisSessionManagerDialog(QWidget *parent = nullptr);
 
 private Q_SLOTS:
     void slotNewSession();
     void slotRenameSession();
     void slotSwitchSession();
     void slotDeleteSession();
     void slotSessionDoubleClicked(QListWidgetItem* item);
 
     void slotClose();
 
 private:
     void updateSessionList();
 
     KisSessionResource *getSelectedSession() const;
 };
 
-#endif
\ No newline at end of file
+#endif
diff --git a/libs/ui/flake/kis_shape_selection.cpp b/libs/ui/flake/kis_shape_selection.cpp
index 8c62b13187..d0d4b65c29 100644
--- a/libs/ui/flake/kis_shape_selection.cpp
+++ b/libs/ui/flake/kis_shape_selection.cpp
@@ -1,388 +1,388 @@
 /*
  *  Copyright (c) 2010 Sven Langkamp <sven.langkamp@gmail.com>
  *  Copyright (c) 2011 Jan Hambrecht <jaham@gmx.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_shape_selection.h"
 
 
 #include <QPainter>
 #include <QTimer>
 #include <kundo2command.h>
 #include <QMimeData>
 
 #include <QTemporaryFile>
 
 #include <KoShapeStroke.h>
 #include <KoPathShape.h>
 #include <KoShapeGroup.h>
 #include <KoCompositeOp.h>
 #include <KoShapeManager.h>
 #include <KisDocument.h>
 
 #include <KoEmbeddedDocumentSaver.h>
 #include <KoGenStyles.h>
 #include <KoOdfLoadingContext.h>
 #include <KoOdfReadStore.h>
 #include <KoOdfStylesReader.h>
 #include <KoOdfWriteStore.h>
 #include <KoXmlNS.h>
 #include <KoShapeRegistry.h>
 #include <KoShapeLoadingContext.h>
 #include <KoXmlWriter.h>
 #include <KoStore.h>
 #include <KoShapeController.h>
 #include <KoShapeSavingContext.h>
 #include <KoStoreDevice.h>
 #include <KoShapeTransformCommand.h>
 #include <KoElementReference.h>
 
 #include <kis_painter.h>
 #include <kis_paint_device.h>
 #include <kis_image.h>
 #include <kis_iterator_ng.h>
 #include <kis_selection.h>
 
 #include "kis_shape_selection_model.h"
 #include "kis_shape_selection_canvas.h"
 #include "kis_take_all_shapes_command.h"
 #include "kis_image_view_converter.h"
 #include "kis_shape_layer.h"
 
 
 #include <kis_debug.h>
 
 KisShapeSelection::KisShapeSelection(KoShapeControllerBase *shapeControllerBase, KisImageWSP image, KisSelectionWSP selection)
     : KoShapeLayer(m_model = new KisShapeSelectionModel(image, selection, this))
     , m_image(image)
     , m_shapeControllerBase(shapeControllerBase)
 {
     Q_ASSERT(m_image);
     setShapeId("KisShapeSelection");
     setSelectable(false);
     m_converter = new KisImageViewConverter(image);
     m_canvas = new KisShapeSelectionCanvas(shapeControllerBase);
     m_canvas->shapeManager()->addShape(this);
 
     m_model->setObjectName("KisShapeSelectionModel");
     m_model->moveToThread(image->thread());
     m_canvas->setObjectName("KisShapeSelectionCanvas");
     m_canvas->moveToThread(image->thread());
 }
 
 KisShapeSelection::~KisShapeSelection()
 {
     m_model->setShapeSelection(0);
     delete m_canvas;
     delete m_converter;
 }
 
 KisShapeSelection::KisShapeSelection(const KisShapeSelection& rhs, KisSelection* selection)
     : KoShapeLayer(m_model = new KisShapeSelectionModel(rhs.m_image, selection, this))
 {
     m_image = rhs.m_image;
     m_shapeControllerBase = rhs.m_shapeControllerBase;
     m_converter = new KisImageViewConverter(m_image);
     m_canvas = new KisShapeSelectionCanvas(m_shapeControllerBase);
     m_canvas->shapeManager()->addShape(this);
 
     Q_FOREACH (KoShape *shape, rhs.shapes()) {
         KoShape *clonedShape = shape->cloneShape();
         KIS_SAFE_ASSERT_RECOVER(clonedShape) { continue; }
         this->addShape(clonedShape);
     }
 }
 
 KisSelectionComponent* KisShapeSelection::clone(KisSelection* selection)
 {
     return new KisShapeSelection(*this, selection);
 }
 
 bool KisShapeSelection::saveSelection(KoStore * store) const
 {
     const QSizeF sizeInPx = m_image->bounds().size();
     const QSizeF sizeInPt(sizeInPx.width() / m_image->xRes(), sizeInPx.height() / m_image->yRes());
 
     return KisShapeLayer::saveShapesToStore(store, this->shapes(), sizeInPt);
 }
 
 bool KisShapeSelection::loadSelection(KoStore* store)
 {
     QSizeF fragmentSize; // unused!
 
     // FIXME: we handle xRes() only!
     KIS_SAFE_ASSERT_RECOVER_NOOP(qFuzzyCompare(m_image->xRes(), m_image->yRes()));
     const qreal resolutionPPI = 72.0 * m_image->xRes();
 
     QList<KoShape*> shapes;
 
     if (store->open("content.svg")) {
         KoStoreDevice storeDev(store);
         storeDev.open(QIODevice::ReadOnly);
 
         shapes = KisShapeLayer::createShapesFromSvg(&storeDev,
                                                     "", m_image->bounds(),
                                                     resolutionPPI, m_canvas->shapeController()->resourceManager(),
                                                     &fragmentSize);
 
         store->close();
 
         Q_FOREACH (KoShape *shape, shapes) {
             addShape(shape);
         }
 
         return true;
     }
 
 
     KoOdfReadStore odfStore(store);
     QString errorMessage;
 
     odfStore.loadAndParse(errorMessage);
 
     if (!errorMessage.isEmpty()) {
         dbgKrita << errorMessage;
         return false;
     }
 
     KoXmlElement contents = odfStore.contentDoc().documentElement();
 
     //    dbgKrita <<"Start loading OASIS document..." << contents.text();
     //    dbgKrita <<"Start loading OASIS contents..." << contents.lastChild().localName();
     //    dbgKrita <<"Start loading OASIS contents..." << contents.lastChild().namespaceURI();
     //    dbgKrita <<"Start loading OASIS contents..." << contents.lastChild().isElement();
 
     KoXmlElement body(KoXml::namedItemNS(contents, KoXmlNS::office, "body"));
 
     if (body.isNull()) {
         dbgKrita << "No office:body found!";
         //setErrorMessage( i18n( "Invalid OASIS document. No office:body tag found." ) );
         return false;
     }
 
     body = KoXml::namedItemNS(body, KoXmlNS::office, "drawing");
     if (body.isNull()) {
         dbgKrita << "No office:drawing found!";
         //setErrorMessage( i18n( "Invalid OASIS document. No office:drawing tag found." ) );
         return false;
     }
 
     KoXmlElement page(KoXml::namedItemNS(body, KoXmlNS::draw, "page"));
     if (page.isNull()) {
         dbgKrita << "No office:drawing found!";
         //setErrorMessage( i18n( "Invalid OASIS document. No draw:page tag found." ) );
         return false;
     }
 
     KoXmlElement * master = 0;
     if (odfStore.styles().masterPages().contains("Standard"))
         master = odfStore.styles().masterPages().value("Standard");
     else if (odfStore.styles().masterPages().contains("Default"))
         master = odfStore.styles().masterPages().value("Default");
     else if (! odfStore.styles().masterPages().empty())
         master = odfStore.styles().masterPages().begin().value();
 
     if (master) {
         const KoXmlElement *style = odfStore.styles().findStyle(
                     master->attributeNS(KoXmlNS::style, "page-layout-name", QString()));
         KoPageLayout pageLayout;
         pageLayout.loadOdf(*style);
         setSize(QSizeF(pageLayout.width, pageLayout.height));
     } else {
         dbgKrita << "No master page found!";
         return false;
     }
 
     KoOdfLoadingContext context(odfStore.styles(), odfStore.store());
     KoShapeLoadingContext shapeContext(context, 0);
 
     KoXmlElement layerElement;
     forEachElement(layerElement, context.stylesReader().layerSet()) {
         if (!loadOdf(layerElement, shapeContext)) {
             dbgKrita << "Could not load vector layer!";
             return false;
         }
     }
 
     KoXmlElement child;
     forEachElement(child, page) {
         KoShape * shape = KoShapeRegistry::instance()->createShapeFromOdf(child, shapeContext);
         if (shape) {
             addShape(shape);
         }
     }
 
     return true;
 }
 
 void KisShapeSelection::setUpdatesEnabled(bool enabled)
 {
     m_model->setUpdatesEnabled(enabled);
 }
 
 bool KisShapeSelection::updatesEnabled() const
 {
     return m_model->updatesEnabled();
 }
 
 KUndo2Command* KisShapeSelection::resetToEmpty()
 {
     return new KisTakeAllShapesCommand(this, true);
 }
 
 bool KisShapeSelection::isEmpty() const
 {
     return !m_model->count();
 }
 
 QPainterPath KisShapeSelection::outlineCache() const
 {
     return m_outline;
 }
 
 bool KisShapeSelection::outlineCacheValid() const
 {
     return true;
 }
 
 void KisShapeSelection::recalculateOutlineCache()
 {
     QList<KoShape*> shapesList = shapes();
 
     QPainterPath outline;
     Q_FOREACH (KoShape * shape, shapesList) {
         QTransform shapeMatrix = shape->absoluteTransformation(0);
         outline = outline.united(shapeMatrix.map(shape->outline()));
     }
 
     QTransform resolutionMatrix;
     resolutionMatrix.scale(m_image->xRes(), m_image->yRes());
 
     m_outline = resolutionMatrix.map(outline);
 }
 
 void KisShapeSelection::paintComponent(QPainter& painter, const KoViewConverter& converter, KoShapePaintingContext &)
 {
     Q_UNUSED(painter);
     Q_UNUSED(converter);
 }
 
 void KisShapeSelection::renderToProjection(KisPaintDeviceSP projection)
 {
     Q_ASSERT(projection);
     Q_ASSERT(m_image);
 
     QRectF boundingRect = outlineCache().boundingRect();
     renderSelection(projection, boundingRect.toAlignedRect());
 }
 
 void KisShapeSelection::renderToProjection(KisPaintDeviceSP projection, const QRect& r)
 {
     Q_ASSERT(projection);
     renderSelection(projection, r);
 }
 
 void KisShapeSelection::renderSelection(KisPaintDeviceSP projection, const QRect& r)
 {
-    Q_ASSERT(projection);
-    Q_ASSERT(m_image);
+    KIS_SAFE_ASSERT_RECOVER_RETURN(projection);
+    KIS_SAFE_ASSERT_RECOVER_RETURN(m_image);
 
     const qint32 MASK_IMAGE_WIDTH = 256;
     const qint32 MASK_IMAGE_HEIGHT = 256;
 
     QImage polygonMaskImage(MASK_IMAGE_WIDTH, MASK_IMAGE_HEIGHT, QImage::Format_ARGB32);
     QPainter maskPainter(&polygonMaskImage);
     maskPainter.setRenderHint(QPainter::Antialiasing, true);
 
     // Break the mask up into chunks so we don't have to allocate a potentially very large QImage.
     for (qint32 x = r.x(); x < r.x() + r.width(); x += MASK_IMAGE_WIDTH) {
         for (qint32 y = r.y(); y < r.y() + r.height(); y += MASK_IMAGE_HEIGHT) {
 
             maskPainter.fillRect(polygonMaskImage.rect(), Qt::black);
             maskPainter.translate(-x, -y);
             maskPainter.fillPath(outlineCache(), Qt::white);
             maskPainter.translate(x, y);
 
             qint32 rectWidth = qMin(r.x() + r.width() - x, MASK_IMAGE_WIDTH);
             qint32 rectHeight = qMin(r.y() + r.height() - y, MASK_IMAGE_HEIGHT);
 
             KisSequentialIterator it(projection, QRect(x, y, rectWidth, rectHeight));
             while (it.nextPixel()) {
                 (*it.rawData()) = qRed(polygonMaskImage.pixel(it.x() - x, it.y() - y));
             }
         }
     }
 }
 
 KoShapeManager* KisShapeSelection::shapeManager() const
 {
     return m_canvas->shapeManager();
 }
 
 KisShapeSelectionFactory::KisShapeSelectionFactory()
     : KoShapeFactoryBase("KisShapeSelection", "selection shape container")
 {
     setHidden(true);
 }
 
 void KisShapeSelection::moveX(qint32 x)
 {
     Q_FOREACH (KoShape* shape, shapeManager()->shapes()) {
         if (shape != this) {
             QPointF pos = shape->position();
             shape->setPosition(QPointF(pos.x() + x/m_image->xRes(), pos.y()));
         }
     }
 }
 
 void KisShapeSelection::moveY(qint32 y)
 {
     Q_FOREACH (KoShape* shape, shapeManager()->shapes()) {
         if (shape != this) {
             QPointF pos = shape->position();
             shape->setPosition(QPointF(pos.x(), pos.y() + y/m_image->yRes()));
         }
     }
 }
 
 // TODO same code as in vector layer, refactor!
 KUndo2Command* KisShapeSelection::transform(const QTransform &transform) {
     QList<KoShape*> shapes = m_canvas->shapeManager()->shapes();
     if(shapes.isEmpty()) return 0;
 
     QTransform realTransform = m_converter->documentToView() *
             transform * m_converter->viewToDocument();
 
     QList<QTransform> oldTransformations;
     QList<QTransform> newTransformations;
 
     // this code won't work if there are shapes, that inherit the transformation from the parent container.
     // the chart and tree shapes are examples for that, but they aren't used in krita and there are no other shapes like that.
     Q_FOREACH (const KoShape* shape, shapes) {
         QTransform oldTransform = shape->transformation();
         oldTransformations.append(oldTransform);
         if (dynamic_cast<const KoShapeGroup*>(shape)) {
             newTransformations.append(oldTransform);
         } else {
             QTransform globalTransform = shape->absoluteTransformation(0);
             QTransform localTransform = globalTransform * realTransform * globalTransform.inverted();
             newTransformations.append(localTransform*oldTransform);
         }
     }
 
     return new KoShapeTransformCommand(shapes, oldTransformations, newTransformations);
 }
diff --git a/libs/ui/kis_mask_manager.cc b/libs/ui/kis_mask_manager.cc
index 88493f0b96..a943f5eed7 100644
--- a/libs/ui/kis_mask_manager.cc
+++ b/libs/ui/kis_mask_manager.cc
@@ -1,310 +1,328 @@
 /* This file is part of the KDE project
  * Copyright (C) Boudewijn Rempt <boud@valdyas.org>, (C) 2006
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_mask_manager.h"
 
 #include <kactioncollection.h>
 
 #include <KoProperties.h>
 
 #include <kis_transaction.h>
 #include <filter/kis_filter_configuration.h>
 #include <commands/kis_node_commands.h>
 #include <kis_undo_adapter.h>
 #include <kis_paint_layer.h>
 #include "KisDocument.h"
 #include "KisViewManager.h"
 #include <kis_layer.h>
 #include <kis_clone_layer.h>
 #include <kis_group_layer.h>
 #include <kis_filter_mask.h>
 #include <lazybrush/kis_colorize_mask.h>
 #include <kis_transform_mask.h>
 #include <kis_transparency_mask.h>
 #include <kis_selection_mask.h>
 #include <kis_effect_mask.h>
 #include "dialogs/kis_dlg_adjustment_layer.h"
 #include "widgets/kis_mask_widgets.h"
 #include <kis_selection.h>
 #include <kis_selection_manager.h>
 #include <kis_pixel_selection.h>
 #include "dialogs/kis_dlg_adj_layer_props.h"
 #include <kis_image.h>
 #include <kis_transform_worker.h>
 #include <KoColorSpace.h>
 #include <KoColor.h>
 #include "kis_node_commands_adapter.h"
 #include "commands/kis_selection_commands.h"
 #include "kis_iterator_ng.h"
 
 KisMaskManager::KisMaskManager(KisViewManager * view)
     : m_view(view)
     , m_imageView(0)
     , m_commandsAdapter(new KisNodeCommandsAdapter(m_view))
 {
 }
 
 void KisMaskManager::setView(QPointer<KisView>imageView)
 {
     m_imageView = imageView;
 }
 
 void KisMaskManager::setup(KActionCollection *actionCollection, KisActionManager *actionManager)
 {
     Q_UNUSED(actionCollection);
     Q_UNUSED(actionManager);
 }
 
 void KisMaskManager::updateGUI()
 {
     // XXX: enable/disable menu items according to whether there's a mask selected currently
     // XXX: disable the selection mask item if there's already a selection mask
     // YYY: doesn't KisAction do that already?
 }
 
 KisMaskSP KisMaskManager::activeMask()
 {
     if (m_imageView) {
         return m_imageView->currentMask();
     }
     return 0;
 }
 
 KisPaintDeviceSP KisMaskManager::activeDevice()
 {
     KisMaskSP mask = activeMask();
     return mask ? mask->paintDevice() : 0;
 }
 
 void KisMaskManager::activateMask(KisMaskSP mask)
 {
     Q_UNUSED(mask);
 }
 
 void KisMaskManager::masksUpdated()
 {
     m_view->updateGUI();
 }
 
 void KisMaskManager::adjustMaskPosition(KisNodeSP node, KisNodeSP activeNode, bool avoidActiveNode, KisNodeSP &parent, KisNodeSP &above)
 {
     Q_ASSERT(node);
     Q_ASSERT(activeNode);
 
     if (!avoidActiveNode && activeNode->allowAsChild(node)) {
         parent = activeNode;
         above = activeNode->lastChild();
     } else if (activeNode->parent() && activeNode->parent()->allowAsChild(node)) {
         parent = activeNode->parent();
         above = activeNode;
     } else {
         KisNodeSP t = activeNode;
         while ((t = t->nextSibling())) {
             if (t->allowAsChild(node)) {
                 parent = t;
                 above = t->lastChild();
                 break;
             }
         }
 
         if (!t) {
             t = activeNode;
             while ((t = t->prevSibling())) {
                 if (t->allowAsChild(node)) {
                     parent = t;
                     above = t->lastChild();
                     break;
                 }
             }
         }
 
         if (!t && activeNode->parent()) {
             adjustMaskPosition(node, activeNode->parent(), true, parent, above);
         } else if (!t) {
             KisImageWSP image = m_view->image();
             KisLayerSP layer = new KisPaintLayer(image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8, image->colorSpace());
             m_commandsAdapter->addNode(layer, activeNode, 0);
 
             parent = layer;
             above = 0;
         }
     }
 }
 
 void KisMaskManager::createMaskCommon(KisMaskSP mask, KisNodeSP activeNode, KisPaintDeviceSP copyFrom, const KUndo2MagicString& macroName, const QString &nodeType, const QString &nodeName, bool suppressSelection, bool avoidActiveNode, bool updateImage)
 {
     m_commandsAdapter->beginMacro(macroName);
 
     KisNodeSP parent;
     KisNodeSP above;
     adjustMaskPosition(mask, activeNode, avoidActiveNode, parent, above);
 
     KisLayerSP parentLayer = qobject_cast<KisLayer*>(parent.data());
     Q_ASSERT(parentLayer);
 
     if (!suppressSelection) {
         if (copyFrom) {
             mask->initSelection(copyFrom, parentLayer);
         } else {
             mask->initSelection(m_view->selection(), parentLayer);
         }
     }
 
     //counting number of KisSelectionMask
     QList<KisNodeSP> masks = parentLayer->childNodes(QStringList(nodeType),KoProperties());
     int number = masks.count() + 1;
     mask->setName(nodeName + QString(" ") + QString::number(number));
 
     m_commandsAdapter->addNode(mask, parentLayer, above, updateImage, updateImage);
     m_commandsAdapter->endMacro();
 
     masksUpdated();
 }
 
-void KisMaskManager::createSelectionMask(KisNodeSP activeNode, KisPaintDeviceSP copyFrom, bool avoidActiveNode)
+bool KisMaskManager::createSelectionMask(KisNodeSP activeNode, KisPaintDeviceSP copyFrom, bool convertActiveNode)
 {
     KisSelectionMaskSP mask = new KisSelectionMask(m_view->image());
-    createMaskCommon(mask, activeNode, copyFrom, kundo2_i18n("Add Selection Mask"), "KisSelectionMask", i18n("Selection"), false, avoidActiveNode, false);
+    createMaskCommon(mask, activeNode, copyFrom, kundo2_i18n("Add Selection Mask"), "KisSelectionMask", i18n("Selection"), false, convertActiveNode, false);
     mask->setActive(true);
+    if (convertActiveNode) {
+        m_commandsAdapter->removeNode(activeNode);
+    }
+    return true;
 }
 
-void KisMaskManager::createTransparencyMask(KisNodeSP activeNode, KisPaintDeviceSP copyFrom, bool avoidActiveNode)
+bool KisMaskManager::createTransparencyMask(KisNodeSP activeNode, KisPaintDeviceSP copyFrom, bool convertActiveNode)
 {
     KisMaskSP mask = new KisTransparencyMask();
-    createMaskCommon(mask, activeNode, copyFrom, kundo2_i18n("Add Transparency Mask"), "KisTransparencyMask", i18n("Transparency Mask"), false, avoidActiveNode);
+    createMaskCommon(mask, activeNode, copyFrom, kundo2_i18n("Add Transparency Mask"), "KisTransparencyMask", i18n("Transparency Mask"), false, convertActiveNode);
+    if (convertActiveNode) {
+        m_commandsAdapter->removeNode(activeNode);
+    }
+    return true;
 }
 
 
-void KisMaskManager::createFilterMask(KisNodeSP activeNode, KisPaintDeviceSP copyFrom, bool quiet, bool avoidActiveNode)
+bool KisMaskManager::createFilterMask(KisNodeSP activeNode, KisPaintDeviceSP copyFrom, bool quiet, bool convertActiveNode)
 {
     KisFilterMaskSP mask = new KisFilterMask();
-    createMaskCommon(mask, activeNode, copyFrom, kundo2_i18n("Add Filter Mask"), "KisFilterMask", i18n("Filter Mask"), false, avoidActiveNode);
+    createMaskCommon(mask, activeNode, copyFrom, kundo2_i18n("Add Filter Mask"), "KisFilterMask", i18n("Filter Mask"), false, convertActiveNode);
+
+    if (convertActiveNode) {
+        m_commandsAdapter->removeNode(activeNode);
+    }
 
     /**
      * FIXME: We'll use layer's original for creation of a thumbnail.
      * Actually, we can't use it's projection as newly created mask
      * may be going to be inserted in the middle of the masks stack
      */
     KisPaintDeviceSP originalDevice = mask->parent()->original();
 
 
     KisDlgAdjustmentLayer dialog(mask, mask.data(), originalDevice,
                                  mask->name(), i18n("New Filter Mask"),
                                  m_view);
 
     // If we are supposed to not disturb the user, don't start asking them about things.
     if(quiet) {
         KisFilterConfigurationSP filter = KisFilterRegistry::instance()->values().first()->defaultConfiguration();
         if (filter) {
             mask->setFilter(filter);
             mask->setName(mask->name());
         }
-        return;
+        return true;
     }
 
+    bool result = false;
+
     if (dialog.exec() == QDialog::Accepted) {
         KisFilterConfigurationSP filter = dialog.filterConfiguration();
         if (filter) {
             QString name = dialog.layerName();
             mask->setFilter(filter);
             mask->setName(name);
         }
 
+        result = true;
+
     } else {
         m_commandsAdapter->undoLastCommand();
     }
+
+    return result;
 }
 
 
 void KisMaskManager::createColorizeMask(KisNodeSP activeNode)
 {
     KisColorizeMaskSP mask = new KisColorizeMask();
     createMaskCommon(mask, activeNode, 0, kundo2_i18n("Add Colorize Mask"), "KisColorizeMask", i18n("Colorize Mask"), true, false);
     mask->setImage(m_view->image());
     mask->initializeCompositeOp();
     delete mask->setColorSpace(mask->parent()->colorSpace());
 }
 
 
 void KisMaskManager::createTransformMask(KisNodeSP activeNode)
 {
     KisTransformMaskSP mask = new KisTransformMask();
     createMaskCommon(mask, activeNode, 0, kundo2_i18n("Add Transform Mask"), "KisTransformMask", i18n("Transform Mask"), true, false);
 }
 
 void KisMaskManager::maskProperties()
 {
     if (!activeMask()) return;
 
     if (activeMask()->inherits("KisFilterMask")) {
         KisFilterMask *mask = static_cast<KisFilterMask*>(activeMask().data());
 
         KisLayerSP layer = qobject_cast<KisLayer*>(mask->parent().data());
         if (! layer)
             return;
 
 
         KisPaintDeviceSP dev = layer->original();
         if (!dev) {
             return;
         }
 
         KisDlgAdjLayerProps dlg(layer, mask, dev, m_view, mask->filter().data(), mask->name(), i18n("Filter Mask Properties"), m_view->mainWindow(), "dlgeffectmaskprops");
 
         KisFilterConfigurationSP configBefore(mask->filter());
         Q_ASSERT(configBefore);
         QString xmlBefore = configBefore->toXML();
 
         if (dlg.exec() == QDialog::Accepted) {
 
             KisFilterConfigurationSP configAfter(dlg.filterConfiguration());
             Q_ASSERT(configAfter);
             QString xmlAfter = configAfter->toXML();
 
             mask->setName(dlg.layerName());
 
             if(xmlBefore != xmlAfter) {
                 KisChangeFilterCmd *cmd
                     = new KisChangeFilterCmd(mask,
                                              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) {
                 mask->setFilter(KisFilterRegistry::instance()->cloneConfiguration(configBefore.data()));
                 mask->setDirty();
             }
         }
 
     } else {
         // Not much to show for transparency or selection masks?
     }
 }
diff --git a/libs/ui/kis_mask_manager.h b/libs/ui/kis_mask_manager.h
index d543d1cd69..5c065284fa 100644
--- a/libs/ui/kis_mask_manager.h
+++ b/libs/ui/kis_mask_manager.h
@@ -1,100 +1,100 @@
 /* This file is part of the KDE project
  * Copyright (C) Boudewijn Rempt <boud@valdyas.org>, (C) 2006
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef KIS_MASK_MANAGER
 #define KIS_MASK_MANAGER
 
 #include <QObject>
 #include <QPointer>
 
 #include "kis_types.h"
 #include "KisView.h"
 
 class KisViewManager;
 class KActionCollection;
 class KisNodeCommandsAdapter;
 class KisActionManager;
 
 #include "kis_mask.h"
 
 /**
  * Handle the gui for manipulating masks.
  */
 class KisMaskManager : public QObject
 {
 
     Q_OBJECT
 
 public:
 
 
     KisMaskManager(KisViewManager * view);
     ~KisMaskManager() override {}
     void setView(QPointer<KisView>view);
 
 private:
     
     friend class KisNodeManager;
     
     void setup(KActionCollection * actionCollection, KisActionManager *actionManager);
 
     void updateGUI();
     
     /**
      * @return the paint device associated with the currently
      *         active mask, if there is one.
      */
     KisPaintDeviceSP activeDevice();
 
     /**
      * @return the active mask, if there is one
      */
     KisMaskSP activeMask();
 
     /**
      * Show the mask properties dialog
      */
     void maskProperties();
 
     /**
      * called whenever the mask stack is updated to enable/disable all
      * menu items
      */
     void masksUpdated();
 
     /**
      * Activate a new mask. There can be only one mask active per
      * view; and if the mask is active, it becomes the paint device.
      */
     void activateMask(KisMaskSP mask);
 
     void adjustMaskPosition(KisNodeSP node, KisNodeSP activeNode, bool avoidActiveNode, KisNodeSP &parent, KisNodeSP &above);
     void createMaskCommon(KisMaskSP mask, KisNodeSP activeNode, KisPaintDeviceSP copyFrom, const KUndo2MagicString &macroName, const QString &nodeType, const QString &nodeName, bool suppressSelection, bool avoidActiveNode, bool updateImage = true);
 
-    void createSelectionMask(KisNodeSP activeNode, KisPaintDeviceSP copyFrom, bool avoidActiveNode);
-    void createFilterMask(KisNodeSP activeNode, KisPaintDeviceSP copyFrom, bool quiet, bool avoidActiveNode);
+    bool createSelectionMask(KisNodeSP activeNode, KisPaintDeviceSP copyFrom, bool convertActiveNode);
+    bool createFilterMask(KisNodeSP activeNode, KisPaintDeviceSP copyFrom, bool quiet, bool convertActiveNode);
     void createColorizeMask(KisNodeSP activeNode);
     void createTransformMask(KisNodeSP activeNode);
-    void createTransparencyMask(KisNodeSP activeNode, KisPaintDeviceSP copyFrom, bool avoidActiveNode);
+    bool createTransparencyMask(KisNodeSP activeNode, KisPaintDeviceSP copyFrom, bool convertActiveNode);
 
     KisViewManager * m_view;
     QPointer<KisView>m_imageView;
     KisNodeCommandsAdapter* m_commandsAdapter;
 
 };
 
 #endif // KIS_MASK_MANAGER
diff --git a/libs/ui/kis_node_manager.cpp b/libs/ui/kis_node_manager.cpp
index 17eef1eea7..0693b7e3d3 100644
--- a/libs/ui/kis_node_manager.cpp
+++ b/libs/ui/kis_node_manager.cpp
@@ -1,1505 +1,1512 @@
 /*
  *  Copyright (C) 2007 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_node_manager.h"
 
 #include <QStandardPaths>
 #include <QMessageBox>
 #include <QSignalMapper>
 #include <QApplication>
 
 #include <kactioncollection.h>
 
 #include <QKeySequence>
 
 #include <kis_icon.h>
 #include <KoSelection.h>
 #include <KoShapeManager.h>
 #include <KoShape.h>
 #include <KoShapeLayer.h>
 #include <KisImportExportManager.h>
 #include <KoFileDialog.h>
 #include <KoToolManager.h>
 #include <KoProperties.h>
 
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorModelStandardIds.h>
 
 #include <kis_types.h>
 #include <kis_node.h>
 #include <kis_selection.h>
 #include <kis_selection_mask.h>
 #include <kis_layer.h>
 #include <kis_mask.h>
 #include <kis_image.h>
 #include <kis_painter.h>
 #include <kis_paint_layer.h>
 #include <KisMimeDatabase.h>
 #include <KisReferenceImagesLayer.h>
 
 #include "KisPart.h"
 #include "canvas/kis_canvas2.h"
 #include "kis_shape_controller.h"
 #include "kis_canvas_resource_provider.h"
 #include "KisViewManager.h"
 #include "KisDocument.h"
 #include "kis_mask_manager.h"
 #include "kis_group_layer.h"
 #include "kis_layer_manager.h"
 #include "kis_selection_manager.h"
 #include "kis_node_commands_adapter.h"
 #include "kis_action.h"
 #include "kis_action_manager.h"
 #include "kis_processing_applicator.h"
 #include "kis_sequential_iterator.h"
 #include "kis_transaction.h"
 #include "kis_node_selection_adapter.h"
 #include "kis_node_insertion_adapter.h"
 #include "kis_node_juggler_compressed.h"
 #include "kis_clipboard.h"
 #include "kis_node_dummies_graph.h"
 #include "kis_mimedata.h"
 #include "kis_layer_utils.h"
 #include "krita_utils.h"
 #include "kis_shape_layer.h"
 
 #include "processing/kis_mirror_processing_visitor.h"
 #include "KisView.h"
 
 #include <kis_signals_blocker.h>
 
 struct KisNodeManager::Private {
 
     Private(KisNodeManager *_q, KisViewManager *v)
         : q(_q)
         , view(v)
         , imageView(0)
         , layerManager(v)
         , maskManager(v)
         , commandsAdapter(v)
         , nodeSelectionAdapter(new KisNodeSelectionAdapter(q))
         , nodeInsertionAdapter(new KisNodeInsertionAdapter(q))
     {
     }
 
     KisNodeManager * q;
     KisViewManager * view;
     QPointer<KisView>imageView;
     KisLayerManager layerManager;
     KisMaskManager maskManager;
     KisNodeCommandsAdapter commandsAdapter;
     QScopedPointer<KisNodeSelectionAdapter> nodeSelectionAdapter;
     QScopedPointer<KisNodeInsertionAdapter> nodeInsertionAdapter;
 
     KisAction *showInTimeline;
 
     KisNodeList selectedNodes;
     QPointer<KisNodeJugglerCompressed> nodeJuggler;
 
     KisNodeWSP previouslyActiveNode;
 
     bool activateNodeImpl(KisNodeSP node);
 
     QSignalMapper nodeCreationSignalMapper;
     QSignalMapper nodeConversionSignalMapper;
 
     void saveDeviceAsImage(KisPaintDeviceSP device,
                            const QString &defaultName,
                            const QRect &bounds,
                            qreal xRes,
                            qreal yRes,
                            quint8 opacity);
 
     void mergeTransparencyMaskAsAlpha(bool writeToLayers);
     KisNodeJugglerCompressed* lazyGetJuggler(const KUndo2MagicString &actionName);
 };
 
 bool KisNodeManager::Private::activateNodeImpl(KisNodeSP node)
 {
     Q_ASSERT(view);
     Q_ASSERT(view->canvasBase());
     Q_ASSERT(view->canvasBase()->globalShapeManager());
     Q_ASSERT(imageView);
     if (node && node == q->activeNode()) {
         return false;
     }
 
     // Set the selection on the shape manager to the active layer
     // and set call KoSelection::setActiveLayer( KoShapeLayer* layer )
     // with the parent of the active layer.
     KoSelection *selection = view->canvasBase()->globalShapeManager()->selection();
     Q_ASSERT(selection);
     selection->deselectAll();
 
     if (!node) {
         selection->setActiveLayer(0);
         imageView->setCurrentNode(0);
         maskManager.activateMask(0);
         layerManager.activateLayer(0);
         previouslyActiveNode = q->activeNode();
     } else {
 
         previouslyActiveNode = q->activeNode();
 
         KoShape * shape = view->document()->shapeForNode(node);
 
         //if (!shape) return false;
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(shape, false);
 
         selection->select(shape);
         KoShapeLayer * shapeLayer = dynamic_cast<KoShapeLayer*>(shape);
 
         //if (!shapeLayer) return false;
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(shapeLayer, false);
 
 //         shapeLayer->setGeometryProtected(node->userLocked());
 //         shapeLayer->setVisible(node->visible());
         selection->setActiveLayer(shapeLayer);
 
         imageView->setCurrentNode(node);
         if (KisLayerSP layer = qobject_cast<KisLayer*>(node.data())) {
             maskManager.activateMask(0);
             layerManager.activateLayer(layer);
         } else if (KisMaskSP mask = dynamic_cast<KisMask*>(node.data())) {
             maskManager.activateMask(mask);
             // XXX_NODE: for now, masks cannot be nested.
             layerManager.activateLayer(static_cast<KisLayer*>(node->parent().data()));
         }
     }
     return true;
 }
 
 KisNodeManager::KisNodeManager(KisViewManager *view)
     : m_d(new Private(this, view))
 {
 
     connect(&m_d->layerManager, SIGNAL(sigLayerActivated(KisLayerSP)), SIGNAL(sigLayerActivated(KisLayerSP)));
 }
 
 KisNodeManager::~KisNodeManager()
 {
     delete m_d;
 }
 
 void KisNodeManager::setView(QPointer<KisView>imageView)
 {
     m_d->maskManager.setView(imageView);
     m_d->layerManager.setView(imageView);
 
     if (m_d->imageView) {
         KisShapeController *shapeController = dynamic_cast<KisShapeController*>(m_d->imageView->document()->shapeController());
         Q_ASSERT(shapeController);
         shapeController->disconnect(SIGNAL(sigActivateNode(KisNodeSP)), this);
         m_d->imageView->image()->disconnect(this);
     }
 
     m_d->imageView = imageView;
 
     if (m_d->imageView) {
         KisShapeController *shapeController = dynamic_cast<KisShapeController*>(m_d->imageView->document()->shapeController());
         Q_ASSERT(shapeController);
         connect(shapeController, SIGNAL(sigActivateNode(KisNodeSP)), SLOT(slotNonUiActivatedNode(KisNodeSP)));
         connect(m_d->imageView->image(), SIGNAL(sigIsolatedModeChanged()),this, SLOT(slotUpdateIsolateModeAction()));
         connect(m_d->imageView->image(), SIGNAL(sigRequestNodeReselection(KisNodeSP, const KisNodeList&)),this, SLOT(slotImageRequestNodeReselection(KisNodeSP, const KisNodeList&)));
         m_d->imageView->resourceProvider()->slotNodeActivated(m_d->imageView->currentNode());
     }
 
 }
 
 #define NEW_LAYER_ACTION(id, layerType)                                 \
     {                                                                   \
         action = actionManager->createAction(id);                       \
         m_d->nodeCreationSignalMapper.setMapping(action, layerType);    \
         connect(action, SIGNAL(triggered()),                            \
                 &m_d->nodeCreationSignalMapper, SLOT(map()));           \
     }
 
 #define CONVERT_NODE_ACTION_2(id, layerType, exclude)                   \
     {                                                                   \
         action = actionManager->createAction(id);                       \
         action->setExcludedNodeTypes(QStringList(exclude));             \
         actionManager->addAction(id, action);                           \
         m_d->nodeConversionSignalMapper.setMapping(action, layerType);  \
         connect(action, SIGNAL(triggered()),                            \
                 &m_d->nodeConversionSignalMapper, SLOT(map()));         \
     }
 
 #define CONVERT_NODE_ACTION(id, layerType)              \
     CONVERT_NODE_ACTION_2(id, layerType, layerType)
 
 void KisNodeManager::setup(KActionCollection * actionCollection, KisActionManager* actionManager)
 {
     m_d->layerManager.setup(actionManager);
     m_d->maskManager.setup(actionCollection, actionManager);
 
     KisAction * action  = actionManager->createAction("mirrorNodeX");
     connect(action, SIGNAL(triggered()), this, SLOT(mirrorNodeX()));
 
     action  = actionManager->createAction("mirrorNodeY");
     connect(action, SIGNAL(triggered()), this, SLOT(mirrorNodeY()));
 
     action = actionManager->createAction("activateNextLayer");
     connect(action, SIGNAL(triggered()), this, SLOT(activateNextNode()));
 
     action = actionManager->createAction("activatePreviousLayer");
     connect(action, SIGNAL(triggered()), this, SLOT(activatePreviousNode()));
 
     action = actionManager->createAction("switchToPreviouslyActiveNode");
     connect(action, SIGNAL(triggered()), this, SLOT(switchToPreviouslyActiveNode()));
 
     action  = actionManager->createAction("save_node_as_image");
     connect(action, SIGNAL(triggered()), this, SLOT(saveNodeAsImage()));
 
     action  = actionManager->createAction("save_vector_node_to_svg");
     connect(action, SIGNAL(triggered()), this, SLOT(saveVectorLayerAsImage()));
     action->setActivationFlags(KisAction::ACTIVE_SHAPE_LAYER);
 
     action = actionManager->createAction("duplicatelayer");
     connect(action, SIGNAL(triggered()), this, SLOT(duplicateActiveNode()));
 
     action = actionManager->createAction("copy_layer_clipboard");
     connect(action, SIGNAL(triggered()), this, SLOT(copyLayersToClipboard()));
 
     action = actionManager->createAction("cut_layer_clipboard");
     connect(action, SIGNAL(triggered()), this, SLOT(cutLayersToClipboard()));
 
     action = actionManager->createAction("paste_layer_from_clipboard");
     connect(action, SIGNAL(triggered()), this, SLOT(pasteLayersFromClipboard()));
 
     action = actionManager->createAction("create_quick_group");
     connect(action, SIGNAL(triggered()), this, SLOT(createQuickGroup()));
 
     action = actionManager->createAction("create_quick_clipping_group");
     connect(action, SIGNAL(triggered()), this, SLOT(createQuickClippingGroup()));
 
     action = actionManager->createAction("quick_ungroup");
     connect(action, SIGNAL(triggered()), this, SLOT(quickUngroup()));
 
     action = actionManager->createAction("select_all_layers");
     connect(action, SIGNAL(triggered()), this, SLOT(selectAllNodes()));
 
     action = actionManager->createAction("select_visible_layers");
     connect(action, SIGNAL(triggered()), this, SLOT(selectVisibleNodes()));
 
     action = actionManager->createAction("select_locked_layers");
     connect(action, SIGNAL(triggered()), this, SLOT(selectLockedNodes()));
 
     action = actionManager->createAction("select_invisible_layers");
     connect(action, SIGNAL(triggered()), this, SLOT(selectInvisibleNodes()));
 
     action = actionManager->createAction("select_unlocked_layers");
     connect(action, SIGNAL(triggered()), this, SLOT(selectUnlockedNodes()));
 
     action = actionManager->createAction("new_from_visible");
     connect(action, SIGNAL(triggered()), this, SLOT(createFromVisible()));
 
     action = actionManager->createAction("show_in_timeline");
     action->setCheckable(true);
     connect(action, SIGNAL(toggled(bool)), this, SLOT(slotShowHideTimeline(bool)));
     m_d->showInTimeline = action;
 
     NEW_LAYER_ACTION("add_new_paint_layer", "KisPaintLayer");
 
     NEW_LAYER_ACTION("add_new_group_layer", "KisGroupLayer");
 
     NEW_LAYER_ACTION("add_new_clone_layer", "KisCloneLayer");
 
     NEW_LAYER_ACTION("add_new_shape_layer", "KisShapeLayer");
 
     NEW_LAYER_ACTION("add_new_adjustment_layer", "KisAdjustmentLayer");
 
     NEW_LAYER_ACTION("add_new_fill_layer", "KisGeneratorLayer");
 
     NEW_LAYER_ACTION("add_new_file_layer", "KisFileLayer");
 
     NEW_LAYER_ACTION("add_new_transparency_mask", "KisTransparencyMask");
 
     NEW_LAYER_ACTION("add_new_filter_mask", "KisFilterMask");
 
     NEW_LAYER_ACTION("add_new_colorize_mask", "KisColorizeMask");
 
     NEW_LAYER_ACTION("add_new_transform_mask", "KisTransformMask");
 
     NEW_LAYER_ACTION("add_new_selection_mask", "KisSelectionMask");
 
     connect(&m_d->nodeCreationSignalMapper, SIGNAL(mapped(const QString &)),
             this, SLOT(createNode(const QString &)));
 
     CONVERT_NODE_ACTION("convert_to_paint_layer", "KisPaintLayer");
 
     CONVERT_NODE_ACTION_2("convert_to_selection_mask", "KisSelectionMask", QStringList() << "KisSelectionMask" << "KisColorizeMask");
 
     CONVERT_NODE_ACTION_2("convert_to_filter_mask", "KisFilterMask", QStringList() << "KisFilterMask" << "KisColorizeMask");
 
     CONVERT_NODE_ACTION_2("convert_to_transparency_mask", "KisTransparencyMask", QStringList() << "KisTransparencyMask" << "KisColorizeMask");
 
     CONVERT_NODE_ACTION("convert_to_animated", "animated");
 
     CONVERT_NODE_ACTION_2("convert_layer_to_file_layer", "KisFileLayer", QStringList()<< "KisFileLayer" << "KisCloneLayer");
 
     connect(&m_d->nodeConversionSignalMapper, SIGNAL(mapped(const QString &)),
             this, SLOT(convertNode(const QString &)));
 
     action = actionManager->createAction("isolate_layer");
     connect(action, SIGNAL(triggered(bool)), this, SLOT(toggleIsolateMode(bool)));
 
     action = actionManager->createAction("toggle_layer_visibility");
     connect(action, SIGNAL(triggered()), this, SLOT(toggleVisibility()));
 
     action = actionManager->createAction("toggle_layer_lock");
     connect(action, SIGNAL(triggered()), this, SLOT(toggleLock()));
 
     action = actionManager->createAction("toggle_layer_inherit_alpha");
     connect(action, SIGNAL(triggered()), this, SLOT(toggleInheritAlpha()));
 
     action = actionManager->createAction("toggle_layer_alpha_lock");
     connect(action, SIGNAL(triggered()), this, SLOT(toggleAlphaLock()));
 
     action  = actionManager->createAction("split_alpha_into_mask");
     connect(action, SIGNAL(triggered()), this, SLOT(slotSplitAlphaIntoMask()));
 
     action  = actionManager->createAction("split_alpha_write");
     connect(action, SIGNAL(triggered()), this, SLOT(slotSplitAlphaWrite()));
 
     // HINT: we can save even when the nodes are not editable
     action  = actionManager->createAction("split_alpha_save_merged");
     connect(action, SIGNAL(triggered()), this, SLOT(slotSplitAlphaSaveMerged()));
 
     connect(this, SIGNAL(sigNodeActivated(KisNodeSP)), SLOT(slotUpdateIsolateModeAction()));
     connect(this, SIGNAL(sigNodeActivated(KisNodeSP)), SLOT(slotTryRestartIsolatedMode()));
 }
 
 void KisNodeManager::updateGUI()
 {
     // enable/disable all relevant actions
     m_d->layerManager.updateGUI();
     m_d->maskManager.updateGUI();
 }
 
 KisNodeSP KisNodeManager::activeNode()
 {
     if (m_d->imageView) {
         return m_d->imageView->currentNode();
     }
     return 0;
 }
 
 KisLayerSP KisNodeManager::activeLayer()
 {
     return m_d->layerManager.activeLayer();
 }
 
 const KoColorSpace* KisNodeManager::activeColorSpace()
 {
     if (m_d->maskManager.activeDevice()) {
         return m_d->maskManager.activeDevice()->colorSpace();
     } else {
         Q_ASSERT(m_d->layerManager.activeLayer());
         if (m_d->layerManager.activeLayer()->parentLayer())
             return m_d->layerManager.activeLayer()->parentLayer()->colorSpace();
         else
             return m_d->view->image()->colorSpace();
     }
 }
 
 void KisNodeManager::moveNodeAt(KisNodeSP node, KisNodeSP parent, int index)
 {
     if (parent->allowAsChild(node)) {
         if (node->inherits("KisSelectionMask") && parent->inherits("KisLayer")) {
             KisSelectionMask *m = dynamic_cast<KisSelectionMask*>(node.data());
             KisLayer *l = qobject_cast<KisLayer*>(parent.data());
             if (m && m->active() && l && l->selectionMask()) {
                 l->selectionMask()->setActive(false);
             }
         }
         m_d->commandsAdapter.moveNode(node, parent, index);
     }
 }
 
 void KisNodeManager::moveNodesDirect(KisNodeList nodes, KisNodeSP parent, KisNodeSP aboveThis)
 {
     KUndo2MagicString actionName = kundo2_i18n("Move Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->moveNode(nodes, parent, aboveThis);
 }
 
 void KisNodeManager::copyNodesDirect(KisNodeList nodes, KisNodeSP parent, KisNodeSP aboveThis)
 {
     KUndo2MagicString actionName = kundo2_i18n("Copy Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->copyNode(nodes, parent, aboveThis);
 }
 
 void KisNodeManager::addNodesDirect(KisNodeList nodes, KisNodeSP parent, KisNodeSP aboveThis)
 {
     KUndo2MagicString actionName = kundo2_i18n("Add Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->addNode(nodes, parent, aboveThis);
 }
 
 void KisNodeManager::toggleIsolateActiveNode()
 {
     KisImageWSP image = m_d->view->image();
     KisNodeSP activeNode = this->activeNode();
     KIS_ASSERT_RECOVER_RETURN(activeNode);
 
     if (activeNode == image->isolatedModeRoot()) {
         toggleIsolateMode(false);
     } else {
         toggleIsolateMode(true);
     }
 }
 
 void KisNodeManager::toggleIsolateMode(bool checked)
 {
     KisImageWSP image = m_d->view->image();
 
     KisNodeSP activeNode = this->activeNode();
     if (checked && activeNode) {
 
         // Transform and colorize masks don't have pixel data...
         if (activeNode->inherits("KisTransformMask") ||
             activeNode->inherits("KisColorizeMask")) return;
 
         if (!image->startIsolatedMode(activeNode)) {
             KisAction *action = m_d->view->actionManager()->actionByName("isolate_layer");
             action->setChecked(false);
         }
     } else {
         image->stopIsolatedMode();
     }
 }
 
 void KisNodeManager::slotUpdateIsolateModeAction()
 {
     KisAction *action = m_d->view->actionManager()->actionByName("isolate_layer");
     Q_ASSERT(action);
 
     KisNodeSP activeNode = this->activeNode();
     KisNodeSP isolatedRootNode = m_d->view->image()->isolatedModeRoot();
 
     action->setChecked(isolatedRootNode && isolatedRootNode == activeNode);
 }
 
 void KisNodeManager::slotTryRestartIsolatedMode()
 {
     KisNodeSP isolatedRootNode = m_d->view->image()->isolatedModeRoot();
     if (!isolatedRootNode) return;
 
     this->toggleIsolateMode(true);
 }
 
 void KisNodeManager::createNode(const QString & nodeType, bool quiet, KisPaintDeviceSP copyFrom)
 {
     if (!m_d->view->blockUntilOperationsFinished(m_d->view->image())) {
         return;
     }
 
     KisNodeSP activeNode = this->activeNode();
     if (!activeNode) {
         activeNode = m_d->view->image()->root();
     }
 
     KIS_ASSERT_RECOVER_RETURN(activeNode);
 
     // XXX: make factories for this kind of stuff,
     //      with a registry
 
     if (nodeType == "KisPaintLayer") {
         m_d->layerManager.addLayer(activeNode);
     } else if (nodeType == "KisGroupLayer") {
         m_d->layerManager.addGroupLayer(activeNode);
     } else if (nodeType == "KisAdjustmentLayer") {
         m_d->layerManager.addAdjustmentLayer(activeNode);
     } else if (nodeType == "KisGeneratorLayer") {
         m_d->layerManager.addGeneratorLayer(activeNode);
     } else if (nodeType == "KisShapeLayer") {
         m_d->layerManager.addShapeLayer(activeNode);
     } else if (nodeType == "KisCloneLayer") {
         m_d->layerManager.addCloneLayer(activeNode);
     } else if (nodeType == "KisTransparencyMask") {
         m_d->maskManager.createTransparencyMask(activeNode, copyFrom, false);
     } else if (nodeType == "KisFilterMask") {
         m_d->maskManager.createFilterMask(activeNode, copyFrom, quiet, false);
     } else if (nodeType == "KisColorizeMask") {
         m_d->maskManager.createColorizeMask(activeNode);
     } else if (nodeType == "KisTransformMask") {
         m_d->maskManager.createTransformMask(activeNode);
     } else if (nodeType == "KisSelectionMask") {
         m_d->maskManager.createSelectionMask(activeNode, copyFrom, false);
     } else if (nodeType == "KisFileLayer") {
         m_d->layerManager.addFileLayer(activeNode);
     }
 }
 
 void KisNodeManager::createFromVisible()
 {
     KisLayerUtils::newLayerFromVisible(m_d->view->image(), m_d->view->image()->root()->lastChild());
 }
 
 void KisNodeManager::slotShowHideTimeline(bool value)
 {
     Q_FOREACH (KisNodeSP node, selectedNodes()) {
         node->setUseInTimeline(value);
     }
 }
 
 KisLayerSP KisNodeManager::createPaintLayer()
 {
     KisNodeSP activeNode = this->activeNode();
     if (!activeNode) {
         activeNode = m_d->view->image()->root();
     }
 
     return m_d->layerManager.addLayer(activeNode);
 }
 
 void KisNodeManager::convertNode(const QString &nodeType)
 {
     KisNodeSP activeNode = this->activeNode();
     if (!activeNode) return;
 
     if (nodeType == "KisPaintLayer") {
         m_d->layerManager.convertNodeToPaintLayer(activeNode);
     } else if (nodeType == "KisSelectionMask" ||
                nodeType == "KisFilterMask" ||
                nodeType == "KisTransparencyMask") {
 
         KisPaintDeviceSP copyFrom = activeNode->paintDevice() ?
             activeNode->paintDevice() : activeNode->projection();
 
         m_d->commandsAdapter.beginMacro(kundo2_i18n("Convert to a Selection Mask"));
 
+        bool result = false;
+
         if (nodeType == "KisSelectionMask") {
-            m_d->maskManager.createSelectionMask(activeNode, copyFrom, true);
+            result = m_d->maskManager.createSelectionMask(activeNode, copyFrom, true);
         } else if (nodeType == "KisFilterMask") {
-            m_d->maskManager.createFilterMask(activeNode, copyFrom, false, true);
+            result = m_d->maskManager.createFilterMask(activeNode, copyFrom, false, true);
         } else if (nodeType == "KisTransparencyMask") {
-            m_d->maskManager.createTransparencyMask(activeNode, copyFrom, true);
+            result = m_d->maskManager.createTransparencyMask(activeNode, copyFrom, true);
         }
 
-        m_d->commandsAdapter.removeNode(activeNode);
         m_d->commandsAdapter.endMacro();
+
+        if (!result) {
+            m_d->view->blockUntilOperationsFinishedForced(m_d->imageView->image());
+            m_d->commandsAdapter.undoLastCommand();
+        }
+
     } else if (nodeType == "KisFileLayer") {
             m_d->layerManager.convertLayerToFileLayer(activeNode);
     } else {
         warnKrita << "Unsupported node conversion type:" << nodeType;
     }
 }
 
 void KisNodeManager::slotSomethingActivatedNodeImpl(KisNodeSP node)
 {
     KIS_ASSERT_RECOVER_RETURN(node != activeNode());
     if (m_d->activateNodeImpl(node)) {
         emit sigUiNeedChangeActiveNode(node);
         emit sigNodeActivated(node);
         nodesUpdated();
         if (node) {
             bool toggled =  m_d->view->actionCollection()->action("view_show_canvas_only")->isChecked();
             if (toggled) {
                 m_d->view->showFloatingMessage( activeLayer()->name(), QIcon(), 1600, KisFloatingMessage::Medium, Qt::TextSingleLine);
             }
         }
     }
 }
 
 void KisNodeManager::slotNonUiActivatedNode(KisNodeSP node)
 {
     // the node must still be in the graph, some asynchronous
     // signals may easily break this requirement
     if (node && !node->graphListener()) {
         node = 0;
     }
 
     if (node == activeNode()) return;
 
     slotSomethingActivatedNodeImpl(node);
 
     if (node) {
         bool toggled =  m_d->view->actionCollection()->action("view_show_canvas_only")->isChecked();
         if (toggled) {
             m_d->view->showFloatingMessage( activeLayer()->name(), QIcon(), 1600, KisFloatingMessage::Medium, Qt::TextSingleLine);
         }
     }
 }
 
 void KisNodeManager::slotUiActivatedNode(KisNodeSP node)
 {
     // the node must still be in the graph, some asynchronous
     // signals may easily break this requirement
     if (node && !node->graphListener()) {
         node = 0;
     }
 
     if (node == activeNode()) return;
 
     slotSomethingActivatedNodeImpl(node);
 
     if (node) {
         QStringList vectorTools = QStringList()
                 << "InteractionTool"
                 << "KarbonPatternTool"
                 << "KarbonGradientTool"
                 << "KarbonCalligraphyTool"
                 << "CreateShapesTool"
                 << "PathTool";
 
         QStringList pixelTools = QStringList()
                 << "KritaShape/KisToolBrush"
                 << "KritaShape/KisToolDyna"
                 << "KritaShape/KisToolMultiBrush"
                 << "KritaFill/KisToolFill"
                 << "KritaFill/KisToolGradient";
 
         if (node->inherits("KisShapeLayer")) {
             if (pixelTools.contains(KoToolManager::instance()->activeToolId())) {
                 KoToolManager::instance()->switchToolRequested("InteractionTool");
             }
         }
         else {
             if (vectorTools.contains(KoToolManager::instance()->activeToolId())) {
                 KoToolManager::instance()->switchToolRequested("KritaShape/KisToolBrush");
             }
         }
     }
 }
 
 void KisNodeManager::nodesUpdated()
 {
     KisNodeSP node = activeNode();
     if (!node) return;
 
     m_d->layerManager.layersUpdated();
     m_d->maskManager.masksUpdated();
 
     m_d->view->updateGUI();
     m_d->view->selectionManager()->selectionChanged();
 
     {
         KisSignalsBlocker b(m_d->showInTimeline);
         m_d->showInTimeline->setChecked(node->useInTimeline());
     }
 }
 
 KisPaintDeviceSP KisNodeManager::activePaintDevice()
 {
     return m_d->maskManager.activeMask() ?
         m_d->maskManager.activeDevice() :
         m_d->layerManager.activeDevice();
 }
 
 void KisNodeManager::nodeProperties(KisNodeSP node)
 {
     if ((selectedNodes().size() > 1 && node->inherits("KisLayer")) || node->inherits("KisLayer")) {
         m_d->layerManager.layerProperties();
     }
     else if (node->inherits("KisMask")) {
         m_d->maskManager.maskProperties();
     }
 }
 
 qint32 KisNodeManager::convertOpacityToInt(qreal opacity)
 {
     /**
      * Scales opacity from the range 0...100
      * to the integer range 0...255
      */
 
     return qMin(255, int(opacity * 2.55 + 0.5));
 }
 
 void KisNodeManager::setNodeOpacity(KisNodeSP node, qint32 opacity,
                                     bool finalChange)
 {
     if (!node) return;
     if (node->opacity() == opacity) return;
 
     if (!finalChange) {
         node->setOpacity(opacity);
         node->setDirty();
     } else {
         m_d->commandsAdapter.setOpacity(node, opacity);
     }
 }
 
 void KisNodeManager::setNodeCompositeOp(KisNodeSP node,
                                         const KoCompositeOp* compositeOp)
 {
     if (!node) return;
     if (node->compositeOp() == compositeOp) return;
 
     m_d->commandsAdapter.setCompositeOp(node, compositeOp);
 }
 
 void KisNodeManager::slotImageRequestNodeReselection(KisNodeSP activeNode, const KisNodeList &selectedNodes)
 {
     if (activeNode) {
         slotNonUiActivatedNode(activeNode);
     }
     if (!selectedNodes.isEmpty()) {
         slotSetSelectedNodes(selectedNodes);
     }
 }
 
 void KisNodeManager::slotSetSelectedNodes(const KisNodeList &nodes)
 {
     m_d->selectedNodes = nodes;
     emit sigUiNeedChangeSelectedNodes(nodes);
 }
 
 KisNodeList KisNodeManager::selectedNodes()
 {
     return m_d->selectedNodes;
 }
 
 KisNodeSelectionAdapter* KisNodeManager::nodeSelectionAdapter() const
 {
     return m_d->nodeSelectionAdapter.data();
 }
 
 KisNodeInsertionAdapter* KisNodeManager::nodeInsertionAdapter() const
 {
     return m_d->nodeInsertionAdapter.data();
 }
 
 bool KisNodeManager::isNodeHidden(KisNodeSP node, bool isGlobalSelectionHidden)
 {
     if (dynamic_cast<KisReferenceImagesLayer *>(node.data())) {
         return true;
     }
 
     if (isGlobalSelectionHidden && dynamic_cast<KisSelectionMask *>(node.data()) &&
         (!node->parent() || !node->parent()->parent())) {
         return true;
     }
 
     return false;
 }
 
 void KisNodeManager::nodeOpacityChanged(qreal opacity, bool finalChange)
 {
     KisNodeSP node = activeNode();
 
     setNodeOpacity(node, convertOpacityToInt(opacity), finalChange);
 }
 
 void KisNodeManager::nodeCompositeOpChanged(const KoCompositeOp* op)
 {
     KisNodeSP node = activeNode();
 
     setNodeCompositeOp(node, op);
 }
 
 void KisNodeManager::duplicateActiveNode()
 {
     KUndo2MagicString actionName = kundo2_i18n("Duplicate Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->duplicateNode(selectedNodes());
 }
 
 KisNodeJugglerCompressed* KisNodeManager::Private::lazyGetJuggler(const KUndo2MagicString &actionName)
 {
     KisImageWSP image = view->image();
 
     if (!nodeJuggler ||
         (nodeJuggler &&
          (nodeJuggler->isEnded() ||
           !nodeJuggler->canMergeAction(actionName)))) {
 
         nodeJuggler = new KisNodeJugglerCompressed(actionName, image, q, 750);
         nodeJuggler->setAutoDelete(true);
     }
 
     return nodeJuggler;
 }
 
 void KisNodeManager::raiseNode()
 {
     KUndo2MagicString actionName = kundo2_i18n("Raise Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->raiseNode(selectedNodes());
 }
 
 void KisNodeManager::lowerNode()
 {
     KUndo2MagicString actionName = kundo2_i18n("Lower Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->lowerNode(selectedNodes());
 }
 
 void KisNodeManager::removeSingleNode(KisNodeSP node)
 {
     if (!node || !node->parent()) {
         return;
     }
 
     KisNodeList nodes;
     nodes << node;
     removeSelectedNodes(nodes);
 }
 
 void KisNodeManager::removeSelectedNodes(KisNodeList nodes)
 {
     KUndo2MagicString actionName = kundo2_i18n("Remove Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->removeNode(nodes);
 }
 
 void KisNodeManager::removeNode()
 {
     removeSelectedNodes(selectedNodes());
 }
 
 void KisNodeManager::mirrorNodeX()
 {
     KisNodeSP node = activeNode();
 
     KUndo2MagicString commandName;
     if (node->inherits("KisLayer")) {
         commandName = kundo2_i18n("Mirror Layer X");
     } else if (node->inherits("KisMask")) {
         commandName = kundo2_i18n("Mirror Mask X");
     }
     mirrorNode(node, commandName, Qt::Horizontal);
 }
 
 void KisNodeManager::mirrorNodeY()
 {
     KisNodeSP node = activeNode();
 
     KUndo2MagicString commandName;
     if (node->inherits("KisLayer")) {
         commandName = kundo2_i18n("Mirror Layer Y");
     } else if (node->inherits("KisMask")) {
         commandName = kundo2_i18n("Mirror Mask Y");
     }
     mirrorNode(node, commandName, Qt::Vertical);
 }
 
 void KisNodeManager::activateNextNode()
 {
     KisNodeSP activeNode = this->activeNode();
     if (!activeNode) return;
 
     KisNodeSP node = activeNode->nextSibling();
 
     while (node && node->childCount() > 0) {
            node = node->firstChild();
     }
 
     if (!node && activeNode->parent() && activeNode->parent()->parent()) {
         node = activeNode->parent();
     }
 
     while(node && isNodeHidden(node, true)) {
         node = node->nextSibling();
     }
 
     if (node) {
         slotNonUiActivatedNode(node);
     }
 }
 
 void KisNodeManager::activatePreviousNode()
 {
     KisNodeSP activeNode = this->activeNode();
     if (!activeNode) return;
 
     KisNodeSP node;
 
     if (activeNode->childCount() > 0) {
         node = activeNode->lastChild();
     }
     else {
         node = activeNode->prevSibling();
     }
 
     while (!node && activeNode->parent()) {
         node = activeNode->parent()->prevSibling();
         activeNode = activeNode->parent();
     }
 
     while(node && isNodeHidden(node, true)) {
         node = node->prevSibling();
     }
 
     if (node) {
         slotNonUiActivatedNode(node);
     }
 }
 
 void KisNodeManager::switchToPreviouslyActiveNode()
 {
     if (m_d->previouslyActiveNode && m_d->previouslyActiveNode->parent()) {
         slotNonUiActivatedNode(m_d->previouslyActiveNode);
     }
 }
 
 void KisNodeManager::rotate(double radians)
 {
     if(!m_d->view->image()) return;
 
     KisNodeSP node = activeNode();
     if (!node) return;
 
     if (!m_d->view->blockUntilOperationsFinished(m_d->view->image())) return;
 
     m_d->view->image()->rotateNode(node, radians);
 }
 
 void KisNodeManager::rotate180()
 {
     rotate(M_PI);
 }
 
 void KisNodeManager::rotateLeft90()
 {
    rotate(-M_PI / 2);
 }
 
 void KisNodeManager::rotateRight90()
 {
     rotate(M_PI / 2);
 }
 
 void KisNodeManager::shear(double angleX, double angleY)
 {
     if (!m_d->view->image()) return;
 
     KisNodeSP node = activeNode();
     if (!node) return;
 
     if(!m_d->view->blockUntilOperationsFinished(m_d->view->image())) return;
 
     m_d->view->image()->shearNode(node, angleX, angleY);
 }
 
 void KisNodeManager::scale(double sx, double sy, KisFilterStrategy *filterStrategy)
 {
     KisNodeSP node = activeNode();
     KIS_ASSERT_RECOVER_RETURN(node);
 
     m_d->view->image()->scaleNode(node, sx, sy, filterStrategy);
 
     nodesUpdated();
 }
 
 void KisNodeManager::mirrorNode(KisNodeSP node, const KUndo2MagicString& actionName, Qt::Orientation orientation)
 {
     KisImageSignalVector emitSignals;
     emitSignals << ModifiedSignal;
 
     KisProcessingApplicator applicator(m_d->view->image(), node,
                                        KisProcessingApplicator::RECURSIVE,
                                        emitSignals, actionName);
 
     KisProcessingVisitorSP visitor =
         new KisMirrorProcessingVisitor(m_d->view->image()->bounds(), orientation);
 
     applicator.applyVisitor(visitor, KisStrokeJobData::CONCURRENT);
     applicator.end();
 
     nodesUpdated();
 }
 
 void KisNodeManager::Private::saveDeviceAsImage(KisPaintDeviceSP device,
                                                 const QString &defaultName,
                                                 const QRect &bounds,
                                                 qreal xRes,
                                                 qreal yRes,
                                                 quint8 opacity)
 {
     KoFileDialog dialog(view->mainWindow(), KoFileDialog::SaveFile, "savenodeasimage");
     dialog.setCaption(i18n("Export \"%1\"", defaultName));
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
     dialog.setMimeTypeFilters(KisImportExportManager::supportedMimeTypes(KisImportExportManager::Export));
     QString filename = dialog.filename();
 
     if (filename.isEmpty()) return;
 
     QUrl url = QUrl::fromLocalFile(filename);
 
     if (url.isEmpty()) return;
 
     QString mimefilter = KisMimeDatabase::mimeTypeForFile(filename, false);
 
     QScopedPointer<KisDocument> doc(KisPart::instance()->createDocument());
 
     KisImageSP dst = new KisImage(doc->createUndoStore(),
                                   bounds.width(),
                                   bounds.height(),
                                   device->compositionSourceColorSpace(),
                                   defaultName);
     dst->setResolution(xRes, yRes);
     doc->setCurrentImage(dst);
     KisPaintLayer* paintLayer = new KisPaintLayer(dst, "paint device", opacity);
     paintLayer->paintDevice()->makeCloneFrom(device, bounds);
     dst->addNode(paintLayer, dst->rootLayer(), KisLayerSP(0));
 
     dst->initialRefreshGraph();
 
     doc->exportDocumentSync(url, mimefilter.toLatin1());
 }
 
 void KisNodeManager::saveNodeAsImage()
 {
     KisNodeSP node = activeNode();
 
     if (!node) {
         warnKrita << "BUG: Save Node As Image was called without any node selected";
         return;
     }
 
     KisImageWSP image = m_d->view->image();
     QRect saveRect = image->bounds() | node->exactBounds();
 
     KisPaintDeviceSP device = node->paintDevice();
     if (!device) {
         device = node->projection();
     }
 
     m_d->saveDeviceAsImage(device, node->name(),
                            saveRect,
                            image->xRes(), image->yRes(),
                            node->opacity());
 }
 
 #include "SvgWriter.h"
 
 void KisNodeManager::saveVectorLayerAsImage()
 {
     KisShapeLayerSP shapeLayer = qobject_cast<KisShapeLayer*>(activeNode().data());
     if (!shapeLayer) {
         return;
     }
 
     KoFileDialog dialog(m_d->view->mainWindow(), KoFileDialog::SaveFile, "savenodeasimage");
     dialog.setCaption(i18nc("@title:window", "Export to SVG"));
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
     dialog.setMimeTypeFilters(QStringList() << "image/svg+xml", "image/svg+xml");
     QString filename = dialog.filename();
 
     if (filename.isEmpty()) return;
 
     QUrl url = QUrl::fromLocalFile(filename);
 
     if (url.isEmpty()) return;
 
     const QSizeF sizeInPx = m_d->view->image()->bounds().size();
     const QSizeF sizeInPt(sizeInPx.width() / m_d->view->image()->xRes(),
                           sizeInPx.height() / m_d->view->image()->yRes());
 
     QList<KoShape*> shapes = shapeLayer->shapes();
     std::sort(shapes.begin(), shapes.end(), KoShape::compareShapeZIndex);
 
     SvgWriter writer(shapes);
     if (!writer.save(filename, sizeInPt, true)) {
         QMessageBox::warning(qApp->activeWindow(), i18nc("@title:window", "Krita"), i18n("Could not save to svg: %1", filename));
     }
 }
 
 void KisNodeManager::slotSplitAlphaIntoMask()
 {
     KisNodeSP node = activeNode();
 
     // guaranteed by KisActionManager
     KIS_ASSERT_RECOVER_RETURN(node->hasEditablePaintDevice());
 
     KisPaintDeviceSP srcDevice = node->paintDevice();
     const KoColorSpace *srcCS = srcDevice->colorSpace();
     const QRect processRect =
         srcDevice->exactBounds() |
         srcDevice->defaultBounds()->bounds();
 
     KisPaintDeviceSP selectionDevice =
         new KisPaintDevice(KoColorSpaceRegistry::instance()->alpha8());
 
     m_d->commandsAdapter.beginMacro(kundo2_i18n("Split Alpha into a Mask"));
     KisTransaction transaction(kundo2_noi18n("__split_alpha_channel__"), srcDevice);
 
     KisSequentialIterator srcIt(srcDevice, processRect);
     KisSequentialIterator dstIt(selectionDevice, processRect);
 
     while (srcIt.nextPixel() && dstIt.nextPixel()) {
         quint8 *srcPtr = srcIt.rawData();
         quint8 *alpha8Ptr = dstIt.rawData();
 
         *alpha8Ptr = srcCS->opacityU8(srcPtr);
         srcCS->setOpacity(srcPtr, OPACITY_OPAQUE_U8, 1);
     }
 
     m_d->commandsAdapter.addExtraCommand(transaction.endAndTake());
 
     createNode("KisTransparencyMask", false, selectionDevice);
     m_d->commandsAdapter.endMacro();
 }
 
 void KisNodeManager::Private::mergeTransparencyMaskAsAlpha(bool writeToLayers)
 {
     KisNodeSP node = q->activeNode();
     KisNodeSP parentNode = node->parent();
 
     // guaranteed by KisActionManager
     KIS_ASSERT_RECOVER_RETURN(node->inherits("KisTransparencyMask"));
 
     if (writeToLayers && !parentNode->hasEditablePaintDevice()) {
         QMessageBox::information(view->mainWindow(),
                                  i18nc("@title:window", "Layer %1 is not editable", parentNode->name()),
                                  i18n("Cannot write alpha channel of "
                                       "the parent layer \"%1\".\n"
                                       "The operation will be cancelled.", parentNode->name()));
         return;
     }
 
     KisPaintDeviceSP dstDevice;
     if (writeToLayers) {
         KIS_ASSERT_RECOVER_RETURN(parentNode->paintDevice());
         dstDevice = parentNode->paintDevice();
     } else {
         KisPaintDeviceSP copyDevice = parentNode->paintDevice();
         if (!copyDevice) {
             copyDevice = parentNode->original();
         }
         dstDevice = new KisPaintDevice(*copyDevice);
     }
 
     const KoColorSpace *dstCS = dstDevice->colorSpace();
 
     KisPaintDeviceSP selectionDevice = node->paintDevice();
     KIS_ASSERT_RECOVER_RETURN(selectionDevice->colorSpace()->pixelSize() == 1);
 
     const QRect processRect =
         selectionDevice->exactBounds() |
         dstDevice->exactBounds() |
         selectionDevice->defaultBounds()->bounds();
 
     QScopedPointer<KisTransaction> transaction;
 
     if (writeToLayers) {
         commandsAdapter.beginMacro(kundo2_i18n("Write Alpha into a Layer"));
         transaction.reset(new KisTransaction(kundo2_noi18n("__write_alpha_channel__"), dstDevice));
     }
 
     KisSequentialIterator srcIt(selectionDevice, processRect);
     KisSequentialIterator dstIt(dstDevice, processRect);
 
     while (srcIt.nextPixel() && dstIt.nextPixel()) {
         quint8 *alpha8Ptr = srcIt.rawData();
         quint8 *dstPtr = dstIt.rawData();
 
         dstCS->setOpacity(dstPtr, *alpha8Ptr, 1);
     }
 
     if (writeToLayers) {
         commandsAdapter.addExtraCommand(transaction->endAndTake());
         commandsAdapter.removeNode(node);
         commandsAdapter.endMacro();
     } else {
         KisImageWSP image = view->image();
         QRect saveRect = image->bounds();
 
         saveDeviceAsImage(dstDevice, parentNode->name(),
                           saveRect,
                           image->xRes(), image->yRes(),
                           OPACITY_OPAQUE_U8);
     }
 }
 
 
 void KisNodeManager::slotSplitAlphaWrite()
 {
     m_d->mergeTransparencyMaskAsAlpha(true);
 }
 
 void KisNodeManager::slotSplitAlphaSaveMerged()
 {
     m_d->mergeTransparencyMaskAsAlpha(false);
 }
 
 void KisNodeManager::toggleLock()
 {
     KisNodeList nodes = this->selectedNodes();
     KisNodeSP active = activeNode();
     if (nodes.isEmpty() || !active) return;
 
     bool isLocked = active->userLocked();
 
     for (auto &node : nodes) {
         node->setUserLocked(!isLocked);
     }
 }
 
 void KisNodeManager::toggleVisibility()
 {
     KisNodeList nodes = this->selectedNodes();
     KisNodeSP active = activeNode();
     if (nodes.isEmpty() || !active) return;
 
     bool isVisible = active->visible();
 
     for (auto &node : nodes) {
         node->setVisible(!isVisible);
         node->setDirty();
     }
 }
 
 void KisNodeManager::toggleAlphaLock()
 {
     KisNodeList nodes = this->selectedNodes();
     KisNodeSP active = activeNode();
     if (nodes.isEmpty() || !active) return;
 
     auto layer = qobject_cast<KisPaintLayer*>(active.data());
     if (!layer) {
         return;
     }
 
     bool isAlphaLocked = layer->alphaLocked();
     for (auto &node : nodes) {
         auto layer = qobject_cast<KisPaintLayer*>(node.data());
         if (layer) {
             layer->setAlphaLocked(!isAlphaLocked);
         }
     }
 }
 
 void KisNodeManager::toggleInheritAlpha()
 {
     KisNodeList nodes = this->selectedNodes();
     KisNodeSP active = activeNode();
     if (nodes.isEmpty() || !active) return;
 
     auto layer = qobject_cast<KisLayer*>(active.data());
     if (!layer) {
         return;
     }
 
     bool isAlphaDisabled = layer->alphaChannelDisabled();
     for (auto &node : nodes) {
         auto layer = qobject_cast<KisLayer*>(node.data());
         if (layer) {
             layer->disableAlphaChannel(!isAlphaDisabled);
             node->setDirty();
         }
     }
 }
 
 void KisNodeManager::cutLayersToClipboard()
 {
     KisNodeList nodes = this->selectedNodes();
     if (nodes.isEmpty()) return;
 
     KisClipboard::instance()->setLayers(nodes, m_d->view->image(), false);
 
     KUndo2MagicString actionName = kundo2_i18n("Cut Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->removeNode(nodes);
 }
 
 void KisNodeManager::copyLayersToClipboard()
 {
     KisNodeList nodes = this->selectedNodes();
     KisClipboard::instance()->setLayers(nodes, m_d->view->image(), true);
 }
 
 void KisNodeManager::pasteLayersFromClipboard()
 {
     const QMimeData *data = KisClipboard::instance()->layersMimeData();
     if (!data) return;
 
     KisNodeSP activeNode = this->activeNode();
 
     KisShapeController *shapeController = dynamic_cast<KisShapeController*>(m_d->imageView->document()->shapeController());
     Q_ASSERT(shapeController);
 
     KisDummiesFacadeBase *dummiesFacade = dynamic_cast<KisDummiesFacadeBase*>(m_d->imageView->document()->shapeController());
     Q_ASSERT(dummiesFacade);
 
     const bool copyNode = false;
     KisImageSP image = m_d->view->image();
     KisNodeDummy *parentDummy = dummiesFacade->dummyForNode(activeNode);
     KisNodeDummy *aboveThisDummy = parentDummy ? parentDummy->lastChild() : 0;
 
     KisMimeData::insertMimeLayers(data,
                                   image,
                                   shapeController,
                                   parentDummy,
                                   aboveThisDummy,
                                   copyNode,
                                   nodeInsertionAdapter());
 }
 
 void KisNodeManager::createQuickGroupImpl(KisNodeJugglerCompressed *juggler,
                                           const QString &overrideGroupName,
                                           KisNodeSP *newGroup,
                                           KisNodeSP *newLastChild)
 {
     KisNodeSP active = activeNode();
     if (!active) return;
 
     KisImageSP image = m_d->view->image();
     QString groupName = !overrideGroupName.isEmpty() ? overrideGroupName : image->nextLayerName();
     KisGroupLayerSP group = new KisGroupLayer(image.data(), groupName, OPACITY_OPAQUE_U8);
 
     KisNodeList nodes1;
     nodes1 << group;
 
     KisNodeList nodes2;
     nodes2 = KisLayerUtils::sortMergableNodes(image->root(), selectedNodes());
     KisLayerUtils::filterMergableNodes(nodes2);
 
     if (KisLayerUtils::checkIsChildOf(active, nodes2)) {
         active = nodes2.first();
     }
 
     KisNodeSP parent = active->parent();
     KisNodeSP aboveThis = active;
 
     juggler->addNode(nodes1, parent, aboveThis);
     juggler->moveNode(nodes2, group, 0);
 
     *newGroup = group;
     *newLastChild = nodes2.last();
 }
 
 void KisNodeManager::createQuickGroup()
 {
     KUndo2MagicString actionName = kundo2_i18n("Quick Group");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
 
     KisNodeSP parent;
     KisNodeSP above;
 
     createQuickGroupImpl(juggler, "", &parent, &above);
 }
 
 void KisNodeManager::createQuickClippingGroup()
 {
     KUndo2MagicString actionName = kundo2_i18n("Quick Clipping Group");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
 
     KisNodeSP parent;
     KisNodeSP above;
 
     KisImageSP image = m_d->view->image();
     createQuickGroupImpl(juggler, image->nextLayerName(i18nc("default name for a clipping group layer", "Clipping Group")), &parent, &above);
 
     KisPaintLayerSP maskLayer = new KisPaintLayer(image.data(), i18nc("default name for quick clip group mask layer", "Mask Layer"), OPACITY_OPAQUE_U8, image->colorSpace());
     maskLayer->disableAlphaChannel(true);
 
     juggler->addNode(KisNodeList() << maskLayer, parent, above);
 }
 
 void KisNodeManager::quickUngroup()
 {
     KisNodeSP active = activeNode();
     if (!active) return;
 
     KisNodeSP parent = active->parent();
     KisNodeSP aboveThis = active;
 
     KUndo2MagicString actionName = kundo2_i18n("Quick Ungroup");
 
     if (parent && dynamic_cast<KisGroupLayer*>(active.data())) {
         KisNodeList nodes = active->childNodes(QStringList(), KoProperties());
 
         KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
         juggler->moveNode(nodes, parent, active);
         juggler->removeNode(KisNodeList() << active);
     } else if (parent && parent->parent()) {
         KisNodeSP grandParent = parent->parent();
 
         KisNodeList allChildNodes = parent->childNodes(QStringList(), KoProperties());
         KisNodeList allSelectedNodes = selectedNodes();
 
         const bool removeParent = KritaUtils::compareListsUnordered(allChildNodes, allSelectedNodes);
 
         KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
         juggler->moveNode(allSelectedNodes, grandParent, parent);
         if (removeParent) {
             juggler->removeNode(KisNodeList() << parent);
         }
     }
 }
 
 void KisNodeManager::selectLayersImpl(const KoProperties &props, const KoProperties &invertedProps)
 {
     KisImageSP image = m_d->view->image();
     KisNodeList nodes = KisLayerUtils::findNodesWithProps(image->root(), props, true);
 
     KisNodeList selectedNodes = this->selectedNodes();
 
     if (KritaUtils::compareListsUnordered(nodes, selectedNodes)) {
         nodes = KisLayerUtils::findNodesWithProps(image->root(), invertedProps, true);
     }
 
     if (!nodes.isEmpty()) {
         slotImageRequestNodeReselection(nodes.last(), nodes);
     }
 }
 
 void KisNodeManager::selectAllNodes()
 {
     KoProperties props;
     selectLayersImpl(props, props);
 }
 
 void KisNodeManager::selectVisibleNodes()
 {
     KoProperties props;
     props.setProperty("visible", true);
 
     KoProperties invertedProps;
     invertedProps.setProperty("visible", false);
 
     selectLayersImpl(props, invertedProps);
 }
 
 void KisNodeManager::selectLockedNodes()
 {
     KoProperties props;
     props.setProperty("locked", true);
 
     KoProperties invertedProps;
     invertedProps.setProperty("locked", false);
 
     selectLayersImpl(props, invertedProps);
 }
 
 void KisNodeManager::selectInvisibleNodes()
 {
     KoProperties props;
     props.setProperty("visible", false);
 
     KoProperties invertedProps;
     invertedProps.setProperty("visible", true);
 
     selectLayersImpl(props, invertedProps);
 }
 
 void KisNodeManager::selectUnlockedNodes()
 {
     KoProperties props;
     props.setProperty("locked", false);
 
     KoProperties invertedProps;
     invertedProps.setProperty("locked", true);
 
     selectLayersImpl(props, invertedProps);
 }
diff --git a/libs/ui/kis_node_view_color_scheme.cpp b/libs/ui/kis_node_view_color_scheme.cpp
index 341b907777..b351593485 100644
--- a/libs/ui/kis_node_view_color_scheme.cpp
+++ b/libs/ui/kis_node_view_color_scheme.cpp
@@ -1,185 +1,192 @@
 /*
  *  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_node_view_color_scheme.h"
 
 #include <QTreeView>
 #include <QStyle>
 
+#include "krita_utils.h"
+#include <QApplication>
 
 #include <QGlobalStatic>
 Q_GLOBAL_STATIC(KisNodeViewColorScheme, s_instance)
 
 struct KisNodeViewColorScheme::Private
 {
     Private() {
         if (colorLabels.isEmpty()) {
             colorLabels << Qt::transparent;
             colorLabels << QColor(91,173,220);
             colorLabels << QColor(151,202,63);
             colorLabels << QColor(247,229,61);
             colorLabels << QColor(255,170,63);
             colorLabels << QColor(177,102,63);
             colorLabels << QColor(238,50,51);
             colorLabels << QColor(191,106,209);
             colorLabels << QColor(118,119,114);
+
+            const QColor noLabelSetColor = qApp->palette().color(QPalette::Highlight);
+            for (auto it = colorLabels.begin(); it != colorLabels.end(); ++it) {
+                KritaUtils::dragColor(&(*it), noLabelSetColor, 0.3);
+            }
         }
     }
 
     static QVector<QColor> colorLabels;
 };
 
 QVector<QColor> KisNodeViewColorScheme::Private::colorLabels;
 
 
 KisNodeViewColorScheme::KisNodeViewColorScheme()
     : m_d(new Private)
 {
 }
 
 KisNodeViewColorScheme::~KisNodeViewColorScheme()
 {
 }
 
 KisNodeViewColorScheme* KisNodeViewColorScheme::instance()
 {
     return s_instance;
 }
 
 QColor KisNodeViewColorScheme::gridColor(const QStyleOptionViewItem &option, QTreeView *view)
 {
     const int gridHint = view->style()->styleHint(QStyle::SH_Table_GridLineColor, &option, view);
     const QColor gridColor = static_cast<QRgb>(gridHint);
     return gridColor;
 }
 
 int KisNodeViewColorScheme::visibilitySize() const
 {
     return 16;
 }
 
 int KisNodeViewColorScheme::visibilityMargin() const
 {
     return 2;
 }
 
 
 int KisNodeViewColorScheme::thumbnailSize() const
 {
     return 20;
 }
 
 int KisNodeViewColorScheme::thumbnailMargin() const
 {
     return 3;
 }
 
 int KisNodeViewColorScheme::decorationSize() const
 {
     return 12;
 }
 
 int KisNodeViewColorScheme::decorationMargin() const
 {
     return 1;
 }
 
 
 int KisNodeViewColorScheme::textMargin() const
 {
     return 2;
 }
 
 
 int KisNodeViewColorScheme::iconSize() const
 {
     return 16;
 }
 
 int KisNodeViewColorScheme::iconMargin() const
 {
     return 1;
 }
 
 int KisNodeViewColorScheme::border() const
 {
     return 1;
 }
 
 int KisNodeViewColorScheme::rowHeight() const
 {
     return border() + 2 * thumbnailMargin() + thumbnailSize();
 }
 
 int KisNodeViewColorScheme::visibilityColumnWidth() const
 {
     return border() +
         2 * visibilityMargin() + visibilitySize() +
         border();
 }
 
 int KisNodeViewColorScheme::indentation() const
 {
     return
         2 * thumbnailMargin() + thumbnailSize() +
         border();
 }
 
 QRect KisNodeViewColorScheme::relThumbnailRect() const
 {
     return QRect(-indentation(),
                  border(),
                  thumbnailSize() + 2 * thumbnailMargin(),
                  thumbnailSize() + 2 * thumbnailMargin());
 }
 
 QRect KisNodeViewColorScheme::relDecorationRect() const
 {
     return QRect(border() + decorationMargin(),
                  border() + decorationMargin(),
                  decorationSize(),
                  decorationSize());
 }
 
 QRect KisNodeViewColorScheme::relExpandButtonRect() const
 {
     const int newY = rowHeight() - decorationMargin() - decorationSize();
     QRect rc = relDecorationRect();
     rc.moveTop(newY);
     return rc;
 }
 
 QColor KisNodeViewColorScheme::colorLabel(int index) const
 {
     /**
      * We should ensure that the index of the overflowing range
      * will never be zero again.
      */
     if (index >= m_d->colorLabels.size()) {
         index = 1 + index % (m_d->colorLabels.size() - 1);
     } else {
         index = index % m_d->colorLabels.size();
     }
 
     return m_d->colorLabels[index];
 }
 
 QVector<QColor> KisNodeViewColorScheme::allColorLabels() const
 {
     return m_d->colorLabels;
 }
diff --git a/libs/ui/kis_png_converter.cpp b/libs/ui/kis_png_converter.cpp
index 3120a00b28..2bf6520a8a 100644
--- a/libs/ui/kis_png_converter.cpp
+++ b/libs/ui/kis_png_converter.cpp
@@ -1,1314 +1,1317 @@
 /*
  *  Copyright (c) 2005-2007 Cyrille Berger <cberger@cberger.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "kis_png_converter.h"
 // A big thank to Glenn Randers-Pehrson for his wonderful
 // documentation of libpng available at
 // http://www.libpng.org/pub/png/libpng-1.2.5-manual.html
 
 #ifndef PNG_MAX_UINT // Removed in libpng 1.4
 #define PNG_MAX_UINT PNG_UINT_31_MAX
 #endif
 
 #include <KoConfig.h> // WORDS_BIGENDIAN
 #include <KoStore.h>
 #include <KoStoreDevice.h>
 
 #include <limits.h>
 #include <stdio.h>
 #include <zlib.h>
 
 #include <QBuffer>
 #include <QFile>
 #include <QApplication>
 
 #include <klocalizedstring.h>
 #include <QUrl>
 
 #include <KoColorSpace.h>
 #include <KoDocumentInfo.h>
 #include <KoID.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorProfile.h>
 #include <KoColor.h>
 #include <KoUnit.h>
 
 #include <kis_config.h>
 #include <kis_painter.h>
 #include <KisDocument.h>
 #include <kis_image.h>
 #include <kis_iterator_ng.h>
 #include <kis_layer.h>
 #include <kis_paint_device.h>
 #include <kis_transaction.h>
 #include <kis_paint_layer.h>
 #include <kis_group_layer.h>
 #include <metadata/kis_meta_data_io_backend.h>
 #include <metadata/kis_meta_data_store.h>
 #include <KoColorModelStandardIds.h>
 #include "dialogs/kis_dlg_png_import.h"
 #include "kis_clipboard.h"
 #include <kis_cursor_override_hijacker.h>
 #include "kis_undo_stores.h"
 
 namespace
 {
 
 
 int getColorTypeforColorSpace(const KoColorSpace * cs , bool alpha)
 {
 
     QString id = cs->id();
 
     if (id == "GRAYA" || id == "GRAYAU16" || id == "GRAYA16") {
         return alpha ? PNG_COLOR_TYPE_GRAY_ALPHA : PNG_COLOR_TYPE_GRAY;
     }
     if (id == "RGBA" || id == "RGBA16") {
         return alpha ? PNG_COLOR_TYPE_RGB_ALPHA : PNG_COLOR_TYPE_RGB;
     }
 
     return -1;
 
 }
 
 bool colorSpaceIdSupported(const QString &id)
 {
     return id == "RGBA" || id == "RGBA16" ||
         id == "GRAYA" || id == "GRAYAU16" || id == "GRAYA16";
 }
 
 QPair<QString, QString> getColorSpaceForColorType(int color_type, int color_nb_bits)
 {
     QPair<QString, QString> r;
 
     if (color_type ==  PNG_COLOR_TYPE_PALETTE) {
         r.first = RGBAColorModelID.id();
         r.second = Integer8BitsColorDepthID.id();
     } else {
         if (color_type == PNG_COLOR_TYPE_GRAY || color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
             r.first = GrayAColorModelID.id();
         } else if (color_type == PNG_COLOR_TYPE_RGB_ALPHA || color_type == PNG_COLOR_TYPE_RGB) {
             r.first = RGBAColorModelID.id();
         }
         if (color_nb_bits == 16) {
             r.second = Integer16BitsColorDepthID.id();
         } else if (color_nb_bits <= 8) {
             r.second = Integer8BitsColorDepthID.id();
         }
     }
     return r;
 }
 
 
 void fillText(png_text* p_text, const char* key, QString& text)
 {
     p_text->compression = PNG_TEXT_COMPRESSION_zTXt;
     p_text->key = const_cast<char *>(key);
     char* textc = new char[text.length()+1];
     strcpy(textc, text.toLatin1());
     p_text->text = textc;
     p_text->text_length = text.length() + 1;
 }
 
 long formatStringList(char *string, const size_t length, const char *format, va_list operands)
 {
     int n = vsnprintf(string, length, format, operands);
 
     if (n < 0)
         string[length-1] = '\0';
 
     return((long) n);
 }
 
 long formatString(char *string, const size_t length, const char *format, ...)
 {
     long n;
 
     va_list operands;
 
     va_start(operands, format);
     n = (long) formatStringList(string, length, format, operands);
     va_end(operands);
     return(n);
 }
 
 void writeRawProfile(png_struct *ping, png_info *ping_info, QString profile_type, QByteArray profile_data)
 {
 
     png_textp      text;
 
     png_uint_32    allocated_length, description_length;
 
     const uchar hex[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
 
     dbgFile << "Writing Raw profile: type=" << profile_type << ", length=" << profile_data.length() << endl;
 
     text               = (png_textp) png_malloc(ping, (png_uint_32) sizeof(png_text));
     description_length = profile_type.length();
     allocated_length   = (png_uint_32)(profile_data.length() * 2 + (profile_data.length() >> 5) + 20 + description_length);
 
     text[0].text   = (png_charp) png_malloc(ping, allocated_length);
 
     QString key = QLatin1Literal("Raw profile type ") + profile_type.toLatin1();
     QByteArray keyData = key.toLatin1();
     text[0].key = keyData.data();
 
     uchar* sp = (uchar*)profile_data.data();
     png_charp dp = text[0].text;
     *dp++ = '\n';
 
     memcpy(dp, profile_type.toLatin1().constData(), profile_type.length());
 
     dp += description_length;
     *dp++ = '\n';
 
     formatString(dp, allocated_length - strlen(text[0].text), "%8lu ", profile_data.length());
 
     dp += 8;
 
     for (long i = 0; i < (long) profile_data.length(); i++) {
         if (i % 36 == 0)
             *dp++ = '\n';
 
         *(dp++) = (char) hex[((*sp >> 4) & 0x0f)];
         *(dp++) = (char) hex[((*sp++) & 0x0f)];
     }
 
     *dp++ = '\n';
     *dp = '\0';
     text[0].text_length = (png_size_t)(dp - text[0].text);
     text[0].compression = -1;
 
     if (text[0].text_length <= allocated_length)
         png_set_text(ping, ping_info, text, 1);
 
     png_free(ping, text[0].text);
     png_free(ping, text);
 }
 
 QByteArray png_read_raw_profile(png_textp text)
 {
     QByteArray profile;
 
     static const unsigned char unhex[103] = {
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 11, 12,
         13, 14, 15
     };
 
     png_charp sp = text[0].text + 1;
     /* look for newline */
     while (*sp != '\n')
         sp++;
     /* look for length */
     while (*sp == '\0' || *sp == ' ' || *sp == '\n')
         sp++;
     png_uint_32 length = (png_uint_32) atol(sp);
     while (*sp != ' ' && *sp != '\n')
         sp++;
     if (length == 0) {
         return profile;
     }
     profile.resize(length);
     /* copy profile, skipping white space and column 1 "=" signs */
     unsigned char *dp = (unsigned char*)profile.data();
     png_uint_32 nibbles = length * 2;
     for (png_uint_32 i = 0; i < nibbles; i++) {
         while (*sp < '0' || (*sp > '9' && *sp < 'a') || *sp > 'f') {
             if (*sp == '\0') {
                 return QByteArray();
             }
             sp++;
         }
         if (i % 2 == 0)
             *dp = (unsigned char)(16 * unhex[(int) *sp++]);
         else
             (*dp++) += unhex[(int) *sp++];
     }
     return profile;
 }
 
 void decode_meta_data(png_textp text, KisMetaData::Store* store, QString type, int headerSize)
 {
     dbgFile << "Decoding " << type << " " << text[0].key;
     KisMetaData::IOBackend* exifIO = KisMetaData::IOBackendRegistry::instance()->value(type);
     Q_ASSERT(exifIO);
 
     QByteArray rawProfile = png_read_raw_profile(text);
     if (headerSize > 0) {
         rawProfile.remove(0, headerSize);
     }
     if (rawProfile.size() > 0) {
         QBuffer buffer;
         buffer.setData(rawProfile);
         exifIO->loadFrom(store, &buffer);
     } else {
         dbgFile << "Decoding failed";
     }
 }
 }
 
 KisPNGConverter::KisPNGConverter(KisDocument *doc, bool batchMode)
 {
     //     Q_ASSERT(doc);
     //     Q_ASSERT(adapter);
 
     m_doc = doc;
     m_stop = false;
     m_max_row = 0;
     m_image = 0;
     m_batchMode = batchMode;
 }
 
 KisPNGConverter::~KisPNGConverter()
 {
 }
 
 class KisPNGReadStream
 {
 public:
     KisPNGReadStream(quint8* buf,  quint32 depth) : m_posinc(8), m_depth(depth), m_buf(buf) {
     }
     int nextValue() {
         if (m_posinc == 0) {
             m_posinc = 8;
             m_buf++;
         }
         m_posinc -= m_depth;
         return (((*m_buf) >> (m_posinc)) & ((1 << m_depth) - 1));
     }
 private:
     quint32 m_posinc, m_depth;
     quint8* m_buf;
 };
 
 class KisPNGWriteStream
 {
 public:
     KisPNGWriteStream(quint8* buf,  quint32 depth) : m_posinc(8), m_depth(depth), m_buf(buf) {
         *m_buf = 0;
     }
     void setNextValue(int v) {
         if (m_posinc == 0) {
             m_posinc = 8;
             m_buf++;
             *m_buf = 0;
         }
         m_posinc -= m_depth;
         *m_buf = (v << m_posinc) | *m_buf;
     }
 private:
     quint32 m_posinc, m_depth;
     quint8* m_buf;
 };
 
 class KisPNGReaderAbstract
 {
 public:
     KisPNGReaderAbstract(png_structp _png_ptr, int _width, int _height) : png_ptr(_png_ptr), width(_width), height(_height) {}
     virtual ~KisPNGReaderAbstract() {}
     virtual png_bytep readLine() = 0;
 protected:
     png_structp png_ptr;
     int width, height;
 };
 
 class KisPNGReaderLineByLine : public KisPNGReaderAbstract
 {
 public:
     KisPNGReaderLineByLine(png_structp _png_ptr, png_infop info_ptr, int _width, int _height) : KisPNGReaderAbstract(_png_ptr, _width, _height) {
         png_uint_32 rowbytes = png_get_rowbytes(png_ptr, info_ptr);
         row_pointer = new png_byte[rowbytes];
     }
     ~KisPNGReaderLineByLine() override {
         delete[] row_pointer;
     }
     png_bytep readLine() override {
         png_read_row(png_ptr, row_pointer, 0);
         return row_pointer;
     }
 private:
     png_bytep row_pointer;
 };
 
 class KisPNGReaderFullImage : public KisPNGReaderAbstract
 {
 public:
     KisPNGReaderFullImage(png_structp _png_ptr, png_infop info_ptr, int _width, int _height) : KisPNGReaderAbstract(_png_ptr, _width, _height), y(0) {
         row_pointers = new png_bytep[height];
         png_uint_32 rowbytes = png_get_rowbytes(png_ptr, info_ptr);
         for (int i = 0; i < height; i++) {
             row_pointers[i] = new png_byte[rowbytes];
         }
         png_read_image(png_ptr, row_pointers);
     }
     ~KisPNGReaderFullImage() override {
         for (int i = 0; i < height; i++) {
             delete[] row_pointers[i];
         }
         delete[] row_pointers;
     }
     png_bytep readLine() override {
         return row_pointers[y++];
     }
 private:
     png_bytepp row_pointers;
     int y;
 };
 
 
 static
 void _read_fn(png_structp png_ptr, png_bytep data, png_size_t length)
 {
     QIODevice *in = (QIODevice *)png_get_io_ptr(png_ptr);
 
     while (length) {
         int nr = in->read((char*)data, length);
         if (nr <= 0) {
             png_error(png_ptr, "Read Error");
             return;
         }
         length -= nr;
     }
 }
 
 static
 void _write_fn(png_structp png_ptr, png_bytep data, png_size_t length)
 {
     QIODevice* out = (QIODevice*)png_get_io_ptr(png_ptr);
 
     uint nr = out->write((char*)data, length);
     if (nr != length) {
         png_error(png_ptr, "Write Error");
         return;
     }
 }
 
 static
 void _flush_fn(png_structp png_ptr)
 {
     Q_UNUSED(png_ptr);
 }
 
 
 KisImageBuilder_Result KisPNGConverter::buildImage(QIODevice* iod)
 {
     dbgFile << "Start decoding PNG File";
 
     png_byte signature[8];
     iod->peek((char*)signature, 8);
 
 #if PNG_LIBPNG_VER < 10400
     if (!png_check_sig(signature, 8)) {
 #else
     if (png_sig_cmp(signature, 0, 8) != 0) {
 #endif
         iod->close();
         return (KisImageBuilder_RESULT_BAD_FETCH);
     }
 
     // Initialize the internal structures
     png_structp png_ptr =  png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
     if (!png_ptr) {
         iod->close();
     }
 
     png_infop info_ptr = png_create_info_struct(png_ptr);
     if (!info_ptr) {
         png_destroy_read_struct(&png_ptr, (png_infopp)0, (png_infopp)0);
         iod->close();
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
     png_infop end_info = png_create_info_struct(png_ptr);
     if (!end_info) {
         png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)0);
         iod->close();
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
     // Catch errors
     if (setjmp(png_jmpbuf(png_ptr))) {
         png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
         iod->close();
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
     // Initialize the special
     png_set_read_fn(png_ptr, iod, _read_fn);
 
 #if defined(PNG_SKIP_sRGB_CHECK_PROFILE) && defined(PNG_SET_OPTION_SUPPORTED)
     png_set_option(png_ptr, PNG_SKIP_sRGB_CHECK_PROFILE, PNG_OPTION_ON);
 #endif
 
     // read all PNG info up to image data
     png_read_info(png_ptr, info_ptr);
 
 
     if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_GRAY && png_get_bit_depth(png_ptr, info_ptr) < 8) {
         png_set_expand(png_ptr);
     }
 
     if (png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_PALETTE && png_get_bit_depth(png_ptr, info_ptr) < 8) {
         png_set_packing(png_ptr);
     }
 
 
     if (png_get_color_type(png_ptr, info_ptr) != PNG_COLOR_TYPE_PALETTE &&
             (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))) {
         png_set_expand(png_ptr);
     }
     png_read_update_info(png_ptr, info_ptr);
 
     // Read information about the png
     png_uint_32 width, height;
     int color_nb_bits, color_type, interlace_type;
     png_get_IHDR(png_ptr, info_ptr, &width, &height, &color_nb_bits, &color_type, &interlace_type, 0, 0);
     dbgFile << "width = " << width << " height = " << height << " color_nb_bits = " << color_nb_bits << " color_type = " << color_type << " interlace_type = " << interlace_type << endl;
     // swap byteorder on little endian machines.
 #ifndef WORDS_BIGENDIAN
     if (color_nb_bits > 8)
         png_set_swap(png_ptr);
 #endif
 
     // Determine the colorspace
     QPair<QString, QString> csName = getColorSpaceForColorType(color_type, color_nb_bits);
     if (csName.first.isEmpty()) {
         png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
         iod->close();
         return KisImageBuilder_RESULT_UNSUPPORTED_COLORSPACE;
     }
     bool hasalpha = (color_type == PNG_COLOR_TYPE_RGB_ALPHA || color_type == PNG_COLOR_TYPE_GRAY_ALPHA);
 
     // Read image profile
     png_charp profile_name;
 #if PNG_LIBPNG_VER_MAJOR >= 1 && PNG_LIBPNG_VER_MINOR >= 5
     png_bytep profile_data;
 #else
     png_charp profile_data;
 #endif
     int compression_type;
     png_uint_32 proflen;
 
     // Get the various optional chunks
 
     // https://www.w3.org/TR/PNG/#11cHRM
 #if defined(PNG_cHRM_SUPPORTED)
     double whitePointX, whitePointY;
     double redX, redY;
     double greenX, greenY;
     double blueX, blueY;
     png_get_cHRM(png_ptr,info_ptr, &whitePointX, &whitePointY, &redX, &redY, &greenX, &greenY, &blueX, &blueY);
     dbgFile << "cHRM:" << whitePointX << whitePointY << redX << redY << greenX << greenY << blueX << blueY;
 #endif
 
     // https://www.w3.org/TR/PNG/#11gAMA
 #if defined(PNG_GAMMA_SUPPORTED)
     double gamma;
     png_get_gAMA(png_ptr, info_ptr, &gamma);
     dbgFile << "gAMA" << gamma;
 #endif
 
     // https://www.w3.org/TR/PNG/#11sRGB
 #if defined(PNG_sRGB_SUPPORTED)
     int sRGBIntent;
     png_get_sRGB(png_ptr, info_ptr, &sRGBIntent);
     dbgFile << "sRGB" << sRGBIntent;
 #endif
 
     bool fromBlender = false;
 
     png_text* text_ptr;
     int num_comments;
     png_get_text(png_ptr, info_ptr, &text_ptr, &num_comments);
 
     for (int i = 0; i < num_comments; i++) {
         QString key = QString(text_ptr[i].key).toLower();
         if (key == "file") {
             QString relatedFile = text_ptr[i].text;
             if (relatedFile.contains(".blend", Qt::CaseInsensitive)){
                 fromBlender=true;
             }
         }
     }
 
     const KoColorProfile* profile = 0;
     if (png_get_iCCP(png_ptr, info_ptr, &profile_name, &compression_type, &profile_data, &proflen)) {
         QByteArray profile_rawdata;
         // XXX: Hardcoded for icc type -- is that correct for us?
         profile_rawdata.resize(proflen);
         memcpy(profile_rawdata.data(), profile_data, proflen);
         profile = KoColorSpaceRegistry::instance()->createColorProfile(csName.first, csName.second, profile_rawdata);
         Q_CHECK_PTR(profile);
         if (profile) {
             //                 dbgFile << "profile name: " << profile->productName() << " profile description: " << profile->productDescription() << " information sur le produit: " << profile->productInfo();
             if (!profile->isSuitableForOutput()) {
                 dbgFile << "the profile is not suitable for output and therefore cannot be used in krita, we need to convert the image to a standard profile"; // TODO: in ko2 popup a selection menu to inform the user
             }
         }
     }
     else {
         dbgFile << "no embedded profile, will use the default profile";
         if (color_nb_bits == 16 && !fromBlender && !qAppName().toLower().contains("test") && !m_batchMode) {
             KisConfig cfg(true);
             quint32 behaviour = cfg.pasteBehaviour();
             if (behaviour == PASTE_ASK) {
                 KisDlgPngImport dlg(m_path, csName.first, csName.second);
                 KisCursorOverrideHijacker hijacker;
                 Q_UNUSED(hijacker);
                 dlg.exec();
                 if (!dlg.profile().isEmpty()) {
                     profile = KoColorSpaceRegistry::instance()->profileByName(dlg.profile());
                 }
 
             }
         }
         dbgFile << "no embedded profile, will use the default profile";
     }
 
     const QString colorSpaceId =
         KoColorSpaceRegistry::instance()->colorSpaceId(csName.first, csName.second);
 
     // Check that the profile is used by the color space
     if (profile && !KoColorSpaceRegistry::instance()->profileIsCompatible(profile, colorSpaceId)) {
         warnFile << "The profile " << profile->name() << " is not compatible with the color space model " << csName.first << " " << csName.second;
         profile = 0;
     }
 
     // Retrieve a pointer to the colorspace
     const KoColorSpace* cs;
     if (profile && profile->isSuitableForOutput()) {
         dbgFile << "image has embedded profile: " << profile->name() << "\n";
         cs = KoColorSpaceRegistry::instance()->colorSpace(csName.first, csName.second, profile);
     }
     else {
         if (csName.first == RGBAColorModelID.id()) {
             cs = KoColorSpaceRegistry::instance()->colorSpace(csName.first, csName.second, "sRGB-elle-V2-srgbtrc.icc");
         } else if (csName.first == GrayAColorModelID.id()) {
             cs = KoColorSpaceRegistry::instance()->colorSpace(csName.first, csName.second, "Gray-D50-elle-V2-srgbtrc.icc");
         } else {
             cs = KoColorSpaceRegistry::instance()->colorSpace(csName.first, csName.second, 0);
         }
     }
 
     if (cs == 0) {
         png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
         return KisImageBuilder_RESULT_UNSUPPORTED_COLORSPACE;
     }
     //TODO: two fixes : one tell the user about the problem and ask for a solution, and two once the kocolorspace include KoColorTransformation, use that instead of hacking a lcms transformation
     // Create the cmsTransform if needed
     KoColorTransformation* transform = 0;
     if (profile && !profile->isSuitableForOutput()) {
         transform = KoColorSpaceRegistry::instance()->colorSpace(csName.first, csName.second, profile)->createColorConverter(cs, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
     }
 
     // Creating the KisImageSP
     if (m_image == 0) {
         KisUndoStore *store = m_doc ? m_doc->createUndoStore() : new KisSurrogateUndoStore();
         m_image = new KisImage(store, width, height, cs, "built image");
     }
 
     // Read resolution
     int unit_type;
     png_uint_32 x_resolution, y_resolution;
 
     png_get_pHYs(png_ptr, info_ptr, &x_resolution, &y_resolution, &unit_type);
     if (x_resolution > 0 && y_resolution > 0 && unit_type == PNG_RESOLUTION_METER) {
         m_image->setResolution((double) POINT_TO_CM(x_resolution) / 100.0, (double) POINT_TO_CM(y_resolution) / 100.0); // It is the "invert" macro because we convert from pointer-per-inchs to points
     }
 
     double coeff = quint8_MAX / (double)(pow((double)2, color_nb_bits) - 1);
     KisPaintLayerSP layer = new KisPaintLayer(m_image.data(), m_image -> nextLayerName(), UCHAR_MAX);
 
     // Read comments/texts...
     png_get_text(png_ptr, info_ptr, &text_ptr, &num_comments);
     if (m_doc) {
         KoDocumentInfo * info = m_doc->documentInfo();
         dbgFile << "There are " << num_comments << " comments in the text";
         for (int i = 0; i < num_comments; i++) {
             QString key = QString(text_ptr[i].key).toLower();
             dbgFile << "key: " << text_ptr[i].key
                     << ", containing: " << text_ptr[i].text
                     << ": " << (key == "raw profile type exif " ? "isExif" : "something else");
             if (key == "title") {
                 info->setAboutInfo("title", text_ptr[i].text);
             } else if (key == "description") {
                 info->setAboutInfo("comment", text_ptr[i].text);
             } else if (key == "author") {
                 info->setAuthorInfo("creator", text_ptr[i].text);
             } else if (key.contains("raw profile type exif")) {
                 decode_meta_data(text_ptr + i, layer->metaData(), "exif", 6);
             } else if (key.contains("raw profile type iptc")) {
                 decode_meta_data(text_ptr + i, layer->metaData(), "iptc", 14);
             } else if (key.contains("raw profile type xmp")) {
                 decode_meta_data(text_ptr + i, layer->metaData(), "xmp", 0);
             } else if (key == "version") {
                 m_image->addAnnotation(new KisAnnotation("kpp_version", "version", QByteArray(text_ptr[i].text)));
             } else if (key == "preset") {
                 m_image->addAnnotation(new KisAnnotation("kpp_preset", "preset", QByteArray(text_ptr[i].text)));
             }
         }
     }
     // Read image data
     QScopedPointer<KisPNGReaderAbstract> reader;
     try {
         if (interlace_type == PNG_INTERLACE_ADAM7) {
             reader.reset(new KisPNGReaderFullImage(png_ptr, info_ptr, width, height));
         } else {
             reader.reset(new KisPNGReaderLineByLine(png_ptr, info_ptr, width, height));
         }
-    } catch (std::bad_alloc& e) {
+    } catch (const std::bad_alloc& e) {
         // new png_byte[] may raise such an exception if the image
         // is invalid / to large.
         dbgFile << "bad alloc: " << e.what();
         // Free only the already allocated png_byte instances.
         png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
     // Read the palette if the file is indexed
     png_colorp palette ;
     int num_palette;
     if (color_type == PNG_COLOR_TYPE_PALETTE) {
         png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette);
     }
 
     // Read the transparency palette
     quint8 palette_alpha[256];
     memset(palette_alpha, 255, 256);
     if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
         if (color_type == PNG_COLOR_TYPE_PALETTE) {
             png_bytep alpha_ptr;
             int num_alpha;
             png_get_tRNS(png_ptr, info_ptr, &alpha_ptr, &num_alpha, 0);
             for (int i = 0; i < num_alpha; ++i) {
                 palette_alpha[i] = alpha_ptr[i];
             }
         }
     }
 
     for (png_uint_32 y = 0; y < height; y++) {
         KisHLineIteratorSP it = layer -> paintDevice() -> createHLineIteratorNG(0, y, width);
 
         png_bytep row_pointer = reader->readLine();
 
         switch (color_type) {
         case PNG_COLOR_TYPE_GRAY:
         case PNG_COLOR_TYPE_GRAY_ALPHA:
             if (color_nb_bits == 16) {
                 quint16 *src = reinterpret_cast<quint16 *>(row_pointer);
                 do {
                     quint16 *d = reinterpret_cast<quint16 *>(it->rawData());
                     d[0] = *(src++);
                     if (transform) transform->transform(reinterpret_cast<quint8*>(d), reinterpret_cast<quint8*>(d), 1);
                     if (hasalpha) {
                         d[1] = *(src++);
                     } else {
                         d[1] = quint16_MAX;
                     }
                 } while (it->nextPixel());
             } else  {
                 KisPNGReadStream stream(row_pointer, color_nb_bits);
                 do {
                     quint8 *d = it->rawData();
                     d[0] = (quint8)(stream.nextValue() * coeff);
                     if (transform) transform->transform(d, d, 1);
                     if (hasalpha) {
                         d[1] = (quint8)(stream.nextValue() * coeff);
                     } else {
                         d[1] = UCHAR_MAX;
                     }
                 } while (it->nextPixel());
             }
             // FIXME:should be able to read 1 and 4 bits depth and scale them to 8 bits"
             break;
         case PNG_COLOR_TYPE_RGB:
         case PNG_COLOR_TYPE_RGB_ALPHA:
             if (color_nb_bits == 16) {
                 quint16 *src = reinterpret_cast<quint16 *>(row_pointer);
                 do {
                     quint16 *d = reinterpret_cast<quint16 *>(it->rawData());
                     d[2] = *(src++);
                     d[1] = *(src++);
                     d[0] = *(src++);
                     if (transform) transform->transform(reinterpret_cast<quint8 *>(d), reinterpret_cast<quint8*>(d), 1);
                     if (hasalpha) d[3] = *(src++);
                     else d[3] = quint16_MAX;
                 } while (it->nextPixel());
             } else {
                 KisPNGReadStream stream(row_pointer, color_nb_bits);
                 do {
                     quint8 *d = it->rawData();
                     d[2] = (quint8)(stream.nextValue() * coeff);
                     d[1] = (quint8)(stream.nextValue() * coeff);
                     d[0] = (quint8)(stream.nextValue() * coeff);
                     if (transform) transform->transform(d, d, 1);
                     if (hasalpha) d[3] = (quint8)(stream.nextValue() * coeff);
                     else d[3] = UCHAR_MAX;
                 } while (it->nextPixel());
             }
             break;
         case PNG_COLOR_TYPE_PALETTE: {
             KisPNGReadStream stream(row_pointer, color_nb_bits);
             do {
                 quint8 *d = it->rawData();
                 quint8 index = stream.nextValue();
                 quint8 alpha = palette_alpha[ index ];
                 if (alpha == 0) {
                     memset(d, 0, 4);
                 } else {
                     png_color c = palette[ index ];
                     d[2] = c.red;
                     d[1] = c.green;
                     d[0] = c.blue;
                     d[3] = alpha;
                 }
             } while (it->nextPixel());
         }
             break;
         default:
             return KisImageBuilder_RESULT_UNSUPPORTED;
         }
     }
     m_image->addNode(layer.data(), m_image->rootLayer().data());
 
     png_read_end(png_ptr, end_info);
     iod->close();
 
     // Freeing memory
     png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
     return KisImageBuilder_RESULT_OK;
 
 }
 
 KisImageBuilder_Result KisPNGConverter::buildImage(const QString &filename)
 {
     m_path = filename;
 
     QFile fp(filename);
     if (fp.exists()) {
         if (!fp.open(QIODevice::ReadOnly)) {
             dbgFile << "Failed to open PNG File";
             return (KisImageBuilder_RESULT_FAILURE);
         }
 
         return buildImage(&fp);
     }
     return (KisImageBuilder_RESULT_NOT_EXIST);
 
 }
 
 
 KisImageSP KisPNGConverter::image()
 {
     return m_image;
 }
 
 bool KisPNGConverter::saveDeviceToStore(const QString &filename, const QRect &imageRect, const qreal xRes, const qreal yRes, KisPaintDeviceSP dev, KoStore *store, KisMetaData::Store* metaData)
 {
     if (store->open(filename)) {
         KoStoreDevice io(store);
         if (!io.open(QIODevice::WriteOnly)) {
             dbgFile << "Could not open for writing:" << filename;
             return false;
         }
         KisPNGConverter pngconv(0);
         vKisAnnotationSP_it annotIt = 0;
         KisMetaData::Store* metaDataStore = 0;
         if (metaData) {
             metaDataStore = new KisMetaData::Store(*metaData);
         }
         KisPNGOptions options;
         options.compression = 0;
         options.interlace = false;
         options.tryToSaveAsIndexed = false;
         options.alpha = true;
         options.saveSRGBProfile = false;
 
         if (dev->colorSpace()->id() != "RGBA") {
             dev = new KisPaintDevice(*dev.data());
             KUndo2Command *cmd = dev->convertTo(KoColorSpaceRegistry::instance()->rgb8());
             delete cmd;
         }
 
         bool success = pngconv.buildFile(&io, imageRect, xRes, yRes, dev, annotIt, annotIt, options, metaDataStore);
         if (success != KisImageBuilder_RESULT_OK) {
             dbgFile << "Saving PNG failed:" << filename;
             delete metaDataStore;
             return false;
         }
         delete metaDataStore;
         io.close();
         if (!store->close()) {
             return false;
         }
     } else {
         dbgFile << "Opening of data file failed :" << filename;
         return false;
     }
     return true;
 
 }
 
 
 KisImageBuilder_Result KisPNGConverter::buildFile(const QString &filename, const QRect &imageRect, const qreal xRes, const qreal yRes, KisPaintDeviceSP device, vKisAnnotationSP_it annotationsStart, vKisAnnotationSP_it annotationsEnd, KisPNGOptions options, KisMetaData::Store* metaData)
 {
     dbgFile << "Start writing PNG File " << filename;
     // Open a QIODevice for writing
     QFile fp (filename);
     if (!fp.open(QIODevice::WriteOnly)) {
         dbgFile << "Failed to open PNG File for writing";
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
     KisImageBuilder_Result result = buildFile(&fp, imageRect, xRes, yRes, device, annotationsStart, annotationsEnd, options, metaData);
 
     return result;
 }
 
 KisImageBuilder_Result KisPNGConverter::buildFile(QIODevice* iodevice, const QRect &imageRect, const qreal xRes, const qreal yRes, KisPaintDeviceSP device, vKisAnnotationSP_it annotationsStart, vKisAnnotationSP_it annotationsEnd, KisPNGOptions options, KisMetaData::Store* metaData)
 {
     if (!device)
         return KisImageBuilder_RESULT_INVALID_ARG;
 
     if (!options.alpha) {
         KisPaintDeviceSP tmp = new KisPaintDevice(device->colorSpace());
         KoColor c(options.transparencyFillColor, device->colorSpace());
         tmp->fill(imageRect, c);
         KisPainter gc(tmp);
         gc.bitBlt(imageRect.topLeft(), device, imageRect);
         gc.end();
         device = tmp;
     }
 
     if (device->colorSpace()->colorDepthId() == Float16BitsColorDepthID
             || device->colorSpace()->colorDepthId() == Float32BitsColorDepthID
             || device->colorSpace()->colorDepthId() == Float64BitsColorDepthID) {
         const KoColorSpace *dstcs = KoColorSpaceRegistry::instance()->colorSpace(device->colorSpace()->colorModelId().id(), Integer16BitsColorDepthID.id(), device->colorSpace()->profile());
         KisPaintDeviceSP tmp = new KisPaintDevice(dstcs);
         KisPainter gc(tmp);
         gc.bitBlt(imageRect.topLeft(), device, imageRect);
         gc.end();
         device = tmp;
     }
 
     if (options.forceSRGB) {
         const KoColorSpace* cs = KoColorSpaceRegistry::instance()->colorSpace(RGBAColorModelID.id(), device->colorSpace()->colorDepthId().id(), "sRGB built-in - (lcms internal)");
         device = new KisPaintDevice(*device);
         KUndo2Command *cmd = device->convertTo(cs);
         delete cmd;
     }
 
     // Initialize structures
     png_structp png_ptr =  png_create_write_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
     if (!png_ptr) {
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
 #if defined(PNG_SKIP_sRGB_CHECK_PROFILE) && defined(PNG_SET_OPTION_SUPPORTED)
     png_set_option(png_ptr, PNG_SKIP_sRGB_CHECK_PROFILE, PNG_OPTION_ON);
 #endif
 
 
 #ifdef PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED
     png_set_check_for_invalid_index(png_ptr, 0);
 #endif
 
     png_infop info_ptr = png_create_info_struct(png_ptr);
     if (!info_ptr) {
         png_destroy_write_struct(&png_ptr, (png_infopp)0);
         return (KisImageBuilder_RESULT_FAILURE);
     }
 
     // If an error occurs during writing, libpng will jump here
     if (setjmp(png_jmpbuf(png_ptr))) {
         png_destroy_write_struct(&png_ptr, &info_ptr);
         return (KisImageBuilder_RESULT_FAILURE);
     }
     // Initialize the writing
     //     png_init_io(png_ptr, fp);
     // Setup the progress function
     // XXX: Implement progress updating -- png_set_write_status_fn(png_ptr, progress);"
     //     setProgressTotalSteps(100/*height*/);
 
     /* set the zlib compression level */
     png_set_compression_level(png_ptr, options.compression);
 
     png_set_write_fn(png_ptr, (void*)iodevice, _write_fn, _flush_fn);
 
     /* set other zlib parameters */
     png_set_compression_mem_level(png_ptr, 8);
     png_set_compression_strategy(png_ptr, Z_DEFAULT_STRATEGY);
     png_set_compression_window_bits(png_ptr, 15);
     png_set_compression_method(png_ptr, 8);
     png_set_compression_buffer_size(png_ptr, 8192);
 
     int color_nb_bits = 8 * device->pixelSize() / device->channelCount();
     int color_type = getColorTypeforColorSpace(device->colorSpace(), options.alpha);
 
     Q_ASSERT(color_type > -1);
 
     // Try to compute a table of color if the colorspace is RGB8f
     QScopedArrayPointer<png_color> palette;
     int num_palette = 0;
     if (!options.alpha && options.tryToSaveAsIndexed && KoID(device->colorSpace()->id()) == KoID("RGBA")) { // png doesn't handle indexed images and alpha, and only have indexed for RGB8
         palette.reset(new png_color[255]);
 
         KisSequentialIterator it(device, imageRect);
 
         bool toomuchcolor = false;
         while (it.nextPixel()) {
             const quint8* c = it.oldRawData();
             bool findit = false;
             for (int i = 0; i < num_palette; i++) {
                 if (palette[i].red == c[2] &&
                         palette[i].green == c[1] &&
                         palette[i].blue == c[0]) {
                     findit = true;
                     break;
                 }
             }
             if (!findit) {
                 if (num_palette == 255) {
                     toomuchcolor = true;
                     break;
                 }
                 palette[num_palette].red = c[2];
                 palette[num_palette].green = c[1];
                 palette[num_palette].blue = c[0];
                 num_palette++;
             }
         }
 
         if (!toomuchcolor) {
             dbgFile << "Found a palette of " << num_palette << " colors";
             color_type = PNG_COLOR_TYPE_PALETTE;
             if (num_palette <= 2) {
                 color_nb_bits = 1;
             } else if (num_palette <= 4) {
                 color_nb_bits = 2;
             } else if (num_palette <= 16) {
                 color_nb_bits = 4;
             } else {
                 color_nb_bits = 8;
             }
         } else {
             palette.reset();
         }
     }
 
     int interlacetype = options.interlace ? PNG_INTERLACE_ADAM7 : PNG_INTERLACE_NONE;
 
     png_set_IHDR(png_ptr, info_ptr,
                  imageRect.width(),
                  imageRect.height(),
                  color_nb_bits,
                  color_type, interlacetype,
                  PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
 
     // set sRGB only if the profile is sRGB  -- http://www.w3.org/TR/PNG/#11sRGB says sRGB and iCCP should not both be present
 
     bool sRGB = device->colorSpace()->profile()->name().contains(QLatin1String("srgb"), Qt::CaseInsensitive);
     /*
      * This automatically writes the correct gamma and chroma chunks along with the sRGB chunk, but firefox's
      * color management is bugged, so once you give it any incentive to start color managing an sRGB image it
      * will turn, for example, a nice desaturated rusty red into bright poppy red. So this is disabled for now.
      */
     /*if (!options.saveSRGBProfile && sRGB) {
         png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr, PNG_sRGB_INTENT_PERCEPTUAL);
     }*/
 
 
     // we should ensure we don't access non-existing palette object
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(palette || color_type != PNG_COLOR_TYPE_PALETTE, KisImageBuilder_RESULT_FAILURE);
 
     // set the palette
     if (color_type == PNG_COLOR_TYPE_PALETTE) {
         png_set_PLTE(png_ptr, info_ptr, palette.data(), num_palette);
     }
     // Save annotation
     vKisAnnotationSP_it it = annotationsStart;
     while (it != annotationsEnd) {
         if (!(*it) || (*it)->type().isEmpty()) {
             dbgFile << "Warning: empty annotation";
             it++;
             continue;
         }
 
         dbgFile << "Trying to store annotation of type " << (*it) -> type() << " of size " << (*it) -> annotation() . size();
 
         if ((*it) -> type().startsWith(QString("krita_attribute:"))) { //
             // Attribute
             // XXX: it should be possible to save krita_attributes in the \"CHUNKs\""
             dbgFile << "cannot save this annotation : " << (*it) -> type();
         } else if ((*it)->type() == "kpp_version" || (*it)->type() == "kpp_preset" ) {
             dbgFile << "Saving preset information " << (*it)->description();
             png_textp      text = (png_textp) png_malloc(png_ptr, (png_uint_32) sizeof(png_text));
 
             QByteArray keyData = (*it)->description().toLatin1();
             text[0].key = keyData.data();
             text[0].text = (char*)(*it)->annotation().data();
             text[0].text_length = (*it)->annotation().size();
             text[0].compression = -1;
 
             png_set_text(png_ptr, info_ptr, text, 1);
             png_free(png_ptr, text);
         }
         it++;
     }
 
     // Save the color profile
     const KoColorProfile* colorProfile = device->colorSpace()->profile();
     QByteArray colorProfileData = colorProfile->rawData();
     if (!sRGB || options.saveSRGBProfile) {
+
 #if PNG_LIBPNG_VER_MAJOR >= 1 && PNG_LIBPNG_VER_MINOR >= 5
-        png_set_iCCP(png_ptr, info_ptr, (char*)"icc", PNG_COMPRESSION_TYPE_BASE, (const png_bytep)colorProfileData.constData(), colorProfileData . size());
+        png_set_iCCP(png_ptr, info_ptr, (png_const_charp)"icc", PNG_COMPRESSION_TYPE_BASE, (png_const_bytep)colorProfileData.constData(), colorProfileData . size());
 #else
-        png_set_iCCP(png_ptr, info_ptr, (char*)"icc", PNG_COMPRESSION_TYPE_BASE, (char*)colorProfileData.constData(), colorProfileData . size());
+        // older version of libpng has a problem with constness on the parameters
+        char typeString[] = "icc";
+        png_set_iCCP(png_ptr, info_ptr, typeString, PNG_COMPRESSION_TYPE_BASE, colorProfileData.data(), colorProfileData . size());
 #endif
     }
 
     // save comments from the document information
     // warning: according to the official png spec, the keys need to be capitalized!
     if (m_doc) {
         png_text texts[4];
         int nbtexts = 0;
         KoDocumentInfo * info = m_doc->documentInfo();
         QString title = info->aboutInfo("title");
         if (!title.isEmpty() && options.storeMetaData) {
             fillText(texts + nbtexts, "Title", title);
             nbtexts++;
         }
         QString abstract = info->aboutInfo("subject");
         if (abstract.isEmpty()) {
             abstract = info->aboutInfo("abstract");
         }
         if (!abstract.isEmpty() && options.storeMetaData) {
             QString keywords = info->aboutInfo("keyword");
             if (!keywords.isEmpty()) {
                 abstract = abstract + " keywords: " + keywords;
             }
             fillText(texts + nbtexts, "Description", abstract);
             nbtexts++;
         }
 
         QString license = info->aboutInfo("license");
         if (!license.isEmpty() && options.storeMetaData) {
             fillText(texts + nbtexts, "Copyright", license);
             nbtexts++;
         }
 
         QString author = info->authorInfo("creator");
         if (!author.isEmpty() && options.storeAuthor) {
             if (!info->authorContactInfo().isEmpty()) {
                 QString contact = info->authorContactInfo().at(0);
                 if (!contact.isEmpty()) {
                     author = author+"("+contact+")";
                 }
             }
             fillText(texts + nbtexts, "Author", author);
             nbtexts++;
         }
 
         png_set_text(png_ptr, info_ptr, texts, nbtexts);
     }
 
     // Save metadata following imagemagick way
 
     // Save exif
     if (metaData && !metaData->empty()) {
         if (options.exif) {
             dbgFile << "Trying to save exif information";
 
             KisMetaData::IOBackend* exifIO = KisMetaData::IOBackendRegistry::instance()->value("exif");
             Q_ASSERT(exifIO);
 
             QBuffer buffer;
             exifIO->saveTo(metaData, &buffer, KisMetaData::IOBackend::JpegHeader);
             writeRawProfile(png_ptr, info_ptr, "exif", buffer.data());
         }
         // Save IPTC
         if (options.iptc) {
             dbgFile << "Trying to save exif information";
             KisMetaData::IOBackend* iptcIO = KisMetaData::IOBackendRegistry::instance()->value("iptc");
             Q_ASSERT(iptcIO);
 
             QBuffer buffer;
             iptcIO->saveTo(metaData, &buffer, KisMetaData::IOBackend::JpegHeader);
 
             dbgFile << "IPTC information size is" << buffer.data().size();
             writeRawProfile(png_ptr, info_ptr, "iptc", buffer.data());
         }
         // Save XMP
         if (options.xmp) {
             dbgFile << "Trying to save XMP information";
             KisMetaData::IOBackend* xmpIO = KisMetaData::IOBackendRegistry::instance()->value("xmp");
             Q_ASSERT(xmpIO);
 
             QBuffer buffer;
             xmpIO->saveTo(metaData, &buffer, KisMetaData::IOBackend::NoHeader);
 
             dbgFile << "XMP information size is" << buffer.data().size();
             writeRawProfile(png_ptr, info_ptr, "xmp", buffer.data());
         }
     }
 #if 0 // Unimplemented?
     // Save resolution
     int unit_type;
     png_uint_32 x_resolution, y_resolution;
 #endif
     png_set_pHYs(png_ptr, info_ptr, CM_TO_POINT(xRes) * 100.0, CM_TO_POINT(yRes) * 100.0, PNG_RESOLUTION_METER); // It is the "invert" macro because we convert from pointer-per-inchs to points
 
     // Save the information to the file
     png_write_info(png_ptr, info_ptr);
     png_write_flush(png_ptr);
 
     // swap byteorder on little endian machines.
 #ifndef WORDS_BIGENDIAN
     if (color_nb_bits > 8)
         png_set_swap(png_ptr);
 #endif
 
     // Write the PNG
     //     png_write_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, 0);
 
     struct RowPointersStruct {
         RowPointersStruct(const QSize &size, int pixelSize)
             : numRows(size.height())
         {
             rows = new png_byte*[numRows];
 
             for (int i = 0; i < numRows; i++) {
                 rows[i] = new png_byte[size.width() * pixelSize];
             }
         }
 
         ~RowPointersStruct() {
             for (int i = 0; i < numRows; i++) {
                 delete[] rows[i];
             }
             delete[] rows;
         }
 
         const int numRows = 0;
         png_byte** rows = 0;
     };
 
 
     // Fill the data structure
     RowPointersStruct rowPointers(imageRect.size(), device->pixelSize());
 
     int row = 0;
     for (int y = imageRect.y(); y < imageRect.y() + imageRect.height(); y++, row++) {
         KisHLineConstIteratorSP it = device->createHLineConstIteratorNG(imageRect.x(), y, imageRect.width());
 
         switch (color_type) {
         case PNG_COLOR_TYPE_GRAY:
         case PNG_COLOR_TYPE_GRAY_ALPHA:
             if (color_nb_bits == 16) {
                 quint16 *dst = reinterpret_cast<quint16 *>(rowPointers.rows[row]);
                 do {
                     const quint16 *d = reinterpret_cast<const quint16 *>(it->oldRawData());
                     *(dst++) = d[0];
                     if (options.alpha) *(dst++) = d[1];
                 } while (it->nextPixel());
             } else {
                 quint8 *dst = rowPointers.rows[row];
                 do {
                     const quint8 *d = it->oldRawData();
                     *(dst++) = d[0];
                     if (options.alpha) *(dst++) = d[1];
                 } while (it->nextPixel());
             }
             break;
         case PNG_COLOR_TYPE_RGB:
         case PNG_COLOR_TYPE_RGB_ALPHA:
             if (color_nb_bits == 16) {
                 quint16 *dst = reinterpret_cast<quint16 *>(rowPointers.rows[row]);
                 do {
                     const quint16 *d = reinterpret_cast<const quint16 *>(it->oldRawData());
                     *(dst++) = d[2];
                     *(dst++) = d[1];
                     *(dst++) = d[0];
                     if (options.alpha) *(dst++) = d[3];
                 } while (it->nextPixel());
             } else {
                 quint8 *dst = rowPointers.rows[row];
                 do {
                     const quint8 *d = it->oldRawData();
                     *(dst++) = d[2];
                     *(dst++) = d[1];
                     *(dst++) = d[0];
                     if (options.alpha) *(dst++) = d[3];
                 } while (it->nextPixel());
             }
             break;
         case PNG_COLOR_TYPE_PALETTE: {
             quint8 *dst = rowPointers.rows[row];
             KisPNGWriteStream writestream(dst, color_nb_bits);
             do {
                 const quint8 *d = it->oldRawData();
                 int i;
                 for (i = 0; i < num_palette; i++) {
                     if (palette[i].red == d[2] &&
                             palette[i].green == d[1] &&
                             palette[i].blue == d[0]) {
                         break;
                     }
                 }
                 writestream.setNextValue(i);
             } while (it->nextPixel());
         }
             break;
         default:
             return KisImageBuilder_RESULT_UNSUPPORTED;
         }
     }
 
     png_write_image(png_ptr, rowPointers.rows);
 
     // Writing is over
     png_write_end(png_ptr, info_ptr);
 
     // Free memory
     png_destroy_write_struct(&png_ptr, &info_ptr);
     return KisImageBuilder_RESULT_OK;
 }
 
 
 void KisPNGConverter::cancel()
 {
     m_stop = true;
 }
 
 void KisPNGConverter::progress(png_structp png_ptr, png_uint_32 row_number, int pass)
 {
     if (png_ptr == 0 || row_number > PNG_MAX_UINT || pass > 7) return;
     //     setProgress(row_number);
 }
 
 bool KisPNGConverter::isColorSpaceSupported(const KoColorSpace *cs)
 {
     return colorSpaceIdSupported(cs->id());
 }
 
 
diff --git a/libs/ui/kisexiv2/kis_exif_io.cpp b/libs/ui/kisexiv2/kis_exif_io.cpp
index 177e295d0d..5bce1725b9 100644
--- a/libs/ui/kisexiv2/kis_exif_io.cpp
+++ b/libs/ui/kisexiv2/kis_exif_io.cpp
@@ -1,635 +1,639 @@
 /*
  *  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.1 of the License.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_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 <metadata/kis_meta_data_store.h>
 #include <metadata/kis_meta_data_entry.h>
 #include <metadata/kis_meta_data_value.h>
 #include <metadata/kis_meta_data_schema.h>
 #include <metadata/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;
-    qint16* dataIt = reinterpret_cast<qint16*>(array.data() + index);
+    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 += 8;
+            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();
         }
     }
-    qint16* dataIt = reinterpret_cast<qint16*>(array.data() + index);
+    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)
     {
         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(); )
     {
-        int lastIndex = array.indexOf(null, index);
-        QString setting = QString::fromUtf16((ushort*)(void*)( array.data() + index), lastIndex - index + 2);
+        const int lastIndex = array.indexOf(null, index);
+        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++) {
-        int val = values[i].asVariant().toInt();
+        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_MAJOR_VERSION == 0 && EXIV2_MINOR_VERSION <= 20
                     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_MAJOR_VERSION == 0 && EXIV2_MINOR_VERSION <= 20
                         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_MAJOR_VERSION == 0 && EXIV2_MINOR_VERSION <= 20
                         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_MAJOR_VERSION == 0 && EXIV2_MINOR_VERSION <= 20
                     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_MAJOR_VERSION == 0 && EXIV2_MINOR_VERSION <= 17
     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_MAJOR_VERSION == 0 && EXIV2_MINOR_VERSION <= 17
     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 v;
             if (it->key() == "Exif.Photo.ExifVersion" || it->key() == "Exif.Photo.FlashpixVersion") {
                 v = exifVersionToKMDValue(it->getValue());
             } else if (it->key() == "Exif.Photo.FileSource") {
                 v = KisMetaData::Value(3);
             } else if (it->key() == "Exif.Photo.SceneType") {
                 v = KisMetaData::Value(1);
             } else if (it->key() == "Exif.Photo.ComponentsConfiguration") {
                 v = exifArrayToKMDIntOrderedArray(it->getValue());
             } else if (it->key() == "Exif.Photo.OECF") {
                 v = exifOECFToKMDOECFStructure(it->getValue(), byteOrder);
             } else if (it->key() == "Exif.Photo.DateTimeDigitized" || it->key() == "Exif.Photo.DateTimeOriginal") {
                 v = KisMetaData::Value(exivValueToDateTime(it->getValue()));
             } else if (it->key() == "Exif.Photo.DeviceSettingDescription") {
                 v = deviceSettingDescriptionExifToKMD(it->getValue());
             } else if (it->key() == "Exif.Photo.CFAPattern") {
                 v = cfaPatternExifToKMD(it->getValue(), byteOrder);
             } else if (it->key() == "Exif.Photo.Flash") {
                 v = flashExifToKMD(it->getValue());
             } else if (it->key() == "Exif.Photo.UserComment") {
                 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);
                 v = 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;
                 }
                 v = exivValueToKMDValue(it->getValue(), forceSeq, arrayType);
             }
             if (it->key() == "Exif.Photo.InteroperabilityTag" || it->key() == "Exif.Photo.0xea1d") { // InteroperabilityTag isn't useful for XMP, 0xea1d isn't a valid Exif tag
                 dbgMetaData << "Ignoring " << it->key().c_str();
             } else {
                 store->addEntry(KisMetaData::Entry(exifSchema, it->tagName().c_str(), v));
             }
         } 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/kisexiv2/kis_exiv2.cpp b/libs/ui/kisexiv2/kis_exiv2.cpp
index dec4785b41..ba3f8e904b 100644
--- a/libs/ui/kisexiv2/kis_exiv2.cpp
+++ b/libs/ui/kisexiv2/kis_exiv2.cpp
@@ -1,294 +1,296 @@
 /*
  *  Copyright (c) 2007 Cyrille Berger <cberger@cberger.net>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; either version 2.1 of the License, or
  *  (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_exiv2.h"
 
 #include <QDateTime>
 
 #include "kis_iptc_io.h"
 #include "kis_exif_io.h"
 #include "kis_xmp_io.h"
 
 #include <metadata/kis_meta_data_value.h>
 #include <kis_debug.h>
 
 // ---- Generic conversion functions ---- //
 
 // Convert an exiv value to a KisMetaData value
 KisMetaData::Value exivValueToKMDValue(const Exiv2::Value::AutoPtr value, bool forceSeq, KisMetaData::Value::ValueType arrayType)
 {
     switch (value->typeId()) {
     case Exiv2::signedByte:
     case Exiv2::invalidTypeId:
     case Exiv2::lastTypeId:
     case Exiv2::directory:
         dbgMetaData << "Invalid value :" << value->typeId() << " value =" << value->toString().c_str();
         return KisMetaData::Value();
     case Exiv2::undefined: {
         dbgMetaData << "Undefined value :" << value->typeId() << " value =" << value->toString().c_str();
         QByteArray array(value->count() , 0);
         value->copy((Exiv2::byte*)array.data(), Exiv2::invalidByteOrder);
         return KisMetaData::Value(QString(array.toBase64()));
     }
     case Exiv2::unsignedByte:
     case Exiv2::unsignedShort:
     case Exiv2::unsignedLong:
     case Exiv2::signedShort:
     case Exiv2::signedLong: {
         if (value->count() == 1 && !forceSeq) {
             return KisMetaData::Value((int)value->toLong());
         } else {
             QList<KisMetaData::Value> array;
             for (int i = 0; i < value->count(); i++)
                 array.push_back(KisMetaData::Value((int)value->toLong(i)));
             return KisMetaData::Value(array, arrayType);
         }
     }
     case Exiv2::asciiString:
     case Exiv2::string:
     case Exiv2::comment: // look at kexiv2 for the problem about decoding correctly that tag
         return KisMetaData::Value(value->toString().c_str());
     case Exiv2::unsignedRational:
         if(value->size() < 2)
         {
             dbgMetaData << "Invalid size :" << value->size() << " value =" << value->toString().c_str();
             return KisMetaData::Value();
         }
         return KisMetaData::Value(KisMetaData::Rational(value->toRational().first , value->toRational().second));
     case Exiv2::signedRational:
         if(value->size() < 2)
         {
             dbgMetaData << "Invalid size :" << value->size() << " value =" << value->toString().c_str();
             return KisMetaData::Value();
         }
         return KisMetaData::Value(KisMetaData::Rational(value->toRational().first , value->toRational().second));
     case Exiv2::date:
     case Exiv2::time:
         return KisMetaData::Value(QDateTime::fromString(value->toString().c_str(), Qt::ISODate));
     case Exiv2::xmpText:
     case Exiv2::xmpAlt:
     case Exiv2::xmpBag:
     case Exiv2::xmpSeq:
     case Exiv2::langAlt:
     default: {
         dbgMetaData << "Unknown type id :" << value->typeId() << " value =" << value->toString().c_str();
         //Q_ASSERT(false); // This point must never be reached !
         return KisMetaData::Value();
     }
     }
     dbgMetaData << "Unknown type id :" << value->typeId() << " value =" << value->toString().c_str();
     //Q_ASSERT(false); // This point must never be reached !
     return KisMetaData::Value();
 }
 
 
 // Convert a QtVariant to an Exiv value
 Exiv2::Value* variantToExivValue(const QVariant& variant, Exiv2::TypeId type)
 {
     switch (type) {
     case Exiv2::undefined: {
         QByteArray arr = QByteArray::fromBase64(variant.toString().toLatin1());
         return new Exiv2::DataValue((Exiv2::byte*)arr.data(), arr.size());
     }
     case Exiv2::unsignedByte:
         return new Exiv2::ValueType<uint16_t>(variant.toUInt(0));
     case Exiv2::unsignedShort:
         return new Exiv2::ValueType<uint16_t>(variant.toUInt(0));
     case Exiv2::unsignedLong:
         return new Exiv2::ValueType<uint32_t>(variant.toUInt(0));
     case Exiv2::signedShort:
         return new Exiv2::ValueType<int16_t>(variant.toInt(0));
     case Exiv2::signedLong:
         return new Exiv2::ValueType<int32_t>(variant.toInt(0));
     case Exiv2::date: {
         QDate date = variant.toDate();
         return new Exiv2::DateValue(date.year(), date.month(), date.day());
     }
     case Exiv2::asciiString:
         if (variant.type() == QVariant::DateTime) {
             return new Exiv2::AsciiValue(qPrintable(variant.toDateTime().toString("yyyy:MM:dd hh:mm:ss")));
         } else
             return new Exiv2::AsciiValue(qPrintable(variant.toString()));
     case Exiv2::string: {
         if (variant.type() == QVariant::DateTime) {
             return new Exiv2::StringValue(qPrintable(variant.toDateTime().toString("yyyy:MM:dd hh:mm:ss")));
         } else
             return new Exiv2::StringValue(qPrintable(variant.toString()));
     }
     case Exiv2::comment:
         return new Exiv2::CommentValue(qPrintable(variant.toString()));
     default:
         dbgMetaData << "Unhandled type:" << type;
         //Q_ASSERT(false);
         return 0;
     }
 }
 
 template<typename _TYPE_>
 Exiv2::Value* arrayToExivValue(const KisMetaData::Value& value)
 {
     Exiv2::ValueType<_TYPE_>* ev = new Exiv2::ValueType<_TYPE_>();
     for (int i = 0; i < value.asArray().size(); ++i) {
         ev->value_.push_back(qvariant_cast<_TYPE_>(value.asArray()[i].asVariant()));
     }
     return ev;
 }
 
 // Convert a KisMetaData to an Exiv value
 Exiv2::Value* kmdValueToExivValue(const KisMetaData::Value& value, Exiv2::TypeId type)
 {
     switch (value.type()) {
     case KisMetaData::Value::Invalid:
         return &*Exiv2::Value::create(Exiv2::invalidTypeId);
     case KisMetaData::Value::Variant: {
         return variantToExivValue(value.asVariant(), type);
     }
     case KisMetaData::Value::Rational:
         //Q_ASSERT(type == Exiv2::signedRational || type == Exiv2::unsignedRational);
         if (type == Exiv2::signedRational) {
             return new Exiv2::ValueType<Exiv2::Rational>(Exiv2::Rational(value.asRational().numerator, value.asRational().denominator));
         } else {
             return new Exiv2::ValueType<Exiv2::URational>(Exiv2::URational(value.asRational().numerator, value.asRational().denominator));
         }
     case KisMetaData::Value::OrderedArray:
         /* Falls through */
     case KisMetaData::Value::UnorderedArray:
         /* Falls through */
     case KisMetaData::Value::AlternativeArray: {
         switch (type) {
         case Exiv2::unsignedByte:
             return arrayToExivValue<uint16_t>(value);
         case Exiv2::unsignedShort:
             return arrayToExivValue<uint16_t>(value);
         case Exiv2::unsignedLong:
             return arrayToExivValue<uint32_t>(value);
         case Exiv2::signedShort:
             return arrayToExivValue<int16_t>(value);
         case Exiv2::signedLong:
             return arrayToExivValue<int32_t>(value);
         case Exiv2::string: {
             Exiv2::StringValue* ev = new Exiv2::StringValue();
             for (int i = 0; i < value.asArray().size(); ++i) {
                 ev->value_ += qvariant_cast<QString>(value.asArray()[i].asVariant()).toLatin1().constData();
                 if (i != value.asArray().size() - 1) ev->value_ += ',';
             }
             return ev;
         }
             break;
         default:
             dbgMetaData << type << " " << value;
-            //Q_ASSERT(false);
+            KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(0 && "Unknown alternative array type", 0);
+            break;
         }
-        /* Falls through */
+        break;
     }
     default:
         dbgMetaData << type << " " << value;
-        //Q_ASSERT(false);
+        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(0 && "Unknown array type", 0);
+        break;
     }
     return 0;
 }
 
 Exiv2::Value* kmdValueToExivXmpValue(const KisMetaData::Value& value)
 {
     //Q_ASSERT(value.type() != KisMetaData::Value::Structure);
     switch (value.type()) {
     case KisMetaData::Value::Invalid:
         return new Exiv2::DataValue(Exiv2::invalidTypeId);
     case KisMetaData::Value::Variant: {
         QVariant var = value.asVariant();
         if (var.type() == QVariant::Bool) {
             if (var.toBool()) {
                 return new Exiv2::XmpTextValue("True");
             } else {
                 return new Exiv2::XmpTextValue("False");
             }
         } else {
             //Q_ASSERT(var.canConvert(QVariant::String));
             return new Exiv2::XmpTextValue(var.toString().toLatin1().constData());
         }
     }
     case KisMetaData::Value::Rational: {
         QString rat = "%1 / %2";
         rat = rat.arg(value.asRational().numerator);
         rat = rat.arg(value.asRational().denominator);
         return new Exiv2::XmpTextValue(rat.toLatin1().constData());
     }
     case KisMetaData::Value::AlternativeArray:
     case KisMetaData::Value::OrderedArray:
     case KisMetaData::Value::UnorderedArray: {
         Exiv2::XmpArrayValue* arrV = new Exiv2::XmpArrayValue;
         switch (value.type()) {
         case KisMetaData::Value::OrderedArray:
             arrV->setXmpArrayType(Exiv2::XmpValue::xaSeq);
             break;
         case KisMetaData::Value::UnorderedArray:
             arrV->setXmpArrayType(Exiv2::XmpValue::xaBag);
             break;
         case KisMetaData::Value::AlternativeArray:
             arrV->setXmpArrayType(Exiv2::XmpValue::xaAlt);
             break;
         default:
             // Cannot happen
             ;
         }
         Q_FOREACH (const KisMetaData::Value& v, value.asArray()) {
             Exiv2::Value* ev = kmdValueToExivXmpValue(v);
             if (ev) {
                 arrV->read(ev->toString());
                 delete ev;
             }
         }
         return arrV;
     }
     case KisMetaData::Value::LangArray: {
         Exiv2::Value* arrV = new Exiv2::LangAltValue;
         QMap<QString, KisMetaData::Value> langArray = value.asLangArray();
         for (QMap<QString, KisMetaData::Value>::iterator it = langArray.begin();
              it != langArray.end(); ++it) {
             QString exivVal;
             if (it.key() != "x-default") {
                 exivVal = "lang=" + it.key() + ' ';
             }
             //Q_ASSERT(it.value().type() == KisMetaData::Value::Variant);
             QVariant var = it.value().asVariant();
             //Q_ASSERT(var.type() == QVariant::String);
             exivVal += var.toString();
             arrV->read(exivVal.toLatin1().constData());
         }
         return arrV;
     }
     case KisMetaData::Value::Structure:
     default: {
         warnKrita << "KisExiv2: Unhandled value type";
         return 0;
     }
 
     }
     warnKrita << "KisExiv2: Unhandled value type";
     return 0;
 }
 
 void KisExiv2::initialize()
 {
     // XXX_EXIV: make the exiv io backends real plugins
 
     KisMetaData::IOBackendRegistry* ioreg = KisMetaData::IOBackendRegistry::instance();
     ioreg->add(new KisIptcIO);
     ioreg->add(new KisExifIO);
     ioreg->add(new KisXMPIO);
 }
diff --git a/libs/ui/tests/CMakeLists.txt b/libs/ui/tests/CMakeLists.txt
index e665eea0d9..5b66293d47 100644
--- a/libs/ui/tests/CMakeLists.txt
+++ b/libs/ui/tests/CMakeLists.txt
@@ -1,178 +1,197 @@
 set( EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR} )
 
 #add_subdirectory(scratchpad)
 include_directories(${CMAKE_SOURCE_DIR}/libs/image/metadata 
                     ${CMAKE_SOURCE_DIR}/sdk/tests )
 
 include(ECMAddTests)
 
 macro_add_unittest_definitions()
 
 ecm_add_tests(
     kis_image_view_converter_test.cpp
     kis_shape_selection_test.cpp
     kis_doc2_test.cpp
     kis_coordinates_converter_test.cpp
     kis_grid_config_test.cpp
     kis_stabilized_events_sampler_test.cpp
     kis_derived_resources_test.cpp
     kis_brush_hud_properties_config_test.cpp
     kis_shape_commands_test.cpp
     kis_shape_layer_test.cpp
     kis_stop_gradient_editor_test.cpp
     kis_file_layer_test.cpp
     kis_multinode_property_test.cpp
-    NAME_PREFIX "krita-ui-"
+    KisFrameSerializerTest.cpp
+    KisFrameCacheStoreTest.cpp
+    kis_animation_exporter_test.cpp
+
     LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "libs-ui-"
 )
 
-ecm_add_test( KisFrameSerializerTest.cpp
-    TEST_NAME krita-ui-KisFrameSerializerTest
-    LINK_LIBRARIES kritaui kritaimage Qt5::Test)
-
-ecm_add_test( KisFrameCacheStoreTest.cpp
-    TEST_NAME krita-ui-KisFrameCacheStoreTest
-    LINK_LIBRARIES kritaui kritaimage Qt5::Test)
-
 ecm_add_test( kis_selection_decoration_test.cpp ../../../sdk/tests/stroke_testing_utils.cpp
-    TEST_NAME krita-ui-KisSelectionDecorationTest
-    LINK_LIBRARIES kritaui kritaimage Qt5::Test)
+    TEST_NAME KisSelectionDecorationTest
+    LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "libs-ui-")
 
 ecm_add_test( kis_node_dummies_graph_test.cpp ../../../sdk/tests/testutil.cpp
-    TEST_NAME krita-ui-KisNodeDummiesGraphTest
-    LINK_LIBRARIES kritaui kritaimage Qt5::Test)
+    TEST_NAME KisNodeDummiesGraphTest
+    LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "libs-ui-")
 
 ecm_add_test( kis_node_shapes_graph_test.cpp ../../../sdk/tests/testutil.cpp
-    TEST_NAME krita-ui-KisNodeShapesGraphTest
-    LINK_LIBRARIES kritaui kritaimage Qt5::Test)
+    TEST_NAME KisNodeShapesGraphTest
+    LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "libs-ui-")
 
 ecm_add_test( kis_model_index_converter_test.cpp ../../../sdk/tests/testutil.cpp
-    TEST_NAME krita-ui-KisModelIndexConverterTest
-    LINK_LIBRARIES kritaui kritaimage Qt5::Test)
+    TEST_NAME KisModelIndexConverterTest
+    LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "libs-ui-")
 
 ecm_add_test( kis_categorized_list_model_test.cpp modeltest.cpp
-    TEST_NAME krita-ui-KisCategorizedListModelTest
-    LINK_LIBRARIES kritaui kritaimage Qt5::Test)
+    TEST_NAME KisCategorizedListModelTest
+    LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "libs-ui-")
 
 ecm_add_test( kis_node_juggler_compressed_test.cpp  ../../../sdk/tests/testutil.cpp
-    TEST_NAME krita-ui-KisNodeJugglerCompressedTest
-    LINK_LIBRARIES kritaimage kritaui Qt5::Test)
-
-ecm_add_test(
-    kis_animation_exporter_test.cpp
-    TEST_NAME kritaui-animation_exporter_test
-    LINK_LIBRARIES kritaui kritaimage Qt5::Test)
+    TEST_NAME KisNodeJugglerCompressedTest
+    LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "libs-ui-")
 
 set(kis_node_view_test_SRCS kis_node_view_test.cpp  ../../../sdk/tests/testutil.cpp)
 qt5_add_resources(kis_node_view_test_SRCS ${krita_QRCS})
 ecm_add_test(${kis_node_view_test_SRCS}
-    TEST_NAME krita-ui-kis_node_view_test
-    LINK_LIBRARIES kritaimage kritaui Qt5::Test)
+    TEST_NAME kis_node_view_test
+    LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "libs-ui-")
 
+ecm_add_test(
+    kis_input_manager_test.cpp ../../../sdk/tests/testutil.cpp
+    TEST_NAME KisInputManagerTest
+    LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "libs-ui-")
 
 
 ##### Tests that currently fail and should be fixed #####
 
 include(KritaAddBrokenUnitTest)
 
 krita_add_broken_unit_test(
     kis_node_model_test.cpp modeltest.cpp
-    TEST_NAME krita-ui-kis_node_model_test
-    LINK_LIBRARIES kritaui Qt5::Test)
+    TEST_NAME kis_node_model_test
+    LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "libs-ui-")
 
 krita_add_broken_unit_test(
     kis_shape_controller_test.cpp kis_dummies_facade_base_test.cpp
-    TEST_NAME krita-ui-kis_shape_controller_test
-    LINK_LIBRARIES kritaimage kritaui Qt5::Test)
+    TEST_NAME kis_shape_controller_test
+    LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "libs-ui-")
 
 krita_add_broken_unit_test(
     kis_prescaled_projection_test.cpp
-    TEST_NAME krita-ui-kis_prescaled_projection_test
-    LINK_LIBRARIES kritaui Qt5::Test)
+    TEST_NAME kis_prescaled_projection_test
+    LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "libs-ui-")
 
 krita_add_broken_unit_test(
     kis_exiv2_test.cpp
-    TEST_NAME krita-ui-KisExiv2Test
-    LINK_LIBRARIES kritaimage kritaui Qt5::Test)
+    TEST_NAME KisExiv2Test
+    LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "libs-ui-")
 
 krita_add_broken_unit_test(
     kis_clipboard_test.cpp
-    TEST_NAME krita-ui-KisClipboardTest
-    LINK_LIBRARIES kritaui kritaimage Qt5::Test)
+    TEST_NAME KisClipboardTest
+    LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "libs-ui-")
 
 krita_add_broken_unit_test(
     freehand_stroke_test.cpp ${CMAKE_SOURCE_DIR}/sdk/tests/stroke_testing_utils.cpp
-    TEST_NAME krita-ui-FreehandStrokeTest
-    LINK_LIBRARIES kritaui kritaimage Qt5::Test)
+    TEST_NAME FreehandStrokeTest
+    LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "libs-ui-")
 
 krita_add_broken_unit_test(
     FreehandStrokeBenchmark.cpp ${CMAKE_SOURCE_DIR}/sdk/tests/stroke_testing_utils.cpp
-    TEST_NAME krita-ui-FreehandStrokeBenchmark
-    LINK_LIBRARIES kritaui kritaimage Qt5::Test)
+    TEST_NAME FreehandStrokeBenchmark
+    LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "libs-ui-")
 
 krita_add_broken_unit_test(
     KisPaintOnTransparencyMaskTest.cpp ${CMAKE_SOURCE_DIR}/sdk/tests/stroke_testing_utils.cpp
-    TEST_NAME krita-ui-KisPaintOnTransparencyMaskTest
-    LINK_LIBRARIES kritaui kritaimage Qt5::Test)
+    TEST_NAME KisPaintOnTransparencyMaskTest
+    LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "libs-ui-")
 
 krita_add_broken_unit_test(
     fill_processing_visitor_test.cpp ${CMAKE_SOURCE_DIR}/sdk/tests/stroke_testing_utils.cpp
-    TEST_NAME krita-ui-FillProcessingVisitorTest
-    LINK_LIBRARIES kritaui kritaimage Qt5::Test)
+    TEST_NAME FillProcessingVisitorTest
+    LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "libs-ui-")
 
 krita_add_broken_unit_test(
     filter_stroke_test.cpp ../../../sdk/tests/stroke_testing_utils.cpp
-    TEST_NAME krita-ui-FilterStrokeTest
-    LINK_LIBRARIES kritaui kritaimage Qt5::Test)
+    TEST_NAME FilterStrokeTest
+    LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "libs-ui-")
 
 krita_add_broken_unit_test(
     kis_selection_manager_test.cpp
-    TEST_NAME krita-ui-KisSelectionManagerTest
-    LINK_LIBRARIES kritaui kritaimage Qt5::Test)
-#set_tests_properties(krita-ui-KisSelectionManagerTest PROPERTIES TIMEOUT 300)
+    TEST_NAME KisSelectionManagerTest
+    LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "libs-ui-")
+#set_tests_properties(libs-ui-KisSelectionManagerTest PROPERTIES TIMEOUT 300)
 
 krita_add_broken_unit_test(
     kis_node_manager_test.cpp
-    TEST_NAME krita-ui-KisNodeManagerTest
-    LINK_LIBRARIES kritaui kritaimage Qt5::Test)
+    TEST_NAME KisNodeManagerTest
+    LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "libs-ui-")
 
 krita_add_broken_unit_test(
     kis_dummies_facade_test.cpp kis_dummies_facade_base_test.cpp ../../../sdk/tests/testutil.cpp
-    TEST_NAME krita-ui-KisDummiesFacadeTest
-    LINK_LIBRARIES kritaui kritaimage Qt5::Test)
+    TEST_NAME KisDummiesFacadeTest
+    LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "libs-ui-")
 
 krita_add_broken_unit_test(
     kis_zoom_and_pan_test.cpp ../../../sdk/tests/testutil.cpp
-    TEST_NAME krita-ui-KisZoomAndPanTest
-    LINK_LIBRARIES kritaui kritaimage Qt5::Test)
-#set_tests_properties(krita-ui-KisZoomAndPanTest PROPERTIES TIMEOUT 300)
+    TEST_NAME KisZoomAndPanTest
+    LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "libs-ui-")
+#set_tests_properties(libs-ui-KisZoomAndPanTest PROPERTIES TIMEOUT 300)
 
 krita_add_broken_unit_test(
     kis_action_manager_test.cpp
-    TEST_NAME krita-ui-KisActionManagerTest
-    LINK_LIBRARIES kritaui kritaimage Qt5::Test)
+    TEST_NAME KisActionManagerTest
+    LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "libs-ui-")
 
 krita_add_broken_unit_test(
     kis_categories_mapper_test.cpp testing_categories_mapper.cpp
-    TEST_NAME krita-ui-KisCategoriesMapperTest
-    LINK_LIBRARIES kritaui kritaimage Qt5::Test)
+    TEST_NAME KisCategoriesMapperTest
+    LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "libs-ui-")
 
 krita_add_broken_unit_test(
     kis_asl_layer_style_serializer_test.cpp
-    TEST_NAME krita-ui-KisAslLayerStyleSerializerTest
-    LINK_LIBRARIES kritaui kritaimage Qt5::Test)
+    TEST_NAME KisAslLayerStyleSerializerTest
+    LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "libs-ui-")
 
 krita_add_broken_unit_test(
     kis_animation_importer_test.cpp
-    TEST_NAME krita-ui-animation_importer_test
-    LINK_LIBRARIES kritaui kritaimage Qt5::Test)
+    TEST_NAME kis_animation_importer_test
+    LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "libs-ui-")
 
 krita_add_broken_unit_test(
     kis_animation_frame_cache_test.cpp
-    TEST_NAME krita-ui-animation_frame_cache_test
-    LINK_LIBRARIES kritaui kritaimage Qt5::Test)
+    TEST_NAME kis_animation_frame_cache_test
+    LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "libs-ui-")
+
 
-ecm_add_test(
-    kis_input_manager_test.cpp ../../../sdk/tests/testutil.cpp
-    TEST_NAME krita-ui-KisInputManagerTest
-    LINK_LIBRARIES kritaui kritaimage Qt5::Test)
diff --git a/libs/ui/tests/KisPaintOnTransparencyMaskTest.cpp b/libs/ui/tests/KisPaintOnTransparencyMaskTest.cpp
index 141359b0c7..a1d9b6ab1e 100644
--- a/libs/ui/tests/KisPaintOnTransparencyMaskTest.cpp
+++ b/libs/ui/tests/KisPaintOnTransparencyMaskTest.cpp
@@ -1,134 +1,134 @@
 #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 "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(KoCanvasResourceManager *manager,
                                KisImageWSP image) {
 
         KoColor color(Qt::red, image->colorSpace());
         color.setOpacity(0.5);
 
         QVariant i;
         i.setValue(color);
         manager->setResource(KoCanvasResourceManager::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));
     }
 
 
     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(QString("failed: %1").arg(name).toLatin1().data());
+                qFatal("%s", QString("failed: %1").arg(name).toLatin1().data());
             }
         }
     }
 
     void beforeCheckingResult(KisImageWSP image, KisNodeSP activeNode) {
         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/kis_selection_decoration_test.cpp b/libs/ui/tests/kis_selection_decoration_test.cpp
index b9787ecad9..65753de57b 100644
--- a/libs/ui/tests/kis_selection_decoration_test.cpp
+++ b/libs/ui/tests/kis_selection_decoration_test.cpp
@@ -1,53 +1,53 @@
 /*
  *  Copyright (c) 2014 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_selection_decoration_test.h"
 
 #include <QTest>
 #include <stroke_testing_utils.h>
 #include "kis_processing_applicator.h"
 #include "commands/kis_selection_commands.h"
 #include "kis_selection.h"
 
 
 void KisSelectionDecorationTest::testConcurrentSelectionFetches()
 {
     KisImageSP image = utils::createImage(0, QSize(3000, 3000));
 
     for (int i = 0; i < 10000; i++) {
         KisProcessingApplicator applicator(image,
                                            0 /* we need no automatic updates */,
                                            KisProcessingApplicator::SUPPORTS_WRAPAROUND_MODE,
                                            KisImageSignalVector() << ModifiedSignal,
                                            kundo2_noi18n("test stroke"));
 
 
-        applicator.applyCommand(new KisSetEmptyGlobalSelectionCommand(image));
-        applicator.applyCommand(new KisDeselectGlobalSelectionCommand(image));
+        applicator.applyCommand(new KisSetEmptyGlobalSelectionCommand(image), KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
+        applicator.applyCommand(new KisDeselectGlobalSelectionCommand(image), KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
 
         applicator.end();
 
         for (int j = 0; j < 100; j++) {
             KisSelectionSP selection = image->globalSelection();
         }
     }
 
     image->waitForDone();
 }
 
 QTEST_MAIN(KisSelectionDecorationTest)
diff --git a/libs/ui/tests/kis_shape_selection_test.cpp b/libs/ui/tests/kis_shape_selection_test.cpp
index 2b33696407..e4637deaff 100644
--- a/libs/ui/tests/kis_shape_selection_test.cpp
+++ b/libs/ui/tests/kis_shape_selection_test.cpp
@@ -1,86 +1,85 @@
 /*
  *  Copyright (c) 2008 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_shape_selection_test.h"
 #include <QTest>
 
 #include <kis_debug.h>
 #include <QRect>
 
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoPathShape.h>
 
 #include "kis_selection.h"
 #include "kis_pixel_selection.h"
 #include "flake/kis_shape_selection.h"
 #include "kis_image.h"
 #include "testutil.h"
 #include "kistest.h"
 #include <KisPart.h>
 #include <KisDocument.h>
 
 void KisShapeSelectionTest::testAddChild()
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     QScopedPointer<KisDocument> doc(KisPart::instance()->createDocument());
     QColor qc(Qt::white);
     qc.setAlpha(0);
     KoColor bgColor(qc, cs);
     doc->newImage("test", 300, 300, cs, bgColor, true, 1, "test", 100);
     KisImageSP image = doc->image();
 
     KisSelectionSP selection = new KisSelection();
     QVERIFY(selection->hasPixelSelection() == false);
     QVERIFY(selection->hasShapeSelection() == false);
 
     KisPixelSelectionSP pixelSelection = selection->pixelSelection();
     pixelSelection->select(QRect(0, 0, 100, 100));
 
     QCOMPARE(TestUtil::alphaDevicePixel(pixelSelection, 25, 25), MAX_SELECTED);
     QCOMPARE(selection->selectedExactRect(), QRect(0, 0, 100, 100));
 
-    QRect rect(50, 50, 100, 100);
+    QRectF rect(50, 50, 100, 100);
     QTransform matrix;
     matrix.scale(1 / image->xRes(), 1 / image->yRes());
     rect = matrix.mapRect(rect);
 
     KoPathShape* shape = new KoPathShape();
     shape->setShapeId(KoPathShapeId);
     shape->moveTo(rect.topLeft());
-    shape->lineTo(rect.topLeft() + QPointF(rect.width(), 0));
+    shape->lineTo(rect.topRight());
     shape->lineTo(rect.bottomRight());
-    shape->lineTo(rect.topLeft() + QPointF(0, rect.height()));
+    shape->lineTo(rect.bottomLeft());
     shape->close();
-    shape->normalize();
 
     KisShapeSelection * shapeSelection = new KisShapeSelection(doc->shapeController(), image, selection);
     selection->setShapeSelection(shapeSelection);
     shapeSelection->addShape(shape);
 
+    QVERIFY(selection->hasShapeSelection());
+
     selection->updateProjection();
     image->waitForDone();
 
     QCOMPARE(selection->selectedExactRect(), QRect(50, 50, 100, 100));
-
-
 }
 
 KISTEST_MAIN(KisShapeSelectionTest)
 
 
diff --git a/libs/ui/widgets/kis_multipliers_double_slider_spinbox.cpp b/libs/ui/widgets/kis_multipliers_double_slider_spinbox.cpp
index 01c7fec92e..0531e150cd 100644
--- a/libs/ui/widgets/kis_multipliers_double_slider_spinbox.cpp
+++ b/libs/ui/widgets/kis_multipliers_double_slider_spinbox.cpp
@@ -1,94 +1,94 @@
 /* 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_multipliers_double_slider_spinbox.h"
 #include "kis_multipliers_double_slider_spinbox_p.h"
 
 #include "ui_wdgmultipliersdoublesliderspinbox.h"
 
 #include "kis_debug.h"
 
 qreal KisMultipliersDoubleSliderSpinBox::Private::currentMultiplier()
 {
     return form.comboBox->itemData(form.comboBox->currentIndex()).toDouble();
 }
 
 void KisMultipliersDoubleSliderSpinBox::Private::updateRange()
 {
     qreal m = currentMultiplier();
     form.sliderSpinBox->setRange(m * min, m * max, decimals);
 }
 
 KisMultipliersDoubleSliderSpinBox::KisMultipliersDoubleSliderSpinBox(QWidget* _parent)
     : QWidget(_parent)
     , d(new Private)
 {
     d->form.setupUi(this);
     addMultiplier(1.0);
     connect(d->form.sliderSpinBox, SIGNAL(valueChanged(qreal)), SIGNAL(valueChanged(qreal)));
     connect(d->form.comboBox, SIGNAL(activated(int)), SLOT(updateRange()));
 }
 
 KisMultipliersDoubleSliderSpinBox::~KisMultipliersDoubleSliderSpinBox()
 {
     delete d;
 }
 
 void KisMultipliersDoubleSliderSpinBox::addMultiplier(double v)
 {
   d->form.comboBox->addItem(i18n("x%1", v), v);
 }
 
 void KisMultipliersDoubleSliderSpinBox::setRange(qreal minimum, qreal maximum, int decimals)
 {
     d->min = minimum;
     d->max = maximum;
     d->decimals = decimals;
     d->updateRange();
 }
 
 qreal KisMultipliersDoubleSliderSpinBox::value()
 {
     return d->form.sliderSpinBox->value();
 }
 
 void KisMultipliersDoubleSliderSpinBox::setValue(qreal value)
 {
     qreal m = d->currentMultiplier();
 
     if (value < m * d->min || value > m * d->max) {
         for(int i = 0; i < d->form.comboBox->count(); ++i) {
             qreal m = d->form.comboBox->itemData(i).toDouble();
             if (value >= m * d->min && value <= m * d->max) {
                 d->form.comboBox->setCurrentIndex(i);
                 d->updateRange();
                 break;
             }
         }
     }
 
     d->form.sliderSpinBox->setValue(value);
 }
 
 void KisMultipliersDoubleSliderSpinBox::setExponentRatio(qreal dbl)
 {
     d->form.sliderSpinBox->setExponentRatio(dbl);
 }
 
-#include "moc_kis_multipliers_double_slider_spinbox.cpp"
\ No newline at end of file
+#include "moc_kis_multipliers_double_slider_spinbox.cpp"
diff --git a/libs/ui/widgets/kis_tone_curve_widget.cpp b/libs/ui/widgets/kis_tone_curve_widget.cpp
index cc197e8e43..679fed4fd5 100644
--- a/libs/ui/widgets/kis_tone_curve_widget.cpp
+++ b/libs/ui/widgets/kis_tone_curve_widget.cpp
@@ -1,362 +1,362 @@
 /* 
  * Copyright (C) 2015 by Wolthera van Hövell tot Westerflier <griffinvalley@gmail.com>
  *
  * Based on the Digikam CIE Tongue widget
  * Copyright (C) 2006-2013 by Gilles Caulier <caulier dot gilles at gmail dot com>
  *
  * Any source code are inspired from lprof project and
  * Copyright (C) 1998-2001 Marti Maria
  *
  * This program is free software; you can redistribute it
  * and/or modify it under the terms of the GNU General
  * Public License as published by the Free Software Foundation;
  * either version 2, or (at your option)
  * any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  **/
 #include <QPointF>
 #include <QPolygonF>
 #include <QPainter>
 #include <QPaintEvent>
 #include <QImage>
 #include <cmath>
 #include <klocalizedstring.h>
 
 
 #include "kis_tone_curve_widget.h"
 
 class Q_DECL_HIDDEN KisToneCurveWidget::Private
 {
 public:
  
     Private() :
         profileDataAvailable(false),
         needUpdatePixmap(false),
         TRCGray(true),
         xBias(0),
         yBias(0),
         pxcols(0),
         pxrows(0),
         gridside(0)
         
     {
     }
     
     bool            profileDataAvailable;
     bool            needUpdatePixmap;
     bool            TRCGray;
     bool            TRCRGB;
  
     int             xBias;
     int             yBias;
     int             pxcols;
     int             pxrows;
 
     QPolygonF       ToneCurveGray;
     QPolygonF       ToneCurveRed;
     QPolygonF       ToneCurveGreen;
     QPolygonF       ToneCurveBlue;
  
     double          gridside;
  
     QPainter        painter;
     QPainter        painter2;
     QPixmap         pixmap;
     QPixmap         curvemap;
 };
 
 KisToneCurveWidget::KisToneCurveWidget(QWidget *parent) :
     QWidget(parent), d(new Private)
 {
     /*this is a tone curve widget*/
 }
 
 KisToneCurveWidget::~KisToneCurveWidget()
 {
     delete d;
 }
 
 void KisToneCurveWidget::setGreyscaleCurve(QPolygonF poly)
 {
     d->ToneCurveGray = poly;
     d->TRCGray = true;
     d->TRCRGB = false;
     d->profileDataAvailable = true;
     d->needUpdatePixmap = true;
 }
 
 void KisToneCurveWidget::setRGBCurve(QPolygonF red, QPolygonF green, QPolygonF blue)
 {
     d->ToneCurveRed = red;
     d->ToneCurveGreen = green;
     d->ToneCurveBlue = blue;
     d->profileDataAvailable = true;
     d->TRCGray = false;
     d->TRCRGB = true;
     d->needUpdatePixmap = true;
 }
 void KisToneCurveWidget::setCMYKCurve(QPolygonF cyan, QPolygonF magenta, QPolygonF yellow, QPolygonF key)
 {
     d->ToneCurveRed = cyan;
     d->ToneCurveGreen = magenta;
     d->ToneCurveBlue = yellow;
     d->ToneCurveGray = key;
     d->profileDataAvailable = true;
     d->TRCGray = false;
     d->TRCRGB = false;
     d->needUpdatePixmap = true;
 }
 void KisToneCurveWidget::setProfileDataAvailable(bool dataAvailable)
 {
     d->profileDataAvailable = dataAvailable;
 }
 int KisToneCurveWidget::grids(double val) const
 {
     return (int) floor(val * d->gridside + 0.5);
 }
 
 void KisToneCurveWidget::mapPoint(QPointF & xy)
 {
     QPointF dummy = xy;
     xy.setX( (int) floor((dummy.x() * (d->pxcols - 1)) + .5) + d->xBias);
     xy.setY( (int) floor(((d->pxrows - 1) - dummy.y() * (d->pxrows - 1)) + .5) );
 }
 
 void KisToneCurveWidget::biasedLine(int x1, int y1, int x2, int y2)
 {
     d->painter.drawLine(x1 + d->xBias, y1, x2 + d->xBias, y2);
 }
  
 void KisToneCurveWidget::biasedText(int x, int y, const QString& txt)
 {
     d->painter.drawText(QPoint(d->xBias + x, y), txt);
 }
 
 void KisToneCurveWidget::drawGrid()
 {
     d->painter.setOpacity(1.0);
     d->painter.setPen(qRgb(255, 255, 255));
     biasedLine(0, 0,           0,           d->pxrows - 1);
     biasedLine(0, d->pxrows-1, d->pxcols-1, d->pxrows - 1);
     
     QFont font;
     font.setPointSize(6);
     d->painter.setFont(font);
     
     for (int y = 1; y <= 9; y += 1)
     {
         QString s;
         int xstart = (y * (d->pxcols - 1)) / 10;
         int ystart = (y * (d->pxrows - 1)) / 10;
  
         s.sprintf("0.%d", y);
         biasedLine(xstart, d->pxrows - grids(1), xstart,   d->pxrows - grids(4));
         biasedText(xstart - grids(11), d->pxrows + grids(15), s);
  
         s.sprintf("0.%d", 10 - y);
         biasedLine(0, ystart, grids(3), ystart);
         biasedText(grids(-25), ystart + grids(5), s);
     }
     
     d->painter.setPen(qRgb(128, 128, 128));
     d->painter.setOpacity(0.5);
  
     for (int y = 1; y <= 9; y += 1)
     {
         int xstart =  (y * (d->pxcols - 1)) / 10;
         int ystart =  (y * (d->pxrows - 1)) / 10;
  
         biasedLine(xstart, grids(4), xstart,   d->pxrows - grids(4) - 1);
         biasedLine(grids(7), ystart, d->pxcols-1-grids(7), ystart);
     }
     d->painter.setOpacity(1.0);
     d->painter.setOpacity(1.0);
 }
 
 void KisToneCurveWidget::updatePixmap()
 {
     d->needUpdatePixmap = false;
     d->pixmap = QPixmap(size());
     d->curvemap = QPixmap(size());
     d->pixmap.fill(Qt::black);
     d->curvemap.fill(Qt::transparent);
 
     d->painter.begin(&d->pixmap);
     
 
     int pixcols = d->pixmap.width();
     int pixrows = d->pixmap.height();
 
     d->gridside = (qMin(pixcols, pixrows)) / 512.0;
     d->xBias    = grids(32);
     d->yBias    = grids(20);
     d->pxcols   = pixcols - d->xBias;
     d->pxrows   = pixrows - d->yBias;
 
     d->painter.setBackground(QBrush(qRgb(0, 0, 0)));
     QPointF start;
     drawGrid();
     d->painter.setRenderHint(QPainter::Antialiasing);
     if (d->TRCGray && d->ToneCurveGray.size()>0){
         QPainterPath path;
         start = d->ToneCurveGray.at(0);
         mapPoint(start);
         path.moveTo(start);
         foreach (QPointF Point, d->ToneCurveGray) {
             mapPoint(Point);
             path.lineTo(Point);
         }
         d->painter.setPen(qRgb(255, 255, 255));
         d->painter.drawPath(path);
     } else if (d->TRCRGB && d->ToneCurveRed.size()>0 && d->ToneCurveGreen.size()>0 && d->ToneCurveBlue.size()>0){
         d->painter.save();
         d->painter.setCompositionMode(QPainter::CompositionMode_Screen);
         QPainterPath path;
         start = d->ToneCurveRed.at(0);
         mapPoint(start);
         path.moveTo(start);
         foreach (QPointF Point, d->ToneCurveRed) {
             mapPoint(Point);
             path.lineTo(Point);
         }
         d->painter.setPen(qRgb(255, 0, 0));
         d->painter.drawPath(path);
         QPainterPath path2;
         start = d->ToneCurveGreen.at(0);
         mapPoint(start);
         path2.moveTo(start);
         foreach (QPointF Point, d->ToneCurveGreen) {
             mapPoint(Point);
             path2.lineTo(Point);
         }
         d->painter.setPen(qRgb(0, 255, 0));
         d->painter.drawPath(path2);
         QPainterPath path3;
         start = d->ToneCurveBlue.at(0);
         mapPoint(start);
         path3.moveTo(start);
         foreach (QPointF Point, d->ToneCurveBlue) {
             mapPoint(Point);
             path3.lineTo(Point);
         }
         d->painter.setPen(qRgb(0, 0, 255));
         d->painter.drawPath(path3);
         d->painter.restore();
     } else {
         d->painter2.begin(&d->curvemap);
         d->painter2.setRenderHint(QPainter::Antialiasing);
         //d->painter2.setCompositionMode(QPainter::CompositionMode_Multiply);
         QPainterPath path;
         start = d->ToneCurveRed.at(0);
         mapPoint(start);
         path.moveTo(start);
         foreach (QPointF Point, d->ToneCurveRed) {
             mapPoint(Point);
             path.lineTo(Point);
         }
         d->painter2.setPen(qRgb(0, 255, 255));
         d->painter2.drawPath(path);
         QPainterPath path2;
         start = d->ToneCurveGreen.at(0);
         mapPoint(start);
         path2.moveTo(start);
         foreach (QPointF Point, d->ToneCurveGreen) {
             mapPoint(Point);
             path2.lineTo(Point);
         }
         d->painter2.setPen(qRgb(255, 0, 255));
         d->painter2.drawPath(path2);
         QPainterPath path3;
         start = d->ToneCurveBlue.at(0);
         mapPoint(start);
         path3.moveTo(start);
         foreach (QPointF Point, d->ToneCurveBlue) {
             mapPoint(Point);
             path3.lineTo(Point);
         }
         d->painter2.setPen(qRgb(255, 255, 0));
         d->painter2.drawPath(path3);
         QPainterPath path4;
         start = d->ToneCurveGray.at(0);
         mapPoint(start);
         path4.moveTo(start);
         foreach (QPointF Point, d->ToneCurveGray) {
             mapPoint(Point);
             path4.lineTo(Point);
         }
         d->painter2.setPen(qRgb(80, 80, 80));
         d->painter2.drawPath(path4);
         d->painter2.end();
         QRect area(d->xBias, 0, d->pxcols, d->pxrows);
         d->painter.drawPixmap(area,d->curvemap, area);
     }
     d->painter.end();
 
 }
 
 void KisToneCurveWidget::paintEvent(QPaintEvent*)
 {
     QPainter p(this);
  
     // Widget is disable : drawing grayed frame.
  
     if ( !isEnabled() )
     {
         p.fillRect(0, 0, width(), height(),
                    palette().color(QPalette::Disabled, QPalette::Background));
  
         QPen pen(palette().color(QPalette::Disabled, QPalette::Foreground));
         pen.setStyle(Qt::SolidLine);
         pen.setWidth(1);
  
         p.setPen(pen);
         p.drawRect(0, 0, width(), height());
  
         return;
     }
 
  
     // No profile data to show, or RAW file
  
     if (!d->profileDataAvailable)
     {
         p.fillRect(0, 0, width(), height(), palette().color(QPalette::Active, QPalette::Background));
         QPen pen(palette().color(QPalette::Active, QPalette::Text));
         pen.setStyle(Qt::SolidLine);
         pen.setWidth(1);
  
         p.setPen(pen);
         p.drawRect(0, 0, width(), height());
  
         p.setPen(Qt::red);
         p.drawText(0, 0, width(), height(), Qt::AlignCenter,
         i18n("No tone curve available..."));
  
         return;
     }
  
     // Create CIE tongue if needed
     if (d->needUpdatePixmap)
     {
         updatePixmap();
     }
  
     // draw prerendered tongue
     p.drawPixmap(0, 0, d->pixmap);
 }
  
 void KisToneCurveWidget::resizeEvent(QResizeEvent* event)
 {
     Q_UNUSED(event);
     setMinimumWidth(height());
     setMaximumWidth(height());
     d->needUpdatePixmap = true;
-}
\ No newline at end of file
+}
diff --git a/libs/ui/widgets/kis_tone_curve_widget.h b/libs/ui/widgets/kis_tone_curve_widget.h
index d0d657c4ae..21f01ba563 100644
--- a/libs/ui/widgets/kis_tone_curve_widget.h
+++ b/libs/ui/widgets/kis_tone_curve_widget.h
@@ -1,67 +1,67 @@
 /* 
  * Copyright (C) 2015 by Wolthera van Hövell tot Westerflier <griffinvalley@gmail.com>
  *
  * Based on the Digikam CIE Tongue widget
  * Copyright (C) 2006-2013 by Gilles Caulier <caulier dot gilles at gmail dot com>
  *
  * Any source code are inspired from lprof project and
  * Copyright (C) 1998-2001 Marti Maria
  *
  * This program is free software; you can redistribute it
  * and/or modify it under the terms of the GNU General
  * Public License as published by the Free Software Foundation;
  * either version 2, or (at your option)
  * any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public 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_TONECURVEWIDGET_H
 #define KIS_TONECURVEWIDGET_H
  
 #include <QWidget>
 #include <QColor>
 #include <QPaintEvent>
 
 #include <kritaui_export.h>
  
 class KRITAUI_EXPORT KisToneCurveWidget : public QWidget
 {
     Q_OBJECT
  
 public:
  
     KisToneCurveWidget(QWidget *parent=0);
     ~KisToneCurveWidget() override;
 
     void setGreyscaleCurve(QPolygonF poly);
     void setRGBCurve(QPolygonF red, QPolygonF green, QPolygonF blue);
     void setCMYKCurve(QPolygonF cyan, QPolygonF magenta, QPolygonF yellow, QPolygonF key);
     void setProfileDataAvailable(bool dataAvailable);
 protected:
  
     int  grids(double val) const;
     void drawGrid();
     void resizeEvent(QResizeEvent* event) override;
     void paintEvent(QPaintEvent*) override;
  
 private:
  
     void updatePixmap();
     void mapPoint(QPointF & xy);
     void biasedLine(int x1, int y1, int x2, int y2);
     void biasedText(int x, int y, const QString& txt);
 private :
  
     class Private;
     Private* const d;
 };
 
-#endif /* KISTONECURVEWIDGET_H */
\ No newline at end of file
+#endif /* KISTONECURVEWIDGET_H */
diff --git a/libs/widgetutils/tests/CMakeLists.txt b/libs/widgetutils/tests/CMakeLists.txt
index c7b0f0ea81..ff3f6aee5c 100644
--- a/libs/widgetutils/tests/CMakeLists.txt
+++ b/libs/widgetutils/tests/CMakeLists.txt
@@ -1,29 +1,17 @@
 set( EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR} )
 include_directories (
     ${CMAKE_SOURCE_DIR}/libs/widgetutils
     ${CMAKE_SOURCE_DIR}/sdk/tests
 )
 
 include(ECMAddTests)
 
 ecm_add_tests(
+    KisActionsSnapshotTest.cpp
     KoPropertiesTest.cpp
-    NAME_PREFIX "libs-widgetutils-"
-    LINK_LIBRARIES kritawidgetutils Qt5::Test
-)
-
-# FIXME this test should be in the ui directory
-ecm_add_test(
-    kis_simple_math_parser_test.cpp
-    TEST_NAME krita-ui-KisSimpleMathParserTest
-    LINK_LIBRARIES kritaui Qt5::Test)
-
-ecm_add_test(
+    kis_simple_math_parser_test.cpp # FIXME this test should be in the ui directory
     TestKoProgressUpdater.cpp
-    TEST_NAME TestKoProgressUpdater
-    LINK_LIBRARIES kritaui Qt5::Test)
 
-ecm_add_test(
-    KisActionsSnapshotTest.cpp
     NAME_PREFIX "libs-widgetutils-"
-    LINK_LIBRARIES kritawidgetutils Qt5::Test)
+    LINK_LIBRARIES kritawidgetutils kritaimage Qt5::Test
+)
diff --git a/packaging/linux/snap/setup/gui/krita.desktop b/packaging/linux/snap/setup/gui/krita.desktop
index 1fbd6e5bd1..2704943308 100755
--- a/packaging/linux/snap/setup/gui/krita.desktop
+++ b/packaging/linux/snap/setup/gui/krita.desktop
@@ -1,137 +1,137 @@
 [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[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 %U
+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[lt]=Skaitmeninis piešimas
 GenericName[mr]=डिजिटल पेंटिंग
 GenericName[nb]=Digital maling
 GenericName[nl]=Digitaal schilderen
 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[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[nl]=Afbeeldingsbewerkingsprogramma gebaseerd op pixels voor de Calligra Suite
 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
 Categories=Qt;KDE;Graphics;
 X-KDE-NativeMimeType=application/x-krita
 X-KDE-ExtraNativeMimeTypes=
 StartupNotify=true
 X-Krita-Version=28
diff --git a/plugins/dockers/animation/kis_time_based_item_model.cpp b/plugins/dockers/animation/kis_time_based_item_model.cpp
index 11db7be8bf..d6f5384709 100644
--- a/plugins/dockers/animation/kis_time_based_item_model.cpp
+++ b/plugins/dockers/animation/kis_time_based_item_model.cpp
@@ -1,509 +1,513 @@
 /*
  *  Copyright (c) 2016 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_time_based_item_model.h"
 
 #include <QPointer>
 #include <kis_config.h>
 
 #include "kis_animation_frame_cache.h"
 #include "kis_animation_player.h"
 #include "kis_signal_compressor_with_param.h"
 #include "kis_image.h"
 #include "kis_image_animation_interface.h"
 #include "kis_time_range.h"
 #include "kis_animation_utils.h"
 #include "kis_keyframe_channel.h"
 #include "kis_processing_applicator.h"
 #include "KisImageBarrierLockerWithFeedback.h"
 #include "commands_new/kis_switch_current_time_command.h"
 #include "kis_command_utils.h"
 
 struct KisTimeBasedItemModel::Private
 {
     Private()
         : animationPlayer(0)
         , numFramesOverride(0)
         , activeFrameIndex(0)
         , scrubInProgress(false)
         , scrubStartFrame(-1)
     {}
 
     KisImageWSP image;
     KisAnimationFrameCacheWSP framesCache;
     QPointer<KisAnimationPlayer> animationPlayer;
 
     QVector<bool> cachedFrames;
 
     int numFramesOverride;
     int activeFrameIndex;
 
     bool scrubInProgress;
     int scrubStartFrame;
 
     QScopedPointer<KisSignalCompressorWithParam<int> > scrubbingCompressor;
 
     int baseNumFrames() const {
 
         auto imageSP = image.toStrongRef();
         if (!imageSP) return 0;
 
         KisImageAnimationInterface *i = imageSP->animationInterface();
         if (!i) return 1;
 
         return i->totalLength();
     }
 
     int effectiveNumFrames() const {
         if (image.isNull()) return 0;
 
         return qMax(baseNumFrames(), numFramesOverride);
     }
 
     int framesPerSecond() {
         return image->animationInterface()->framerate();
     }
 };
 
 KisTimeBasedItemModel::KisTimeBasedItemModel(QObject *parent)
     : QAbstractTableModel(parent)
     , m_d(new Private())
 {
     KisConfig cfg(true);
 
     using namespace std::placeholders;
     std::function<void (int)> callback(
         std::bind(&KisTimeBasedItemModel::slotInternalScrubPreviewRequested, this, _1));
 
     m_d->scrubbingCompressor.reset(
         new KisSignalCompressorWithParam<int>(cfg.scrubbingUpdatesDelay(), callback, KisSignalCompressor::FIRST_ACTIVE));
 }
 
 KisTimeBasedItemModel::~KisTimeBasedItemModel()
 {}
 
 void KisTimeBasedItemModel::setImage(KisImageWSP image)
 {
     KisImageWSP oldImage = m_d->image;
 
     m_d->image = image;
 
     if (image) {
         KisImageAnimationInterface *ai = image->animationInterface();
 
         slotCurrentTimeChanged(ai->currentUITime());
 
         connect(ai, SIGNAL(sigFramerateChanged()), SLOT(slotFramerateChanged()));
         connect(ai, SIGNAL(sigUiTimeChanged(int)), SLOT(slotCurrentTimeChanged(int)));
     }
 
     if (image != oldImage) {
         beginResetModel();
         endResetModel();
     }
 }
 
 void KisTimeBasedItemModel::setFrameCache(KisAnimationFrameCacheSP cache)
 {
     if (KisAnimationFrameCacheSP(m_d->framesCache) == cache) return;
 
     if (m_d->framesCache) {
         m_d->framesCache->disconnect(this);
     }
 
     m_d->framesCache = cache;
 
     if (m_d->framesCache) {
         connect(m_d->framesCache, SIGNAL(changed()), SLOT(slotCacheChanged()));
     }
 }
 
 void KisTimeBasedItemModel::setAnimationPlayer(KisAnimationPlayer *player)
 {
     if (m_d->animationPlayer == player) return;
 
     if (m_d->animationPlayer) {
         m_d->animationPlayer->disconnect(this);
     }
 
     m_d->animationPlayer = player;
 
     if (m_d->animationPlayer) {
         connect(m_d->animationPlayer, SIGNAL(sigPlaybackStopped()), SLOT(slotPlaybackStopped()));
         connect(m_d->animationPlayer, SIGNAL(sigFrameChanged()), SLOT(slotPlaybackFrameChanged()));
     }
 }
 
 void KisTimeBasedItemModel::setLastVisibleFrame(int time)
 {
     const int growThreshold = m_d->effectiveNumFrames() - 3;
     const int growValue = time + 8;
 
     const int shrinkThreshold = m_d->effectiveNumFrames() - 12;
     const int shrinkValue = qMax(m_d->baseNumFrames(), qMin(growValue, shrinkThreshold));
     const bool canShrink = m_d->effectiveNumFrames() > m_d->baseNumFrames();
 
     if (time >= growThreshold) {
         beginInsertColumns(QModelIndex(), m_d->effectiveNumFrames(), growValue - 1);
         m_d->numFramesOverride = growValue;
         endInsertColumns();
     } else if (time < shrinkThreshold && canShrink) {
         beginRemoveColumns(QModelIndex(), shrinkValue, m_d->effectiveNumFrames() - 1);
         m_d->numFramesOverride = shrinkValue;
         endRemoveColumns();
     }
 }
 
 int KisTimeBasedItemModel::columnCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent);
     return m_d->effectiveNumFrames();
 }
 
 QVariant KisTimeBasedItemModel::data(const QModelIndex &index, int role) const
 {
     switch (role) {
     case ActiveFrameRole: {
         return index.column() == m_d->activeFrameIndex;
     }
     }
 
     return QVariant();
 }
 
 bool KisTimeBasedItemModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
     if (!index.isValid()) return false;
 
     switch (role) {
     case ActiveFrameRole: {
         setHeaderData(index.column(), Qt::Horizontal, value, role);
         break;
     }
     }
 
     return false;
 }
 
 QVariant KisTimeBasedItemModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     if (orientation == Qt::Horizontal) {
         switch (role) {
         case ActiveFrameRole:
             return section == m_d->activeFrameIndex;
         case FrameCachedRole:
             return m_d->cachedFrames.size() > section ? m_d->cachedFrames[section] : false;
         case FramesPerSecondRole:
             return m_d->framesPerSecond();
         }
     }
 
     return QVariant();
 }
 
 bool KisTimeBasedItemModel::setHeaderData(int section, Qt::Orientation orientation, const QVariant &value, int role)
 {
     if (orientation == Qt::Horizontal) {
         switch (role) {
         case ActiveFrameRole:
             if (value.toBool() &&
                 section != m_d->activeFrameIndex) {
 
                 int prevFrame = m_d->activeFrameIndex;
                 m_d->activeFrameIndex = section;
 
                 scrubTo(m_d->activeFrameIndex, m_d->scrubInProgress);
 
                 /**
                  * Optimization Hack Alert:
                  *
                  * ideally, we should emit all four signals, but... The
                  * point is this code is used in a tight loop during
                  * playback, so it should run as fast as possible. To tell
                  * the story short, commenting out these three lines makes
                  * playback run 15% faster ;)
                  */
 
                 if (m_d->scrubInProgress) {
                     //emit dataChanged(this->index(0, prevFrame), this->index(rowCount() - 1, prevFrame));
                     emit dataChanged(this->index(0, m_d->activeFrameIndex), this->index(rowCount() - 1, m_d->activeFrameIndex));
                     //emit headerDataChanged (Qt::Horizontal, prevFrame, prevFrame);
                     //emit headerDataChanged (Qt::Horizontal, m_d->activeFrameIndex, m_d->activeFrameIndex);
                 } else {
                     emit dataChanged(this->index(0, prevFrame), this->index(rowCount() - 1, prevFrame));
                     emit dataChanged(this->index(0, m_d->activeFrameIndex), this->index(rowCount() - 1, m_d->activeFrameIndex));
                     emit headerDataChanged (Qt::Horizontal, prevFrame, prevFrame);
                     emit headerDataChanged (Qt::Horizontal, m_d->activeFrameIndex, m_d->activeFrameIndex);
                 }
             }
         }
     }
 
     return false;
 }
 
 bool KisTimeBasedItemModel::removeFrames(const QModelIndexList &indexes)
 {
     KisAnimationUtils::FrameItemList frameItems;
 
     {
         KisImageBarrierLockerWithFeedback locker(m_d->image);
 
         Q_FOREACH (const QModelIndex &index, indexes) {
             int time = index.column();
             Q_FOREACH(KisKeyframeChannel *channel, channelsAt(index)) {
                 if (channel->keyframeAt(time)) {
                     frameItems << KisAnimationUtils::FrameItem(channel->node(), channel->id(), index.column());
                 }
             }
         }
     }
 
     if (frameItems.isEmpty()) return false;
 
     KisAnimationUtils::removeKeyframes(m_d->image, frameItems);
 
     return true;
 }
 
-KUndo2Command* KisTimeBasedItemModel::createOffsetFramesCommand(QModelIndexList srcIndexes, const QPoint &offset, bool copyFrames, bool moveEmptyFrames, KUndo2Command *parentCommand)
+KUndo2Command* KisTimeBasedItemModel::createOffsetFramesCommand(QModelIndexList srcIndexes,
+                                                                const QPoint &offset,
+                                                                bool copyFrames,
+                                                                bool moveEmptyFrames,
+                                                                KUndo2Command *parentCommand)
 {
     if (srcIndexes.isEmpty()) return 0;
     if (offset.isNull()) return 0;
 
     KisAnimationUtils::sortPointsForSafeMove(&srcIndexes, offset);
 
     KisAnimationUtils::FrameItemList srcFrameItems;
     KisAnimationUtils::FrameItemList dstFrameItems;
 
     Q_FOREACH (const QModelIndex &srcIndex, srcIndexes) {
         QModelIndex dstIndex = index(
                 srcIndex.row() + offset.y(),
                 srcIndex.column() + offset.x());
 
         KisNodeSP srcNode = nodeAt(srcIndex);
         KisNodeSP dstNode = nodeAt(dstIndex);
         if (!srcNode || !dstNode) return 0;
 
         Q_FOREACH(KisKeyframeChannel *channel, channelsAt(srcIndex)) {
             if (moveEmptyFrames || channel->keyframeAt(srcIndex.column())) {
                 srcFrameItems << KisAnimationUtils::FrameItem(srcNode, channel->id(), srcIndex.column());
                 dstFrameItems << KisAnimationUtils::FrameItem(dstNode, channel->id(), dstIndex.column());
             }
         }
     }
 
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(srcFrameItems.size() == dstFrameItems.size(), 0);
     if (srcFrameItems.isEmpty()) return 0;
 
     return
         KisAnimationUtils::createMoveKeyframesCommand(srcFrameItems,
                                                       dstFrameItems,
                                                       copyFrames,
                                                       moveEmptyFrames,
                                                       parentCommand);
 }
 
 bool KisTimeBasedItemModel::removeFramesAndOffset(QModelIndexList indicesToRemove)
 {
     if (indicesToRemove.isEmpty()) return true;
 
     std::sort(indicesToRemove.begin(), indicesToRemove.end(),
               [] (const QModelIndex &lhs, const QModelIndex &rhs) {
                   return lhs.column() > rhs.column();
               });
 
     const int minColumn = indicesToRemove.last().column();
 
     KUndo2Command *parentCommand = new KUndo2Command(kundo2_i18np("Remove frame and shift", "Remove %1 frames and shift", indicesToRemove.size()));
 
     {
         KisImageBarrierLockerWithFeedback locker(m_d->image);
 
         Q_FOREACH (const QModelIndex &index, indicesToRemove) {
             QModelIndexList indicesToOffset;
             for (int column = index.column() + 1; column < columnCount(); column++) {
                 indicesToOffset << this->index(index.row(), column);
             }
             createOffsetFramesCommand(indicesToOffset, QPoint(-1, 0), false, true, parentCommand);
         }
 
         const int oldTime = m_d->image->animationInterface()->currentUITime();
         const int newTime = minColumn;
 
         new KisSwitchCurrentTimeCommand(m_d->image->animationInterface(),
                                         oldTime,
                                         newTime,
                                         parentCommand);
     }
 
     KisProcessingApplicator::runSingleCommandStroke(m_d->image, parentCommand, KisStrokeJobData::BARRIER);
     return true;
 }
 
 bool KisTimeBasedItemModel::mirrorFrames(QModelIndexList indexes)
 {
     QScopedPointer<KUndo2Command> parentCommand(new KUndo2Command(kundo2_i18n("Mirror Frames")));
 
     {
         KisImageBarrierLockerWithFeedback locker(m_d->image);
 
         QMap<int, QModelIndexList> rowsList;
 
         Q_FOREACH (const QModelIndex &index, indexes) {
             rowsList[index.row()].append(index);
         }
 
 
         Q_FOREACH (int row, rowsList.keys()) {
             QModelIndexList &list = rowsList[row];
 
             KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!list.isEmpty(), false);
 
             std::sort(list.begin(), list.end(),
                 [] (const QModelIndex &lhs, const QModelIndex &rhs) {
                     return lhs.column() < rhs.column();
                 });
 
             auto srcIt = list.begin();
             auto dstIt = list.end();
 
             KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(srcIt != dstIt, false);
             --dstIt;
 
             QList<KisKeyframeChannel*> channels = channelsAt(*srcIt).values();
 
             while (srcIt < dstIt) {
                 Q_FOREACH (KisKeyframeChannel *channel, channels) {
                     channel->swapFrames(srcIt->column(), dstIt->column(), parentCommand.data());
                 }
 
                 srcIt++;
                 dstIt--;
             }
         }
     }
 
     KisProcessingApplicator::runSingleCommandStroke(m_d->image,
                                                     new KisCommandUtils::SkipFirstRedoWrapper(parentCommand.take()),
                                                     KisStrokeJobData::BARRIER);
     return true;
 }
 
 void KisTimeBasedItemModel::slotInternalScrubPreviewRequested(int time)
 {
     if (m_d->animationPlayer && !m_d->animationPlayer->isPlaying()) {
         m_d->animationPlayer->displayFrame(time);
     }
 }
 
 void KisTimeBasedItemModel::setScrubState(bool active)
 {
     if (!m_d->scrubInProgress && active) {
         m_d->scrubStartFrame = m_d->activeFrameIndex;
         m_d->scrubInProgress = true;
     }
 
     if (m_d->scrubInProgress && !active) {
 
         m_d->scrubInProgress = false;
 
         if (m_d->scrubStartFrame >= 0 &&
             m_d->scrubStartFrame != m_d->activeFrameIndex) {
 
             scrubTo(m_d->activeFrameIndex, false);
         }
 
         m_d->scrubStartFrame = -1;
     }
 }
 
 void KisTimeBasedItemModel::scrubTo(int time, bool preview)
 {
     if (m_d->animationPlayer && m_d->animationPlayer->isPlaying()) return;
 
     KIS_ASSERT_RECOVER_RETURN(m_d->image);
 
     if (preview) {
         if (m_d->animationPlayer) {
             m_d->scrubbingCompressor->start(time);
         }
     } else {
         m_d->image->animationInterface()->requestTimeSwitchWithUndo(time);
     }
 }
 
 void KisTimeBasedItemModel::slotFramerateChanged()
 {
     emit headerDataChanged(Qt::Horizontal, 0, columnCount() - 1);
 }
 
 void KisTimeBasedItemModel::slotCurrentTimeChanged(int time)
 {
     if (time != m_d->activeFrameIndex) {
         setHeaderData(time, Qt::Horizontal, true, ActiveFrameRole);
     }
 }
 
 void KisTimeBasedItemModel::slotCacheChanged()
 {
     const int numFrames = columnCount();
     m_d->cachedFrames.resize(numFrames);
 
     for (int i = 0; i < numFrames; i++) {
         m_d->cachedFrames[i] =
             m_d->framesCache->frameStatus(i) == KisAnimationFrameCache::Cached;
     }
 
     emit headerDataChanged(Qt::Horizontal, 0, numFrames);
 }
 
 
 void KisTimeBasedItemModel::slotPlaybackFrameChanged()
 {
     if (!m_d->animationPlayer->isPlaying()) return;
     setData(index(0, m_d->animationPlayer->currentTime()), true, ActiveFrameRole);
 }
 
 void KisTimeBasedItemModel::slotPlaybackStopped()
 {
     setData(index(0, m_d->image->animationInterface()->currentUITime()), true, ActiveFrameRole);
 }
 
 void KisTimeBasedItemModel::setPlaybackRange(const KisTimeRange &range)
 {
     if (m_d->image.isNull()) return;
 
     KisImageAnimationInterface *i = m_d->image->animationInterface();
     i->setPlaybackRange(range);
 }
 
 bool KisTimeBasedItemModel::isPlaybackActive() const
 {
     return m_d->animationPlayer && m_d->animationPlayer->isPlaying();
 }
 
 int KisTimeBasedItemModel::currentTime() const
 {
     return m_d->image->animationInterface()->currentUITime();
 }
 
 KisImageWSP KisTimeBasedItemModel::image() const
 {
     return m_d->image;
 }
diff --git a/plugins/dockers/animation/timeline_frames_model.cpp b/plugins/dockers/animation/timeline_frames_model.cpp
index 1bbd094bf4..6eb66dffae 100644
--- a/plugins/dockers/animation/timeline_frames_model.cpp
+++ b/plugins/dockers/animation/timeline_frames_model.cpp
@@ -1,980 +1,982 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "timeline_frames_model.h"
 #include <QFont>
 #include <QSize>
 #include <QColor>
 #include <QMimeData>
 #include <QPointer>
 #include <KoResourceModel.h>
 
 #include "kis_layer.h"
 #include "kis_config.h"
 
 #include "kis_global.h"
 #include "kis_debug.h"
 #include "kis_image.h"
 #include "kis_image_animation_interface.h"
 #include "kis_undo_adapter.h"
 #include "kis_node_dummies_graph.h"
 #include "kis_dummies_facade_base.h"
 #include "kis_signal_compressor.h"
 #include "kis_signal_compressor_with_param.h"
 #include "kis_keyframe_channel.h"
 #include "kundo2command.h"
 #include "kis_post_execution_undo_adapter.h"
 #include <commands/kis_node_property_list_command.h>
 #include <commands_new/kis_switch_current_time_command.h>
 
 #include "kis_animation_utils.h"
 #include "timeline_color_scheme.h"
 #include "kis_node_model.h"
 #include "kis_projection_leaf.h"
 #include "kis_time_range.h"
 
 #include "kis_node_view_color_scheme.h"
 #include "krita_utils.h"
 #include <QApplication>
 #include "kis_processing_applicator.h"
 #include <KisImageBarrierLockerWithFeedback.h>
 #include "kis_node_uuid_info.h"
 
 
 struct TimelineFramesModel::Private
 {
     Private()
         : activeLayerIndex(0),
           dummiesFacade(0),
           needFinishInsertRows(false),
           needFinishRemoveRows(false),
           updateTimer(200, KisSignalCompressor::FIRST_INACTIVE),
           parentOfRemovedNode(0)
     {}
 
     int activeLayerIndex;
 
     QPointer<KisDummiesFacadeBase> dummiesFacade;
     KisImageWSP image;
     bool needFinishInsertRows;
     bool needFinishRemoveRows;
 
     QList<KisNodeDummy*> updateQueue;
     KisSignalCompressor updateTimer;
 
     KisNodeDummy* parentOfRemovedNode;
     QScopedPointer<TimelineNodeListKeeper> converter;
 
     QScopedPointer<NodeManipulationInterface> nodeInterface;
 
     QPersistentModelIndex lastClickedIndex;
 
     QVariant layerName(int row) const {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return QVariant();
         return dummy->node()->name();
     }
 
     bool layerEditable(int row) const {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return true;
         return dummy->node()->visible() && !dummy->node()->userLocked();
     }
 
     bool frameExists(int row, int column) const {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return false;
 
         KisKeyframeChannel *primaryChannel = dummy->node()->getKeyframeChannel(KisKeyframeChannel::Content.id());
         return (primaryChannel && primaryChannel->keyframeAt(column));
     }
 
     bool frameHasContent(int row, int column) {
 
         KisNodeDummy *dummy = converter->dummyFromRow(row);
 
         KisKeyframeChannel *primaryChannel = dummy->node()->getKeyframeChannel(KisKeyframeChannel::Content.id());
         if (!primaryChannel) return false;
 
         // first check if we are a key frame
         KisKeyframeSP frame = primaryChannel->activeKeyframeAt(column);
         if (!frame) return false;
 
         return frame->hasContent();
     }
 
     bool specialKeyframeExists(int row, int column) {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return false;
         Q_FOREACH(KisKeyframeChannel *channel, dummy->node()->keyframeChannels()) {
             if (channel->id() != KisKeyframeChannel::Content.id() && channel->keyframeAt(column)) {
                 return true;
             }
         }
         return false;
     }
 
     int frameColorLabel(int row, int column) {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return -1;
 
         KisKeyframeChannel *primaryChannel = dummy->node()->getKeyframeChannel(KisKeyframeChannel::Content.id());
         if (!primaryChannel) return -1;
 
         KisKeyframeSP frame = primaryChannel->activeKeyframeAt(column);
         if (!frame) return -1;
 
         return frame->colorLabel();
     }
 
     void setFrameColorLabel(int row, int column, int color) {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return;
 
         KisKeyframeChannel *primaryChannel = dummy->node()->getKeyframeChannel(KisKeyframeChannel::Content.id());
         if (!primaryChannel) return;
 
         KisKeyframeSP frame = primaryChannel->keyframeAt(column);
         if (!frame) return;
 
         frame->setColorLabel(color);
     }
 
     int layerColorLabel(int row) const {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return -1;
         return dummy->node()->colorLabelIndex();
     }
 
     QVariant layerProperties(int row) const {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return QVariant();
 
         PropertyList props = dummy->node()->sectionModelProperties();
         return QVariant::fromValue(props);
     }
 
     bool setLayerProperties(int row, PropertyList props) {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return false;
 
         KisNodePropertyListCommand::setNodePropertiesNoUndo(dummy->node(), image, props);
         return true;
     }
 
     bool addKeyframe(int row, int column, bool copy) {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return false;
 
         KisNodeSP node = dummy->node();
         if (!KisAnimationUtils::supportsContentFrames(node)) return false;
 
         KisAnimationUtils::createKeyframeLazy(image, node, KisKeyframeChannel::Content.id(), column, copy);
         return true;
     }
 
     bool addNewLayer(int row) {
         Q_UNUSED(row);
 
         if (nodeInterface) {
             KisLayerSP layer = nodeInterface->addPaintLayer();
             layer->setUseInTimeline(true);
         }
 
         return true;
     }
 
     bool removeLayer(int row) {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return false;
 
         if (nodeInterface) {
             nodeInterface->removeNode(dummy->node());
         }
 
         return true;
     }
 };
 
 TimelineFramesModel::TimelineFramesModel(QObject *parent)
     : ModelWithExternalNotifications(parent),
       m_d(new Private)
 {
     connect(&m_d->updateTimer, SIGNAL(timeout()), SLOT(processUpdateQueue()));
 }
 
 TimelineFramesModel::~TimelineFramesModel()
 {
 }
 
 bool TimelineFramesModel::hasConnectionToCanvas() const
 {
     return m_d->dummiesFacade;
 }
 
 void TimelineFramesModel::setNodeManipulationInterface(NodeManipulationInterface *iface)
 {
     m_d->nodeInterface.reset(iface);
 }
 
 KisNodeSP TimelineFramesModel::nodeAt(QModelIndex index) const
 {
     /**
      * The dummy might not exist because the user could (quickly) change
      * active layer and the list of the nodes in m_d->converter will change.
      */
     KisNodeDummy *dummy = m_d->converter->dummyFromRow(index.row());
     return dummy ? dummy->node() : 0;
 }
 
 QMap<QString, KisKeyframeChannel*> TimelineFramesModel::channelsAt(QModelIndex index) const
 {
     KisNodeDummy *srcDummy = m_d->converter->dummyFromRow(index.row());
     return srcDummy->node()->keyframeChannels();
 }
 
 void TimelineFramesModel::setDummiesFacade(KisDummiesFacadeBase *dummiesFacade, KisImageSP image)
 {
     KisDummiesFacadeBase *oldDummiesFacade = m_d->dummiesFacade;
 
     if (m_d->dummiesFacade && m_d->image) {
         m_d->image->animationInterface()->disconnect(this);
         m_d->image->disconnect(this);
         m_d->dummiesFacade->disconnect(this);
     }
 
     m_d->image = image;
     KisTimeBasedItemModel::setImage(image);
 
     m_d->dummiesFacade = dummiesFacade;
     m_d->converter.reset();
 
     if (m_d->dummiesFacade) {
         m_d->converter.reset(new TimelineNodeListKeeper(this, m_d->dummiesFacade));
         connect(m_d->dummiesFacade, SIGNAL(sigDummyChanged(KisNodeDummy*)),
                 SLOT(slotDummyChanged(KisNodeDummy*)));
         connect(m_d->image->animationInterface(),
                 SIGNAL(sigFullClipRangeChanged()), SIGNAL(sigInfiniteTimelineUpdateNeeded()));
         connect(m_d->image->animationInterface(),
                 SIGNAL(sigAudioChannelChanged()), SIGNAL(sigAudioChannelChanged()));
         connect(m_d->image->animationInterface(),
                 SIGNAL(sigAudioVolumeChanged()), SIGNAL(sigAudioChannelChanged()));
         connect(m_d->image, SIGNAL(sigImageModified()), SLOT(slotImageContentChanged()));
     }
 
     if (m_d->dummiesFacade != oldDummiesFacade) {
         beginResetModel();
         endResetModel();
     }
 
     if (m_d->dummiesFacade) {
         emit sigInfiniteTimelineUpdateNeeded();
         emit sigAudioChannelChanged();
     }
 }
 
 void TimelineFramesModel::slotDummyChanged(KisNodeDummy *dummy)
 {
     if (!m_d->updateQueue.contains(dummy)) {
         m_d->updateQueue.append(dummy);
     }
     m_d->updateTimer.start();
 }
 
 void TimelineFramesModel::slotImageContentChanged()
 {
     if (m_d->activeLayerIndex < 0) return;
 
     KisNodeDummy *dummy = m_d->converter->dummyFromRow(m_d->activeLayerIndex);
     if (!dummy) return;
 
     slotDummyChanged(dummy);
 }
 
 void TimelineFramesModel::processUpdateQueue()
 {
     Q_FOREACH (KisNodeDummy *dummy, m_d->updateQueue) {
         int row = m_d->converter->rowForDummy(dummy);
 
         if (row >= 0) {
             emit headerDataChanged (Qt::Vertical, row, row);
             emit dataChanged(this->index(row, 0), this->index(row, columnCount() - 1));
         }
     }
     m_d->updateQueue.clear();
 }
 
 void TimelineFramesModel::slotCurrentNodeChanged(KisNodeSP node)
 {
     if (!node) {
         m_d->activeLayerIndex = -1;
         return;
     }
 
     KisNodeDummy *dummy = m_d->dummiesFacade->dummyForNode(node);
     if (!dummy) {
         // It's perfectly normal that dummyForNode returns 0; that happens
         // when views get activated while Krita is closing down.
         return;
     }
 
     m_d->converter->updateActiveDummy(dummy);
 
     const int row = m_d->converter->rowForDummy(dummy);
     if (row < 0) {
         qWarning() << "WARNING: TimelineFramesModel::slotCurrentNodeChanged: node not found!";
     }
 
     if (row >= 0 && m_d->activeLayerIndex != row) {
         setData(index(row, 0), true, ActiveLayerRole);
     }
 }
 
 int TimelineFramesModel::rowCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent);
     if(!m_d->dummiesFacade) return 0;
 
     return m_d->converter->rowCount();
 }
 
 QVariant TimelineFramesModel::data(const QModelIndex &index, int role) const
 {
     if(!m_d->dummiesFacade) return QVariant();
 
     switch (role) {
     case ActiveLayerRole: {
         return index.row() == m_d->activeLayerIndex;
     }
     case FrameEditableRole: {
         return m_d->layerEditable(index.row());
     }
     case FrameHasContent: {
         return m_d->frameHasContent(index.row(), index.column());
     }
     case FrameExistsRole: {
         return m_d->frameExists(index.row(), index.column());
     }
     case SpecialKeyframeExists: {
         return m_d->specialKeyframeExists(index.row(), index.column());
     }
     case FrameColorLabelIndexRole: {
         int label = m_d->frameColorLabel(index.row(), index.column());
         return label > 0 ? label : QVariant();
     }
     case Qt::DisplayRole: {
         return m_d->layerName(index.row());
     }
     case Qt::TextAlignmentRole: {
         return QVariant(Qt::AlignHCenter | Qt::AlignVCenter);
     }
     case KoResourceModel::LargeThumbnailRole: {
         KisNodeDummy *dummy = m_d->converter->dummyFromRow(index.row());
         if (!dummy) {
             return  QVariant();
         }
         const int maxSize = 200;
 
         QSize size = dummy->node()->extent().size();
         size.scale(maxSize, maxSize, Qt::KeepAspectRatio);
         if (size.width() == 0 || size.height() == 0) {
             // No thumbnail can be shown if there isn't width or height...
             return QVariant();
         }
         QImage image(dummy->node()->createThumbnailForFrame(size.width(), size.height(), index.column()));
         return image;
     }
     }
 
     return ModelWithExternalNotifications::data(index, role);
 }
 
 bool TimelineFramesModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
     if (!index.isValid() || !m_d->dummiesFacade) return false;
 
     switch (role) {
     case ActiveLayerRole: {
         if (value.toBool() &&
             index.row() != m_d->activeLayerIndex) {
 
             int prevLayer = m_d->activeLayerIndex;
             m_d->activeLayerIndex = index.row();
 
             emit dataChanged(this->index(prevLayer, 0), this->index(prevLayer, columnCount() - 1));
             emit dataChanged(this->index(m_d->activeLayerIndex, 0), this->index(m_d->activeLayerIndex, columnCount() - 1));
 
             emit headerDataChanged(Qt::Vertical, prevLayer, prevLayer);
             emit headerDataChanged(Qt::Vertical, m_d->activeLayerIndex, m_d->activeLayerIndex);
 
             KisNodeDummy *dummy = m_d->converter->dummyFromRow(m_d->activeLayerIndex);
             KIS_ASSERT_RECOVER(dummy) { return true; }
 
             emit requestCurrentNodeChanged(dummy->node());
             emit sigEnsureRowVisible(m_d->activeLayerIndex);
         }
         break;
     }
     case FrameColorLabelIndexRole: {
         m_d->setFrameColorLabel(index.row(), index.column(), value.toInt());
     }
         break;
     }
 
     return ModelWithExternalNotifications::setData(index, value, role);
 }
 
 QVariant TimelineFramesModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     if(!m_d->dummiesFacade) return QVariant();
 
     if (orientation == Qt::Vertical) {
         switch (role) {
         case ActiveLayerRole:
             return section == m_d->activeLayerIndex;
         case Qt::DisplayRole: {
             QVariant value = headerData(section, orientation, Qt::ToolTipRole);
             if (!value.isValid()) return value;
 
             QString name = value.toString();
             const int maxNameSize = 13;
 
             if (name.size() > maxNameSize) {
                 name = QString("%1...").arg(name.left(maxNameSize));
             }
 
             return name;
         }
         case Qt::TextColorRole: {
             // WARNING: this role doesn't work for header views! Use
             //          bold font to show isolated mode instead!
             return QVariant();
         }
         case Qt::FontRole: {
             KisNodeDummy *dummy = m_d->converter->dummyFromRow(section);
             if (!dummy) return QVariant();
             KisNodeSP node = dummy->node();
 
             QFont baseFont;
             if (node->projectionLeaf()->isDroppedMask()) {
                 baseFont.setStrikeOut(true);
             } else if (m_d->image && m_d->image->isolatedModeRoot() &&
                        KisNodeModel::belongsToIsolatedGroup(m_d->image, node, m_d->dummiesFacade)) {
                 baseFont.setBold(true);
             }
             return baseFont;
         }
         case Qt::ToolTipRole: {
             return m_d->layerName(section);
         }
         case TimelinePropertiesRole: {
             return QVariant::fromValue(m_d->layerProperties(section));
         }
         case OtherLayersRole: {
             TimelineNodeListKeeper::OtherLayersList list =
                 m_d->converter->otherLayersList();
 
             return QVariant::fromValue(list);
         }
         case LayerUsedInTimelineRole: {
             KisNodeDummy *dummy = m_d->converter->dummyFromRow(section);
             if (!dummy) return QVariant();
             return dummy->node()->useInTimeline();
         }
         case Qt::BackgroundRole: {
             int label = m_d->layerColorLabel(section);
             if (label > 0) {
                 KisNodeViewColorScheme scm;
                 QColor color = scm.colorLabel(label);
                 QPalette pal = qApp->palette();
                 color = KritaUtils::blendColors(color, pal.color(QPalette::Button), 0.3);
                 return QBrush(color);
             } else {
                 return QVariant();
             }
         }
         }
     }
 
     return ModelWithExternalNotifications::headerData(section, orientation, role);
 }
 
 bool TimelineFramesModel::setHeaderData(int section, Qt::Orientation orientation, const QVariant &value, int role)
 {
     if (!m_d->dummiesFacade) return false;
 
     if (orientation == Qt::Vertical) {
         switch (role) {
         case ActiveLayerRole: {
             setData(index(section, 0), value, role);
             break;
         }
         case TimelinePropertiesRole: {
             TimelineFramesModel::PropertyList props = value.value<TimelineFramesModel::PropertyList>();
 
             int result = m_d->setLayerProperties(section, props);
             emit headerDataChanged (Qt::Vertical, section, section);
             return result;
         }
         case LayerUsedInTimelineRole: {
             KisNodeDummy *dummy = m_d->converter->dummyFromRow(section);
             if (!dummy) return false;
             dummy->node()->setUseInTimeline(value.toBool());
             return true;
         }
         }
     }
 
     return ModelWithExternalNotifications::setHeaderData(section, orientation, value, role);
 }
 
 Qt::DropActions TimelineFramesModel::supportedDragActions() const
 {
     return Qt::MoveAction | Qt::CopyAction;
 }
 
 Qt::DropActions TimelineFramesModel::supportedDropActions() const
 {
     return Qt::MoveAction | Qt::CopyAction;
 }
 
 QStringList TimelineFramesModel::mimeTypes() const
 {
     QStringList types;
     types << QLatin1String("application/x-krita-frame");
     return types;
 }
 
 void TimelineFramesModel::setLastClickedIndex(const QModelIndex &index)
 {
     m_d->lastClickedIndex = index;
 }
 
 QMimeData* TimelineFramesModel::mimeData(const QModelIndexList &indexes) const
 {
     return mimeDataExtended(indexes, m_d->lastClickedIndex, UndefinedPolicy);
 }
 
 QMimeData *TimelineFramesModel::mimeDataExtended(const QModelIndexList &indexes,
                                                  const QModelIndex &baseIndex,
                                                  TimelineFramesModel::MimeCopyPolicy copyPolicy) const
 {
     QMimeData *data = new QMimeData();
 
     QByteArray encoded;
     QDataStream stream(&encoded, QIODevice::WriteOnly);
 
     const int baseRow = baseIndex.row();
     const int baseColumn = baseIndex.column();
 
     stream << indexes.size();
     stream << baseRow << baseColumn;
 
     Q_FOREACH (const QModelIndex &index, indexes) {
         KisNodeSP node = nodeAt(index);
         KIS_SAFE_ASSERT_RECOVER(node) { continue; }
 
         stream << index.row() - baseRow << index.column() - baseColumn;
 
         const QByteArray uuidData = node->uuid().toRfc4122();
         stream << int(uuidData.size());
         stream.writeRawData(uuidData.data(), uuidData.size());
     }
 
     stream << int(copyPolicy);
     data->setData("application/x-krita-frame", encoded);
 
     return data;
 }
 
 inline void decodeBaseIndex(QByteArray *encoded, int *row, int *col)
 {
     int size_UNUSED = 0;
 
     QDataStream stream(encoded, QIODevice::ReadOnly);
     stream >> size_UNUSED >> *row >> *col;
 }
 
 bool TimelineFramesModel::canDropFrameData(const QMimeData */*data*/, const QModelIndex &index)
 {
     if (!index.isValid()) return false;
 
     /**
      * Now we support D&D around any layer, so just return 'true' all
      * the time.
      */
     return true;
 }
 
 bool TimelineFramesModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent)
 {
     Q_UNUSED(row);
     Q_UNUSED(column);
 
     return dropMimeDataExtended(data, action, parent);
 }
 
 bool TimelineFramesModel::dropMimeDataExtended(const QMimeData *data, Qt::DropAction action, const QModelIndex &parent, bool *dataMoved)
 {
     bool result = false;
 
     if ((action != Qt::MoveAction && action != Qt::CopyAction) ||
         !parent.isValid()) return result;
 
     QByteArray encoded = data->data("application/x-krita-frame");
     QDataStream stream(&encoded, QIODevice::ReadOnly);
 
     int size, baseRow, baseColumn;
     stream >> size >> baseRow >> baseColumn;
 
     const QPoint offset(parent.column() - baseColumn, parent.row() - baseRow);
 
     KisAnimationUtils::FrameMovePairList frameMoves;
 
     for (int i = 0; i < size; i++) {
         int relRow, relColumn;
         stream >> relRow >> relColumn;
 
         const int srcRow = baseRow + relRow;
         const int srcColumn = baseColumn + relColumn;
 
         int uuidLen = 0;
         stream >> uuidLen;
         QByteArray uuidData(uuidLen, '\0');
         stream.readRawData(uuidData.data(), uuidLen);
         QUuid nodeUuid = QUuid::fromRfc4122(uuidData);
 
         KisNodeSP srcNode;
 
         if (!nodeUuid.isNull()) {
             KisNodeUuidInfo nodeInfo(nodeUuid);
             srcNode = nodeInfo.findNode(m_d->image->root());
         } else {
             QModelIndex index = this->index(srcRow, srcColumn);
             srcNode = nodeAt(index);
         }
 
         KIS_SAFE_ASSERT_RECOVER(srcNode) { continue; }
 
         const QModelIndex dstIndex = this->index(srcRow + offset.y(), srcColumn + offset.x());
         if (!dstIndex.isValid()) continue;
 
         KisNodeSP dstNode = nodeAt(dstIndex);
         KIS_SAFE_ASSERT_RECOVER(dstNode) { continue; }
 
         Q_FOREACH (KisKeyframeChannel *channel, srcNode->keyframeChannels().values()) {
             KisAnimationUtils::FrameItem srcItem(srcNode, channel->id(), srcColumn);
             KisAnimationUtils::FrameItem dstItem(dstNode, channel->id(), dstIndex.column());
             frameMoves << std::make_pair(srcItem, dstItem);
         }
     }
 
     MimeCopyPolicy copyPolicy = UndefinedPolicy;
 
     if (!stream.atEnd()) {
         int value = 0;
         stream >> value;
         copyPolicy = MimeCopyPolicy(value);
     }
 
     const bool copyFrames =
         copyPolicy == UndefinedPolicy ?
         action == Qt::CopyAction :
         copyPolicy == CopyFramesPolicy;
 
     if (dataMoved) {
         *dataMoved = !copyFrames;
     }
 
     KUndo2Command *cmd = 0;
 
     if (!frameMoves.isEmpty()) {
         KisImageBarrierLockerWithFeedback locker(m_d->image);
         cmd = KisAnimationUtils::createMoveKeyframesCommand(frameMoves, copyFrames, false, 0);
     }
 
     if (cmd) {
         KisProcessingApplicator::runSingleCommandStroke(m_d->image, cmd, KisStrokeJobData::BARRIER);
     }
 
     return cmd;
 }
 
 Qt::ItemFlags TimelineFramesModel::flags(const QModelIndex &index) const
 {
     Qt::ItemFlags flags = ModelWithExternalNotifications::flags(index);
     if (!index.isValid()) return flags;
 
     if (m_d->frameExists(index.row(), index.column()) || m_d->specialKeyframeExists(index.row(), index.column())) {
         if (data(index, FrameEditableRole).toBool()) {
             flags |= Qt::ItemIsDragEnabled;
         }
     }
 
     /**
      * Basically we should forbid overrides only if we D&D a single frame
      * and allow it when we D&D multiple frames. But we cannot distinguish
      * it here... So allow all the time.
      */
     flags |= Qt::ItemIsDropEnabled;
 
     return flags;
 }
 
 bool TimelineFramesModel::insertRows(int row, int count, const QModelIndex &parent)
 {
     Q_UNUSED(parent);
 
     KIS_ASSERT_RECOVER(count == 1) { return false; }
 
     if (row < 0 || row > rowCount()) return false;
 
     bool result = m_d->addNewLayer(row);
     return result;
 }
 
 bool TimelineFramesModel::removeRows(int row, int count, const QModelIndex &parent)
 {
     Q_UNUSED(parent);
     KIS_ASSERT_RECOVER(count == 1) { return false; }
 
     if (row < 0 || row >= rowCount()) return false;
 
     bool result = m_d->removeLayer(row);
     return result;
 }
 
 bool TimelineFramesModel::insertOtherLayer(int index, int dstRow)
 {
     Q_UNUSED(dstRow);
 
     TimelineNodeListKeeper::OtherLayersList list =
         m_d->converter->otherLayersList();
 
     if (index < 0 || index >= list.size()) return false;
 
     list[index].dummy->node()->setUseInTimeline(true);
     dstRow = m_d->converter->rowForDummy(list[index].dummy);
     setData(this->index(dstRow, 0), true, ActiveLayerRole);
 
     return true;
 }
 
 int TimelineFramesModel::activeLayerRow() const
 {
     return m_d->activeLayerIndex;
 }
 
 bool TimelineFramesModel::createFrame(const QModelIndex &dstIndex)
 {
     if (!dstIndex.isValid()) return false;
 
     return m_d->addKeyframe(dstIndex.row(), dstIndex.column(), false);
 }
 
 bool TimelineFramesModel::copyFrame(const QModelIndex &dstIndex)
 {
     if (!dstIndex.isValid()) return false;
 
     return m_d->addKeyframe(dstIndex.row(), dstIndex.column(), true);
 }
 
 bool TimelineFramesModel::insertFrames(int dstColumn, const QList<int> &dstRows, int count, int timing)
 {
     if (dstRows.isEmpty() || count <= 0) return true;
     timing = qMax(timing, 1);
 
     KUndo2Command *parentCommand = new KUndo2Command(kundo2_i18np("Insert frame", "Insert %1 frames", count));
 
     {
         KisImageBarrierLockerWithFeedback locker(m_d->image);
 
         QModelIndexList indexes;
 
         Q_FOREACH (int row, dstRows) {
             for (int column = dstColumn; column < columnCount(); column++) {
                 indexes << index(row, column);
             }
         }
 
         setLastVisibleFrame(columnCount() + (count * timing) - 1);
 
         createOffsetFramesCommand(indexes, QPoint((count * timing), 0), false, false, parentCommand);
 
         Q_FOREACH (int row, dstRows) {
             KisNodeDummy *dummy = m_d->converter->dummyFromRow(row);
             if (!dummy) continue;
 
             KisNodeSP node = dummy->node();
             if (!KisAnimationUtils::supportsContentFrames(node)) continue;
 
             for (int column = dstColumn; column < dstColumn + (count * timing); column += timing) {
                 KisAnimationUtils::createKeyframeCommand(m_d->image, node, KisKeyframeChannel::Content.id(), column, false, parentCommand);
             }
         }
 
         const int oldTime = m_d->image->animationInterface()->currentUITime();
         const int newTime = dstColumn > oldTime ? dstColumn : dstColumn + (count * timing) - 1;
 
         new KisSwitchCurrentTimeCommand(m_d->image->animationInterface(),
                                         oldTime,
                                         newTime, parentCommand);
     }
 
     KisProcessingApplicator::runSingleCommandStroke(m_d->image, parentCommand, KisStrokeJobData::BARRIER);
 
     return true;
 }
 
 bool TimelineFramesModel::insertHoldFrames(QModelIndexList selectedIndexes, int count)
 {
     if (selectedIndexes.isEmpty() || count == 0) return true;
 
     QScopedPointer<KUndo2Command> parentCommand(new KUndo2Command(kundo2_i18np("Insert frame", "Insert %1 frames", count)));
 
     {
         KisImageBarrierLockerWithFeedback locker(m_d->image);
 
         QSet<KisKeyframeSP> uniqueKeyframesInSelection;
 
         int minSelectedTime = std::numeric_limits<int>::max();
 
         Q_FOREACH (const QModelIndex &index, selectedIndexes) {
             KisNodeSP node = nodeAt(index);
             KIS_SAFE_ASSERT_RECOVER(node) { continue; }
 
             KisKeyframeChannel *channel = node->getKeyframeChannel(KisKeyframeChannel::Content.id());
             if (!channel) continue;
 
             minSelectedTime = qMin(minSelectedTime, index.column());
             KisKeyframeSP keyFrame = channel->activeKeyframeAt(index.column());
 
             if (keyFrame) {
                 uniqueKeyframesInSelection.insert(keyFrame);
             }
         }
 
         QList<KisKeyframeSP> keyframesToMove;
 
         for (auto it = uniqueKeyframesInSelection.begin(); it != uniqueKeyframesInSelection.end(); ++it) {
             KisKeyframeSP keyframe = *it;
 
             KisKeyframeChannel *channel = keyframe->channel();
             KisKeyframeSP nextKeyframe = channel->nextKeyframe(keyframe);
 
             if (nextKeyframe) {
                 keyframesToMove << nextKeyframe;
             }
         }
 
         std::sort(keyframesToMove.begin(), keyframesToMove.end(),
             [] (KisKeyframeSP lhs, KisKeyframeSP rhs) {
                 return lhs->time() > rhs->time();
             });
 
         if (keyframesToMove.isEmpty()) return true;
 
         const int maxColumn = columnCount();
 
         if (count > 0) {
             setLastVisibleFrame(columnCount() + count);
         }
 
         Q_FOREACH (KisKeyframeSP keyframe, keyframesToMove) {
             int plannedFrameMove = count;
 
             if (count < 0) {
                 KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(keyframe->time() > 0, false);
 
                 KisKeyframeSP prevFrame = keyframe->channel()->previousKeyframe(keyframe);
                 KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(prevFrame, false);
 
                 plannedFrameMove = qMax(count, prevFrame->time() - keyframe->time() + 1);
 
                 minSelectedTime = qMin(minSelectedTime, prevFrame->time());
             }
 
             KisNodeDummy *dummy = m_d->dummiesFacade->dummyForNode(keyframe->channel()->node());
             KIS_SAFE_ASSERT_RECOVER(dummy) { continue; }
 
             const int row = m_d->converter->rowForDummy(dummy);
             KIS_SAFE_ASSERT_RECOVER(row >= 0) { continue; }
 
             QModelIndexList indexes;
             for (int column = keyframe->time(); column < maxColumn; column++) {
                 indexes << index(row, column);
             }
 
-            createOffsetFramesCommand(indexes, QPoint(plannedFrameMove, 0), false, false, parentCommand.data());
+            createOffsetFramesCommand(indexes,
+                                      QPoint(plannedFrameMove, 0),
+                                      false, true, parentCommand.data());
         }
 
         const int oldTime = m_d->image->animationInterface()->currentUITime();
         const int newTime = minSelectedTime;
 
         new KisSwitchCurrentTimeCommand(m_d->image->animationInterface(),
                                         oldTime,
                                         newTime, parentCommand.data());
     }
 
 
     KisProcessingApplicator::runSingleCommandStroke(m_d->image, parentCommand.take(), KisStrokeJobData::BARRIER);
     return true;
 }
 
 QString TimelineFramesModel::audioChannelFileName() const
 {
     return m_d->image ? m_d->image->animationInterface()->audioChannelFileName() : QString();
 }
 
 void TimelineFramesModel::setAudioChannelFileName(const QString &fileName)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->image);
     m_d->image->animationInterface()->setAudioChannelFileName(fileName);
 }
 
 bool TimelineFramesModel::isAudioMuted() const
 {
     return m_d->image ? m_d->image->animationInterface()->isAudioMuted() : false;
 }
 
 void TimelineFramesModel::setAudioMuted(bool value)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->image);
     m_d->image->animationInterface()->setAudioMuted(value);
 }
 
 qreal TimelineFramesModel::audioVolume() const
 {
     return m_d->image ? m_d->image->animationInterface()->audioVolume() : 0.5;
 }
 
 void TimelineFramesModel::setAudioVolume(qreal value)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->image);
     m_d->image->animationInterface()->setAudioVolume(value);
 }
 
 void TimelineFramesModel::setFullClipRangeStart(int column)
 {
     m_d->image->animationInterface()->setFullClipRangeStartTime(column);
 }
 
 void TimelineFramesModel::setFullClipRangeEnd(int column)
 {
     m_d->image->animationInterface()->setFullClipRangeEndTime(column);
 }
diff --git a/plugins/dockers/animation/timeline_frames_view.cpp b/plugins/dockers/animation/timeline_frames_view.cpp
index b77846d916..b3cdc8124f 100644
--- a/plugins/dockers/animation/timeline_frames_view.cpp
+++ b/plugins/dockers/animation/timeline_frames_view.cpp
@@ -1,1548 +1,1503 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "timeline_frames_view.h"
 
 #include "timeline_frames_model.h"
 #include "timeline_ruler_header.h"
 #include "timeline_layers_header.h"
 #include "timeline_insert_keyframe_dialog.h"
 #include "timeline_frames_item_delegate.h"
 
 #include <QPainter>
 #include <QApplication>
 #include <QDropEvent>
 #include <QMenu>
 #include <QScrollBar>
 #include <QDrag>
 #include <QInputDialog>
 #include <QClipboard>
 #include <QMimeData>
 
 #include "KSharedConfig"
 
 #include "kis_zoom_button.h"
 #include "kis_icon_utils.h"
 #include "kis_animation_utils.h"
 #include "kis_custom_modifiers_catcher.h"
 #include "kis_action.h"
 #include "kis_signal_compressor.h"
 #include "kis_time_range.h"
 #include "kis_color_label_selector_widget.h"
 #include "kis_slider_spin_box.h"
 #include <KisImportExportManager.h>
 #include <kis_signals_blocker.h>
 #include <kis_image_config.h>
 
 #include <KoFileDialog.h>
 #include <KoIconToolTip.h>
 
 typedef QPair<QRect, QModelIndex> QItemViewPaintPair;
 typedef QList<QItemViewPaintPair> QItemViewPaintPairs;
 
 struct TimelineFramesView::Private
 {
     Private(TimelineFramesView *_q)
         : q(_q),
           fps(1),
           zoomStillPointIndex(-1),
           zoomStillPointOriginalOffset(0),
           dragInProgress(false),
           dragWasSuccessful(false),
           modifiersCatcher(0),
           selectionChangedCompressor(300, KisSignalCompressor::FIRST_INACTIVE)
     {}
 
     TimelineFramesView *q;
 
     TimelineFramesModel *model;
     TimelineRulerHeader *horizontalRuler;
     TimelineLayersHeader *layersHeader;
     int fps;
     int zoomStillPointIndex;
     int zoomStillPointOriginalOffset;
     QPoint initialDragPanValue;
     QPoint initialDragPanPos;
 
     QToolButton *addLayersButton;
     KisAction *showHideLayerAction;
 
     QToolButton *audioOptionsButton;
 
     KisColorLabelSelectorWidget *colorSelector;
     QWidgetAction *colorSelectorAction;
     KisColorLabelSelectorWidget *multiframeColorSelector;
     QWidgetAction *multiframeColorSelectorAction;
 
     QMenu *audioOptionsMenu;
     QAction *openAudioAction;
     QAction *audioMuteAction;
     KisSliderSpinBox *volumeSlider;
 
     QMenu *layerEditingMenu;
     QMenu *existingLayersMenu;
 
     TimelineInsertKeyframeDialog *insertKeyframeDialog;
 
     KisZoomButton *zoomDragButton;
 
     bool dragInProgress;
     bool dragWasSuccessful;
 
     KisCustomModifiersCatcher *modifiersCatcher;
     QPoint lastPressedPosition;
     Qt::KeyboardModifiers lastPressedModifier;
     KisSignalCompressor selectionChangedCompressor;
 
     QStyleOptionViewItem viewOptionsV4() const;
     QItemViewPaintPairs draggablePaintPairs(const QModelIndexList &indexes, QRect *r) const;
     QPixmap renderToPixmap(const QModelIndexList &indexes, QRect *r) const;
 
     KoIconToolTip tip;
 
     KisActionManager *actionMan = 0;
 };
 
 TimelineFramesView::TimelineFramesView(QWidget *parent)
     : QTableView(parent),
       m_d(new Private(this))
 {
     m_d->modifiersCatcher = new KisCustomModifiersCatcher(this);
     m_d->modifiersCatcher->addModifier("pan-zoom", Qt::Key_Space);
     m_d->modifiersCatcher->addModifier("offset-frame", Qt::Key_Alt);
 
     setCornerButtonEnabled(false);
     setSelectionBehavior(QAbstractItemView::SelectItems);
     setSelectionMode(QAbstractItemView::ExtendedSelection);
 
     setItemDelegate(new TimelineFramesItemDelegate(this));
 
     setDragEnabled(true);
     setDragDropMode(QAbstractItemView::DragDrop);
     setAcceptDrops(true);
     setDropIndicatorShown(true);
     setDefaultDropAction(Qt::MoveAction);
 
     m_d->horizontalRuler = new TimelineRulerHeader(this);
     this->setHorizontalHeader(m_d->horizontalRuler);
 
     connect(m_d->horizontalRuler, SIGNAL(sigInsertColumnLeft()), SLOT(slotInsertKeyframeColumnLeft()));
     connect(m_d->horizontalRuler, SIGNAL(sigInsertColumnRight()), SLOT(slotInsertKeyframeColumnRight()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigInsertMultipleColumns()), SLOT(slotInsertMultipleKeyframeColumns()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigRemoveColumns()), SLOT(slotRemoveSelectedColumns()));
     connect(m_d->horizontalRuler, SIGNAL(sigRemoveColumnsAndShift()), SLOT(slotRemoveSelectedColumnsAndShift()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigInsertHoldColumns()), SLOT(slotInsertHoldFrameColumn()));
     connect(m_d->horizontalRuler, SIGNAL(sigRemoveHoldColumns()), SLOT(slotRemoveHoldFrameColumn()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigInsertHoldColumnsCustom()), SLOT(slotInsertMultipleHoldFrameColumns()));
     connect(m_d->horizontalRuler, SIGNAL(sigRemoveHoldColumnsCustom()), SLOT(slotRemoveMultipleHoldFrameColumns()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigMirrorColumns()), SLOT(slotMirrorColumns()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigCopyColumns()), SLOT(slotCopyColumns()));
     connect(m_d->horizontalRuler, SIGNAL(sigCutColumns()), SLOT(slotCutColumns()));
     connect(m_d->horizontalRuler, SIGNAL(sigPasteColumns()), SLOT(slotPasteColumns()));
 
     m_d->layersHeader = new TimelineLayersHeader(this);
 
     m_d->layersHeader->setSectionResizeMode(QHeaderView::Fixed);
 
     m_d->layersHeader->setDefaultSectionSize(24);
     m_d->layersHeader->setMinimumWidth(60);
     m_d->layersHeader->setHighlightSections(true);
 
     this->setVerticalHeader(m_d->layersHeader);
 
     connect(horizontalScrollBar(), SIGNAL(valueChanged(int)), SLOT(slotUpdateInfiniteFramesCount()));
     connect(horizontalScrollBar(), SIGNAL(sliderReleased()), SLOT(slotUpdateInfiniteFramesCount()));
 
     /********** New Layer Menu ***********************************************************/
 
     m_d->addLayersButton = new QToolButton(this);
     m_d->addLayersButton->setAutoRaise(true);
     m_d->addLayersButton->setIcon(KisIconUtils::loadIcon("addlayer"));
     m_d->addLayersButton->setIconSize(QSize(20, 20));
     m_d->addLayersButton->setPopupMode(QToolButton::InstantPopup);
 
     m_d->layerEditingMenu = new QMenu(this);
     m_d->layerEditingMenu->addAction(KisAnimationUtils::newLayerActionName, this, SLOT(slotAddNewLayer()));
     m_d->existingLayersMenu = m_d->layerEditingMenu->addMenu(KisAnimationUtils::addExistingLayerActionName);
     m_d->layerEditingMenu->addSeparator();
 
     m_d->layerEditingMenu->addAction(KisAnimationUtils::removeLayerActionName, this, SLOT(slotRemoveLayer()));
 
     connect(m_d->existingLayersMenu, SIGNAL(aboutToShow()), SLOT(slotUpdateLayersMenu()));
     connect(m_d->existingLayersMenu, SIGNAL(triggered(QAction*)), SLOT(slotAddExistingLayer(QAction*)));
 
     connect(m_d->layersHeader, SIGNAL(sigRequestContextMenu(const QPoint&)), SLOT(slotLayerContextMenuRequested(const QPoint&)));
 
     m_d->addLayersButton->setMenu(m_d->layerEditingMenu);
 
     /********** Audio Channel Menu *******************************************************/
 
     m_d->audioOptionsButton = new QToolButton(this);
     m_d->audioOptionsButton->setAutoRaise(true);
     m_d->audioOptionsButton->setIcon(KisIconUtils::loadIcon("audio-none"));
     m_d->audioOptionsButton->setIconSize(QSize(20, 20)); // very small on windows if not 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->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);
 
     connect(&m_d->selectionChangedCompressor, SIGNAL(timeout()),
             SLOT(slotSelectionChanged()));
     connect(&m_d->selectionChangedCompressor, SIGNAL(timeout()),
             SLOT(slotUpdateFrameActions()));
 
     {
         QClipboard *cb = QApplication::clipboard();
         connect(cb, SIGNAL(dataChanged()), SLOT(slotUpdateFrameActions()));
     }
 }
 
 TimelineFramesView::~TimelineFramesView()
 {
 }
 
 void TimelineFramesView::setShowInTimeline(KisAction *action)
 {
     m_d->showHideLayerAction = action;
     m_d->layerEditingMenu->addAction(m_d->showHideLayerAction);
 }
 
 void TimelineFramesView::setActionManager(KisActionManager *actionManager)
 {
     m_d->actionMan = actionManager;
     m_d->horizontalRuler->setActionManager(actionManager);
 
 
     if (actionManager) {
         KisAction *action = 0;
 
         action = m_d->actionMan->createAction("add_blank_frame");
         connect(action, SIGNAL(triggered()), SLOT(slotAddBlankFrame()));
 
         action = m_d->actionMan->createAction("add_duplicate_frame");
         connect(action, SIGNAL(triggered()), SLOT(slotAddDuplicateFrame()));
 
         action = m_d->actionMan->createAction("insert_keyframe_left");
         connect(action, SIGNAL(triggered()), SLOT(slotInsertKeyframeLeft()));
 
         action = m_d->actionMan->createAction("insert_keyframe_right");
         connect(action, SIGNAL(triggered()), SLOT(slotInsertKeyframeRight()));
 
         action = m_d->actionMan->createAction("insert_multiple_keyframes");
         connect(action, SIGNAL(triggered()), SLOT(slotInsertMultipleKeyframes()));
 
         action = m_d->actionMan->createAction("remove_frames_and_pull");
         connect(action, SIGNAL(triggered()), SLOT(slotRemoveSelectedFramesAndShift()));
 
         action = m_d->actionMan->createAction("remove_frames");
         connect(action, SIGNAL(triggered()), SLOT(slotRemoveSelectedFrames()));
 
         action = m_d->actionMan->createAction("insert_hold_frame");
         connect(action, SIGNAL(triggered()), SLOT(slotInsertHoldFrame()));
 
         action = m_d->actionMan->createAction("insert_multiple_hold_frames");
         connect(action, SIGNAL(triggered()), SLOT(slotInsertMultipleHoldFrames()));
 
         action = m_d->actionMan->createAction("remove_hold_frame");
         connect(action, SIGNAL(triggered()), SLOT(slotRemoveHoldFrame()));
 
         action = m_d->actionMan->createAction("remove_multiple_hold_frames");
         connect(action, SIGNAL(triggered()), SLOT(slotRemoveMultipleHoldFrames()));
 
         action = m_d->actionMan->createAction("mirror_frames");
         connect(action, SIGNAL(triggered()), SLOT(slotMirrorFrames()));
 
         action = m_d->actionMan->createAction("copy_frames_to_clipboard");
         connect(action, SIGNAL(triggered()), SLOT(slotCopyFrames()));
 
         action = m_d->actionMan->createAction("cut_frames_to_clipboard");
         connect(action, SIGNAL(triggered()), SLOT(slotCutFrames()));
 
         action = m_d->actionMan->createAction("paste_frames_from_clipboard");
         connect(action, SIGNAL(triggered()), SLOT(slotPasteFrames()));
 
         action = m_d->actionMan->createAction("set_start_time");
         connect(action, SIGNAL(triggered()), SLOT(slotSetStartTimeToCurrentPosition()));
 
         action = m_d->actionMan->createAction("set_end_time");
         connect(action, SIGNAL(triggered()), SLOT(slotSetEndTimeToCurrentPosition()));
 
         action = m_d->actionMan->createAction("update_playback_range");
         connect(action, SIGNAL(triggered()), SLOT(slotUpdatePlackbackRange()));
     }
 }
 
 void resizeToMinimalSize(QAbstractButton *w, int minimalSize) {
     QSize buttonSize = w->sizeHint();
     if (buttonSize.height() > minimalSize) {
         buttonSize = QSize(minimalSize, minimalSize);
     }
     w->resize(buttonSize);
 }
 
 void TimelineFramesView::updateGeometries()
 {
     QTableView::updateGeometries();
 
     const int availableHeight = m_d->horizontalRuler->height();
     const int margin = 2;
     const int minimalSize = availableHeight - 2 * margin;
 
     resizeToMinimalSize(m_d->addLayersButton, minimalSize);
     resizeToMinimalSize(m_d->audioOptionsButton, minimalSize);
     resizeToMinimalSize(m_d->zoomDragButton, minimalSize);
 
     int x = 2 * margin;
     int y = (availableHeight - minimalSize) / 2;
     m_d->addLayersButton->move(x, 2 * y);
     m_d->audioOptionsButton->move(x + minimalSize + 2 * margin, 2 * y);
 
     const int availableWidth = m_d->layersHeader->width();
 
     x = availableWidth - margin - minimalSize;
     m_d->zoomDragButton->move(x, 2 * y);
 }
 
 void TimelineFramesView::setModel(QAbstractItemModel *model)
 {
     TimelineFramesModel *framesModel = qobject_cast<TimelineFramesModel*>(model);
     m_d->model = framesModel;
 
     QTableView::setModel(model);
 
     connect(m_d->model, SIGNAL(headerDataChanged(Qt::Orientation, int, int)),
             this, SLOT(slotHeaderDataChanged(Qt::Orientation, int, int)));
 
     connect(m_d->model, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
             this, SLOT(slotDataChanged(QModelIndex,QModelIndex)));
 
     connect(m_d->model, SIGNAL(rowsRemoved(const QModelIndex&, int, int)),
             this, SLOT(slotReselectCurrentIndex()));
 
     connect(m_d->model, SIGNAL(sigInfiniteTimelineUpdateNeeded()),
             this, SLOT(slotUpdateInfiniteFramesCount()));
 
     connect(m_d->model, SIGNAL(sigAudioChannelChanged()),
             this, SLOT(slotUpdateAudioActions()));
 
     connect(selectionModel(), SIGNAL(selectionChanged(const QItemSelection &, const QItemSelection &)),
             &m_d->selectionChangedCompressor, SLOT(start()));
 
     connect(m_d->model, SIGNAL(sigEnsureRowVisible(int)), SLOT(slotEnsureRowVisible(int)));
     slotUpdateAudioActions();
 }
 
 void TimelineFramesView::setFramesPerSecond(int fps)
 {
     m_d->fps = fps;
     m_d->horizontalRuler->setFramePerSecond(fps);
 
     // For some reason simple update sometimes doesn't work here, so
     // reset the whole header
     //
     // m_d->horizontalRuler->reset();
 }
 
 void TimelineFramesView::slotZoomButtonPressed(qreal staticPoint)
 {
     m_d->zoomStillPointIndex =
             qIsNaN(staticPoint) ? currentIndex().column() : staticPoint;
 
     const int w = m_d->horizontalRuler->defaultSectionSize();
 
     m_d->zoomStillPointOriginalOffset =
             w * m_d->zoomStillPointIndex -
             horizontalScrollBar()->value();
 }
 
 void TimelineFramesView::slotZoomButtonChanged(qreal zoomLevel)
 {
     if (m_d->horizontalRuler->setZoom(zoomLevel)) {
         slotUpdateInfiniteFramesCount();
 
         const int w = m_d->horizontalRuler->defaultSectionSize();
         horizontalScrollBar()->setValue(w * m_d->zoomStillPointIndex - m_d->zoomStillPointOriginalOffset);
 
         viewport()->update();
     }
 }
 
 void TimelineFramesView::slotColorLabelChanged(int label)
 {
     Q_FOREACH(QModelIndex index, selectedIndexes()) {
         m_d->model->setData(index, label, TimelineFramesModel::FrameColorLabelIndexRole);
     }
     KisImageConfig(false).setDefaultFrameColorLabel(label);
 }
 
 void TimelineFramesView::slotSelectAudioChannelFile()
 {
     if (!m_d->model) return;
 
     QString defaultDir = QStandardPaths::writableLocation(QStandardPaths::MusicLocation);
 
     const QString currentFile = m_d->model->audioChannelFileName();
     QDir baseDir = QFileInfo(currentFile).absoluteDir();
     if (baseDir.exists()) {
         defaultDir = baseDir.absolutePath();
     }
 
     const QString result = KisImportExportManager::askForAudioFileName(defaultDir, this);
     const QFileInfo info(result);
 
     if (info.exists()) {
         m_d->model->setAudioChannelFileName(info.absoluteFilePath());
     }
 }
 
 void TimelineFramesView::slotAudioChannelMute(bool value)
 {
     if (!m_d->model) return;
 
     if (value != m_d->model->isAudioMuted()) {
         m_d->model->setAudioMuted(value);
     }
 }
 
 void TimelineFramesView::slotUpdateIcons()
 {
     m_d->addLayersButton->setIcon(KisIconUtils::loadIcon("addlayer"));
     m_d->audioOptionsButton->setIcon(KisIconUtils::loadIcon("audio-none"));
     m_d->zoomDragButton->setIcon(KisIconUtils::loadIcon("zoom-horizontal"));
 }
 
 void TimelineFramesView::slotAudioChannelRemove()
 {
     if (!m_d->model) return;
     m_d->model->setAudioChannelFileName(QString());
 }
 
 void TimelineFramesView::slotUpdateAudioActions()
 {
     if (!m_d->model) return;
 
     const QString currentFile = m_d->model->audioChannelFileName();
 
     if (currentFile.isEmpty()) {
         m_d->openAudioAction->setText(i18nc("@item:inmenu", "Open audio..."));
     } else {
         QFileInfo info(currentFile);
         m_d->openAudioAction->setText(i18nc("@item:inmenu", "Change audio (%1)...", info.fileName()));
     }
 
     m_d->audioMuteAction->setChecked(m_d->model->isAudioMuted());
 
     QIcon audioIcon;
     if (currentFile.isEmpty()) {
         audioIcon = KisIconUtils::loadIcon("audio-none");
     } else {
         if (m_d->model->isAudioMuted()) {
             audioIcon = KisIconUtils::loadIcon("audio-volume-mute");
         } else {
             audioIcon = KisIconUtils::loadIcon("audio-volume-high");
         }
     }
 
     m_d->audioOptionsButton->setIcon(audioIcon);
 
     m_d->volumeSlider->setEnabled(!m_d->model->isAudioMuted());
 
     KisSignalsBlocker b(m_d->volumeSlider);
     m_d->volumeSlider->setValue(qRound(m_d->model->audioVolume() * 100.0));
 }
 
 void TimelineFramesView::slotAudioVolumeChanged(int value)
 {
     m_d->model->setAudioVolume(qreal(value) / 100.0);
 }
 
 void TimelineFramesView::slotUpdateInfiniteFramesCount()
 {
     if (horizontalScrollBar()->isSliderDown()) return;
 
     const int sectionWidth = m_d->horizontalRuler->defaultSectionSize();
     const int calculatedIndex =
             (horizontalScrollBar()->value() +
              m_d->horizontalRuler->width() - 1) / sectionWidth;
 
     m_d->model->setLastVisibleFrame(calculatedIndex);
 }
 
 void TimelineFramesView::currentChanged(const QModelIndex &current, const QModelIndex &previous)
 {
     QTableView::currentChanged(current, previous);
 
     if (previous.column() != current.column()) {
         m_d->model->setData(previous, false, TimelineFramesModel::ActiveFrameRole);
         m_d->model->setData(current, true, TimelineFramesModel::ActiveFrameRole);
     }
 }
 
 QItemSelectionModel::SelectionFlags TimelineFramesView::selectionCommand(const QModelIndex &index,
                                                                          const QEvent *event) const
 {
     // WARNING: Copy-pasted from KisNodeView! Please keep in sync!
 
     /**
      * Qt has a bug: when we Ctrl+click on an item, the item's
      * selections gets toggled on mouse *press*, whereas usually it is
      * done on mouse *release*.  Therefore the user cannot do a
      * Ctrl+D&D with the default configuration. This code fixes the
      * problem by manually returning QItemSelectionModel::NoUpdate
      * flag when the user clicks on an item and returning
      * QItemSelectionModel::Toggle on release.
      */
 
     if (event &&
             (event->type() == QEvent::MouseButtonPress ||
              event->type() == QEvent::MouseButtonRelease) &&
             index.isValid()) {
 
         const QMouseEvent *mevent = static_cast<const QMouseEvent*>(event);
 
         if (mevent->button() == Qt::RightButton &&
                 selectionModel()->selectedIndexes().contains(index)) {
 
             // Allow calling context menu for multiple layers
             return QItemSelectionModel::NoUpdate;
         }
 
         if (event->type() == QEvent::MouseButtonPress &&
                 (mevent->modifiers() & Qt::ControlModifier)) {
 
             return QItemSelectionModel::NoUpdate;
         }
 
         if (event->type() == QEvent::MouseButtonRelease &&
                 (mevent->modifiers() & Qt::ControlModifier)) {
 
             return QItemSelectionModel::Toggle;
         }
     }
 
     return QAbstractItemView::selectionCommand(index, event);
 }
 
 void TimelineFramesView::slotSelectionChanged()
 {
     int minColumn = std::numeric_limits<int>::max();
     int maxColumn = std::numeric_limits<int>::min();
 
     foreach (const QModelIndex &idx, selectedIndexes()) {
         if (idx.column() > maxColumn) {
             maxColumn = idx.column();
         }
 
         if (idx.column() < minColumn) {
             minColumn = idx.column();
         }
     }
 
     KisTimeRange range;
     if (maxColumn > minColumn) {
         range = KisTimeRange(minColumn, maxColumn - minColumn + 1);
     }
     m_d->model->setPlaybackRange(range);
 }
 
 void TimelineFramesView::slotReselectCurrentIndex()
 {
     QModelIndex index = currentIndex();
     currentChanged(index, index);
 }
 
 void TimelineFramesView::slotEnsureRowVisible(int row)
 {
     QModelIndex index = currentIndex();
     if (!index.isValid() || row < 0) return;
 
     index = m_d->model->index(row, index.column());
     scrollTo(index);
 }
 
 void TimelineFramesView::slotDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight)
 {
     if (m_d->model->isPlaybackActive()) return;
 
     int selectedColumn = -1;
 
     for (int j = topLeft.column(); j <= bottomRight.column(); j++) {
         QVariant value = m_d->model->data(
                     m_d->model->index(topLeft.row(), j),
                     TimelineFramesModel::ActiveFrameRole);
 
         if (value.isValid() && value.toBool()) {
             selectedColumn = j;
             break;
         }
     }
 
     QModelIndex index = currentIndex();
 
     if (!index.isValid() && selectedColumn < 0) {
         return;
     }
 
 
     if (selectedColumn == -1) {
         selectedColumn = index.column();
     }
 
     if (selectedColumn != index.column() && !m_d->dragInProgress) {
         int row= index.isValid() ? index.row() : 0;
         selectionModel()->setCurrentIndex(m_d->model->index(row, selectedColumn), QItemSelectionModel::ClearAndSelect);
     }
 }
 
 void TimelineFramesView::slotHeaderDataChanged(Qt::Orientation orientation, int first, int last)
 {
     Q_UNUSED(first);
     Q_UNUSED(last);
 
     if (orientation == Qt::Horizontal) {
         const int newFps = m_d->model->headerData(0, Qt::Horizontal, TimelineFramesModel::FramesPerSecondRole).toInt();
 
         if (newFps != m_d->fps) {
             setFramesPerSecond(newFps);
         }
     }
 }
 
 void TimelineFramesView::rowsInserted(const QModelIndex& parent, int start, int end)
 {
     QTableView::rowsInserted(parent, start, end);
 }
 
 inline bool isIndexDragEnabled(QAbstractItemModel *model, const QModelIndex &index) {
     return (model->flags(index) & Qt::ItemIsDragEnabled);
 }
 
 QStyleOptionViewItem TimelineFramesView::Private::viewOptionsV4() const
 {
     QStyleOptionViewItem option = q->viewOptions();
     option.locale = q->locale();
     option.locale.setNumberOptions(QLocale::OmitGroupSeparator);
     option.widget = q;
     return option;
 }
 
 QItemViewPaintPairs TimelineFramesView::Private::draggablePaintPairs(const QModelIndexList &indexes, QRect *r) const
 {
     Q_ASSERT(r);
     QRect &rect = *r;
     const QRect viewportRect = q->viewport()->rect();
     QItemViewPaintPairs ret;
     for (int i = 0; i < indexes.count(); ++i) {
         const QModelIndex &index = indexes.at(i);
         const QRect current = q->visualRect(index);
         if (current.intersects(viewportRect)) {
             ret += qMakePair(current, index);
             rect |= current;
         }
     }
     rect &= viewportRect;
     return ret;
 }
 
 QPixmap TimelineFramesView::Private::renderToPixmap(const QModelIndexList &indexes, QRect *r) const
 {
     Q_ASSERT(r);
     QItemViewPaintPairs paintPairs = draggablePaintPairs(indexes, r);
     if (paintPairs.isEmpty())
         return QPixmap();
     QPixmap pixmap(r->size());
     pixmap.fill(Qt::transparent);
     QPainter painter(&pixmap);
     QStyleOptionViewItem option = viewOptionsV4();
     option.state |= QStyle::State_Selected;
     for (int j = 0; j < paintPairs.count(); ++j) {
         option.rect = paintPairs.at(j).first.translated(-r->topLeft());
         const QModelIndex &current = paintPairs.at(j).second;
         //adjustViewOptionsForIndex(&option, current);
 
         q->itemDelegate(current)->paint(&painter, option, current);
     }
     return pixmap;
 }
 
 void TimelineFramesView::startDrag(Qt::DropActions supportedActions)
 {
     QModelIndexList indexes = selectionModel()->selectedIndexes();
 
     if (!indexes.isEmpty() && m_d->modifiersCatcher->modifierPressed("offset-frame")) {
         QVector<int> rows;
         int leftmostColumn = std::numeric_limits<int>::max();
 
         Q_FOREACH (const QModelIndex &index, indexes) {
             leftmostColumn = qMin(leftmostColumn, index.column());
             if (!rows.contains(index.row())) {
                 rows.append(index.row());
             }
         }
 
         const int lastColumn = m_d->model->columnCount() - 1;
 
         selectionModel()->clear();
         Q_FOREACH (const int row, rows) {
             QItemSelection sel(m_d->model->index(row, leftmostColumn), m_d->model->index(row, lastColumn));
             selectionModel()->select(sel, QItemSelectionModel::Select);
         }
 
         supportedActions = Qt::MoveAction;
 
         {
             QModelIndexList indexes = selectedIndexes();
             for(int i = indexes.count() - 1 ; i >= 0; --i) {
                 if (!isIndexDragEnabled(m_d->model, indexes.at(i)))
                     indexes.removeAt(i);
             }
 
             selectionModel()->clear();
 
             if (indexes.count() > 0) {
                 QMimeData *data = m_d->model->mimeData(indexes);
                 if (!data)
                     return;
                 QRect rect;
                 QPixmap pixmap = m_d->renderToPixmap(indexes, &rect);
                 rect.adjust(horizontalOffset(), verticalOffset(), 0, 0);
                 QDrag *drag = new QDrag(this);
                 drag->setPixmap(pixmap);
                 drag->setMimeData(data);
                 drag->setHotSpot(m_d->lastPressedPosition - rect.topLeft());
                 drag->exec(supportedActions, Qt::MoveAction);
                 setCurrentIndex(currentIndex());
             }
         }
     } else {
 
         /**
          * Workaround for Qt5's bug: if we start a dragging action right during
          * Shift-selection, Qt will get crazy. We cannot workaround it easily,
          * because we would need to fork mouseMoveEvent() for that (where the
          * decision about drag state is done). So we just abort dragging in that
          * case.
          *
          * BUG:373067
          */
         if (m_d->lastPressedModifier & Qt::ShiftModifier) {
             return;
         }
 
         /**
          * Workaround for Qt5's bugs:
          *
          * 1) Qt doesn't treat selection the selection on D&D
          *    correctly, so we save it in advance and restore
          *    afterwards.
          *
          * 2) There is a private variable in QAbstractItemView:
          *    QAbstractItemView::Private::currentSelectionStartIndex.
          *    It is initialized *only* when the setCurrentIndex() is called
          *    explicitly on the view object, not on the selection model.
          *    Therefore we should explicitly call setCurrentIndex() after
          *    D&D, even if it already has *correct* value!
          *
          * 2) We should also call selectionModel()->select()
          *    explicitly.  There are two reasons for it: 1) Qt doesn't
          *    maintain selection over D&D; 2) when reselecting single
          *    element after D&D, Qt goes crazy, because it tries to
          *    read *global* keyboard modifiers. Therefore if we are
          *    dragging with Shift or Ctrl pressed it'll get crazy. So
          *    just reset it explicitly.
          */
 
         QModelIndexList selectionBefore = selectionModel()->selectedIndexes();
         QModelIndex currentBefore = selectionModel()->currentIndex();
 
         // initialize a global status variable
         m_d->dragWasSuccessful = false;
         QAbstractItemView::startDrag(supportedActions);
 
         QModelIndex newCurrent;
         QPoint selectionOffset;
 
         if (m_d->dragWasSuccessful) {
             newCurrent = currentIndex();
             selectionOffset = QPoint(newCurrent.column() - currentBefore.column(),
                                      newCurrent.row() - currentBefore.row());
         } else {
             newCurrent = currentBefore;
             selectionOffset = QPoint();
         }
 
         setCurrentIndex(newCurrent);
         selectionModel()->clearSelection();
         Q_FOREACH (const QModelIndex &idx, selectionBefore) {
             QModelIndex newIndex =
                     model()->index(idx.row() + selectionOffset.y(),
                                    idx.column() + selectionOffset.x());
             selectionModel()->select(newIndex, QItemSelectionModel::Select);
         }
     }
 }
 
 void TimelineFramesView::dragEnterEvent(QDragEnterEvent *event)
 {
     m_d->dragInProgress = true;
     m_d->model->setScrubState(true);
 
     QTableView::dragEnterEvent(event);
 }
 
 void TimelineFramesView::dragMoveEvent(QDragMoveEvent *event)
 {
     m_d->dragInProgress = true;
     m_d->model->setScrubState(true);
 
     QTableView::dragMoveEvent(event);
 
     if (event->isAccepted()) {
         QModelIndex index = indexAt(event->pos());
         if (!m_d->model->canDropFrameData(event->mimeData(), index)) {
             event->ignore();
         } else {
             selectionModel()->setCurrentIndex(index, QItemSelectionModel::NoUpdate);
         }
     }
 }
 
 void TimelineFramesView::dropEvent(QDropEvent *event)
 {
     m_d->dragInProgress = false;
     m_d->model->setScrubState(false);
 
     QAbstractItemView::dropEvent(event);
     m_d->dragWasSuccessful = event->isAccepted();
 }
 
 void TimelineFramesView::dragLeaveEvent(QDragLeaveEvent *event)
 {
     m_d->dragInProgress = false;
     m_d->model->setScrubState(false);
 
     QAbstractItemView::dragLeaveEvent(event);
 }
 
 void TimelineFramesView::createFrameEditingMenuActions(QMenu *menu, bool addFrameCreationActions)
 {
     slotUpdateFrameActions();
 
     // calculate if selection range is set. This will determine if the update playback range is available
     QSet<int> rows;
     int minColumn = 0;
     int maxColumn = 0;
     calculateSelectionMetrics(minColumn, maxColumn, rows);
 
     bool selectionExists = minColumn != maxColumn;
 
 
     if (selectionExists) {
         KisActionManager::safePopulateMenu(menu, "update_playback_range", m_d->actionMan);
     } else {
         KisActionManager::safePopulateMenu(menu, "set_start_time", m_d->actionMan);
         KisActionManager::safePopulateMenu(menu, "set_end_time", m_d->actionMan);
     }
 
     menu->addSeparator();
 
     KisActionManager::safePopulateMenu(menu, "cut_frames_to_clipboard", m_d->actionMan);
     KisActionManager::safePopulateMenu(menu, "copy_frames_to_clipboard", m_d->actionMan);
     KisActionManager::safePopulateMenu(menu, "paste_frames_from_clipboard", m_d->actionMan);
 
     menu->addSeparator();
 
     {   //Frames submenu.
         QMenu *frames = menu->addMenu(i18nc("@item:inmenu", "Keyframes"));
         KisActionManager::safePopulateMenu(frames, "insert_keyframe_left", m_d->actionMan);
         KisActionManager::safePopulateMenu(frames, "insert_keyframe_right", m_d->actionMan);
         frames->addSeparator();
         KisActionManager::safePopulateMenu(frames, "insert_multiple_keyframes", m_d->actionMan);
     }
 
     {   //Holds submenu.
         QMenu *hold = menu->addMenu(i18nc("@item:inmenu", "Hold Frames"));
         KisActionManager::safePopulateMenu(hold, "insert_hold_frame", m_d->actionMan);
         KisActionManager::safePopulateMenu(hold, "remove_hold_frame", m_d->actionMan);
         hold->addSeparator();
         KisActionManager::safePopulateMenu(hold, "insert_multiple_hold_frames", m_d->actionMan);
         KisActionManager::safePopulateMenu(hold, "remove_multiple_hold_frames", m_d->actionMan);
     }
 
     menu->addSeparator();
 
     KisActionManager::safePopulateMenu(menu, "remove_frames", m_d->actionMan);
     KisActionManager::safePopulateMenu(menu, "remove_frames_and_pull", m_d->actionMan);
 
     menu->addSeparator();
 
     if (addFrameCreationActions) {
         KisActionManager::safePopulateMenu(menu, "add_blank_frame", m_d->actionMan);
         KisActionManager::safePopulateMenu(menu, "add_duplicate_frame", m_d->actionMan);
         menu->addSeparator();
     }
 }
 
 void TimelineFramesView::mousePressEvent(QMouseEvent *event)
 {
     QPersistentModelIndex index = indexAt(event->pos());
 
     if (m_d->modifiersCatcher->modifierPressed("pan-zoom")) {
 
         if (event->button() == Qt::RightButton) {
             // TODO: try calculate index under mouse cursor even when
             //       it is outside any visible row
             qreal staticPoint = index.isValid() ? index.column() : currentIndex().column();
             m_d->zoomDragButton->beginZoom(event->pos(), staticPoint);
         } else if (event->button() == Qt::LeftButton) {
             m_d->initialDragPanPos = event->pos();
             m_d->initialDragPanValue =
                     QPoint(horizontalScrollBar()->value(),
                            verticalScrollBar()->value());
         }
         event->accept();
 
     } else if (event->button() == Qt::RightButton) {
 
         int numSelectedItems = selectionModel()->selectedIndexes().size();
 
         if (index.isValid() &&
                 numSelectedItems <= 1 &&
                 m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) {
 
             model()->setData(index, true, TimelineFramesModel::ActiveLayerRole);
             model()->setData(index, true, TimelineFramesModel::ActiveFrameRole);
             setCurrentIndex(index);
 
             if (model()->data(index, TimelineFramesModel::FrameExistsRole).toBool() ||
                     model()->data(index, TimelineFramesModel::SpecialKeyframeExists).toBool()) {
 
                 {
                     KisSignalsBlocker b(m_d->colorSelector);
                     QVariant colorLabel = index.data(TimelineFramesModel::FrameColorLabelIndexRole);
                     int labelIndex = colorLabel.isValid() ? colorLabel.toInt() : 0;
                     m_d->colorSelector->setCurrentIndex(labelIndex);
                 }
 
                 QMenu menu;
                 createFrameEditingMenuActions(&menu, false);
                 menu.addSeparator();
                 menu.addAction(m_d->colorSelectorAction);
                 menu.exec(event->globalPos());
 
             } else {
                 {
                     KisSignalsBlocker b(m_d->colorSelector);
                     const int labelIndex = KisImageConfig(true).defaultFrameColorLabel();
                     m_d->colorSelector->setCurrentIndex(labelIndex);
                 }
 
                 QMenu menu;
                 createFrameEditingMenuActions(&menu, true);
 
                 menu.addSeparator();
                 menu.addAction(m_d->colorSelectorAction);
                 menu.exec(event->globalPos());
             }
         } else if (numSelectedItems > 1) {
             int labelIndex = -1;
             bool haveFrames = false;
             Q_FOREACH(QModelIndex index, selectedIndexes()) {
                 haveFrames |= index.data(TimelineFramesModel::FrameExistsRole).toBool();
                 QVariant colorLabel = index.data(TimelineFramesModel::FrameColorLabelIndexRole);
                 if (colorLabel.isValid()) {
                     if (labelIndex == -1) {
                         // First label
                         labelIndex = colorLabel.toInt();
                     } else if (labelIndex != colorLabel.toInt()) {
                         // Mixed colors in selection
                         labelIndex = -1;
                         break;
                     }
                 }
             }
 
             if (haveFrames) {
                 KisSignalsBlocker b(m_d->multiframeColorSelector);
                 m_d->multiframeColorSelector->setCurrentIndex(labelIndex);
             }
 
             QMenu menu;
             createFrameEditingMenuActions(&menu, false);
             menu.addSeparator();
             KisActionManager::safePopulateMenu(&menu, "mirror_frames", m_d->actionMan);
             menu.addSeparator();
             menu.addAction(m_d->multiframeColorSelectorAction);
             menu.exec(event->globalPos());
         }
     } else if (event->button() == Qt::MidButton) {
         QModelIndex index = model()->buddy(indexAt(event->pos()));
         if (index.isValid()) {
             QStyleOptionViewItem option = viewOptions();
             option.rect = visualRect(index);
             // The offset of the headers is needed to get the correct position inside the view.
             m_d->tip.showTip(this, event->pos() + QPoint(verticalHeader()->width(), horizontalHeader()->height()), option, index);
         }
         event->accept();
     } else {
         if (index.isValid()) {
             m_d->model->setLastClickedIndex(index);
         }
 
         m_d->lastPressedPosition =
                 QPoint(horizontalOffset(), verticalOffset()) + event->pos();
         m_d->lastPressedModifier = event->modifiers();
 
         QAbstractItemView::mousePressEvent(event);
     }
 }
 
 void TimelineFramesView::mouseMoveEvent(QMouseEvent *e)
 {
     if (m_d->modifiersCatcher->modifierPressed("pan-zoom")) {
 
         if (e->buttons() & Qt::RightButton) {
             m_d->zoomDragButton->continueZoom(e->pos());
         } else if (e->buttons() & Qt::LeftButton) {
             QPoint diff = e->pos() - m_d->initialDragPanPos;
             QPoint offset = QPoint(m_d->initialDragPanValue.x() - diff.x(),
                                    m_d->initialDragPanValue.y() - diff.y());
 
             const int height = m_d->layersHeader->defaultSectionSize();
 
             horizontalScrollBar()->setValue(offset.x());
             verticalScrollBar()->setValue(offset.y() / height);
         }
         e->accept();
     } else if (e->buttons() == Qt::MidButton) {
         QModelIndex index = model()->buddy(indexAt(e->pos()));
         if (index.isValid()) {
             QStyleOptionViewItem option = viewOptions();
             option.rect = visualRect(index);
             // The offset of the headers is needed to get the correct position inside the view.
             m_d->tip.showTip(this, e->pos() + QPoint(verticalHeader()->width(), horizontalHeader()->height()), option, index);
         }
         e->accept();
     } else {
         m_d->model->setScrubState(true);
         QTableView::mouseMoveEvent(e);
     }
 }
 
 void TimelineFramesView::mouseReleaseEvent(QMouseEvent *e)
 {
     if (m_d->modifiersCatcher->modifierPressed("pan-zoom")) {
         e->accept();
     } else {
         m_d->model->setScrubState(false);
         QTableView::mouseReleaseEvent(e);
     }
 }
 
 void TimelineFramesView::wheelEvent(QWheelEvent *e)
 {
     QModelIndex index = currentIndex();
     int column= -1;
 
     if (index.isValid()) {
         column= index.column() + ((e->delta() > 0) ? 1 : -1);
     }
 
     if (column >= 0 && !m_d->dragInProgress) {
         setCurrentIndex(m_d->model->index(index.row(), column));
     }
 }
 
 void TimelineFramesView::slotUpdateLayersMenu()
 {
     QAction *action = 0;
 
     m_d->existingLayersMenu->clear();
 
     QVariant value = model()->headerData(0, Qt::Vertical, TimelineFramesModel::OtherLayersRole);
     if (value.isValid()) {
         TimelineFramesModel::OtherLayersList list = value.value<TimelineFramesModel::OtherLayersList>();
 
         int i = 0;
         Q_FOREACH (const TimelineFramesModel::OtherLayer &l, list) {
             action = m_d->existingLayersMenu->addAction(l.name);
             action->setData(i++);
         }
     }
 }
 
 void TimelineFramesView::slotUpdateFrameActions()
 {
     if (!m_d->actionMan) return;
 
     const QModelIndexList editableIndexes = calculateSelectionSpan(false, true);
     const bool hasEditableFrames = !editableIndexes.isEmpty();
 
     bool hasExistingFrames = false;
     Q_FOREACH (const QModelIndex &index, editableIndexes) {
         if (model()->data(index, TimelineFramesModel::FrameExistsRole).toBool()) {
             hasExistingFrames = true;
             break;
         }
     }
 
     auto enableAction = [this] (const QString &id, bool value) {
         KisAction *action = m_d->actionMan->actionByName(id);
         KIS_SAFE_ASSERT_RECOVER_RETURN(action);
         action->setEnabled(value);
     };
 
     enableAction("add_blank_frame", hasEditableFrames);
     enableAction("add_duplicate_frame", hasEditableFrames);
 
     enableAction("insert_keyframe_left", hasEditableFrames);
     enableAction("insert_keyframe_right", hasEditableFrames);
     enableAction("insert_multiple_keyframes", hasEditableFrames);
 
     enableAction("remove_frames", hasEditableFrames && hasExistingFrames);
     enableAction("remove_frames_and_pull", hasEditableFrames);
 
     enableAction("insert_hold_frame", hasEditableFrames);
     enableAction("insert_multiple_hold_frames", hasEditableFrames);
 
     enableAction("remove_hold_frame", hasEditableFrames);
     enableAction("remove_multiple_hold_frames", hasEditableFrames);
 
     enableAction("mirror_frames", hasEditableFrames && editableIndexes.size() > 1);
 
     enableAction("copy_frames_to_clipboard", true);
     enableAction("cut_frames_to_clipboard", hasEditableFrames);
 
     QClipboard *cp = QApplication::clipboard();
     const QMimeData *data = cp->mimeData();
 
     enableAction("paste_frames_from_clipboard", data && data->hasFormat("application/x-krita-frame"));
 
     //TODO: update column actions!
 }
 
 void TimelineFramesView::slotSetStartTimeToCurrentPosition()
 {
      m_d->model->setFullClipRangeStart(this->currentIndex().column());
 }
 
 void TimelineFramesView::slotSetEndTimeToCurrentPosition()
 {
     m_d->model->setFullClipRangeEnd(this->currentIndex().column());
 }
 
 void TimelineFramesView::slotUpdatePlackbackRange()
 {
     QSet<int> rows;
     int minColumn = 0;
     int maxColumn = 0;
 
     calculateSelectionMetrics(minColumn, maxColumn, rows);
 
     m_d->model->setFullClipRangeStart(minColumn);
     m_d->model->setFullClipRangeEnd(maxColumn);
 }
 
 void TimelineFramesView::slotLayerContextMenuRequested(const QPoint &globalPos)
 {
     m_d->layerEditingMenu->exec(globalPos);
 }
 
 void TimelineFramesView::slotAddNewLayer()
 {
     QModelIndex index = currentIndex();
     const int newRow = index.isValid() ? index.row() : 0;
     model()->insertRow(newRow);
 }
 
 void TimelineFramesView::slotAddExistingLayer(QAction *action)
 {
     QVariant value = action->data();
 
     if (value.isValid()) {
         QModelIndex index = currentIndex();
         const int newRow = index.isValid() ? index.row() + 1 : 0;
 
         m_d->model->insertOtherLayer(value.toInt(), newRow);
     }
 }
 
 void TimelineFramesView::slotRemoveLayer()
 {
     QModelIndex index = currentIndex();
     if (!index.isValid()) return;
 
     model()->removeRow(index.row());
 }
 
 void TimelineFramesView::slotAddBlankFrame()
 {
     QModelIndex index = currentIndex();
     if (!index.isValid() ||
         !m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) {
 
         return;
     }
 
     m_d->model->createFrame(index);
 }
 
 void TimelineFramesView::slotAddDuplicateFrame()
 {
     QModelIndex index = currentIndex();
     if (!index.isValid() ||
         !m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) {
 
         return;
     }
 
     m_d->model->copyFrame(index);
 }
 
 void TimelineFramesView::calculateSelectionMetrics(int &minColumn, int &maxColumn, QSet<int> &rows) const
 {
     minColumn = std::numeric_limits<int>::max();
     maxColumn = std::numeric_limits<int>::min();
 
     Q_FOREACH (const QModelIndex &index, selectionModel()->selectedIndexes()) {
         if (!m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) continue;
 
         rows.insert(index.row());
         minColumn = qMin(minColumn, index.column());
         maxColumn = qMax(maxColumn, index.column());
     }
 }
 
 void TimelineFramesView::insertKeyframes(int count, int timing, TimelineDirection direction, bool entireColumn)
 {
     QSet<int> rows;
     int minColumn = 0, maxColumn = 0;
 
     calculateSelectionMetrics(minColumn, maxColumn, rows);
 
     if (count <= 0) { //Negative count? Use number of selected frames.
         count = qMax(1, maxColumn - minColumn + 1);
     }
 
     const int insertionColumn =
         direction == TimelineDirection::RIGHT ?
         maxColumn + 1 : minColumn;
 
     if (entireColumn) {
         rows.clear();
         for (int i = 0; i < m_d->model->rowCount(); i++) {
             if (!m_d->model->data(m_d->model->index(i, insertionColumn), TimelineFramesModel::FrameEditableRole).toBool()) continue;
             rows.insert(i);
         }
     }
 
     if (!rows.isEmpty()) {
         m_d->model->insertFrames(insertionColumn, rows.toList(), count, timing);
     }
 }
 
 void TimelineFramesView::insertMultipleKeyframes(bool entireColumn)
 {
     int count, timing;
     TimelineDirection direction;
 
     if (m_d->insertKeyframeDialog->promptUserSettings(count, timing, direction)) {
         insertKeyframes(count, timing, direction, entireColumn);
     }
 }
 
 QModelIndexList TimelineFramesView::calculateSelectionSpan(bool entireColumn, bool editableOnly) const
 {
     QModelIndexList indexes;
 
     if (entireColumn) {
         QSet<int> rows;
         int minColumn = 0;
         int maxColumn = 0;
 
         calculateSelectionMetrics(minColumn, maxColumn, rows);
 
         rows.clear();
         for (int i = 0; i < m_d->model->rowCount(); i++) {
             if (editableOnly &&
                 !m_d->model->data(m_d->model->index(i, minColumn), TimelineFramesModel::FrameEditableRole).toBool()) continue;
 
             for (int column = minColumn; column <= maxColumn; column++) {
                 indexes << m_d->model->index(i, column);
             }
         }
     } else {
         Q_FOREACH (const QModelIndex &index, selectionModel()->selectedIndexes()) {
             if (!editableOnly || m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) {
                 indexes << index;
             }
         }
     }
 
     return indexes;
 }
 
 void TimelineFramesView::slotRemoveSelectedFrames(bool entireColumn, bool pull)
 {
     const QModelIndexList selectedIndices = calculateSelectionSpan(entireColumn);
 
     if (!selectedIndices.isEmpty()) {
         if (pull) {
             m_d->model->removeFramesAndOffset(selectedIndices);
         } else {
             m_d->model->removeFrames(selectedIndices);
         }
     }
 }
 
 void TimelineFramesView::insertOrRemoveHoldFrames(int count, bool entireColumn)
 {
     QModelIndexList indexes;
 
     if (!entireColumn) {
         Q_FOREACH (const QModelIndex &index, selectionModel()->selectedIndexes()) {
             if (m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) {
                 indexes << index;
             }
         }
     } else {
         const int column = selectionModel()->currentIndex().column();
 
         for (int i = 0; i < m_d->model->rowCount(); i++) {
             const QModelIndex index = m_d->model->index(i, column);
             if (m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) {
                 indexes << index;
             }
         }
     }
 
     if (!indexes.isEmpty()) {
         m_d->model->insertHoldFrames(indexes, count);
     }
 }
 
 void TimelineFramesView::insertOrRemoveMultipleHoldFrames(bool insertion, bool entireColumn)
 {
     bool ok = false;
     const int count = QInputDialog::getInt(this,
                                            i18nc("@title:window", "Insert or Remove Hold Frames"),
                                            i18nc("@label:spinbox", "Enter number of frames"),
-                                           defaultNumberOfFramesToAdd(),
+                                           insertion ?
+                                               m_d->insertKeyframeDialog->defaultTimingOfAddedFrames() :
+                                               m_d->insertKeyframeDialog->defaultNumberOfHoldFramesToRemove(),
                                            1, 10000, 1, &ok);
 
     if (ok) {
         if (insertion) {
-            setDefaultNumberOfFramesToAdd(count);
+            m_d->insertKeyframeDialog->setDefaultTimingOfAddedFrames(count);
             insertOrRemoveHoldFrames(count, entireColumn);
         } else {
-            setDefaultNumberOfFramesToRemove(count);
+            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();
         }
     }
 }
 
-int TimelineFramesView::defaultNumberOfFramesToAdd() const
-{
-    KConfigGroup cfg =  KSharedConfig::openConfig()->group("FrameActionsDefaultValues");
-    return cfg.readEntry("defaultNumberOfFramesToAdd", 1);
-}
-
-void TimelineFramesView::setDefaultNumberOfFramesToAdd(int value) const
-{
-    KConfigGroup cfg =  KSharedConfig::openConfig()->group("FrameActionsDefaultValues");
-    cfg.writeEntry("defaultNumberOfFramesToAdd", value);
-}
-
-int TimelineFramesView::defaultNumberOfColumnsToAdd() const
-{
-    KConfigGroup cfg =  KSharedConfig::openConfig()->group("FrameActionsDefaultValues");
-    return cfg.readEntry("defaultNumberOfColumnsToAdd", 1);
-}
-
-void TimelineFramesView::setDefaultNumberOfColumnsToAdd(int value) const
-{
-    KConfigGroup cfg =  KSharedConfig::openConfig()->group("FrameActionsDefaultValues");
-    cfg.writeEntry("defaultNumberOfColumnsToAdd", value);
-}
-
-int TimelineFramesView::defaultNumberOfFramesToRemove() const
-{
-    KConfigGroup cfg =  KSharedConfig::openConfig()->group("FrameActionsDefaultValues");
-    return cfg.readEntry("defaultNumberOfFramesToRemove", 1);
-}
-
-void TimelineFramesView::setDefaultNumberOfFramesToRemove(int value) const
-{
-    KConfigGroup cfg =  KSharedConfig::openConfig()->group("FrameActionsDefaultValues");
-    cfg.writeEntry("defaultNumberOfFramesToRemove", value);
-}
-
-int TimelineFramesView::defaultNumberOfColumnsToRemove() const
-{
-    KConfigGroup cfg =  KSharedConfig::openConfig()->group("FrameActionsDefaultValues");
-    return cfg.readEntry("defaultNumberOfColumnsToRemove", 1);
-}
-
-void TimelineFramesView::setDefaultNumberOfColumnsToRemove(int value) const
-{
-    KConfigGroup cfg =  KSharedConfig::openConfig()->group("FrameActionsDefaultValues");
-    cfg.writeEntry("defaultNumberOfColumnsToRemove", value);
-}
-
 bool TimelineFramesView::viewportEvent(QEvent *event)
 {
     if (event->type() == QEvent::ToolTip && model()) {
         QHelpEvent *he = static_cast<QHelpEvent *>(event);
         QModelIndex index = model()->buddy(indexAt(he->pos()));
         if (index.isValid()) {
             QStyleOptionViewItem option = viewOptions();
             option.rect = visualRect(index);
             // The offset of the headers is needed to get the correct position inside the view.
             m_d->tip.showTip(this, he->pos() + QPoint(verticalHeader()->width(), horizontalHeader()->height()), option, index);
             return true;
         }
     }
 
     return QTableView::viewportEvent(event);
 }
diff --git a/plugins/dockers/animation/timeline_frames_view.h b/plugins/dockers/animation/timeline_frames_view.h
index ee7315e1f2..bc6aefc8ad 100644
--- a/plugins/dockers/animation/timeline_frames_view.h
+++ b/plugins/dockers/animation/timeline_frames_view.h
@@ -1,198 +1,186 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __TIMELINE_FRAMES_VIEW_H
 #define __TIMELINE_FRAMES_VIEW_H
 
 
 #include <QScopedPointer>
 #include <QTableView>
 #include "kis_action_manager.h"
 #include "kritaanimationdocker_export.h"
 
 class KisAction;
 class TimelineWidget;
 
 enum TimelineDirection : short
 {
     LEFT = -1,
     BEFORE = -1,
 
     RIGHT = 1,
     AFTER = 1
 };
 
 
 class KRITAANIMATIONDOCKER_EXPORT TimelineFramesView : public QTableView
 {
     Q_OBJECT
 
 public:
     TimelineFramesView(QWidget *parent);
     ~TimelineFramesView() override;
 
     void setModel(QAbstractItemModel *model) override;
 
     void updateGeometries() override;
 
     void setShowInTimeline(KisAction *action);
 
     void setActionManager(KisActionManager *actionManager);
 
 public Q_SLOTS:
     void slotSelectionChanged();
     void slotUpdateIcons();
 
 private Q_SLOTS:
     void slotUpdateLayersMenu();
     void slotUpdateFrameActions();
 
     void slotSetStartTimeToCurrentPosition();
     void slotSetEndTimeToCurrentPosition();
     void slotUpdatePlackbackRange();
 
     // Layer
     void slotAddNewLayer();
     void slotAddExistingLayer(QAction *action);
     void slotDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight);
     void slotRemoveLayer();
     void slotLayerContextMenuRequested(const QPoint &globalPos);
 
     // New, Insert and Remove Frames
     void slotAddBlankFrame();
     void slotAddDuplicateFrame();
 
     void slotInsertKeyframeLeft() {insertKeyframes(-1, 1, TimelineDirection::LEFT, false);}
     void slotInsertKeyframeRight() {insertKeyframes(-1, 1, TimelineDirection::RIGHT, false);}
 
     void slotInsertKeyframeColumnLeft() {insertKeyframes(-1, 1, TimelineDirection::LEFT, true);}
     void slotInsertKeyframeColumnRight() {insertKeyframes(-1, 1, TimelineDirection::RIGHT, true);}
 
     void slotInsertMultipleKeyframes() {insertMultipleKeyframes(false);}
     void slotInsertMultipleKeyframeColumns() {insertMultipleKeyframes(true);}
 
     void slotRemoveSelectedFrames(bool entireColumn = false, bool pull = false);
     void slotRemoveSelectedFramesAndShift() {slotRemoveSelectedFrames(false, true);}
 
     void slotRemoveSelectedColumns() {slotRemoveSelectedFrames(true);}
     void slotRemoveSelectedColumnsAndShift() {slotRemoveSelectedFrames(true, true);}
 
     void slotInsertHoldFrame() {insertOrRemoveHoldFrames(1);}
     void slotRemoveHoldFrame() {insertOrRemoveHoldFrames(-1);}
 
     void slotInsertHoldFrameColumn() {insertOrRemoveHoldFrames(1,true);}
     void slotRemoveHoldFrameColumn() {insertOrRemoveHoldFrames(-1,true);}
 
     void slotInsertMultipleHoldFrames() {insertOrRemoveMultipleHoldFrames(true);}
     void slotRemoveMultipleHoldFrames() {insertOrRemoveMultipleHoldFrames(false);}
 
     void slotInsertMultipleHoldFrameColumns() {insertOrRemoveMultipleHoldFrames(true, true);}
     void slotRemoveMultipleHoldFrameColumns() {insertOrRemoveMultipleHoldFrames(false, true);}
 
     void slotMirrorFrames(bool entireColumn = false);
     void slotMirrorColumns() {slotMirrorFrames(true);}
 
     // Copy-paste
     void slotCopyFrames() {cutCopyImpl(false, true);}
     void slotCutFrames() {cutCopyImpl(false, false);}
 
     void slotCopyColumns() {cutCopyImpl(true, true);}
     void slotCutColumns() {cutCopyImpl(true, false);}
 
     void slotPasteFrames(bool entireColumn = false);
     void slotPasteColumns() {slotPasteFrames(true);}
 
     void slotReselectCurrentIndex();
 
     void slotUpdateInfiniteFramesCount();
 
     void slotHeaderDataChanged(Qt::Orientation orientation, int first, int last);
 
     void slotZoomButtonPressed(qreal staticPoint);
     void slotZoomButtonChanged(qreal value);
 
     void slotColorLabelChanged(int);
     void slotEnsureRowVisible(int row);
 
     // Audio
     void slotSelectAudioChannelFile();
     void slotAudioChannelMute(bool value);
     void slotAudioChannelRemove();
     void slotUpdateAudioActions();
     void slotAudioVolumeChanged(int value);
 
 private:
     void setFramesPerSecond(int fps);
 
     void calculateSelectionMetrics(int &minColumn, int &maxColumn, QSet<int> &rows) const;
 
     /*   Insert new keyframes/columns.
      *
      *   count        - Number of frames to add. If <0, use number of currently SELECTED frames.
      *   timing       - Animation timing of frames to be added (on 1s, 2s, 3s, etc.)
      *   direction    - Insert frames before (left) or after (right) selection scrubber.
      *   entireColumn - Create frames on all layers (rows) instead of just the active layer?
      */
     void insertKeyframes(int count = 1, int timing = 1,
                          TimelineDirection direction = TimelineDirection::LEFT, bool entireColumn = false);
     void insertMultipleKeyframes(bool entireColumn = false);
 
     void insertOrRemoveHoldFrames(int count, bool entireColumn = false);
     void insertOrRemoveMultipleHoldFrames(bool insertion, bool entireColumn = false);
 
     void cutCopyImpl(bool entireColumn, bool copy);
 
     void createFrameEditingMenuActions(QMenu *menu, bool addFrameCreationActions);
 
     QModelIndexList calculateSelectionSpan(bool entireColumn, bool editableOnly = true) const;
 
-    int defaultNumberOfFramesToAdd() const;
-    void setDefaultNumberOfFramesToAdd(int value) const;
-
-    int defaultNumberOfColumnsToAdd() const;
-    void setDefaultNumberOfColumnsToAdd(int value) const;
-
-    int defaultNumberOfFramesToRemove() const;
-    void setDefaultNumberOfFramesToRemove(int value) const;
-
-    int defaultNumberOfColumnsToRemove() const;
-    void setDefaultNumberOfColumnsToRemove(int value) const;
-
 protected:
     QItemSelectionModel::SelectionFlags selectionCommand(const QModelIndex &index,
                                                          const QEvent *event) const override;
 
     void currentChanged(const QModelIndex &current, const QModelIndex &previous) override;
     void startDrag(Qt::DropActions supportedActions) override;
     void dragEnterEvent(QDragEnterEvent *event) override;
     void dragMoveEvent(QDragMoveEvent *event) override;
     void dropEvent(QDropEvent *event) override;
     void dragLeaveEvent(QDragLeaveEvent *event) override;
     void mousePressEvent(QMouseEvent *event) override;
     void mouseMoveEvent(QMouseEvent *e) override;
     void mouseReleaseEvent(QMouseEvent *e) override;
     void wheelEvent(QWheelEvent *e) override;
     void rowsInserted(const QModelIndex &parent, int start, int end) override;
     bool viewportEvent(QEvent *event) override;
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 #endif /* __TIMELINE_FRAMES_VIEW_H */
diff --git a/plugins/dockers/animation/timeline_insert_keyframe_dialog.cpp b/plugins/dockers/animation/timeline_insert_keyframe_dialog.cpp
index 1cf6af47ea..12ca211ee2 100644
--- a/plugins/dockers/animation/timeline_insert_keyframe_dialog.cpp
+++ b/plugins/dockers/animation/timeline_insert_keyframe_dialog.cpp
@@ -1,90 +1,127 @@
 /*
  *  Copyright (c) 2018 Emmet O'Neill <emmetoneill.pdx@gmail.com>
  *  Copyright (c) 2018 Eoin O'Neill <eoinoneill1991@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  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_insert_keyframe_dialog.h"
 #include "timeline_frames_view.h"
 
 #include <QLabel>
 #include <QGroupBox>
 #include <QSpinBox>
 #include <QRadioButton>
 #include <QDialogButtonBox>
 #include <QVBoxLayout>
 #include <QFormLayout>
 #include <klocalizedstring.h>
 
+#include "KSharedConfig"
+#include "KConfigGroup"
+
+
 TimelineInsertKeyframeDialog::TimelineInsertKeyframeDialog(QWidget *parent) :
     QDialog(parent)
 {
     setWindowTitle(i18nc("@title:window","Insert Keyframes"));
     setModal(true);
     setLayout(new QVBoxLayout(this));
     {   // Count and Spacing Forms.
         QWidget *forms = new QWidget(this);
         layout()->addWidget(forms);
 
         frameCountSpinbox.setMinimum(1);
         frameCountSpinbox.setValue(1);
 
         frameTimingSpinbox.setMinimum(1);
         frameTimingSpinbox.setValue(1);
 
         QFormLayout *LO = new QFormLayout(forms);
 
 
         LO->addRow(QString(i18nc("@label:spinbox", "Number of frames:")), &frameCountSpinbox);
         LO->addRow(QString(i18nc("@label:spinbox", "Frame timing:")), &frameTimingSpinbox);
     }
     {   // Side Buttons.
         QGroupBox *sideRadioButtons = new QGroupBox(i18nc("@label:group","Side:"), this);
         layout()->addWidget(sideRadioButtons);
 
         leftBefore = new QRadioButton(i18nc("@label:radio", "Left / Before"), sideRadioButtons);
         rightAfter = new QRadioButton(i18nc("@label:radio", "Right / After"), sideRadioButtons);
         leftBefore->setChecked(true);
 
         QVBoxLayout *LO = new QVBoxLayout(sideRadioButtons);
 
         LO->addWidget(leftBefore);
         LO->addWidget(rightAfter);
     }
     {   // Cancel / OK Buttons.
         QDialogButtonBox *buttonbox = new QDialogButtonBox(QDialogButtonBox::Cancel | QDialogButtonBox::Ok);
         layout()->addWidget(buttonbox);
 
         connect(buttonbox, SIGNAL(accepted()), this, SLOT(accept()));
         connect(buttonbox, SIGNAL(rejected()), this, SLOT(reject()));
     }
 }
 
 bool TimelineInsertKeyframeDialog::promptUserSettings(int &out_count, int &out_timing, TimelineDirection &out_direction)
 {
+    KConfigGroup cfg =  KSharedConfig::openConfig()->group("FrameActionsDefaultValues");
+    frameCountSpinbox.setValue(cfg.readEntry("defaultNumberOfFramesToAdd", 1));
+    frameTimingSpinbox.setValue(defaultTimingOfAddedFrames());
+    rightAfter->setChecked(cfg.readEntry("addNewFramesToTheRight", true));
+
     if (exec() == QDialog::Accepted) {
         out_count = frameCountSpinbox.value();
         out_timing = frameTimingSpinbox.value();
 
         out_direction = TimelineDirection::LEFT; // Default
         if (rightAfter && rightAfter->isChecked()) {
             out_direction = TimelineDirection::RIGHT;
         }
 
+        cfg.writeEntry("defaultNumberOfFramesToAdd", out_count);
+        setDefaultTimingOfAddedFrames(out_timing);
+        cfg.writeEntry("addNewFramesToTheRight", rightAfter->isChecked());
+
         return true;
     }
     return false;
 }
+
+int TimelineInsertKeyframeDialog::defaultTimingOfAddedFrames() const
+{
+    KConfigGroup cfg =  KSharedConfig::openConfig()->group("FrameActionsDefaultValues");
+    return cfg.readEntry("defaultTimingOfAddedFrames", 1);
+}
+
+void TimelineInsertKeyframeDialog::setDefaultTimingOfAddedFrames(int value)
+{
+    KConfigGroup cfg =  KSharedConfig::openConfig()->group("FrameActionsDefaultValues");
+    cfg.writeEntry("defaultTimingOfAddedFrames", value);
+}
+
+int TimelineInsertKeyframeDialog::defaultNumberOfHoldFramesToRemove() const
+{
+    KConfigGroup cfg =  KSharedConfig::openConfig()->group("FrameActionsDefaultValues");
+    return cfg.readEntry("defaultNumberOfHoldFramesToRemove", 1);
+}
+
+void TimelineInsertKeyframeDialog::setDefaultNumberOfHoldFramesToRemove(int value)
+{
+    KConfigGroup cfg =  KSharedConfig::openConfig()->group("FrameActionsDefaultValues");
+    cfg.writeEntry("defaultNumberOfHoldFramesToRemove", value);
+}
diff --git a/plugins/dockers/animation/timeline_insert_keyframe_dialog.h b/plugins/dockers/animation/timeline_insert_keyframe_dialog.h
index b6392ce54f..40bfcf2a74 100644
--- a/plugins/dockers/animation/timeline_insert_keyframe_dialog.h
+++ b/plugins/dockers/animation/timeline_insert_keyframe_dialog.h
@@ -1,45 +1,52 @@
 /*
  *  Copyright (c) 2018 Emmet O'Neill <emmetoneill.pdx@gmail.com>
  *  Copyright (c) 2018 Eoin O'Neill <eoinoneill1991@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __TIMELINE_INSERT_KEYFRAME_DIALOG_H
 #define __TIMELINE_INSERT_KEYFRAME_DIALOG_H
 
 #include "kritaanimationdocker_export.h"
 #include <QDialog>
 #include <QSpinBox>
 #include <QRadioButton>
 
 enum TimelineDirection : short;
 
 class KRITAANIMATIONDOCKER_EXPORT TimelineInsertKeyframeDialog : QDialog {
     Q_OBJECT
 private:
     QSpinBox frameCountSpinbox;
     QSpinBox frameTimingSpinbox;
 
     QRadioButton *leftBefore;
     QRadioButton *rightAfter;
 
 public:
     TimelineInsertKeyframeDialog(QWidget *parent = 0);
 
     bool promptUserSettings(int &count, int &timing, TimelineDirection &out_direction);
+
+    int defaultTimingOfAddedFrames() const;
+    void setDefaultTimingOfAddedFrames(int value);
+
+    int defaultNumberOfHoldFramesToRemove() const;
+    void setDefaultNumberOfHoldFramesToRemove(int value);
+
 };
 
 #endif // __TIMELINE_INSERT_KEYFRAME_DIALOG_H
diff --git a/plugins/dockers/artisticcolorselector/artisticcolorselector_plugin.cpp b/plugins/dockers/artisticcolorselector/artisticcolorselector_plugin.cpp
index 1f7d70b6ca..7051282cd8 100644
--- a/plugins/dockers/artisticcolorselector/artisticcolorselector_plugin.cpp
+++ b/plugins/dockers/artisticcolorselector/artisticcolorselector_plugin.cpp
@@ -1,57 +1,57 @@
 /*
  *  Copyright (c) 2009 Cyrille Berger <cberger@cberger.net>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2.1 of the License.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "artisticcolorselector_plugin.h"
 #include "artisticcolorselector_dock.h"
 
 #include <kpluginfactory.h>
 #include <klocalizedstring.h>
 #include <KoDockFactoryBase.h>
 #include <KoDockRegistry.h>
 
 K_PLUGIN_FACTORY_WITH_JSON(PaletteDockPluginFactory, "krita_artisticcolorselector.json", registerPlugin<ArtisticColorSelectorPlugin>();)
 
 class ArtisticColorSelectorDockFactory: public KoDockFactoryBase
 {
 public:
     QString id() const override {
         return QString("ArtisticColorSelector");
     }
 
     virtual Qt::DockWidgetArea defaultDockWidgetArea() const {
         return Qt::RightDockWidgetArea;
     }
 
     QDockWidget* createDockWidget() override {
         ArtisticColorSelectorDock* dockWidget = new ArtisticColorSelectorDock();
         dockWidget->setObjectName(id());
         return dockWidget;
     }
 
     DockPosition defaultDockPosition() const override {
         return DockMinimized;
     }
 };
 
 
 ArtisticColorSelectorPlugin::ArtisticColorSelectorPlugin(QObject* parent, const QVariantList &):
     QObject(parent)
 {
     KoDockRegistry::instance()->add(new ArtisticColorSelectorDockFactory());
 }
 
-#include "artisticcolorselector_plugin.moc"
\ No newline at end of file
+#include "artisticcolorselector_plugin.moc"
diff --git a/plugins/dockers/lut/tests/CMakeLists.txt b/plugins/dockers/lut/tests/CMakeLists.txt
index 4fecc309b1..85cd5ecbc6 100644
--- a/plugins/dockers/lut/tests/CMakeLists.txt
+++ b/plugins/dockers/lut/tests/CMakeLists.txt
@@ -1,14 +1,15 @@
 macro_add_unittest_definitions()
 include_directories(${CMAKE_SOURCE_DIR}/sdk/tests ../)
 include_directories(SYSTEM
     ${OCIO_INCLUDE_DIR}
     )
 
 ########### next target ###############
 
 krita_add_broken_unit_test(kis_ocio_display_filter_test.cpp 
     ../black_white_point_chooser.cpp  
     ../ocio_display_filter.cpp  
     ${CMAKE_SOURCE_DIR}/sdk/tests/stroke_testing_utils.cpp
-    TEST_NAME krita-ocio-KisOcioDisplayFilterTest
-    LINK_LIBRARIES kritaimage kritaui ${OCIO_LIBRARIES} KF5::I18n Qt5::Test)
+    TEST_NAME KisOcioDisplayFilterTest
+    LINK_LIBRARIES kritaui ${OCIO_LIBRARIES} KF5::I18n Qt5::Test
+    NAME_PREFIX "plugins-dockers-lut-")
diff --git a/plugins/extensions/buginfo/dlg_buginfo.cpp b/plugins/extensions/buginfo/dlg_buginfo.cpp
index 538a8d06bf..69e7ffc47c 100644
--- a/plugins/extensions/buginfo/dlg_buginfo.cpp
+++ b/plugins/extensions/buginfo/dlg_buginfo.cpp
@@ -1,91 +1,96 @@
 /*
  * Copyright (c) 2017 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "dlg_buginfo.h"
 
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 #include <opengl/kis_opengl.h>
 #include <KritaVersionWrapper.h>
 #include <QSysInfo>
 
 #include <QDesktopWidget>
 #include <QClipboard>
 
 #include "kis_document_aware_spin_box_unit_manager.h"
 
 DlgBugInfo::DlgBugInfo(QWidget *parent)
     : KoDialog(parent)
 {
     setCaption(i18n("Please paste this information in your bug report"));
 
     setButtons(User1 | Ok);
     setButtonText(User1, i18n("Copy to clipboard"));
     setDefaultButton(Ok);
 
     m_page = new WdgBugInfo(this);
     Q_CHECK_PTR(m_page);
 
     setMainWidget(m_page);
 
     QString info;
 
     // Krita version info
     info.append("Krita");
     info.append("\n  Version: ").append(KritaVersionWrapper::versionString(true));
     info.append("\n\n");
 
+    info.append("Qt");
+    info.append("\n  Version (compiled): ").append(QT_VERSION_STR);
+    info.append("\n  Version (loaded): ").append(qVersion());
+    info.append("\n\n");
+
     // OS information
     info.append("OS Information");
     info.append("\n  Build ABI: ").append(QSysInfo::buildAbi());
     info.append("\n  Build CPU: ").append(QSysInfo::buildCpuArchitecture());
     info.append("\n  CPU: ").append(QSysInfo::currentCpuArchitecture());
     info.append("\n  Kernel Type: ").append(QSysInfo::kernelType());
     info.append("\n  Kernel Version: ").append(QSysInfo::kernelVersion());
     info.append("\n  Pretty Productname: ").append(QSysInfo::prettyProductName());
     info.append("\n  Product Type: ").append(QSysInfo::productType());
     info.append("\n  Product Version: ").append(QSysInfo::productVersion());
     info.append("\n");
 
     // OpenGL information
     info.append("\n").append(KisOpenGL::getDebugText());
 
     // Installation information
 
     // calculate a default height for the widget
     int wheight = m_page->sizeHint().height();
     m_page->txtBugInfo->setText(info);
 
     QFontMetrics fm = m_page->txtBugInfo->fontMetrics();
     int target_height = fm.height() * info.split('\n').size() + wheight;
 
     QDesktopWidget dw;
     QRect screen_rect = dw.availableGeometry(dw.primaryScreen());
 
     resize(m_page->size().width(), target_height > screen_rect.height() ? screen_rect.height() : target_height);
 
     connect(this, &KoDialog::user1Clicked, this, [this](){
         QGuiApplication::clipboard()->setText(m_page->txtBugInfo->toPlainText());
         m_page->txtBugInfo->selectAll(); // feedback
     });
 }
 
 DlgBugInfo::~DlgBugInfo()
 {
     delete m_page;
 }
diff --git a/plugins/extensions/clonesarray/dlg_clonesarray.cpp b/plugins/extensions/clonesarray/dlg_clonesarray.cpp
index 51447ae480..f553c21392 100644
--- a/plugins/extensions/clonesarray/dlg_clonesarray.cpp
+++ b/plugins/extensions/clonesarray/dlg_clonesarray.cpp
@@ -1,257 +1,257 @@
 /*
  *  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 "dlg_clonesarray.h"
 
 #include <klocalizedstring.h>
 
 #include <KoColorSpaceConstants.h>
 
 #include <kis_debug.h>
 #include <KisViewManager.h>
 #include <kis_image.h>
 #include <kis_processing_applicator.h>
 #include <commands/kis_image_commands.h>
 #include <kis_node.h>
 #include <kis_group_layer.h>
 #include <kis_clone_layer.h>
 
 
 DlgClonesArray::DlgClonesArray(KisViewManager *viewManager, QWidget *parent)
     : KoDialog(parent)
     , m_viewManager(viewManager)
     , m_applicator(0)
     , m_baseLayer(m_viewManager->activeLayer())
 {
     Q_ASSERT(m_baseLayer);
 
     setCaption(i18n("Create Clones Array"));
     setButtons(Ok | Apply | Cancel);
     setDefaultButton(Ok);
     setObjectName("clones_array_dialog");
 
     m_page = new WdgClonesArray(this);
     Q_CHECK_PTR(m_page);
     m_page->setObjectName("clones_array");
 
     setMainWidget(m_page);
     resize(m_page->sizeHint());
 
     connect(this, SIGNAL(okClicked()), SLOT(okClicked()));
     connect(this, SIGNAL(applyClicked()), SLOT(applyClicked()));
     connect(this, SIGNAL(cancelClicked()), SLOT(cancelClicked()));
 
     connect(m_page->columnXOffset, SIGNAL(valueChanged(int)), SLOT(syncOrthogonalToAngular()));
     connect(m_page->columnYOffset, SIGNAL(valueChanged(int)), SLOT(syncOrthogonalToAngular()));
     connect(m_page->rowXOffset, SIGNAL(valueChanged(int)), SLOT(syncOrthogonalToAngular()));
     connect(m_page->rowYOffset, SIGNAL(valueChanged(int)), SLOT(syncOrthogonalToAngular()));
 
     connect(m_page->columnDistance, SIGNAL(valueChanged(double)), SLOT(syncAngularToOrthogonal()));
     connect(m_page->columnAngle, SIGNAL(valueChanged(double)), SLOT(syncAngularToOrthogonal()));
     connect(m_page->rowDistance, SIGNAL(valueChanged(double)), SLOT(syncAngularToOrthogonal()));
     connect(m_page->rowAngle, SIGNAL(valueChanged(double)), SLOT(syncAngularToOrthogonal()));
 
     connect(m_page->numNegativeColumns, SIGNAL(valueChanged(int)), SLOT(setDirty()));
     connect(m_page->numPositiveColumns, SIGNAL(valueChanged(int)), SLOT(setDirty()));
     connect(m_page->numNegativeRows, SIGNAL(valueChanged(int)), SLOT(setDirty()));
     connect(m_page->numPositiveRows, SIGNAL(valueChanged(int)), SLOT(setDirty()));
 
     connect(m_page->numNegativeColumns, SIGNAL(valueChanged(int)), SLOT(updateCheckboxAvailability()));
     connect(m_page->numPositiveColumns, SIGNAL(valueChanged(int)), SLOT(updateCheckboxAvailability()));
     connect(m_page->numNegativeRows, SIGNAL(valueChanged(int)), SLOT(updateCheckboxAvailability()));
     connect(m_page->numPositiveRows, SIGNAL(valueChanged(int)), SLOT(updateCheckboxAvailability()));
 
     connect(m_page->columnPreference, SIGNAL(stateChanged(int)), SLOT(setDirty()));
 
     initializeValues();
     updateCheckboxAvailability();
 }
 
 DlgClonesArray::~DlgClonesArray()
 {
     delete m_page;
 }
 
 void DlgClonesArray::initializeValues()
 {
     if (m_baseLayer && m_baseLayer->original()) {
         QRect bounds = m_baseLayer->original()->exactBounds();
         m_page->columnXOffset->setValue(bounds.width());
         m_page->rowYOffset->setValue(bounds.height());
     }
 }
 
 void DlgClonesArray::setDirty()
 {
     m_isDirty = true;
     enableButtonApply(m_isDirty);
 }
 
 void DlgClonesArray::setClean()
 {
     m_isDirty = false;
     enableButtonApply(m_isDirty);
 }
 
 void DlgClonesArray::updateCheckboxAvailability()
 {
     m_page->columnPreference->setEnabled(
                 m_page->numNegativeColumns->value() > 0 ||
                 m_page->numNegativeRows->value() > 0);
 }
 
 void DlgClonesArray::syncOrthogonalToAngular()
 {
     setAngularSignalsEnabled(false);
 
     int x, y;
 
     x = m_page->columnXOffset->value();
     y = m_page->columnYOffset->value();
     m_page->columnDistance->setValue((float)sqrt(pow2(x) + pow2(y)));
     m_page->columnAngle->setValue(kisRadiansToDegrees(atan2((double) y, (double) x)));
 
     x = m_page->rowXOffset->value();
     y = m_page->rowYOffset->value();
     m_page->rowDistance->setValue((float)sqrt(pow2(x) + pow2(y)));
     m_page->rowAngle->setValue(kisRadiansToDegrees(atan2((double) y, (double) x)));
 
     setAngularSignalsEnabled(true);
     setDirty();
 }
 
 void DlgClonesArray::syncAngularToOrthogonal()
 {
     setOrthogonalSignalsEnabled(false);
 
     qreal a, d;
 
     d = m_page->columnDistance->value();
     a = kisDegreesToRadians(m_page->columnAngle->value());
     m_page->columnXOffset->setValue(qRound(d * cos(a)));
     m_page->columnYOffset->setValue(qRound(d * sin(a)));
 
     d = m_page->rowDistance->value();
     a = kisDegreesToRadians(m_page->rowAngle->value());
     m_page->rowXOffset->setValue(qRound(d * cos(a)));
     m_page->rowYOffset->setValue(qRound(d * sin(a)));
 
     setOrthogonalSignalsEnabled(true);
     setDirty();
 }
 
 void DlgClonesArray::setOrthogonalSignalsEnabled(bool value)
 {
     m_page->columnXOffset->blockSignals(!value);
     m_page->columnYOffset->blockSignals(!value);
     m_page->rowXOffset->blockSignals(!value);
     m_page->rowYOffset->blockSignals(!value);
 }
 
 void DlgClonesArray::setAngularSignalsEnabled(bool value)
 {
     m_page->columnDistance->blockSignals(!value);
     m_page->columnAngle->blockSignals(!value);
     m_page->rowDistance->blockSignals(!value);
     m_page->rowAngle->blockSignals(!value);
 }
 
 void DlgClonesArray::okClicked()
 {
     if (!m_applicator || m_isDirty) {
         reapplyClones();
     }
 
     Q_ASSERT(m_applicator);
 
     m_applicator->end();
     delete m_applicator;
     m_applicator = 0;
 }
 
 void DlgClonesArray::applyClicked()
 {
     reapplyClones();
 }
 
 void DlgClonesArray::cancelClicked()
 {
     if (m_applicator) {
         m_applicator->cancel();
         delete m_applicator;
         m_applicator = 0;
     }
 }
 
 void DlgClonesArray::reapplyClones()
 {
     cancelClicked();
 
     KisImageSP image = m_viewManager->image();
 
     if (!m_viewManager->blockUntilOperationsFinished(image)) return;
 
     m_applicator =
             new KisProcessingApplicator(image, 0,
                                         KisProcessingApplicator::NONE,
                                         KisImageSignalVector() << ModifiedSignal);
 
     int columnXOffset = m_page->columnXOffset->value();
     int columnYOffset = m_page->columnYOffset->value();
     int rowXOffset = m_page->rowXOffset->value();
     int rowYOffset = m_page->rowYOffset->value();
     bool rowPreference = !m_page->columnPreference->isChecked();
 
     int startColumn = -m_page->numNegativeColumns->value();
     int startRow = -m_page->numNegativeRows->value();
 
     int endColumn = m_page->numPositiveColumns->value() - 1;
     int endRow = m_page->numPositiveRows->value() - 1;
 
-    QString positiveGroupName = QString(i18n("+ Array of %1")).arg(m_baseLayer->name());
+    QString positiveGroupName = i18n("+ Array of %1", m_baseLayer->name());
     KisGroupLayerSP positiveGroupLayer = new KisGroupLayer(image, positiveGroupName, OPACITY_OPAQUE_U8);
     m_applicator->applyCommand(new KisImageLayerAddCommand(image, positiveGroupLayer, m_baseLayer->parent(), m_baseLayer, false, true), KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
 
     KisGroupLayerSP negativeGroupLayer;
 
     if (startRow < 0 || startColumn < 0) {
-        QString negativeGroupName = QString(i18n("- Array of %1")).arg(m_baseLayer->name());
+        QString negativeGroupName = i18n("- Array of %1", m_baseLayer->name());
         negativeGroupLayer = new KisGroupLayer(image, negativeGroupName, OPACITY_OPAQUE_U8);
         m_applicator->applyCommand(new KisImageLayerAddCommand(image, negativeGroupLayer, m_baseLayer->parent(), m_baseLayer->prevSibling(), false, true), KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
     }
 
     for (int row = endRow; row >= startRow; row--) {
         for (int col = endColumn; col >= startColumn; col--) {
             if (!col && !row) continue;
 
             bool choosePositiveGroup = rowPreference ? row > 0 || (row == 0 && col > 0) : col > 0 || (col == 0 && row > 0);
             KisNodeSP parent = choosePositiveGroup ? positiveGroupLayer : negativeGroupLayer;
 
 
-            QString cloneName = QString("Clone %1, %2").arg(col).arg(row);
+            QString cloneName = i18n("Clone %1, %2", col, row);
             KisCloneLayerSP clone = new KisCloneLayer(m_baseLayer, image, cloneName, OPACITY_OPAQUE_U8);
             clone->setX(-row * rowXOffset + col * columnXOffset);
             clone->setY(-row * rowYOffset + col * columnYOffset);
 
             m_applicator->applyCommand(new KisImageLayerAddCommand(image, clone, parent, 0, true, false), KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
         }
     }
 
     setClean();
 }
 
diff --git a/plugins/extensions/metadataeditor/kis_meta_data_model.cpp b/plugins/extensions/metadataeditor/kis_meta_data_model.cpp
index 4f91736f8b..c06f10fc14 100644
--- a/plugins/extensions/metadataeditor/kis_meta_data_model.cpp
+++ b/plugins/extensions/metadataeditor/kis_meta_data_model.cpp
@@ -1,113 +1,115 @@
 /*
  *  Copyright (c) 2010 Cyrille Berger <cberger@cberger.net>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; either version 2.1 of the License, or
  *  (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_meta_data_model.h"
 
 #include <klocalizedstring.h>
 
 #include <metadata/kis_meta_data_store.h>
 #include <metadata/kis_meta_data_entry.h>
 #include <metadata/kis_meta_data_value.h>
 
 KisMetaDataModel::KisMetaDataModel(KisMetaData::Store* store) : m_store(store)
 {
 
 }
 
 int KisMetaDataModel::rowCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent);
     return m_store->keys().count();
 }
 
 int KisMetaDataModel::columnCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent);
     return 3;
 }
 
 QVariant KisMetaDataModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid()) {
         return QVariant();
     }
     Q_ASSERT(index.row() < m_store->keys().count());
     switch (role) {
     case Qt::DisplayRole: {
         switch (index.column()) {
         case 0:
             return m_store->keys()[index.row()];
         case 1: {
             KisMetaData::Value::ValueType vt = m_store->entries()[index.row()].value().type();
             switch (vt) {
             case KisMetaData::Value::Invalid:
                 return i18n("Invalid");
             case KisMetaData::Value::Variant: {
                 int vt = m_store->entries()[index.row()].value().asVariant().type();
                 switch (vt) {
                 case QVariant::Date:
                 case QVariant::DateTime:
                     return i18n("Date");
                 case QVariant::Double:
                 case QVariant::Int:
                     return i18n("Number");
                 case QVariant::String:
                     return i18n("String");
                 default:
                     return i18n("Variant (%1)", vt);
                 }
             }
             case KisMetaData::Value::OrderedArray:
                 return i18n("Ordered array");
             case KisMetaData::Value::UnorderedArray:
                 return i18n("Unordered array");
             case KisMetaData::Value::AlternativeArray:
                 return i18n("Alternative array");
             case KisMetaData::Value::LangArray:
                 return i18n("Language array");
             case KisMetaData::Value::Structure:
                 return i18n("Structure");
             case KisMetaData::Value::Rational:
                 return i18n("Rational");
             }
             break;
         }
         case 2:
             return m_store->entries()[index.row()].value().toString();
         }
+        break;
     }
     default:
         return QVariant();
     }
+    return QVariant();
 }
 
 QVariant KisMetaDataModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     if (orientation == Qt::Horizontal && role == Qt::DisplayRole) {
         Q_ASSERT(section < 3);
         switch (section) {
         case 0:
             return i18n("Key");
         case 1:
             return i18n("Type");
         case 2:
             return i18nc("Metadata item value", "Value");
         }
     }
     return QVariant();
 }
diff --git a/plugins/extensions/pykrita/sip/krita/Document.sip b/plugins/extensions/pykrita/sip/krita/Document.sip
index a5f5475f03..d56cebc266 100644
--- a/plugins/extensions/pykrita/sip/krita/Document.sip
+++ b/plugins/extensions/pykrita/sip/krita/Document.sip
@@ -1,87 +1,88 @@
 class Document : QObject /NoDefaultCtors/
 {
 %TypeHeaderCode
 #include "Document.h"
 %End
     Document(const Document & __0);
 public:
     bool operator==(const Document &other) const;
     bool operator!=(const Document &other) const;
 
     QList<qreal> horizontalGuides() const;
     QList<qreal> verticalGuides() const;
     bool guidesVisible() const;
     bool guidesLocked() const;
 public Q_SLOTS:
 
     Document *clone() const /Factory/;
     Node * activeNode() const  /Factory/;
     void setActiveNode(Node*  value);
     QList<Node*> topLevelNodes() const  /Factory/;
     Node *nodeByName(const QString &node) const  /Factory/;
     bool batchmode() const;
     void setBatchmode(bool value);
     QString colorDepth() const;
     QString colorModel() const;
     QString colorProfile() const;
     bool setColorProfile(const QString &colorProfile);
     bool setColorSpace(const QString &value, const QString &colorDepth, const QString &colorProfile);
     QColor backgroundColor();
     bool setBackgroundColor(const QColor &color);
     QString documentInfo() const;
     void setDocumentInfo(const QString &document);
     QString fileName() const;
     void setFileName(QString value);
     int height() const;
     void setHeight(int value);
     QString name() const;
     void setName(QString value);
     int resolution() const;
     void setResolution(int value);
     Node * rootNode() const  /Factory/;
     Selection * selection() const  /Factory/;
     void setSelection(Selection*  value);
     int width() const;
     void setWidth(int value);
     int xOffset() const;
     void setXOffset(int x);
     int yOffset() const;
     void setYOffset(int y);
     double xRes() const;
     void setXRes(double xRes) const;
     double yRes() const;
     void setYRes(double yRes) const;
     QByteArray pixelData(int x, int y, int w, int h) const;
     bool close();
     void crop(int x, int y, int w, int h);
     bool exportImage(const QString &filename, const InfoObject & exportConfiguration);
     void flatten();
     void resizeImage(int x, int y, int w, int h);
     void scaleImage(int w, int h, int xres, int yres, QString strategy);
     void rotateImage(double radians);
     void shearImage(double angleX, double angleY);
     bool save();
     bool saveAs(const QString & filename);
     Node *createNode(const QString & name, const QString & nodeType)  /Factory/;
     GroupLayer *createGroupLayer(const QString &name) /Factory/;
     CloneLayer *createCloneLayer(const QString &name, const Node *source) /Factory/;
     FilterLayer *createFilterLayer(const QString &name, Filter &filter, Selection &selection) /Factory/;
     FillLayer *createFillLayer(const QString &name, const QString filterName, InfoObject &configuration, Selection &selection) /Factory/;
     VectorLayer *createVectorLayer(const QString &name) /Factory/;
     FilterMask *createFilterMask(const QString &name, Filter &filter) /Factory/;
     SelectionMask *createSelectionMask(const QString &name) /Factory/;
     QImage projection(int x = 0, int y = 0, int w = 0, int h = 0) const;
     QImage thumbnail(int w, int h) const;
     void lock();
     void unlock();
     void waitForDone();
     bool tryBarrierLock();
     bool isIdle();
     void refreshProjection();
     void setHorizontalGuides(const QList<qreal> &lines);
     void setVerticalGuides(const QList<qreal> &lines);
     void setGuidesVisible(bool visible);
     void setGuidesLocked(bool locked);
+    bool modified() const;
 private:
 
 };
diff --git a/plugins/extensions/pykrita/sip/krita/Filter.sip b/plugins/extensions/pykrita/sip/krita/Filter.sip
index ff61085a88..a6106841cb 100644
--- a/plugins/extensions/pykrita/sip/krita/Filter.sip
+++ b/plugins/extensions/pykrita/sip/krita/Filter.sip
@@ -1,22 +1,22 @@
 class Filter : QObject
 {
 %TypeHeaderCode
 #include "Filter.h"
 %End
     Filter(const Filter & __0);
 
 public:
     Filter();
     virtual ~Filter();
     bool operator==(const Filter &other) const;
     bool operator!=(const Filter &other) const;
 
 public Q_SLOTS:
     QString name() const;
     void setName(const QString &);
     InfoObject * configuration() const;
-    void setConfiguration(InfoObject*  value);
+    void setConfiguration(InfoObject*  value /TransferThis/ );
     void apply(Node *node, int x, int y, int w, int h);
     bool startFilter(Node *node, int x, int y, int w, int h);
 private:
 };
diff --git a/plugins/extensions/pykrita/testapi.py b/plugins/extensions/pykrita/testapi.py
deleted file mode 100644
index 6cca36f594..0000000000
--- a/plugins/extensions/pykrita/testapi.py
+++ /dev/null
@@ -1,31 +0,0 @@
-#
-# Tests the PyKrita API
-#
-
-import sys
-from PyQt5.QtGui import *
-from PyQt5.QtWidgets import *
-from krita import *
-
-
-def __main__(args):
-    print("Arguments:", args)
-    Application.setBatchmode(True)
-    print("Batchmode: ", Application.batchmode())
-    print("Profiles:", Application.profiles("GRAYA", "U16"))
-    document = Application.openDocument(args[0])
-    print("Opened", document.fileName(), "WxH", document.width(), document.height(), "resolution", document.xRes(), document.yRes(), "in ppi", document.resolution())
-    node = document.rootNode()
-    print("Root", node.name(), "opacity", node.opacity())
-    for child in node.childNodes():
-        print("\tChild", child.name(), "opacity", node.opacity(), node.blendingMode())
-        # r = child.save(child.name() + ".png", document.xRes(), document.yRes());
-        # print("Saving result:", r)
-        for channel in child.channels():
-            print("Channel", channel.name(), "contents:", len(channel.pixelData(node.bounds())))
-
-    document.close()
-
-    document = Application.createDocument(100, 100, "test", "GRAYA", "U16", "")
-    document.setBatchmode(True)
-    # document.saveAs("test.kra")
diff --git a/plugins/extensions/pykrita/tests/__init__.py b/plugins/extensions/pykrita/tests/__init__.py
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/plugins/extensions/pykrita/tests/actionTests/__init__.py b/plugins/extensions/pykrita/tests/actionTests/__init__.py
deleted file mode 100644
index 8df7667fb6..0000000000
--- a/plugins/extensions/pykrita/tests/actionTests/__init__.py
+++ /dev/null
@@ -1,6 +0,0 @@
-import sys
-
-
-inst_dir = sys.argv[2]
-source_dir = sys.argv[3]
-sys.path.insert(0, str("{0}/share/krita/pykrita/PyKrita").format(inst_dir))
diff --git a/plugins/extensions/pykrita/tests/actionTests/action_test.py b/plugins/extensions/pykrita/tests/actionTests/action_test.py
deleted file mode 100644
index 6ebc5590e6..0000000000
--- a/plugins/extensions/pykrita/tests/actionTests/action_test.py
+++ /dev/null
@@ -1,84 +0,0 @@
-import unittest
-from krita import Action
-from PyQt5.QtWidgets import QAction
-
-
-class TestAction(unittest.TestCase):
-
-    def setUp(self):
-        self.instance = Action()
-        self.instance.triggered.connect(self.slotTriggered)
-        self.triggered = False
-
-    def testConstructor(self):
-        self.assertEqual(bool(self.instance), True)
-
-    def testConstructorWithStringQAction(self):
-        new_action = Action("test", QAction("test"))
-        self.assertEqual(bool(new_action), True)
-
-    def testConstructorInvalidParameter(self):
-        with self.assertRaises(TypeError):
-            Action(str(''))
-
-    def testEqualOperator(self):
-        new_action = self.instance
-        self.assertEqual(new_action == self.instance, True)
-
-    def testInequalityOperator(self):
-        new_action = Action()
-        self.assertEqual(new_action != self.instance, True)
-
-    def testTextProperties(self):
-        self.instance.setText("test")
-        self.assertEqual(self.instance.text() == "test", True)
-
-    def testNameProperties(self):
-        self.instance.setName("test")
-        self.assertEqual(self.instance.name() == "test", True)
-
-    def testCheckableInitialState(self):
-        self.assertEqual(self.instance.isCheckable(), False)
-
-    def testCheckableToTrue(self):
-        self.instance.setCheckable(True)
-        self.assertEqual(self.instance.isCheckable(), True)
-
-    def testCheckableToFalse(self):
-        self.instance.setCheckable(False)
-        self.assertEqual(self.instance.isCheckable(), False)
-
-    def testCheckedInitialState(self):
-        self.assertEqual(self.instance.isChecked(), False)
-
-    def testCheckedToTrue(self):
-        self.instance.setCheckable(True)
-        self.instance.setChecked(True)
-        self.assertEqual(self.instance.isChecked(), True)
-
-    def testCheckedToFalse(self):
-        self.instance.setChecked(False)
-        self.assertEqual(self.instance.isChecked(), False)
-
-    def testCheckedToFalseNotCheckable(self):
-        self.instance.setChecked(True)
-        self.assertEqual(self.instance.isChecked(), False)
-
-    def testVisibleInitialState(self):
-        self.assertEqual(self.instance.isVisible(), True)
-
-    def testVisibleToTrue(self):
-        self.instance.setVisible(True)
-        self.assertEqual(self.instance.isVisible(), True)
-
-    def testVisibleToFalse(self):
-        self.instance.setVisible(False)
-        self.assertEqual(self.instance.isVisible(), False)
-
-    def testTrigger(self):
-        self.instance.trigger()
-        self.assertEqual(self.triggered, True)
-
-    # helper method
-    def slotTriggered(self):
-        self.triggered = True
diff --git a/plugins/extensions/pykrita/tests/actionTests/extension_test.py b/plugins/extensions/pykrita/tests/actionTests/extension_test.py
deleted file mode 100644
index 9ae63c2a9b..0000000000
--- a/plugins/extensions/pykrita/tests/actionTests/extension_test.py
+++ /dev/null
@@ -1,30 +0,0 @@
-import unittest
-from krita import Extension
-from PyQt5.QtCore import QObject
-
-
-class TestExtension(unittest.TestCase):
-
-    def testConstructorSubClass(self):
-        self.assertEqual(bool(SubClassExtension()), True)
-
-    def testConstructorSubClassWithParent(self):
-        self.assertEqual(bool(SubClassExtension(QObject())), True)
-
-    def testConstructorInvalidParameter(self):
-        with self.assertRaises(TypeError):
-            SubClassExtension(str(''))
-
-    def testConstructorAbstractClass(self):
-        with self.assertRaises(TypeError):
-            Extension()
-
-    def testExtensionHasMethodsetup(self):
-        setup = getattr(SubClassExtension(), "setup", None)
-        self.assertEqual(bool(callable(setup)), True)
-
-
-class SubClassExtension(Extension):
-
-    def setup(self):
-        pass
diff --git a/plugins/extensions/pykrita/tests/actionTests/filter_test.py b/plugins/extensions/pykrita/tests/actionTests/filter_test.py
deleted file mode 100644
index 364dafd511..0000000000
--- a/plugins/extensions/pykrita/tests/actionTests/filter_test.py
+++ /dev/null
@@ -1,31 +0,0 @@
-import unittest
-from krita import Filter, InfoObject
-from PyQt5.QtCore import QObject
-
-
-class TestFilter(unittest.TestCase):
-
-    def setUp(self):
-        self._instance = Filter()
-
-    def testConstructor(self):
-        self.assertTrue(Filter())
-
-    def testConstructorInvalidParameter(self):
-        with self.assertRaises(TypeError):
-            Filter(str(''))
-
-    def testEqualOperator(self):
-        sameFilter = self._instance
-        self.assertTrue(sameFilter == self._instance)
-
-    def testEmptyNameProperty(self):
-        self.assertFalse(self._instance.name())
-
-    # segmentation fault here, I need to verify that.
-    def testConfigurationProperties(self):
-        pass
-        # infoObject = InfoObject()
-        # f = Filter()
-        # f.setConfiguration(infoObject)
-        # self.assertEqual(f.configuration(), infoObject)
diff --git a/plugins/extensions/pykrita/tests/actionTests/infoobject_test.py b/plugins/extensions/pykrita/tests/actionTests/infoobject_test.py
deleted file mode 100644
index 71682dcc42..0000000000
--- a/plugins/extensions/pykrita/tests/actionTests/infoobject_test.py
+++ /dev/null
@@ -1,43 +0,0 @@
-import unittest
-from krita import InfoObject
-from PyQt5.QtCore import QObject
-
-
-class TestInfoObject(unittest.TestCase):
-
-    def setUp(self):
-        self._instance = InfoObject()
-
-    def testConstructor(self):
-        self.assertTrue(InfoObject())
-
-    def testConstructorWithParent(self):
-        self.assertTrue(InfoObject(QObject()))
-
-    def testConstructorInvalidParameter(self):
-        with self.assertRaises(TypeError):
-            InfoObject(str(''))
-
-    def testEqualOperator(self):
-        sameInfoObject = self._instance
-        self.assertTrue(sameInfoObject == self._instance)
-
-    def testInequalityOperator(self):
-        newInfoObject = InfoObject()
-        self.assertTrue(newInfoObject != self._instance)
-
-    def testPropertiesAcessorsOneProperty(self):
-        self._instance.setProperties({"test": "test"})
-        self.assertEqual(self._instance.properties(), {"test": "test"})
-
-    def testPropertiesAcessorsSetProperties(self):
-        self._instance.setProperties({"test": "test", "test1": 1})
-        self.assertEqual(self._instance.properties(), {"test": "test", "test1": 1})
-
-    def testPropertySlotsString(self):
-        self._instance.setProperty("key", "value")
-        self.assertEqual(self._instance.property("key"), "value")
-
-    def testPropertySlotsInvalidKey(self):
-        self._instance.setProperty("key", "value")
-        self.assertEqual(self._instance.property("keys"), None)
diff --git a/plugins/extensions/pykrita/tests/basetest.py b/plugins/extensions/pykrita/tests/basetest.py
deleted file mode 100644
index 296db56c6d..0000000000
--- a/plugins/extensions/pykrita/tests/basetest.py
+++ /dev/null
@@ -1,8 +0,0 @@
-import unittest
-import sys
-
-inst_dir = sys.argv[2]
-source_dir = sys.argv[3]
-sys.path.insert(0, str("{0}/share/krita/pykrita/PyKrita").format(inst_dir))
-
-from krita import *
diff --git a/plugins/extensions/qmic/tests/CMakeLists.txt b/plugins/extensions/qmic/tests/CMakeLists.txt
index 685b181f6e..0ac7637ddc 100644
--- a/plugins/extensions/qmic/tests/CMakeLists.txt
+++ b/plugins/extensions/qmic/tests/CMakeLists.txt
@@ -1,11 +1,12 @@
 set( EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR} )
 include_directories( ${CMAKE_SOURCE_DIR}/sdk/tests
     ${CMAKE_CURRENT_SOURCE_DIR}/..
     ${CMAKE_BINARY_DIR}/plugins/extensions/qmic
 )
 
 macro_add_unittest_definitions()
 
 ecm_add_test(kis_qmic_tests.cpp ${CMAKE_CURRENT_SOURCE_DIR}/../kis_qmic_simple_convertor.cpp
-    TEST_NAME krita-qmic-test
-    LINK_LIBRARIES kritaimage Qt5::Test)
+    TEST_NAME kis_qmic_tests
+    LINK_LIBRARIES kritaimage Qt5::Test
+    NAME_PREFIX "plugins-extensions-qmic-")
diff --git a/plugins/filters/imageenhancement/kis_wavelet_noise_reduction.cpp b/plugins/filters/imageenhancement/kis_wavelet_noise_reduction.cpp
index 4b92fe6554..639e146a37 100644
--- a/plugins/filters/imageenhancement/kis_wavelet_noise_reduction.cpp
+++ b/plugins/filters/imageenhancement/kis_wavelet_noise_reduction.cpp
@@ -1,125 +1,125 @@
 /*
  * This file is part of the KDE project
  *
  * 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_wavelet_noise_reduction.h"
 
 
 #include <cmath>
 
 #include <KoUpdater.h>
 
 #include <kis_layer.h>
 #include <kis_math_toolbox.h>
 #include <widgets/kis_multi_double_filter_widget.h>
 #include <widgets/kis_multi_integer_filter_widget.h>
 #include <kis_paint_device.h>
 #include <filter/kis_filter_category_ids.h>
 #include <filter/kis_filter_configuration.h>
 #include <kis_processing_information.h>
 #include "kis_global.h"
 
 KisWaveletNoiseReduction::KisWaveletNoiseReduction()
     : KisFilter(id(), FiltersCategoryEnhanceId, i18n("&Wavelet Noise Reducer..."))
 {
     setSupportsPainting(false);
     setSupportsThreading(false);
 }
 
 
 KisWaveletNoiseReduction::~KisWaveletNoiseReduction()
 {
 }
 
 KisConfigWidget * KisWaveletNoiseReduction::createConfigurationWidget(QWidget* parent, const KisPaintDeviceSP) const
 {
     vKisDoubleWidgetParam param;
     param.push_back(KisDoubleWidgetParam(0.0, 256.0, BEST_WAVELET_THRESHOLD_VALUE, i18n("Threshold"), "threshold"));
     return new KisMultiDoubleFilterWidget(id().id(), parent, id().id(), param);
 }
 
 KisFilterConfigurationSP KisWaveletNoiseReduction::factoryConfiguration() const
 {
     KisFilterConfigurationSP config = new KisFilterConfiguration(id().id(), 0);
     config->setProperty("threshold", BEST_WAVELET_THRESHOLD_VALUE);
     return config;
 }
 
 void KisWaveletNoiseReduction::processImpl(KisPaintDeviceSP device,
                                            const QRect& applyRect,
                                            const KisFilterConfigurationSP _config,
                                            KoUpdater* progressUpdater
                                            ) const
 {
     Q_ASSERT(device);
 
     KisFilterConfigurationSP config = _config ? _config : defaultConfiguration();
     const float threshold = config->getDouble("threshold", BEST_WAVELET_THRESHOLD_VALUE);
 
     KisMathToolbox mathToolbox;
 
     //     dbgFilters << size <<"" << maxrectsize <<"" << srcTopLeft.x() <<"" << srcTopLeft.y();
 
     //     dbgFilters <<"Transforming...";
     KisMathToolbox::KisWavelet* buff = 0;
     KisMathToolbox::KisWavelet* wav = 0;
 
     try {
         buff = mathToolbox.initWavelet(device, applyRect);
-    } catch (std::bad_alloc) {
+    } catch (const std::bad_alloc&) {
         if (buff) delete buff;
         return;
     }
     try {
         wav = mathToolbox.fastWaveletTransformation(device, applyRect, buff);
-    } catch (std::bad_alloc) {
+    } catch (const std::bad_alloc&) {
         if (wav) delete wav;
         return;
     }
 
     float* const fin = wav->coeffs + wav->depth * pow2(wav->size);
     float* const begin = wav->coeffs + wav->depth;
 
     const int size = fin - begin;
     const int progressOffset = int(std::ceil(std::log2(size / 100)));
     const int progressMask = (1 << progressOffset) - 1;
     const int numProgressSteps = size >> progressOffset;
     int pointsProcessed = 0;
 
     progressUpdater->setRange(0, numProgressSteps);
 
     for (float* it = begin; it < fin; it++) {
         if (*it > threshold) {
             *it -= threshold;
         } else if (*it < -threshold) {
             *it += threshold;
         } else {
             *it = 0.;
         }
 
         if (!(pointsProcessed & progressMask)) {
             progressUpdater->setValue(pointsProcessed >> progressOffset);
         }
         pointsProcessed++;
     }
 
     mathToolbox.fastWaveletUntransformation(device, applyRect, wav, buff);
 
     delete wav;
     delete buff;
 }
diff --git a/plugins/filters/indexcolors/indexcolorpalette.h b/plugins/filters/indexcolors/indexcolorpalette.h
index 820304787c..7833878ac5 100644
--- a/plugins/filters/indexcolors/indexcolorpalette.h
+++ b/plugins/filters/indexcolors/indexcolorpalette.h
@@ -1,66 +1,66 @@
 /*
  * Copyright 2014 Manuel Riecke <spell1337@gmail.com>
  *
  * Permission to use, copy, modify, and distribute this software
  * and its documentation for any purpose and without fee is hereby
  * granted, provided that the above copyright notice appear in all
  * copies and that both that the copyright notice and this
  * permission notice and warranty disclaimer appear in supporting
  * documentation, and that the name of the author not be used in
  * advertising or publicity pertaining to distribution of the
  * software without specific, written prior permission.
  *
  * The author disclaim all warranties with regard to this
  * software, including all implied warranties of merchantability
  * and fitness.  In no event shall the author be liable for any
  * special, indirect or consequential damages or any damages
  * whatsoever resulting from loss of use, data or profits, whether
  * in an action of contract, negligence or other tortious action,
  * arising out of or in connection with the use or performance of
  * this software.
  */
 
 #ifndef INDEXCOLORPALETTE_H
 #define INDEXCOLORPALETTE_H
 
 #include <QVector>
 #include <QColor>
 #include <QPair>
 #include <KoColor.h>
 
 struct LabColor
 {
     quint16 L;
     quint16 a;
     quint16 b;
 };
 
 struct IndexColorPalette
 {
     QVector<LabColor> colors;
 
     struct
     {
         float L;
         float a;
         float b;
     } similarityFactors;
 
     IndexColorPalette();
     void insertShades(QColor clrA, QColor clrB, int shades);
     void insertShades(KoColor clrA, KoColor clrB, int shades);
     void insertShades(LabColor clrA, LabColor clrB, int shades);
     
     void insertColor(QColor clr);
     void insertColor(KoColor clr);
     void insertColor(LabColor clr);
     
     void mergeMostReduantColors();
     
     LabColor getNearestIndex(LabColor clr) const;
     int numColors() const;
     float similarity(LabColor c0, LabColor c1) const;
     QPair< int, int > getNeighbours(int mainClr) const;
 };
 
-#endif // INDEXCOLORPALETTE_H
\ No newline at end of file
+#endif // INDEXCOLORPALETTE_H
diff --git a/plugins/filters/levelfilter/levelfilter.cpp b/plugins/filters/levelfilter/levelfilter.cpp
index 9e99761458..ab2697a414 100644
--- a/plugins/filters/levelfilter/levelfilter.cpp
+++ b/plugins/filters/levelfilter/levelfilter.cpp
@@ -1,41 +1,41 @@
 /*
  * This file is part of Krita
  *
  * Copyright (c) 2006 Frederic Coiffier <fcoiffie@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "levelfilter.h"
 
 #include <kpluginfactory.h>
 
 #include "kis_level_filter.h"
 #include "filter/kis_filter_registry.h"
 
 K_PLUGIN_FACTORY_WITH_JSON(LevelFilterFactory, "kritalevelfilter.json", registerPlugin<LevelFilter>();)
 
 LevelFilter::LevelFilter(QObject *parent, const QVariantList &)
         : QObject(parent)
 {
     KisFilterRegistry::instance()->add(new KisLevelFilter());
 
 }
 
 LevelFilter::~LevelFilter()
 {
 }
 
-#include "levelfilter.moc"
\ No newline at end of file
+#include "levelfilter.moc"
diff --git a/plugins/filters/normalize/kis_normalize.cpp b/plugins/filters/normalize/kis_normalize.cpp
index 4726dd0d59..75eb322d8f 100644
--- a/plugins/filters/normalize/kis_normalize.cpp
+++ b/plugins/filters/normalize/kis_normalize.cpp
@@ -1,130 +1,137 @@
 /*
  *
  *  Copyright (c) 2015 Wolthera van Hövell tot Westerflier <griffinvalley@gmail.com>
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  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_normalize.h"
 #include <stdlib.h>
 #include <vector>
 
 #include <QPoint>
 #include <QTime>
 #include <QVector3D>
 
 #include <kpluginfactory.h>
 #include <klocalizedstring.h>
 
 #include <kis_debug.h>
 
 #include <kis_processing_information.h>
 #include <kis_types.h>
 #include <kis_selection.h>
 #include <kis_layer.h>
 #include <filter/kis_filter_category_ids.h>
 #include <filter/kis_filter_registry.h>
 #include <kis_global.h>
 
 #include <KoColorSpaceMaths.h>
 #include <filter/kis_color_transformation_configuration.h>
 
 K_PLUGIN_FACTORY_WITH_JSON(KritaNormalizeFilterFactory, "kritanormalize.json", registerPlugin<KritaNormalizeFilter>();)
 
 KritaNormalizeFilter::KritaNormalizeFilter(QObject *parent, const QVariantList &)
     : QObject(parent)
 {
     KisFilterRegistry::instance()->add(KisFilterSP(new KisFilterNormalize()));
 }
 
 KritaNormalizeFilter::~KritaNormalizeFilter()
 {
 }
 
 
 KisFilterNormalize::KisFilterNormalize()
     : KisColorTransformationFilter(KoID("normalize", i18n("Normalize")),
                                    FiltersCategoryMapId, i18n("&Normalize..."))
 {
     setColorSpaceIndependence(FULLY_INDEPENDENT);
     setSupportsPainting(true);
     setShowConfigurationWidget(false);
 }
 
 KoColorTransformation* KisFilterNormalize::createTransformation(const KoColorSpace* cs, const KisFilterConfigurationSP config) const
 {
     Q_UNUSED(config);
     return new KisNormalizeTransformation(cs);
 }
 
 KisNormalizeTransformation::KisNormalizeTransformation(const KoColorSpace* cs) : m_colorSpace(cs), m_psize(cs->pixelSize())
 {
 
 }
 
 void KisNormalizeTransformation::transform(const quint8* src, quint8* dst, qint32 nPixels) const
 {
+    // if the color space is not RGBA o something like that, just
+    // pass the values through
+    if (m_colorSpace->channelCount() != 4) {
+        memcpy(dst, src, nPixels * m_colorSpace->pixelSize());
+        return;
+    }
+
     QVector3D normal_vector;
     QVector<float> channelValues(4);
     //if (m_colorSpace->colorDepthId().id()!="F16" && m_colorSpace->colorDepthId().id()!="F32" && m_colorSpace->colorDepthId().id()!="F64") {
     /* I don't know why, but the results of this are unexpected with a floating point space.
      * And manipulating the pixels gives strange results.
      */
     while (nPixels--) {
         m_colorSpace->normalisedChannelsValue(src, channelValues);
         normal_vector.setX(channelValues[2]*2-1.0);
         normal_vector.setY(channelValues[1]*2-1.0);
         normal_vector.setZ(channelValues[0]*2-1.0);
         normal_vector.normalize();
 
         channelValues[0]=normal_vector.z()*0.5+0.5;
         channelValues[1]=normal_vector.y()*0.5+0.5;
         channelValues[2]=normal_vector.x()*0.5+0.5;
         //channelValues[3]=1.0;
 
         m_colorSpace->fromNormalisedChannelsValue(dst, channelValues);
 
         dst[3]=src[3];
         src += m_psize;
         dst += m_psize;
     }
     /*    } else {
     while (nPixels--) {
         m_colorSpace->normalisedChannelsValue(src, channelValues);
         qreal max = qMax(channelValues[2], qMax(channelValues[1], channelValues[0]));
         qreal min = qMin(channelValues[2], qMin(channelValues[1], channelValues[0]));
         qreal range = max-min;
         normal_vector.setX( ((channelValues[2]-min)/range) *2.0-1.0);
         normal_vector.setY( ((channelValues[1]-min)/range) *2.0-1.0);
         normal_vector.setZ( ((channelValues[0]-min)/range) *2.0-1.0);
         normal_vector.normalize();
 
         channelValues[2]=normal_vector.x()*0.5+0.5;
         channelValues[1]=normal_vector.y()*0.5+0.5;
         channelValues[0]=normal_vector.z()*0.5+0.5;
         //channelValues[3]=1.0;
 
         m_colorSpace->fromNormalisedChannelsValue(dst, channelValues);
         dst[3]=src[3];
         //hack to trunucate values.
         m_colorSpace->toRgbA16(dst, reinterpret_cast<quint8 *>(m_rgba), 1);
         m_colorSpace->fromRgbA16(reinterpret_cast<quint8 *>(m_rgba), dst, 1);
 
         src += m_psize;
         dst += m_psize;
     }
     }*/
 }
 
 #include "kis_normalize.moc"
diff --git a/plugins/filters/smalltilesfilter/kis_small_tiles_filter.cpp b/plugins/filters/smalltilesfilter/kis_small_tiles_filter.cpp
index 3479eeb6f1..3de792466c 100644
--- a/plugins/filters/smalltilesfilter/kis_small_tiles_filter.cpp
+++ b/plugins/filters/smalltilesfilter/kis_small_tiles_filter.cpp
@@ -1,113 +1,115 @@
 /*
  * This file is part of Krita
  *
  * Copyright (c) 2005 Michael Thaler <michael.thaler@physik.tu-muenchen.de>
  *
  * ported from Gimp, Copyright (C) 1997 Eiichi Takamori <taka@ma1.seikyou.ne.jp>
  * original pixelize.c for GIMP 0.54 by Tracy Scott
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  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_small_tiles_filter.h"
 
 #include <stdlib.h>
 #include <vector>
 
 #include <QPoint>
 #include <QSpinBox>
 #include <QVector>
 
 #include <klocalizedstring.h>
 #include <kpluginfactory.h>
 
 #include <KoUpdater.h>
 
 #include <KisDocument.h>
 #include <kis_debug.h>
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <filter/kis_filter_registry.h>
 #include <kis_global.h>
 #include <kis_types.h>
 #include <kis_paint_device.h>
 #include <kis_filter_strategy.h>
 #include <kis_painter.h>
 #include <kis_selection.h>
 #include <filter/kis_filter_category_ids.h>
 #include <filter/kis_filter_configuration.h>
 #include <kis_processing_information.h>
 #include <KoCompositeOpRegistry.h>
 
 #include "widgets/kis_multi_integer_filter_widget.h"
 
 KisSmallTilesFilter::KisSmallTilesFilter() : KisFilter(id(), FiltersCategoryMapId, i18n("&Small Tiles..."))
 {
     setSupportsPainting(true);
     setSupportsThreading(false);
     setSupportsAdjustmentLayers(false);
 }
 
 void KisSmallTilesFilter::processImpl(KisPaintDeviceSP device,
-                                      const QRect& /*applyRect*/,
+                                      const QRect& applyRect,
                                       const KisFilterConfigurationSP config,
                                       KoUpdater* progressUpdater
                                       ) const
 {
     Q_ASSERT(!device.isNull());
 
     //read the filter configuration values from the KisFilterConfiguration object
-    quint32 numberOfTiles = config->getInt("numberOfTiles", 2);
+    const quint32 numberOfTiles = config->getInt("numberOfTiles", 2);
 
-    QRect srcRect = device->exactBounds();
+    const QRect srcRect = applyRect;
 
-    int w = static_cast<int>(srcRect.width() / numberOfTiles);
-    int h = static_cast<int>(srcRect.height() / numberOfTiles);
+    const int w = static_cast<int>(srcRect.width() / numberOfTiles);
+    const int h = static_cast<int>(srcRect.height() / numberOfTiles);
 
-    KisPaintDeviceSP tile = device->createThumbnailDevice(srcRect.width() / numberOfTiles, srcRect.height() / numberOfTiles);
+    KisPaintDeviceSP tile = device->createThumbnailDevice(w, h);
     if (tile.isNull()) return;
 
+    device->clear(applyRect);
+
     KisPainter gc(device);
     gc.setCompositeOp(COMPOSITE_COPY);
 
     if (progressUpdater) {
         progressUpdater->setRange(0, numberOfTiles);
     }
 
     for (uint y = 0; y < numberOfTiles; ++y) {
         for (uint x = 0; x < numberOfTiles; ++x) {
             gc.bitBlt(w * x, h * y, tile, 0, 0, w, h);
         }
         if (progressUpdater) progressUpdater->setValue(y);
     }
     gc.end();
 }
 
 KisConfigWidget * KisSmallTilesFilter::createConfigurationWidget(QWidget* parent, const KisPaintDeviceSP) const
 {
     vKisIntegerWidgetParam param;
     param.push_back(KisIntegerWidgetParam(2, 5, 1, i18n("Number of tiles"), "numberOfTiles"));
     return new KisMultiIntegerFilterWidget(id().id(),  parent,  id().id(),  param);
 
 }
 
 KisFilterConfigurationSP KisSmallTilesFilter::factoryConfiguration() const
 {
     KisFilterConfigurationSP config = new KisFilterConfiguration("smalltiles", 1);
     config->setProperty("numberOfTiles", 2);
     return config;
 }
 
 
diff --git a/plugins/filters/smalltilesfilter/kis_small_tiles_filter_plugin.cpp b/plugins/filters/smalltilesfilter/kis_small_tiles_filter_plugin.cpp
index b986fcdfd9..d4b93f5892 100644
--- a/plugins/filters/smalltilesfilter/kis_small_tiles_filter_plugin.cpp
+++ b/plugins/filters/smalltilesfilter/kis_small_tiles_filter_plugin.cpp
@@ -1,41 +1,41 @@
 /*
  * This file is part of the KDE project
  *
  * Copyright (c) 2005 Michael Thaler <michael.thaler@physik.tu-muenchen.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_small_tiles_filter_plugin.h"
 
 #include <kpluginfactory.h>
 
 #include "kis_small_tiles_filter.h"
 #include "kis_global.h"
 #include "filter/kis_filter_registry.h"
 
 K_PLUGIN_FACTORY_WITH_JSON(KisSmallTilesFilterPluginFactory, "kritasmalltilesfilter.json", registerPlugin<KisSmallTilesFilterPlugin>();)
 
 KisSmallTilesFilterPlugin::KisSmallTilesFilterPlugin(QObject *parent, const QVariantList &)
         : QObject(parent)
 {
     KisFilterRegistry::instance()->add(new KisSmallTilesFilter());
 }
 
 KisSmallTilesFilterPlugin::~KisSmallTilesFilterPlugin()
 {
 }
 
-#include "kis_small_tiles_filter_plugin.moc"
\ No newline at end of file
+#include "kis_small_tiles_filter_plugin.moc"
diff --git a/plugins/filters/tests/data/asc-cdl.cfg b/plugins/filters/tests/data/asc-cdl.cfg
index b6cba394e4..42f7f56cd3 100644
--- a/plugins/filters/tests/data/asc-cdl.cfg
+++ b/plugins/filters/tests/data/asc-cdl.cfg
@@ -1,18 +1,18 @@
 <!DOCTYPE params>
 <params version="0">
  <param type="color" name="offset"><![CDATA[<!DOCTYPE color>
 <color>
  <RGB g="0" b="0" r="0" space="sRGB built-in"/>
 </color>
 ]]></param>
  <param type="color" name="power"><![CDATA[<!DOCTYPE color>
 <color>
- <RGB g="1" b="1" r="1" space="sRGB built-in"/>
+ <RGB g="1.2" b="0.8" r="0.3" space="sRGB built-in"/>
 </color>
 ]]></param>
  <param type="color" name="slope"><![CDATA[<!DOCTYPE color>
 <color>
  <RGB g="1" b="1" r="1" space="sRGB built-in"/>
 </color>
 ]]></param>
 </params>
diff --git a/plugins/filters/tests/data/burn.cfg b/plugins/filters/tests/data/burn.cfg
index 962ef855d1..754cf64c09 100644
--- a/plugins/filters/tests/data/burn.cfg
+++ b/plugins/filters/tests/data/burn.cfg
@@ -1,2 +1,5 @@
 <!DOCTYPE params>
-<params version="0"/>
+<params version="0">
+  <param name="type" type="internal">0</param>
+  <param name="exposure" type="internal">2.0</param>
+</params>
diff --git a/plugins/filters/tests/data/carrot_asc-cdl.png b/plugins/filters/tests/data/carrot_asc-cdl.png
new file mode 100644
index 0000000000..77a2f732d2
Binary files /dev/null and b/plugins/filters/tests/data/carrot_asc-cdl.png differ
diff --git a/plugins/filters/tests/data/carrot_burn.png b/plugins/filters/tests/data/carrot_burn.png
new file mode 100644
index 0000000000..93018e6c3b
Binary files /dev/null and b/plugins/filters/tests/data/carrot_burn.png differ
diff --git a/plugins/filters/tests/data/carrot_colorbalance.png b/plugins/filters/tests/data/carrot_colorbalance.png
new file mode 100644
index 0000000000..353677412d
Binary files /dev/null and b/plugins/filters/tests/data/carrot_colorbalance.png differ
diff --git a/plugins/filters/tests/data/carrot_colortoalpha.png b/plugins/filters/tests/data/carrot_colortoalpha.png
new file mode 100644
index 0000000000..149b3670a9
Binary files /dev/null and b/plugins/filters/tests/data/carrot_colortoalpha.png differ
diff --git a/plugins/filters/tests/data/carrot_crosschannel.png b/plugins/filters/tests/data/carrot_crosschannel.png
new file mode 100644
index 0000000000..5d905dfd32
Binary files /dev/null and b/plugins/filters/tests/data/carrot_crosschannel.png differ
diff --git a/plugins/filters/tests/data/carrot_dodge.png b/plugins/filters/tests/data/carrot_dodge.png
new file mode 100644
index 0000000000..d7730d181f
Binary files /dev/null and b/plugins/filters/tests/data/carrot_dodge.png differ
diff --git a/plugins/filters/tests/data/carrot_edge detection.png b/plugins/filters/tests/data/carrot_edge detection.png
new file mode 100644
index 0000000000..caf1d1510d
Binary files /dev/null and b/plugins/filters/tests/data/carrot_edge detection.png differ
diff --git a/plugins/filters/tests/data/carrot_emboss all directions.png b/plugins/filters/tests/data/carrot_emboss all directions.png
new file mode 100644
index 0000000000..6a2394d96d
Binary files /dev/null and b/plugins/filters/tests/data/carrot_emboss all directions.png differ
diff --git a/plugins/filters/tests/data/carrot_emboss horizontal and vertical.png b/plugins/filters/tests/data/carrot_emboss horizontal and vertical.png
index f4fcc9376f..87ddbe7646 100644
Binary files a/plugins/filters/tests/data/carrot_emboss horizontal and vertical.png and b/plugins/filters/tests/data/carrot_emboss horizontal and vertical.png differ
diff --git a/plugins/filters/tests/data/carrot_emboss horizontal only.png b/plugins/filters/tests/data/carrot_emboss horizontal only.png
new file mode 100644
index 0000000000..a67d08adc7
Binary files /dev/null and b/plugins/filters/tests/data/carrot_emboss horizontal only.png differ
diff --git a/plugins/filters/tests/data/carrot_emboss laplascian.png b/plugins/filters/tests/data/carrot_emboss laplascian.png
new file mode 100644
index 0000000000..3eaec0ff50
Binary files /dev/null and b/plugins/filters/tests/data/carrot_emboss laplascian.png differ
diff --git a/plugins/filters/tests/data/carrot_emboss vertical only.png b/plugins/filters/tests/data/carrot_emboss vertical only.png
new file mode 100644
index 0000000000..90153ac067
Binary files /dev/null and b/plugins/filters/tests/data/carrot_emboss vertical only.png differ
diff --git a/plugins/filters/tests/data/carrot_halftone.png b/plugins/filters/tests/data/carrot_halftone.png
new file mode 100644
index 0000000000..73c1882405
Binary files /dev/null and b/plugins/filters/tests/data/carrot_halftone.png differ
diff --git a/plugins/filters/tests/data/carrot_height to normal.png b/plugins/filters/tests/data/carrot_height to normal.png
new file mode 100644
index 0000000000..5048f81ef6
Binary files /dev/null and b/plugins/filters/tests/data/carrot_height to normal.png differ
diff --git a/plugins/filters/tests/data/carrot_indexcolors.png b/plugins/filters/tests/data/carrot_indexcolors.png
new file mode 100644
index 0000000000..d4d39dd23b
Binary files /dev/null and b/plugins/filters/tests/data/carrot_indexcolors.png differ
diff --git a/plugins/filters/tests/data/carrot_lens blur.png b/plugins/filters/tests/data/carrot_lens blur.png
new file mode 100644
index 0000000000..512e7018be
Binary files /dev/null and b/plugins/filters/tests/data/carrot_lens blur.png differ
diff --git a/plugins/filters/tests/data/carrot_levels.png b/plugins/filters/tests/data/carrot_levels.png
new file mode 100644
index 0000000000..eb4abb1b6b
Binary files /dev/null and b/plugins/filters/tests/data/carrot_levels.png differ
diff --git a/plugins/filters/tests/data/carrot_mean removal.png b/plugins/filters/tests/data/carrot_mean removal.png
new file mode 100644
index 0000000000..d80d357f9f
Binary files /dev/null and b/plugins/filters/tests/data/carrot_mean removal.png differ
diff --git a/plugins/filters/tests/data/carrot_motion blur.png b/plugins/filters/tests/data/carrot_motion blur.png
new file mode 100644
index 0000000000..1263674732
Binary files /dev/null and b/plugins/filters/tests/data/carrot_motion blur.png differ
diff --git a/plugins/filters/tests/data/carrot_normalize.png b/plugins/filters/tests/data/carrot_normalize.png
new file mode 100644
index 0000000000..adf754daba
Binary files /dev/null and b/plugins/filters/tests/data/carrot_normalize.png differ
diff --git a/plugins/filters/tests/data/carrot_perchannel.png b/plugins/filters/tests/data/carrot_perchannel.png
new file mode 100644
index 0000000000..1f533eaf95
Binary files /dev/null and b/plugins/filters/tests/data/carrot_perchannel.png differ
diff --git a/plugins/filters/tests/data/carrot_posterize.png b/plugins/filters/tests/data/carrot_posterize.png
new file mode 100644
index 0000000000..19c9897732
Binary files /dev/null and b/plugins/filters/tests/data/carrot_posterize.png differ
diff --git a/plugins/filters/tests/data/carrot_roundcorners.png b/plugins/filters/tests/data/carrot_roundcorners.png
index bce2fd0916..afdccc05cc 100644
Binary files a/plugins/filters/tests/data/carrot_roundcorners.png and b/plugins/filters/tests/data/carrot_roundcorners.png differ
diff --git a/plugins/filters/tests/data/carrot_smalltiles.png b/plugins/filters/tests/data/carrot_smalltiles.png
index 46bcfcf59b..189484a469 100644
Binary files a/plugins/filters/tests/data/carrot_smalltiles.png and b/plugins/filters/tests/data/carrot_smalltiles.png differ
diff --git a/plugins/filters/tests/data/carrot_threshold.png b/plugins/filters/tests/data/carrot_threshold.png
new file mode 100644
index 0000000000..0dc5b1bf9b
Binary files /dev/null and b/plugins/filters/tests/data/carrot_threshold.png differ
diff --git a/plugins/filters/tests/data/carrot_unsharp.png b/plugins/filters/tests/data/carrot_unsharp.png
index d0625cce26..6d3c0e3f9b 100644
Binary files a/plugins/filters/tests/data/carrot_unsharp.png and b/plugins/filters/tests/data/carrot_unsharp.png differ
diff --git a/plugins/filters/tests/data/carrot_wave.png b/plugins/filters/tests/data/carrot_wave.png
new file mode 100644
index 0000000000..110d6055e3
Binary files /dev/null and b/plugins/filters/tests/data/carrot_wave.png differ
diff --git a/plugins/filters/tests/data/colorbalance.cfg b/plugins/filters/tests/data/colorbalance.cfg
index 44c31070fe..da95070a3d 100644
--- a/plugins/filters/tests/data/colorbalance.cfg
+++ b/plugins/filters/tests/data/colorbalance.cfg
@@ -1,13 +1,13 @@
 <!DOCTYPE params>
 <params version="0">
  <param type="internal" name="cyan_red_highlights">0</param>
- <param type="internal" name="cyan_red_midtones">0</param>
+ <param type="internal" name="cyan_red_midtones">80</param>
  <param type="internal" name="cyan_red_shadows">0</param>
  <param type="internal" name="magenta_blue_highlights">0</param>
  <param type="internal" name="magenta_blue_midtones">0</param>
  <param type="internal" name="magenta_blue_shadows">0</param>
  <param type="internal" name="preserve_luminosity">true</param>
  <param type="internal" name="yellow_green_highlights">0</param>
- <param type="internal" name="yellow_green_midtones">0</param>
+ <param type="internal" name="yellow_green_midtones">80</param>
  <param type="internal" name="yellow_green_shadows">0</param>
 </params>
diff --git a/plugins/filters/tests/data/colortoalpha.cfg b/plugins/filters/tests/data/colortoalpha.cfg
index 2ad5b352ee..48bd9498c7 100644
--- a/plugins/filters/tests/data/colortoalpha.cfg
+++ b/plugins/filters/tests/data/colortoalpha.cfg
@@ -1,5 +1,5 @@
 <!DOCTYPE params>
 <params>
  <param name="targetcolor" ><![CDATA[#ffffff]]></param>
- <param name="threshold" ><![CDATA[0]]></param>
+ <param name="threshold" ><![CDATA[50]]></param>
 </params>
diff --git a/plugins/filters/tests/data/crosschannel.cfg b/plugins/filters/tests/data/crosschannel.cfg
index fcaa8c129c..ebd9b0e0c2 100644
--- a/plugins/filters/tests/data/crosschannel.cfg
+++ b/plugins/filters/tests/data/crosschannel.cfg
@@ -1,4 +1,20 @@
 <!DOCTYPE params>
 <params version="1">
- <param name="nTransfers">0</param>
+ <param name="nTransfers">8</param>
+ <param name="curve0">0,0.5;1,0.5;</param>
+ <param name="curve1">0,0.5;0.844548,0.709804;1,0.5;</param>
+ <param name="curve2">0,0.5;1,0.5;</param>
+ <param name="curve3">0,0.5;1,0.5;</param>
+ <param name="curve4">0,0.5;1,0.5;</param>
+ <param name="curve5">0,0.5;1,0.5;</param>
+ <param name="curve6">0,0.5;1,0.5;</param>
+ <param name="curve7">0,0.5;1,0.5;</param>
+ <param name="driver0">7</param>
+ <param name="driver1">7</param>
+ <param name="driver2">7</param>
+ <param name="driver3">7</param>
+ <param name="driver4">7</param>
+ <param name="driver5">7</param>
+ <param name="driver6">7</param>
+ <param name="driver7">7</param>
 </params>
diff --git a/plugins/filters/tests/data/dodge.cfg b/plugins/filters/tests/data/dodge.cfg
index 962ef855d1..754cf64c09 100644
--- a/plugins/filters/tests/data/dodge.cfg
+++ b/plugins/filters/tests/data/dodge.cfg
@@ -1,2 +1,5 @@
 <!DOCTYPE params>
-<params version="0"/>
+<params version="0">
+  <param name="type" type="internal">0</param>
+  <param name="exposure" type="internal">2.0</param>
+</params>
diff --git a/plugins/filters/tests/data/height to normal.cfg b/plugins/filters/tests/data/height to normal.cfg
new file mode 100644
index 0000000000..30265e40fc
--- /dev/null
+++ b/plugins/filters/tests/data/height to normal.cfg	
@@ -0,0 +1,11 @@
+<!DOCTYPE params>
+<params version="1">
+ <param type="internal" name="blueSwizzle">4</param>
+ <param type="internal" name="channelToConvert">0</param>
+ <param type="internal" name="greenSwizzle">2</param>
+ <param type="internal" name="horizRadius">1</param>
+ <param type="internal" name="lockAspect">true</param>
+ <param type="internal" name="redSwizzle">0</param>
+ <param type="string" name="type"><![CDATA[sobol]]></param>
+ <param type="internal" name="vertRadius">1</param>
+</params>
diff --git a/plugins/filters/tests/data/hsvadjustment.cfg b/plugins/filters/tests/data/hsvadjustment.cfg
index 9018c18de2..47b541aa98 100644
--- a/plugins/filters/tests/data/hsvadjustment.cfg
+++ b/plugins/filters/tests/data/hsvadjustment.cfg
@@ -1,6 +1,6 @@
 <!DOCTYPE params>
 <params>
 <param name="h" ><![CDATA[2]]></param>
 <param name="s" ><![CDATA[20]]></param>
 <param name="v" ><![CDATA[40]]></param>
-<params/>
+</params>
diff --git a/plugins/filters/tests/data/indexcolors.cfg b/plugins/filters/tests/data/indexcolors.cfg
new file mode 100644
index 0000000000..14b20a8104
--- /dev/null
+++ b/plugins/filters/tests/data/indexcolors.cfg
@@ -0,0 +1,10 @@
+<!DOCTYPE params>
+<params version="0">
+ <param type="internal" name="LFactor">1</param>
+ <param type="internal" name="aFactor">1</param>
+ <param type="internal" name="alphaSteps">1</param>
+ <param type="internal" name="bFactor">1</param>
+ <param type="internal" name="colorLimit">32</param>
+ <param type="bytearray" name="paletteGen">AAAAAAH//////////wAAAf//////////AAAB//////////8AAAH//////////wAAAf///////wAAAAAB////////AAAAAAH///////8AAAAAAf///////wAAAAAB//+goKCgpKQAAAH//6CgoKCkpAAAAf//oKCgoKSkAAAB//+goKCgpKQAAAH//wAAAAAAAAAAAf//AAAAAAAAAAAB//8AAAAAAAAAAAH//wAAAAAAAAAAAQAAAAEAAAABAAAAAQAAAAAAAAQAAAAEAAAABAAAAAIA</param>
+ <param type="internal" name="reduceColorsEnabled">false</param>
+</params>
diff --git a/plugins/filters/tests/data/lens blur.cfg b/plugins/filters/tests/data/lens blur.cfg
new file mode 100644
index 0000000000..b96088a870
--- /dev/null
+++ b/plugins/filters/tests/data/lens blur.cfg	
@@ -0,0 +1,8 @@
+<!DOCTYPE params>
+<params version="1">
+ <param type="internal" name="halfHeight">5</param>
+ <param type="internal" name="halfWidth">5</param>
+ <param type="internal" name="irisRadius">5</param>
+ <param type="internal" name="irisRotation">0</param>
+ <param type="string" name="irisShape"><![CDATA[Pentagon (5)]]></param>
+</params>
diff --git a/plugins/filters/tests/data/levels.cfg b/plugins/filters/tests/data/levels.cfg
new file mode 100644
index 0000000000..cfb3f7c7ce
--- /dev/null
+++ b/plugins/filters/tests/data/levels.cfg
@@ -0,0 +1,8 @@
+<!DOCTYPE params>
+<params version="1">
+ <param type="internal" name="blackvalue">0</param>
+ <param type="internal" name="gammavalue">4.583</param>
+ <param type="internal" name="outblackvalue">0</param>
+ <param type="internal" name="outwhitevalue">255</param>
+ <param type="internal" name="whitevalue">255</param>
+</params>
diff --git a/plugins/filters/tests/data/motion blur.cfg b/plugins/filters/tests/data/motion blur.cfg
new file mode 100644
index 0000000000..cc979049c3
--- /dev/null
+++ b/plugins/filters/tests/data/motion blur.cfg	
@@ -0,0 +1,5 @@
+<!DOCTYPE params>
+<params version="1">
+ <param type="internal" name="blurAngle">0</param>
+ <param type="internal" name="blurLength">5</param>
+</params>
diff --git a/plugins/filters/tests/data/burn.cfg b/plugins/filters/tests/data/normalize.cfg
similarity index 100%
copy from plugins/filters/tests/data/burn.cfg
copy to plugins/filters/tests/data/normalize.cfg
diff --git a/plugins/filters/tests/data/perchannel.cfg b/plugins/filters/tests/data/perchannel.cfg
index c7370487e0..dd7788563e 100644
--- a/plugins/filters/tests/data/perchannel.cfg
+++ b/plugins/filters/tests/data/perchannel.cfg
@@ -1,2 +1,12 @@
 <!DOCTYPE params>
-<params/>
+<params version="1">
+ <param name="nTransfers">8</param>
+ <param name="curve0">0,0;0.218097,0.561594;0.798144,0.101449;1,1;</param>
+ <param name="curve1">0,0;1,1;</param>
+ <param name="curve2">0,0;0.696056,0.402174;1,1;</param>
+ <param name="curve3">0,0;1,1;</param>
+ <param name="curve4">0,0;1,1;</param>
+ <param name="curve5">0,0;1,1;</param>
+ <param name="curve6">0,0;1,1;</param>
+ <param name="curve7">0,0;1,1;</param>
+</params>
diff --git a/plugins/filters/tests/data/phongbumpmap.cfg b/plugins/filters/tests/data/phongbumpmap.cfg
new file mode 100644
index 0000000000..e9970b08ed
--- /dev/null
+++ b/plugins/filters/tests/data/phongbumpmap.cfg
@@ -0,0 +1,26 @@
+<!DOCTYPE params>
+<params version="2">
+ <param type="internal" name="Azimuth0">50</param>
+ <param type="internal" name="Azimuth1">100</param>
+ <param type="internal" name="Azimuth2">150</param>
+ <param type="internal" name="Azimuth3">200</param>
+ <param type="internal" name="Inclination0">25</param>
+ <param type="internal" name="Inclination1">20</param>
+ <param type="internal" name="Inclination2">30</param>
+ <param type="internal" name="Inclination3">40</param>
+ <param type="internal" name="ambientReflectivity">0.2</param>
+ <param type="internal" name="diffuseReflectivity">0.5</param>
+ <param type="internal" name="diffuseReflectivityIsEnabled">true</param>
+ <param type="internal" name="illuminantColor0">#ffff00</param>
+ <param type="internal" name="illuminantColor1">#ff0000</param>
+ <param type="internal" name="illuminantColor2">#0000ff</param>
+ <param type="internal" name="illuminantColor3">#00ff00</param>
+ <param type="internal" name="illuminantIsEnabled0">true</param>
+ <param type="internal" name="illuminantIsEnabled1">true</param>
+ <param type="internal" name="illuminantIsEnabled2">false</param>
+ <param type="internal" name="illuminantIsEnabled3">false</param>
+ <param type="internal" name="shinynessExponent">2</param>
+ <param type="internal" name="specularReflectivity">0.3</param>
+ <param type="internal" name="specularReflectivityIsEnabled">true</param>
+ <param type="internal" name="useNormalMapIsEnabled">false</param>
+</params>
diff --git a/plugins/filters/tests/data/posterize.cfg b/plugins/filters/tests/data/posterize.cfg
new file mode 100644
index 0000000000..5b86329cf6
--- /dev/null
+++ b/plugins/filters/tests/data/posterize.cfg
@@ -0,0 +1,4 @@
+<!DOCTYPE params>
+<params version="0">
+ <param type="internal" name="steps">16</param>
+</params>
diff --git a/plugins/filters/tests/data/threshold.cfg b/plugins/filters/tests/data/threshold.cfg
new file mode 100644
index 0000000000..a5243036b3
--- /dev/null
+++ b/plugins/filters/tests/data/threshold.cfg
@@ -0,0 +1,4 @@
+<!DOCTYPE params>
+<params version="1">
+ <param type="internal" name="threshold">128</param>
+</params>
diff --git a/plugins/filters/tests/kis_all_filter_test.cpp b/plugins/filters/tests/kis_all_filter_test.cpp
index 09e0e1aa86..c6c7638711 100644
--- a/plugins/filters/tests/kis_all_filter_test.cpp
+++ b/plugins/filters/tests/kis_all_filter_test.cpp
@@ -1,316 +1,288 @@
 /*
  *  Copyright (c) 2008 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_all_filter_test.h"
 #include <QTest>
 #include "filter/kis_filter_configuration.h"
 #include "filter/kis_filter_registry.h"
 #include "kis_selection.h"
 #include "kis_processing_information.h"
 #include "filter/kis_filter.h"
 #include "kis_pixel_selection.h"
 #include "kis_transaction.h"
 #include <KoColorSpaceRegistry.h>
-
-bool compareQImages(QPoint & pt, const QImage & image1, const QImage & image2)
-{
-//     QTime t;
-//     t.start();
-
-    int w1 = image1.width();
-    int h1 = image1.height();
-    int w2 = image2.width();
-    int h2 = image2.height();
-
-    if (w1 != w2 || h1 != h2) {
-        dbgKrita << w1 << " " << w2 << " " << h1 << " " << h2;
-        pt.setX(-1);
-        pt.setY(-1);
-        return false;
-    }
-
-    for (int x = 0; x < w1; ++x) {
-        for (int y = 0; y < h1; ++y) {
-            if (image1.pixel(x, y) != image2.pixel(x, y)) {
-                pt.setX(x);
-                pt.setY(y);
-                return false;
-            }
-        }
-    }
-//     dbgKrita << "compareQImages time elapsed:" << t.elapsed();
-    return true;
-}
+#include <sdk/tests/qimage_test_util.h>
+#include <sdk/tests/testing_timed_default_bounds.h>
 
 bool testFilterSrcNotIsDev(KisFilterSP f)
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
 
     QImage qimage(QString(FILES_DATA_DIR) + QDir::separator() + "carrot.png");
     QImage result(QString(FILES_DATA_DIR) + QDir::separator() + "carrot_" + f->id() + ".png");
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
+    dev->setDefaultBounds(new TestUtil::TestingTimedDefaultBounds(qimage.rect()));
+
     KisPaintDeviceSP dstdev = new KisPaintDevice(cs);
+    dstdev->setDefaultBounds(new TestUtil::TestingTimedDefaultBounds(qimage.rect()));
+
     dev->convertFromQImage(qimage, 0, 0, 0);
 
     // Get the predefined configuration from a file
     KisFilterConfigurationSP  kfc = f->defaultConfiguration();
 
     QFile file(QString(FILES_DATA_DIR) + QDir::separator() + f->id() + ".cfg");
     if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
-        //dbgKrita << "creating new file for " << f->id();
+        //qDebug() << "creating new file for " << f->id();
         file.open(QIODevice::WriteOnly | QIODevice::Text);
         QTextStream out(&file);
         out.setCodec("UTF-8");
         out << kfc->toXML();
     } else {
         QString s;
         QTextStream in(&file);
         in.setCodec("UTF-8");
         s = in.readAll();
-        //dbgKrita << "Read for " << f->id() << "\n" << s;
+        //qDebug() << "Read for " << f->id() << "\n" << s;
         kfc->fromXML(s);
     }
     dbgKrita << f->id();// << "\n" << kfc->toXML() << "\n";
 
     f->process(dev, dstdev, 0, QRect(QPoint(0,0), qimage.size()), kfc);
 
     QPoint errpoint;
 
-    if (!compareQImages(errpoint, result, dstdev->convertToQImage(0, 0, 0, qimage.width(), qimage.height()))) {
-        dev->convertToQImage(0, 0, 0, qimage.width(), qimage.height()).save(QString("src_not_is_dst_carrot_%1.png").arg(f->id()));
-        return false;
-    }
-    return true;
-}
-
-bool testFilterNoTransaction(KisFilterSP f)
-{
-    const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
-
-    QImage qimage(QString(FILES_DATA_DIR) + QDir::separator() + "carrot.png");
-    QImage result(QString(FILES_DATA_DIR) + QDir::separator() + "carrot_" + f->id() + ".png");
-    KisPaintDeviceSP dev = new KisPaintDevice(cs);
-    dev->convertFromQImage(qimage, 0, 0, 0);
-
-    // Get the predefined configuration from a file
-    KisFilterConfigurationSP  kfc = f->defaultConfiguration();
+    QImage actualResult = dstdev->convertToQImage(0, 0, 0, qimage.width(), qimage.height());
 
-    QFile file(QString(FILES_DATA_DIR) + QDir::separator() + f->id() + ".cfg");
-    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
-        //dbgKrita << "creating new file for " << f->id();
-        file.open(QIODevice::WriteOnly | QIODevice::Text);
-        QTextStream out(&file);
-        out.setCodec("UTF-8");
-        out << kfc->toXML();
-    } else {
-        QString s;
-        QTextStream in(&file);
-        in.setCodec("UTF-8");
-        s = in.readAll();
-        //dbgKrita << "Read for " << f->id() << "\n" << s;
-        kfc->fromXML(s);
-    }
-    dbgKrita << f->id();// << "\n" << kfc->toXML() << "\n";
-
-    f->process(dev, QRect(QPoint(0,0), qimage.size()), kfc);
-
-    QPoint errpoint;
-
-    if (!compareQImages(errpoint, result, dev->convertToQImage(0, 0, 0, qimage.width(), qimage.height()))) {
-        dev->convertToQImage(0, 0, 0, qimage.width(), qimage.height()).save(QString("no_transactio_carrot_%1.png").arg(f->id()));
+    if (!TestUtil::compareQImages(errpoint, result, actualResult, 1, 1)) {
+        qDebug() << "Failed compare result images for: " << f->id();
+        qDebug() << errpoint;
+        actualResult.save(QString("carrot_%1.png").arg(f->id()));
+        result.save(QString("carrot_%1_expected.png").arg(f->id()));
         return false;
     }
     return true;
 }
 
 bool testFilter(KisFilterSP f)
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
 
     QImage qimage(QString(FILES_DATA_DIR) + QDir::separator() + "carrot.png");
     QString resultFileName = QString(FILES_DATA_DIR) + QDir::separator() + "carrot_" + f->id() + ".png";
     QImage result(resultFileName);
-    if (!QFileInfo(resultFileName).exists()) {
-        dbgKrita << resultFileName << " not found";
-        return false;
-    }
+
+    //if (!f->id().contains("hsv")) return true;
+
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
+    dev->setDefaultBounds(new TestUtil::TestingTimedDefaultBounds(qimage.rect()));
     dev->convertFromQImage(qimage, 0, 0, 0);
     KisTransaction * cmd = new KisTransaction(kundo2_noi18n(f->name()), dev);
 
     // Get the predefined configuration from a file
     KisFilterConfigurationSP  kfc = f->defaultConfiguration();
 
     QFile file(QString(FILES_DATA_DIR) + QDir::separator() + f->id() + ".cfg");
     if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
-        //dbgKrita << "creating new file for " << f->id();
+        //qDebug() << "creating new file for " << f->id();
         file.open(QIODevice::WriteOnly | QIODevice::Text);
         QTextStream out(&file);
         out.setCodec("UTF-8");
         out << kfc->toXML();
     } else {
         QString s;
         QTextStream in(&file);
         in.setCodec("UTF-8");
         s = in.readAll();
-        //dbgKrita << "Read for " << f->id() << "\n" << s;
-        kfc->fromXML(s);
+        //qDebug() << "Read for " << f->id() << "\n" << s;
+        const bool validConfig = kfc->fromXML(s);
+
+
+        if (!validConfig) {
+            qDebug() << QString("Couldn't parse XML settings for filter %1").arg(f->id()).toLatin1();
+            return false;
+        }
     }
     dbgKrita << f->id();// << "\n" << kfc->toXML() << "\n";
 
     f->process(dev, QRect(QPoint(0,0), qimage.size()), kfc);
 
     QPoint errpoint;
 
     delete cmd;
 
-    if (!compareQImages(errpoint, result, dev->convertToQImage(0, 0, 0, qimage.width(), qimage.height()))) {
-        dbgKrita << errpoint;
-        dev->convertToQImage(0, 0, 0, qimage.width(), qimage.height()).save(QString("carrot_%1.png").arg(f->id()));
+    QImage actualResult = dev->convertToQImage(0, 0, 0, qimage.width(), qimage.height());
+
+    if (!TestUtil::compareQImages(errpoint, result, actualResult, 1, 1)) {
+        qDebug() << "Failed compare result images for: " << f->id();
+        qDebug() << errpoint;
+        actualResult.save(QString("carrot_%1.png").arg(f->id()));
+        result.save(QString("carrot_%1_expected.png").arg(f->id()));
         return false;
     }
     return true;
 }
 
 
 bool testFilterWithSelections(KisFilterSP f)
 {
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
 
     QImage qimage(QString(FILES_DATA_DIR) + QDir::separator() + "carrot.png");
     QImage result(QString(FILES_DATA_DIR) + QDir::separator() + "carrot_" + f->id() + ".png");
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
+    dev->setDefaultBounds(new TestUtil::TestingTimedDefaultBounds(qimage.rect()));
     dev->convertFromQImage(qimage, 0, 0, 0);
 
     // Get the predefined configuration from a file
     KisFilterConfigurationSP  kfc = f->defaultConfiguration();
 
     QFile file(QString(FILES_DATA_DIR) + QDir::separator() + f->id() + ".cfg");
     if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
-        //dbgKrita << "creating new file for " << f->id();
+        //qDebug() << "creating new file for " << f->id();
         file.open(QIODevice::WriteOnly | QIODevice::Text);
         QTextStream out(&file);
         out.setCodec("UTF-8");
         out << kfc->toXML();
     } else {
         QString s;
         QTextStream in(&file);
         in.setCodec("UTF-8");
         s = in.readAll();
-        //dbgKrita << "Read for " << f->id() << "\n" << s;
+        //qDebug() << "Read for " << f->id() << "\n" << s;
         kfc->fromXML(s);
     }
     dbgKrita << f->id();// << "\n"; << kfc->toXML() << "\n";
 
     KisSelectionSP sel1 = new KisSelection(new KisSelectionDefaultBounds(dev));
     sel1->pixelSelection()->select(qimage.rect());
 
     f->process(dev, dev, sel1, QRect(QPoint(0,0), qimage.size()), kfc);
 
     QPoint errpoint;
 
-    if (!compareQImages(errpoint, result, dev->convertToQImage(0, 0, 0, qimage.width(), qimage.height()))) {
-        dev->convertToQImage(0, 0, 0, qimage.width(), qimage.height()).save(QString("sel_carrot_%1.png").arg(f->id()));
+    QImage actualResult = dev->convertToQImage(0, 0, 0, qimage.width(), qimage.height());
+
+    if (!TestUtil::compareQImages(errpoint, result, actualResult, 1, 1)) {
+        qDebug() << "Failed compare result images for: " << f->id();
+        qDebug() << errpoint;
+        actualResult.save(QString("carrot_%1.png").arg(f->id()));
+        result.save(QString("carrot_%1_expected.png").arg(f->id()));
         return false;
     }
 
-
     return true;
 }
 
 void KisAllFilterTest::testAllFilters()
 {
+    QStringList excludeFilters;
+    excludeFilters << "colortransfer";
+    excludeFilters << "gradientmap";
+    excludeFilters << "phongbumpmap";
+    excludeFilters << "raindrops";
+
+    // halftone has some bezier curve painting drifts, so
+    // let's just exclude it
+    excludeFilters << "halftone";
+
     QStringList failures;
     QStringList successes;
 
     QList<QString> filterList = KisFilterRegistry::instance()->keys();
     std::sort(filterList.begin(), filterList.end());
     for (QList<QString>::Iterator it = filterList.begin(); it != filterList.end(); ++it) {
+        if (excludeFilters.contains(*it)) continue;
+
         if (testFilter(KisFilterRegistry::instance()->value(*it)))
             successes << *it;
         else
             failures << *it;
     }
     dbgKrita << "Success: " << successes;
     if (failures.size() > 0) {
         QFAIL(QString("Failed filters:\n\t %1").arg(failures.join("\n\t")).toLatin1());
     }
 }
 
-void KisAllFilterTest::testAllFiltersNoTransaction()
+void KisAllFilterTest::testAllFiltersSrcNotIsDev()
 {
-    QStringList failures;
-    QStringList successes;
+    QStringList excludeFilters;
+    excludeFilters << "colortransfer";
+    excludeFilters << "gradientmap";
+    excludeFilters << "phongbumpmap";
+    excludeFilters << "raindrops";
 
-    QList<QString> filterList = KisFilterRegistry::instance()->keys();
-    std::sort(filterList.begin(), filterList.end());
-    for (QList<QString>::Iterator it = filterList.begin(); it != filterList.end(); ++it) {
-        if (testFilterNoTransaction(KisFilterRegistry::instance()->value(*it)))
-            successes << *it;
-        else
-            failures << *it;
-    }
-    dbgKrita << "Success (no transaction): " << successes;
-    if (failures.size() > 0) {
-        QFAIL(QString("Failed filters (no transaction):\n\t %1").arg(failures.join("\n\t")).toLatin1());
-    }
-
-}
+    // halftone has some bezier curve painting drifts, so
+    // let's just exclude it
+    excludeFilters << "halftone";
 
-void KisAllFilterTest::testAllFiltersSrcNotIsDev()
-{
     QStringList failures;
     QStringList successes;
 
     QList<QString> filterList = KisFilterRegistry::instance()->keys();
     std::sort(filterList.begin(), filterList.end());
     for (QList<QString>::Iterator it = filterList.begin(); it != filterList.end(); ++it) {
+        if (excludeFilters.contains(*it)) continue;
+
         if (testFilterSrcNotIsDev(KisFilterRegistry::instance()->value(*it)))
             successes << *it;
         else
             failures << *it;
     }
     dbgKrita << "Src!=Dev Success: " << successes;
     if (failures.size() > 0) {
         QFAIL(QString("Src!=Dev Failed filters:\n\t %1").arg(failures.join("\n\t")).toLatin1());
     }
 
 }
 
 void KisAllFilterTest::testAllFiltersWithSelections()
 {
+    QStringList excludeFilters;
+    excludeFilters << "colortransfer";
+    excludeFilters << "gradientmap";
+    excludeFilters << "phongbumpmap";
+    excludeFilters << "raindrops";
+
+    // halftone has some bezier curve painting drifts, so
+    // let's just exclude it
+    excludeFilters << "halftone";
+
     QStringList failures;
     QStringList successes;
 
     QList<QString> filterList = KisFilterRegistry::instance()->keys();
     std::sort(filterList.begin(), filterList.end());
     for (QList<QString>::Iterator it = filterList.begin(); it != filterList.end(); ++it) {
+        if (excludeFilters.contains(*it)) continue;
+
         if (testFilterWithSelections(KisFilterRegistry::instance()->value(*it)))
             successes << *it;
         else
             failures << *it;
     }
     dbgKrita << "Success: " << successes;
     if (failures.size() > 0) {
         QFAIL(QString("Failed filters with selections:\n\t %1").arg(failures.join("\n\t")).toLatin1());
     }
 }
 
 
 
 QTEST_MAIN(KisAllFilterTest)
diff --git a/plugins/filters/tests/kis_all_filter_test.h b/plugins/filters/tests/kis_all_filter_test.h
index 8db01e3385..e82c1b000f 100644
--- a/plugins/filters/tests/kis_all_filter_test.h
+++ b/plugins/filters/tests/kis_all_filter_test.h
@@ -1,36 +1,35 @@
 /*
  *  Copyright (c) 2008 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_ALL_FILTER_TEST_H
 #define KIS_ALL_FILTER_TEST_H
 
 #include <QtTest>
 
 class KisAllFilterTest : public QObject
 {
     Q_OBJECT
 
 private Q_SLOTS:
 
     void testAllFilters();
-    void testAllFiltersNoTransaction();
     void testAllFiltersSrcNotIsDev();
     void testAllFiltersWithSelections();
 };
 
 #endif
diff --git a/plugins/filters/tests/kis_crash_filter_test.cpp b/plugins/filters/tests/kis_crash_filter_test.cpp
index 1fbdc3058e..e044e8d527 100644
--- a/plugins/filters/tests/kis_crash_filter_test.cpp
+++ b/plugins/filters/tests/kis_crash_filter_test.cpp
@@ -1,99 +1,122 @@
 /*
  *  Copyright (c) 2008 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_crash_filter_test.h"
 #include <KoColorProfile.h>
 #include <QTest>
 #include "filter/kis_filter_configuration.h"
 #include "filter/kis_filter_registry.h"
 #include "kis_selection.h"
 #include "kis_processing_information.h"
 #include "filter/kis_filter.h"
 #include "kis_pixel_selection.h"
 #include <KoColorSpaceRegistry.h>
+#include "kis_transaction.h"
+#include <sdk/tests/testing_timed_default_bounds.h>
 
 
 bool KisCrashFilterTest::applyFilter(const KoColorSpace * cs,  KisFilterSP f)
 {
 
     QImage qimage(QString(FILES_DATA_DIR) + QDir::separator() + "carrot.png");
 
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
-//    dev->fill(0, 0, 100, 100, dev->defaultPixel());
+    dev->setDefaultBounds(new TestUtil::TestingTimedDefaultBounds(qimage.rect()));
     dev->convertFromQImage(qimage, 0, 0, 0);
 
     // Get the predefined configuration from a file
     KisFilterConfigurationSP  kfc = f->defaultConfiguration();
 
     QFile file(QString(FILES_DATA_DIR) + QDir::separator() + f->id() + ".cfg");
     if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
         dbgKrita << "creating new file for " << f->id();
         file.open(QIODevice::WriteOnly | QIODevice::Text);
         QTextStream out(&file);
         out.setCodec("UTF-8");
         out << kfc->toXML();
     } else {
         QString s;
         QTextStream in(&file);
         in.setCodec("UTF-8");
         s = in.readAll();
         kfc->fromXML(s);
     }
     dbgKrita << f->id() << ", " << cs->id() << ", " << cs->profile()->name();// << kfc->toXML() << "\n";
 
-    f->process(dev, QRect(QPoint(0,0), qimage.size()), kfc);
+    {
+        KisTransaction t(kundo2_noi18n(f->name()), dev);
+        f->process(dev, QRect(QPoint(0,0), qimage.size()), kfc);
+    }
 
     return true;
 
 }
 
 bool KisCrashFilterTest::testFilter(KisFilterSP f)
 {
-    QList<const KoColorSpace*> colorSpaces = KoColorSpaceRegistry::instance()->allColorSpaces(KoColorSpaceRegistry::AllColorSpaces, KoColorSpaceRegistry::AllProfiles);
+    QList<const KoColorSpace*> colorSpaces = KoColorSpaceRegistry::instance()->allColorSpaces(KoColorSpaceRegistry::AllColorSpaces, KoColorSpaceRegistry::OnlyDefaultProfile);
     bool ok = false;
     Q_FOREACH (const KoColorSpace* colorSpace, colorSpaces) {
         // XXX: Let's not check the painterly colorspaces right now
         if (colorSpace->id().startsWith("KS", Qt::CaseInsensitive)) {
             continue;
         }
+
+        // Alpha color spaces are never processed directly. They are
+        // first converted into GrayA color space
+        if (colorSpace->id().startsWith("ALPHA", Qt::CaseInsensitive)) {
+            continue;
+        }
+
         ok = applyFilter(colorSpace, f);
     }
 
     return ok;
 }
 
 void KisCrashFilterTest::testCrashFilters()
 {
+    QStringList excludeFilters;
+    excludeFilters << "colortransfer";
+    excludeFilters << "gradientmap";
+    excludeFilters << "phongbumpmap";
+    excludeFilters << "perchannel";
+    excludeFilters << "height to normal";
+
+
     QStringList failures;
     QStringList successes;
 
     QList<QString> filterList = KisFilterRegistry::instance()->keys();
     std::sort(filterList.begin(), filterList.end());
     for (QList<QString>::Iterator it = filterList.begin(); it != filterList.end(); ++it) {
+        if (excludeFilters.contains(*it)) continue;
+
         if (testFilter(KisFilterRegistry::instance()->value(*it)))
             successes << *it;
         else
             failures << *it;
     }
     dbgKrita << "Success: " << successes;
     if (failures.size() > 0) {
         QFAIL(QString("Failed filters:\n\t %1").arg(failures.join("\n\t")).toLatin1());
     }
 }
 
-QTEST_MAIN(KisCrashFilterTest)
+#include <sdk/tests/kistest.h>
+KISTEST_MAIN(KisCrashFilterTest)
diff --git a/plugins/filters/unsharp/unsharp.cpp b/plugins/filters/unsharp/unsharp.cpp
index a829881b11..118c654114 100644
--- a/plugins/filters/unsharp/unsharp.cpp
+++ b/plugins/filters/unsharp/unsharp.cpp
@@ -1,41 +1,41 @@
 /*
  * This file is part of Krita
  *
  * Copyright (c) 2006 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 "unsharp.h"
 #include <kpluginfactory.h>
 
 #include "kis_unsharp_filter.h"
 
 #include <filter/kis_filter_registry.h>
 
 K_PLUGIN_FACTORY_WITH_JSON(UnsharpPluginFactory, "kritaunsharpfilter.json", registerPlugin<UnsharpPlugin>();)
 
 UnsharpPlugin::UnsharpPlugin(QObject *parent, const QVariantList &)
         : QObject(parent)
 {
     KisFilterRegistry::instance()->add(new KisUnsharpFilter());
 
 }
 
 UnsharpPlugin::~UnsharpPlugin()
 {
 }
 
-#include "unsharp.moc"
\ No newline at end of file
+#include "unsharp.moc"
diff --git a/plugins/flake/textshape/dialogs/DockerStylesComboModel.cpp b/plugins/flake/textshape/dialogs/DockerStylesComboModel.cpp
index 4feaba223e..6979622320 100644
--- a/plugins/flake/textshape/dialogs/DockerStylesComboModel.cpp
+++ b/plugins/flake/textshape/dialogs/DockerStylesComboModel.cpp
@@ -1,185 +1,183 @@
 /* This file is part of the KDE project
  * Copyright (C) 2012 Pierre Stirnweiss <pstirnweiss@googlemail.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 "DockerStylesComboModel.h"
 
 #include <KoCharacterStyle.h>
 #include <KoParagraphStyle.h>
 #include <KoStyleManager.h>
 
 #include <klocalizedstring.h>
 
 #include <QDebug>
 
 #include "StylesModel.h"
 
 DockerStylesComboModel::DockerStylesComboModel(QObject *parent) 
     : StylesFilteredModelBase(parent)
     , m_styleManager(0)
 {
 }
 
 Qt::ItemFlags DockerStylesComboModel::flags(const QModelIndex &index) const
 {
     if (index.internalId() == (quintptr)UsedStyleId || index.internalId() == (quintptr)UnusedStyleId) {
         return (Qt::NoItemFlags);
     }
     return (Qt::ItemIsEnabled | Qt::ItemIsSelectable);
 }
 
 QModelIndex DockerStylesComboModel::index(int row, int column, const QModelIndex &parent) const
 {
     if (row < 0 || column != 0) {
         return QModelIndex();
     }
 
     if (!parent.isValid()) {
         if (row >= m_proxyToSource.count()) {
             return QModelIndex();
         }
         return createIndex(row, column, (m_proxyToSource.at(row) >= 0) ? int(m_sourceModel->index(m_proxyToSource.at(row), 0, QModelIndex()).internalId()) : m_proxyToSource.at(row));
     }
     return QModelIndex();
 }
 
 QVariant DockerStylesComboModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid()) {
         return QVariant();
     }
 
     switch (role) {
     case AbstractStylesModel::isTitleRole: {
-        if (index.internalId() == (quintptr)UsedStyleId || index.internalId() == (quintptr)UnusedStyleId) {
-            return true;
-        }
+        return (index.internalId() == (quintptr)UsedStyleId || index.internalId() == (quintptr)UnusedStyleId);
     }
     case Qt::DisplayRole: {
         if (index.internalId() == (quintptr)UsedStyleId) {
             return i18n("Used Styles");
         }
         if (index.internalId() == (quintptr)UnusedStyleId) {
             return i18n("Unused Styles");
         }
         return QVariant();
     }
     case Qt::DecorationRole: {
         return m_sourceModel->data(m_sourceModel->index(m_proxyToSource.at(index.row()), 0, QModelIndex()), role);
         break;
     }
     case Qt::SizeHintRole: {
         return QVariant(QSize(250, 48));
     }
     default: break;
     };
     return QVariant();
 }
 
 void DockerStylesComboModel::setInitialUsedStyles(QVector<int> usedStyles)
 {
     Q_UNUSED(usedStyles);
     // This is not used yet. Let's revisit this later.
 
 //    m_usedStyles << usedStyles;
 //    beginResetModel();
 //    createMapping();
 //    endResetModel();
 }
 
 void DockerStylesComboModel::setStyleManager(KoStyleManager *sm)
 {
     Q_ASSERT(sm);
     Q_ASSERT(m_sourceModel);
     if (!sm || !m_sourceModel || m_styleManager == sm) {
         return;
     }
     m_styleManager = sm;
     createMapping();
 }
 
 void DockerStylesComboModel::styleApplied(const KoCharacterStyle *style)
 {
     QModelIndex sourceIndex = m_sourceModel->indexOf(style);
     if (!sourceIndex.isValid()) {
         return; // Probably default style.
     }
     if (m_usedStylesId.contains(style->styleId())) {
         return; // Style already among used styles.
     }
     beginResetModel();
     createMapping();
     endResetModel();
 }
 
 void DockerStylesComboModel::createMapping()
 {
     Q_ASSERT(m_sourceModel);
     if (!m_sourceModel || !m_styleManager) {
         return;
     }
 
     m_proxyToSource.clear();
     m_sourceToProxy.clear();
     m_unusedStyles.clear();
     m_usedStyles.clear();
     m_usedStylesId.clear();
 
     QVector<int> usedStyles;
     if (m_sourceModel->stylesType() == AbstractStylesModel::CharacterStyle) {
         usedStyles = m_styleManager->usedCharacterStyles();
     } else {
         usedStyles = m_styleManager->usedParagraphStyles();
     }
 
     // The order of the styles is already correctly given by the source model.
     // Therefore it is not needed to resort the styles again here. The source model
     // makes sure to have the NoneStyleId as first style and the styles after
     // that are ordered by name.
     for (int i = 0; i < m_sourceModel->rowCount(QModelIndex()); ++i) {
         QModelIndex index = m_sourceModel->index(i, 0, QModelIndex());
         int id = (int)index.internalId();
         if (id == StylesModel::NoneStyleId || usedStyles.contains(id)) {
             m_usedStylesId.append(id);
             m_usedStyles.append(i);
         } else {
             m_unusedStyles.append(i);
         }
     }
     if (!m_usedStyles.isEmpty()) {
         m_proxyToSource << UsedStyleId << m_usedStyles;
     }
     if (!m_unusedStyles.isEmpty()) {
         m_proxyToSource << UnusedStyleId << m_unusedStyles; //UsedStyleId and UnusedStyleId will be detected as title (in index method) and will be treated accordingly
     }
     m_sourceToProxy.fill(-1, m_sourceModel->rowCount((QModelIndex())));
     for (int i = 0; i < m_proxyToSource.count(); ++i) {
         if (m_proxyToSource.at(i) >= 0) { //we do not need to map to the titles
             m_sourceToProxy[m_proxyToSource.at(i)] = i;
         }
     }
 }
 
 KoCharacterStyle *DockerStylesComboModel::findStyle(int styleId) const
 {
     if (m_sourceModel->stylesType() == AbstractStylesModel::CharacterStyle) {
         return m_styleManager->characterStyle(styleId);
     } else {
         return m_styleManager->paragraphStyle(styleId);
     }
 }
diff --git a/plugins/flake/textshape/dialogs/TableOfContentsStyleModel.cpp b/plugins/flake/textshape/dialogs/TableOfContentsStyleModel.cpp
index 37447bdc05..7c39f6e3d4 100644
--- a/plugins/flake/textshape/dialogs/TableOfContentsStyleModel.cpp
+++ b/plugins/flake/textshape/dialogs/TableOfContentsStyleModel.cpp
@@ -1,260 +1,259 @@
 /* This file is part of the KDE project
  * Copyright (C) 2011 Gopalakrishna Bhat A <gopalakbhat@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 "TableOfContentsStyleModel.h"
 
 #include "KoStyleManager.h"
 #include <KoStyleThumbnailer.h>
 #include "KoParagraphStyle.h"
 #include "ToCBibGeneratorInfo.h"
 #include "KoTableOfContentsGeneratorInfo.h"
+#include "kis_assert.h"
 
 #include <QPair>
 
 #include <klocalizedstring.h>
 
 TableOfContentsStyleModel::TableOfContentsStyleModel(const KoStyleManager *manager, KoTableOfContentsGeneratorInfo *info)
     : QAbstractTableModel()
     , m_styleManager(manager)
     , m_styleThumbnailer(new KoStyleThumbnailer())
     , m_tocInfo(info)
 {
     Q_ASSERT(manager);
     Q_ASSERT(info);
 
     m_styleThumbnailer->setThumbnailSize(QSize(250, 48));
 
     Q_FOREACH (const KoParagraphStyle *style, m_styleManager->paragraphStyles()) {
         m_styleList.append(style->styleId());
         m_outlineLevel.append(getOutlineLevel(style->styleId()));
     }
 
 }
 
 QModelIndex TableOfContentsStyleModel::index(int row, int column, const QModelIndex &parent) const
 {
     if (row < 0 || column < 0 || column > 1) {
         return QModelIndex();
     }
 
     if (!parent.isValid()) {
         if (row >= m_styleList.count()) {
             return QModelIndex();
         }
 
         QPair<int, int> *modelValue = new QPair<int, int>(m_styleList[row], m_outlineLevel[row]);
         return createIndex(row, column, modelValue);
     }
     return QModelIndex();
 }
 
 int TableOfContentsStyleModel::rowCount(const QModelIndex &parent) const
 {
     if (!parent.isValid()) {
         return m_styleList.count();
     }
     return 0;
 }
 
 int TableOfContentsStyleModel::columnCount(const QModelIndex &parent) const
 {
     if (!parent.isValid()) {
         return 2;
     }
     return 0;
 }
 
 QVariant TableOfContentsStyleModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid()) {
         return QVariant();
     }
 
     int id = static_cast< QPair<int, int> *>(index.internalPointer())->first;
     if (index.column() == 0) {
         switch (role) {
         case Qt::DisplayRole: {
             return QVariant();
         }
         case Qt::DecorationRole: {
             if (!m_styleThumbnailer) {
                 return QPixmap();
             }
             KoParagraphStyle *paragStyle = m_styleManager->paragraphStyle(id);
             if (paragStyle) {
                 return m_styleThumbnailer->thumbnail(paragStyle);
             }
             break;
         }
         default: break;
         }
     } else {
         KoParagraphStyle *paragStyle = m_styleManager->paragraphStyle(id);
+        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(paragStyle, QVariant());
+
         switch (role) {
         case Qt::DisplayRole: {
-            if (paragStyle) {
-                if (QVariant(static_cast< QPair<int, int> *>(index.internalPointer())->second).value<int>() == 0) {
-                    return QVariant(i18n("Disabled"));
-                } else {
-                    return QVariant(static_cast< QPair<int, int> *>(index.internalPointer())->second);
-                }
+            if (QVariant(static_cast< QPair<int, int> *>(index.internalPointer())->second).value<int>() == 0) {
+                return QVariant(i18n("Disabled"));
+            } else {
+                return QVariant(static_cast< QPair<int, int> *>(index.internalPointer())->second);
             }
         }
         case Qt::EditRole: {
-            if (paragStyle) {
-                return QVariant(static_cast< QPair<int, int> *>(index.internalPointer())->second);
-            }
+            return QVariant(static_cast< QPair<int, int> *>(index.internalPointer())->second);
         }
         default: break;
         }
     }
     return QVariant();
 }
 
 Qt::ItemFlags TableOfContentsStyleModel::flags(const QModelIndex &index) const
 {
     if (!index.isValid()) {
         return 0;
     }
     if (index.column() == 0) {
         return (Qt::ItemIsSelectable | Qt::ItemIsEnabled);
     }
     if (index.column() == 1) {
         return (Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable);
     }
     return 0;
 }
 
 bool TableOfContentsStyleModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
     if (!index.isValid()) {
         return false;
     }
 
     static_cast< QPair<int, int> *>(index.internalPointer())->second = value.toInt();
     QAbstractTableModel::setData(index, value, role);
     m_outlineLevel[index.row()] = value.toInt();
     return true;
 }
 
 void TableOfContentsStyleModel::saveData()
 {
     int row = 0;
 
     Q_FOREACH (const int styleId, m_styleList) {
         KoParagraphStyle *paragStyle = m_styleManager->paragraphStyle(styleId);
         if (paragStyle) {
             setOutlineLevel(styleId, m_outlineLevel[row]);
         }
         row++;
     }
 }
 
 int TableOfContentsStyleModel::getOutlineLevel(int styleId)
 {
     foreach (const IndexSourceStyles &indexSourceStyles, m_tocInfo->m_indexSourceStyles) {
         foreach (const IndexSourceStyle &indexStyle, indexSourceStyles.styles) {
             if (m_styleManager->paragraphStyle(indexStyle.styleId) && styleId == indexStyle.styleId) {
                 return indexSourceStyles.outlineLevel;
             }
         }
     }
     return 0;
 }
 
 void TableOfContentsStyleModel::setOutlineLevel(int styleId, int outLineLevel)
 {
     //ignore changes to paragraph styles with KoParagraphStyle::OutlineLevel property set.
     //i.e. those considered by KoTableOfContentsGeneratorInfo::m_useOutlineLevel==true
     if (m_styleManager->paragraphStyle(styleId)->hasProperty(KoParagraphStyle::OutlineLevel)) {
         return;
     }
 
     //check if the outlineLevel has changed
     if (getOutlineLevel(styleId) == outLineLevel) {
         return;
     }
 
     //now insert the style at the correct place( remove from the old place first and then insert at the new level)
     IndexSourceStyle indexStyleMoved;
     bool styleFound = false;
     int sourceStyleIndex = 0;
     foreach (const IndexSourceStyles &indexSourceStyles, m_tocInfo->m_indexSourceStyles) {
         int index = 0;
         foreach (const IndexSourceStyle &indexStyle, indexSourceStyles.styles) {
             if (styleId == indexStyle.styleId) {
                 styleFound = true;
                 indexStyleMoved = m_tocInfo->m_indexSourceStyles[sourceStyleIndex].styles.takeAt(index);
                 break;
             }
             index++;
 
             if (styleFound == true) {
                 break;
             }
         }
         sourceStyleIndex++;
     }
 
     //this style is not in the IndexSourceStyles list so fill it
     if (!styleFound) {
         indexStyleMoved.styleId = styleId;
         indexStyleMoved.styleName = m_styleManager->paragraphStyle(styleId)->name();
     }
 
     //check if IndexSourceStyles are there for this outlineLevel, if not create it
     bool sourceStylePresent = false;
     foreach (const IndexSourceStyles &indexSourceStyles, m_tocInfo->m_indexSourceStyles) {
         if (outLineLevel == indexSourceStyles.outlineLevel) {
             sourceStylePresent = true;
             break;
         }
     }
 
     if (!sourceStylePresent) {
         IndexSourceStyles indexStyles;
         indexStyles.outlineLevel = outLineLevel;
         m_tocInfo->m_indexSourceStyles.append(indexStyles);
     }
 
     sourceStyleIndex = 0;
     foreach (const IndexSourceStyles &indexSourceStyles, m_tocInfo->m_indexSourceStyles) {
         if (outLineLevel == indexSourceStyles.outlineLevel) {
             m_tocInfo->m_indexSourceStyles[sourceStyleIndex].styles.append(indexStyleMoved);
             break;
         }
         sourceStyleIndex++;
     }
 
 }
 
 QVariant TableOfContentsStyleModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     if (orientation == Qt::Horizontal && role == Qt::DisplayRole) {
         if (section == 0) {
             return i18n("Styles");
         } else if (section == 1) {
             return i18n("Level");
         } else {
             return QAbstractTableModel::headerData(section, orientation, role);
         }
     } else {
         return QAbstractTableModel::headerData(section, orientation, role);
     }
 }
diff --git a/plugins/impex/brush/krita_brush.desktop b/plugins/impex/brush/krita_brush.desktop
index a0eb1ba611..19dd8f621d 100644
--- a/plugins/impex/brush/krita_brush.desktop
+++ b/plugins/impex/brush/krita_brush.desktop
@@ -1,73 +1,73 @@
 [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[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 %u
+Exec=krita %f
 MimeType=image/x-gimp-brush;
 Type=Application
 Icon=calligrakrita
 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 3e0b42747c..7ae9f5af2e 100644
--- a/plugins/impex/csv/krita_csv.desktop
+++ b/plugins/impex/csv/krita_csv.desktop
@@ -1,71 +1,71 @@
 [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[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 %u
+Exec=krita %f
 MimeType=text/csv;
 Type=Application
 Icon=calligrakrita
 Categories=Qt;KDE;Office;Graphics;
 StartupNotify=true
 NoDisplay=true
diff --git a/plugins/impex/csv/tests/CMakeLists.txt b/plugins/impex/csv/tests/CMakeLists.txt
index 6fc6c5605b..dd7a4193ff 100644
--- a/plugins/impex/csv/tests/CMakeLists.txt
+++ b/plugins/impex/csv/tests/CMakeLists.txt
@@ -1,10 +1,11 @@
 set( EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR} )
 include_directories(     ${CMAKE_SOURCE_DIR}/sdk/tests )
 
 include(KritaAddBrokenUnitTest)
 
 macro_add_unittest_definitions()
 
 ecm_add_test(kis_csv_test.cpp
-    TEST_NAME krita-plugin-format-csv_test
-    LINK_LIBRARIES kritaui Qt5::Test)
+    TEST_NAME kis_csv_test
+    LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "plugins-impex-")
diff --git a/plugins/impex/exr/krita_exr.desktop b/plugins/impex/exr/krita_exr.desktop
index b6148effeb..2a30a3505b 100644
--- a/plugins/impex/exr/krita_exr.desktop
+++ b/plugins/impex/exr/krita_exr.desktop
@@ -1,124 +1,124 @@
 [Desktop Entry]
 Categories=Qt;KDE;Office;Graphics;
-Exec=krita %u
+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[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
 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[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/exr/tests/CMakeLists.txt b/plugins/impex/exr/tests/CMakeLists.txt
index 12f8ff21d7..ec28428903 100644
--- a/plugins/impex/exr/tests/CMakeLists.txt
+++ b/plugins/impex/exr/tests/CMakeLists.txt
@@ -1,10 +1,11 @@
 set( EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR} )
 include_directories(     ${CMAKE_SOURCE_DIR}/sdk/tests )
 
 include(KritaAddBrokenUnitTest)
 
 macro_add_unittest_definitions()
 
 ecm_add_test(kis_exr_test.cpp
-    TEST_NAME krita-plugin-format-exr_test
-    LINK_LIBRARIES kritaui Qt5::Test)
+    TEST_NAME kis_exr_test
+    LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "plugins-impex-")
diff --git a/plugins/impex/gif/krita_gif.desktop b/plugins/impex/gif/krita_gif.desktop
index b2907f0576..80afd40c5a 100644
--- a/plugins/impex/gif/krita_gif.desktop
+++ b/plugins/impex/gif/krita_gif.desktop
@@ -1,71 +1,71 @@
 [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[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 %u
+Exec=krita %f
 MimeType=image/gif;
 Type=Application
 Icon=calligrakrita
 Categories=Qt;KDE;Office;Graphics;
 StartupNotify=true
 NoDisplay=true
diff --git a/plugins/impex/heif/krita_heif.desktop b/plugins/impex/heif/krita_heif.desktop
index e56711a12f..03315e7738 100644
--- a/plugins/impex/heif/krita_heif.desktop
+++ b/plugins/impex/heif/krita_heif.desktop
@@ -1,124 +1,124 @@
 [Desktop Entry]
 Categories=Qt;KDE;Office;Graphics;
-Exec=krita %u
+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[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
 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[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 27a3972576..0c254dc52a 100644
--- a/plugins/impex/heightmap/krita_heightmap.desktop
+++ b/plugins/impex/heightmap/krita_heightmap.desktop
@@ -1,75 +1,75 @@
 [Desktop Entry]
 Categories=Qt;KDE;Office;Graphics;
-Exec=krita %u
+Exec=krita %f
 GenericName=
 Icon=calligrakrita
 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[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/heightmap/tests/CMakeLists.txt b/plugins/impex/heightmap/tests/CMakeLists.txt
index 23bfe8f462..d4a60d03e4 100644
--- a/plugins/impex/heightmap/tests/CMakeLists.txt
+++ b/plugins/impex/heightmap/tests/CMakeLists.txt
@@ -1,10 +1,11 @@
 set( EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR} )
 include_directories(     ${CMAKE_SOURCE_DIR}/sdk/tests )
 
 include(KritaAddBrokenUnitTest)
 
 macro_add_unittest_definitions()
 
 ecm_add_test(kis_heightmap_test.cpp
-    TEST_NAME krita-plugin-format-heightmap_test
-    LINK_LIBRARIES kritaui Qt5::Test)
+    TEST_NAME kis_heightmap_test
+    LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "plugins-impex-")
diff --git a/plugins/impex/jpeg/krita_jpeg.desktop b/plugins/impex/jpeg/krita_jpeg.desktop
index bfe9cc616c..c94f6e6e54 100644
--- a/plugins/impex/jpeg/krita_jpeg.desktop
+++ b/plugins/impex/jpeg/krita_jpeg.desktop
@@ -1,74 +1,74 @@
 [Desktop Entry]
 Categories=Qt;KDE;Office;Graphics;
-Exec=krita %u
+Exec=krita %f
 Icon=calligrakrita
 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[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/jpeg/tests/CMakeLists.txt b/plugins/impex/jpeg/tests/CMakeLists.txt
index 54f1b648db..0d71011a0a 100644
--- a/plugins/impex/jpeg/tests/CMakeLists.txt
+++ b/plugins/impex/jpeg/tests/CMakeLists.txt
@@ -1,9 +1,10 @@
 #set EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR})
 include_directories(${CMAKE_SOURCE_DIR}/sdk/tests)
 include(KritaAddBrokenUnitTest)
 
 macro_add_unittest_definitions()
 
 ecm_add_test(kis_jpeg_test.cpp
-    TEST_NAME krita-plugin-format-jpeg_test
-    LINK_LIBRARIES kritaui Qt5::Test)
+    TEST_NAME kis_jpeg_test
+    LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "plugins-impex-")
diff --git a/plugins/impex/kra/krita_kra.desktop b/plugins/impex/kra/krita_kra.desktop
index f206e61b00..213e9c3660 100644
--- a/plugins/impex/kra/krita_kra.desktop
+++ b/plugins/impex/kra/krita_kra.desktop
@@ -1,75 +1,75 @@
 [Desktop Entry]
 Categories=Qt;KDE;Office;Graphics;
 Comment=
-Exec=krita %u
+Exec=krita %f
 Icon=calligrakrita
 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[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/libkra/tests/CMakeLists.txt b/plugins/impex/libkra/tests/CMakeLists.txt
index 1fcf6a5787..096295b95c 100644
--- a/plugins/impex/libkra/tests/CMakeLists.txt
+++ b/plugins/impex/libkra/tests/CMakeLists.txt
@@ -1,15 +1,12 @@
 set( EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR} )
 
 include_directories( ${CMAKE_SOURCE_DIR}/sdk/tests )
 
 macro_add_unittest_definitions()
 
-ecm_add_test(
+ecm_add_tests(
     kis_kra_loader_test.cpp
-    TEST_NAME KisKraLoaderTest
-    LINK_LIBRARIES kritaimage kritaui kritalibkra Qt5::Test)
-
-ecm_add_test(
     kis_kra_saver_test.cpp
-    TEST_NAME KisKraSaverTest
-    LINK_LIBRARIES kritaimage kritaui kritalibkra Qt5::Test)
+
+    LINK_LIBRARIES kritaui kritalibkra Qt5::Test
+    NAME_PREFIX "plugins-impex-")
diff --git a/plugins/impex/ora/krita_ora.desktop b/plugins/impex/ora/krita_ora.desktop
index 6d235ad19f..d58255fa96 100644
--- a/plugins/impex/ora/krita_ora.desktop
+++ b/plugins/impex/ora/krita_ora.desktop
@@ -1,75 +1,75 @@
 [Desktop Entry]
 Categories=Qt;KDE;Office;Graphics;
 Comment=
-Exec=krita %u
+Exec=krita %f
 Icon=calligrakrita
 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[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 6362a0b6bc..f443c612b6 100644
--- a/plugins/impex/pdf/krita_pdf.desktop
+++ b/plugins/impex/pdf/krita_pdf.desktop
@@ -1,74 +1,74 @@
 [Desktop Entry]
 Categories=Qt;KDE;Office;Graphics;
-Exec=krita %u
+Exec=krita %f
 Icon=calligrakrita
 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[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 69e3b3037d..6ff582fd54 100644
--- a/plugins/impex/png/krita_png.desktop
+++ b/plugins/impex/png/krita_png.desktop
@@ -1,71 +1,71 @@
 [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[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 %u
+Exec=krita %f
 MimeType=image/png;
 Type=Application
 Icon=calligrakrita
 Categories=Qt;KDE;Office;Graphics;
 StartupNotify=true
 NoDisplay=true
diff --git a/plugins/impex/png/tests/CMakeLists.txt b/plugins/impex/png/tests/CMakeLists.txt
index df46d5885a..8d78edc511 100644
--- a/plugins/impex/png/tests/CMakeLists.txt
+++ b/plugins/impex/png/tests/CMakeLists.txt
@@ -1,10 +1,11 @@
 set( EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR} )
 include_directories(     ${CMAKE_SOURCE_DIR}/sdk/tests )
 
 include(KritaAddBrokenUnitTest)
 
 macro_add_unittest_definitions()
 
 ecm_add_test(kis_png_test.cpp
-    TEST_NAME krita-plugin-format-png_test
-    LINK_LIBRARIES kritaui Qt5::Test)
+    TEST_NAME kis_png_test
+    LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "plugins-impex-")
diff --git a/plugins/impex/ppm/krita_ppm.desktop b/plugins/impex/ppm/krita_ppm.desktop
index 64fdea171a..a3b0a16396 100644
--- a/plugins/impex/ppm/krita_ppm.desktop
+++ b/plugins/impex/ppm/krita_ppm.desktop
@@ -1,75 +1,75 @@
 [Desktop Entry]
 Categories=Qt;KDE;Office;Graphics;
-Exec=krita %u
+Exec=krita %f
 GenericName=
 Icon=calligrakrita
 MimeType=image/x-portable-pixmap;image/x-portable-graymap;image/x-portable-bitmap;
 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[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/ppm/tests/CMakeLists.txt b/plugins/impex/ppm/tests/CMakeLists.txt
index e00547dfd8..27bc54a312 100644
--- a/plugins/impex/ppm/tests/CMakeLists.txt
+++ b/plugins/impex/ppm/tests/CMakeLists.txt
@@ -1,10 +1,11 @@
 set( EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR} )
 include_directories(     ${CMAKE_SOURCE_DIR}/sdk/tests )
 
 include(KritaAddBrokenUnitTest)
 
 macro_add_unittest_definitions()
 
 ecm_add_test(kis_ppm_test.cpp
-    TEST_NAME krita-plugin-format-ppm_test
-    LINK_LIBRARIES kritaui Qt5::Test)
+    TEST_NAME kis_ppm_test
+    LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "plugins-impex-")
diff --git a/plugins/impex/psd/krita_psd.desktop b/plugins/impex/psd/krita_psd.desktop
index e3113e396b..53620b5837 100644
--- a/plugins/impex/psd/krita_psd.desktop
+++ b/plugins/impex/psd/krita_psd.desktop
@@ -1,74 +1,74 @@
 [Desktop Entry]
 Categories=Qt;KDE;Office;Graphics;
-Exec=krita %u
+Exec=krita %f
 Icon=calligrakrita
 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[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/psd/tests/CMakeLists.txt b/plugins/impex/psd/tests/CMakeLists.txt
index f9f727239f..802d78e47f 100644
--- a/plugins/impex/psd/tests/CMakeLists.txt
+++ b/plugins/impex/psd/tests/CMakeLists.txt
@@ -1,37 +1,40 @@
 include_directories(${CMAKE_BINARY_DIR}/libs/psd)  #For kispsd_include.h
 include_directories(${CMAKE_BINARY_DIR}/libs/pigment)
 
 set( EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR} )
 include_directories(
     ${CMAKE_SOURCE_DIR}/..
     ${CMAKE_SOURCE_DIR}/sdk/tests
     ${CMAKE_SOURCE_DIR}/libs/psd
     ${CMAKE_SOURCE_DIR}/plugins/impex/psd
     ${CMAKE_SOURCE_DIR}/libs/pigment
 )
 
 macro_add_unittest_definitions()
 
 if (WIN32)
     set(PSD_TEST_LIBS kritapsd Qt5::Test ${WIN32_PLATFORM_NET_LIBS})
 else (WIN32)
     set(PSD_TEST_LIBS kritapsd Qt5::Test)
 endif (WIN32)
 
 ecm_add_tests(
     psd_utils_test.cpp
     compression_test.cpp
-    NAME_PREFIX "krita-psd-"
+    NAME_PREFIX "plugins-impex-psd-"
     LINK_LIBRARIES ${PSD_TEST_LIBS})
 
 ecm_add_test(psd_header_test.cpp ../psd_header.cpp
-    TEST_NAME krita-psd-psd_header_test
-    LINK_LIBRARIES kritaglobal KF5::I18n ${PSD_TEST_LIBS})
+    TEST_NAME psd_header_test
+    LINK_LIBRARIES kritaglobal KF5::I18n ${PSD_TEST_LIBS}
+    NAME_PREFIX "plugins-impex-psd-")
 
 ecm_add_test(psd_colormode_block_test.cpp ../psd_header.cpp ../psd_colormode_block.cpp
-    TEST_NAME krita-psd-psd_colormode_block_test
-    LINK_LIBRARIES kritaglobal KF5::I18n Qt5::Gui ${PSD_TEST_LIBS})
+    TEST_NAME psd_colormode_block_test
+    LINK_LIBRARIES kritaglobal KF5::I18n Qt5::Gui ${PSD_TEST_LIBS}
+    NAME_PREFIX "plugins-impex-psd-")
 
 krita_add_broken_unit_test(kis_psd_test.cpp
-    TEST_NAME krita-plugins-formats-psd_test
-    LINK_LIBRARIES ${PSD_TEST_LIBS} kritaui)
+    TEST_NAME kis_psd_test
+    LINK_LIBRARIES ${PSD_TEST_LIBS} kritaui
+    NAME_PREFIX "plugins-impex-psd-")
diff --git a/plugins/impex/qimageio/krita_qimageio.desktop b/plugins/impex/qimageio/krita_qimageio.desktop
index 2549a562ce..5b7176211f 100644
--- a/plugins/impex/qimageio/krita_qimageio.desktop
+++ b/plugins/impex/qimageio/krita_qimageio.desktop
@@ -1,71 +1,71 @@
 [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[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 %u
+Exec=krita %f
 MimeType=image/bmp;image/x-xpixmap;image/x-xbitmap;image/vnd.microsoft.icon;image/webp
 Type=Application
 Icon=calligrakrita
 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 25ae68957c..26b97dd8d1 100644
--- a/plugins/impex/raw/krita_raw.desktop
+++ b/plugins/impex/raw/krita_raw.desktop
@@ -1,71 +1,71 @@
 [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[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 %u
+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
 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 82ac722acf..0f64b14bbc 100644
--- a/plugins/impex/spriter/krita_spriter.desktop
+++ b/plugins/impex/spriter/krita_spriter.desktop
@@ -1,71 +1,71 @@
 [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[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 %u
+Exec=krita %f
 MimeType=image/x-scml;
 Type=Application
 Icon=calligrakrita
 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 188cdc1f38..ace1cc9290 100644
--- a/plugins/impex/svg/krita_svg.desktop
+++ b/plugins/impex/svg/krita_svg.desktop
@@ -1,71 +1,71 @@
 [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[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 %u
+Exec=krita %f
 MimeType=image/svg+xml;
 Type=Application
 Icon=calligrakrita
 Categories=Qt;KDE;Office;Graphics;
 StartupNotify=true
 NoDisplay=true
diff --git a/plugins/impex/svg/tests/CMakeLists.txt b/plugins/impex/svg/tests/CMakeLists.txt
index 82e0ea0717..94fcb20c21 100644
--- a/plugins/impex/svg/tests/CMakeLists.txt
+++ b/plugins/impex/svg/tests/CMakeLists.txt
@@ -1,10 +1,11 @@
 set(EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR})
 include_directories(${CMAKE_SOURCE_DIR}/sdk/tests)
 include(ECMAddTests)
 macro_add_unittest_definitions()
 
 ecm_add_test(
     kis_svg_test.cpp
-    TEST_NAME plugins-impex-KisSvgTest
+    TEST_NAME KisSvgTest
     LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "plugins-impex-"
 )
diff --git a/plugins/impex/svg/tests/kis_svg_test.cpp b/plugins/impex/svg/tests/kis_svg_test.cpp
index 0d146352be..6ca66688f8 100644
--- a/plugins/impex/svg/tests/kis_svg_test.cpp
+++ b/plugins/impex/svg/tests/kis_svg_test.cpp
@@ -1,40 +1,40 @@
 /*
  * Copyright (C) 2007 Cyrille Berger <cberger@cberger.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_svg_test.h"
 
 
 #include <QTest>
 #include <QCoreApplication>
 
 #include  <sdk/tests/kistest.h>
 
 #include "filestest.h"
 
 #ifndef FILES_DATA_DIR
 #error "FILES_DATA_DIR not set. A directory with the data used for testing the importing of files in krita"
 #endif
 
 
 void KisSvgTest::testFiles()
 {
-    TestUtil::testFiles(QString(FILES_DATA_DIR) + "/sources", QStringList());
+    TestUtil::testFiles(QString(FILES_DATA_DIR) + "/sources", QStringList(), QString(), 30, 50);
 }
 
 KISTEST_MAIN(KisSvgTest)
 
diff --git a/plugins/impex/tga/krita_tga.desktop b/plugins/impex/tga/krita_tga.desktop
index 8adf143a0f..21d0856f6e 100644
--- a/plugins/impex/tga/krita_tga.desktop
+++ b/plugins/impex/tga/krita_tga.desktop
@@ -1,71 +1,71 @@
 [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[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 %u
+Exec=krita %f
 MimeType=image/x-tga;
 Type=Application
 Icon=calligrakrita
 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 3a758b632e..0eef0c8d4a 100644
--- a/plugins/impex/tiff/krita_tiff.desktop
+++ b/plugins/impex/tiff/krita_tiff.desktop
@@ -1,74 +1,74 @@
 [Desktop Entry]
 Categories=Qt;KDE;Office;Graphics;
-Exec=krita %u
+Exec=krita %f
 Icon=calligrakrita
 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[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 8f2ab1fa43..d72ceb7daf 100644
--- a/plugins/impex/xcf/krita_xcf.desktop
+++ b/plugins/impex/xcf/krita_xcf.desktop
@@ -1,74 +1,74 @@
 [Desktop Entry]
 Categories=Qt;KDE;Office;Graphics;
-Exec=krita %u
+Exec=krita %f
 Icon=calligrakrita
 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[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/impex/xcf/tests/CMakeLists.txt b/plugins/impex/xcf/tests/CMakeLists.txt
index 00fa7882a8..2609bfd6dd 100644
--- a/plugins/impex/xcf/tests/CMakeLists.txt
+++ b/plugins/impex/xcf/tests/CMakeLists.txt
@@ -1,10 +1,11 @@
 set( EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR} )
 include_directories(     ${CMAKE_SOURCE_DIR}/sdk/tests )
 
 include(KritaAddBrokenUnitTest)
 
 macro_add_unittest_definitions()
 
 ecm_add_test(kis_xcf_test.cpp
-    TEST_NAME krita-plugin-format-xcf_test
-    LINK_LIBRARIES kritaui Qt5::Test)
+    TEST_NAME kis_xcf_test
+    LINK_LIBRARIES kritaui Qt5::Test
+    NAME_PREFIX "plugins-impex-")
diff --git a/plugins/paintops/defaultpaintops/brush/tests/CMakeLists.txt b/plugins/paintops/defaultpaintops/brush/tests/CMakeLists.txt
index d2d4500c5e..5f2ad29e2d 100644
--- a/plugins/paintops/defaultpaintops/brush/tests/CMakeLists.txt
+++ b/plugins/paintops/defaultpaintops/brush/tests/CMakeLists.txt
@@ -1,20 +1,21 @@
 set( EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR} )
 include_directories(     ${CMAKE_SOURCE_DIR}/sdk/tests )
 
 include(KritaAddBrokenUnitTest)
 
-
 macro_add_unittest_definitions()
 
 include(ECMAddTests)
 
 ecm_add_test(KisDabRenderingQueueTest.cpp
     TEST_NAME KisDabRenderingQueueTest
-    LINK_LIBRARIES kritadefaultpaintops kritalibpaintop kritaimage Qt5::Test)
+    LINK_LIBRARIES kritadefaultpaintops kritalibpaintop kritaimage Qt5::Test
+    NAME_PREFIX "plugins-defaultpaintops-")
 
 
 
 krita_add_broken_unit_test(kis_brushop_test.cpp ../../../../../sdk/tests/stroke_testing_utils.cpp
-    TEST_NAME krita-plugins-KisBrushOpTest
-    LINK_LIBRARIES kritaimage kritaui kritalibpaintop Qt5::Test)
+    TEST_NAME KisBrushOpTest
+    LINK_LIBRARIES kritaui kritalibpaintop Qt5::Test
+    NAME_PREFIX "plugins-defaultpaintops-")
 
diff --git a/plugins/paintops/libpaintop/tests/CMakeLists.txt b/plugins/paintops/libpaintop/tests/CMakeLists.txt
index d38c247878..13fbec8082 100644
--- a/plugins/paintops/libpaintop/tests/CMakeLists.txt
+++ b/plugins/paintops/libpaintop/tests/CMakeLists.txt
@@ -1,13 +1,13 @@
 ########### next target ###############
 include_directories( ${CMAKE_SOURCE_DIR}/..    ${CMAKE_SOURCE_DIR}/sdk/tests )
 
 include(KritaAddBrokenUnitTest)
 
 ecm_add_test(kis_sensors_test.cpp
-    TEST_NAME krita-paintop-SensorsTest
+    NAME_PREFIX plugins-libpaintop-
     LINK_LIBRARIES kritaimage kritalibpaintop Qt5::Test)
 
 krita_add_broken_unit_test(kis_embedded_pattern_manager_test.cpp
-    TEST_NAME krita-paintop-EmbeddedPatternManagerTest
+    NAME_PREFIX plugins-libpaintop-
     LINK_LIBRARIES kritaimage kritalibpaintop Qt5::Test)
 
diff --git a/plugins/tools/basictools/kis_tool_brush.cc b/plugins/tools/basictools/kis_tool_brush.cc
index b16d49e275..8a0aed7e31 100644
--- a/plugins/tools/basictools/kis_tool_brush.cc
+++ b/plugins/tools/basictools/kis_tool_brush.cc
@@ -1,469 +1,473 @@
 /*
  *  kis_tool_brush.cc - part of Krita
  *
  *  Copyright (c) 2003-2004 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2015 Moritz Molch <kde@moritzmolch.de>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_tool_brush.h"
 #include <kis_icon.h>
 
 #include <QCheckBox>
 #include <QComboBox>
 
 #include <klocalizedstring.h>
 #include <QAction>
 #include <QLabel>
 #include <kactioncollection.h>
 
 #include <KoCanvasBase.h>
 #include <KoCanvasController.h>
 
 #include <kis_action_registry.h>
 #include "kis_cursor.h"
 #include "kis_config.h"
 #include "kis_slider_spin_box.h"
 #include "kundo2magicstring.h"
 
 #define MAXIMUM_SMOOTHNESS_DISTANCE 1000.0 // 0..1000.0 == weight in gui
 #define MAXIMUM_MAGNETISM 1000
 
 
 void KisToolBrush::addSmoothingAction(int enumId, const QString &id, const QString &name, const QIcon &icon, KActionCollection *globalCollection)
 {
     /**
      * KisToolBrush is the base of several tools, but the actions
      * should be unique, so let's be careful with them
      */
     if (!globalCollection->action(id)) {
         QAction *action = new QAction(name, globalCollection);
         action->setIcon(icon);
         globalCollection->addAction(id, action);
     }
 
     QAction *action = dynamic_cast<QAction*>(globalCollection->action(id));
     addAction(id, action);
 
     connect(action, SIGNAL(triggered()), &m_signalMapper, SLOT(map()));
     m_signalMapper.setMapping(action, enumId);
 }
 
 KisToolBrush::KisToolBrush(KoCanvasBase * canvas)
     : KisToolFreehand(canvas,
                       KisCursor::load("tool_freehand_cursor.png", 5, 5),
                       kundo2_i18n("Freehand Brush Stroke"))
 {
     setObjectName("tool_brush");
     connect(this, SIGNAL(smoothingTypeChanged()), this, SLOT(resetCursorStyle()));
 
     KActionCollection *collection = this->canvas()->canvasController()->actionCollection();
 
     addSmoothingAction(KisSmoothingOptions::NO_SMOOTHING, "set_no_brush_smoothing", i18nc("@action", "Brush Smoothing: Disabled"), KisIconUtils::loadIcon("smoothing-no"), collection);
     addSmoothingAction(KisSmoothingOptions::SIMPLE_SMOOTHING, "set_simple_brush_smoothing", i18nc("@action", "Brush Smoothing: Basic"), KisIconUtils::loadIcon("smoothing-basic"), collection);
     addSmoothingAction(KisSmoothingOptions::WEIGHTED_SMOOTHING, "set_weighted_brush_smoothing", i18nc("@action", "Brush Smoothing: Weighted"), KisIconUtils::loadIcon("smoothing-weighted"), collection);
     addSmoothingAction(KisSmoothingOptions::STABILIZER, "set_stabilizer_brush_smoothing", i18nc("@action", "Brush Smoothing: Stabilizer"), KisIconUtils::loadIcon("smoothing-stabilizer"), collection);
 
 }
 
 KisToolBrush::~KisToolBrush()
 {
 }
 
 void KisToolBrush::activate(ToolActivation activation, const QSet<KoShape*> &shapes)
 {
     KisToolFreehand::activate(activation, shapes);
     connect(&m_signalMapper, SIGNAL(mapped(int)), SLOT(slotSetSmoothingType(int)), Qt::UniqueConnection);
 
     m_configGroup =  KSharedConfig::openConfig()->group(toolId());
 }
 
 void KisToolBrush::deactivate()
 {
     disconnect(&m_signalMapper, 0, this, 0);
     KisToolFreehand::deactivate();
 }
 
 int KisToolBrush::smoothingType() const
 {
     return smoothingOptions()->smoothingType();
 }
 
 bool KisToolBrush::smoothPressure() const
 {
     return smoothingOptions()->smoothPressure();
 }
 
 int KisToolBrush::smoothnessQuality() const
 {
     return smoothingOptions()->smoothnessDistance();
 }
 
 qreal KisToolBrush::smoothnessFactor() const
 {
     return smoothingOptions()->tailAggressiveness();
 }
 
 void KisToolBrush::slotSetSmoothingType(int index)
 {
     /**
      * The slot can also be called from smoothing-type-switching
      * action that would mean the combo box will not be synchronized
      */
     if (m_cmbSmoothingType->currentIndex() != index) {
         m_cmbSmoothingType->setCurrentIndex(index);
     }
 
     switch (index) {
     case 0:
         smoothingOptions()->setSmoothingType(KisSmoothingOptions::NO_SMOOTHING);
         showControl(m_sliderSmoothnessDistance, false);
         showControl(m_sliderTailAggressiveness, false);
         showControl(m_chkSmoothPressure, false);
         showControl(m_chkUseScalableDistance, false);
         showControl(m_sliderDelayDistance, false);
         showControl(m_chkFinishStabilizedCurve, false);
         showControl(m_chkStabilizeSensors, false);
         break;
     case 1:
         smoothingOptions()->setSmoothingType(KisSmoothingOptions::SIMPLE_SMOOTHING);
         showControl(m_sliderSmoothnessDistance, false);
         showControl(m_sliderTailAggressiveness, false);
         showControl(m_chkSmoothPressure, false);
         showControl(m_chkUseScalableDistance, false);
         showControl(m_sliderDelayDistance, false);
         showControl(m_chkFinishStabilizedCurve, false);
         showControl(m_chkStabilizeSensors, false);
         break;
     case 2:
         smoothingOptions()->setSmoothingType(KisSmoothingOptions::WEIGHTED_SMOOTHING);
         showControl(m_sliderSmoothnessDistance, true);
         showControl(m_sliderTailAggressiveness, true);
         showControl(m_chkSmoothPressure, true);
         showControl(m_chkUseScalableDistance, true);
         showControl(m_sliderDelayDistance, false);
         showControl(m_chkFinishStabilizedCurve, false);
         showControl(m_chkStabilizeSensors, false);
         break;
     case 3:
     default:
         smoothingOptions()->setSmoothingType(KisSmoothingOptions::STABILIZER);
         showControl(m_sliderSmoothnessDistance, true);
         showControl(m_sliderTailAggressiveness, false);
         showControl(m_chkSmoothPressure, false);
         showControl(m_chkUseScalableDistance, true);
         showControl(m_sliderDelayDistance, true);
         showControl(m_chkFinishStabilizedCurve, true);
         showControl(m_chkStabilizeSensors, true);
     }
 
     emit smoothingTypeChanged();
 }
 
 void KisToolBrush::slotSetSmoothnessDistance(qreal distance)
 {
     smoothingOptions()->setSmoothnessDistance(distance);
     emit smoothnessQualityChanged();
 }
 
 void KisToolBrush::slotSetTailAgressiveness(qreal argh_rhhrr)
 {
     smoothingOptions()->setTailAggressiveness(argh_rhhrr);
     emit smoothnessFactorChanged();
 }
 
 // used with weighted smoothing
 void KisToolBrush::setSmoothPressure(bool value)
 {
     smoothingOptions()->setSmoothPressure(value);
 }
 
 void KisToolBrush::slotSetMagnetism(int magnetism)
 {
     m_magnetism = expf(magnetism / (double)MAXIMUM_MAGNETISM) / expf(1.0);
 }
 
 bool KisToolBrush::useScalableDistance() const
 {
     return smoothingOptions()->useScalableDistance();
 }
 
 // used with weighted smoothing
 void KisToolBrush::setUseScalableDistance(bool value)
 {
     smoothingOptions()->setUseScalableDistance(value);
 
     emit useScalableDistanceChanged();
 }
 
 void KisToolBrush::resetCursorStyle()
 {
     KisConfig cfg(true);
     CursorStyle cursorStyle = cfg.newCursorStyle();
 
     // When the stabilizer is in use, we avoid using the brush outline cursor,
     // because it would hide the real position of the cursor to the user,
     // yielding unexpected results.
     if (smoothingOptions()->smoothingType() == KisSmoothingOptions::STABILIZER &&
         smoothingOptions()->useDelayDistance() &&
         cursorStyle == CURSOR_STYLE_NO_CURSOR) {
 
         useCursor(KisCursor::roundCursor());
     } else {
         KisToolFreehand::resetCursorStyle();
     }
 
     overrideCursorIfNotEditable();
 }
 
 // stabilizer brush settings
 bool KisToolBrush::useDelayDistance() const
 {
     return smoothingOptions()->useDelayDistance();
 }
 
 qreal KisToolBrush::delayDistance() const
 {
     return smoothingOptions()->delayDistance();
 }
 
 void KisToolBrush::setUseDelayDistance(bool value)
 {
     smoothingOptions()->setUseDelayDistance(value);
     m_sliderDelayDistance->setEnabled(value);
     enableControl(m_chkFinishStabilizedCurve, !value);
 
     emit useDelayDistanceChanged();
 }
 
 void KisToolBrush::setDelayDistance(qreal value)
 {
     smoothingOptions()->setDelayDistance(value);
     emit delayDistanceChanged();
 }
 
 void KisToolBrush::setFinishStabilizedCurve(bool value)
 {
     smoothingOptions()->setFinishStabilizedCurve(value);
 
     emit finishStabilizedCurveChanged();
 }
 
 bool KisToolBrush::finishStabilizedCurve() const
 {
     return smoothingOptions()->finishStabilizedCurve();
 }
 
 void KisToolBrush::setStabilizeSensors(bool value)
 {
     smoothingOptions()->setStabilizeSensors(value);
     emit stabilizeSensorsChanged();
 }
 
 bool KisToolBrush::stabilizeSensors() const
 {
     return smoothingOptions()->stabilizeSensors();
 }
 
 void KisToolBrush::updateSettingsViews()
 {
     m_cmbSmoothingType->setCurrentIndex(smoothingOptions()->smoothingType());
 
     m_sliderSmoothnessDistance->setValue(smoothingOptions()->smoothnessDistance());
     m_chkDelayDistance->setChecked(smoothingOptions()->useDelayDistance());
     m_sliderDelayDistance->setValue(smoothingOptions()->delayDistance());
     m_sliderTailAggressiveness->setValue(smoothingOptions()->tailAggressiveness());
     m_chkSmoothPressure->setChecked(smoothingOptions()->smoothPressure());
     m_chkUseScalableDistance->setChecked(smoothingOptions()->useScalableDistance());
     m_cmbSmoothingType->setCurrentIndex((int)smoothingOptions()->smoothingType());
     m_chkStabilizeSensors->setChecked(smoothingOptions()->stabilizeSensors());
 
     emit smoothnessQualityChanged();
     emit smoothnessFactorChanged();
     emit smoothPressureChanged();
     emit smoothingTypeChanged();
     emit useScalableDistanceChanged();
     emit useDelayDistanceChanged();
     emit delayDistanceChanged();
     emit finishStabilizedCurveChanged();
     emit stabilizeSensorsChanged();
 
     KisTool::updateSettingsViews();
 }
 
 QWidget * KisToolBrush::createOptionWidget()
 {
     QWidget *optionsWidget = KisToolFreehand::createOptionWidget();
     optionsWidget->setObjectName(toolId() + "option widget");
 
     // See https://bugs.kde.org/show_bug.cgi?id=316896
     QWidget *specialSpacer = new QWidget(optionsWidget);
     specialSpacer->setObjectName("SpecialSpacer");
     specialSpacer->setFixedSize(0, 0);
     optionsWidget->layout()->addWidget(specialSpacer);
 
     // Line smoothing configuration
     m_cmbSmoothingType = new QComboBox(optionsWidget);
     m_cmbSmoothingType->addItems(QStringList()
             << i18n("None")
             << i18n("Basic")
             << i18n("Weighted")
             << i18n("Stabilizer"));
     connect(m_cmbSmoothingType, SIGNAL(currentIndexChanged(int)), this, SLOT(slotSetSmoothingType(int)));
     addOptionWidgetOption(m_cmbSmoothingType, new QLabel(i18n("Brush Smoothing:")));
 
     m_sliderSmoothnessDistance = new KisDoubleSliderSpinBox(optionsWidget);
     m_sliderSmoothnessDistance->setRange(3.0, MAXIMUM_SMOOTHNESS_DISTANCE, 1);
+    m_sliderSmoothnessDistance->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)));
 
     QAction *toggleaction =  KisActionRegistry::instance()->makeQAction("toggle_assistant", this);
     addAction("toggle_assistant", toggleaction);
     toggleaction->setShortcut(QKeySequence(Qt::ControlModifier + Qt::ShiftModifier + Qt::Key_L));
     connect(toggleaction, SIGNAL(triggered(bool)), m_chkAssistant, SLOT(toggle()));
 
     QLabel* magnetismLabel = new QLabel(i18n("Magnetism:"));
     addOptionWidgetOption(m_sliderMagnetism, magnetismLabel);
 
     QLabel* snapSingleLabel = new QLabel(i18n("Snap Single:"));
 
     m_chkOnlyOneAssistant = new QCheckBox(optionsWidget);
     m_chkOnlyOneAssistant->setToolTip(i18nc("@info:tooltip","Make it only snap to a single assistant, prevents snapping mess while using the infinite assistants."));
     m_chkOnlyOneAssistant->setCheckState(Qt::Checked);//turn on by default.
     connect(m_chkOnlyOneAssistant, SIGNAL(toggled(bool)), this, SLOT(setOnlyOneAssistantSnap(bool)));
     addOptionWidgetOption(m_chkOnlyOneAssistant, snapSingleLabel);
 
 
     // set the assistant snapping options to hidden by default and toggle their visibility based based off snapping checkbox
     m_sliderMagnetism->setVisible(false);
     m_chkOnlyOneAssistant->setVisible(false);
     snapSingleLabel->setVisible(false);
     magnetismLabel->setVisible(false);
 
    connect(m_chkAssistant, SIGNAL(toggled(bool)), m_sliderMagnetism, SLOT(setVisible(bool)));
    connect(m_chkAssistant, SIGNAL(toggled(bool)), m_chkOnlyOneAssistant, SLOT(setVisible(bool)));
    connect(m_chkAssistant, SIGNAL(toggled(bool)), snapSingleLabel, SLOT(setVisible(bool)));
     connect(m_chkAssistant, SIGNAL(toggled(bool)), magnetismLabel, SLOT(setVisible(bool)));
 
 
     KisConfig cfg(true);
     slotSetSmoothingType(cfg.lineSmoothingType());
 
     return optionsWidget;
 }
 
 
diff --git a/plugins/tools/basictools/tests/CMakeLists.txt b/plugins/tools/basictools/tests/CMakeLists.txt
index 4cf3933e76..f859770067 100644
--- a/plugins/tools/basictools/tests/CMakeLists.txt
+++ b/plugins/tools/basictools/tests/CMakeLists.txt
@@ -1,20 +1,22 @@
 set( EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR} )
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..
                     ${CMAKE_SOURCE_DIR}/sdk/tests
                     ${CMAKE_BINARY_DIR}/plugins/tools/basictools)
 
 
 
 macro_add_unittest_definitions()
 
 ########### next target ###############
 
 krita_add_broken_unit_test(move_stroke_test.cpp ${CMAKE_SOURCE_DIR}/sdk/tests/stroke_testing_utils.cpp ../strokes/move_stroke_strategy.cpp
-    TEST_NAME krita-basictools-MoveStrokeTest
-    LINK_LIBRARIES kritabasicflakes kritaui Qt5::Test)
+    TEST_NAME MoveStrokeTest
+    LINK_LIBRARIES kritabasicflakes kritaui Qt5::Test
+    NAME_PREFIX "plugins-tools-basictools-")
 
 ########### next target ###############
 
 ecm_add_test(move_selection_stroke_test.cpp ${CMAKE_SOURCE_DIR}/sdk/tests/stroke_testing_utils.cpp ../strokes/move_selection_stroke_strategy.cpp
-    TEST_NAME krita-basictools-MoveSelectionStrokeTest
-    LINK_LIBRARIES kritabasicflakes kritaui Qt5::Test)
+    TEST_NAME MoveSelectionStrokeTest
+    LINK_LIBRARIES kritabasicflakes kritaui Qt5::Test
+    NAME_PREFIX "plugins-tools-basictools-")
diff --git a/plugins/tools/tool_transform2/kis_transform_args_keyframe_channel.cpp b/plugins/tools/tool_transform2/kis_transform_args_keyframe_channel.cpp
index 35e7dd3921..d4e2301126 100644
--- a/plugins/tools/tool_transform2/kis_transform_args_keyframe_channel.cpp
+++ b/plugins/tools/tool_transform2/kis_transform_args_keyframe_channel.cpp
@@ -1,122 +1,124 @@
 /*
  *  Copyright (c) 2016 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_transform_args_keyframe_channel.h"
 
 struct KisTransformArgsKeyframe : public KisKeyframe
 {
     KisTransformArgsKeyframe(KisTransformArgsKeyframeChannel *channel, int time)
         : KisKeyframe(channel, time)
     {}
 
     KisTransformArgsKeyframe(KisTransformArgsKeyframeChannel *channel, int time, const ToolTransformArgs &args)
         : KisKeyframe(channel, time)
         , args(args)
     {}
 
     KisTransformArgsKeyframe(const KisTransformArgsKeyframe *rhs, KisKeyframeChannel *channel)
         : KisKeyframe(rhs, channel)
         , args(rhs->args)
     {}
 
     ToolTransformArgs args;
 
     KisKeyframeSP cloneFor(KisKeyframeChannel *channel) const override
     {
         KisTransformArgsKeyframeChannel *argsChannel = dynamic_cast<KisTransformArgsKeyframeChannel*>(channel);
         Q_ASSERT(argsChannel);
         return toQShared(new KisTransformArgsKeyframe(this, channel));
     }
 };
 
 KisTransformArgsKeyframeChannel::AddKeyframeCommand::AddKeyframeCommand(KisTransformArgsKeyframeChannel *channel, int time, const ToolTransformArgs &args, KUndo2Command *parentCommand)
     : KisReplaceKeyframeCommand(channel, time, toQShared(new KisTransformArgsKeyframe(channel, time, args)), parentCommand)
 {
 }
 
 KisTransformArgsKeyframeChannel::KisTransformArgsKeyframeChannel(const KoID &id, KisDefaultBoundsBaseSP defaultBounds, const ToolTransformArgs &initialValue)
     : KisKeyframeChannel(id, defaultBounds)
 {
     KisKeyframeSP keyframe = addKeyframe(0);
     KisTransformArgsKeyframe *argsKeyframe = dynamic_cast<KisTransformArgsKeyframe*>(keyframe.data());
     argsKeyframe->args = initialValue;
 }
 
 ToolTransformArgs &KisTransformArgsKeyframeChannel::transformArgs(KisKeyframeSP keyframe) const
 {
     KisTransformArgsKeyframe *key = dynamic_cast<KisTransformArgsKeyframe*>(keyframe.data());
     Q_ASSERT(key != 0);
     return key->args;
 }
 
 bool KisTransformArgsKeyframeChannel::hasScalarValue() const
 {
     return false;
 }
 
 KisKeyframeSP KisTransformArgsKeyframeChannel::createKeyframe(int time, const KisKeyframeSP copySrc, KUndo2Command *parentCommand)
 {
     Q_UNUSED(parentCommand);
     KisTransformArgsKeyframe *srcKey = dynamic_cast<KisTransformArgsKeyframe*>(copySrc.data());
     KisTransformArgsKeyframe *newKey;
 
     if (srcKey) {
         newKey = new KisTransformArgsKeyframe(this, time, srcKey->args);
     } else {
         newKey = new KisTransformArgsKeyframe(this, time);
     }
 
     return toQShared(newKey);
 }
 
 void KisTransformArgsKeyframeChannel::destroyKeyframe(KisKeyframeSP, KUndo2Command*)
 {}
 
 void KisTransformArgsKeyframeChannel::uploadExternalKeyframe(KisKeyframeChannel *srcChannel, int srcTime, KisKeyframeSP dstFrame)
 {
     Q_UNUSED(srcChannel);
     Q_UNUSED(srcTime);
     Q_UNUSED(dstFrame);
 }
 
 QRect KisTransformArgsKeyframeChannel::affectedRect(KisKeyframeSP key)
 {
     Q_UNUSED(key);
     // TODO
     return QRect();
 }
 
 KisKeyframeSP KisTransformArgsKeyframeChannel::loadKeyframe(const QDomElement &keyframeNode)
 {
     ToolTransformArgs args;
     args.fromXML(keyframeNode);
 
-    int time = keyframeNode.attribute("time").toUInt();
+    int time = keyframeNode.attribute("time").toInt();
+    workaroundBrokenFrameTimeBug(&time);
+
     KisTransformArgsKeyframe *keyframe = new KisTransformArgsKeyframe(this, time, args);
 
     return toQShared(keyframe);
 }
 
 void KisTransformArgsKeyframeChannel::saveKeyframe(KisKeyframeSP keyframe, QDomElement keyframeElement, const QString &layerFilename)
 {
     Q_UNUSED(layerFilename);
     KisTransformArgsKeyframe *key = dynamic_cast<KisTransformArgsKeyframe*>(keyframe.data());
     KIS_ASSERT_RECOVER_RETURN(key);
 
     key->args.toXML(&keyframeElement);
 }
diff --git a/plugins/tools/tool_transform2/tests/CMakeLists.txt b/plugins/tools/tool_transform2/tests/CMakeLists.txt
index 4403f18df4..57baa7e8e6 100644
--- a/plugins/tools/tool_transform2/tests/CMakeLists.txt
+++ b/plugins/tools/tool_transform2/tests/CMakeLists.txt
@@ -1,18 +1,18 @@
 set( EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR} )
 include_directories(
     ${CMAKE_CURRENT_SOURCE_DIR}/..
     ${CMAKE_CURRENT_BINARY_DIR}/..
     ${CMAKE_SOURCE_DIR}/sdk/tests
 )
 
 macro_add_unittest_definitions()
 
 ########### next target ###############
 
 ecm_add_test(test_save_load_transform_args.cpp
-    TEST_NAME krita-plugin-tooltransform-TestSaveLoadTransformArgs
+    NAME_PREFIX plugins-tooltransform-
     LINK_LIBRARIES kritatooltransform kritaui kritaimage Qt5::Test)
 
 ecm_add_test(test_animated_transform_parameters.cpp
-    TEST_NAME krita-plugin-tooltransform-TestAnimatedTransformParameters
+    NAME_PREFIX plugins-tooltransform-
     LINK_LIBRARIES kritatooltransform kritaui kritaimage Qt5::Test)
diff --git a/sdk/tests/kistest.h b/sdk/tests/kistest.h
index ef912e92d5..cd2f1fee9b 100644
--- a/sdk/tests/kistest.h
+++ b/sdk/tests/kistest.h
@@ -1,70 +1,75 @@
 /*
  *  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
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KISTEST
 #define KISTEST
 
 #include <KoConfig.h>
 #include <QApplication>
 #include <QTest>
 #include <QtTest/qtestsystem.h>
 #include <set>
 
 #ifndef QT_NO_OPENGL
 #  define QTEST_ADD_GPU_BLACKLIST_SUPPORT_DEFS \
     extern Q_TESTLIB_EXPORT std::set<QByteArray> *(*qgpu_features_ptr)(const QString &); \
     extern Q_GUI_EXPORT std::set<QByteArray> *qgpu_features(const QString &);
 #  define QTEST_ADD_GPU_BLACKLIST_SUPPORT \
     qgpu_features_ptr = qgpu_features;
 #else
 #  define QTEST_ADD_GPU_BLACKLIST_SUPPORT_DEFS
 #  define QTEST_ADD_GPU_BLACKLIST_SUPPORT
 #endif
 
 #if defined(QT_NETWORK_LIB)
 #  include <QtTest/qtest_network.h>
 #endif
 #include <QtTest/qtest_widgets.h>
 
 #ifdef QT_KEYPAD_NAVIGATION
 #  define QTEST_DISABLE_KEYPAD_NAVIGATION QApplication::setNavigationMode(Qt::NavigationModeNone);
 #else
 #  define QTEST_DISABLE_KEYPAD_NAVIGATION
 #endif
 
 #define KISTEST_MAIN(TestObject) \
-QT_BEGIN_NAMESPACE \
-QTEST_ADD_GPU_BLACKLIST_SUPPORT_DEFS \
-QT_END_NAMESPACE \
 int main(int argc, char *argv[]) \
 { \
+\
+    if (qEnvironmentVariableIsSet("QT_LOGGING_RULES")) { \
+        qWarning() << "Disable extra debugging output!!!"; \
+        qputenv("QT_LOGGING_RULES", \
+                qgetenv("QT_LOGGING_RULES") + \
+                QByteArrayLiteral(";krita.lib.plugin.debug=false;krita.lib.resources.debug=false;krita.lib.pigment.debug=false")); \
+    } \
+    qputenv("QT_LOGGING_RULES", ""); \
+\
     qputenv("EXTRA_RESOURCE_DIRS", QByteArray(KRITA_EXTRA_RESOURCE_DIRS)); \
     QApplication app(argc, argv); \
     app.setAttribute(Qt::AA_Use96Dpi, true); \
     QTEST_DISABLE_KEYPAD_NAVIGATION \
-    QTEST_ADD_GPU_BLACKLIST_SUPPORT \
     TestObject tc; \
     QTEST_SET_MAIN_SOURCE_PATH \
     return QTest::qExec(&tc, argc, argv); \
 }
 
 
 
 
 
 #endif