diff --git a/3rdparty/ext_openjpeg/CMakeLists.txt b/3rdparty/ext_openjpeg/CMakeLists.txt
index 3e34540089..f755c49e6c 100755
--- a/3rdparty/ext_openjpeg/CMakeLists.txt
+++ b/3rdparty/ext_openjpeg/CMakeLists.txt
@@ -1,14 +1,14 @@
 SET(PREFIX_ext_openjpeg "${EXTPREFIX}" )
 ExternalProject_Add( ext_openjpeg
 	DOWNLOAD_DIR ${EXTERNALS_DOWNLOAD_DIR}
-	URL http://files.kde.org/krita/build/dependencies/openjpeg-version.2.1.tar.gz
-	URL_MD5 3e1c451c087f8462955426da38aa3b3d
+	URL https://files.kde.org/krita/build/dependencies/openjpeg-version.2.3.1.tar.gz
+	URL_MD5 3b9941dc7a52f0376694adb15a72903f
 	
     INSTALL_DIR ${PREFIX_ext_openjpeg}
-	CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${PREFIX_ext_openjpeg} -DCMAKE_BUILD_TYPE=${GLOBAL_BUILD_TYPE} ${GLOBAL_PROFILE}
+	CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${PREFIX_ext_openjpeg} -DOPENJPEG_INSTALL_INCLUDE_DIR=include/ -DCMAKE_BUILD_TYPE=${GLOBAL_BUILD_TYPE} ${GLOBAL_PROFILE}
 	
     UPDATE_COMMAND ""
 	ALWAYS 0
     DEPENDS ext_png ext_tiff ext_lcms2 ext_zlib
 )
 
diff --git a/3rdparty/ext_sip/CMakeLists.txt b/3rdparty/ext_sip/CMakeLists.txt
index a7ae294c60..8dcb9f2459 100644
--- a/3rdparty/ext_sip/CMakeLists.txt
+++ b/3rdparty/ext_sip/CMakeLists.txt
@@ -1,84 +1,84 @@
 SET(PREFIX_ext_sip "${EXTPREFIX}" )
 if (UNIX)
     if(NOT APPLE)
       SET(PYTHON_EXECUTABLE_PATH ${PREFIX_ext_sip}/bin/python3)
       if(NOT EXISTS ${PYTHON_EXECUTABLE_PATH})
         message("WARNING: using system python3!")
         SET(PYTHON_EXECUTABLE_PATH python3)
       endif()
 
         ExternalProject_Add( ext_sip
         DOWNLOAD_DIR ${EXTERNALS_DOWNLOAD_DIR}
         URL https://files.kde.org/krita/build/dependencies/sip-4.19.19.tar.gz
         URL_MD5 98111479309dc472410f26080d6d4a88
 
         CONFIGURE_COMMAND ${PYTHON_EXECUTABLE_PATH} <SOURCE_DIR>/configure.py -b ${PREFIX_ext_sip}/bin -d ${PREFIX_ext_sip}/lib/python3.8/site-packages -e ${PREFIX_ext_sip}/include  --sipdir ${PREFIX_ext_sip}/sip --target-py-version 3.8 --sip-module PyQt5.sip
         BUILD_COMMAND make
 
         # force single-threaded installation to avoid
         # race conditions in post-install .py script
         INSTALL_COMMAND make -j1 install
 
             BUILD_IN_SOURCE 1
 
             UPDATE_COMMAND ""
         )
     else(APPLE)
         if(NOT PYTHONINTERP_FOUND)
             SET(PYTHON_EXECUTABLE ${PREFIX_ext_sip}/bin/python3)
             if(NOT EXISTS "${PYTHON_EXECUTABLE}")
                 message("WARNING: using system python3!")
                 SET(PYTHON_EXECUTABLE python3)
             endif()
         endif()
 
         ExternalProject_Add( ext_sip
             DOWNLOAD_DIR ${EXTERNALS_DOWNLOAD_DIR}
             URL https://files.kde.org/krita/build/dependencies/sip-4.19.19.tar.gz
             URL_MD5 98111479309dc472410f26080d6d4a88
 
             CMAKE_ARGS -DPYTHON_INCLUDE_DIR=${PREFIX_ext_sip}/lib/Python.framework/Headers
             CONFIGURE_COMMAND ${PYTHON_EXECUTABLE} <SOURCE_DIR>/configure.py --deployment-target=10.11
                 -b ${PREFIX_ext_sip}/bin -d ${PREFIX_ext_sip}/lib/Python.framework/Versions/Current/site-packages/ 
                 -e ${PREFIX_ext_sip}/include --sipdir ${PREFIX_ext_sip}/share/sip --target-py-version 3.8 --sip-module PyQt5.sip
             BUILD_COMMAND make
 
             # force single-threaded installation to avoid
             # race conditions in post-install .py script
             INSTALL_COMMAND make -j1 install
                 # COMMAND ${CMAKE_COMMAND} -E create_symlink ./PyQt5/sip.so ${PREFIX_ext_sip}/lib/Python.framework/Versions/Current/site-packages/sip.so
                 # COMMAND ${CMAKE_COMMAND} -E create_symlink ./PyQt5/sip.pyi ${PREFIX_ext_sip}/lib/Python.framework/Versions/Current/site-packages/sip.pyi
 
             BUILD_IN_SOURCE 1
 
             UPDATE_COMMAND ""
         )
     endif()
 elseif (MINGW)
     list(APPEND _SIP_conf
         --platform win32-g++
         -b ${PREFIX_ext_sip}/bin
         -d ${PREFIX_ext_sip}/lib/krita-python-libs
         -e ${PREFIX_ext_sip}/include
         --sipdir ${PREFIX_ext_sip}/share/sip
         --target-py-version 3.8
         --sip-module PyQt5.sip
     )
     ExternalProject_Add( ext_sip
         DOWNLOAD_DIR ${EXTERNALS_DOWNLOAD_DIR}
-        URL https://files.kde.org/krita/build/dependencies/sip-4.19.15.zip
-        URL_MD5 4a1a4760cfabef15d68f45a6920974c2
+        URL https://files.kde.org/krita/build/dependencies/sip-4.19.19.tar.gz
+        URL_MD5 98111479309dc472410f26080d6d4a88
 
         CONFIGURE_COMMAND ${PYTHON_EXECUTABLE} <SOURCE_DIR>/configure.py ${_SIP_conf}
         BUILD_COMMAND mingw32-make -j${SUBMAKE_JOBS} LDFLAGS=${SECURITY_SHARED_LINKER_FLAGS}
 
         # force single-threaded installation to avoid
         # race conditions in post-install .py script
         INSTALL_COMMAND mingw32-make -j1 install
         
         BUILD_IN_SOURCE 1
 
         UPDATE_COMMAND ""
     )
 endif()
 
diff --git a/build-tools/windows/build.cmd b/build-tools/windows/build.cmd
index 392167d759..eaf74bba25 100644
--- a/build-tools/windows/build.cmd
+++ b/build-tools/windows/build.cmd
@@ -1,819 +1,819 @@
 @echo off
 
 setlocal enabledelayedexpansion
 goto begin
 
 
 :: Subroutines
 
 :find_on_path out_variable file_name
 set %1=%~f$PATH:2
 goto :EOF
 
 
 :get_dir_path out_variable file_path
 set %1=%~dp2
 goto :EOF
 
 
 :get_full_path out_variable file_path
 setlocal
 set FULL_PATH=%~f2
 if not exist "%FULL_PATH%" (
     set FULL_PATH=
 ) else (
     if exist "%FULL_PATH%\" (
         set FULL_PATH=
     )
 )
 endlocal & set "%1=%FULL_PATH%"
 goto :EOF
 
 
 :get_full_path_dir out_variable file_path
 setlocal
 set FULL_PATH=%~dp2
 if not exist "%FULL_PATH%" (
     set FULL_PATH=
 )
 endlocal & set "%1=%FULL_PATH%"
 goto :EOF
 
 
 :prompt_for_string out_variable prompt
 set /p %1=%~2^>
 goto :EOF
 
 
 :prompt_for_positive_integer out_variable prompt
 setlocal
 call :prompt_for_string USER_INPUT "%~2"
 if "%USER_INPUT%" == "" set USER_INPUT=0
 set /a RESULT=%USER_INPUT%
 if not %RESULT% GTR 0 (
     set RESULT=
 )
 endlocal & set "%1=%RESULT%"
 goto :EOF
 
 
 :prompt_for_file out_variable prompt
 setlocal
 :prompt_for_file__retry
 call :prompt_for_string USER_INPUT "%~2"
 if "%USER_INPUT%" == "" (
     endlocal
     set %1=
     goto :EOF
 )
 call :get_full_path RESULT "%USER_INPUT%"
 if "%RESULT%" == "" (
     echo Input does not point to valid file!
     set USER_INPUT=
     goto prompt_for_file__retry
 )
 endlocal & set "%1=%RESULT%"
 goto :EOF
 
 
 :prompt_for_dir out_variable prompt
 setlocal
 :prompt_for_dir__retry
 call :prompt_for_string USER_INPUT "%~2"
 if "%USER_INPUT%" == "" (
     endlocal
     set %1=
     goto :EOF
 )
 call :get_full_path_dir RESULT "%USER_INPUT%\"
 if "%RESULT%" == "" (
     echo Input does not point to valid dir!
     set USER_INPUT=
     goto prompt_for_dir__retry
 )
 endlocal & set "%1=%RESULT%"
 goto :EOF
 
 
 :usage
 echo Usage:
 echo %~n0 [--no-interactive] [ OPTIONS ... ]
 echo.
 echo Basic options:
 echo --no-interactive                Run without interactive prompts
 echo                                 When not specified, the script will prompt
 echo                                 for some of the parameters.
 echo --jobs ^<count^>                  Set parallel jobs count when building
 echo                                 Defaults to no. of logical cores
 echo --skip-deps                     Skips (re)building of deps
 echo --skip-krita                    Skips (re)building of Krita
 echo --cmd                           Launch a cmd prompt instead of building.
 echo                                 The environment is set up like the build
 echo                                 environment with some helper command macros.
 echo.
 echo Path options:
 echo --src-dir ^<dir_path^>            Specify Krita source dir
 echo                                 If unspecified, this will be determined from
 echo                                 the script location.
 echo --download-dir ^<dir_path^>       Specify deps download dir
 echo                                 Can be omitted if --skip-deps is used
 echo --deps-build-dir ^<dir_path^>     Specify deps build dir
 echo                                 Can be omitted if --skip-deps is used
 echo --deps-install-dir ^<dir_path^>   Specify deps install dir
 echo --krita-build-dir ^<dir_path^>    Specify Krita build dir
 echo                                 Can be omitted if --skip-krita is used
 echo --krita-install-dir ^<dir_path^>  Specify Krita install dir
 echo                                 Can be omitted if --skip-krita is used
 echo.
 goto :EOF
 :usage_and_exit
 call :usage
 exit /b
 :usage_and_fail
 call :usage
 exit /b 100
 
 
 :: ----------------------------
 :begin
 
 echo Krita build script for Windows
 echo.
 
 
 :: command-line args parsing
 set ARG_NO_INTERACTIVE=
 set ARG_JOBS=
 set ARG_SKIP_DEPS=
 set ARG_SKIP_KRITA=
 set ARG_SRC_DIR=
 set ARG_DOWNLOAD_DIR=
 set ARG_DEPS_BUILD_DIR=
 set ARG_DEPS_INSTALL_DIR=
 set ARG_KRITA_BUILD_DIR=
 set ARG_KRITA_INSTALL_DIR=
 set ARG_CMD=
 :args_parsing_loop
 set CURRENT_MATCHED=
 if not "%1" == "" (
     if "%1" == "--no-interactive" (
         set ARG_NO_INTERACTIVE=1
         set CURRENT_MATCHED=1
     )
     if "%1" == "--jobs" (
         if not "%ARG_JOBS%" == "" (
             echo ERROR: Arg --jobs specified more than once 1>&2
             echo.
             goto usage_and_fail
         )
         set /a "ARG_JOBS=%2"
         if not !ARG_JOBS! GTR 0 (
             echo ERROR: Arg --jobs is not a positive integer 1>&2
             echo.
             goto usage_and_fail
         )
         shift /2
         set CURRENT_MATCHED=1
     )
     if "%1" == "--skip-deps" (
         set ARG_SKIP_DEPS=1
         set CURRENT_MATCHED=1
     )
     if "%1" == "--skip-krita" (
         set ARG_SKIP_KRITA=1
         set CURRENT_MATCHED=1
     )
     if "%1" == "--src-dir" (
         if not "%ARG_SRC_DIR%" == "" (
             echo ERROR: Arg --src-dir specified more than once 1>&2
             echo.
             goto usage_and_fail
         )
         if not exist "%~f2\" (
             echo ERROR: Arg --src-dir does not point to a directory 1>&2
             echo.
             goto usage_and_fail
         )
         call :get_dir_path ARG_SRC_DIR "%~f2\"
         shift /2
         set CURRENT_MATCHED=1
     )
     if "%1" == "--download-dir" (
         if not "%ARG_DOWNLOAD_DIR%" == "" (
             echo ERROR: Arg --download-dir specified more than once 1>&2
             echo.
             goto usage_and_fail
         )
         if "%~f2" == "" (
             echo ERROR: Arg --download-dir does not point to a valid path 1>&2
             echo.
             goto usage_and_fail
         )
         call :get_dir_path ARG_DOWNLOAD_DIR "%~f2\"
         shift /2
         set CURRENT_MATCHED=1
     )
     if "%1" == "--deps-build-dir" (
         if not "%ARG_DEPS_BUILD_DIR%" == "" (
             echo ERROR: Arg --deps-build-dir specified more than once 1>&2
             echo.
             goto usage_and_fail
         )
         if "%~f2" == "" (
             echo ERROR: Arg --deps-build-dir does not point to a valid path 1>&2
             echo.
             goto usage_and_fail
         )
         call :get_dir_path ARG_DEPS_BUILD_DIR "%~f2\"
         shift /2
         set CURRENT_MATCHED=1
     )
     if "%1" == "--deps-install-dir" (
         if not "%ARG_DEPS_INSTALL_DIR%" == "" (
             echo ERROR: Arg --deps-install-dir specified more than once 1>&2
             echo.
             goto usage_and_fail
         )
         if "%~f2" == "" (
             echo ERROR: Arg --deps-install-dir does not point to a valid path 1>&2
             echo.
             goto usage_and_fail
         )
         call :get_dir_path ARG_DEPS_INSTALL_DIR "%~f2\"
         shift /2
         set CURRENT_MATCHED=1
     )
     if "%1" == "--krita-build-dir" (
         if not "%ARG_KRITA_BUILD_DIR%" == "" (
             echo ERROR: Arg --krita-build-dir specified more than once 1>&2
             echo.
             goto usage_and_fail
         )
         if "%~f2" == "" (
             echo ERROR: Arg --krita-build-dir does not point to a valid path 1>&2
             echo.
             goto usage_and_fail
         )
         call :get_dir_path ARG_KRITA_BUILD_DIR "%~f2\"
         shift /2
         set CURRENT_MATCHED=1
     )
     if "%1" == "--krita-install-dir" (
         if not "%ARG_KRITA_INSTALL_DIR%" == "" (
             echo ERROR: Arg --krita-install-dir specified more than once 1>&2
             echo.
             goto usage_and_fail
         )
         if "%~f2" == "" (
             echo ERROR: Arg --krita-install-dir does not point to a valid path 1>&2
             echo.
             goto usage_and_fail
         )
         call :get_dir_path ARG_KRITA_INSTALL_DIR "%~f2\"
         shift /2
         set CURRENT_MATCHED=1
     )
     if "%1" == "--cmd" (
         set ARG_CMD=1
         set CURRENT_MATCHED=1
     )
     if "%1" == "--help" (
         goto usage_and_exit
     )
     if not "!CURRENT_MATCHED!" == "1" (
         echo ERROR: Unknown option %1 1>&2
         echo.
         goto usage_and_fail
     )
     shift /1
     goto args_parsing_loop
 )
 
 if "%ARG_NO_INTERACTIVE%" == "1" (
     echo Non-interactive mode
 ) else (
     echo Interactive mode
     :: Trick to pause on exit
     call :real_begin
     pause
     exit /b !ERRORLEVEL!
 )
 :real_begin
 echo.
 
 
 if "%ARG_SKIP_DEPS%" == "1" (
     if "%ARG_SKIP_KRITA%" == "1" (
         echo ERROR: You cannot skip both deps and Krita 1>&2
         echo.
         exit /b 102
     )
     echo Building of deps will be skipped.
 ) else (
     if "%ARG_SKIP_KRITA%" == "1" (
         echo Building of Krita will be skipped.
     ) else (
         echo Both deps and Krita will be built.
     )
 )
 
 
 :: Check environment config
 
 if "%CMAKE_EXE%" == "" (
     call :find_on_path CMAKE_EXE cmake.exe
     if "!CMAKE_EXE!" == "" (
         if not "%ARG_NO_INTERACTIVE%" == "1" (
             call :prompt_for_file CMAKE_EXE "Provide path to cmake.exe"
         )
         if "!CMAKE_EXE!" == "" (
             echo ERROR: CMake not found! 1>&2
             exit /b 102
         )
     ) else (
         echo Found CMake on PATH: !CMAKE_EXE!
         if not "%ARG_NO_INTERACTIVE%" == "1" (
             choice /c ny /n /m "Is this correct? [y/n] "
             if errorlevel 3 exit 255
             if not errorlevel 2 (
                 call :prompt_for_file CMAKE_EXE "Provide path to cmake.exe"
                 if "!CMAKE_EXE!" == "" (
                     echo ERROR: CMake not found! 1>&2
                     exit /b 102
                 )
             )
         )
     )
 )
 echo CMake: %CMAKE_EXE%
 
 if "%SEVENZIP_EXE%" == "" (
     call :find_on_path SEVENZIP_EXE 7z.exe
     if "!SEVENZIP_EXE!" == "" (
         set "SEVENZIP_EXE=%ProgramFiles%\7-Zip\7z.exe"
         if "!SEVENZIP_EXE!" == "" (
             set "SEVENZIP_EXE=%ProgramFiles(x86)%\7-Zip\7z.exe"
         )
         if "!SEVENZIP_EXE!" == "" (
             echo 7-Zip not found
         )
     )
 )
 if "%SEVENZIP_EXE%" == "" (
     echo 7-Zip: %SEVENZIP_EXE%
 )
 
 if "%MINGW_BIN_DIR%" == "" (
     call :find_on_path MINGW_BIN_DIR_MAKE_EXE mingw32-make.exe
     if "!MINGW_BIN_DIR_MAKE_EXE!" == "" (
         if not "%ARG_NO_INTERACTIVE%" == "1" (
             call :prompt_for_file MINGW_BIN_DIR_MAKE_EXE "Provide path to mingw32-make.exe of mingw-w64"
         )
         if "!MINGW_BIN_DIR_MAKE_EXE!" == "" (
             echo ERROR: mingw-w64 not found! 1>&2
             exit /b 102
         )
         call :get_dir_path MINGW_BIN_DIR "!MINGW_BIN_DIR_MAKE_EXE!"
     ) else (
         call :get_dir_path MINGW_BIN_DIR "!MINGW_BIN_DIR_MAKE_EXE!"
         echo Found mingw on PATH: !MINGW_BIN_DIR!
         if not "%ARG_NO_INTERACTIVE%" == "1" (
             choice /c ny /n /m "Is this correct? [y/n] "
             if errorlevel 3 exit 255
             if not errorlevel 2 (
                 call :prompt_for_file MINGW_BIN_DIR_MAKE_EXE "Provide path to mingw32-make.exe of mingw-w64"
                 if "!MINGW_BIN_DIR_MAKE_EXE!" == "" (
                     echo ERROR: mingw-w64 not found! 1>&2
                     exit /b 102
                 )
                 call :get_dir_path MINGW_BIN_DIR "!MINGW_BIN_DIR_MAKE_EXE!"
             )
         )
     )
 )
 echo mingw-w64: %MINGW_BIN_DIR%
 
 if "%PYTHON_BIN_DIR%" == "" (
     call :find_on_path PYTHON_BIN_DIR_PYTHON_EXE python.exe
     if "!PYTHON_BIN_DIR_PYTHON_EXE!" == "" (
         if not "%ARG_NO_INTERACTIVE%" == "1" (
             call :prompt_for_file PYTHON_BIN_DIR_PYTHON_EXE "Provide path to python.exe of Python 3.6.2"
         )
         if "!PYTHON_BIN_DIR_PYTHON_EXE!" == "" (
             echo ERROR: Python not found! 1>&2
             exit /b 102
         )
         call :get_dir_path PYTHON_BIN_DIR "!PYTHON_BIN_DIR_PYTHON_EXE!"
     ) else (
         call :get_dir_path PYTHON_BIN_DIR "!PYTHON_BIN_DIR_PYTHON_EXE!"
         echo Found Python on PATH: !PYTHON_BIN_DIR!
         if not "%ARG_NO_INTERACTIVE%" == "1" (
             choice /c ny /n /m "Is this correct? [y/n] "
             if errorlevel 3 exit 255
             if not errorlevel 2 (
                 call :prompt_for_file PYTHON_BIN_DIR_PYTHON_EXE "Provide path to python.exe of Python 3.6.2"
                 if "!PYTHON_BIN_DIR_PYTHON_EXE!" == "" (
                     echo ERROR: Python not found! 1>&2
                     exit /b 102
                 )
                 call :get_dir_path PYTHON_BIN_DIR "!PYTHON_BIN_DIR_PYTHON_EXE!"
             )
         )
     )
 )
 echo Python: %PYTHON_BIN_DIR%
 
 if "%ARG_SKIP_DEPS%" == "1" goto skip_windows_sdk_dir_check
 
 if "%WindowsSdkDir%" == "" if not "%ProgramFiles(x86)%" == "" set "WindowsSdkDir=%ProgramFiles(x86)%\Windows Kits\10"
 if "%WindowsSdkDir%" == "" set "WindowsSdkDir=%ProgramFiles(x86)%\Windows Kits\10"
 if exist "%WindowsSdkDir%\" (
     pushd "%WindowsSdkDir%"
     if exist "bin\x64\fxc.exe" (
         set HAVE_FXC_EXE=1
         if "%WindowsSdkVerBinPath%" == "" set "WindowsSdkVerBinPath=%WindowsSdkDir%"
     ) else (
         for /f "delims=" %%a in ('dir /a:d /b "bin\10.*"') do (
             if exist "bin\%%a\x64\fxc.exe" (
                 set HAVE_FXC_EXE=1
                 if "%WindowsSdkVerBinPath%" == "" set "WindowsSdkVerBinPath=%WindowsSdkDir%\bin\%%a\"
             )
         )
     )
     popd
 )
 set QT_ENABLE_DYNAMIC_OPENGL=ON
 if not "%HAVE_FXC_EXE%" == "1" (
     set WindowsSdkDir=
     echo Windows SDK 10 with fxc.exe not found
     echo Qt will *not* be built with ANGLE ^(dynamic OpenGL^) support.
     if not "%ARG_NO_INTERACTIVE%" == "1" (
         choice /c ny /n /m "Is this ok? [y/n] "
         if errorlevel 3 exit 255
         if not errorlevel 2 (
             exit /b 102
         )
     )
     set QT_ENABLE_DYNAMIC_OPENGL=OFF
 ) else echo Windows SDK 10 with fxc.exe found on %WindowsSdkDir%
 
 :skip_windows_sdk_dir_check
 
 if not "%ARG_JOBS%" == "" (
     set "PARALLEL_JOBS=%ARG_JOBS%"
 )
 if "%PARALLEL_JOBS%" == "" (
     echo Number of logical CPU cores detected: %NUMBER_OF_PROCESSORS%
     echo Enabling %NUMBER_OF_PROCESSORS% parallel jobs
     set PARALLEL_JOBS=%NUMBER_OF_PROCESSORS%
     if not "%ARG_NO_INTERACTIVE%" == "1" (
         choice /c ny /n /m "Is this correct? [y/n] "
         if errorlevel 3 exit 255
         if not errorlevel 2 (
             call :prompt_for_positive_integer PARALLEL_JOBS "Provide no. of parallel jobs"
             if "!PARALLEL_JOBS!" == "" (
                 echo ERROR: Invalid job count! 1>&2
                 exit /b 102
             )
         )
     )
 )
 echo Parallel jobs count: %PARALLEL_JOBS%
 
 if not "%ARG_SRC_DIR%" == "" (
     set "KRITA_SRC_DIR=%ARG_SRC_DIR%"
 )
 if "%KRITA_SRC_DIR%" == "" (
     :: Check whether this looks like to be in the source tree
 	set "_temp=%~dp0"
 	if "!_temp:~-21!" == "\build-tools\windows\" (
         if exist "!_temp:~0,-21!\CMakeLists.txt" (
             if exist "!_temp:~0,-21!\3rdparty\CMakeLists.txt" (
                 set "KRITA_SRC_DIR=!_temp:~0,-21!\"
                 echo Script is running inside Krita src dir
             )
         )
     )
 )
 if "%KRITA_SRC_DIR%" == "" (
     if not "%ARG_NO_INTERACTIVE%" == "1" (
         call :prompt_for_dir KRITA_SRC_DIR "Provide path of Krita src dir"
     )
     if "!KRITA_SRC_DIR!" == "" (
         echo ERROR: Krita src dir not found! 1>&2
         exit /b 102
     )
 )
 echo Krita src: %KRITA_SRC_DIR%
 
 if "%ARG_SKIP_DEPS%" == "1" goto skip_deps_args_check
 
 if not "%ARG_DOWNLOAD_DIR%" == "" (
     set "DEPS_DOWNLOAD_DIR=%ARG_DOWNLOAD_DIR%"
 )
 if "%DEPS_DOWNLOAD_DIR%" == "" (
     set DEPS_DOWNLOAD_DIR=%CD%\d\
     echo Using default deps download dir: !DEPS_DOWNLOAD_DIR!
     if not "%ARG_NO_INTERACTIVE%" == "1" (
         choice /c ny /n /m "Is this ok? [y/n] "
         if errorlevel 3 exit 255
         if not errorlevel 2 (
             call :prompt_for_dir DEPS_DOWNLOAD_DIR "Provide path of depps download dir"
         )
     )
     if "!DEPS_DOWNLOAD_DIR!" == "" (
         echo ERROR: Deps download dir not set! 1>&2
         exit /b 102
     )
 )
 echo Deps download dir: %DEPS_DOWNLOAD_DIR%
 
 if not "%ARG_DEPS_BUILD_DIR%" == "" (
     set "DEPS_BUILD_DIR=%ARG_DEPS_BUILD_DIR%"
 )
 if "%DEPS_BUILD_DIR%" == "" (
     set DEPS_BUILD_DIR=%CD%\b_deps\
     echo Using default deps build dir: !DEPS_BUILD_DIR!
     if not "%ARG_NO_INTERACTIVE%" == "1" (
         choice /c ny /n /m "Is this ok? [y/n] "
         if errorlevel 3 exit 255
         if not errorlevel 2 (
             call :prompt_for_dir DEPS_BUILD_DIR "Provide path of deps build dir"
         )
     )
     if "!DEPS_BUILD_DIR!" == "" (
         echo ERROR: Deps build dir not set! 1>&2
         exit /b 102
     )
 )
 echo Deps build dir: %DEPS_BUILD_DIR%
 
 :skip_deps_args_check
 
 if not "%ARG_DEPS_INSTALL_DIR%" == "" (
     set "DEPS_INSTALL_DIR=%ARG_DEPS_INSTALL_DIR%"
 )
 if "%DEPS_INSTALL_DIR%" == "" (
     set DEPS_INSTALL_DIR=%CD%\i_deps\
     echo Using default deps install dir: !DEPS_INSTALL_DIR!
     if not "%ARG_NO_INTERACTIVE%" == "1" (
         choice /c ny /n /m "Is this ok? [y/n] "
         if errorlevel 3 exit 255
         if not errorlevel 2 (
             call :prompt_for_dir DEPS_INSTALL_DIR "Provide path of deps install dir"
         )
     )
     if "!DEPS_INSTALL_DIR!" == "" (
         echo ERROR: Deps install dir not set! 1>&2
         exit /b 102
     )
 )
 echo Deps install dir: %DEPS_INSTALL_DIR%
 
 if "%ARG_SKIP_KRITA%" == "1" goto skip_krita_args_check
 
 if not "%ARG_KRITA_BUILD_DIR%" == "" (
     set "KRITA_BUILD_DIR=%ARG_KRITA_BUILD_DIR%"
 )
 if "%KRITA_BUILD_DIR%" == "" (
     set KRITA_BUILD_DIR=%CD%\b\
     echo Using default Krita build dir: !KRITA_BUILD_DIR!
     if not "%ARG_NO_INTERACTIVE%" == "1" (
         choice /c ny /n /m "Is this ok? [y/n] "
         if errorlevel 3 exit 255
         if not errorlevel 2 (
             call :prompt_for_dir KRITA_BUILD_DIR "Provide path of Krita build dir"
         )
     )
     if "!KRITA_BUILD_DIR!" == "" (
         echo ERROR: Krita build dir not set! 1>&2
         exit /b 102
     )
 )
 echo Krita build dir: %KRITA_BUILD_DIR%
 
 if not "%ARG_KRITA_INSTALL_DIR%" == "" (
     set "KRITA_INSTALL_DIR=%ARG_KRITA_INSTALL_DIR%"
 )
 if "%KRITA_INSTALL_DIR%" == "" (
     set KRITA_INSTALL_DIR=%CD%\i\
     echo Using default Krita install dir: !KRITA_INSTALL_DIR!
     if not "%ARG_NO_INTERACTIVE%" == "1" (
         choice /c ny /n /m "Is this ok? [y/n] "
         if errorlevel 3 exit 255
         if not errorlevel 2 (
             call :prompt_for_dir KRITA_INSTALL_DIR "Provide path of Krita install dir"
         )
     )
     if "!KRITA_INSTALL_DIR!" == "" (
         echo ERROR: Krita install dir not set! 1>&2
         exit /b 102
     )
 )
 echo Krita install dir: %KRITA_INSTALL_DIR%
 
 :skip_krita_args_check
 
 echo.
 
 
 if not "%ARG_NO_INTERACTIVE%" == "1" (
     choice /c ny /n /m "Is the above ok? [y/n] "
     if errorlevel 3 exit 255
     if not errorlevel 2 (
         exit /b 1
     )
     echo.
 )
 
 :: Initialize clean PATH
 set PATH=%SystemRoot%\system32;%SystemRoot%;%SystemRoot%\System32\Wbem;%SYSTEMROOT%\System32\WindowsPowerShell\v1.0\
 set PATH=%MINGW_BIN_DIR%;%PYTHON_BIN_DIR%;%PATH%
 
 echo Creating dirs...
 if NOT "%ARG_SKIP_DEPS%" == "1" (
     mkdir %DEPS_DOWNLOAD_DIR%
     if errorlevel 1 (
         if not exist "%DEPS_DOWNLOAD_DIR%\" (
             echo ERROR: Cannot create deps download dir! 1>&2
             exit /b 103
         )
     )
     mkdir %DEPS_BUILD_DIR%
     if errorlevel 1 (
         if not exist "%DEPS_BUILD_DIR%\" (
             echo ERROR: Cannot create deps build dir! 1>&2
             exit /b 103
         )
     )
     mkdir %DEPS_INSTALL_DIR%
     if errorlevel 1 (
         if not exist "%DEPS_INSTALL_DIR%\" (
             echo ERROR: Cannot create deps install dir! 1>&2
             exit /b 103
         )
     )
 )
 if NOT "%ARG_SKIP_KRITA%" == "1" (
     mkdir %KRITA_BUILD_DIR%
     if errorlevel 1 (
         if not exist "%KRITA_BUILD_DIR%\" (
             echo ERROR: Cannot create Krita build dir! 1>&2
             exit /b 103
         )
     )
     mkdir %KRITA_INSTALL_DIR%
     if errorlevel 1 (
         if not exist "%KRITA_INSTALL_DIR%\" (
             echo ERROR: Cannot create Krita install dir! 1>&2
             exit /b 103
         )
     )
 )
 
 echo.
 
 
 set CMAKE_BUILD_TYPE=RelWithDebInfo
 set QT_ENABLE_DEBUG_INFO=OFF
 
 :: Paths for CMake
 set "BUILDDIR_DOWNLOAD_CMAKE=%DEPS_DOWNLOAD_DIR:\=/%"
 set "BUILDDIR_DOWNLOAD_CMAKE=%BUILDDIR_DOWNLOAD_CMAKE: =\ %"
 set "BUILDDIR_DEPS_INSTALL_CMAKE=%DEPS_INSTALL_DIR:\=/%"
 set "BUILDDIR_DEPS_INSTALL_CMAKE=%BUILDDIR_DEPS_INSTALL_CMAKE: =\ %"
 set "BUILDDIR_KRITA_INSTALL_CMAKE=%KRITA_INSTALL_DIR:\=/%"
 set "BUILDDIR_KRITA_INSTALL_CMAKE=%BUILDDIR_KRITA_INSTALL_CMAKE: =\ %"
 
 set PATH=%DEPS_INSTALL_DIR%\bin;%PATH%
 
 if not "%GETTEXT_SEARCH_PATH%" == "" (
     set PATH=!PATH!;!GETTEXT_SEARCH_PATH!
 )
 
 :: Prepare the CMake command lines
 set CMDLINE_CMAKE_DEPS="%CMAKE_EXE%" "%KRITA_SRC_DIR%\3rdparty" ^
     -DSUBMAKE_JOBS=%PARALLEL_JOBS% ^
     -DQT_ENABLE_DEBUG_INFO=%QT_ENABLE_DEBUG_INFO% ^
     -DQT_ENABLE_DYNAMIC_OPENGL=%QT_ENABLE_DYNAMIC_OPENGL% ^
     -DEXTERNALS_DOWNLOAD_DIR=%BUILDDIR_DOWNLOAD_CMAKE% ^
     -DINSTALL_ROOT=%BUILDDIR_DEPS_INSTALL_CMAKE% ^
     -G "MinGW Makefiles" ^
     -DUSE_QT_TABLET_WINDOWS=ON ^
     -DCMAKE_BUILD_TYPE=%CMAKE_BUILD_TYPE%
     
 set CMDLINE_CMAKE_KRITA="%CMAKE_EXE%" "%KRITA_SRC_DIR%\." ^
     -DBoost_DEBUG=OFF ^
     -DBOOST_INCLUDEDIR=%BUILDDIR_DEPS_INSTALL_CMAKE%/include ^
     -DBOOST_ROOT=%BUILDDIR_DEPS_INSTALL_CMAKE% ^
     -DBOOST_LIBRARYDIR=%BUILDDIR_DEPS_INSTALL_CMAKE%/lib ^
     -DCMAKE_PREFIX_PATH=%BUILDDIR_DEPS_INSTALL_CMAKE% ^
     -DCMAKE_INSTALL_PREFIX=%BUILDDIR_KRITA_INSTALL_CMAKE% ^
     -DBUILD_TESTING=OFF ^
     -DHAVE_MEMORY_LEAK_TRACKER=OFF ^
     -DFOUNDATION_BUILD=ON ^
     -DUSE_QT_TABLET_WINDOWS=ON ^
     -DHIDE_SAFE_ASSERTS=ON ^
     -Wno-dev ^
     -G "MinGW Makefiles"  ^
     -DCMAKE_BUILD_TYPE=%CMAKE_BUILD_TYPE%
 
 :: Launch CMD prompt if requested
 if "%ARG_CMD%" == "1" (
     doskey cmake-deps=cmd /c "pushd %DEPS_BUILD_DIR% && %CMDLINE_CMAKE_DEPS%"
     doskey cmake-krita=cmd /c "pushd %KRITA_BUILD_DIR% && %CMDLINE_CMAKE_KRITA%"
     doskey make-deps=cmd /c "pushd %DEPS_BUILD_DIR% && "%CMAKE_EXE%" --build . --config %CMAKE_BUILD_TYPE% --target $*"
     doskey make-krita=cmd /c "pushd %KRITA_BUILD_DIR% && "%CMAKE_EXE%" --build . --config %CMAKE_BUILD_TYPE% --target install -- -j%PARALLEL_JOBS%"
     echo.
     title Krita build - %KRITA_SRC_DIR% ^(deps: %DEPS_BUILD_DIR%, krita: %KRITA_BUILD_DIR%^)
     echo You're now in the build environment.
     echo The following macros are available:
     echo   cmake-deps
     echo     -- Run CMake for the deps.
     echo   make-deps ^<deps target^>
     echo     -- Run build for the specified deps target. The target name should
     echo        include the `ext_` prefix, e.g. `ext_qt`.
     echo   cmake-krita
     echo     -- Run CMake for Krita.
     echo   make-krita
     echo     -- Run build for Krita's `install` target.
     echo.
     echo For more info, type `doskey /macros` to view the macro commands.
     cmd /k
     exit
 )
 
 
 if "%ARG_SKIP_DEPS%" == "1" goto skip_build_deps
 
 pushd %DEPS_BUILD_DIR%
 if errorlevel 1 (
     echo ERROR: Cannot enter deps build dir! 1>&2
     exit /b 104
 )
 
 echo Running CMake for deps...
 
 @echo on
 %CMDLINE_CMAKE_DEPS%
 @if errorlevel 1 (
     @echo ERROR: CMake configure failed! 1>&2
     @exit /b 104
 )
 @echo off
 echo.
 
 set EXT_TARGETS=patch png2ico zlib gettext openssl boost exiv2 fftw3 eigen3 
 set EXT_TARGETS=%EXT_TARGETS% jpeg lcms2 ocio ilmbase openexr png tiff gsl vc libraw
 set EXT_TARGETS=%EXT_TARGETS% giflib qt kwindowsystem drmingw gmic freetype poppler 
 set EXT_TARGETS=%EXT_TARGETS% python sip pyqt
-set EXT_TARGETS=%EXT_TARGETS% lzma quazip
+set EXT_TARGETS=%EXT_TARGETS% lzma quazip openjpeg
 
 for %%a in (%EXT_TARGETS%) do (
     echo Building ext_%%a...
     "%CMAKE_EXE%" --build . --config %CMAKE_BUILD_TYPE% --target ext_%%a
     if errorlevel 1 (
         echo ERROR: Building of ext_%%a failed! 1>&2
         exit /b 105
     )
 )
 echo.
 
 echo ******** Built deps ********
 popd
 
 :skip_build_deps
 
 if "%ARG_SKIP_KRITA%" == "1" goto skip_build_krita
 
 pushd %KRITA_BUILD_DIR%
 if errorlevel 1 (
     echo ERROR: Cannot enter Krita build dir! 1>&2
     exit /b 104
 )
 
 echo Running CMake for Krita...
 
 @echo on
 %CMDLINE_CMAKE_KRITA%
 @if errorlevel 1 (
     @echo ERROR: CMake configure failed! 1>&2
     @exit /b 104
 )
 @echo off
 echo.
 
 echo Building Krita...
 "%CMAKE_EXE%" --build . --config %CMAKE_BUILD_TYPE% --target install -- -j%PARALLEL_JOBS%
 if errorlevel 1 (
     echo ERROR: Building of Krita failed! 1>&2
     exit /b 105
 )
 echo.
 
 echo ******** Built Krita ********
 popd
 
 :skip_build_krita
 
 echo Krita build completed!
diff --git a/krita/krita.action b/krita/krita.action
index 3e1cdc6507..73247b578d 100644
--- a/krita/krita.action
+++ b/krita/krita.action
@@ -1,3653 +1,3682 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ActionCollection version="2" name="Krita">
   <Actions category="General">
     <text>General</text>
     <Action name="open_resources_directory">
       <icon></icon>
       <text>Open Resources Folder</text>
       <whatsThis>Opens a file browser at the location Krita saves resources such as brushes to.</whatsThis>
       <toolTip>Opens a file browser at the location Krita saves resources such as brushes to.</toolTip>
       <iconText>Open Resources Folder</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="windows_cascade">
       <icon></icon>
       <text>C&amp;ascade</text>
       <whatsThis></whatsThis>
       <toolTip>Cascade</toolTip>
       <iconText>Cascade</iconText>
       <activationFlags>10</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="windows_tile">
       <icon></icon>
       <text>&amp;Tile</text>
       <whatsThis></whatsThis>
       <toolTip>Tile</toolTip>
       <iconText>Tile</iconText>
       <activationFlags>10</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="create_bundle">
       <icon></icon>
       <text>Create Resource Bundle...</text>
       <whatsThis></whatsThis>
       <toolTip>Create Resource Bundle</toolTip>
       <iconText>Create Resource Bundle</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="mainToolBar">
       <icon></icon>
       <text>Show File Toolbar</text>
       <whatsThis></whatsThis>
       <toolTip>Show File Toolbar</toolTip>
       <iconText>Show File Toolbar</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="show_color_selector">
       <icon></icon>
       <text>Show color selector</text>
       <whatsThis></whatsThis>
       <toolTip>Show color selector</toolTip>
       <iconText>Show color selector</iconText>
       <shortcut>Shift+I</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="show_mypaint_shade_selector">
       <icon></icon>
       <text>Show MyPaint shade selector</text>
       <whatsThis></whatsThis>
       <toolTip>Show MyPaint shade selector</toolTip>
       <iconText>Show MyPaint shade selector</iconText>
       <shortcut>Shift+M</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="show_minimal_shade_selector">
       <icon></icon>
       <text>Show minimal shade selector</text>
       <whatsThis></whatsThis>
       <toolTip>Show minimal shade selector</toolTip>
       <iconText>Show minimal shade selector</iconText>
       <shortcut>Shift+N</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="show_color_history">
       <icon></icon>
       <text>Show color history</text>
       <whatsThis></whatsThis>
       <toolTip>Show color history</toolTip>
       <iconText>Show color history</iconText>
       <shortcut>H</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="show_common_colors">
       <icon></icon>
       <text>Show common colors</text>
       <whatsThis></whatsThis>
       <toolTip>Show common colors</toolTip>
       <iconText>Show common colors</iconText>
       <shortcut>U</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="show_tool_options">
       <icon></icon>
       <text>Show Tool Options</text>
       <whatsThis></whatsThis>
       <toolTip>Show Tool Options</toolTip>
       <iconText>Show Tool Options</iconText>
       <shortcut>\</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="show_brush_editor">
       <icon></icon>
       <text>Show Brush Editor</text>
       <whatsThis></whatsThis>
       <toolTip>Show Brush Editor</toolTip>
       <iconText>Show Brush Editor</iconText>
       <shortcut>F5</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="show_brush_presets">
       <icon></icon>
       <text>Show Brush Presets</text>
       <whatsThis></whatsThis>
       <toolTip>Show Brush Presets</toolTip>
       <iconText>Show Brush Presets</iconText>
       <shortcut>F6</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="tablet_debugger">
       <icon></icon>
       <text>Toggle Tablet Debugger</text>
       <whatsThis></whatsThis>
       <toolTip>Toggle Tablet Debugger</toolTip>
       <iconText>Toggle Tablet Debugger</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+Shift+T</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
 
 
     <Action name="buginfo">
       <icon></icon>
       <text>Show Krita log for bug reports.</text>
       <whatsThis></whatsThis>
       <toolTip>Show Krita log for bug reports.</toolTip>
       <iconText>Show Krita log for bug reports.</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="sysinfo">
       <icon></icon>
 
 
       <text>Show system information for bug reports.</text>
       <whatsThis></whatsThis>
       <toolTip>Show system information for bug reports.</toolTip>
       <iconText>Show system information for bug reports.</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
 
     <Action name="rename_composition">
       <icon></icon>
       <text>Rename Composition...</text>
       <whatsThis></whatsThis>
       <toolTip>Rename Composition</toolTip>
       <iconText>Rename Composition</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="update_composition">
       <icon></icon>
       <text>Update Composition</text>
       <whatsThis></whatsThis>
       <toolTip>Update Composition</toolTip>
       <iconText>Update Composition</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="ruler_pixel_multiple2">
       <icon></icon>
       <text>Use multiple of 2 for pixel scale</text>
       <whatsThis>Use multiple of 2 for pixel scale</whatsThis>
       <toolTip>Use multiple of 2 for pixel scale</toolTip>
       <iconText>Use multiple of 2 for pixel scale</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="invert_selection">
       <icon></icon>
       <text>&amp;Invert Selection</text>
       <whatsThis></whatsThis>
       <toolTip>Invert current selection</toolTip>
       <iconText>Invert Selection</iconText>
       <activationFlags>10000000000</activationFlags>
       <activationConditions>100</activationConditions>
       <shortcut>Ctrl+Shift+I</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="create_snapshot">
       <icon></icon>
       <text>Create Snapshot</text>
       <whatsThis></whatsThis>
       <toolTip>Create Snapshot</toolTip>
       <iconText></iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="switchto_snapshot">
       <icon></icon>
       <text>Switch to Selected Snapshot</text>
       <whatsThis></whatsThis>
       <toolTip>Switch to selected snapshot</toolTip>
       <iconText></iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="remove_snapshot">
       <icon></icon>
       <text>Remove Selected Snapshot</text>
       <whatsThis></whatsThis>
       <toolTip>Remove Selected Snapshot</toolTip>
       <iconText></iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
   </Actions>
 
   <Actions category="Painting">
     <text>Painting</text>
     <Action name="make_brush_color_lighter">
       <icon>lightness-increase</icon>
       <text>Make brush color lighter</text>
       <whatsThis></whatsThis>
       <toolTip>Make brush color lighter</toolTip>
       <iconText>Make brush color lighter</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>L</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="make_brush_color_darker">
       <icon>lightness-decrease</icon>
       <text>Make brush color darker</text>
       <whatsThis></whatsThis>
       <toolTip>Make brush color darker</toolTip>
       <iconText>Make brush color darker</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>K</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="make_brush_color_saturated">
       <icon></icon>
       <text>Make brush color more saturated</text>
       <whatsThis></whatsThis>
       <toolTip>Make brush color more saturated</toolTip>
       <iconText>Make brush color more saturated</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="make_brush_color_desaturated">
       <icon></icon>
       <text>Make brush color more desaturated</text>
       <whatsThis></whatsThis>
       <toolTip>Make brush color more desaturated</toolTip>
       <iconText>Make brush color more desaturated</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="shift_brush_color_clockwise">
       <icon></icon>
       <text>Shift brush color hue clockwise</text>
       <whatsThis></whatsThis>
       <toolTip>Shift brush color hue clockwise</toolTip>
       <iconText>Shift brush color hue clockwise</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="shift_brush_color_counter_clockwise">
       <icon></icon>
       <text>Shift brush color hue counter-clockwise</text>
       <whatsThis></whatsThis>
       <toolTip>Shift brush color hue counter-clockwise</toolTip>
       <iconText>Shift brush color hue counter-clockwise</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="make_brush_color_redder">
       <icon></icon>
       <text>Make brush color more red</text>
       <whatsThis></whatsThis>
       <toolTip>Make brush color more red</toolTip>
       <iconText>Make brush color more red</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="make_brush_color_greener">
       <icon></icon>
       <text>Make brush color more green</text>
       <whatsThis></whatsThis>
       <toolTip>Make brush color more green</toolTip>
       <iconText>Make brush color more green</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="make_brush_color_bluer">
       <icon></icon>
       <text>Make brush color more blue</text>
       <whatsThis></whatsThis>
       <toolTip>Make brush color more blue</toolTip>
       <iconText>Make brush color more blue</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="make_brush_color_yellower">
       <icon></icon>
     <text>Make brush color more yellow</text>
       <whatsThis></whatsThis>
       <toolTip>Make brush color more yellow</toolTip>
       <iconText>Make brush color more yellow</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="increase_opacity">
       <icon>opacity-increase</icon>
       <text>Increase opacity</text>
       <whatsThis></whatsThis>
       <toolTip>Increase opacity</toolTip>
       <iconText>Increase opacity</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>O</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="decrease_opacity">
       <icon>opacity-decrease</icon>
       <text>Decrease opacity</text>
       <whatsThis></whatsThis>
       <toolTip>Decrease opacity</toolTip>
       <iconText>Decrease opacity</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>I</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="erase_action">
       <icon>draw-eraser</icon>
       <text>Set eraser mode</text>
       <whatsThis></whatsThis>
       <toolTip>Set eraser mode</toolTip>
       <iconText>Set eraser mode</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>E</shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="reload_preset_action">
       <icon>view-refresh</icon>
       <text>Reload Original Preset</text>
       <whatsThis></whatsThis>
       <toolTip>Reload Original Preset</toolTip>
       <iconText>Reload Original Preset</iconText>
       <activationFlags>10000</activationFlags>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="preserve_alpha">
       <icon>transparency-unlocked</icon>
       <text>Preserve Alpha</text>
       <whatsThis></whatsThis>
       <toolTip>Preserve Alpha</toolTip>
       <iconText>Preserve Alpha</iconText>
       <activationFlags>10000</activationFlags>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="disable_pressure">
       <icon>transform_icons_penPressure</icon>
       <text>Use Pen Pressure</text>
       <whatsThis></whatsThis>
       <toolTip>Use Pen Pressure</toolTip>
       <iconText>Use Pen Pressure</iconText>
       <activationFlags>10000</activationFlags>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="hmirror_action">
       <icon>symmetry-horizontal</icon>
       <text>Horizontal Mirror Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Horizontal Mirror Tool</toolTip>
       <iconText>Horizontal Mirror Tool</iconText>
       <activationFlags>0</activationFlags>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="vmirror_action">
       <icon>symmetry-vertical</icon>
       <text>Vertical Mirror Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Vertical Mirror Tool</toolTip>
       <iconText>Vertical Mirror Tool</iconText>
       <activationFlags>0</activationFlags>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="mirrorX-hideDecorations">
       <icon></icon>
       <text>Hide Mirror X Line</text>
       <whatsThis></whatsThis>
       <toolTip>Hide Mirror X Line</toolTip>
       <iconText>Hide Mirror X Line</iconText>
       <activationFlags>10000</activationFlags>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="mirrorY-hideDecorations">
       <icon></icon>
       <text>Hide Mirror Y Line</text>
       <whatsThis></whatsThis>
       <toolTip>Hide Mirror Y Line</toolTip>
       <iconText>Hide Mirror Y Line</iconText>
       <activationFlags>10000</activationFlags>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
    <Action name="mirrorX-lock">
       <icon></icon>
       <text>Lock</text>
       <whatsThis></whatsThis>
       <toolTip>Lock X Line</toolTip>
       <iconText>Lock X Line</iconText>
       <activationFlags>10000</activationFlags>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
    <Action name="mirrorY-lock">
       <icon></icon>
       <text>Lock Y Line</text>
       <whatsThis></whatsThis>
       <toolTip>Lock Y Line</toolTip>
       <iconText>Lock Y Line</iconText>
       <activationFlags>10000</activationFlags>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
    <Action name="mirrorX-moveToCenter">
       <icon></icon>
       <text>Move to Canvas Center X</text>
       <whatsThis></whatsThis>
       <toolTip>Move to Canvas Center X</toolTip>
       <iconText>Move to Canvas Center X</iconText>
       <activationFlags>10000</activationFlags>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="mirrorY-moveToCenter">
       <icon></icon>
       <text>Move to Canvas Center Y</text>
       <whatsThis></whatsThis>
       <toolTip>Move to Canvas Center Y</toolTip>
       <iconText>Move to Canvas Center Y</iconText>
       <activationFlags>10000</activationFlags>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="toggle-selection-overlay-mode">
       <icon></icon>
       <text>&amp;Toggle Selection Display Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Toggle Selection Display Mode</toolTip>
       <iconText>Toggle Selection Display Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="next_favorite_preset">
       <icon></icon>
       <text>Next Favourite Preset</text>
       <whatsThis></whatsThis>
       <toolTip>Next Favourite Preset</toolTip>
       <iconText>Next Favourite Preset</iconText>
       <shortcut>,</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="previous_favorite_preset">
       <icon></icon>
       <text>Previous Favourite Preset</text>
       <whatsThis></whatsThis>
       <toolTip>Previous Favourite Preset</toolTip>
       <iconText>Previous Favourite Preset</iconText>
       <shortcut>.</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="previous_preset">
       <icon>preset-switcher</icon>
       <text>Switch to Previous Preset</text>
       <whatsThis></whatsThis>
       <toolTip>Switch to Previous Preset</toolTip>
       <iconText>Switch to Previous Preset</iconText>
       <shortcut>/</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="BrushesAndStuff">
       <icon></icon>
       <text>Hide Brushes and Stuff Toolbar</text>
       <whatsThis></whatsThis>
       <toolTip>Hide Brushes and Stuff Toolbar</toolTip>
       <iconText>Hide Brushes and Stuff Toolbar</iconText>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="reset_fg_bg">
       <icon></icon>
       <text>Reset Foreground and Background Color</text>
       <whatsThis></whatsThis>
       <toolTip>Reset Foreground and Background Color</toolTip>
       <iconText>Reset Foreground and Background Color</iconText>
       <shortcut>D</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="toggle_fg_bg">
       <icon></icon>
       <text>Swap Foreground and Background Color</text>
       <whatsThis></whatsThis>
       <toolTip>Swap Foreground and Background Color</toolTip>
       <iconText>Swap Foreground and Background Color</iconText>
       <shortcut>X</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="selection_tool_mode_add">
       <icon></icon>
       <text>Selection Mode: Add</text>
       <whatsThis></whatsThis>
       <toolTip>Selection Mode: Add</toolTip>
       <iconText>Selection Mode: Add</iconText>
       <shortcut>A</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="selection_tool_mode_subtract">
       <icon></icon>
       <text>Selection Mode: Subtract</text>
       <whatsThis></whatsThis>
       <toolTip>Selection Mode: Subtract</toolTip>
       <iconText>Selection Mode: Subtract</iconText>
       <shortcut>S</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="selection_tool_mode_intersect">
       <icon></icon>
       <text>Selection Mode: Intersect</text>
       <whatsThis></whatsThis>
       <toolTip>Selection Mode: Intersect</toolTip>
       <iconText>Selection Mode: Intersect</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="selection_tool_mode_replace">
       <icon></icon>
       <text>Selection Mode: Replace</text>
       <whatsThis></whatsThis>
       <toolTip>Selection Mode: Replace</toolTip>
       <iconText>Selection Mode: Replace</iconText>
       <shortcut>R</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="set_weighted_brush_smoothing">
       <icon>smoothing-weighted</icon>
       <text>Brush Smoothing: Weighted</text>
       <whatsThis></whatsThis>
       <toolTip>Brush Smoothing: Weighted</toolTip>
       <iconText>Brush Smoothing: Weighted</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="set_no_brush_smoothing">
       <icon>smoothing-no</icon>
       <text>Brush Smoothing: Disabled</text>
       <whatsThis></whatsThis>
       <toolTip>Brush Smoothing: Disabled</toolTip>
       <iconText>Brush Smoothing: Disabled</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="set_stabilizer_brush_smoothing">
       <icon>smoothing-stabilizer</icon>
       <text>Brush Smoothing: Stabilizer</text>
       <whatsThis></whatsThis>
       <toolTip>Brush Smoothing: Stabilizer</toolTip>
       <iconText>Brush Smoothing: Stabilizer</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="decrease_brush_size">
       <icon>brushsize-decrease</icon>
       <text>Decrease Brush Size</text>
       <whatsThis></whatsThis>
       <toolTip>Decrease Brush Size</toolTip>
       <iconText>Decrease Brush Size</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>[</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="set_simple_brush_smoothing">
       <icon>smoothing-basic</icon>
       <text>Brush Smoothing: Basic</text>
       <whatsThis></whatsThis>
       <toolTip>Brush Smoothing: Basic</toolTip>
       <iconText>Brush Smoothing: Basic</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="increase_brush_size">
       <icon>brushsize-increase</icon>
       <text>Increase Brush Size</text>
       <whatsThis></whatsThis>
       <toolTip>Increase Brush Size</toolTip>
       <iconText>Increase Brush Size</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>]</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="toggle_assistant">
       <icon></icon>
       <text>Toggle Assistant</text>
       <whatsThis></whatsThis>
       <toolTip>Toggle Assistant</toolTip>
       <iconText>ToggleAssistant</iconText>
       <shortcut>Ctrl+Shift+L</shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="undo_polygon_selection">
       <icon></icon>
       <text>Undo Polygon Selection Points</text>
       <whatsThis></whatsThis>
       <toolTip>Undo Polygon Selection Points</toolTip>
       <iconText>Undo Polygon Selection Points</iconText>
       <shortcut>Shift+Z</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="fill_selection_foreground_color_opacity">
       <icon></icon>
       <text>Fill with Foreground Color (Opacity)</text>
       <whatsThis></whatsThis>
       <toolTip>Fill with Foreground Color (Opacity)</toolTip>
       <iconText>Fill with Foreground Color (Opacity)</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut>Ctrl+Shift+Backspace</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="fill_selection_background_color_opacity">
       <icon></icon>
       <text>Fill with Background Color (Opacity)</text>
       <whatsThis></whatsThis>
       <toolTip>Fill with Background Color (Opacity)</toolTip>
       <iconText>Fill with Background Color (Opacity)</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut>Ctrl+Backspace</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="fill_selection_pattern_opacity">
       <icon></icon>
       <text>Fill with Pattern (Opacity)</text>
       <whatsThis></whatsThis>
       <toolTip>Fill with Pattern (Opacity)</toolTip>
       <iconText>Fill with Pattern (Opacity)</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="convert_selection_to_shape">
       <icon></icon>
       <text>Convert &amp;to Shape</text>
       <whatsThis></whatsThis>
       <toolTip>Convert to Shape</toolTip>
       <iconText>Convert to Shape</iconText>
       <activationFlags>10000000000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="show-global-selection-mask">
       <icon></icon>
       <text>&amp;Show Global Selection Mask</text>
       <whatsThis></whatsThis>
       <toolTip>Shows global selection as a usual selection mask in &lt;interface>Layers&lt;/interface> docker</toolTip>
       <iconText>Show Global Selection Mask</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>100</activationConditions>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
   </Actions>
 
   <Actions category="Filters">
     <text>Filters</text>
     <Action name="krita_filter_colortoalpha">
       <icon>color-to-alpha</icon>
       <text>&amp;Color to Alpha...</text>
       <whatsThis></whatsThis>
       <toolTip>Color to Alpha</toolTip>
       <iconText>Color to Alpha</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_top edge detections">
       <icon></icon>
       <text>&amp;Top Edge Detection</text>
       <whatsThis></whatsThis>
       <toolTip>Top Edge Detection</toolTip>
       <iconText>Top Edge Detection</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_indexcolors">
       <icon></icon>
       <text>&amp;Index Colors...</text>
       <whatsThis></whatsThis>
       <toolTip>Index Colors</toolTip>
       <iconText>Index Colors</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_emboss horizontal only">
       <icon></icon>
       <text>Emboss Horizontal &amp;Only</text>
       <whatsThis></whatsThis>
       <toolTip>Emboss Horizontal Only</toolTip>
       <iconText>Emboss Horizontal Only</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_dodge">
       <icon></icon>
       <text>D&amp;odge</text>
       <whatsThis></whatsThis>
       <toolTip>Dodge</toolTip>
       <iconText>Dodge</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_sharpen">
       <icon></icon>
       <text>&amp;Sharpen</text>
       <whatsThis></whatsThis>
       <toolTip>Sharpen</toolTip>
       <iconText>Sharpen</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_burn">
       <icon></icon>
       <text>B&amp;urn</text>
       <whatsThis></whatsThis>
       <toolTip>Burn</toolTip>
       <iconText>Burn</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_mean removal">
       <icon></icon>
       <text>&amp;Mean Removal</text>
       <whatsThis></whatsThis>
       <toolTip>Mean Removal</toolTip>
       <iconText>Mean Removal</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_gaussian blur">
       <icon></icon>
       <text>&amp;Gaussian Blur...</text>
       <whatsThis></whatsThis>
       <toolTip>Gaussian Blur</toolTip>
       <iconText>Gaussian Blur</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_emboss all directions">
       <icon></icon>
       <text>Emboss &amp;in All Directions</text>
       <whatsThis></whatsThis>
       <toolTip>Emboss in All Directions</toolTip>
       <iconText>Emboss in All Directions</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_smalltiles">
       <icon></icon>
       <text>&amp;Small Tiles...</text>
       <whatsThis></whatsThis>
       <toolTip>Small Tiles</toolTip>
       <iconText>Small Tiles</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_levels">
       <icon></icon>
       <text>&amp;Levels...</text>
       <whatsThis></whatsThis>
       <toolTip>Levels</toolTip>
       <iconText>Levels</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+L</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_sobel">
       <icon></icon>
       <text>&amp;Sobel...</text>
       <whatsThis></whatsThis>
       <toolTip>Sobel</toolTip>
       <iconText>Sobel</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_wave">
       <icon></icon>
       <text>&amp;Wave...</text>
       <whatsThis></whatsThis>
       <toolTip>Wave</toolTip>
       <iconText>Wave</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_motion blur">
       <icon></icon>
       <text>&amp;Motion Blur...</text>
       <whatsThis></whatsThis>
       <toolTip>Motion Blur</toolTip>
       <iconText>Motion Blur</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_invert">
       <icon></icon>
       <text>&amp;Invert</text>
       <whatsThis></whatsThis>
       <toolTip>Invert</toolTip>
       <iconText>Invert</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+I</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_perchannel">
       <icon></icon>
       <text>&amp;Color Adjustment curves...</text>
       <whatsThis></whatsThis>
       <toolTip>Color Adjustment curves</toolTip>
       <iconText>Color Adjustment curves</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+M</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_pixelize">
       <icon></icon>
       <text>Pi&amp;xelize...</text>
       <whatsThis></whatsThis>
       <toolTip>Pixelize</toolTip>
       <iconText>Pixelize</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_emboss laplascian">
       <icon></icon>
       <text>Emboss (&amp;Laplacian)</text>
       <whatsThis></whatsThis>
       <toolTip>Emboss (Laplacian)</toolTip>
       <iconText>Emboss (Laplacian)</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_left edge detections">
       <icon></icon>
       <text>&amp;Left Edge Detection</text>
       <whatsThis></whatsThis>
       <toolTip>Left Edge Detection</toolTip>
       <iconText>Left Edge Detection</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_blur">
       <icon></icon>
       <text>&amp;Blur...</text>
       <whatsThis></whatsThis>
       <toolTip>Blur</toolTip>
       <iconText>Blur</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_raindrops">
       <icon></icon>
       <text>&amp;Raindrops...</text>
       <whatsThis></whatsThis>
       <toolTip>Raindrops</toolTip>
       <iconText>Raindrops</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_bottom edge detections">
       <icon></icon>
       <text>&amp;Bottom Edge Detection</text>
       <whatsThis></whatsThis>
       <toolTip>Bottom Edge Detection</toolTip>
       <iconText>Bottom Edge Detection</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_noise">
       <icon></icon>
       <text>&amp;Random Noise...</text>
       <whatsThis></whatsThis>
       <toolTip>Random Noise</toolTip>
       <iconText>Random Noise</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_brightnesscontrast">
       <icon></icon>
       <text>&amp;Brightness/Contrast curve...</text>
       <whatsThis></whatsThis>
       <toolTip>Brightness/Contrast curve</toolTip>
       <iconText>Brightness/Contrast curve</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_colorbalance">
       <icon></icon>
       <text>Colo&amp;r Balance...</text>
       <whatsThis></whatsThis>
       <toolTip>Color Balance</toolTip>
       <iconText>Color Balance</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+B</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_phongbumpmap">
       <icon></icon>
       <text>&amp;Phong Bumpmap...</text>
       <whatsThis></whatsThis>
       <toolTip>Phong Bumpmap</toolTip>
       <iconText>Phong Bumpmap</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_desaturate">
       <icon></icon>
       <text>&amp;Desaturate</text>
       <whatsThis></whatsThis>
       <toolTip>Desaturate</toolTip>
       <iconText>Desaturate</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+Shift+U</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_colortransfer">
       <icon></icon>
       <text>Color &amp;Transfer...</text>
       <whatsThis></whatsThis>
       <toolTip>Color Transfer</toolTip>
       <iconText>Color Transfer</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_emboss vertical only">
       <icon></icon>
       <text>Emboss &amp;Vertical Only</text>
       <whatsThis></whatsThis>
       <toolTip>Emboss Vertical Only</toolTip>
       <iconText>Emboss Vertical Only</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_lens blur">
       <icon></icon>
       <text>&amp;Lens Blur...</text>
       <whatsThis></whatsThis>
       <toolTip>Lens Blur</toolTip>
       <iconText>Lens Blur</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_minimize">
       <icon></icon>
       <text>M&amp;inimize Channel</text>
       <whatsThis></whatsThis>
       <toolTip>Minimize Channel</toolTip>
       <iconText>Minimize Channel</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_maximize">
       <icon></icon>
       <text>M&amp;aximize Channel</text>
       <whatsThis></whatsThis>
       <toolTip>Maximize Channel</toolTip>
       <iconText>Maximize Channel</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_oilpaint">
       <icon></icon>
       <text>&amp;Oilpaint...</text>
       <whatsThis></whatsThis>
       <toolTip>Oilpaint</toolTip>
       <iconText>Oilpaint</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_right edge detections">
       <icon></icon>
       <text>&amp;Right Edge Detection</text>
       <whatsThis></whatsThis>
       <toolTip>Right Edge Detection</toolTip>
       <iconText>Right Edge Detection</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_autocontrast">
       <icon></icon>
       <text>&amp;Auto Contrast</text>
       <whatsThis></whatsThis>
       <toolTip>Auto Contrast</toolTip>
       <iconText>Auto Contrast</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_roundcorners">
       <icon></icon>
       <text>&amp;Round Corners...</text>
       <whatsThis></whatsThis>
       <toolTip>Round Corners</toolTip>
       <iconText>Round Corners</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_unsharp">
       <icon></icon>
       <text>&amp;Unsharp Mask...</text>
       <whatsThis></whatsThis>
       <toolTip>Unsharp Mask</toolTip>
       <iconText>Unsharp Mask</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_emboss">
       <icon></icon>
       <text>&amp;Emboss with Variable Depth...</text>
       <whatsThis></whatsThis>
       <toolTip>Emboss with Variable Depth</toolTip>
       <iconText>Emboss with Variable Depth</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_emboss horizontal and vertical">
       <icon></icon>
       <text>Emboss &amp;Horizontal &amp;&amp; Vertical</text>
       <whatsThis></whatsThis>
       <toolTip>Emboss Horizontal &amp; Vertical</toolTip>
       <iconText>Emboss Horizontal &amp; Vertical</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_randompick">
       <icon></icon>
       <text>Random &amp;Pick...</text>
       <whatsThis></whatsThis>
       <toolTip>Random Pick</toolTip>
       <iconText>Random Pick</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_gaussiannoisereducer">
       <icon></icon>
       <text>&amp;Gaussian Noise Reduction...</text>
       <whatsThis></whatsThis>
       <toolTip>Gaussian Noise Reduction</toolTip>
       <iconText>Gaussian Noise Reduction</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_posterize">
       <icon></icon>
       <text>&amp;Posterize...</text>
       <whatsThis></whatsThis>
       <toolTip>Posterize</toolTip>
       <iconText>Posterize</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_waveletnoisereducer">
       <icon></icon>
       <text>&amp;Wavelet Noise Reducer...</text>
       <whatsThis></whatsThis>
       <toolTip>Wavelet Noise Reducer</toolTip>
       <iconText>Wavelet Noise Reducer</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="krita_filter_hsvadjustment">
       <icon></icon>
       <text>&amp;HSV Adjustment...</text>
       <whatsThis></whatsThis>
       <toolTip>HSV Adjustment</toolTip>
       <iconText>HSV Adjustment</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+U</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
   </Actions>
 
   <Actions category="tool-shortcuts">
     <text>Tool Shortcuts</text>
     <Action name="KritaShape/KisToolDyna">
       <icon></icon>
       <text>Dynamic Brush Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Dynamic Brush Tool</toolTip>
       <iconText>Dynamic Brush Tool</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KisToolCrop">
       <icon></icon>
       <text>Crop Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Crop the image to an area</toolTip>
       <iconText>Crop the image to an area</iconText>
       <shortcut>C</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KisToolPolygon">
       <icon></icon>
       <text>Polygon Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Polygon Tool. Shift-mouseclick ends the polygon.</toolTip>
       <iconText>Polygon Tool. Shift-mouseclick ends the polygon.</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KritaShape/KisToolRectangle">
       <icon></icon>
       <text>Rectangle Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Rectangle Tool</toolTip>
       <iconText>Rectangle Tool</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KritaShape/KisToolMultiBrush">
       <icon></icon>
       <text>Multibrush Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Multibrush Tool</toolTip>
       <iconText>Multibrush Tool</iconText>
       <shortcut>Q</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KritaShape/KisToolLazyBrush">
       <icon></icon>
       <text>Colorize Mask Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Colorize Mask Tool</toolTip>
       <iconText>Colorize Mask Tool</iconText>
       <shortcut></shortcut>
       <statusTip></statusTip>
     </Action>
     <Action name="KritaShape/KisToolSmartPatch">
       <icon></icon>
       <text>Smart Patch Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Smart Patch Tool</toolTip>
       <iconText>Smart Patch Tool</iconText>
       <shortcut></shortcut>
       <statusTip></statusTip>
     </Action>
     <Action name="PanTool">
       <icon></icon>
       <text>Pan Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Pan Tool</toolTip>
       <iconText>Pan Tool</iconText>
       <shortcut></shortcut>
       <statusTip></statusTip>
     </Action>
     <Action name="InteractionTool">
       <icon></icon>
       <text>Select Shapes Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Select Shapes Tool</toolTip>
       <iconText>Select Shapes Tool</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KritaSelected/KisToolColorPicker">
       <icon></icon>
       <text>Color Picker</text>
       <whatsThis></whatsThis>
       <toolTip>Select a color from the image or current layer</toolTip>
       <iconText>Select a color from the image or current layer</iconText>
       <shortcut>P</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KisToolSelectOutline">
       <icon></icon>
       <text>Outline Selection Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Outline Selection Tool</toolTip>
       <iconText>Outline Selection Tool</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KisToolSelectPath">
       <icon></icon>
       <text>Bezier Curve Selection Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Bezier Curve Selection Tool</toolTip>
       <iconText>Bezier Curve Selection Tool</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KisToolSelectSimilar">
       <icon></icon>
       <text>Similar Color Selection Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Similar Color Selection Tool</toolTip>
       <iconText>Similar Color Selection Tool</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KritaFill/KisToolFill">
       <icon></icon>
       <text>Fill Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Fill a contiguous area of color with a color, or fill a selection.</toolTip>
       <iconText>Fill a contiguous area of color with a color, or fill a selection.</iconText>
       <shortcut>F</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KritaShape/KisToolLine">
       <icon></icon>
       <text>Line Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Line Tool</toolTip>
       <iconText>Line Tool</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KisToolPencil">
       <icon></icon>
       <text>Freehand Path Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Freehand Path Tool</toolTip>
       <iconText>Freehand Path Tool</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KisToolPath">
       <icon></icon>
       <text>Bezier Curve Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Bezier Curve Tool. Shift-mouseclick or double-click ends the curve.</toolTip>
       <iconText>Bezier Curve Tool. Shift-mouseclick or double-click ends the curve.</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KritaShape/KisToolEllipse">
       <icon></icon>
       <text>Ellipse Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Ellipse Tool</toolTip>
       <iconText>Ellipse Tool</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KritaShape/KisToolBrush">
       <icon></icon>
       <text>Freehand Brush Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Freehand Brush Tool</toolTip>
       <iconText>Freehand Brush Tool</iconText>
       <shortcut>B</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="CreateShapesTool">
       <icon></icon>
       <text>Create object</text>
       <whatsThis></whatsThis>
       <toolTip>Create object</toolTip>
       <iconText>Create object</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KisToolSelectElliptical">
       <icon></icon>
       <text>Elliptical Selection Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Elliptical Selection Tool</toolTip>
       <iconText>Elliptical Selection Tool</iconText>
       <shortcut>J</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KisToolSelectContiguous">
       <icon></icon>
       <text>Contiguous Selection Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Contiguous Selection Tool</toolTip>
       <iconText>Contiguous Selection Tool</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KarbonPatternTool">
       <icon></icon>
       <text>Pattern editing</text>
       <whatsThis></whatsThis>
       <toolTip>Pattern editing</toolTip>
       <iconText>Pattern editing</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="ReviewTool">
       <icon></icon>
       <text>Review</text>
       <whatsThis></whatsThis>
       <toolTip>Review</toolTip>
       <iconText>Review</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KritaFill/KisToolGradient">
       <icon></icon>
       <text>Draw a gradient.</text>
       <whatsThis></whatsThis>
       <toolTip>Draw a gradient.</toolTip>
       <iconText>Draw a gradient.</iconText>
       <shortcut>G</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KisToolSelectPolygonal">
       <icon></icon>
       <text>Polygonal Selection Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Polygonal Selection Tool</toolTip>
       <iconText>Polygonal Selection Tool</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KritaShape/KisToolMeasure">
       <icon></icon>
       <text>Measurement Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Measure the distance between two points</toolTip>
       <iconText>Measure the distance between two points</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KisToolSelectRectangular">
       <icon></icon>
       <text>Rectangular Selection Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Rectangular Selection Tool</toolTip>
       <iconText>Rectangular Selection Tool</iconText>
       <shortcut>Ctrl+R</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KritaTransform/KisToolMove">
       <icon></icon>
       <text>Move Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Move a layer</toolTip>
       <iconText>Move a layer</iconText>
       <shortcut>T</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="VectorTool">
       <icon></icon>
       <text>Vector Image Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Vector Image (EMF/WMF/SVM/SVG) tool</toolTip>
       <iconText>Vector Image (EMF/WMF/SVM/SVG) tool</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KarbonCalligraphyTool">
       <icon></icon>
       <text>Calligraphy</text>
       <whatsThis></whatsThis>
       <toolTip>Calligraphy</toolTip>
       <iconText>Calligraphy</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="PathTool">
       <icon></icon>
       <text>Path editing</text>
       <whatsThis></whatsThis>
       <toolTip>Path editing</toolTip>
       <iconText>Path editing</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="ZoomTool">
       <icon></icon>
       <text>Zoom Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Zoom Tool</toolTip>
       <iconText>Zoom Tool</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KisToolPolyline">
       <icon></icon>
       <text>Polyline Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Polyline Tool. Shift-mouseclick ends the polyline.</toolTip>
       <iconText>Polyline Tool. Shift-mouseclick ends the polyline.</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KisToolTransform">
       <icon></icon>
       <text>Transform Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Transform a layer or a selection</toolTip>
       <iconText>Transform a layer or a selection</iconText>
       <shortcut>Ctrl+T</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KisAssistantTool">
       <icon></icon>
       <text>Assistant Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Assistant Tool</toolTip>
       <iconText>Assistant Tool</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="KarbonGradientTool">
       <icon></icon>
       <text>Gradient Editing Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Gradient editing</toolTip>
       <iconText>Gradient editing</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="ToolReferenceImages">
       <icon></icon>
       <text>Reference Images Tool</text>
       <whatsThis></whatsThis>
       <toolTip>Reference Images Tool</toolTip>
       <iconText>Reference Images Tool</iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
   </Actions>
 
   <Actions category="Blending Modes">
     <text>Blending Modes</text>
 
 <!-- commented out in the code right now
     <Action name="Next Blending Mode">
       <icon></icon>
       <text>Next Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Next Blending Mode</toolTip>
       <iconText>Next Blending Mode</iconText>
       <shortcut>Alt+Shift++</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Previous Blending Mode">
       <icon></icon>
       <text>Previous Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Previous Blending Mode</toolTip>
       <iconText>Previous Blending Mode</iconText>
       <shortcut>Alt+Shift+-</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 -->
     <Action name="Select Normal Blending Mode">
       <icon></icon>
       <text>Select Normal Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Normal Blending Mode</toolTip>
       <iconText>Select Normal Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+N</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Dissolve Blending Mode">
       <icon></icon>
       <text>Select Dissolve Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Dissolve Blending Mode</toolTip>
       <iconText>Select Dissolve Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+I</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Behind Blending Mode">
       <icon></icon>
       <text>Select Behind Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Behind Blending Mode</toolTip>
       <iconText>Select Behind Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+Q</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Clear Blending Mode">
       <icon></icon>
       <text>Select Clear Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Clear Blending Mode</toolTip>
       <iconText>Select Clear Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+R</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Darken Blending Mode">
       <icon></icon>
       <text>Select Darken Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Darken Blending Mode</toolTip>
       <iconText>Select Darken Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+K</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Multiply Blending Mode">
       <icon></icon>
       <text>Select Multiply Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Multiply Blending Mode</toolTip>
       <iconText>Select Multiply Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+M</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Color Burn Blending Mode">
       <icon></icon>
       <text>Select Color Burn Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Color Burn Blending Mode</toolTip>
       <iconText>Select Color Burn Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+B</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Linear Burn Blending Mode">
       <icon></icon>
       <text>Select Linear Burn Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Linear Burn Blending Mode</toolTip>
       <iconText>Select Linear Burn Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+A</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Lighten Blending Mode">
       <icon></icon>
       <text>Select Lighten Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Lighten Blending Mode</toolTip>
       <iconText>Select Lighten Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+G</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Screen Blending Mode">
       <icon></icon>
       <text>Select Screen Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Screen Blending Mode</toolTip>
       <iconText>Select Screen Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+S</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Color Dodge Blending Mode">
       <icon></icon>
       <text>Select Color Dodge Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Color Dodge Blending Mode</toolTip>
       <iconText>Select Color Dodge Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+D</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Linear Dodge Blending Mode">
       <icon></icon>
       <text>Select Linear Dodge Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Linear Dodge Blending Mode</toolTip>
       <iconText>Select Linear Dodge Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+W</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Overlay Blending Mode">
       <icon></icon>
       <text>Select Overlay Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Overlay Blending Mode</toolTip>
       <iconText>Select Overlay Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+O</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Hard Overlay Blending Mode">
       <icon></icon>
       <text>Select Hard Overlay Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Hard Overlay Blending Mode</toolTip>
       <iconText>Select Hard Overlay Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+P</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Soft Light Blending Mode">
       <icon></icon>
       <text>Select Soft Light Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Soft Light Blending Mode</toolTip>
       <iconText>Select Soft Light Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+F</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Hard Light Blending Mode">
       <icon></icon>
       <text>Select Hard Light Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Hard Light Blending Mode</toolTip>
       <iconText>Select Hard Light Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+H</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Vivid Light Blending Mode">
       <icon></icon>
       <text>Select Vivid Light Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Vivid Light Blending Mode</toolTip>
       <iconText>Select Vivid Light Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+V</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Linear Light Blending Mode">
       <icon></icon>
       <text>Select Linear Light Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Linear Light Blending Mode</toolTip>
       <iconText>Select Linear Light Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+J</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Pin Light Blending Mode">
       <icon></icon>
       <text>Select Pin Light Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Pin Light Blending Mode</toolTip>
       <iconText>Select Pin Light Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+Z</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Hard Mix Blending Mode">
       <icon></icon>
       <text>Select Hard Mix Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Hard Mix Blending Mode</toolTip>
       <iconText>Select Hard Mix Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+L</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Difference Blending Mode">
       <icon></icon>
       <text>Select Difference Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Difference Blending Mode</toolTip>
       <iconText>Select Difference Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+E</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Exclusion Blending Mode">
       <icon></icon>
       <text>Select Exclusion Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Exclusion Blending Mode</toolTip>
       <iconText>Select Exclusion Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+X</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Hue Blending Mode">
       <icon></icon>
       <text>Select Hue Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Hue Blending Mode</toolTip>
       <iconText>Select Hue Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+U</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Saturation Blending Mode">
       <icon></icon>
       <text>Select Saturation Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Saturation Blending Mode</toolTip>
       <iconText>Select Saturation Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+T</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Color Blending Mode">
       <icon></icon>
       <text>Select Color Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Color Blending Mode</toolTip>
       <iconText>Select Color Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+C</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="Select Luminosity Blending Mode">
       <icon></icon>
       <text>Select Luminosity Blending Mode</text>
       <whatsThis></whatsThis>
       <toolTip>Select Luminosity Blending Mode</toolTip>
       <iconText>Select Luminosity Blending Mode</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Alt+Shift+Y</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
   </Actions>
 
   <Actions category="Animation">
     <text>Animation</text>
     <Action name="previous_frame">
       <icon></icon>
       <text>Previous frame</text>
       <whatsThis></whatsThis>
       <toolTip>Move to previous frame</toolTip>
       <iconText>Move to previous frame</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="next_frame">
       <icon></icon>
       <text>Next frame</text>
       <whatsThis></whatsThis>
       <toolTip>Move to next frame</toolTip>
       <iconText>Move to next frame</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="toggle_playback">
       <icon></icon>
       <text>Play / pause animation</text>
       <whatsThis></whatsThis>
       <toolTip>Play / pause animation</toolTip>
       <iconText>Play / pause animation</iconText>
       <activationFlags>1</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="add_blank_frame">
       <icon>addblankframe</icon>
       <text>Create Blank Frame</text>
       <whatsThis></whatsThis>
       <toolTip>Add blank frame</toolTip>
       <iconText>Add blank frame</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="add_duplicate_frame">
       <icon>addduplicateframe</icon>
       <text>Create Duplicate Frame</text>
       <whatsThis></whatsThis>
       <toolTip>Add duplicate frame</toolTip>
       <iconText>Add duplicate frame</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="toggle_onion_skin">
       <icon></icon>
       <text>Toggle onion skin</text>
       <whatsThis></whatsThis>
       <toolTip>Toggle onion skin</toolTip>
       <iconText>Toggle onion skin</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="previous_keyframe">
       <icon></icon>
       <text>Previous Keyframe</text>
       <whatsThis></whatsThis>
       <toolTip></toolTip>
       <iconText></iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="next_keyframe">
       <icon></icon>
       <text>Next Keyframe</text>
       <whatsThis></whatsThis>
       <toolTip></toolTip>
       <iconText></iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="first_frame">
       <icon></icon>
       <text>First Frame</text>
       <whatsThis></whatsThis>
       <toolTip></toolTip>
       <iconText></iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="last_frame">
       <icon></icon>
       <text>Last Frame</text>
       <whatsThis></whatsThis>
       <toolTip></toolTip>
       <iconText></iconText>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="lazy_frame">
       <icon></icon>
       <text>Auto Frame Mode</text>
       <whatsThis></whatsThis>
       <toolTip></toolTip>
       <iconText></iconText>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="drop_frames">
       <icon></icon>
       <text></text>
       <whatsThis></whatsThis>
       <toolTip></toolTip>
       <iconText></iconText>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="show_in_timeline">
       <icon></icon>
       <text>Show in Timeline</text>
       <whatsThis></whatsThis>
       <toolTip></toolTip>
       <iconText></iconText>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="insert_keyframe_left">
       <icon></icon>
       <text>Insert Keyframe Left</text>
       <whatsThis></whatsThis>
       <toolTip>Insert keyframes to the left of selection, moving the tail of animation to the right.</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="insert_keyframe_right">
       <icon></icon>
       <text>Insert Keyframe Right</text>
       <whatsThis></whatsThis>
       <toolTip>Insert keyframes to the right of selection, moving the tail of animation to the right.</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="insert_multiple_keyframes">
       <icon></icon>
       <text>Insert Multiple Keyframes</text>
       <whatsThis></whatsThis>
       <toolTip>Insert several keyframes based on user parameters.</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="remove_frames_and_pull">
       <icon></icon>
       <text>Remove Frame and Pull</text>
       <whatsThis></whatsThis>
       <toolTip>Remove keyframes moving the tail of animation to the left</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="remove_frames">
       <icon>deletekeyframe</icon>
       <text>Remove Keyframe</text>
       <whatsThis></whatsThis>
       <toolTip>Remove keyframes without moving anything around</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="insert_column_left">
       <icon></icon>
       <text>Insert Column Left</text>
       <whatsThis></whatsThis>
       <toolTip>Insert column to the left of selection, moving the tail of animation to the right</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="insert_column_right">
       <icon></icon>
       <text>Insert Column Right</text>
       <whatsThis></whatsThis>
       <toolTip>Insert column to the right of selection, moving the tail of animation to the right</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="insert_multiple_columns">
       <icon></icon>
       <text>Insert Multiple Columns</text>
       <whatsThis></whatsThis>
       <toolTip>Insert several columns based on user parameters.</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="remove_columns_and_pull">
       <icon></icon>
       <text>Remove Column and Pull</text>
       <whatsThis></whatsThis>
       <toolTip>Remove columns moving the tail of animation to the left</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="remove_columns">
       <icon></icon>
       <text>Remove Column</text>
       <whatsThis></whatsThis>
       <toolTip>Remove columns without moving anything around</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="insert_hold_frame">
       <icon></icon>
       <text>Insert Hold Frame</text>
       <whatsThis></whatsThis>
       <toolTip>Insert a hold frame after every keyframe</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="insert_multiple_hold_frames">
       <icon></icon>
       <text>Insert Multiple Hold Frames</text>
       <whatsThis></whatsThis>
       <toolTip>Insert N hold frames after every keyframe</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="remove_hold_frame">
       <icon></icon>
       <text>Remove Hold Frame</text>
       <whatsThis></whatsThis>
       <toolTip>Remove a hold frame after every keyframe</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="remove_multiple_hold_frames">
       <icon></icon>
       <text>Remove Multiple Hold Frames</text>
       <whatsThis></whatsThis>
       <toolTip>Remove N hold frames after every keyframe</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="insert_hold_column">
       <icon></icon>
       <text>Insert Hold Column</text>
       <whatsThis></whatsThis>
       <toolTip>Insert a hold column into the frame at the current position</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="insert_multiple_hold_columns">
       <icon></icon>
       <text>Insert Multiple Hold Columns</text>
       <whatsThis></whatsThis>
       <toolTip>Insert N hold columns into the frame at the current position</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="remove_hold_column">
       <icon></icon>
       <text>Remove Hold Column</text>
       <whatsThis></whatsThis>
       <toolTip>Remove a hold column from the frame at the current position</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="remove_multiple_hold_columns">
       <icon></icon>
       <text>Remove Multiple Hold Columns</text>
       <whatsThis></whatsThis>
       <toolTip>Remove N hold columns from the frame at the current position</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
+
+    <Action name="insert_opacity_keyframe">
+      <icon></icon>
+      <text>Add opacity keyframe</text>
+      <whatsThis></whatsThis>
+      <toolTip>Adds keyframe to control layer opacity</toolTip>
+      <iconText></iconText>
+      <activationFlags>100000</activationFlags>
+      <activationConditions>0</activationConditions>
+      <shortcut></shortcut>
+      <isCheckable>false</isCheckable>
+      <statusTip></statusTip>
+    </Action>
+
+
+    <Action name="remove_opacity_keyframe">
+      <icon></icon>
+      <text>Remove opacity keyframe</text>
+      <whatsThis></whatsThis>
+      <toolTip>Removes keyframe to control layer opacity</toolTip>
+      <iconText></iconText>
+      <activationFlags>100000</activationFlags>
+      <activationConditions>0</activationConditions>
+      <shortcut></shortcut>
+      <isCheckable>false</isCheckable>
+      <statusTip></statusTip>
+    </Action>
+
+
     <Action name="mirror_frames">
       <icon></icon>
       <text>Mirror Frames</text>
       <whatsThis></whatsThis>
       <toolTip>Mirror frames' position</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="mirror_columns">
       <icon></icon>
       <text>Mirror Columns</text>
       <whatsThis></whatsThis>
       <toolTip>Mirror columns' position</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="copy_frames_to_clipboard">
       <icon></icon>
       <text>Copy to Clipboard</text>
       <whatsThis></whatsThis>
       <toolTip>Copy frames to clipboard</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="cut_frames_to_clipboard">
       <icon></icon>
       <text>Cut to Clipboard</text>
       <whatsThis></whatsThis>
       <toolTip>Cut frames to clipboard</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="paste_frames_from_clipboard">
       <icon></icon>
       <text>Paste from Clipboard</text>
       <whatsThis></whatsThis>
       <toolTip>Paste frames from clipboard</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="copy_columns_to_clipboard">
       <icon></icon>
       <text>Copy Columns to Clipboard</text>
       <whatsThis></whatsThis>
       <toolTip>Copy columns to clipboard</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="cut_columns_to_clipboard">
       <icon></icon>
       <text>Cut Columns to Clipboard</text>
       <whatsThis></whatsThis>
       <toolTip>Cut columns to clipboard</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
     <Action name="paste_columns_from_clipboard">
       <icon></icon>
       <text>Paste Columns from Clipboard</text>
       <whatsThis></whatsThis>
       <toolTip>Paste columns from clipboard</toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
 
 
     <Action name="set_start_time">
       <icon></icon>
       <text>Set Start Time</text>
       <whatsThis></whatsThis>
       <toolTip></toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
 
     <Action name="set_end_time">
       <icon></icon>
       <text>Set End Time</text>
       <whatsThis></whatsThis>
       <toolTip></toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
 
     <Action name="update_playback_range">
       <icon></icon>
       <text>Update Playback Range</text>
       <whatsThis></whatsThis>
       <toolTip></toolTip>
       <iconText></iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
 
 
   </Actions>
 
   <Actions category="Layers">
     <text>Layers</text>
 
     <Action name="activateNextLayer">
       <icon></icon>
       <text>Activate next layer</text>
       <whatsThis></whatsThis>
       <toolTip>Activate next layer</toolTip>
       <iconText>Activate next layer</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>PgUp</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="activatePreviousLayer">
       <icon></icon>
       <text>Activate previous layer</text>
       <whatsThis></whatsThis>
       <toolTip>Activate previous layer</toolTip>
       <iconText>Activate previous layer</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>PgDown</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="switchToPreviouslyActiveNode">
       <icon></icon>
       <text>Activate previously selected layer</text>
       <whatsThis></whatsThis>
       <toolTip>Activate previously selected layer</toolTip>
       <iconText>Activate previously selected layer</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>;</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="add_new_group_layer">
       <icon>groupLayer</icon>
       <text>&amp;Group Layer</text>
       <whatsThis></whatsThis>
       <toolTip>Group Layer</toolTip>
       <iconText>Group Layer</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="add_new_clone_layer">
       <icon>cloneLayer</icon>
       <text>&amp;Clone Layer</text>
       <whatsThis></whatsThis>
       <toolTip>Clone Layer</toolTip>
       <iconText>Clone Layer</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="add_new_shape_layer">
       <icon>vectorLayer</icon>
       <text>&amp;Vector Layer</text>
       <whatsThis></whatsThis>
       <toolTip>Vector Layer</toolTip>
       <iconText>Vector Layer</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="add_new_adjustment_layer">
       <icon>filterLayer</icon>
       <text>&amp;Filter Layer...</text>
       <whatsThis></whatsThis>
       <toolTip>Filter Layer</toolTip>
       <iconText>Filter Layer</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="add_new_fill_layer">
       <icon>fillLayer</icon>
       <text>&amp;Fill Layer...</text>
       <whatsThis></whatsThis>
       <toolTip>Fill Layer</toolTip>
       <iconText>Fill Layer</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="add_new_file_layer">
       <icon>fileLayer</icon>
       <text>&amp;File Layer...</text>
       <whatsThis></whatsThis>
       <toolTip>File Layer</toolTip>
       <iconText>File Layer</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="add_new_transparency_mask">
       <icon>transparencyMask</icon>
       <text>&amp;Transparency Mask</text>
       <whatsThis></whatsThis>
       <toolTip>Transparency Mask</toolTip>
       <iconText>Transparency Mask</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="add_new_filter_mask">
       <icon>filterMask</icon>
       <text>&amp;Filter Mask...</text>
       <whatsThis></whatsThis>
       <toolTip>Filter Mask</toolTip>
       <iconText>Filter Mask</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="add_new_colorize_mask">
       <icon>filterMask</icon>
       <text>&amp;Colorize Mask</text>
       <whatsThis></whatsThis>
       <toolTip>Colorize Mask</toolTip>
       <iconText>Colorize Mask</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="add_new_transform_mask">
       <icon>transformMask</icon>
       <text>&amp;Transform Mask...</text>
       <whatsThis></whatsThis>
       <toolTip>Transform Mask</toolTip>
       <iconText>Transform Mask</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="add_new_selection_mask">
       <icon>selectionMask</icon>
       <text>&amp;Local Selection</text>
       <whatsThis></whatsThis>
       <toolTip>Local Selection</toolTip>
       <iconText>Local Selection</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="isolate_layer">
       <icon>view-filter</icon>
       <text>&amp;Isolate Layer</text>
       <whatsThis></whatsThis>
       <toolTip>Isolate Layer</toolTip>
       <iconText>Isolate Layer</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>true</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="toggle_layer_lock">
       <icon>layer-locked</icon>
       <text>&amp;Toggle layer lock</text>
       <whatsThis></whatsThis>
       <toolTip>Toggle layer lock</toolTip>
       <iconText>Toggle layer lock</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="toggle_layer_visibility">
       <icon>visible</icon>
       <text>Toggle layer &amp;visibility</text>
       <whatsThis></whatsThis>
       <toolTip>Toggle layer visibility</toolTip>
       <iconText>Toggle layer visibility</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="toggle_layer_alpha_lock">
       <icon>transparency-locked</icon>
       <text>Toggle layer &amp;alpha</text>
       <whatsThis></whatsThis>
       <toolTip>Toggle layer alpha</toolTip>
       <iconText>Toggle layer alpha</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="toggle_layer_inherit_alpha">
       <icon>transparency-enabled</icon>
       <text>Toggle layer alpha &amp;inheritance</text>
       <whatsThis></whatsThis>
       <toolTip>Toggle layer alpha inheritance</toolTip>
       <iconText>Toggle layer alpha inheritance</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="add_new_paint_layer">
       <icon>paintLayer</icon>
       <text>&amp;Paint Layer</text>
       <whatsThis></whatsThis>
       <toolTip>Paint Layer</toolTip>
       <iconText>Paint Layer</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Insert</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="new_from_visible">
       <icon></icon>
       <text>&amp;New Layer From Visible</text>
       <whatsThis></whatsThis>
       <toolTip>New layer from visible</toolTip>
       <iconText>New layer from visible</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="duplicatelayer">
       <icon>duplicatelayer</icon>
       <text>&amp;Duplicate Layer or Mask</text>
       <whatsThis></whatsThis>
       <toolTip>Duplicate Layer or Mask</toolTip>
       <iconText>Duplicate Layer or Mask</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+J</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="cut_selection_to_new_layer">
       <icon></icon>
       <text>&amp;Cut Selection to New Layer</text>
       <whatsThis></whatsThis>
       <toolTip>Cut Selection to New Layer</toolTip>
       <iconText>Cut Selection to New Layer</iconText>
       <activationFlags>100000000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut>Ctrl+Shift+J</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="copy_selection_to_new_layer">
       <icon></icon>
       <text>Copy &amp;Selection to New Layer</text>
       <whatsThis></whatsThis>
       <toolTip>Copy Selection to New Layer</toolTip>
       <iconText>Copy Selection to New Layer</iconText>
       <activationFlags>100000000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+Alt+J</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="copy_layer_clipboard">
       <icon></icon>
       <text>Copy Layer</text>
       <whatsThis></whatsThis>
       <toolTip>Copy layer to clipboard</toolTip>
       <iconText>Copy layer to clipboard</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="cut_layer_clipboard">
       <icon></icon>
       <text>Cut Layer</text>
       <whatsThis></whatsThis>
       <toolTip>Cut layer to clipboard</toolTip>
       <iconText>Cut layer to clipboard</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="paste_layer_from_clipboard">
       <icon></icon>
       <text>Paste Layer</text>
       <whatsThis></whatsThis>
       <toolTip>Paste layer from clipboard</toolTip>
       <iconText>Paste layer from clipboard</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="create_quick_group">
       <icon></icon>
       <text>Quick Group</text>
       <whatsThis></whatsThis>
       <toolTip>Create a group layer containing selected layers</toolTip>
       <iconText>Quick Group</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+G</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="quick_ungroup">
       <icon></icon>
       <text>Quick Ungroup</text>
       <whatsThis></whatsThis>
       <toolTip>Remove grouping of the layers or remove one layer out of the group</toolTip>
       <iconText>Quick Ungroup</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+Alt+G</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="create_quick_clipping_group">
       <icon></icon>
       <text>Quick Clipping Group</text>
       <whatsThis></whatsThis>
       <toolTip>Group selected layers and add a layer with clipped alpha channel</toolTip>
       <iconText>Quick Clipping Group</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+Shift+G</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="select_all_layers">
       <icon></icon>
       <text>All Layers</text>
       <whatsThis></whatsThis>
       <toolTip>Select all layers</toolTip>
       <iconText>Select all layers</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="select_visible_layers">
       <icon></icon>
       <text>Visible Layers</text>
       <whatsThis></whatsThis>
       <toolTip>Select all visible layers</toolTip>
       <iconText>Select all visible layers</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="select_locked_layers">
       <icon></icon>
       <text>Locked Layers</text>
       <whatsThis></whatsThis>
       <toolTip>Select all locked layers</toolTip>
       <iconText>Select all locked layers</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="select_invisible_layers">
       <icon></icon>
       <text>Invisible Layers</text>
       <whatsThis></whatsThis>
       <toolTip>Select all invisible layers</toolTip>
       <iconText>Select all invisible layers</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="select_unlocked_layers">
       <icon></icon>
       <text>Unlocked Layers</text>
       <whatsThis></whatsThis>
       <toolTip>Select all unlocked layers</toolTip>
       <iconText>Select all unlocked layers</iconText>
       <activationFlags>10000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="save_node_as_image">
       <icon>document-save</icon>
       <text>&amp;Save Layer/Mask...</text>
       <whatsThis></whatsThis>
       <toolTip>Save Layer/Mask</toolTip>
       <iconText>Save Layer/Mask</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
         <Action name="save_vector_node_to_svg">
       <icon>document-save</icon>
       <text>Save Vector Layer as SVG...</text>
       <whatsThis></whatsThis>
       <toolTip>Save Vector Layer as SVG</toolTip>
       <iconText>Save Vector Layer as SVG</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="save_groups_as_images">
       <icon>document-save</icon>
       <text>Save &amp;Group Layers...</text>
       <whatsThis></whatsThis>
       <toolTip>Save Group Layers</toolTip>
       <iconText>Save Group Layers</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="convert_group_to_animated">
       <icon></icon>
       <text>Convert group to &amp;animated layer</text>
       <whatsThis></whatsThis>
       <toolTip>Convert child layers into animation frames</toolTip>
       <iconText>Convert child layers into animation frames</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
         <Action name="convert_to_animated">
       <icon></icon>
       <text>Convert to &amp;animated layer</text>
       <whatsThis></whatsThis>
       <toolTip>Convert layer into animation frames</toolTip>
       <iconText>Convert layer into animation frames</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="convert_to_file_layer">
       <icon>fileLayer</icon>
       <text>to &amp;File Layer</text>
       <whatsThis></whatsThis>
       <toolTip>Saves out the layers into a new image and then references that image.</toolTip>
       <iconText>Convert to File Layer</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="import_layer_from_file">
       <icon></icon>
       <text>I&amp;mport Layer...</text>
       <whatsThis></whatsThis>
       <toolTip>Import Layer</toolTip>
       <iconText>Import Layer</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="import_layer_as_paint_layer">
       <icon>paintLayer</icon>
       <text>&amp;as Paint Layer...</text>
       <whatsThis></whatsThis>
       <toolTip>as Paint Layer</toolTip>
       <iconText>as Paint Layer</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="import_layer_as_transparency_mask">
       <icon>transparencyMask</icon>
       <text>as &amp;Transparency Mask...</text>
       <whatsThis></whatsThis>
       <toolTip>as Transparency Mask</toolTip>
       <iconText>as Transparency Mask</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="import_layer_as_filter_mask">
       <icon>filterMask</icon>
       <text>as &amp;Filter Mask...</text>
       <whatsThis></whatsThis>
       <toolTip>as Filter Mask</toolTip>
       <iconText>as Filter Mask</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="import_layer_as_selection_mask">
       <icon>selectionMask</icon>
       <text>as &amp;Selection Mask...</text>
       <whatsThis></whatsThis>
       <toolTip>as Selection Mask</toolTip>
       <iconText>as Selection Mask</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="convert_to_paint_layer">
       <icon>paintLayer</icon>
       <text>to &amp;Paint Layer</text>
       <whatsThis></whatsThis>
       <toolTip>to Paint Layer</toolTip>
       <iconText>to Paint Layer</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="convert_to_transparency_mask">
       <icon>transparencyMask</icon>
       <text>to &amp;Transparency Mask</text>
       <whatsThis></whatsThis>
       <toolTip>to Transparency Mask</toolTip>
       <iconText>to Transparency Mask</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="convert_to_filter_mask">
       <icon>filterMask</icon>
       <text>to &amp;Filter Mask...</text>
       <whatsThis></whatsThis>
       <toolTip>to Filter Mask</toolTip>
       <iconText>to Filter Mask</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="convert_to_selection_mask">
       <icon>selectionMask</icon>
       <text>to &amp;Selection Mask</text>
       <whatsThis></whatsThis>
       <toolTip>to Selection Mask</toolTip>
       <iconText>to Selection Mask</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="split_alpha_into_mask">
       <icon>transparencyMask</icon>
       <text>&amp;Alpha into Mask</text>
       <whatsThis></whatsThis>
       <toolTip>Alpha into Mask</toolTip>
       <iconText>Alpha into Mask</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>10</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="split_alpha_write">
       <icon>transparency-enabled</icon>
       <text>&amp;Write as Alpha</text>
       <whatsThis></whatsThis>
       <toolTip>Write as Alpha</toolTip>
       <iconText>Write as Alpha</iconText>
       <activationFlags>1000000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="split_alpha_save_merged">
       <icon>document-save</icon>
       <text>&amp;Save Merged...</text>
       <whatsThis></whatsThis>
       <toolTip>Save Merged</toolTip>
       <iconText>Save Merged</iconText>
       <activationFlags>1000000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="layersplit">
       <icon>split-layer</icon>
       <text>Split Layer...</text>
       <whatsThis></whatsThis>
       <toolTip>Split Layer</toolTip>
       <iconText>Split Layer</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="waveletdecompose">
       <icon></icon>
       <text>Wavelet Decompose ...</text>
       <whatsThis></whatsThis>
       <toolTip>Wavelet Decompose</toolTip>
       <iconText>Wavelet Decompose</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="mirrorNodeX">
       <icon>symmetry-horizontal</icon>
       <text>Mirror Layer Hori&amp;zontally</text>
       <whatsThis></whatsThis>
       <toolTip>Mirror Layer Horizontally</toolTip>
       <iconText>Mirror Layer Horizontally</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="mirrorNodeY">
       <icon>symmetry-vertical</icon>
       <text>Mirror Layer &amp;Vertically</text>
       <whatsThis></whatsThis>
       <toolTip>Mirror Layer Vertically</toolTip>
       <iconText>Mirror Layer Vertically</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="rotatelayer">
       <icon></icon>
       <text>&amp;Rotate Layer...</text>
       <whatsThis></whatsThis>
       <toolTip>Rotate Layer</toolTip>
       <iconText>Rotate Layer</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="rotateLayerCW90">
       <icon>object-rotate-right</icon>
       <text>Rotate &amp;Layer 90° to the Right</text>
       <whatsThis></whatsThis>
       <toolTip>Rotate Layer 90° to the Right</toolTip>
       <iconText>Rotate Layer 90° to the Right</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="rotateLayerCCW90">
       <icon>object-rotate-left</icon>
       <text>Rotate Layer &amp;90° to the Left</text>
       <whatsThis></whatsThis>
       <toolTip>Rotate Layer 90° to the Left</toolTip>
       <iconText>Rotate Layer 90° to the Left</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="rotateLayer180">
       <icon></icon>
       <text>Rotate Layer &amp;180°</text>
       <whatsThis></whatsThis>
       <toolTip>Rotate Layer 180°</toolTip>
       <iconText>Rotate Layer 180°</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="layersize">
       <icon></icon>
       <text>Scale &amp;Layer to new Size...</text>
       <whatsThis></whatsThis>
       <toolTip>Scale Layer to new Size</toolTip>
       <iconText>Scale Layer to new Size</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="shearlayer">
       <icon></icon>
       <text>&amp;Shear Layer...</text>
       <whatsThis></whatsThis>
       <toolTip>Shear Layer</toolTip>
       <iconText>Shear Layer</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="mirrorAllNodesX">
       <icon>symmetry-horizontal</icon>
       <text>Mirror All Layers Hori&amp;zontally</text>
       <whatsThis></whatsThis>
       <toolTip>Mirror All Layers Horizontally</toolTip>
       <iconText>Mirror All Layers Horizontally</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="mirrorAllNodesY">
       <icon>symmetry-vertical</icon>
       <text>Mirror All Layers &amp;Vertically</text>
       <whatsThis></whatsThis>
       <toolTip>Mirror All Layers Vertically</toolTip>
       <iconText>Mirror All Layers Vertically</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="rotateAllLayers">
       <icon></icon>
       <text>&amp;Rotate All Layers...</text>
       <whatsThis></whatsThis>
       <toolTip>Rotate All Layers</toolTip>
       <iconText>Rotate All Layers</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="rotateAllLayersCW90">
       <icon>object-rotate-right</icon>
       <text>Rotate All &amp;Layers 90° to the Right</text>
       <whatsThis></whatsThis>
       <toolTip>Rotate All Layers 90° to the Right</toolTip>
       <iconText>Rotate All Layers 90° to the Right</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="rotateAllLayersCCW90">
       <icon>object-rotate-left</icon>
       <text>Rotate All Layers &amp;90° to the Left</text>
       <whatsThis></whatsThis>
       <toolTip>Rotate All Layers 90° to the Left</toolTip>
       <iconText>Rotate All Layers 90° to the Left</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="rotateAllLayers180">
       <icon></icon>
       <text>Rotate All Layers &amp;180°</text>
       <whatsThis></whatsThis>
       <toolTip>Rotate All Layers 180°</toolTip>
       <iconText>Rotate All Layers 180°</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="scaleAllLayers">
       <icon></icon>
       <text>Scale All &amp;Layers to new Size...</text>
       <whatsThis></whatsThis>
       <toolTip>Scale All Layers to new Size</toolTip>
       <iconText>Scale All Layers to new Size</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="shearAllLayers">
       <icon></icon>
       <text>&amp;Shear All Layers...</text>
       <whatsThis></whatsThis>
       <toolTip>Shear All Layers</toolTip>
       <iconText>Shear All Layers</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="offsetlayer">
       <icon></icon>
       <text>&amp;Offset Layer...</text>
       <whatsThis></whatsThis>
       <toolTip>Offset Layer</toolTip>
       <iconText>Offset Layer</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="clones_array">
       <icon></icon>
       <text>Clones &amp;Array...</text>
       <whatsThis></whatsThis>
       <toolTip>Clones Array</toolTip>
       <iconText>Clones Array</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="EditLayerMetaData">
       <icon></icon>
       <text>&amp;Edit metadata...</text>
       <whatsThis></whatsThis>
       <toolTip>Edit metadata</toolTip>
       <iconText>Edit metadata</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="histogram">
       <icon></icon>
       <text>&amp;Histogram...</text>
       <whatsThis></whatsThis>
       <toolTip>Histogram</toolTip>
       <iconText>Histogram</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="layercolorspaceconversion">
       <icon></icon>
       <text>&amp;Convert Layer Color Space...</text>
       <whatsThis></whatsThis>
       <toolTip>Convert Layer Color Space</toolTip>
       <iconText>Convert Layer Color Space</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="merge_layer">
       <icon>merge-layer-below</icon>
       <text>&amp;Merge with Layer Below</text>
       <whatsThis></whatsThis>
       <toolTip>Merge with Layer Below</toolTip>
       <iconText>Merge with Layer Below</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+E</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="flatten_layer">
       <icon></icon>
       <text>&amp;Flatten Layer</text>
       <whatsThis></whatsThis>
       <toolTip>Flatten Layer</toolTip>
       <iconText>Flatten Layer</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="rasterize_layer">
       <icon></icon>
       <text>Ras&amp;terize Layer</text>
       <whatsThis></whatsThis>
       <toolTip>Rasterize Layer</toolTip>
       <iconText>Rasterize Layer</iconText>
       <activationFlags>10000000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="flatten_image">
       <icon></icon>
       <text>Flatten ima&amp;ge</text>
       <whatsThis></whatsThis>
       <toolTip>Flatten image</toolTip>
       <iconText>Flatten image</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>Ctrl+Shift+E</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="layer_style">
       <icon></icon>
       <text>La&amp;yer Style...</text>
       <whatsThis></whatsThis>
       <toolTip>Layer Style</toolTip>
       <iconText>Layer Style</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="LayerGroupSwitcher/previous">
       <icon></icon>
       <text>Move into previous group</text>
       <whatsThis></whatsThis>
       <toolTip>Move into previous group</toolTip>
       <iconText>Move into previous group</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="LayerGroupSwitcher/next">
       <icon></icon>
       <text>Move into next group</text>
       <whatsThis></whatsThis>
       <toolTip>Move into next group</toolTip>
       <iconText>Move into next group</iconText>
       <activationFlags>0</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="RenameCurrentLayer">
       <icon></icon>
       <text>Rename current layer</text>
       <whatsThis></whatsThis>
       <toolTip>Rename current layer</toolTip>
       <iconText>Rename current layer</iconText>
       <activationFlags>100000</activationFlags>
       <activationConditions>0</activationConditions>
       <shortcut>F2</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="remove_layer">
       <icon>deletelayer</icon>
       <text>&amp;Remove Layer</text>
       <whatsThis></whatsThis>
       <toolTip>Remove Layer</toolTip>
       <iconText>Remove Layer</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut>Shift+Delete</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="move_layer_up">
       <icon>arrowupblr</icon>
       <text>Move Layer or Mask Up</text>
       <whatsThis></whatsThis>
       <toolTip>Move Layer or Mask Up</toolTip>
       <iconText></iconText>
       <shortcut>Ctrl+PgUp</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="move_layer_down">
       <icon>arrowdown</icon>
       <text>Move Layer or Mask Down</text>
       <whatsThis></whatsThis>
       <toolTip>Move Layer or Mask Down</toolTip>
       <iconText></iconText>
       <shortcut>Ctrl+PgDown</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="layer_properties">
       <icon>properties</icon>
       <text>&amp;Properties...</text>
       <whatsThis></whatsThis>
       <toolTip>Properties</toolTip>
       <iconText>Properties</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut>F3</shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
     <Action name="set-copy-from">
       <icon></icon>
       <text>Set Copy F&amp;rom...</text>
       <whatsThis></whatsThis>
       <toolTip>Set the source for the selected clone layer(s).</toolTip>
       <iconText>Set Copy From</iconText>
       <activationFlags>1000</activationFlags>
       <activationConditions>1</activationConditions>
       <shortcut></shortcut>
       <isCheckable>false</isCheckable>
       <statusTip></statusTip>
     </Action>
   </Actions>
 </ActionCollection>
diff --git a/libs/flake/KoDrag.cpp b/libs/flake/KoDrag.cpp
index e77a3d10da..5b4a68246b 100644
--- a/libs/flake/KoDrag.cpp
+++ b/libs/flake/KoDrag.cpp
@@ -1,128 +1,128 @@
 /* This file is part of the KDE project
  * Copyright (C) 2007-2008 Thorsten Zachmann <zachmann@kde.org>
  * Copyright (C) 2009 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 "KoDrag.h"
 #include "KoDragOdfSaveHelper.h"
 
 #include <QApplication>
 #include <QBuffer>
 #include <QByteArray>
 #include <QClipboard>
 #include <QMimeData>
 #include <QString>
 #include <QTransform>
 
 #include <FlakeDebug.h>
 
 #include <KoStore.h>
 #include <KoGenStyles.h>
 #include <KoOdfWriteStore.h>
 #include <KoXmlWriter.h>
 #include <KoDocumentBase.h>
 #include <KoEmbeddedDocumentSaver.h>
 #include "KoShapeSavingContext.h"
 
 #include <KoShapeContainer.h>
 #include <KoShape.h>
 
 #include <QRect>
 #include <SvgWriter.h>
 
 
 class KoDragPrivate {
 public:
     KoDragPrivate() : mimeData(0) { }
     ~KoDragPrivate() { delete mimeData; }
     QMimeData *mimeData;
 };
 
 KoDrag::KoDrag()
     : d(new KoDragPrivate())
 {
 }
 
 KoDrag::~KoDrag()
 {
     delete d;
 }
 
 bool KoDrag::setSvg(const QList<KoShape *> originalShapes)
 {
     QRectF boundingRect;
     QList<KoShape*> shapes;
 
     Q_FOREACH (KoShape *shape, originalShapes) {
         boundingRect |= shape->boundingRect();
 
         KoShape *clonedShape = shape->cloneShape();
 
         /**
          * The shape is cloned without its parent's transformation, so we should
          * adjust it manually.
          */
         KoShape *oldParentShape = shape->parent();
         if (oldParentShape) {
-            clonedShape->applyTransformation(oldParentShape->absoluteTransformation());
+            clonedShape->applyAbsoluteTransformation(oldParentShape->absoluteTransformation());
         }
 
         shapes.append(clonedShape);
     }
 
     std::sort(shapes.begin(), shapes.end(), KoShape::compareShapeZIndex);
 
     QBuffer buffer;
     QLatin1String mimeType("image/svg+xml");
 
     buffer.open(QIODevice::WriteOnly);
 
     const QSizeF pageSize(boundingRect.right(), boundingRect.bottom());
     SvgWriter writer(shapes);
     writer.save(buffer, pageSize);
 
     buffer.close();
 
     qDeleteAll(shapes);
 
     setData(mimeType, buffer.data());
     return true;
 }
 
 void KoDrag::setData(const QString &mimeType, const QByteArray &data)
 {
     if (d->mimeData == 0) {
         d->mimeData = new QMimeData();
     }
     d->mimeData->setData(mimeType, data);
 }
 
 void KoDrag::addToClipboard()
 {
     if (d->mimeData) {
         QApplication::clipboard()->setMimeData(d->mimeData);
         d->mimeData = 0;
     }
 }
 
 QMimeData * KoDrag::mimeData()
 {
     QMimeData *mimeData = d->mimeData;
     d->mimeData = 0;
     return mimeData;
 }
diff --git a/libs/image/kis_image.cc b/libs/image/kis_image.cc
index 511486f73a..87ee57086b 100644
--- a/libs/image/kis_image.cc
+++ b/libs/image/kis_image.cc
@@ -1,2273 +1,2280 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2007 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_image.h"
 
 #include <KoConfig.h> // WORDS_BIGENDIAN
 
 #include <stdlib.h>
 #include <math.h>
 
 #include <QImage>
 #include <QPainter>
 #include <QSize>
 #include <QDateTime>
 #include <QRect>
 #include <QtConcurrent>
 
 #include <klocalizedstring.h>
 
 #include "KoColorSpaceRegistry.h"
 #include "KoColor.h"
 #include "KoColorProfile.h"
 #include <KoCompositeOpRegistry.h>
 #include "KisProofingConfiguration.h"
 
 #include "kis_adjustment_layer.h"
 #include "kis_annotation.h"
 #include "kis_count_visitor.h"
 #include "kis_filter_strategy.h"
 #include "kis_group_layer.h"
 #include "commands/kis_image_commands.h"
 #include "kis_layer.h"
 #include "kis_meta_data_merge_strategy_registry.h"
 #include "kis_name_server.h"
 #include "kis_paint_layer.h"
 #include "kis_projection_leaf.h"
 #include "kis_painter.h"
 #include "kis_selection.h"
 #include "kis_transaction.h"
 #include "kis_meta_data_merge_strategy.h"
 #include "kis_memory_statistics_server.h"
 
 #include "kis_image_config.h"
 #include "kis_update_scheduler.h"
 #include "kis_image_signal_router.h"
 #include "kis_image_animation_interface.h"
 #include "kis_stroke_strategy.h"
 #include "kis_simple_stroke_strategy.h"
 #include "kis_image_barrier_locker.h"
 
 
 #include "kis_undo_stores.h"
 #include "kis_legacy_undo_adapter.h"
 #include "kis_post_execution_undo_adapter.h"
 
 #include "kis_transform_worker.h"
 #include "kis_processing_applicator.h"
 #include "processing/kis_crop_processing_visitor.h"
 #include "processing/kis_crop_selections_processing_visitor.h"
 #include "processing/kis_transform_processing_visitor.h"
 #include "processing/kis_convert_color_space_processing_visitor.h"
 #include "processing/kis_assign_profile_processing_visitor.h"
 #include "commands_new/kis_image_resize_command.h"
 #include "commands_new/kis_image_set_resolution_command.h"
 #include "commands_new/kis_activate_selection_mask_command.h"
 #include "kis_do_something_command.h"
 #include "kis_composite_progress_proxy.h"
 #include "kis_layer_composition.h"
 #include "kis_wrapped_rect.h"
 #include "kis_crop_saved_extra_data.h"
 #include "kis_layer_utils.h"
 
 #include "kis_lod_transform.h"
 
 #include "kis_suspend_projection_updates_stroke_strategy.h"
 #include "kis_sync_lod_cache_stroke_strategy.h"
 
 #include "kis_projection_updates_filter.h"
 
 #include "kis_layer_projection_plane.h"
 
 #include "kis_update_time_monitor.h"
 #include "tiles3/kis_lockless_stack.h"
 
 #include <QtCore>
 
 #include <functional>
 
 #include "kis_time_range.h"
 
 #include "KisRunnableBasedStrokeStrategy.h"
 #include "KisRunnableStrokeJobData.h"
 #include "KisRunnableStrokeJobUtils.h"
 #include "KisRunnableStrokeJobsInterface.h"
 
 #include "KisBusyWaitBroker.h"
 
 
 // #define SANITY_CHECKS
 
 #ifdef SANITY_CHECKS
 #define SANITY_CHECK_LOCKED(name)                                       \
     if (!locked()) warnKrita() << "Locking policy failed:" << name          \
                                << "has been called without the image"       \
                                   "being locked";
 #else
 #define SANITY_CHECK_LOCKED(name)
 #endif
 
 
 struct KisImageSPStaticRegistrar {
     KisImageSPStaticRegistrar() {
         qRegisterMetaType<KisImageSP>("KisImageSP");
     }
 };
 static KisImageSPStaticRegistrar __registrar;
 
 class KisImage::KisImagePrivate
 {
 public:
     KisImagePrivate(KisImage *_q, qint32 w, qint32 h,
                     const KoColorSpace *c,
                     KisUndoStore *undo,
                     KisImageAnimationInterface *_animationInterface)
         : q(_q)
         , lockedForReadOnly(false)
         , width(w)
         , height(h)
         , colorSpace(c ? c : KoColorSpaceRegistry::instance()->rgb8())
         , nserver(1)
         , undoStore(undo ? undo : new KisDumbUndoStore())
         , legacyUndoAdapter(undoStore.data(), _q)
         , postExecutionUndoAdapter(undoStore.data(), _q)
         , signalRouter(_q)
         , animationInterface(_animationInterface)
         , scheduler(_q, _q)
         , axesCenter(QPointF(0.5, 0.5))
     {
         {
             KisImageConfig cfg(true);
             if (cfg.enableProgressReporting()) {
                 scheduler.setProgressProxy(&compositeProgressProxy);
             }
 
             // Each of these lambdas defines a new factory function.
             scheduler.setLod0ToNStrokeStrategyFactory(
                 [=](bool forgettable) {
                     return KisLodSyncPair(
                         new KisSyncLodCacheStrokeStrategy(KisImageWSP(q), forgettable),
                         KisSyncLodCacheStrokeStrategy::createJobsData(KisImageWSP(q)));
                 });
 
             scheduler.setSuspendResumeUpdatesStrokeStrategyFactory(
                 [=]() {
                     KisSuspendProjectionUpdatesStrokeStrategy::SharedDataSP data = KisSuspendProjectionUpdatesStrokeStrategy::createSharedData();
 
                     KisSuspendResumePair suspend(new KisSuspendProjectionUpdatesStrokeStrategy(KisImageWSP(q), true, data),
                                                  KisSuspendProjectionUpdatesStrokeStrategy::createSuspendJobsData(KisImageWSP(q)));
                     KisSuspendResumePair resume(new KisSuspendProjectionUpdatesStrokeStrategy(KisImageWSP(q), false, data),
                                                 KisSuspendProjectionUpdatesStrokeStrategy::createResumeJobsData(KisImageWSP(q)));
 
                     return std::make_pair(suspend, resume);
                 });
         }
 
         connect(q, SIGNAL(sigImageModified()), KisMemoryStatisticsServer::instance(), SLOT(notifyImageChanged()));
     }
 
     ~KisImagePrivate() {
         /**
          * Stop animation interface. It may use the rootLayer.
          */
         delete animationInterface;
 
         /**
          * First delete the nodes, while strokes
          * and undo are still alive
          */
         rootLayer.clear();
     }
 
     KisImage *q;
 
     quint32 lockCount = 0;
     bool lockedForReadOnly;
 
     qint32 width;
     qint32 height;
 
     double xres = 1.0;
     double yres = 1.0;
 
     const KoColorSpace * colorSpace;
     KisProofingConfigurationSP proofingConfig;
 
     KisSelectionSP deselectedGlobalSelection;
     KisGroupLayerSP rootLayer; // The layers are contained in here
     KisSelectionMaskSP targetOverlaySelectionMask; // the overlay switching stroke will try to switch into this mask
     KisSelectionMaskSP overlaySelectionMask;
     QList<KisLayerCompositionSP> compositions;
     KisNodeSP isolatedRootNode;
     bool wrapAroundModePermitted = false;
 
     KisNameServer nserver;
 
     QScopedPointer<KisUndoStore> undoStore;
     KisLegacyUndoAdapter legacyUndoAdapter;
     KisPostExecutionUndoAdapter postExecutionUndoAdapter;
 
     vKisAnnotationSP annotations;
 
     QAtomicInt disableUIUpdateSignals;
     KisLocklessStack<QRect> savedDisabledUIUpdates;
 
     // filters are applied in a reversed way, from rbegin() to rend()
     QVector<KisProjectionUpdatesFilterSP> projectionUpdatesFilters;
     QStack<KisProjectionUpdatesFilterCookie> disabledUpdatesCookies;
     KisImageSignalRouter signalRouter;
     KisImageAnimationInterface *animationInterface;
     KisUpdateScheduler scheduler;
     QAtomicInt disableDirtyRequests;
 
 
     KisCompositeProgressProxy compositeProgressProxy;
 
     bool blockLevelOfDetail = false;
 
     QPointF axesCenter;
     bool allowMasksOnRootNode = false;
 
     bool tryCancelCurrentStrokeAsync();
 
     void notifyProjectionUpdatedInPatches(const QRect &rc, QVector<KisRunnableStrokeJobData *> &jobs);
 
     void convertImageColorSpaceImpl(const KoColorSpace *dstColorSpace,
                                     bool convertLayers,
                                     KoColorConversionTransformation::Intent renderingIntent,
                                     KoColorConversionTransformation::ConversionFlags conversionFlags);
 
     struct SetImageProjectionColorSpace;
 };
 
 KisImage::KisImage(KisUndoStore *undoStore, qint32 width, qint32 height, const KoColorSpace * colorSpace, const QString& name)
         : QObject(0)
         , KisShared()
         , m_d(new KisImagePrivate(this, width, height,
                                   colorSpace, undoStore,
                                   new KisImageAnimationInterface(this)))
 {
     // make sure KisImage belongs to the GUI thread
     moveToThread(qApp->thread());
     connect(this, SIGNAL(sigInternalStopIsolatedModeRequested()), SLOT(stopIsolatedMode()));
 
     setObjectName(name);
     setRootLayer(new KisGroupLayer(this, "root", OPACITY_OPAQUE_U8));
 }
 
 KisImage::~KisImage()
 {
     dbgImage << "deleting kisimage" << objectName();
 
     /**
      * Request the tools to end currently running strokes
      */
     waitForDone();
 
     delete m_d;
     disconnect(); // in case Qt gets confused
 }
 
 KisImageSP KisImage::fromQImage(const QImage &image, KisUndoStore *undoStore)
 {
     const KoColorSpace *colorSpace = 0;
 
     switch (image.format()) {
     case QImage::Format_Invalid:
     case QImage::Format_Mono:
     case QImage::Format_MonoLSB:
         colorSpace = KoColorSpaceRegistry::instance()->graya8();
         break;
     case QImage::Format_Indexed8:
     case QImage::Format_RGB32:
     case QImage::Format_ARGB32:
     case QImage::Format_ARGB32_Premultiplied:
         colorSpace = KoColorSpaceRegistry::instance()->rgb8();
         break;
     case QImage::Format_RGB16:
         colorSpace = KoColorSpaceRegistry::instance()->rgb16();
         break;
     case QImage::Format_ARGB8565_Premultiplied:
     case QImage::Format_RGB666:
     case QImage::Format_ARGB6666_Premultiplied:
     case QImage::Format_RGB555:
     case QImage::Format_ARGB8555_Premultiplied:
     case QImage::Format_RGB888:
     case QImage::Format_RGB444:
     case QImage::Format_ARGB4444_Premultiplied:
     case QImage::Format_RGBX8888:
     case QImage::Format_RGBA8888:
     case QImage::Format_RGBA8888_Premultiplied:
         colorSpace = KoColorSpaceRegistry::instance()->rgb8();
         break;
     case QImage::Format_BGR30:
     case QImage::Format_A2BGR30_Premultiplied:
     case QImage::Format_RGB30:
     case QImage::Format_A2RGB30_Premultiplied:
         colorSpace = KoColorSpaceRegistry::instance()->rgb8();
         break;
     case QImage::Format_Alpha8:
         colorSpace = KoColorSpaceRegistry::instance()->alpha8();
         break;
     case QImage::Format_Grayscale8:
         colorSpace = KoColorSpaceRegistry::instance()->graya8();
         break;
 #if QT_VERSION >= QT_VERSION_CHECK(5, 13, 0)
     case QImage::Format_Grayscale16:
         colorSpace = KoColorSpaceRegistry::instance()->graya16();
         break;
 #endif
 #if QT_VERSION >= QT_VERSION_CHECK(5, 12, 0)
     case QImage::Format_RGBX64:
     case QImage::Format_RGBA64:
     case QImage::Format_RGBA64_Premultiplied:
         colorSpace = KoColorSpaceRegistry::instance()->colorSpace(RGBAColorModelID.id(), Float32BitsColorDepthID.id(), 0);
         break;
 #endif
     default:
         colorSpace = 0;
     }
 
     KisImageSP img = new KisImage(undoStore, image.width(), image.height(), colorSpace, i18n("Imported Image"));
     KisPaintLayerSP layer = new KisPaintLayer(img, img->nextLayerName(), 255);
     layer->paintDevice()->convertFromQImage(image, 0, 0, 0);
     img->addNode(layer.data(), img->rootLayer().data());
 
     return img;
 }
 
 KisImage *KisImage::clone(bool exactCopy)
 {
     return new KisImage(*this, 0, exactCopy);
 }
 
 void KisImage::copyFromImage(const KisImage &rhs)
 {
     copyFromImageImpl(rhs, REPLACE);
 }
 
 void KisImage::copyFromImageImpl(const KisImage &rhs, int policy)
 {
     // make sure we choose exactly one from REPLACE and CONSTRUCT
     KIS_ASSERT_RECOVER_RETURN((policy & REPLACE) != (policy & CONSTRUCT));
 
     // only when replacing do we need to emit signals
 #define EMIT_IF_NEEDED if (!(policy & REPLACE)) {} else emit
 
     if (policy & REPLACE) { // if we are constructing the image, these are already set
         if (m_d->width != rhs.width() || m_d->height != rhs.height()) {
             m_d->width = rhs.width();
             m_d->height = rhs.height();
             emit sigSizeChanged(QPointF(), QPointF());
         }
         if (m_d->colorSpace != rhs.colorSpace()) {
             m_d->colorSpace = rhs.colorSpace();
             emit sigColorSpaceChanged(m_d->colorSpace);
         }
     }
 
     // from KisImage::KisImage(const KisImage &, KisUndoStore *, bool)
     setObjectName(rhs.objectName());
 
     if (m_d->xres != rhs.m_d->xres || m_d->yres != rhs.m_d->yres) {
         m_d->xres = rhs.m_d->xres;
         m_d->yres = rhs.m_d->yres;
         EMIT_IF_NEEDED sigResolutionChanged(m_d->xres, m_d->yres);
     }
 
     m_d->allowMasksOnRootNode = rhs.m_d->allowMasksOnRootNode;
 
     if (rhs.m_d->proofingConfig) {
         KisProofingConfigurationSP proofingConfig(new KisProofingConfiguration(*rhs.m_d->proofingConfig));
         if (policy & REPLACE) {
             setProofingConfiguration(proofingConfig);
         } else {
             m_d->proofingConfig = proofingConfig;
         }
     }
 
     KisNodeSP newRoot = rhs.root()->clone();
     newRoot->setGraphListener(this);
     newRoot->setImage(this);
     m_d->rootLayer = dynamic_cast<KisGroupLayer*>(newRoot.data());
     setRoot(newRoot);
 
     bool exactCopy = policy & EXACT_COPY;
 
     if (exactCopy || rhs.m_d->isolatedRootNode || rhs.m_d->overlaySelectionMask) {
         QQueue<KisNodeSP> linearizedNodes;
         KisLayerUtils::recursiveApplyNodes(rhs.root(),
                                            [&linearizedNodes](KisNodeSP node) {
                                                linearizedNodes.enqueue(node);
                                            });
         KisLayerUtils::recursiveApplyNodes(newRoot,
                                            [&linearizedNodes, exactCopy, &rhs, this](KisNodeSP node) {
                                                KisNodeSP refNode = linearizedNodes.dequeue();
 
                                                if (exactCopy) {
                                                    node->setUuid(refNode->uuid());
                                                }
 
                                                if (rhs.m_d->isolatedRootNode &&
                                                    rhs.m_d->isolatedRootNode == refNode) {
                                                    m_d->isolatedRootNode = node;
                                                }
 
                                                if (rhs.m_d->overlaySelectionMask &&
                                                    KisNodeSP(rhs.m_d->overlaySelectionMask) == refNode) {
                                                    m_d->targetOverlaySelectionMask = dynamic_cast<KisSelectionMask*>(node.data());
                                                    m_d->overlaySelectionMask = m_d->targetOverlaySelectionMask;
                                                    m_d->rootLayer->notifyChildMaskChanged();
                                                }
                                            });
     }
 
     KisLayerUtils::recursiveApplyNodes(newRoot,
                                        [](KisNodeSP node) {
                                            dbgImage << "Node: " << (void *)node.data();
                                        });
 
     m_d->compositions.clear();
 
     Q_FOREACH (KisLayerCompositionSP comp, rhs.m_d->compositions) {
         m_d->compositions << toQShared(new KisLayerComposition(*comp, this));
     }
 
     EMIT_IF_NEEDED sigLayersChangedAsync();
 
     m_d->nserver = rhs.m_d->nserver;
 
     vKisAnnotationSP newAnnotations;
     Q_FOREACH (KisAnnotationSP annotation, rhs.m_d->annotations) {
         newAnnotations << annotation->clone();
     }
     m_d->annotations = newAnnotations;
 
     KIS_ASSERT_RECOVER_NOOP(rhs.m_d->projectionUpdatesFilters.isEmpty());
     KIS_ASSERT_RECOVER_NOOP(!rhs.m_d->disableUIUpdateSignals);
     KIS_ASSERT_RECOVER_NOOP(!rhs.m_d->disableDirtyRequests);
 
     m_d->blockLevelOfDetail = rhs.m_d->blockLevelOfDetail;
 
 #undef EMIT_IF_NEEDED
 }
 
 KisImage::KisImage(const KisImage& rhs, KisUndoStore *undoStore, bool exactCopy)
     : KisNodeFacade(),
       KisNodeGraphListener(),
       KisShared(),
       m_d(new KisImagePrivate(this,
                               rhs.width(), rhs.height(),
                               rhs.colorSpace(),
                               undoStore ? undoStore : new KisDumbUndoStore(),
                               new KisImageAnimationInterface(*rhs.animationInterface(), this)))
 {
     // make sure KisImage belongs to the GUI thread
     moveToThread(qApp->thread());
     connect(this, SIGNAL(sigInternalStopIsolatedModeRequested()), SLOT(stopIsolatedMode()));
 
     copyFromImageImpl(rhs, CONSTRUCT | (exactCopy ? EXACT_COPY : 0));
 }
 
 void KisImage::aboutToAddANode(KisNode *parent, int index)
 {
     KisNodeGraphListener::aboutToAddANode(parent, index);
     SANITY_CHECK_LOCKED("aboutToAddANode");
 }
 
 void KisImage::nodeHasBeenAdded(KisNode *parent, int index)
 {
     KisNodeGraphListener::nodeHasBeenAdded(parent, index);
 
     SANITY_CHECK_LOCKED("nodeHasBeenAdded");
     m_d->signalRouter.emitNodeHasBeenAdded(parent, index);
 }
 
 void KisImage::aboutToRemoveANode(KisNode *parent, int index)
 {
     KisNodeSP deletedNode = parent->at(index);
     if (!dynamic_cast<KisSelectionMask*>(deletedNode.data()) &&
         deletedNode == m_d->isolatedRootNode) {
 
         emit sigInternalStopIsolatedModeRequested();
     }
 
     KisNodeGraphListener::aboutToRemoveANode(parent, index);
 
     SANITY_CHECK_LOCKED("aboutToRemoveANode");
     m_d->signalRouter.emitAboutToRemoveANode(parent, index);
 }
 
 void KisImage::nodeChanged(KisNode* node)
 {
     KisNodeGraphListener::nodeChanged(node);
     requestStrokeEnd();
     m_d->signalRouter.emitNodeChanged(node);
 }
 
 void KisImage::invalidateAllFrames()
 {
     invalidateFrames(KisTimeRange::infinite(0), QRect());
 }
 
 void KisImage::setOverlaySelectionMask(KisSelectionMaskSP mask)
 {
     if (m_d->targetOverlaySelectionMask == mask) return;
 
     m_d->targetOverlaySelectionMask = mask;
 
     struct UpdateOverlaySelectionStroke : public KisSimpleStrokeStrategy {
         UpdateOverlaySelectionStroke(KisImageSP image)
             : KisSimpleStrokeStrategy(QLatin1String("update-overlay-selection-mask"), kundo2_noi18n("update-overlay-selection-mask")),
               m_image(image)
         {
             this->enableJob(JOB_INIT, true, KisStrokeJobData::BARRIER, KisStrokeJobData::EXCLUSIVE);
             setClearsRedoOnStart(false);
         }
 
         void initStrokeCallback() {
             KisSelectionMaskSP oldMask = m_image->m_d->overlaySelectionMask;
             KisSelectionMaskSP newMask = m_image->m_d->targetOverlaySelectionMask;
             if (oldMask == newMask) return;
 
             KIS_SAFE_ASSERT_RECOVER_RETURN(!newMask || newMask->graphListener() == m_image);
 
             m_image->m_d->overlaySelectionMask = newMask;
 
             if (oldMask || newMask) {
                 m_image->m_d->rootLayer->notifyChildMaskChanged();
             }
 
             if (oldMask) {
                 m_image->m_d->rootLayer->setDirtyDontResetAnimationCache(oldMask->extent());
             }
 
             if (newMask) {
                 newMask->setDirty();
             }
 
             m_image->undoAdapter()->emitSelectionChanged();
         }
 
     private:
         KisImageSP m_image;
     };
 
     KisStrokeId id = startStroke(new UpdateOverlaySelectionStroke(this));
     endStroke(id);
 }
 
 KisSelectionMaskSP KisImage::overlaySelectionMask() const
 {
     return m_d->overlaySelectionMask;
 }
 
 bool KisImage::hasOverlaySelectionMask() const
 {
     return m_d->overlaySelectionMask;
 }
 
 KisSelectionSP KisImage::globalSelection() const
 {
     KisSelectionMaskSP selectionMask = m_d->rootLayer->selectionMask();
     if (selectionMask) {
         return selectionMask->selection();
     } else {
         return 0;
     }
 }
 
 void KisImage::setGlobalSelection(KisSelectionSP globalSelection)
 {
     KisSelectionMaskSP selectionMask = m_d->rootLayer->selectionMask();
 
     if (!globalSelection) {
         if (selectionMask) {
             removeNode(selectionMask);
         }
     }
     else {
         if (!selectionMask) {
             selectionMask = new KisSelectionMask(this);
             selectionMask->initSelection(m_d->rootLayer);
             addNode(selectionMask);
             // If we do not set the selection now, the setActive call coming next
             // can be very, very expensive, depending on the size of the image.
             selectionMask->setSelection(globalSelection);
             selectionMask->setActive(true);
         }
         else {
             selectionMask->setSelection(globalSelection);
         }
 
         KIS_SAFE_ASSERT_RECOVER_NOOP(m_d->rootLayer->childCount() > 0);
         KIS_SAFE_ASSERT_RECOVER_NOOP(m_d->rootLayer->selectionMask());
     }
 
     m_d->deselectedGlobalSelection = 0;
     m_d->legacyUndoAdapter.emitSelectionChanged();
 }
 
 void KisImage::deselectGlobalSelection()
 {
     KisSelectionSP savedSelection = globalSelection();
     setGlobalSelection(0);
     m_d->deselectedGlobalSelection = savedSelection;
 }
 
 bool KisImage::canReselectGlobalSelection()
 {
     return m_d->deselectedGlobalSelection;
 }
 
 void KisImage::reselectGlobalSelection()
 {
     if(m_d->deselectedGlobalSelection) {
         setGlobalSelection(m_d->deselectedGlobalSelection);
     }
 }
 
 QString KisImage::nextLayerName(const QString &_baseName) const
 {
     QString baseName = _baseName;
 
     if (m_d->nserver.currentSeed() == 0) {
         m_d->nserver.number();
         return i18n("background");
     }
 
     if (baseName.isEmpty()) {
         baseName = i18n("Layer");
     }
 
     return QString("%1 %2").arg(baseName).arg(m_d->nserver.number());
 }
 
 void KisImage::rollBackLayerName()
 {
     m_d->nserver.rollback();
 }
 
 KisCompositeProgressProxy* KisImage::compositeProgressProxy()
 {
     return &m_d->compositeProgressProxy;
 }
 
 bool KisImage::locked() const
 {
     return m_d->lockCount != 0;
 }
 
 void KisImage::barrierLock(bool readOnly)
 {
     if (!locked()) {
         requestStrokeEnd();
         KisBusyWaitBroker::instance()->notifyWaitOnImageStarted(this);
         m_d->scheduler.barrierLock();
         KisBusyWaitBroker::instance()->notifyWaitOnImageEnded(this);
         m_d->lockedForReadOnly = readOnly;
     } else {
         m_d->lockedForReadOnly &= readOnly;
     }
 
     m_d->lockCount++;
 }
 
 bool KisImage::tryBarrierLock(bool readOnly)
 {
     bool result = true;
 
     if (!locked()) {
         result = m_d->scheduler.tryBarrierLock();
         m_d->lockedForReadOnly = readOnly;
     }
 
     if (result) {
         m_d->lockCount++;
         m_d->lockedForReadOnly &= readOnly;
     }
 
     return result;
 }
 
 bool KisImage::isIdle(bool allowLocked)
 {
     return (allowLocked || !locked()) && m_d->scheduler.isIdle();
 }
 
 void KisImage::lock()
 {
     if (!locked()) {
         requestStrokeEnd();
         KisBusyWaitBroker::instance()->notifyWaitOnImageStarted(this);
         m_d->scheduler.lock();
         KisBusyWaitBroker::instance()->notifyWaitOnImageEnded(this);
     }
     m_d->lockCount++;
     m_d->lockedForReadOnly = false;
 }
 
 void KisImage::unlock()
 {
     Q_ASSERT(locked());
 
     if (locked()) {
         m_d->lockCount--;
 
         if (m_d->lockCount == 0) {
             m_d->scheduler.unlock(!m_d->lockedForReadOnly);
         }
     }
 }
 
 void KisImage::blockUpdates()
 {
     m_d->scheduler.blockUpdates();
 }
 
 void KisImage::unblockUpdates()
 {
     m_d->scheduler.unblockUpdates();
 }
 
 void KisImage::setSize(const QSize& size)
 {
     m_d->width = size.width();
     m_d->height = size.height();
 }
 
 void KisImage::resizeImageImpl(const QRect& newRect, bool cropLayers)
 {
     if (newRect == bounds() && !cropLayers) return;
 
     KUndo2MagicString actionName = cropLayers ?
         kundo2_i18n("Crop Image") :
         kundo2_i18n("Resize Image");
 
     KisImageSignalVector emitSignals;
     emitSignals << ComplexSizeChangedSignal(newRect, newRect.size());
     emitSignals << ModifiedSignal;
 
     KisCropSavedExtraData *extraData =
         new KisCropSavedExtraData(cropLayers ?
                                   KisCropSavedExtraData::CROP_IMAGE :
                                   KisCropSavedExtraData::RESIZE_IMAGE,
                                   newRect);
 
     KisProcessingApplicator applicator(this, m_d->rootLayer,
                                        KisProcessingApplicator::RECURSIVE |
                                        KisProcessingApplicator::NO_UI_UPDATES,
                                        emitSignals, actionName, extraData);
 
     if (cropLayers || !newRect.topLeft().isNull()) {
         KisProcessingVisitorSP visitor =
             new KisCropProcessingVisitor(newRect, cropLayers, true);
         applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
     }
     applicator.applyCommand(new KisImageResizeCommand(this, newRect.size()));
     applicator.end();
 }
 
 void KisImage::resizeImage(const QRect& newRect)
 {
     resizeImageImpl(newRect, false);
 }
 
 void KisImage::cropImage(const QRect& newRect)
 {
     resizeImageImpl(newRect, true);
 }
 
 
 void KisImage::cropNode(KisNodeSP node, const QRect& newRect)
 {
     bool isLayer = qobject_cast<KisLayer*>(node.data());
     KUndo2MagicString actionName = isLayer ?
         kundo2_i18n("Crop Layer") :
         kundo2_i18n("Crop Mask");
 
     KisImageSignalVector emitSignals;
     emitSignals << ModifiedSignal;
 
     KisCropSavedExtraData *extraData =
         new KisCropSavedExtraData(KisCropSavedExtraData::CROP_LAYER,
                                   newRect, node);
 
     KisProcessingApplicator applicator(this, node,
                                        KisProcessingApplicator::RECURSIVE,
                                        emitSignals, actionName, extraData);
 
     KisProcessingVisitorSP visitor =
         new KisCropProcessingVisitor(newRect, true, false);
     applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
     applicator.end();
 }
 
 void KisImage::scaleImage(const QSize &size, qreal xres, qreal yres, KisFilterStrategy *filterStrategy)
 {
     bool resolutionChanged = xres != xRes() && yres != yRes();
     bool sizeChanged = size != this->size();
 
     if (!resolutionChanged && !sizeChanged) return;
 
     KisImageSignalVector emitSignals;
     if (resolutionChanged) emitSignals << ResolutionChangedSignal;
     if (sizeChanged) emitSignals << ComplexSizeChangedSignal(bounds(), size);
     emitSignals << ModifiedSignal;
 
     KUndo2MagicString actionName = sizeChanged ?
         kundo2_i18n("Scale Image") :
         kundo2_i18n("Change Image Resolution");
 
     KisProcessingApplicator::ProcessingFlags signalFlags =
         (resolutionChanged || sizeChanged) ?
                 KisProcessingApplicator::NO_UI_UPDATES :
                 KisProcessingApplicator::NONE;
 
     KisProcessingApplicator applicator(this, m_d->rootLayer,
                                        KisProcessingApplicator::RECURSIVE | signalFlags,
                                        emitSignals, actionName);
 
     qreal sx = qreal(size.width()) / this->size().width();
     qreal sy = qreal(size.height()) / this->size().height();
 
     QTransform shapesCorrection;
 
     if (resolutionChanged) {
         shapesCorrection = QTransform::fromScale(xRes() / xres, yRes() / yres);
     }
 
     KisProcessingVisitorSP visitor =
         new KisTransformProcessingVisitor(sx, sy,
                                           0, 0,
                                           QPointF(),
                                           0,
                                           0, 0,
                                           filterStrategy,
                                           shapesCorrection);
 
     applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
 
     if (resolutionChanged) {
         KUndo2Command *parent =
             new KisResetShapesCommand(m_d->rootLayer);
         new KisImageSetResolutionCommand(this, xres, yres, parent);
         applicator.applyCommand(parent);
     }
 
     if (sizeChanged) {
         applicator.applyCommand(new KisImageResizeCommand(this, size));
     }
 
     applicator.end();
 }
 
 void KisImage::scaleNode(KisNodeSP node, const QPointF &center, qreal scaleX, qreal scaleY, KisFilterStrategy *filterStrategy, KisSelectionSP selection)
 {
     KUndo2MagicString actionName(kundo2_i18n("Scale Layer"));
     KisImageSignalVector emitSignals;
     emitSignals << ModifiedSignal;
 
     QPointF offset;
     {
         KisTransformWorker worker(0,
                                   scaleX, scaleY,
                                   0, 0, 0, 0,
                                   0.0,
                                   0, 0, 0, 0);
         QTransform transform = worker.transform();
 
         offset = center - transform.map(center);
     }
 
     KisProcessingApplicator applicator(this, node,
                                        KisProcessingApplicator::RECURSIVE,
                                        emitSignals, actionName);
 
     KisTransformProcessingVisitor *visitor =
         new KisTransformProcessingVisitor(scaleX, scaleY,
                                           0, 0,
                                           QPointF(),
                                           0,
                                           offset.x(), offset.y(),
                                           filterStrategy);
 
     visitor->setSelection(selection);
 
     if (selection) {
         applicator.applyVisitor(visitor, KisStrokeJobData::CONCURRENT);
     } else {
         applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
     }
 
     applicator.end();
 }
 
 void KisImage::rotateImpl(const KUndo2MagicString &actionName,
                           KisNodeSP rootNode,
                           double radians,
                           bool resizeImage,
                           KisSelectionSP selection)
 {
     // we can either transform (and resize) the whole image or
     // transform a selection, we cannot do both at the same time
     KIS_SAFE_ASSERT_RECOVER(!(bool(selection) && resizeImage)) {
         selection = 0;
     }
 
     const QRect baseBounds =
         resizeImage ? bounds() :
         selection ? selection->selectedExactRect() :
         rootNode->exactBounds();
 
     QPointF offset;
     QSize newSize;
 
     {
         KisTransformWorker worker(0,
                                   1.0, 1.0,
                                   0, 0, 0, 0,
                                   radians,
                                   0, 0, 0, 0);
         QTransform transform = worker.transform();
 
         if (resizeImage) {
             QRect newRect = transform.mapRect(baseBounds);
             newSize = newRect.size();
             offset = -newRect.topLeft();
         }
         else {
             QPointF origin = QRectF(baseBounds).center();
 
             newSize = size();
             offset = -(transform.map(origin) - origin);
         }
     }
 
     bool sizeChanged = resizeImage &&
         (newSize.width() != baseBounds.width() ||
          newSize.height() != baseBounds.height());
 
     // These signals will be emitted after processing is done
     KisImageSignalVector emitSignals;
     if (sizeChanged) emitSignals << ComplexSizeChangedSignal(baseBounds, newSize);
     emitSignals << ModifiedSignal;
 
     // These flags determine whether updates are transferred to the UI during processing
     KisProcessingApplicator::ProcessingFlags signalFlags =
         sizeChanged ?
         KisProcessingApplicator::NO_UI_UPDATES :
         KisProcessingApplicator::NONE;
 
 
     KisProcessingApplicator applicator(this, rootNode,
                                        KisProcessingApplicator::RECURSIVE | signalFlags,
                                        emitSignals, actionName);
 
     KisFilterStrategy *filter = KisFilterStrategyRegistry::instance()->value("Bicubic");
 
     KisTransformProcessingVisitor *visitor =
             new KisTransformProcessingVisitor(1.0, 1.0, 0.0, 0.0,
                                               QPointF(),
                                               radians,
                                               offset.x(), offset.y(),
                                               filter);
     if (selection) {
         visitor->setSelection(selection);
     }
 
     if (selection) {
         applicator.applyVisitor(visitor, KisStrokeJobData::CONCURRENT);
     } else {
         applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
     }
 
     if (sizeChanged) {
         applicator.applyCommand(new KisImageResizeCommand(this, newSize));
     }
     applicator.end();
 }
 
 
 void KisImage::rotateImage(double radians)
 {
     rotateImpl(kundo2_i18n("Rotate Image"), root(), radians, true, 0);
 }
 
 void KisImage::rotateNode(KisNodeSP node, double radians, KisSelectionSP selection)
 {
     if (node->inherits("KisMask")) {
         rotateImpl(kundo2_i18n("Rotate Mask"), node, radians, false, selection);
     } else {
         rotateImpl(kundo2_i18n("Rotate Layer"), node, radians, false, selection);
     }
 }
 
 void KisImage::shearImpl(const KUndo2MagicString &actionName,
                          KisNodeSP rootNode,
                          bool resizeImage,
                          double angleX, double angleY,
                          KisSelectionSP selection)
 {
     const QRect baseBounds =
         resizeImage ? bounds() :
         selection ? selection->selectedExactRect() :
         rootNode->exactBounds();
 
     const QPointF origin = QRectF(baseBounds).center();
 
     //angleX, angleY are in degrees
     const qreal pi = 3.1415926535897932385;
     const qreal deg2rad = pi / 180.0;
 
     qreal tanX = tan(angleX * deg2rad);
     qreal tanY = tan(angleY * deg2rad);
 
     QPointF offset;
     QSize newSize;
 
     {
         KisTransformWorker worker(0,
                                   1.0, 1.0,
                                   tanX, tanY, origin.x(), origin.y(),
                                   0,
                                   0, 0, 0, 0);
 
         QRect newRect = worker.transform().mapRect(baseBounds);
         newSize = newRect.size();
         if (resizeImage) offset = -newRect.topLeft();
     }
 
     if (newSize == baseBounds.size()) return;
 
     KisImageSignalVector emitSignals;
     if (resizeImage) emitSignals << ComplexSizeChangedSignal(baseBounds, newSize);
     emitSignals << ModifiedSignal;
 
     KisProcessingApplicator::ProcessingFlags signalFlags =
         KisProcessingApplicator::RECURSIVE;
     if (resizeImage) signalFlags |= KisProcessingApplicator::NO_UI_UPDATES;
 
     KisProcessingApplicator applicator(this, rootNode,
                                        signalFlags,
                                        emitSignals, actionName);
 
     KisFilterStrategy *filter = KisFilterStrategyRegistry::instance()->value("Bilinear");
 
     KisTransformProcessingVisitor *visitor =
             new KisTransformProcessingVisitor(1.0, 1.0,
                                               tanX, tanY, origin,
                                               0,
                                               offset.x(), offset.y(),
                                               filter);
 
     if (selection) {
         visitor->setSelection(selection);
     }
 
     if (selection) {
         applicator.applyVisitor(visitor, KisStrokeJobData::CONCURRENT);
     } else {
         applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
     }
 
     if (resizeImage) {
         applicator.applyCommand(new KisImageResizeCommand(this, newSize));
     }
 
     applicator.end();
 }
 
 void KisImage::shearNode(KisNodeSP node, double angleX, double angleY, KisSelectionSP selection)
 {
     if (node->inherits("KisMask")) {
         shearImpl(kundo2_i18n("Shear Mask"), node, false,
                   angleX, angleY, selection);
     } else {
         shearImpl(kundo2_i18n("Shear Layer"), node, false,
                   angleX, angleY, selection);
     }
 }
 
 void KisImage::shear(double angleX, double angleY)
 {
     shearImpl(kundo2_i18n("Shear Image"), m_d->rootLayer, true,
               angleX, angleY, 0);
 }
 
 void KisImage::convertLayerColorSpace(KisNodeSP node,
                                       const KoColorSpace *dstColorSpace,
                                       KoColorConversionTransformation::Intent renderingIntent,
                                       KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     if (!node->projectionLeaf()->isLayer()) return;
 
     const KoColorSpace *srcColorSpace = node->colorSpace();
 
     if (!dstColorSpace || *srcColorSpace == *dstColorSpace) return;
 
     KUndo2MagicString actionName =
         kundo2_i18n("Convert Layer Color Space");
 
     KisImageSignalVector emitSignals;
     emitSignals << ModifiedSignal;
 
     KisProcessingApplicator applicator(this, node,
                                        KisProcessingApplicator::RECURSIVE |
                                        KisProcessingApplicator::NO_UI_UPDATES,
                                        emitSignals, actionName);
 
     applicator.applyVisitor(
         new KisConvertColorSpaceProcessingVisitor(
             srcColorSpace, dstColorSpace,
             renderingIntent, conversionFlags),
         KisStrokeJobData::CONCURRENT);
 
     applicator.end();
 }
 
 struct KisImage::KisImagePrivate::SetImageProjectionColorSpace : public KisCommandUtils::FlipFlopCommand
 {
     SetImageProjectionColorSpace(const KoColorSpace *cs, KisImageWSP image,
                                  State initialState, KUndo2Command *parent = 0)
         : KisCommandUtils::FlipFlopCommand(initialState, parent),
           m_cs(cs),
           m_image(image)
     {
     }
 
     void partA() override {
         KisImageSP image = m_image;
 
         if (image) {
             image->setProjectionColorSpace(m_cs);
         }
     }
 
 private:
     const KoColorSpace *m_cs;
     KisImageWSP m_image;
 };
 
 void KisImage::KisImagePrivate::convertImageColorSpaceImpl(const KoColorSpace *dstColorSpace,
                                                            bool convertLayers,
                                                            KoColorConversionTransformation::Intent renderingIntent,
                                                            KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     const KoColorSpace *srcColorSpace = this->colorSpace;
 
     if (!dstColorSpace || *srcColorSpace == *dstColorSpace) return;
 
     const KUndo2MagicString actionName =
         convertLayers ?
         kundo2_i18n("Convert Image Color Space") :
         kundo2_i18n("Convert Projection Color Space");
 
     KisImageSignalVector emitSignals;
     emitSignals << ColorSpaceChangedSignal;
     emitSignals << ModifiedSignal;
 
     KisProcessingApplicator applicator(q, this->rootLayer,
                                        KisProcessingApplicator::RECURSIVE |
                                        KisProcessingApplicator::NO_UI_UPDATES,
                                        emitSignals, actionName);
 
     applicator.applyCommand(
         new KisImagePrivate::SetImageProjectionColorSpace(dstColorSpace,
                                                           KisImageWSP(q),
                                                           KisCommandUtils::FlipFlopCommand::INITIALIZING),
         KisStrokeJobData::BARRIER);
 
     if (convertLayers) {
         applicator.applyVisitor(
                     new KisConvertColorSpaceProcessingVisitor(
                         srcColorSpace, dstColorSpace,
                         renderingIntent, conversionFlags),
                     KisStrokeJobData::CONCURRENT);
     } else {
         applicator.applyCommand(
             new KisDoSomethingCommand<
                     KisDoSomethingCommandOps::ResetOp, KisGroupLayerSP>
                     (this->rootLayer, false));
         applicator.applyCommand(
             new KisDoSomethingCommand<
                     KisDoSomethingCommandOps::ResetOp, KisGroupLayerSP>
                     (this->rootLayer, true));
     }
 
     applicator.applyCommand(
         new KisImagePrivate::SetImageProjectionColorSpace(srcColorSpace,
                                                           KisImageWSP(q),
                                                           KisCommandUtils::FlipFlopCommand::FINALIZING),
         KisStrokeJobData::BARRIER);
 
 
     applicator.end();
 }
 
 void KisImage::convertImageColorSpace(const KoColorSpace *dstColorSpace,
                                       KoColorConversionTransformation::Intent renderingIntent,
                                       KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     m_d->convertImageColorSpaceImpl(dstColorSpace, true, renderingIntent, conversionFlags);
 }
 
 void KisImage::convertImageProjectionColorSpace(const KoColorSpace *dstColorSpace)
 {
     m_d->convertImageColorSpaceImpl(dstColorSpace, false,
                                     KoColorConversionTransformation::internalRenderingIntent(),
                                     KoColorConversionTransformation::internalConversionFlags());
 }
 
 
 bool KisImage::assignLayerProfile(KisNodeSP node, const KoColorProfile *profile)
 {
     const KoColorSpace *srcColorSpace = node->colorSpace();
 
     if (!node->projectionLeaf()->isLayer()) return false;
     if (!profile || *srcColorSpace->profile() == *profile) return false;
 
     KUndo2MagicString actionName = kundo2_i18n("Assign Profile to Layer");
 
     KisImageSignalVector emitSignals;
     emitSignals << ModifiedSignal;
 
     const KoColorSpace *dstColorSpace = KoColorSpaceRegistry::instance()->colorSpace(colorSpace()->colorModelId().id(), colorSpace()->colorDepthId().id(), profile);
     if (!dstColorSpace) return false;
 
     KisProcessingApplicator applicator(this, node,
                                        KisProcessingApplicator::RECURSIVE |
                                        KisProcessingApplicator::NO_UI_UPDATES,
                                        emitSignals, actionName);
 
     applicator.applyVisitor(
         new KisAssignProfileProcessingVisitor(
             srcColorSpace, dstColorSpace),
         KisStrokeJobData::CONCURRENT);
 
     applicator.end();
 
     return true;
 }
 
 
 bool KisImage::assignImageProfile(const KoColorProfile *profile, bool blockAllUpdates)
 {
     if (!profile) return false;
 
     const KoColorSpace *srcColorSpace = m_d->colorSpace;
     bool imageProfileIsSame = *srcColorSpace->profile() == *profile;
 
     imageProfileIsSame &=
         !KisLayerUtils::recursiveFindNode(m_d->rootLayer,
             [profile] (KisNodeSP node) {
                 return *node->colorSpace()->profile() != *profile;
             });
 
     if (imageProfileIsSame) {
         dbgImage << "Trying to set the same image profile again" << ppVar(srcColorSpace->profile()->name()) << ppVar(profile->name());
         return true;
     }
 
     KUndo2MagicString actionName = kundo2_i18n("Assign Profile");
 
     KisImageSignalVector emitSignals;
     emitSignals << ProfileChangedSignal;
     emitSignals << ModifiedSignal;
 
     const KoColorSpace *dstColorSpace = KoColorSpaceRegistry::instance()->colorSpace(colorSpace()->colorModelId().id(), colorSpace()->colorDepthId().id(), profile);
     if (!dstColorSpace) return false;
 
     KisProcessingApplicator applicator(this, m_d->rootLayer,
                                        KisProcessingApplicator::RECURSIVE |
                                        (!blockAllUpdates ?
                                             KisProcessingApplicator::NO_UI_UPDATES :
                                             KisProcessingApplicator::NO_IMAGE_UPDATES),
                                        emitSignals, actionName);
 
     applicator.applyCommand(
         new KisImagePrivate::SetImageProjectionColorSpace(dstColorSpace,
                                                           KisImageWSP(this),
                                                           KisCommandUtils::FlipFlopCommand::INITIALIZING),
         KisStrokeJobData::BARRIER);
 
     applicator.applyVisitor(
         new KisAssignProfileProcessingVisitor(
             srcColorSpace, dstColorSpace),
         KisStrokeJobData::CONCURRENT);
 
     applicator.applyCommand(
         new KisImagePrivate::SetImageProjectionColorSpace(srcColorSpace,
                                                           KisImageWSP(this),
                                                           KisCommandUtils::FlipFlopCommand::FINALIZING),
         KisStrokeJobData::BARRIER);
 
 
     applicator.end();
 
     return true;
 }
 
 void KisImage::setProjectionColorSpace(const KoColorSpace * colorSpace)
 {
     m_d->colorSpace = colorSpace;
 }
 
 const KoColorSpace * KisImage::colorSpace() const
 {
     return m_d->colorSpace;
 }
 
 const KoColorProfile * KisImage::profile() const
 {
     return colorSpace()->profile();
 }
 
 double KisImage::xRes() const
 {
     return m_d->xres;
 }
 
 double KisImage::yRes() const
 {
     return m_d->yres;
 }
 
 void KisImage::setResolution(double xres, double yres)
 {
     m_d->xres = xres;
     m_d->yres = yres;
     m_d->signalRouter.emitNotification(ResolutionChangedSignal);
 }
 
 QPointF KisImage::documentToPixel(const QPointF &documentCoord) const
 {
     return QPointF(documentCoord.x() * xRes(), documentCoord.y() * yRes());
 }
 
 QPoint KisImage::documentToImagePixelFloored(const QPointF &documentCoord) const
 {
     QPointF pixelCoord = documentToPixel(documentCoord);
     return QPoint(qFloor(pixelCoord.x()), qFloor(pixelCoord.y()));
 }
 
 QRectF KisImage::documentToPixel(const QRectF &documentRect) const
 {
     return QRectF(documentToPixel(documentRect.topLeft()), documentToPixel(documentRect.bottomRight()));
 }
 
 QPointF KisImage::pixelToDocument(const QPointF &pixelCoord) const
 {
     return QPointF(pixelCoord.x() / xRes(), pixelCoord.y() / yRes());
 }
 
 QPointF KisImage::pixelToDocument(const QPoint &pixelCoord) const
 {
     return QPointF((pixelCoord.x() + 0.5) / xRes(), (pixelCoord.y() + 0.5) / yRes());
 }
 
 QRectF KisImage::pixelToDocument(const QRectF &pixelCoord) const
 {
     return QRectF(pixelToDocument(pixelCoord.topLeft()), pixelToDocument(pixelCoord.bottomRight()));
 }
 
 qint32 KisImage::width() const
 {
     return m_d->width;
 }
 
 qint32 KisImage::height() const
 {
     return m_d->height;
 }
 
 KisGroupLayerSP KisImage::rootLayer() const
 {
     Q_ASSERT(m_d->rootLayer);
     return m_d->rootLayer;
 }
 
 KisPaintDeviceSP KisImage::projection() const
 {
     if (m_d->isolatedRootNode) {
         return m_d->isolatedRootNode->projection();
     }
 
 
     Q_ASSERT(m_d->rootLayer);
     KisPaintDeviceSP projection = m_d->rootLayer->projection();
     Q_ASSERT(projection);
     return projection;
 }
 
 qint32 KisImage::nlayers() const
 {
     QStringList list;
     list << "KisLayer";
 
     KisCountVisitor visitor(list, KoProperties());
     m_d->rootLayer->accept(visitor);
     return visitor.count();
 }
 
 qint32 KisImage::nHiddenLayers() const
 {
     QStringList list;
     list << "KisLayer";
     KoProperties properties;
     properties.setProperty("visible", false);
     KisCountVisitor visitor(list, properties);
     m_d->rootLayer->accept(visitor);
 
     return visitor.count();
 }
 
 void KisImage::flatten(KisNodeSP activeNode)
 {
     KisLayerUtils::flattenImage(this, activeNode);
 }
 
 void KisImage::mergeMultipleLayers(QList<KisNodeSP> mergedNodes, KisNodeSP putAfter)
 {
     if (!KisLayerUtils::tryMergeSelectionMasks(this, mergedNodes, putAfter)) {
         KisLayerUtils::mergeMultipleLayers(this, mergedNodes, putAfter);
     }
 }
 
 void KisImage::mergeDown(KisLayerSP layer, const KisMetaData::MergeStrategy* strategy)
 {
     KisLayerUtils::mergeDown(this, layer, strategy);
 }
 
 void KisImage::flattenLayer(KisLayerSP layer)
 {
     KisLayerUtils::flattenLayer(this, layer);
 }
 
 
 void KisImage::setModified()
 {
     m_d->signalRouter.emitNotification(ModifiedSignal);
 }
 
 QImage KisImage::convertToQImage(QRect imageRect,
                                  const KoColorProfile * profile)
 {
     qint32 x;
     qint32 y;
     qint32 w;
     qint32 h;
     imageRect.getRect(&x, &y, &w, &h);
     return convertToQImage(x, y, w, h, profile);
 }
 
 QImage KisImage::convertToQImage(qint32 x,
                                  qint32 y,
                                  qint32 w,
                                  qint32 h,
                                  const KoColorProfile * profile)
 {
     KisPaintDeviceSP dev = projection();
     if (!dev) return QImage();
     QImage image = dev->convertToQImage(const_cast<KoColorProfile*>(profile), x, y, w, h,
                                         KoColorConversionTransformation::internalRenderingIntent(),
                                         KoColorConversionTransformation::internalConversionFlags());
 
     return image;
 }
 
 
 
 QImage KisImage::convertToQImage(const QSize& scaledImageSize, const KoColorProfile *profile)
 {
     if (scaledImageSize.isEmpty()) {
         return QImage();
     }
 
     KisPaintDeviceSP dev = new KisPaintDevice(colorSpace());
     KisPainter gc;
     gc.copyAreaOptimized(QPoint(0, 0), projection(), dev, bounds());
     gc.end();
     double scaleX = qreal(scaledImageSize.width()) / width();
     double scaleY = qreal(scaledImageSize.height()) / height();
 
     QPointer<KoUpdater> updater = new KoDummyUpdater();
 
     KisTransformWorker worker(dev, scaleX, scaleY, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, updater, KisFilterStrategyRegistry::instance()->value("Bicubic"));
     worker.run();
 
     delete updater;
 
     return dev->convertToQImage(profile);
 }
 void KisImage::notifyLayersChanged()
 {
     m_d->signalRouter.emitNotification(LayersChangedSignal);
 }
 
 QRect KisImage::bounds() const
 {
     return QRect(0, 0, width(), height());
 }
 
 QRect KisImage::effectiveLodBounds() const
 {
     QRect boundRect = bounds();
 
     const int lod = currentLevelOfDetail();
     if (lod > 0) {
         KisLodTransform t(lod);
         boundRect = t.map(boundRect);
     }
 
     return boundRect;
 }
 
 KisPostExecutionUndoAdapter* KisImage::postExecutionUndoAdapter() const
 {
     const int lod = currentLevelOfDetail();
     return lod > 0 ?
         m_d->scheduler.lodNPostExecutionUndoAdapter() :
         &m_d->postExecutionUndoAdapter;
 }
 
 const KUndo2Command* KisImage::lastExecutedCommand() const
 {
     return m_d->undoStore->presentCommand();
 }
 
 void KisImage::setUndoStore(KisUndoStore *undoStore)
 {
 
     m_d->legacyUndoAdapter.setUndoStore(undoStore);
     m_d->postExecutionUndoAdapter.setUndoStore(undoStore);
     m_d->undoStore.reset(undoStore);
 }
 
 KisUndoStore* KisImage::undoStore()
 {
     return m_d->undoStore.data();
 }
 
 KisUndoAdapter* KisImage::undoAdapter() const
 {
     return &m_d->legacyUndoAdapter;
 }
 
 void KisImage::setDefaultProjectionColor(const KoColor &color)
 {
     KIS_ASSERT_RECOVER_RETURN(m_d->rootLayer);
     m_d->rootLayer->setDefaultProjectionColor(color);
 }
 
 KoColor KisImage::defaultProjectionColor() const
 {
     KIS_ASSERT_RECOVER(m_d->rootLayer) {
         return KoColor(Qt::transparent, m_d->colorSpace);
     }
 
     return m_d->rootLayer->defaultProjectionColor();
 }
 
 void KisImage::setRootLayer(KisGroupLayerSP rootLayer)
 {
     emit sigInternalStopIsolatedModeRequested();
 
     KoColor defaultProjectionColor(Qt::transparent, m_d->colorSpace);
 
     if (m_d->rootLayer) {
         m_d->rootLayer->setGraphListener(0);
         m_d->rootLayer->disconnect();
 
         KisPaintDeviceSP original = m_d->rootLayer->original();
         defaultProjectionColor = original->defaultPixel();
     }
 
     m_d->rootLayer = rootLayer;
     m_d->rootLayer->disconnect();
     m_d->rootLayer->setGraphListener(this);
     m_d->rootLayer->setImage(this);
 
     setRoot(m_d->rootLayer.data());
     this->setDefaultProjectionColor(defaultProjectionColor);
 }
 
 void KisImage::addAnnotation(KisAnnotationSP annotation)
 {
     // Find the icc annotation, if there is one
     vKisAnnotationSP_it it = m_d->annotations.begin();
     while (it != m_d->annotations.end()) {
         if ((*it)->type() == annotation->type()) {
             *it = annotation;
             return;
         }
         ++it;
     }
     m_d->annotations.push_back(annotation);
 }
 
 KisAnnotationSP KisImage::annotation(const QString& type)
 {
     vKisAnnotationSP_it it = m_d->annotations.begin();
     while (it != m_d->annotations.end()) {
         if ((*it)->type() == type) {
             return *it;
         }
         ++it;
     }
     return KisAnnotationSP(0);
 }
 
 void KisImage::removeAnnotation(const QString& type)
 {
     vKisAnnotationSP_it it = m_d->annotations.begin();
     while (it != m_d->annotations.end()) {
         if ((*it)->type() == type) {
             m_d->annotations.erase(it);
             return;
         }
         ++it;
     }
 }
 
 vKisAnnotationSP_it KisImage::beginAnnotations()
 {
     return m_d->annotations.begin();
 }
 
 vKisAnnotationSP_it KisImage::endAnnotations()
 {
     return m_d->annotations.end();
 }
 
 void KisImage::notifyAboutToBeDeleted()
 {
     emit sigAboutToBeDeleted();
 }
 
 KisImageSignalRouter* KisImage::signalRouter()
 {
     return &m_d->signalRouter;
 }
 
 void KisImage::waitForDone()
 {
     requestStrokeEnd();
     KisBusyWaitBroker::instance()->notifyWaitOnImageStarted(this);
     m_d->scheduler.waitForDone();
     KisBusyWaitBroker::instance()->notifyWaitOnImageEnded(this);
 }
 
 KisStrokeId KisImage::startStroke(KisStrokeStrategy *strokeStrategy)
 {
     /**
      * Ask open strokes to end gracefully. All the strokes clients
      * (including the one calling this method right now) will get
      * a notification that they should probably end their strokes.
      * However this is purely their choice whether to end a stroke
      * or not.
      */
     if (strokeStrategy->requestsOtherStrokesToEnd()) {
         requestStrokeEnd();
     }
 
     /**
      * Some of the strokes can cancel their work with undoing all the
      * changes they did to the paint devices. The problem is that undo
      * stack will know nothing about it. Therefore, just notify it
      * explicitly
      */
     if (strokeStrategy->clearsRedoOnStart()) {
         m_d->undoStore->purgeRedoState();
     }
 
     return m_d->scheduler.startStroke(strokeStrategy);
 }
 
 void KisImage::KisImagePrivate::notifyProjectionUpdatedInPatches(const QRect &rc, QVector<KisRunnableStrokeJobData*> &jobs)
 {
     KisImageConfig imageConfig(true);
     int patchWidth = imageConfig.updatePatchWidth();
     int patchHeight = imageConfig.updatePatchHeight();
 
     for (int y = 0; y < rc.height(); y += patchHeight) {
         for (int x = 0; x < rc.width(); x += patchWidth) {
             QRect patchRect(x, y, patchWidth, patchHeight);
             patchRect &= rc;
 
             KritaUtils::addJobConcurrent(jobs, std::bind(&KisImage::notifyProjectionUpdated, q, patchRect));
         }
     }
 }
 
 bool KisImage::startIsolatedMode(KisNodeSP node)
 {
     struct StartIsolatedModeStroke : public KisRunnableBasedStrokeStrategy {
         StartIsolatedModeStroke(KisNodeSP node, KisImageSP image)
             : KisRunnableBasedStrokeStrategy(QLatin1String("start-isolated-mode"),
                                              kundo2_noi18n("start-isolated-mode")),
               m_node(node),
               m_image(image)
         {
             this->enableJob(JOB_INIT, true, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
             this->enableJob(JOB_DOSTROKE, true);
             setClearsRedoOnStart(false);
         }
 
         void initStrokeCallback() {
             // pass-though node don't have any projection prepared, so we should
             // explicitly regenerate it before activating isolated mode.
             m_node->projectionLeaf()->explicitlyRegeneratePassThroughProjection();
 
             m_image->m_d->isolatedRootNode = m_node;
             emit m_image->sigIsolatedModeChanged();
 
             // the GUI uses our thread to do the color space conversion so we
             // need to emit this signal in multiple threads
             QVector<KisRunnableStrokeJobData*> jobs;
             m_image->m_d->notifyProjectionUpdatedInPatches(m_image->bounds(), jobs);
             this->runnableJobsInterface()->addRunnableJobs(jobs);
 
 
             m_image->invalidateAllFrames();
         }
 
     private:
         KisNodeSP m_node;
         KisImageSP m_image;
     };
 
     KisStrokeId id = startStroke(new StartIsolatedModeStroke(node, this));
     endStroke(id);
 
     return true;
 }
 
 void KisImage::stopIsolatedMode()
 {
     if (!m_d->isolatedRootNode)  return;
 
     struct StopIsolatedModeStroke : public KisRunnableBasedStrokeStrategy {
         StopIsolatedModeStroke(KisImageSP image)
             : KisRunnableBasedStrokeStrategy(QLatin1String("stop-isolated-mode"), kundo2_noi18n("stop-isolated-mode")),
               m_image(image)
         {
             this->enableJob(JOB_INIT);
             this->enableJob(JOB_DOSTROKE, true);
             setClearsRedoOnStart(false);
         }
 
         void initStrokeCallback() {
             if (!m_image->m_d->isolatedRootNode)  return;
 
             //KisNodeSP oldRootNode = m_image->m_d->isolatedRootNode;
             m_image->m_d->isolatedRootNode = 0;
 
             emit m_image->sigIsolatedModeChanged();
 
             m_image->invalidateAllFrames();
 
             // the GUI uses our thread to do the color space conversion so we
             // need to emit this signal in multiple threads
             QVector<KisRunnableStrokeJobData*> jobs;
             m_image->m_d->notifyProjectionUpdatedInPatches(m_image->bounds(), jobs);
             this->runnableJobsInterface()->addRunnableJobs(jobs);
 
             // TODO: Substitute notifyProjectionUpdated() with this code
             // when update optimization is implemented
             //
             // QRect updateRect = bounds() | oldRootNode->extent();
             // oldRootNode->setDirty(updateRect);
         }
 
     private:
         KisImageSP m_image;
     };
 
     KisStrokeId id = startStroke(new StopIsolatedModeStroke(this));
     endStroke(id);
 }
 
 KisNodeSP KisImage::isolatedModeRoot() const
 {
     return m_d->isolatedRootNode;
 }
 
 void KisImage::addJob(KisStrokeId id, KisStrokeJobData *data)
 {
     KisUpdateTimeMonitor::instance()->reportJobStarted(data);
     m_d->scheduler.addJob(id, data);
 }
 
 void KisImage::endStroke(KisStrokeId id)
 {
     m_d->scheduler.endStroke(id);
 }
 
 bool KisImage::cancelStroke(KisStrokeId id)
 {
     return m_d->scheduler.cancelStroke(id);
 }
 
 bool KisImage::KisImagePrivate::tryCancelCurrentStrokeAsync()
 {
     return scheduler.tryCancelCurrentStrokeAsync();
 }
 
 void KisImage::requestUndoDuringStroke()
 {
     emit sigUndoDuringStrokeRequested();
 }
 
 void KisImage::requestStrokeCancellation()
 {
     if (!m_d->tryCancelCurrentStrokeAsync()) {
         emit sigStrokeCancellationRequested();
     }
 }
 
 UndoResult KisImage::tryUndoUnfinishedLod0Stroke()
 {
     return m_d->scheduler.tryUndoLastStrokeAsync();
 }
 
 void KisImage::requestStrokeEnd()
 {
     emit sigStrokeEndRequested();
     emit sigStrokeEndRequestedActiveNodeFiltered();
 }
 
 void KisImage::requestStrokeEndActiveNode()
 {
     emit sigStrokeEndRequested();
 }
 
 void KisImage::refreshGraph(KisNodeSP root)
 {
     refreshGraph(root, bounds(), bounds());
 }
 
 void KisImage::refreshGraph(KisNodeSP root, const QRect &rc, const QRect &cropRect)
 {
     if (!root) root = m_d->rootLayer;
 
     m_d->animationInterface->notifyNodeChanged(root.data(), rc, true);
     m_d->scheduler.fullRefresh(root, rc, cropRect);
 }
 
 void KisImage::initialRefreshGraph()
 {
     /**
      * NOTE: Tricky part. We set crop rect to null, so the clones
      * will not rely on precalculated projections of their sources
      */
 
     refreshGraphAsync(0, bounds(), QRect());
     waitForDone();
 }
 
 void KisImage::refreshGraphAsync(KisNodeSP root)
 {
     refreshGraphAsync(root, bounds(), bounds());
 }
 
 void KisImage::refreshGraphAsync(KisNodeSP root, const QRect &rc)
 {
     refreshGraphAsync(root, rc, bounds());
 }
 
 void KisImage::refreshGraphAsync(KisNodeSP root, const QRect &rc, const QRect &cropRect)
 {
     if (!root) root = m_d->rootLayer;
 
     m_d->animationInterface->notifyNodeChanged(root.data(), rc, true);
     m_d->scheduler.fullRefreshAsync(root, rc, cropRect);
 }
 
 void KisImage::requestProjectionUpdateNoFilthy(KisNodeSP pseudoFilthy, const QRect &rc, const QRect &cropRect)
+{
+    requestProjectionUpdateNoFilthy(pseudoFilthy, rc, cropRect, true);
+}
+
+void KisImage::requestProjectionUpdateNoFilthy(KisNodeSP pseudoFilthy, const QRect &rc, const QRect &cropRect, const bool resetAnimationCache)
 {
     KIS_ASSERT_RECOVER_RETURN(pseudoFilthy);
 
-    m_d->animationInterface->notifyNodeChanged(pseudoFilthy.data(), rc, false);
+    if (resetAnimationCache) {
+        m_d->animationInterface->notifyNodeChanged(pseudoFilthy.data(), rc, false);
+    }
     m_d->scheduler.updateProjectionNoFilthy(pseudoFilthy, rc, cropRect);
 }
 
 void KisImage::addSpontaneousJob(KisSpontaneousJob *spontaneousJob)
 {
     m_d->scheduler.addSpontaneousJob(spontaneousJob);
 }
 
 bool KisImage::hasUpdatesRunning() const
 {
     return m_d->scheduler.hasUpdatesRunning();
 }
 
 KisProjectionUpdatesFilterCookie KisImage::addProjectionUpdatesFilter(KisProjectionUpdatesFilterSP filter)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(filter, KisProjectionUpdatesFilterCookie());
 
     m_d->projectionUpdatesFilters.append(filter);
 
     return KisProjectionUpdatesFilterCookie(filter.data());
 }
 
 KisProjectionUpdatesFilterSP KisImage::removeProjectionUpdatesFilter(KisProjectionUpdatesFilterCookie cookie)
 {
     KIS_SAFE_ASSERT_RECOVER_NOOP(cookie);
     KIS_SAFE_ASSERT_RECOVER_NOOP(m_d->projectionUpdatesFilters.last() == cookie);
 
     auto it = std::find(m_d->projectionUpdatesFilters.begin(), m_d->projectionUpdatesFilters.end(), cookie);
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(it != m_d->projectionUpdatesFilters.end(), KisProjectionUpdatesFilterSP());
 
     KisProjectionUpdatesFilterSP filter = *it;
 
     m_d->projectionUpdatesFilters.erase(it);
 
     return filter;
 }
 
 KisProjectionUpdatesFilterCookie KisImage::currentProjectionUpdatesFilter() const
 {
     return !m_d->projectionUpdatesFilters.isEmpty() ?
                 m_d->projectionUpdatesFilters.last().data() :
                 KisProjectionUpdatesFilterCookie();
 }
 
 void KisImage::disableDirtyRequests()
 {
     m_d->disabledUpdatesCookies.push(
         addProjectionUpdatesFilter(toQShared(new KisDropAllProjectionUpdatesFilter())));
 }
 
 void KisImage::enableDirtyRequests()
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(!m_d->disabledUpdatesCookies.isEmpty());
     removeProjectionUpdatesFilter(m_d->disabledUpdatesCookies.pop());
 }
 
 void KisImage::disableUIUpdates()
 {
     m_d->disableUIUpdateSignals.ref();
 }
 
 void KisImage::notifyBatchUpdateStarted()
 {
     m_d->signalRouter.emitNotifyBatchUpdateStarted();
 }
 
 void KisImage::notifyBatchUpdateEnded()
 {
     m_d->signalRouter.emitNotifyBatchUpdateEnded();
 }
 
 void KisImage::notifyUIUpdateCompleted(const QRect &rc)
 {
     notifyProjectionUpdated(rc);
 }
 
 QVector<QRect> KisImage::enableUIUpdates()
 {
     m_d->disableUIUpdateSignals.deref();
 
     QRect rect;
     QVector<QRect> postponedUpdates;
 
     while (m_d->savedDisabledUIUpdates.pop(rect)) {
         postponedUpdates.append(rect);
     }
 
     return postponedUpdates;
 }
 
 void KisImage::notifyProjectionUpdated(const QRect &rc)
 {
     KisUpdateTimeMonitor::instance()->reportUpdateFinished(rc);
 
     if (!m_d->disableUIUpdateSignals) {
         int lod = currentLevelOfDetail();
         QRect dirtyRect = !lod ? rc : KisLodTransform::upscaledRect(rc, lod);
 
         if (dirtyRect.isEmpty()) return;
 
         emit sigImageUpdated(dirtyRect);
     } else {
         m_d->savedDisabledUIUpdates.push(rc);
     }
 }
 
 void KisImage::setWorkingThreadsLimit(int value)
 {
     m_d->scheduler.setThreadsLimit(value);
 }
 
 int KisImage::workingThreadsLimit() const
 {
     return m_d->scheduler.threadsLimit();
 }
 
 void KisImage::notifySelectionChanged()
 {
     /**
      * The selection is calculated asynchronously, so it is not
      * handled by disableUIUpdates() and other special signals of
      * KisImageSignalRouter
      */
     m_d->legacyUndoAdapter.emitSelectionChanged();
 
     /**
      * Editing of selection masks doesn't necessary produce a
      * setDirty() call, so in the end of the stroke we need to request
      * direct update of the UI's cache.
      */
     if (m_d->isolatedRootNode &&
         dynamic_cast<KisSelectionMask*>(m_d->isolatedRootNode.data())) {
 
         notifyProjectionUpdated(bounds());
     }
 }
 
 void KisImage::requestProjectionUpdateImpl(KisNode *node,
                                            const QVector<QRect> &rects,
                                            const QRect &cropRect)
 {
     if (rects.isEmpty()) return;
 
     m_d->scheduler.updateProjection(node, rects, cropRect);
 }
 
 void KisImage::requestProjectionUpdate(KisNode *node, const QVector<QRect> &rects, bool resetAnimationCache)
 {
     /**
      * We iterate through the filters in a reversed way. It makes the most nested filters
      * to execute first.
      */
     for (auto it = m_d->projectionUpdatesFilters.rbegin();
          it != m_d->projectionUpdatesFilters.rend();
          ++it) {
 
         KIS_SAFE_ASSERT_RECOVER(*it) { continue; }
 
         if ((*it)->filter(this, node, rects, resetAnimationCache)) {
             return;
         }
     }
 
     if (resetAnimationCache) {
         m_d->animationInterface->notifyNodeChanged(node, rects, false);
     }
 
     /**
      * Here we use 'permitted' instead of 'active' intentively,
      * because the updates may come after the actual stroke has been
      * finished. And having some more updates for the stroke not
      * supporting the wrap-around mode will not make much harm.
      */
     if (m_d->wrapAroundModePermitted) {
         QVector<QRect> allSplitRects;
 
         const QRect boundRect = effectiveLodBounds();
         Q_FOREACH (const QRect &rc, rects) {
             KisWrappedRect splitRect(rc, boundRect);
             allSplitRects.append(splitRect);
         }
 
         requestProjectionUpdateImpl(node, allSplitRects, boundRect);
 
     } else {
         requestProjectionUpdateImpl(node, rects, bounds());
     }
 
     KisNodeGraphListener::requestProjectionUpdate(node, rects, resetAnimationCache);
 }
 
 void KisImage::invalidateFrames(const KisTimeRange &range, const QRect &rect)
 {
     m_d->animationInterface->invalidateFrames(range, rect);
 }
 
 void KisImage::requestTimeSwitch(int time)
 {
     m_d->animationInterface->requestTimeSwitchNonGUI(time);
 }
 
 KisNode *KisImage::graphOverlayNode() const
 {
     return m_d->overlaySelectionMask.data();
 }
 
 QList<KisLayerCompositionSP> KisImage::compositions()
 {
     return m_d->compositions;
 }
 
 void KisImage::addComposition(KisLayerCompositionSP composition)
 {
     m_d->compositions.append(composition);
 }
 
 void KisImage::removeComposition(KisLayerCompositionSP composition)
 {
     m_d->compositions.removeAll(composition);
 }
 
 bool checkMasksNeedConversion(KisNodeSP root, const QRect &bounds)
 {
     KisSelectionMask *mask = dynamic_cast<KisSelectionMask*>(root.data());
     if (mask &&
         (!bounds.contains(mask->paintDevice()->exactBounds()) ||
          mask->selection()->hasShapeSelection())) {
 
         return true;
     }
 
     KisNodeSP node = root->firstChild();
 
     while (node) {
         if (checkMasksNeedConversion(node, bounds)) {
             return true;
         }
 
         node = node->nextSibling();
     }
 
     return false;
 }
 
 void KisImage::setWrapAroundModePermitted(bool value)
 {
     if (m_d->wrapAroundModePermitted != value) {
         requestStrokeEnd();
     }
 
     m_d->wrapAroundModePermitted = value;
 
     if (m_d->wrapAroundModePermitted &&
         checkMasksNeedConversion(root(), bounds())) {
 
         KisProcessingApplicator applicator(this, root(),
                                            KisProcessingApplicator::RECURSIVE,
                                            KisImageSignalVector() << ModifiedSignal,
                                            kundo2_i18n("Crop Selections"));
 
         KisProcessingVisitorSP visitor =
             new KisCropSelectionsProcessingVisitor(bounds());
 
         applicator.applyVisitor(visitor, KisStrokeJobData::CONCURRENT);
         applicator.end();
     }
 }
 
 bool KisImage::wrapAroundModePermitted() const
 {
     return m_d->wrapAroundModePermitted;
 }
 
 bool KisImage::wrapAroundModeActive() const
 {
     return m_d->wrapAroundModePermitted &&
         m_d->scheduler.wrapAroundModeSupported();
 }
 
 void KisImage::setDesiredLevelOfDetail(int lod)
 {
     if (m_d->blockLevelOfDetail) {
         qWarning() << "WARNING: KisImage::setDesiredLevelOfDetail()"
                    << "was called while LoD functionality was being blocked!";
         return;
     }
 
     m_d->scheduler.setDesiredLevelOfDetail(lod);
 }
 
 int KisImage::currentLevelOfDetail() const
 {
     if (m_d->blockLevelOfDetail) {
         return 0;
     }
 
     return m_d->scheduler.currentLevelOfDetail();
 }
 
 void KisImage::setLevelOfDetailBlocked(bool value)
 {
     KisImageBarrierLockerRaw l(this);
 
     if (value && !m_d->blockLevelOfDetail) {
         m_d->scheduler.setDesiredLevelOfDetail(0);
     }
 
     m_d->blockLevelOfDetail = value;
 }
 
 void KisImage::explicitRegenerateLevelOfDetail()
 {
     if (!m_d->blockLevelOfDetail) {
         m_d->scheduler.explicitRegenerateLevelOfDetail();
     }
 }
 
 bool KisImage::levelOfDetailBlocked() const
 {
     return m_d->blockLevelOfDetail;
 }
 
 void KisImage::nodeCollapsedChanged(KisNode * node)
 {
     Q_UNUSED(node);
     emit sigNodeCollapsedChanged();
 }
 
 KisImageAnimationInterface* KisImage::animationInterface() const
 {
     return m_d->animationInterface;
 }
 
 void KisImage::setProofingConfiguration(KisProofingConfigurationSP proofingConfig)
 {
     m_d->proofingConfig = proofingConfig;
     emit sigProofingConfigChanged();
 }
 
 KisProofingConfigurationSP KisImage::proofingConfiguration() const
 {
     if (m_d->proofingConfig) {
         return m_d->proofingConfig;
     }
     return KisProofingConfigurationSP();
 }
 
 QPointF KisImage::mirrorAxesCenter() const
 {
     return m_d->axesCenter;
 }
 
 void KisImage::setMirrorAxesCenter(const QPointF &value) const
 {
     m_d->axesCenter = value;
 }
 
 void KisImage::setAllowMasksOnRootNode(bool value)
 {
     m_d->allowMasksOnRootNode = value;
 }
 
 bool KisImage::allowMasksOnRootNode() const
 {
     return m_d->allowMasksOnRootNode;
 }
diff --git a/libs/image/kis_image.h b/libs/image/kis_image.h
index b0c28ea3bf..6aad733425 100644
--- a/libs/image/kis_image.h
+++ b/libs/image/kis_image.h
@@ -1,1237 +1,1239 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2007 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef KIS_IMAGE_H_
 #define KIS_IMAGE_H_
 
 #include <QObject>
 #include <QString>
 #include <QPainter>
 #include <QRect>
 #include <QBitArray>
 
 #include <KoColorConversionTransformation.h>
 
 #include "kis_types.h"
 #include "kis_shared.h"
 #include "kis_node_graph_listener.h"
 #include "kis_node_facade.h"
 #include "kis_image_interfaces.h"
 #include "kis_strokes_queue_undo_result.h"
 
 #include <kritaimage_export.h>
 
 class KoColorSpace;
 class KoColor;
 
 class KisCompositeProgressProxy;
 class KisUndoStore;
 class KisUndoAdapter;
 class KisImageSignalRouter;
 class KisPostExecutionUndoAdapter;
 class KisFilterStrategy;
 class KoColorProfile;
 class KisLayerComposition;
 class KisSpontaneousJob;
 class KisImageAnimationInterface;
 class KUndo2MagicString;
 class KisProofingConfiguration;
 class KisPaintDevice;
 
 namespace KisMetaData
 {
 class MergeStrategy;
 }
 
 /**
  * This is the image class, it contains a tree of KisLayer stack and
  * meta information about the image. And it also provides some
  * functions to manipulate the whole image.
  */
 class KRITAIMAGE_EXPORT KisImage : public QObject,
         public KisStrokesFacade,
         public KisStrokeUndoFacade,
         public KisUpdatesFacade,
         public KisProjectionUpdateListener,
         public KisNodeFacade,
         public KisNodeGraphListener,
         public KisShared
 {
 
     Q_OBJECT
 
 public:
 
     /// @p colorSpace can be null. In that case, it will be initialised to a default color space.
     KisImage(KisUndoStore *undoStore, qint32 width, qint32 height, const KoColorSpace *colorSpace, const QString& name);
     ~KisImage() override;
 
     static KisImageSP fromQImage(const QImage &image, KisUndoStore *undoStore);
 
 public: // KisNodeGraphListener implementation
 
     void aboutToAddANode(KisNode *parent, int index) override;
     void nodeHasBeenAdded(KisNode *parent, int index) override;
     void aboutToRemoveANode(KisNode *parent, int index) override;
     void nodeChanged(KisNode * node) override;
     void nodeCollapsedChanged(KisNode *node) override;
     void invalidateAllFrames() override;
     void notifySelectionChanged() override;
     void requestProjectionUpdate(KisNode *node, const QVector<QRect> &rects, bool resetAnimationCache) override;
     void invalidateFrames(const KisTimeRange &range, const QRect &rect) override;
     void requestTimeSwitch(int time) override;
     KisNode* graphOverlayNode() const override;
 
 public: // KisProjectionUpdateListener implementation
     void notifyProjectionUpdated(const QRect &rc) override;
 
 public:
 
     /**
      * Set the number of threads used by the image's working threads
      */
     void setWorkingThreadsLimit(int value);
 
     /**
      * Return the number of threads available to the image's working threads
      */
     int workingThreadsLimit() const;
 
     /**
      * Makes a copy of the image with all the layers. If possible, shallow
      * copies of the layers are made.
      *
      * \p exactCopy shows if the copied image should look *exactly* the same as
      * the other one (according to it's .kra xml representation). It means that
      * the layers will have the same UUID keys and, therefore, you are not
      * expected to use the copied image anywhere except for saving. Don't use
      * this option if you plan to work with the copied image later.
      */
     KisImage *clone(bool exactCopy = false);
 
     void copyFromImage(const KisImage &rhs);
 
 private:
 
     // must specify exactly one from CONSTRUCT or REPLACE.
     enum CopyPolicy {
         CONSTRUCT = 1, ///< we are copy-constructing a new KisImage
         REPLACE = 2, ///< we are replacing the current KisImage with another
         EXACT_COPY = 4, /// we need an exact copy of the original image
     };
 
     void copyFromImageImpl(const KisImage &rhs, int policy);
 
 public:
 
     /**
      * Render the projection onto a QImage.
      */
     QImage convertToQImage(qint32 x1,
                            qint32 y1,
                            qint32 width,
                            qint32 height,
                            const KoColorProfile * profile);
 
     /**
      * Render the projection onto a QImage.
      * (this is an overloaded function)
      */
     QImage convertToQImage(QRect imageRect,
                            const KoColorProfile * profile);
 
 
     /**
      * Render a thumbnail of the projection onto a QImage.
      */
     QImage convertToQImage(const QSize& scaledImageSize, const KoColorProfile *profile);
 
     /**
      * [low-level] Lock the image without waiting for all the internal job queues are processed
      *
      * WARNING: Don't use it unless you really know what you are doing! Use barrierLock() instead!
      *
      * Waits for all the **currently running** internal jobs to complete and locks the image
      * for writing. Please note that this function does **not** wait for all the internal
      * queues to process, so there might be some non-finished actions pending. It means that
      * you just postpone these actions until you unlock() the image back. Until then, then image
      * might easily be frozen in some inconsistent state.
      *
      * The only sane usage for this function is to lock the image for **emergency**
      * processing, when some internal action or scheduler got hung up, and you just want
      * to fetch some data from the image without races.
      *
      * In all other cases, please use barrierLock() instead!
      */
     void lock();
 
     /**
      * Unlocks the image and starts/resumes all the pending internal jobs. If the image
      * has been locked for a non-readOnly access, then all the internal caches of the image
      * (e.g. lod-planes) are reset and regeneration jobs are scheduled.
      */
     void unlock();
 
     /**
      * @return return true if the image is in a locked state, i.e. all the internal
      *         jobs are blocked from execution by calling wither lock() or barrierLock().
      *
      *         When the image is locked, the user can do some modifications to the image
      *         contents safely without a perspective having race conditions with internal
      *         image jobs.
      */
     bool locked() const;
 
     /**
      * Sets the mask (it must be a part of the node hierarchy already) to be paited on
      * the top of all layers. This method does all the locking and syncing for you. It
      * is executed asynchronously.
      */
     void setOverlaySelectionMask(KisSelectionMaskSP mask);
 
     /**
      * \see setOverlaySelectionMask
      */
     KisSelectionMaskSP overlaySelectionMask() const;
 
     /**
      * \see setOverlaySelectionMask
      */
     bool hasOverlaySelectionMask() const;
 
     /**
      * @return the global selection object or 0 if there is none. The
      * global selection is always read-write.
      */
     KisSelectionSP globalSelection() const;
 
     /**
      * Retrieve the next automatic layername (XXX: fix to add option to return Mask X)
      */
     QString nextLayerName(const QString &baseName = "") const;
 
     /**
      * Set the automatic layer name counter one back.
      */
     void rollBackLayerName();
 
     /**
      * @brief start asynchronous operation on resizing the image
      *
      * The method will resize the image to fit the new size without
      * dropping any pixel data. The GUI will get correct
      * notification with old and new sizes, so it adjust canvas origin
      * accordingly and avoid jumping of the canvas on screen
      *
      * @param newRect the rectangle of the image which will be visible
      *        after operation is completed
      *
      * Please note that the actual operation starts asynchronously in
      * a background, so you cannot expect the image having new size
      * right after this call.
      */
     void resizeImage(const QRect& newRect);
 
     /**
      * @brief start asynchronous operation on cropping the image
      *
      * The method will **drop** all the image data outside \p newRect
      * and resize the image to fit the new size. The GUI will get correct
      * notification with old and new sizes, so it adjust canvas origin
      * accordingly and avoid jumping of the canvas on screen
      *
      * @param newRect the rectangle of the image which will be cut-out
      *
      * Please note that the actual operation starts asynchronously in
      * a background, so you cannot expect the image having new size
      * right after this call.
      */
     void cropImage(const QRect& newRect);
 
 
     /**
      * @brief start asynchronous operation on cropping a subtree of nodes starting at \p node
      *
      * The method will **drop** all the layer data outside \p newRect. Neither
      * image nor a layer will be moved anywhere
      *
      * @param node node to crop
      * @param newRect the rectangle of the layer which will be cut-out
      *
      * Please note that the actual operation starts asynchronously in
      * a background, so you cannot expect the image having new size
      * right after this call.
      */
     void cropNode(KisNodeSP node, const QRect& newRect);
 
     /**
      * @brief start asynchronous operation on scaling the image
      * @param size new image size in pixels
      * @param xres new image x-resolution pixels-per-pt
      * @param yres new image y-resolution pixels-per-pt
      * @param filterStrategy filtering strategy
      *
      * Please note that the actual operation starts asynchronously in
      * a background, so you cannot expect the image having new size
      * right after this call.
      */
     void scaleImage(const QSize &size, qreal xres, qreal yres, KisFilterStrategy *filterStrategy);
 
     /**
      * @brief start asynchronous operation on scaling a subtree of nodes starting at \p node
      * @param node node to scale
      * @param center the center of the scaling
      * @param scaleX x-scale coefficient to be applied to the node
      * @param scaleY y-scale coefficient to be applied to the node
      * @param filterStrategy filtering strategy
      * @param selection the selection we based on
      *
      * Please note that the actual operation starts asynchronously in
      * a background, so you cannot expect the image having new size
      * right after this call.
      */
     void scaleNode(KisNodeSP node, const QPointF &center, qreal scaleX, qreal scaleY, KisFilterStrategy *filterStrategy, KisSelectionSP selection);
 
     /**
      * @brief start asynchronous operation on rotating the image
      *
      * The image is resized to fit the rotated rectangle
      *
      * @param radians rotation angle in radians
      *
      * Please note that the actual operation starts asynchronously in
      * a background, so you cannot expect the operation being completed
      * right after the call
      */
     void rotateImage(double radians);
 
     /**
      * @brief start asynchronous operation on rotating a subtree of nodes starting at \p node
      *
      * The image is not resized!
      *
      * @param node the root of the subtree to rotate
      * @param radians rotation angle in radians
      * @param selection the selection we based on
      *
      * Please note that the actual operation starts asynchronously in
      * a background, so you cannot expect the operation being completed
      * right after the call
      */
     void rotateNode(KisNodeSP node, double radians, KisSelectionSP selection);
 
     /**
      * @brief start asynchronous operation on shearing the image
      *
      * The image is resized to fit the sheared polygon
      *
      * @p angleX, @p angleY are given in degrees.
      *
      * Please note that the actual operation starts asynchronously in
      * a background, so you cannot expect the operation being completed
      * right after the call
      */
     void shear(double angleX, double angleY);
 
     /**
      * @brief start asynchronous operation on shearing a subtree of nodes starting at \p node
      *
      * The image is not resized!
      *
      * @param node the root of the subtree to rotate
      * @param angleX x-shear given in degrees.
      * @param angleY y-shear given in degrees.
      * @param selection the selection we based on
      *
      * Please note that the actual operation starts asynchronously in
      * a background, so you cannot expect the operation being completed
      * right after the call
      */
     void shearNode(KisNodeSP node, double angleX, double angleY, KisSelectionSP selection);
 
     /**
      * Convert image projection to \p dstColorSpace, keeping all the layers intouched.
      */
     void convertImageProjectionColorSpace(const KoColorSpace *dstColorSpace);
 
     /**
      * Convert the image and all its layers to the dstColorSpace
      */
     void convertImageColorSpace(const KoColorSpace *dstColorSpace,
                                 KoColorConversionTransformation::Intent renderingIntent,
                                 KoColorConversionTransformation::ConversionFlags conversionFlags);
 
     /**
      * Convert layer and all its child layers to dstColorSpace
      */
     void convertLayerColorSpace(KisNodeSP node,
                                 const KoColorSpace *dstColorSpace,
                                 KoColorConversionTransformation::Intent renderingIntent,
                                 KoColorConversionTransformation::ConversionFlags conversionFlags);
 
 
     // Get the profile associated with this image
     const KoColorProfile *  profile() const;
 
     /**
      * Set the profile of the layer and all its children to the new profile.
      * It doesn't do any pixel conversion.
      *
      * This is essential if you have loaded an image that didn't
      * have an embedded profile to which you want to attach the right profile.
      *
      * @returns false if the profile could not be assigned
      */
     bool assignLayerProfile(KisNodeSP node, const KoColorProfile *profile);
 
     /**
      * Set the profile of the image to the new profile and do the same for
      * all layers that have the same colorspace and profile of the image.
      * It doesn't do any pixel conversion.
      *
      * This is essential if you have loaded an image that didn't
      * have an embedded profile to which you want to attach the right profile.
      *
      * @returns false if the profile could not be assigned
      */
     bool assignImageProfile(const KoColorProfile *profile, bool blockAllUpdates = false);
 
     /**
      * Returns the current undo adapter. You can add new commands to the
      * undo stack using the adapter. This adapter is used for a backward
      * compatibility for old commands created before strokes. It blocks
      * all the porcessing at the scheduler, waits until it's finished
      * and executes commands exclusively.
      */
     KisUndoAdapter* undoAdapter() const;
 
     /**
      * This adapter is used by the strokes system. The commands are added
      * to it *after* redo() is done (in the scheduler context). They are
      * wrapped into a special command and added to the undo stack. redo()
      * in not called.
      */
     KisPostExecutionUndoAdapter* postExecutionUndoAdapter() const override;
 
     /**
      * Return the lastly executed LoD0 command. It is effectively the same
      * as to call undoAdapter()->presentCommand();
      */
     const KUndo2Command* lastExecutedCommand() const override;
 
     /**
      * Replace current undo store with the new one. The old store
      * will be deleted.
      * This method is used by KisDocument for dropping all the commands
      * during file loading.
      */
     void setUndoStore(KisUndoStore *undoStore);
 
     /**
      * Return current undo store of the image
      */
     KisUndoStore* undoStore();
 
     /**
      * Tell the image it's modified; this emits the sigImageModified
      * signal. This happens when the image needs to be saved
      */
     void setModified();
 
     /**
      * The default colorspace of this image: new layers will have this
      * colorspace and the projection will have this colorspace.
      */
     const KoColorSpace * colorSpace() const;
 
     /**
      * X resolution in pixels per pt
      */
     double xRes() const;
 
     /**
      * Y resolution in pixels per pt
      */
     double yRes() const;
 
     /**
      * Set the resolution in pixels per pt.
      */
     void setResolution(double xres, double yres);
 
     /**
      * Convert a document coordinate to a pixel coordinate.
      *
      * @param documentCoord PostScript Pt coordinate to convert.
      */
     QPointF documentToPixel(const QPointF &documentCoord) const;
 
     /**
      * Convert a document coordinate to an integer pixel coordinate rounded down.
      *
      * @param documentCoord PostScript Pt coordinate to convert.
      */
     QPoint documentToImagePixelFloored(const QPointF &documentCoord) const;
 
     /**
      * Convert a document rectangle to a pixel rectangle.
      *
      * @param documentRect PostScript Pt rectangle to convert.
      */
     QRectF documentToPixel(const QRectF &documentRect) const;
 
     /**
      * Convert a pixel coordinate to a document coordinate.
      *
      * @param pixelCoord pixel coordinate to convert.
      */
     QPointF pixelToDocument(const QPointF &pixelCoord) const;
 
     /**
      * Convert an integer pixel coordinate to a document coordinate.
      * The document coordinate is at the centre of the pixel.
      *
      * @param pixelCoord pixel coordinate to convert.
      */
     QPointF pixelToDocument(const QPoint &pixelCoord) const;
 
     /**
      * Convert a document rectangle to an integer pixel rectangle.
      *
      * @param pixelCoord pixel coordinate to convert.
      */
     QRectF pixelToDocument(const QRectF &pixelCoord) const;
 
     /**
      * Return the width of the image
      */
     qint32 width() const;
 
     /**
      * Return the height of the image
      */
     qint32 height() const;
 
     /**
      * Return the size of the image
      */
     QSize size() const {
         return QSize(width(), height());
     }
 
     /**
      * @return the root node of the image node graph
      */
     KisGroupLayerSP rootLayer() const;
 
     /**
      * Return the projection; that is, the complete, composited
      * representation of this image.
      */
     KisPaintDeviceSP projection() const;
 
     /**
      * Return the number of layers (not other nodes) that are in this
      * image.
      */
     qint32 nlayers() const;
 
     /**
      * Return the number of layers (not other node types) that are in
      * this image and that are hidden.
      */
     qint32 nHiddenLayers() const;
 
     /**
      * Merge all visible layers and discard hidden ones.
      */
     void flatten(KisNodeSP activeNode);
 
     /**
      * Merge the specified layer with the layer
      * below this layer, remove the specified layer.
      */
     void mergeDown(KisLayerSP l, const KisMetaData::MergeStrategy* strategy);
 
     /**
      * flatten the layer: that is, the projection becomes the layer
      * and all subnodes are removed. If this is not a paint layer, it will morph
      * into a paint layer.
      */
     void flattenLayer(KisLayerSP layer);
 
     /**
      * Merges layers in \p mergedLayers and creates a new layer above
      * \p putAfter
      */
     void mergeMultipleLayers(QList<KisNodeSP> mergedLayers, KisNodeSP putAfter);
 
     /// @return the exact bounds of the image in pixel coordinates.
     QRect bounds() const override;
 
     /**
      * Returns the actual bounds of the image, taking LevelOfDetail
      * into account.  This value is used as a bounds() value of
      * KisDefaultBounds object.
      */
     QRect effectiveLodBounds() const;
 
     /// use if the layers have changed _completely_ (eg. when flattening)
     void notifyLayersChanged();
 
     /**
      * Sets the default color of the root layer projection. All the layers
      * will be merged on top of this very color
      */
     void setDefaultProjectionColor(const KoColor &color);
 
     /**
      * \see setDefaultProjectionColor()
      */
     KoColor defaultProjectionColor() const;
 
     void setRootLayer(KisGroupLayerSP rootLayer);
 
     /**
      * Add an annotation for this image. This can be anything: Gamma, EXIF, etc.
      * Note that the "icc" annotation is reserved for the color strategies.
      * If the annotation already exists, overwrite it with this one.
      */
     void addAnnotation(KisAnnotationSP annotation);
 
     /** get the annotation with the given type, can return 0 */
     KisAnnotationSP annotation(const QString& type);
 
     /** delete the annotation, if the image contains it */
     void removeAnnotation(const QString& type);
 
     /**
      * Start of an iteration over the annotations of this image (including the ICC Profile)
      */
     vKisAnnotationSP_it beginAnnotations();
 
     /** end of an iteration over the annotations of this image */
     vKisAnnotationSP_it endAnnotations();
 
     /**
      * Called before the image is deleted and sends the sigAboutToBeDeleted signal
      */
     void notifyAboutToBeDeleted();
 
     KisImageSignalRouter* signalRouter();
 
     /**
      * Returns whether we can reselect current global selection
      *
      * \see reselectGlobalSelection()
      */
     bool canReselectGlobalSelection();
 
     /**
      * Returns the layer compositions for the image
      */
     QList<KisLayerCompositionSP> compositions();
 
     /**
      * Adds a new layer composition, will be saved with the image
      */
     void addComposition(KisLayerCompositionSP composition);
 
     /**
      * Remove the layer compostion
      */
     void removeComposition(KisLayerCompositionSP composition);
 
     /**
      * Permit or deny the wrap-around mode for all the paint devices
      * of the image. Note that permitting the wraparound mode will not
      * necessarily activate it right now. To be activated the wrap
      * around mode should be 1) permitted; 2) supported by the
      * currently running stroke.
      */
     void setWrapAroundModePermitted(bool value);
 
     /**
      * \return whether the wrap-around mode is permitted for this
      *         image. If the wrap around mode is permitted and the
      *         currently running stroke supports it, the mode will be
      *         activated for all paint devices of the image.
      *
      * \see setWrapAroundMode
      */
     bool wrapAroundModePermitted() const;
 
 
     /**
      * \return whether the wraparound mode is activated for all the
      *         devices of the image. The mode is activated when both
      *         factors are true: the user permitted it and the stroke
      *         supports it
      */
     bool wrapAroundModeActive() const;
 
     /**
      * \return current level of detail which is used when processing the image.
      * Current working zoom = 2 ^ (- currentLevelOfDetail()). Default value is
      * null, which means we work on the original image.
      */
     int currentLevelOfDetail() const;
 
     /**
      * Notify KisImage which level of detail should be used in the
      * lod-mode. Setting the mode does not guarantee the LOD to be
      * used. It will be activated only when the stokes supports it.
      */
     void setDesiredLevelOfDetail(int lod);
 
     /**
      * Relative position of the mirror axis center
      *     0,0 - topleft corner of the image
      *     1,1 - bottomright corner of the image
      */
     QPointF mirrorAxesCenter() const;
 
     /**
      * Sets the relative position of the axes center
      * \see mirrorAxesCenter() for details
      */
     void setMirrorAxesCenter(const QPointF &value) const;
 
     /**
      * Configure the image to allow masks on the root not (as reported by
      * root()->allowAsChild()). By default it is not allowed (because it
      * looks weird from GUI point of view)
      */
     void setAllowMasksOnRootNode(bool value);
 
     /**
      * \see setAllowMasksOnRootNode()
      */
     bool allowMasksOnRootNode() const;
 
 public Q_SLOTS:
 
     /**
      * Explicitly start regeneration of LoD planes of all the devices
      * in the image. This call should be performed when the user is idle,
      * just to make the quality of image updates better.
      */
     void explicitRegenerateLevelOfDetail();
 
 public:
 
     /**
      * Blocks usage of level of detail functionality. After this method
      * has been called, no new strokes will use LoD.
      */
     void setLevelOfDetailBlocked(bool value);
 
     /**
      * \see setLevelOfDetailBlocked()
      */
     bool levelOfDetailBlocked() const;
 
     KisImageAnimationInterface *animationInterface() const;
 
     /**
      * @brief setProofingConfiguration, this sets the image's proofing configuration, and signals
      * the proofingConfiguration has changed.
      * @param proofingConfig - the kis proofing config that will be used instead.
      */
     void setProofingConfiguration(KisProofingConfigurationSP proofingConfig);
     /**
      * @brief proofingConfiguration
      * @return the proofing configuration of the image.
      */
     KisProofingConfigurationSP proofingConfiguration() const;
 
 public Q_SLOTS:
     bool startIsolatedMode(KisNodeSP node);
     void stopIsolatedMode();
 
 public:
     KisNodeSP isolatedModeRoot() const;
 
 Q_SIGNALS:
 
     /**
      *  Emitted whenever an action has caused the image to be
      *  recomposited. Parameter is the rect that has been recomposited.
      */
     void sigImageUpdated(const QRect &);
 
     /**
        Emitted whenever the image has been modified, so that it
        doesn't match with the version saved on disk.
      */
     void sigImageModified();
 
     /**
      * The signal is emitted when the size of the image is changed.
      * \p oldStillPoint and \p newStillPoint give the receiver the
      * hint about how the new and old rect of the image correspond to
      * each other. They specify the point of the image around which
      * the conversion was done. This point will stay still on the
      * user's screen. That is the \p newStillPoint of the new image
      * will be painted at the same screen position, where \p
      * oldStillPoint of the old image was painted.
      *
      * \param oldStillPoint is a still point represented in *old*
      *                      image coordinates
      *
      * \param newStillPoint is a still point represented in *new*
      *                      image coordinates
      */
     void sigSizeChanged(const QPointF &oldStillPoint, const QPointF &newStillPoint);
 
     void sigProfileChanged(const KoColorProfile *  profile);
     void sigColorSpaceChanged(const KoColorSpace*  cs);
     void sigResolutionChanged(double xRes, double yRes);
     void sigRequestNodeReselection(KisNodeSP activeNode, const KisNodeList &selectedNodes);
 
     /**
      * Inform the model that a node was changed
      */
     void sigNodeChanged(KisNodeSP node);
 
     /**
      * Inform that the image is going to be deleted
      */
     void sigAboutToBeDeleted();
 
     /**
      * The signal is emitted right after a node has been connected
      * to the graph of the nodes.
      *
      * WARNING: you must not request any graph-related information
      * about the node being run in a not-scheduler thread. If you need
      * information about the parent/siblings of the node connect
      * with Qt::DirectConnection, get needed information and then
      * emit another Qt::AutoConnection signal to pass this information
      * to your thread. See details of the implementation
      * in KisDummiesfacadeBase.
      */
     void sigNodeAddedAsync(KisNodeSP node);
 
     /**
      * This signal is emitted right before a node is going to removed
      * from the graph of the nodes.
      *
      * WARNING: you must not request any graph-related information
      * about the node being run in a not-scheduler thread.
      *
      * \see comment in sigNodeAddedAsync()
      */
     void sigRemoveNodeAsync(KisNodeSP node);
 
     /**
      * Emitted when the root node of the image has changed.
      * It happens, e.g. when we flatten the image. When
      * this happens the receiver should reload information
      * about the image
      */
     void sigLayersChangedAsync();
 
     /**
      * Emitted when the UI has requested the undo of the last stroke's
      * operation. The point is, we cannot deal with the internals of
      * the stroke without its creator knowing about it (which most
      * probably cause a crash), so we just forward this request from
      * the UI to the creator of the stroke.
      *
      * If your tool supports undoing part of its work, just listen to
      * this signal and undo when it comes
      */
     void sigUndoDuringStrokeRequested();
 
     /**
      * Emitted when the UI has requested the cancellation of
      * the stroke. The point is, we cannot cancel the stroke
      * without its creator knowing about it (which most probably
      * cause a crash), so we just forward this request from the UI
      * to the creator of the stroke.
      *
      * If your tool supports cancelling of its work in the middle
      * of operation, just listen to this signal and cancel
      * the stroke when it comes
      */
     void sigStrokeCancellationRequested();
 
     /**
      * Emitted when the image decides that the stroke should better
      * be ended. The point is, we cannot just end the stroke
      * without its creator knowing about it (which most probably
      * cause a crash), so we just forward this request from the UI
      * to the creator of the stroke.
      *
      * If your tool supports long  strokes that may involve multiple
      * mouse actions in one stroke, just listen to this signal and
      * end the stroke when it comes.
      */
     void sigStrokeEndRequested();
 
     /**
      * Same as sigStrokeEndRequested() but is not emitted when the active node
      * is changed.
      */
     void sigStrokeEndRequestedActiveNodeFiltered();
 
     /**
      * Emitted when the isolated mode status has changed.
      *
      * Can be used by the receivers to catch a fact of forcefully
      * stopping the isolated mode by the image when some complex
      * action was requested
      */
     void sigIsolatedModeChanged();
 
     /**
      * Emitted when one or more nodes changed the collapsed state
      *
      */
     void sigNodeCollapsedChanged();
 
     /**
      * Emitted when the proofing configuration of the image is being changed.
      *
      */
     void sigProofingConfigChanged();
 
     /**
      * Internal signal for asynchronously requesting isolated mode to stop. Don't use it
      * outside KisImage, use sigIsolatedModeChanged() instead.
      */
     void sigInternalStopIsolatedModeRequested();
 
 public Q_SLOTS:
     KisCompositeProgressProxy* compositeProgressProxy();
 
     bool isIdle(bool allowLocked = false);
 
     /**
      * @brief Wait until all the queued background jobs are completed and lock the image.
      *
      * KisImage object has a local scheduler that executes long-running image
      * rendering/modifying jobs (we call them "strokes") in a background. Basically,
      * one should either access the image from the scope of such jobs (strokes) or
      * just lock the image before using.
      *
      * Calling barrierLock() will wait until all the queued operations are finished
      * and lock the image, so you can start accessing it in a safe way.
      *
      * @p readOnly tells the image if the caller is going to modify the image during
      *             holding the lock. Locking with non-readOnly  access will reset all
      *             the internal caches of the image (lod-planes) when the lock status
      *             will be lifted.
      */
     void barrierLock(bool readOnly = false);
 
     /**
      * @brief Tries to lock the image without waiting for the jobs to finish
      *
      * Same as barrierLock(), but doesn't block execution of the calling thread
      * until all the background jobs are finished. Instead, in case of presence of
      * unfinished jobs in the queue, it just returns false
      *
      * @return whether the lock has been acquired
      * @see barrierLock
      */
     bool tryBarrierLock(bool readOnly = false);
 
     /**
      * Wait for all the internal image jobs to complete and return without locking
      * the image. This function is handly for tests or other synchronous actions,
      * when one needs to wait for the result of his actions.
      */
     void waitForDone();
 
     KisStrokeId startStroke(KisStrokeStrategy *strokeStrategy) override;
     void addJob(KisStrokeId id, KisStrokeJobData *data) override;
     void endStroke(KisStrokeId id) override;
     bool cancelStroke(KisStrokeId id) override;
 
     /**
      * @brief blockUpdates block updating the image projection
      */
     void blockUpdates() override;
 
     /**
      * @brief unblockUpdates unblock updating the image project. This
      * only restarts the scheduler and does not schedule a full refresh.
      */
     void unblockUpdates() override;
 
     /**
      * Disables notification of the UI about the changes in the image.
      * This feature is used by KisProcessingApplicator. It is needed
      * when we change the size of the image. In this case, the whole
      * image will be reloaded into UI by sigSizeChanged(), so there is
      * no need to inform the UI about individual dirty rects.
      *
      * The last call to enableUIUpdates() will return the list of updates
      * that were requested while they were blocked.
      */
     void disableUIUpdates() override;
 
     /**
      * Notify GUI about a bunch of updates planned. GUI is expected to wait
      * until all the updates are completed, and render them on screen only
      * in the very and of the batch.
      */
     void notifyBatchUpdateStarted() override;
 
     /**
      * Notify GUI that batch update has been completed. Now GUI can start
      * showing all of them on screen.
      */
     void notifyBatchUpdateEnded() override;
 
     /**
      * Notify GUI that rect \p rc is now prepared in the image and
      * GUI can read data from it.
      *
      * WARNING: GUI will read the data right in the handler of this
      *          signal, so exclusive access to the area must be guaranteed
      *          by the caller.
      */
     void notifyUIUpdateCompleted(const QRect &rc) override;
 
     /**
      * \see disableUIUpdates
      */
     QVector<QRect> enableUIUpdates() override;
 
     /**
      * Disables the processing of all the setDirty() requests that
      * come to the image. The incoming requests are effectively
      * *dropped*.
      *
      * This feature is used by KisProcessingApplicator. For many cases
      * it provides its own updates interface, which recalculates the
      * whole subtree of nodes. But while we change any particular
      * node, it can ask for an update itself. This method is a way of
      * blocking such intermediate (and excessive) requests.
      *
      * NOTE: this is a convenience function for addProjectionUpdatesFilter()
      *       that installs a predefined filter that eats everything. Please
      *       note that these calls are *not* recursive.
      *
      * WARNING: The calls to enable/disable must be balanced.
      */
     void disableDirtyRequests() override;
 
     /**
      * \see disableDirtyRequests()
      */
     void enableDirtyRequests() override;
 
     /**
      * Installs a filter object that will filter all the incoming projection update
      * requests. If the filter return true, the incoming update is dropped.
      *
      * NOTE: you can add multiple filters to the image, **but** the calls to add/remove
      *       must be nested and balanced. E.g.
      *
      *       \code{.cpp}
      *
      *       auto cookie1 = image->addProjectionUpdatesFilter(filter1);
      *       auto cookie2 = image->addProjectionUpdatesFilter(filter2);
      *
      *       /// ...do something...
      *
      *       /// correct:
      *       image->removeProjectionUpdatesFilter(cookie2)
      *       image->removeProjectionUpdatesFilter(cookie1)
      *
      *       /// incorrect:
      *       // image->removeProjectionUpdatesFilter(cookie1)
      *       // image->removeProjectionUpdatesFilter(cookie2)
      *       \endcode
      */
     KisProjectionUpdatesFilterCookie addProjectionUpdatesFilter(KisProjectionUpdatesFilterSP filter) override;
 
     /**
      * @brief removes already installed filter from the stack of updates filers
      * @param cookie a cookie object returned by addProjectionUpdatesFilter() on intallation
      * @return the installed filter. If the cookie is invalid, or nesting rule has been
      *         broken, then removeProjectionUpdatesFilter() may safe-assert and return nullptr.
      *
      * NOTE: some weird code (e.g. KisRegenerateFrameStrokeStrategy) needs to temporary remove
      * all the filters and then install them back. Current implementation ensures that after removal
      * and the following installation, cookies will be preserved. So this operation is considered
      * safe.
      *
      * \see addProjectionUpdatesFilter()
      */
     KisProjectionUpdatesFilterSP removeProjectionUpdatesFilter(KisProjectionUpdatesFilterCookie cookie) override;
 
     /**
      * Return the cookie of the lastly-installed filter
      *
      * \see addProjectionUpdatesFilter()
      */
     KisProjectionUpdatesFilterCookie currentProjectionUpdatesFilter() const override;
 
 
     void refreshGraphAsync(KisNodeSP root = KisNodeSP()) override;
     void refreshGraphAsync(KisNodeSP root, const QRect &rc) override;
     void refreshGraphAsync(KisNodeSP root, const QRect &rc, const QRect &cropRect) override;
 
     /**
      * Triggers synchronous recomposition of the projection
      */
     void refreshGraph(KisNodeSP root = KisNodeSP());
     void refreshGraph(KisNodeSP root, const QRect& rc, const QRect &cropRect);
     void initialRefreshGraph();
 
     /**
      * Initiate a stack regeneration skipping the recalculation of the
      * filthy node's projection.
      *
      * Works exactly as pseudoFilthy->setDirty() with the only
      * exception that pseudoFilthy::updateProjection() will not be
      * called. That is used by KisRecalculateTransformMaskJob to avoid
      * cyclic dependencies.
      */
     void requestProjectionUpdateNoFilthy(KisNodeSP pseudoFilthy, const QRect &rc, const QRect &cropRect);
 
+    void requestProjectionUpdateNoFilthy(KisNodeSP pseudoFilthy, const QRect &rc, const QRect &cropRect, const bool notifyFrameChange );
+
     /**
      * Adds a spontaneous job to the updates queue.
      *
      * A spontaneous job may do some trivial tasks in the background,
      * like updating the outline of selection or purging unused tiles
      * from the existing paint devices.
      */
     void addSpontaneousJob(KisSpontaneousJob *spontaneousJob);
 
     /**
      * \return true if there are some updates in the updates queue
      * Please note, that is doesn't guarantee that there are no updates
      * running in in the updater context at the very moment. To guarantee that
      * there are no updates left at all, please use barrier jobs instead.
      */
     bool hasUpdatesRunning() const override;
 
     /**
      * This method is called by the UI (*not* by the creator of the
      * stroke) when it thinks the current stroke should undo its last
      * action, for example, when the user presses Ctrl+Z while some
      * stroke is active.
      *
      * If the creator of the stroke supports undoing of intermediate
      * actions, it will be notified about this request and can undo
      * its last action.
      */
     void requestUndoDuringStroke();
 
     /**
      * This method is called by the UI (*not* by the creator of the
      * stroke) when it thinks current stroke should be cancelled. If
      * there is a running stroke that has already been detached from
      * its creator (ended or cancelled), it will be forcefully
      * cancelled and reverted. If there is an open stroke present, and
      * if its creator supports cancelling, it will be notified about
      * the request and the stroke will be cancelled
      */
     void requestStrokeCancellation();
 
     /**
      * This method requests the last stroke executed on the image to become undone.
      * If the stroke is not ended, or if all the Lod0 strokes are completed, the method
      * returns UNDO_FAIL. If the last Lod0 is going to be finished soon, then UNDO_WAIT
      * is returned and the caller should just wait for its completion and call global undo
      * instead. UNDO_OK means one unfinished stroke has been undone.
      */
     UndoResult tryUndoUnfinishedLod0Stroke();
 
     /**
      * This method is called when image or some other part of Krita
      * (*not* the creator of the stroke) decides that the stroke
      * should be ended. If the creator of the stroke supports it, it
      * will be notified and the stroke will be cancelled
      */
     void requestStrokeEnd();
 
     /**
      * Same as requestStrokeEnd() but is called by view manager when
      * the current node is changed. Use to distinguish
      * sigStrokeEndRequested() and
      * sigStrokeEndRequestedActiveNodeFiltered() which are used by
      * KisNodeJugglerCompressed
      */
     void requestStrokeEndActiveNode();
 
 private:
 
     KisImage(const KisImage& rhs, KisUndoStore *undoStore, bool exactCopy);
     KisImage& operator=(const KisImage& rhs);
 
     void emitSizeChanged();
 
     void resizeImageImpl(const QRect& newRect, bool cropLayers);
     void rotateImpl(const KUndo2MagicString &actionName, KisNodeSP rootNode, double radians,
                     bool resizeImage, KisSelectionSP selection);
     void shearImpl(const KUndo2MagicString &actionName, KisNodeSP rootNode,
                    bool resizeImage, double angleX, double angleY, KisSelectionSP selection);
 
     void safeRemoveTwoNodes(KisNodeSP node1, KisNodeSP node2);
 
     void refreshHiddenArea(KisNodeSP rootNode, const QRect &preparedArea);
 
     void requestProjectionUpdateImpl(KisNode *node,
                                      const QVector<QRect> &rects,
                                      const QRect &cropRect);
 
     friend class KisImageResizeCommand;
     void setSize(const QSize& size);
 
     void setProjectionColorSpace(const KoColorSpace * colorSpace);
 
 
     friend class KisDeselectGlobalSelectionCommand;
     friend class KisReselectGlobalSelectionCommand;
     friend class KisSetGlobalSelectionCommand;
     friend class KisImageTest;
     friend class Document; // For libkis
 
     /**
      * Replaces the current global selection with globalSelection. If
      * \p globalSelection is empty, removes the selection object, so that
      * \ref globalSelection() will return 0 after that.
      */
     void setGlobalSelection(KisSelectionSP globalSelection);
 
     /**
      * Deselects current global selection.
      * \ref globalSelection() will return 0 after that.
      */
     void deselectGlobalSelection();
 
     /**
      * Reselects current deselected selection
      *
      * \see deselectGlobalSelection()
      */
     void reselectGlobalSelection();
 
 private:
     class KisImagePrivate;
     KisImagePrivate * m_d;
 };
 
 #endif // KIS_IMAGE_H_
diff --git a/libs/image/kis_image_animation_interface.cpp b/libs/image/kis_image_animation_interface.cpp
index 2e62827d65..2edb94d12e 100644
--- a/libs/image/kis_image_animation_interface.cpp
+++ b/libs/image/kis_image_animation_interface.cpp
@@ -1,425 +1,426 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_image_animation_interface.h"
 
 #include <QFileInfo>
 
 #include "kis_global.h"
 #include "kis_image.h"
 #include "kis_regenerate_frame_stroke_strategy.h"
 #include "kis_switch_time_stroke_strategy.h"
 #include "kis_keyframe_channel.h"
 #include "kis_time_range.h"
 
 #include "kis_post_execution_undo_adapter.h"
 #include "commands_new/kis_switch_current_time_command.h"
 #include "kis_layer_utils.h"
 
 
 struct KisImageAnimationInterface::Private
 {
     Private()
         : image(0),
           externalFrameActive(false),
           frameInvalidationBlocked(false),
           cachedLastFrameValue(-1),
           audioChannelMuted(false),
           audioChannelVolume(0.5),
           m_currentTime(0),
           m_currentUITime(0)
     {
     }
 
     Private(const Private &rhs, KisImage *newImage)
         : image(newImage),
           externalFrameActive(false),
           frameInvalidationBlocked(false),
           fullClipRange(rhs.fullClipRange),
           playbackRange(rhs.playbackRange),
           framerate(rhs.framerate),
           cachedLastFrameValue(-1),
           audioChannelFileName(rhs.audioChannelFileName),
           audioChannelMuted(rhs.audioChannelMuted),
           audioChannelVolume(rhs.audioChannelVolume),
           m_currentTime(rhs.m_currentTime),
           m_currentUITime(rhs.m_currentUITime)
     {
     }
 
     KisImage *image;
     bool externalFrameActive;
     bool frameInvalidationBlocked;
 
     KisTimeRange fullClipRange;
     KisTimeRange playbackRange;
     int framerate;
     int cachedLastFrameValue;
     QString audioChannelFileName;
     bool audioChannelMuted;
     qreal audioChannelVolume;
 
     KisSwitchTimeStrokeStrategy::SharedTokenWSP switchToken;
 
     inline int currentTime() const {
         return m_currentTime;
     }
 
     inline int currentUITime() const {
         return m_currentUITime;
     }
     inline void setCurrentTime(int value) {
         m_currentTime = value;
     }
 
     inline void setCurrentUITime(int value) {
         m_currentUITime = value;
     }
 private:
     int m_currentTime;
     int m_currentUITime;
 };
 
 
 KisImageAnimationInterface::KisImageAnimationInterface(KisImage *image)
     : QObject(image),
       m_d(new Private)
 {
     m_d->image = image;
 
     m_d->framerate = 24;
     m_d->fullClipRange = KisTimeRange::fromTime(0, 100);
 
     connect(this, SIGNAL(sigInternalRequestTimeSwitch(int,bool)), SLOT(switchCurrentTimeAsync(int,bool)));
 }
 
 KisImageAnimationInterface::KisImageAnimationInterface(const KisImageAnimationInterface &rhs, KisImage *newImage)
     : m_d(new Private(*rhs.m_d, newImage))
 {
     connect(this, SIGNAL(sigInternalRequestTimeSwitch(int,bool)), SLOT(switchCurrentTimeAsync(int,bool)));
 }
 
 KisImageAnimationInterface::~KisImageAnimationInterface()
 {
 }
 
 bool KisImageAnimationInterface::hasAnimation() const
 {
     bool hasAnimation = false;
 
     KisLayerUtils::recursiveApplyNodes(
         m_d->image->root(),
         [&hasAnimation](KisNodeSP node) {
             hasAnimation |= node->isAnimated();
         });
 
     return hasAnimation;
 }
 
 int KisImageAnimationInterface::currentTime() const
 {
     return m_d->currentTime();
 }
 
 int KisImageAnimationInterface::currentUITime() const
 {
     return m_d->currentUITime();
 }
 
 const KisTimeRange& KisImageAnimationInterface::fullClipRange() const
 {
     return m_d->fullClipRange;
 }
 
 void KisImageAnimationInterface::setFullClipRange(const KisTimeRange range)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(!range.isInfinite());
     m_d->fullClipRange = range;
     emit sigFullClipRangeChanged();
 }
 
 void KisImageAnimationInterface::setFullClipRangeStartTime(int column)
 {
     KisTimeRange newRange(column,  m_d->fullClipRange.end(), false);
     setFullClipRange(newRange);
 }
 
 void KisImageAnimationInterface::setFullClipRangeEndTime(int column)
 {
     KisTimeRange newRange(m_d->fullClipRange.start(), column, false);
     setFullClipRange(newRange);
 }
 
 const KisTimeRange& KisImageAnimationInterface::playbackRange() const
 {
     return m_d->playbackRange.isValid() ? m_d->playbackRange : m_d->fullClipRange;
 }
 
 void KisImageAnimationInterface::setPlaybackRange(const KisTimeRange range)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(!range.isInfinite());
     m_d->playbackRange = range;
     emit sigPlaybackRangeChanged();
 }
 
 int KisImageAnimationInterface::framerate() const
 {
     return m_d->framerate;
 }
 
 QString KisImageAnimationInterface::audioChannelFileName() const
 {
     return m_d->audioChannelFileName;
 }
 
 void KisImageAnimationInterface::setAudioChannelFileName(const QString &fileName)
 {
     QFileInfo info(fileName);
 
     KIS_SAFE_ASSERT_RECOVER_NOOP(fileName.isEmpty() || info.isAbsolute());
     m_d->audioChannelFileName = fileName.isEmpty() ? fileName : info.absoluteFilePath();
 
     emit sigAudioChannelChanged();
 }
 
 bool KisImageAnimationInterface::isAudioMuted() const
 {
     return m_d->audioChannelMuted;
 }
 
 void KisImageAnimationInterface::setAudioMuted(bool value)
 {
     m_d->audioChannelMuted = value;
     emit sigAudioChannelChanged();
 }
 
 qreal KisImageAnimationInterface::audioVolume() const
 {
     return m_d->audioChannelVolume;
 }
 
 void KisImageAnimationInterface::setAudioVolume(qreal value)
 {
     m_d->audioChannelVolume = value;
     emit sigAudioVolumeChanged();
 }
 
 void KisImageAnimationInterface::setFramerate(int fps)
 {
     m_d->framerate = fps;
     emit sigFramerateChanged();
 }
 
 KisImageWSP KisImageAnimationInterface::image() const
 {
     return m_d->image;
 }
 
 bool KisImageAnimationInterface::externalFrameActive() const
 {
     return m_d->externalFrameActive;
 }
 
 void KisImageAnimationInterface::requestTimeSwitchWithUndo(int time)
 {
     if (currentUITime() == time) return;
     requestTimeSwitchNonGUI(time, true);
 }
 
 void KisImageAnimationInterface::setDefaultProjectionColor(const KoColor &color)
 {
     int savedTime = 0;
     saveAndResetCurrentTime(currentTime(), &savedTime);
 
     m_d->image->setDefaultProjectionColor(color);
 
     restoreCurrentTime(&savedTime);
 }
 
 void KisImageAnimationInterface::requestTimeSwitchNonGUI(int time, bool useUndo)
 {
     emit sigInternalRequestTimeSwitch(time, useUndo);
 }
 
 void KisImageAnimationInterface::explicitlySetCurrentTime(int frameId)
 {
     m_d->setCurrentTime(frameId);
 }
 
 void KisImageAnimationInterface::switchCurrentTimeAsync(int frameId, bool useUndo)
 {
     if (currentUITime() == frameId) return;
 
     const KisTimeRange range = KisTimeRange::calculateIdenticalFramesRecursive(m_d->image->root(), currentUITime());
     const bool needsRegeneration = !range.contains(frameId);
 
     KisSwitchTimeStrokeStrategy::SharedTokenSP token =
         m_d->switchToken.toStrongRef();
 
     if (!token || !token->tryResetDestinationTime(frameId, needsRegeneration)) {
 
         {
             KisPostExecutionUndoAdapter *undoAdapter = useUndo ?
                 m_d->image->postExecutionUndoAdapter() : 0;
 
             KisSwitchTimeStrokeStrategy *strategy =
                 new KisSwitchTimeStrokeStrategy(frameId, needsRegeneration,
                                                 this, undoAdapter);
 
             m_d->switchToken = strategy->token();
 
             KisStrokeId stroke = m_d->image->startStroke(strategy);
             m_d->image->endStroke(stroke);
         }
 
         if (needsRegeneration) {
             KisStrokeStrategy *strategy =
                 new KisRegenerateFrameStrokeStrategy(this);
 
             KisStrokeId strokeId = m_d->image->startStroke(strategy);
             m_d->image->endStroke(strokeId);
         }
+
     }
 
     m_d->setCurrentUITime(frameId);
     emit sigUiTimeChanged(frameId);
 }
 
 void KisImageAnimationInterface::requestFrameRegeneration(int frameId, const KisRegion &dirtyRegion)
 {
     KisStrokeStrategy *strategy =
         new KisRegenerateFrameStrokeStrategy(frameId,
                                              dirtyRegion,
                                              this);
 
     QList<KisStrokeJobData*> jobs = KisRegenerateFrameStrokeStrategy::createJobsData(m_d->image);
 
     KisStrokeId stroke = m_d->image->startStroke(strategy);
     Q_FOREACH (KisStrokeJobData* job, jobs) {
         m_d->image->addJob(stroke, job);
     }
     m_d->image->endStroke(stroke);
 }
 
 void KisImageAnimationInterface::saveAndResetCurrentTime(int frameId, int *savedValue)
 {
     m_d->externalFrameActive = true;
     *savedValue = m_d->currentTime();
     m_d->setCurrentTime(frameId);
 }
 
 void KisImageAnimationInterface::restoreCurrentTime(int *savedValue)
 {
     m_d->setCurrentTime(*savedValue);
     m_d->externalFrameActive = false;
 }
 
 void KisImageAnimationInterface::notifyFrameReady()
 {
     emit sigFrameReady(m_d->currentTime());
 }
 
 void KisImageAnimationInterface::notifyFrameCancelled()
 {
     emit sigFrameCancelled();
 }
 
 KisUpdatesFacade* KisImageAnimationInterface::updatesFacade() const
 {
     return m_d->image;
 }
 
 void KisImageAnimationInterface::notifyNodeChanged(const KisNode *node,
                                                    const QRect &rect,
                                                    bool recursive)
 {
     notifyNodeChanged(node, QVector<QRect>({rect}), recursive);
 }
 
 void KisImageAnimationInterface::notifyNodeChanged(const KisNode *node,
                                                    const QVector<QRect> &rects,
                                                    bool recursive)
 {
     if (externalFrameActive() || m_d->frameInvalidationBlocked) return;
 
     // even overlay selection masks are not rendered in the cache
     if (node->inherits("KisSelectionMask")) return;
 
     const int currentTime = m_d->currentTime();
     KisTimeRange invalidateRange;
 
     if (recursive) {
         invalidateRange = KisTimeRange::calculateAffectedFramesRecursive(node, currentTime);
     } else {
         invalidateRange = KisTimeRange::calculateNodeAffectedFrames(node, currentTime);
     }
 
     // we compress the updated rect (atm, no one uses it anyway)
     QRect unitedRect;
     Q_FOREACH (const QRect &rc, rects) {
         unitedRect |= rc;
     }
 
     invalidateFrames(invalidateRange, unitedRect);
 }
 
 void KisImageAnimationInterface::invalidateFrames(const KisTimeRange &range, const QRect &rect)
 {
     m_d->cachedLastFrameValue = -1;
     emit sigFramesChanged(range, rect);
 }
 
 void KisImageAnimationInterface::blockFrameInvalidation(bool value)
 {
     m_d->frameInvalidationBlocked = value;
 }
 
 int findLastKeyframeTimeRecursive(KisNodeSP node)
 {
     int time = 0;
 
     KisKeyframeChannel *channel;
     Q_FOREACH (channel, node->keyframeChannels()) {
         KisKeyframeSP keyframe = channel->lastKeyframe();
         if (keyframe) {
             time = std::max(time, keyframe->time());
         }
     }
 
     KisNodeSP child = node->firstChild();
     while (child) {
         time = std::max(time, findLastKeyframeTimeRecursive(child));
         child = child->nextSibling();
     }
 
     return time;
 }
 
 int KisImageAnimationInterface::totalLength()
 {
     if (m_d->cachedLastFrameValue < 0) {
         m_d->cachedLastFrameValue = findLastKeyframeTimeRecursive(m_d->image->root());
     }
 
     int lastKey = m_d->cachedLastFrameValue;
 
     lastKey  = std::max(lastKey, m_d->fullClipRange.end());
     lastKey  = std::max(lastKey, m_d->currentUITime());
 
     return lastKey + 1;
 }
diff --git a/libs/image/kis_legacy_undo_adapter.cpp b/libs/image/kis_legacy_undo_adapter.cpp
index e988a85a8c..483352ead5 100644
--- a/libs/image/kis_legacy_undo_adapter.cpp
+++ b/libs/image/kis_legacy_undo_adapter.cpp
@@ -1,75 +1,83 @@
 /*
  *  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_legacy_undo_adapter.h"
 
 #include "kis_image.h"
 
 
 KisLegacyUndoAdapter::KisLegacyUndoAdapter(KisUndoStore *undoStore,
                                            KisImageWSP image)
     : KisUndoAdapter(undoStore, image.data()),
       m_image(image),
       m_macroCounter(0)
 {
 }
 
 const KUndo2Command* KisLegacyUndoAdapter::presentCommand()
 {
     return undoStore()->presentCommand();
 }
 
 void KisLegacyUndoAdapter::undoLastCommand()
 {
     undoStore()->undoLastCommand();
 }
 
 void KisLegacyUndoAdapter::addCommand(KUndo2Command *command)
 {
     if(!command) return;
 
     if(m_macroCounter) {
         undoStore()->addCommand(command);
     }
     else {
         m_image->barrierLock();
         undoStore()->addCommand(command);
         m_image->unlock();
+
+        /// Sometimes legacy commands forget to emit sigImageModified() signal,
+        /// it causes dockers to be updated in correctly. Let's help them.
+        m_image->setModified();
     }
 }
 
 void KisLegacyUndoAdapter::beginMacro(const KUndo2MagicString& macroName)
 {
     if(!m_macroCounter) {
         m_image->barrierLock();
     }
 
     m_macroCounter++;
     undoStore()->beginMacro(macroName);
 }
 
 void KisLegacyUndoAdapter::endMacro()
 {
     m_macroCounter--;
 
     if(!m_macroCounter) {
         m_image->unlock();
     }
     undoStore()->endMacro();
+
+    /// Sometimes legacy commands forget to emit sigImageModified() signal,
+    /// it causes dockers to be updated in correctly. Let's help them.
+    m_image->setModified();
 }
 
diff --git a/libs/image/kis_recalculate_transform_mask_job.cpp b/libs/image/kis_recalculate_transform_mask_job.cpp
index a5a492c36f..fc5d78a3f7 100644
--- a/libs/image/kis_recalculate_transform_mask_job.cpp
+++ b/libs/image/kis_recalculate_transform_mask_job.cpp
@@ -1,100 +1,106 @@
 /*
  *  Copyright (c) 2014 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_recalculate_transform_mask_job.h"
 
 #include "kis_transform_mask.h"
 #include "kis_debug.h"
 #include "kis_layer.h"
 #include "kis_image.h"
+#include "kis_image_animation_interface.h"
 #include "kis_abstract_projection_plane.h"
 #include "kis_transform_mask_params_interface.h"
 
 KisRecalculateTransformMaskJob::KisRecalculateTransformMaskJob(KisTransformMaskSP mask)
     : m_mask(mask)
 {
     setExclusive(true);
 }
 
 bool KisRecalculateTransformMaskJob::overrides(const KisSpontaneousJob *_otherJob)
 {
     const KisRecalculateTransformMaskJob *otherJob =
         dynamic_cast<const KisRecalculateTransformMaskJob*>(_otherJob);
 
     return otherJob && otherJob->m_mask == m_mask;
 }
 
 void KisRecalculateTransformMaskJob::run()
 {
     /**
      * The mask might have been deleted from the layers stack. In
      * such a case, don't try do update it.
      */
     if (!m_mask->parent()) return;
 
     m_mask->recaclulateStaticImage();
 
     KisLayerSP layer = qobject_cast<KisLayer*>(m_mask->parent().data());
 
     if (!layer) {
         warnKrita << "WARNING: KisRecalculateTransformMaskJob::run() Mask has no parent layer! Skipping projection update!";
         return;
     }
 
     KisImageSP image = layer->image();
     Q_ASSERT(image);
 
-
     /**
      * Depending on whether the mask is hidden we should either
      * update it entirely via the setDirty() call, or we can use a
      * lightweight approach by directly regenerating the
      * precalculated static image using
      * KisRecalculateTransformMaskJob.
      */
     if (m_mask->transformParams()->isHidden()) {
         QRect updateRect = m_mask->extent();
 
         if (layer->original()) {
             updateRect |= layer->original()->defaultBounds()->bounds();
         }
-        m_mask->setDirty(updateRect);
+
+        if (layer->isAnimated()) {
+            m_mask->setDirty(updateRect);
+        } else {
+            m_mask->setDirtyDontResetAnimationCache(updateRect);
+        }
     } else {
         /**
          * When we call requestProjectionUpdateNoFilthy() on a layer,
          * its masks' change rect is not counted, because it is considered
          * to be N_ABOVE_FILTHY. Therefore, we should expand the dirty
          * rect manually to get the correct update
          */
+
         QRect updateRect = layer->projectionPlane()->changeRect(layer->extent(), KisLayer::N_FILTHY);
-        image->requestProjectionUpdateNoFilthy(layer, updateRect, image->bounds());
+        image->requestProjectionUpdateNoFilthy(layer, updateRect, image->bounds(),layer->isAnimated());
     }
 }
 
 int KisRecalculateTransformMaskJob::levelOfDetail() const
 {
     return 0;
 }
 
 QString KisRecalculateTransformMaskJob::debugName() const
 {
     QString result;
     QDebug dbg(&result);
     dbg << "KisRecalculateTransformMaskJob" << m_mask;
     return result;
 }
diff --git a/libs/pigment/KoColorSpace.h b/libs/pigment/KoColorSpace.h
index df314198c4..e10bb70673 100644
--- a/libs/pigment/KoColorSpace.h
+++ b/libs/pigment/KoColorSpace.h
@@ -1,646 +1,674 @@
 /*
  *  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> 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;
 
     /**
      * Position of the alpha channel in a pixel
      */
     virtual quint32 alphaPos() 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
      * @param conversionFlags conversion flags
      */
     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 source
      * @param dst destination
      * @param numPixels the amount of pixels.
      * @param proofingTransform the intent used for proofing.
      * @return
      */
     virtual bool proofPixelsTo(const quint8 * src,
                                quint8 * dst,
                                quint32 numPixels,
                                KoColorConversionTransformation *proofingTransform) const;
 
+    /**
+     * Convert @p nPixels pixels in @p src into their human-visible
+     * visual representation. The channel is shown as grayscale.
+     *
+     * Both buffers are in the same color space.
+     *
+     * @param src source buffer in (*this) color space
+     * @param dst destination buffer in the same color space as @p src
+     * @param nPixels length of the buffers in number of pixels
+     * @param pixelSize stride of each pixel in the destination buffer
+     * @param selectedChannelIndex Index of the selected channel.
+     */
+    virtual void convertChannelToVisualRepresentation(const quint8 *src, quint8 *dst, quint32 nPixels, const qint32 selectedChannelIndex) const = 0;
+
+    /**
+     * Convert @p nPixels pixels in @p src into their human-visible
+     * visual representation. The channels are shown as if other channels were null (or, if Lab, L = 1.0, *a = *b = 0.0).
+     *
+     * Both buffers are in the same color space.
+     *
+     * @param src source buffer in (*this) color space
+     * @param dst destination buffer in the same color space as @p src
+     * @param nPixels length of the buffers in number of pixels
+     * @param pixelSize stride of each pixel in the destination buffer
+     * @param selectedChannels Bitmap of selected channels
+     */
+    virtual void convertChannelToVisualRepresentation(const quint8 *src, quint8 *dst, quint32 nPixels, const QBitArray selectedChannels) const = 0;
+
 //============================== 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 params 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
      * @param renderingIntent the rendering intent
      * @param conversionFlags the conversion flags.
      *
      */
     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 https://web.archive.org/web/20110826002520/http://create.freedesktop.org/wiki/Swatches_-_colour_file_format/Draft
      *
      * 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 https://web.archive.org/web/20110826002520/http://create.freedesktop.org/wiki/Swatches_-_colour_file_format/Draft
      *
      * @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/KoColorSpaceAbstract.h b/libs/pigment/KoColorSpaceAbstract.h
index 54f4519e63..fd1a6776ae 100644
--- a/libs/pigment/KoColorSpaceAbstract.h
+++ b/libs/pigment/KoColorSpaceAbstract.h
@@ -1,216 +1,247 @@
 /*
  *  Copyright (c) 2006 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2007 Emanuele Tamponi <emanuele@valinor.it>
  *
  * 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 KOCOLORSPACEABSTRACT_H
 #define KOCOLORSPACEABSTRACT_H
 
 #include <QBitArray>
 #include <klocalizedstring.h>
 
 #include <KoColorSpace.h>
 #include <KoColorProfile.h>
 #include <KoColorSpaceMaths.h>
 #include <KoColorSpaceRegistry.h>
 #include "KoFallBackColorTransformation.h"
 #include "KoLabDarkenColorTransformation.h"
 #include "KoMixColorsOpImpl.h"
 
 #include "KoConvolutionOpImpl.h"
 #include "KoInvertColorTransformation.h"
 
 /**
  * This in an implementation of KoColorSpace which can be used as a base for colorspaces with as many
  * different channels of the same type.
  *
  * The template parameters must be a class which inherits KoColorSpaceTrait (or a class with the same signature).
  *
  * SOMETYPE is the type of the channel for instance (quint8, quint32...),
  * SOMENBOFCHANNELS is the number of channels including the alpha channel
  * SOMEALPHAPOS is the position of the alpha channel in the pixel (can be equal to -1 if no alpha channel).
  */
 template<class _CSTrait>
 class KoColorSpaceAbstract : public KoColorSpace
 {
 public:
     typedef _CSTrait ColorSpaceTraits;
 
 public:
     KoColorSpaceAbstract(const QString &id, const QString &name) :
         KoColorSpace(id, name, new KoMixColorsOpImpl< _CSTrait>(), new KoConvolutionOpImpl< _CSTrait>()) {
     }
 
     quint32 colorChannelCount() const override {
         if (_CSTrait::alpha_pos == -1)
             return _CSTrait::channels_nb;
         else
             return _CSTrait::channels_nb - 1;
     }
 
     quint32 channelCount() const override {
         return _CSTrait::channels_nb;
     }
 
     quint32 alphaPos() const override {
         return _CSTrait::alpha_pos;
     }
 
 
     quint32 pixelSize() const override {
         return _CSTrait::pixelSize;
     }
 
     QString channelValueText(const quint8 *pixel, quint32 channelIndex) const override {
         return _CSTrait::channelValueText(pixel, channelIndex);
     }
 
     QString normalisedChannelValueText(const quint8 *pixel, quint32 channelIndex) const override {
         return _CSTrait::normalisedChannelValueText(pixel, channelIndex);
     }
 
     void normalisedChannelsValue(const quint8 *pixel, QVector<float> &channels) const override {
         return _CSTrait::normalisedChannelsValue(pixel, channels);
     }
 
     void fromNormalisedChannelsValue(quint8 *pixel, const QVector<float> &values) const override {
         return _CSTrait::fromNormalisedChannelsValue(pixel, values);
     }
 
     quint8 scaleToU8(const quint8 * srcPixel, qint32 channelIndex) const override {
         typename _CSTrait::channels_type c = _CSTrait::nativeArray(srcPixel)[channelIndex];
         return KoColorSpaceMaths<typename _CSTrait::channels_type, quint8>::scaleToA(c);
     }
 
     void singleChannelPixel(quint8 *dstPixel, const quint8 *srcPixel, quint32 channelIndex) const override {
         _CSTrait::singleChannelPixel(dstPixel, srcPixel, channelIndex);
     }
 
     quint8 opacityU8(const quint8 * U8_pixel) const override {
         return _CSTrait::opacityU8(U8_pixel);
     }
 
     qreal opacityF(const quint8 * U8_pixel) const override {
         return _CSTrait::opacityF(U8_pixel);
     }
 
     void setOpacity(quint8 * pixels, quint8 alpha, qint32 nPixels) const override {
         _CSTrait::setOpacity(pixels, alpha, nPixels);
     }
 
     void setOpacity(quint8 * pixels, qreal alpha, qint32 nPixels) const override {
         _CSTrait::setOpacity(pixels, alpha, nPixels);
     }
 
     void multiplyAlpha(quint8 * pixels, quint8 alpha, qint32 nPixels) const override {
         _CSTrait::multiplyAlpha(pixels, alpha, nPixels);
     }
 
     void applyAlphaU8Mask(quint8 * pixels, const quint8 * alpha, qint32 nPixels) const override {
         _CSTrait::applyAlphaU8Mask(pixels, alpha, nPixels);
     }
 
     void applyInverseAlphaU8Mask(quint8 * pixels, const quint8 * alpha, qint32 nPixels) const override {
         _CSTrait::applyInverseAlphaU8Mask(pixels, alpha, nPixels);
     }
 
     void applyAlphaNormedFloatMask(quint8 * pixels, const float * alpha, qint32 nPixels) const override {
         _CSTrait::applyAlphaNormedFloatMask(pixels, alpha, nPixels);
     }
 
     void applyInverseNormedFloatMask(quint8 * pixels, const float * alpha, qint32 nPixels) const override {
         _CSTrait::applyInverseAlphaNormedFloatMask(pixels, alpha, nPixels);
     }
 
     quint8 intensity8(const quint8 * src) const override {
         QColor c;
         const_cast<KoColorSpaceAbstract<_CSTrait> *>(this)->toQColor(src, &c);
         return static_cast<quint8>(c.red() * 0.30 + c.green() * 0.59 + c.blue() * 0.11);
     }
 
     KoColorTransformation* createInvertTransformation() const override {
         return KoInvertColorTransformation::getTransformator(this);
     }
 
     KoColorTransformation *createDarkenAdjustment(qint32 shade, bool compensate, qreal compensation) const override {
         return new KoFallBackColorTransformation(this, KoColorSpaceRegistry::instance()->lab16(""), new KoLabDarkenColorTransformation<quint16>(shade, compensate, compensation, KoColorSpaceRegistry::instance()->lab16("")));
     }
 
     bool convertPixelsTo(const quint8 *src,
                                  quint8 *dst, const KoColorSpace *dstColorSpace,
                                  quint32 numPixels,
                                  KoColorConversionTransformation::Intent renderingIntent,
                                  KoColorConversionTransformation::ConversionFlags conversionFlags) const override
     {
 
         // check whether we have the same profile and color model, but only a different bit
         // depth; in that case we don't convert as such, but scale
         bool scaleOnly = false;
 
         // Note: getting the id() is really, really expensive, so only do that if
         // we are sure there is a difference between the colorspaces
         if (!(*this == *dstColorSpace)) {
             scaleOnly = dstColorSpace->colorModelId().id() == colorModelId().id() &&
                          dstColorSpace->colorDepthId().id() != colorDepthId().id() &&
                          dstColorSpace->profile()->name()   == profile()->name();
         }
 
         if (scaleOnly && dynamic_cast<const KoColorSpaceAbstract*>(dstColorSpace)) {
             typedef typename _CSTrait::channels_type channels_type;
 
             switch(dstColorSpace->channels()[0]->channelValueType())
             {
             case KoChannelInfo::UINT8:
                 scalePixels<_CSTrait::pixelSize, 1, channels_type, quint8>(src, dst, numPixels);
                 return true;
 //             case KoChannelInfo::INT8:
 //                 scalePixels<_CSTrait::pixelSize, 1, channels_type, qint8>(src, dst, numPixels);
 //                 return true;
             case KoChannelInfo::UINT16:
                 scalePixels<_CSTrait::pixelSize, 2, channels_type, quint16>(src, dst, numPixels);
                 return true;
             case KoChannelInfo::INT16:
                 scalePixels<_CSTrait::pixelSize, 2, channels_type, qint16>(src, dst, numPixels);
                 return true;
             case KoChannelInfo::UINT32:
                 scalePixels<_CSTrait::pixelSize, 4, channels_type, quint32>(src, dst, numPixels);
                 return true;
             default:
                 break;
             }
         }
 
         return KoColorSpace::convertPixelsTo(src, dst, dstColorSpace, numPixels, renderingIntent, conversionFlags);
     }
 
+    void convertChannelToVisualRepresentation(const quint8 *src, quint8 *dst, quint32 nPixels, const qint32 selectedChannelIndex) const override
+    {
+        qint32 selectedChannelPos = this->channels()[selectedChannelIndex]->pos();
+        for (uint pixelIndex = 0; pixelIndex < nPixels; ++pixelIndex) {
+            for (uint channelIndex = 0; channelIndex < this->channelCount(); ++channelIndex) {
+                KoChannelInfo *channel = this->channels().at(channelIndex);
+                qint32 channelSize = channel->size();
+                if (channel->channelType() == KoChannelInfo::COLOR) {
+                    memcpy(dst + (pixelIndex * _CSTrait::pixelSize) + (channelIndex * channelSize), src + (pixelIndex * _CSTrait::pixelSize) + selectedChannelPos, channelSize);
+                } else if (channel->channelType() == KoChannelInfo::ALPHA) {
+                    memcpy(dst + (pixelIndex * _CSTrait::pixelSize) + (channelIndex * channelSize), src + (pixelIndex * _CSTrait::pixelSize) + (channelIndex * channelSize), channelSize);
+                }
+            }
+        }
+    }
+
+    void convertChannelToVisualRepresentation(const quint8 *src, quint8 *dst, quint32 nPixels, const QBitArray selectedChannels) const override
+    {
+        for (uint pixelIndex = 0; pixelIndex < nPixels; ++pixelIndex) {
+            for (uint channelIndex = 0; channelIndex < this->channelCount(); ++channelIndex) {
+                KoChannelInfo *channel = this->channels().at(channelIndex);
+                qint32 channelSize = channel->size();
+                if (selectedChannels.testBit(channelIndex)) {
+                    memcpy(dst + (pixelIndex * _CSTrait::pixelSize) + (channelIndex * channelSize), src + (pixelIndex * _CSTrait::pixelSize) + (channelIndex * channelSize), channelSize);
+                } else {
+                    reinterpret_cast<typename _CSTrait::channels_type *>(dst + (pixelIndex * _CSTrait::pixelSize) + (channelIndex * channelSize))[0] = _CSTrait::math_trait::zeroValue;
+                }
+            }
+        }
+    }
+
 private:
     template<int srcPixelSize, int dstChannelSize, class TSrcChannel, class TDstChannel>
     void scalePixels(const quint8* src, quint8* dst, quint32 numPixels) const {
         qint32 dstPixelSize = dstChannelSize * _CSTrait::channels_nb;
 
         for(quint32 i=0; i<numPixels; ++i) {
             const TSrcChannel* srcPixel = reinterpret_cast<const TSrcChannel*>(src + i * srcPixelSize);
             TDstChannel*       dstPixel = reinterpret_cast<TDstChannel*>(dst + i * dstPixelSize);
 
             for(quint32 c=0; c<_CSTrait::channels_nb; ++c)
                 dstPixel[c] = Arithmetic::scale<TDstChannel>(srcPixel[c]);
         }
     }
 };
 
 #endif // KOCOLORSPACEABSTRACT_H
diff --git a/libs/pigment/KoColorSpaceTraits.h b/libs/pigment/KoColorSpaceTraits.h
index 5c73af4667..f17ae4c51d 100644
--- a/libs/pigment/KoColorSpaceTraits.h
+++ b/libs/pigment/KoColorSpaceTraits.h
@@ -1,235 +1,238 @@
 /*
  *  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 _KO_COLORSPACE_TRAITS_H_
 #define _KO_COLORSPACE_TRAITS_H_
 
 #include <QVector>
 
 #include "KoColorSpaceConstants.h"
 #include "KoColorSpaceMaths.h"
 #include "DebugPigment.h"
 
 const int MAX_CHANNELS_TYPE_SIZE = sizeof(double);
 const int MAX_CHANNELS_NB = 5;
 const int MAX_PIXEL_SIZE = MAX_CHANNELS_NB * MAX_CHANNELS_TYPE_SIZE;
 
 /**
  * This class is the base class to define the main characteristics of a colorspace
  * which inherits KoColorSpaceAbstract.
  *
  * - _channels_type_ is the type of the value use for each channel, for example quint8 for 8bits per channel
  *                   color spaces, or quint16 for 16bits integer per channel, float for 32bits per channel
  *                   floating point color spaces
  * - _channels_nb_ is the total number of channels in an image (for example RGB is 3 but RGBA is four)
  * - _alpha_pos_ is the position of the alpha channel among the channels, if there is no alpha channel,
  *               then _alpha_pos_ is set to -1
  *
  * For instance a colorspace of three color channels and alpha channel in 16bits,
  * will be defined as KoColorSpaceTrait\<quint16, 4, 3\>. The same without the alpha
  * channel is KoColorSpaceTrait\<quint16,3,-1\>
  *
  */
 template<typename _channels_type_, int _channels_nb_, int _alpha_pos_>
 struct KoColorSpaceTrait {
 
     static_assert(sizeof(_channels_type_) <= MAX_CHANNELS_TYPE_SIZE, "MAX_CHANNELS_TYPE_SIZE too small");
     static_assert(_channels_nb_ <= MAX_CHANNELS_NB, "MAX_CHANNELS_NB too small");
 
     /// the type of the value of the channels of this color space
     typedef _channels_type_ channels_type;
 
     /// the number of channels in this color space
     static const quint32 channels_nb = _channels_nb_;
 
     /// the position of the alpha channel in the channels of the pixel (or -1 if no alpha
     /// channel.
     static const qint32 alpha_pos = _alpha_pos_;
 
     /// the number of bit for each channel
     static const int depth = KoColorSpaceMathsTraits<_channels_type_>::bits;
 
+    /// the associated math class
+    typedef KoColorSpaceMathsTraits<_channels_type_> math_trait;
+
     /**
      * @return the size in byte of one pixel
      */
     static const quint32 pixelSize = channels_nb * sizeof(channels_type);
 
     /**
      * @return the value of the alpha channel for this pixel in the 0..255 range
      */
     inline static quint8 opacityU8(const quint8 * U8_pixel) {
         if (alpha_pos < 0) return OPACITY_OPAQUE_U8;
         channels_type c = nativeArray(U8_pixel)[alpha_pos];
         return  KoColorSpaceMaths<channels_type, quint8>::scaleToA(c);
     }
 
     inline static qreal opacityF(const quint8 * U8_pixel) {
         if (alpha_pos < 0) return OPACITY_OPAQUE_F;
         channels_type c = nativeArray(U8_pixel)[alpha_pos];
         return  KoColorSpaceMaths<channels_type, qreal>::scaleToA(c);
     }
 
     /**
      * Set the alpha channel for this pixel from a value in the 0..255 range
      */
     inline static void setOpacity(quint8 * pixels, quint8 alpha, qint32 nPixels) {
         if (alpha_pos < 0) return;
         qint32 psize = pixelSize;
         channels_type valpha =  KoColorSpaceMaths<quint8, channels_type>::scaleToA(alpha);
         for (; nPixels > 0; --nPixels, pixels += psize) {
             nativeArray(pixels)[alpha_pos] = valpha;
         }
     }
 
     inline static void setOpacity(quint8 * pixels, qreal alpha, qint32 nPixels) {
         if (alpha_pos < 0) return;
         qint32 psize = pixelSize;
         channels_type valpha =  KoColorSpaceMaths<qreal, channels_type>::scaleToA(alpha);
         for (; nPixels > 0; --nPixels, pixels += psize) {
             nativeArray(pixels)[alpha_pos] = valpha;
         }
     }
 
     /**
      * Convenient function for transforming a quint8* array in a pointer of the native channels type
      */
     inline static const channels_type* nativeArray(const quint8 * a) {
         return reinterpret_cast<const channels_type*>(a);
     }
 
     /**
      * Convenient function for transforming a quint8* array in a pointer of the native channels type
      */
     inline static channels_type* nativeArray(quint8 * a) {
         return reinterpret_cast< channels_type*>(a);
     }
 
     /**
      * Allocate nPixels pixels for this colorspace.
      */
     inline static quint8* allocate(quint32 nPixels) {
         return new quint8[ nPixels * pixelSize ];
     }
 
     inline static void singleChannelPixel(quint8 *dstPixel, const quint8 *srcPixel, quint32 channelIndex) {
         const channels_type* src = nativeArray(srcPixel);
         channels_type* dst = nativeArray(dstPixel);
         for (uint i = 0; i < channels_nb; i++) {
             if (i != channelIndex) {
                 dst[i] = 0;
             } else {
                 dst[i] = src[i];
             }
         }
     }
 
     inline static QString channelValueText(const quint8 *pixel, quint32 channelIndex) {
         if (channelIndex > channels_nb) return QString("Error");
         channels_type c = nativeArray(pixel)[channelIndex];
         return QString().setNum(c);
     }
 
     inline static QString normalisedChannelValueText(const quint8 *pixel, quint32 channelIndex) {
         if (channelIndex > channels_nb) return QString("Error");
         channels_type c = nativeArray(pixel)[channelIndex];
         return QString().setNum(100. *((qreal)c) / KoColorSpaceMathsTraits< channels_type>::unitValue);
     }
 
     inline static void normalisedChannelsValue(const quint8 *pixel, QVector<float> &channels) {
         Q_ASSERT((int)channels.count() >= (int)channels_nb);
         channels_type c;
         for (uint i = 0; i < channels_nb; i++) {
             c = nativeArray(pixel)[i];
             channels[i] = ((qreal)c) / KoColorSpaceMathsTraits<channels_type>::unitValue;
         }
     }
 
     inline static void fromNormalisedChannelsValue(quint8 *pixel, const QVector<float> &values) {
         Q_ASSERT((int)values.count() >= (int)channels_nb);
         channels_type c;
         for (uint i = 0; i < channels_nb; i++) {
             float b = qBound((float)KoColorSpaceMathsTraits<channels_type>::min,
                              (float)KoColorSpaceMathsTraits<channels_type>::unitValue * values[i],
                              (float)KoColorSpaceMathsTraits<channels_type>::max);
             c = (channels_type)b;
             nativeArray(pixel)[i] = c;
 
         }
     }
     inline static void multiplyAlpha(quint8 * pixels, quint8 alpha, qint32 nPixels) {
         if (alpha_pos < 0) return;
 
         channels_type valpha =  KoColorSpaceMaths<quint8, channels_type>::scaleToA(alpha);
 
         for (; nPixels > 0; --nPixels, pixels += pixelSize) {
             channels_type* alphapixel = nativeArray(pixels) + alpha_pos;
             *alphapixel = KoColorSpaceMaths<channels_type>::multiply(*alphapixel, valpha);
         }
     }
 
     inline static void applyAlphaU8Mask(quint8 * pixels, const quint8 * alpha, qint32 nPixels) {
         if (alpha_pos < 0) return;
 
         for (; nPixels > 0; --nPixels, pixels += pixelSize, ++alpha) {
             channels_type valpha =  KoColorSpaceMaths<quint8, channels_type>::scaleToA(*alpha);
             channels_type* alphapixel = nativeArray(pixels) + alpha_pos;
             *alphapixel = KoColorSpaceMaths<channels_type>::multiply(*alphapixel, valpha);
         }
     }
 
     inline static void applyInverseAlphaU8Mask(quint8 * pixels, const quint8 * alpha, qint32 nPixels) {
         if (alpha_pos < 0) return;
 
         for (; nPixels > 0; --nPixels, pixels += pixelSize, ++alpha) {
             channels_type valpha =  KoColorSpaceMaths<quint8, channels_type>::scaleToA(OPACITY_OPAQUE_U8 - *alpha);
             channels_type* alphapixel = nativeArray(pixels) + alpha_pos;
             *alphapixel = KoColorSpaceMaths<channels_type>::multiply(*alphapixel, valpha);
         }
     }
 
     inline static void applyAlphaNormedFloatMask(quint8 * pixels, const float * alpha, qint32 nPixels) {
         if (alpha_pos < 0) return;
 
         for (; nPixels > 0; --nPixels, pixels += pixelSize, ++alpha) {
             channels_type valpha =  channels_type(KoColorSpaceMathsTraits<channels_type>::unitValue * (*alpha));
             channels_type* alphapixel = nativeArray(pixels) + alpha_pos;
             *alphapixel = KoColorSpaceMaths<channels_type>::multiply(*alphapixel, valpha);
         }
     }
 
     inline static void applyInverseAlphaNormedFloatMask(quint8 * pixels, const float * alpha, qint32 nPixels) {
         if (alpha_pos < 0) return;
 
         for (; nPixels > 0; --nPixels, pixels += pixelSize, ++alpha) {
             channels_type valpha =  channels_type(KoColorSpaceMathsTraits<channels_type>::unitValue * (1.0f - *alpha));
             channels_type* alphapixel = nativeArray(pixels) + alpha_pos;
             *alphapixel = KoColorSpaceMaths<channels_type>::multiply(*alphapixel, valpha);
         }
     }
 };
 
 #include "KoRgbColorSpaceTraits.h"
 #include "KoBgrColorSpaceTraits.h"
 #include "KoGrayColorSpaceTraits.h"
 #include "KoLabColorSpaceTraits.h"
 #include "KoXyzColorSpaceTraits.h"
 #include "KoYcbcrColorSpaceTraits.h"
 #include "KoCmykColorSpaceTraits.h"
 
 #endif
diff --git a/libs/pigment/colorspaces/KoLabColorSpace.cpp b/libs/pigment/colorspaces/KoLabColorSpace.cpp
index 03a37feb27..562324e213 100644
--- a/libs/pigment/colorspaces/KoLabColorSpace.cpp
+++ b/libs/pigment/colorspaces/KoLabColorSpace.cpp
@@ -1,196 +1,284 @@
 /*
  *  Copyright (c) 2004-2009 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2006 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 "KoLabColorSpace.h"
 
 #include <limits.h>
 #include <stdlib.h>
 #include <math.h>
 
 #include <QImage>
 #include <QBitArray>
 
 #include <klocalizedstring.h>
 
 #include "KoChannelInfo.h"
 #include "KoID.h"
 #include "KoIntegerMaths.h"
 #include "KoColorConversions.h"
 
 #include "../compositeops/KoCompositeOps.h"
 
 KoLabColorSpace::KoLabColorSpace() :
         KoSimpleColorSpace<KoLabU16Traits>(colorSpaceId(),
                                            i18n("L*a*b* (16-bit integer/channel, unmanaged)"),
                                            LABAColorModelID,
                                            Integer16BitsColorDepthID)
 {
     addChannel(new KoChannelInfo(i18n("Lightness"), CHANNEL_L     * sizeof(quint16), CHANNEL_L, KoChannelInfo::COLOR, KoChannelInfo::UINT16, sizeof(quint16), QColor(100, 100, 100)));
     addChannel(new KoChannelInfo(i18n("a*"),        CHANNEL_A     * sizeof(quint16), CHANNEL_A, KoChannelInfo::COLOR, KoChannelInfo::UINT16, sizeof(quint16), QColor(150, 150, 150)));
     addChannel(new KoChannelInfo(i18n("b*"),        CHANNEL_B     * sizeof(quint16), CHANNEL_B, KoChannelInfo::COLOR, KoChannelInfo::UINT16, sizeof(quint16), QColor(200, 200, 200)));
     addChannel(new KoChannelInfo(i18n("Alpha"),     CHANNEL_ALPHA * sizeof(quint16), CHANNEL_ALPHA, KoChannelInfo::ALPHA, KoChannelInfo::UINT16, sizeof(quint16)));
 
     // ADD, ALPHA_DARKEN, BURN, DIVIDE, DODGE, ERASE, MULTIPLY, OVER, OVERLAY, SCREEN, SUBTRACT
     addStandardCompositeOps<KoLabU16Traits>(this);
 
 }
 
 KoLabColorSpace::~KoLabColorSpace()
 {
 }
 
 
 QString KoLabColorSpace::colorSpaceId()
 {
     return QString("LABA");
 }
 
 
 KoColorSpace* KoLabColorSpace::clone() const
 {
     return new KoLabColorSpace();
 }
 
 void KoLabColorSpace::fromQColor(const QColor& c, quint8 *dst, const KoColorProfile * /*profile*/) const
 {
     // Convert between RGB and CIE-Lab color spaces
     // Uses ITU-R recommendation BT.709 with D65 as reference white.
     // algorithm contributed by "Mark A. Ruzon" <ruzon@CS.Stanford.EDU>
 
     int R, G, B, A;
     c.getRgb(&R, &G, &B, &A);
 
     double X, Y, Z, fX, fY, fZ;
 
     X = 0.412453 * R + 0.357580 * G + 0.180423 * B;
     Y = 0.212671 * R + 0.715160 * G + 0.072169 * B;
     Z = 0.019334 * R + 0.119193 * G + 0.950227 * B;
 
     X /= (255 * 0.950456);
     Y /=  255;
     Z /= (255 * 1.088754);
 
     quint8 L, a, b;
 
     if (Y > 0.008856) {
         fY = pow(Y, 1.0 / 3.0);
         L = static_cast<int>(116.0 * fY - 16.0 + 0.5);
     } else {
         fY = 7.787 * Y + 16.0 / 116.0;
         L = static_cast<int>(903.3 * Y + 0.5);
     }
 
     if (X > 0.008856)
         fX = pow(X, 1.0 / 3.0);
     else
         fX = 7.787 * X + 16.0 / 116.0;
 
     if (Z > 0.008856)
         fZ = pow(Z, 1.0 / 3.0);
     else
         fZ = 7.787 * Z + 16.0 / 116.0;
 
     a = static_cast<int>(500.0 * (fX - fY) + 0.5);
     b = static_cast<int>(200.0 * (fY - fZ) + 0.5);
 
     dst[CHANNEL_L] = UINT8_TO_UINT16(L);
     dst[CHANNEL_A] = UINT8_TO_UINT16(a);
     dst[CHANNEL_B] = UINT8_TO_UINT16(b);
     dst[CHANNEL_ALPHA] = UINT8_TO_UINT16(A);
 }
 
 void KoLabColorSpace::toQColor(const quint8 * src, QColor *c, const KoColorProfile * /*profile*/) const
 {
     // Convert between RGB and CIE-Lab color spaces
     // Uses ITU-R recommendation BT.709 with D65 as reference white.
     // algorithm contributed by "Mark A. Ruzon" <ruzon@CS.Stanford.EDU>
     quint8 L, a, b, A;
     L = UINT16_TO_UINT8(src[CHANNEL_L]);
     a = UINT16_TO_UINT8(src[CHANNEL_A]);
     b = UINT16_TO_UINT8(src[CHANNEL_B]);
     A = UINT16_TO_UINT8(src[CHANNEL_ALPHA]);
 
     double X, Y, Z, fX, fY, fZ;
     int RR, GG, BB;
 
     fY = pow((L + 16.0) / 116.0, 3.0);
     if (fY < 0.008856)
         fY = L / 903.3;
     Y = fY;
 
     if (fY > 0.008856)
         fY = pow(fY, 1.0 / 3.0);
     else
         fY = 7.787 * fY + 16.0 / 116.0;
 
     fX = a / 500.0 + fY;
     if (fX > 0.206893)
         X = pow(fX, 3.0);
     else
         X = (fX - 16.0 / 116.0) / 7.787;
 
     fZ = fY - b / 200.0;
     if (fZ > 0.206893)
         Z = pow(fZ, 3.0);
     else
         Z = (fZ - 16.0 / 116.0) / 7.787;
 
     X *= 0.950456 * 255;
     Y *= 255;
     Z *= 1.088754 * 255;
 
     RR = static_cast<int>(3.240479 * X - 1.537150 * Y - 0.498535 * Z + 0.5);
     GG = static_cast<int>(-0.969256 * X + 1.875992 * Y + 0.041556 * Z + 0.5);
     BB = static_cast<int>(0.055648 * X - 0.204043 * Y + 1.057311 * Z + 0.5);
 
     quint8 R = RR < 0 ? 0 : RR > 255 ? 255 : RR;
     quint8 G = GG < 0 ? 0 : GG > 255 ? 255 : GG;
     quint8 B = BB < 0 ? 0 : BB > 255 ? 255 : BB;
 
     c->setRgba(qRgba(R, G, B, A));
 }
 
 void KoLabColorSpace::toHSY(const QVector<double> &channelValues, qreal *hue, qreal *sat, qreal *luma) const
 {
     LabToLCH(channelValues[0],channelValues[1],channelValues[2], luma, sat, hue);
 }
 
 QVector <double> KoLabColorSpace::fromHSY(qreal *hue, qreal *sat, qreal *luma) const
 {
     QVector <double> channelValues(4);
     LCHToLab(*luma, *sat, *hue, &channelValues[0],&channelValues[1],&channelValues[2]);
     channelValues[3]=1.0;
     return channelValues;
 }
 
 void KoLabColorSpace::toYUV(const QVector<double> &channelValues, qreal *y, qreal *u, qreal *v) const
 {
     *y =channelValues[0];
     *v=channelValues[1];
     *u=channelValues[2];
 }
 
 QVector <double> KoLabColorSpace::fromYUV(qreal *y, qreal *u, qreal *v) const
 {
     QVector <double> channelValues(4);
     channelValues[0]=*y;
     channelValues[1]=*v;
     channelValues[2]=*u;
     channelValues[3]=1.0;
     return channelValues;
 }
+
+quint8 KoLabColorSpace::scaleToU8(const quint8 *srcPixel, qint32 channelIndex) const
+{
+    typename ColorSpaceTraits::channels_type c = ColorSpaceTraits::nativeArray(srcPixel)[channelIndex];
+    qreal b = 0;
+    switch (channelIndex) {
+    case ColorSpaceTraits::L_pos:
+        b = ((qreal)c) / ColorSpaceTraits::math_trait::unitValueL;
+        break;
+    case ColorSpaceTraits::a_pos:
+    case ColorSpaceTraits::b_pos:
+        if (c <= ColorSpaceTraits::math_trait::halfValueAB) {
+            b = ((qreal)c - ColorSpaceTraits::math_trait::zeroValueAB) / (2.0 * (ColorSpaceTraits::math_trait::halfValueAB - ColorSpaceTraits::math_trait::zeroValueAB));
+        } else {
+            b = 0.5 + ((qreal)c - ColorSpaceTraits::math_trait::halfValueAB) / (2.0 * (ColorSpaceTraits::math_trait::unitValueAB - ColorSpaceTraits::math_trait::halfValueAB));
+        }
+        break;
+    default:
+        b = ((qreal)c) / ColorSpaceTraits::math_trait::unitValue;
+        break;
+    }
+
+    return KoColorSpaceMaths<qreal, quint8>::scaleToA(b);
+}
+
+void KoLabColorSpace::convertChannelToVisualRepresentation(const quint8 *src, quint8 *dst, quint32 nPixels, const qint32 selectedChannelIndex) const
+{
+    for (uint pixelIndex = 0; pixelIndex < nPixels; ++pixelIndex) {
+        for (uint channelIndex = 0; channelIndex < this->channelCount(); ++channelIndex) {
+            KoChannelInfo *channel = this->channels().at(channelIndex);
+            qint32 channelSize = channel->size();
+            if (channel->channelType() == KoChannelInfo::COLOR) {
+                if (channelIndex == ColorSpaceTraits::L_pos) {
+                    ColorSpaceTraits::channels_type c = ColorSpaceTraits::parent::nativeArray((src + (pixelIndex * ColorSpaceTraits::pixelSize)))[selectedChannelIndex];
+                    switch (selectedChannelIndex) {
+                    case ColorSpaceTraits::L_pos:
+                        break;
+                    case ColorSpaceTraits::a_pos:
+                    case ColorSpaceTraits::b_pos:
+                        if (c <= ColorSpaceTraits::math_trait::halfValueAB) {
+                            c = ColorSpaceTraits::math_trait::unitValueL * (((qreal)c - ColorSpaceTraits::math_trait::zeroValueAB) / (2.0 * (ColorSpaceTraits::math_trait::halfValueAB - ColorSpaceTraits::math_trait::zeroValueAB)));
+                        } else {
+                            c = ColorSpaceTraits::math_trait::unitValueL * (0.5 + ((qreal)c - ColorSpaceTraits::math_trait::halfValueAB) / (2.0 * (ColorSpaceTraits::math_trait::unitValueAB - ColorSpaceTraits::math_trait::halfValueAB)));
+                        }
+                        break;
+                    // As per KoChannelInfo alpha channels are [0..1]
+                    default:
+                        c = ColorSpaceTraits::math_trait::unitValueL * (qreal)c / ColorSpaceTraits::math_trait::unitValue;
+                        break;
+                    }
+                    ColorSpaceTraits::parent::nativeArray(dst + (pixelIndex * ColorSpaceTraits::pixelSize))[channelIndex] = c;
+                } else {
+                    ColorSpaceTraits::parent::nativeArray(dst + (pixelIndex * ColorSpaceTraits::pixelSize))[channelIndex] = ColorSpaceTraits::math_trait::halfValueAB;
+                }
+            } else if (channel->channelType() == KoChannelInfo::ALPHA) {
+                memcpy(dst + (pixelIndex * ColorSpaceTraits::pixelSize) + (channelIndex * channelSize), src + (pixelIndex * ColorSpaceTraits::pixelSize) + (channelIndex * channelSize), channelSize);
+            }
+        }
+    }
+}
+
+void KoLabColorSpace::convertChannelToVisualRepresentation(const quint8 *src, quint8 *dst, quint32 nPixels, const QBitArray selectedChannels) const
+{
+    for (uint pixelIndex = 0; pixelIndex < nPixels; ++pixelIndex) {
+        for (uint channelIndex = 0; channelIndex < this->channelCount(); ++channelIndex) {
+            KoChannelInfo *channel = this->channels().at(channelIndex);
+            qint32 channelSize = channel->size();
+            if (selectedChannels.testBit(channelIndex)) {
+                memcpy(dst + (pixelIndex * ColorSpaceTraits::pixelSize) + (channelIndex * channelSize), src + (pixelIndex * ColorSpaceTraits::pixelSize) + (channelIndex * channelSize), channelSize);
+            } else {
+                ColorSpaceTraits::channels_type v;
+                switch (channelIndex) {
+                case ColorSpaceTraits::L_pos:
+                    v = ColorSpaceTraits::math_trait::halfValueL;
+                    break;
+                case ColorSpaceTraits::a_pos:
+                case ColorSpaceTraits::b_pos:
+                    v = ColorSpaceTraits::math_trait::halfValueAB;
+                    break;
+                default:
+                    v = ColorSpaceTraits::math_trait::zeroValue;
+                    break;
+                }
+                reinterpret_cast<ColorSpaceTraits::channels_type *>(dst + (pixelIndex * ColorSpaceTraits::pixelSize) + (channelIndex * channelSize))[0] = v;
+            }
+        }
+    }
+}
diff --git a/libs/pigment/colorspaces/KoLabColorSpace.h b/libs/pigment/colorspaces/KoLabColorSpace.h
index 1168204143..ad2a393701 100644
--- a/libs/pigment/colorspaces/KoLabColorSpace.h
+++ b/libs/pigment/colorspaces/KoLabColorSpace.h
@@ -1,87 +1,90 @@
 /*
  *  Copyright (c) 2004 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2006 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.
  */
 #ifndef KOLABCOLORSPACE_H
 #define KOLABCOLORSPACE_H
 
 #include <QColor>
 
 #include "KoSimpleColorSpace.h"
 #include "KoSimpleColorSpaceFactory.h"
 #include "KoColorModelStandardIds.h"
 
 struct KoLabU16Traits;
 
 /**
  * Basic and simple implementation of the LAB colorspace
  */
 class KoLabColorSpace : public KoSimpleColorSpace<KoLabU16Traits>
 {
 
 public:
 
     KoLabColorSpace();
 
     ~KoLabColorSpace() override;
 
     static QString colorSpaceId();
 
     virtual KoColorSpace* clone() const;
 
     void fromQColor(const QColor& color, quint8 *dst, const KoColorProfile * profile = 0) const override;
 
     void toQColor(const quint8 *src, QColor *c, const KoColorProfile * profile = 0) const override;
     
     void toHSY(const QVector<double> &channelValues, qreal *hue, qreal *sat, qreal *luma) const override;
     QVector <double> fromHSY(qreal *hue, qreal *sat, qreal *luma) const override;
     void toYUV(const QVector<double> &channelValues, qreal *y, qreal *u, qreal *v) const override;
     QVector <double> fromYUV(qreal *y, qreal *u, qreal *v) const override;
+    quint8 scaleToU8(const quint8 * srcPixel, qint32 channelIndex) const override;
+    void convertChannelToVisualRepresentation(const quint8 *src, quint8 *dst, quint32 nPixels, const qint32 selectedChannelIndex) const override;
+    void convertChannelToVisualRepresentation(const quint8 *src, quint8 *dst, quint32 nPixels, const QBitArray selectedChannels) const override;
 
 private:
 
     static const quint32 CHANNEL_L = 0;
     static const quint32 CHANNEL_A = 1;
     static const quint32 CHANNEL_B = 2;
     static const quint32 CHANNEL_ALPHA = 3;
     static const quint32 MAX_CHANNEL_L = 0xff00;
     static const quint32 MAX_CHANNEL_AB = 0xffff;
     static const quint32 CHANNEL_AB_ZERO_OFFSET = 0x8000;
 
 
 };
 
 class KoLabColorSpaceFactory : public KoSimpleColorSpaceFactory
 {
 
 public:
 
     KoLabColorSpaceFactory()
             : KoSimpleColorSpaceFactory("LABA",
                                         i18n("L*a*b* (16-bit integer/channel, unmanaged)"),
                                         true,
                                         LABAColorModelID,
                                         Integer16BitsColorDepthID) {
     }
 
     KoColorSpace *createColorSpace(const KoColorProfile *) const override {
         return new KoLabColorSpace();
     }
 
 };
 
 #endif
diff --git a/libs/ui/KisPart.cpp b/libs/ui/KisPart.cpp
index 4e6ecc263f..f0b4bfbd10 100644
--- a/libs/ui/KisPart.cpp
+++ b/libs/ui/KisPart.cpp
@@ -1,590 +1,600 @@
 /* This file is part of the KDE project
  * Copyright (C) 1998-1999 Torben Weis       <weis@kde.org>
  * Copyright (C) 2000-2005 David Faure       <faure@kde.org>
  * Copyright (C) 2007-2008 Thorsten Zachmann <zachmann@kde.org>
  * Copyright (C) 2010-2012 Boudewijn Rempt   <boud@valdyas.org>
  * Copyright (C) 2011 Inge Wallin            <ingwa@kogmbh.com>
  * Copyright (C) 2015 Michael Abrahams       <miabraha@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "KisPart.h"
 
 #include "KoProgressProxy.h"
 #include <KoCanvasController.h>
 #include <KoCanvasControllerWidget.h>
 #include <KoColorSpaceEngine.h>
 #include <KoCanvasBase.h>
 #include <KoToolManager.h>
 #include <KoShapeControllerBase.h>
 #include <KoResourceServerProvider.h>
 #include <kis_icon.h>
 
 #include "KisApplication.h"
 #include "KisMainWindow.h"
 #include "KisDocument.h"
 #include "KisView.h"
 #include "KisViewManager.h"
 #include "KisImportExportManager.h"
 
 #include <kis_debug.h>
 #include <KoResourcePaths.h>
 #include <KoDialog.h>
 #include <QMessageBox>
 #include <klocalizedstring.h>
 #include <kactioncollection.h>
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <QKeySequence>
 
 #include <QDialog>
 #include <QApplication>
 #include <QDomDocument>
 #include <QDomElement>
 #include <QGlobalStatic>
 #include <KisMimeDatabase.h>
 #include <dialogs/KisSessionManagerDialog.h>
 
 #include "kis_config.h"
 #include "kis_shape_controller.h"
 #include "KisResourceServerProvider.h"
 #include "kis_animation_cache_populator.h"
+#include "kis_image_animation_interface.h"
+#include "kis_time_range.h"
 #include "kis_idle_watcher.h"
 #include "kis_image.h"
 #include "KisOpenPane.h"
 
 #include "kis_color_manager.h"
 
 #include "kis_action.h"
 #include "kis_action_registry.h"
 #include "KisSessionResource.h"
 #include "KisBusyWaitBroker.h"
 #include "dialogs/kis_delayed_save_dialog.h"
 
 Q_GLOBAL_STATIC(KisPart, s_instance)
 
 
 class Q_DECL_HIDDEN KisPart::Private
 {
 public:
     Private(KisPart *_part)
         : part(_part)
         , idleWatcher(2500)
         , animationCachePopulator(_part)
     {
     }
 
     ~Private()
     {
     }
 
     KisPart *part;
 
     QList<QPointer<KisView> > views;
     QList<QPointer<KisMainWindow> > mainWindows;
     QList<QPointer<KisDocument> > documents;
     KActionCollection *actionCollection{0};
     KisIdleWatcher idleWatcher;
     KisAnimationCachePopulator animationCachePopulator;
 
     KisSessionResourceSP currentSession;
     bool closingSession{false};
     QScopedPointer<KisSessionManagerDialog> sessionManager;
 
     bool queryCloseDocument(KisDocument *document) {
         Q_FOREACH(auto view, views) {
             if (view && view->isVisible() && view->document() == document) {
                 return view->queryClose();
             }
         }
 
         return true;
     }
 };
 
 
 KisPart* KisPart::instance()
 {
     return s_instance;
 }
 
 namespace {
 void busyWaitWithFeedback(KisImageSP image)
 {
     const int busyWaitDelay = 1000;
     KisDelayedSaveDialog dialog(image, KisDelayedSaveDialog::ForcedDialog, busyWaitDelay, KisPart::instance()->currentMainwindow());
     dialog.blockIfImageIsBusy();
 }
 }
 
 KisPart::KisPart()
     : d(new Private(this))
 {
     // Preload all the resources in the background
     Q_UNUSED(KoResourceServerProvider::instance());
     Q_UNUSED(KisResourceServerProvider::instance());
     Q_UNUSED(KisColorManager::instance());
 
     connect(this, SIGNAL(documentOpened(QString)),
             this, SLOT(updateIdleWatcherConnections()));
 
     connect(this, SIGNAL(documentClosed(QString)),
             this, SLOT(updateIdleWatcherConnections()));
 
     connect(KisActionRegistry::instance(), SIGNAL(shortcutsUpdated()),
             this, SLOT(updateShortcuts()));
     connect(&d->idleWatcher, SIGNAL(startedIdleMode()),
             &d->animationCachePopulator, SLOT(slotRequestRegeneration()));
 
 
     d->animationCachePopulator.slotRequestRegeneration();
     KisBusyWaitBroker::instance()->setFeedbackCallback(&busyWaitWithFeedback);
 }
 
 KisPart::~KisPart()
 {
     while (!d->documents.isEmpty()) {
         delete d->documents.takeFirst();
     }
 
     while (!d->views.isEmpty()) {
         delete d->views.takeFirst();
     }
 
     while (!d->mainWindows.isEmpty()) {
         delete d->mainWindows.takeFirst();
     }
 
     delete d;
 }
 
 void KisPart::updateIdleWatcherConnections()
 {
     QVector<KisImageSP> images;
 
     Q_FOREACH (QPointer<KisDocument> document, documents()) {
         if (document->image()) {
             images << document->image();
         }
     }
 
     d->idleWatcher.setTrackedImages(images);
 }
 
 void KisPart::addDocument(KisDocument *document)
 {
     //dbgUI << "Adding document to part list" << document;
     Q_ASSERT(document);
     if (!d->documents.contains(document)) {
         d->documents.append(document);
         emit documentOpened('/'+objectName());
         emit sigDocumentAdded(document);
         connect(document, SIGNAL(sigSavingFinished()), SLOT(slotDocumentSaved()));
     }
 }
 
 QList<QPointer<KisDocument> > KisPart::documents() const
 {
     return d->documents;
 }
 
 KisDocument *KisPart::createDocument() const
 {
     KisDocument *doc = new KisDocument();
     return doc;
 }
 
 KisDocument *KisPart::createTemporaryDocument() const
 {
     KisDocument *doc = new KisDocument(false);
     return doc;
 }
 
 
 int KisPart::documentCount() const
 {
     return d->documents.size();
 }
 
 void KisPart::removeDocument(KisDocument *document)
 {
     d->documents.removeAll(document);
     emit documentClosed('/'+objectName());
     emit sigDocumentRemoved(document->url().toLocalFile());
     document->deleteLater();
 }
 
 KisMainWindow *KisPart::createMainWindow(QUuid id)
 {
     KisMainWindow *mw = new KisMainWindow(id);
     dbgUI <<"mainWindow" << (void*)mw << "added to view" << this;
     d->mainWindows.append(mw);
     emit sigWindowAdded(mw);
     return mw;
 }
 
 KisView *KisPart::createView(KisDocument *document,
                              KisViewManager *viewManager,
                              QWidget *parent)
 {
     // If creating the canvas fails, record this and disable OpenGL next time
     KisConfig cfg(false);
     KConfigGroup grp( KSharedConfig::openConfig(), "crashprevention");
     if (grp.readEntry("CreatingCanvas", false)) {
         cfg.disableOpenGL();
     }
     if (cfg.canvasState() == "OPENGL_FAILED") {
         cfg.disableOpenGL();
     }
     grp.writeEntry("CreatingCanvas", true);
     grp.sync();
 
     QApplication::setOverrideCursor(Qt::WaitCursor);
     KisView *view = new KisView(document,  viewManager, parent);
     QApplication::restoreOverrideCursor();
 
     // Record successful canvas creation
     grp.writeEntry("CreatingCanvas", false);
     grp.sync();
 
     addView(view);
 
     return view;
 }
 
 void KisPart::addView(KisView *view)
 {
     if (!view)
         return;
 
     if (!d->views.contains(view)) {
         d->views.append(view);
     }
 
     emit sigViewAdded(view);
 }
 
 void KisPart::removeView(KisView *view)
 {
     if (!view) return;
 
     /**
      * HACK ALERT: we check here explicitly if the document (or main
      *             window), is saving the stuff. If we close the
      *             document *before* the saving is completed, a crash
      *             will happen.
      */
     KIS_ASSERT_RECOVER_RETURN(!view->mainWindow()->hackIsSaving());
 
     emit sigViewRemoved(view);
 
     QPointer<KisDocument> doc = view->document();
     d->views.removeAll(view);
 
     if (doc) {
         bool found = false;
         Q_FOREACH (QPointer<KisView> view, d->views) {
             if (view && view->document() == doc) {
                 found = true;
                 break;
             }
         }
         if (!found) {
             removeDocument(doc);
         }
     }
 }
 
 QList<QPointer<KisView> > KisPart::views() const
 {
     return d->views;
 }
 
 int KisPart::viewCount(KisDocument *doc) const
 {
     if (!doc) {
         return d->views.count();
     }
     else {
         int count = 0;
         Q_FOREACH (QPointer<KisView> view, d->views) {
             if (view && view->isVisible() && view->document() == doc) {
                 count++;
             }
         }
         return count;
     }
 }
 
 bool KisPart::closingSession() const
 {
     return d->closingSession;
 }
 
 bool KisPart::exists()
 {
     return s_instance.exists();
 }
 
 bool KisPart::closeSession(bool keepWindows)
 {
     d->closingSession = true;
 
     Q_FOREACH(auto document, d->documents) {
         if (!d->queryCloseDocument(document.data())) {
             d->closingSession = false;
             return false;
         }
     }
 
     if (d->currentSession) {
         KisConfig kisCfg(false);
         if (kisCfg.saveSessionOnQuit(false)) {
 
             d->currentSession->storeCurrentWindows();
             d->currentSession->save();
 
             KConfigGroup cfg = KSharedConfig::openConfig()->group("session");
             cfg.writeEntry("previousSession", d->currentSession->name());
         }
 
         d->currentSession = nullptr;
     }
 
     if (!keepWindows) {
         Q_FOREACH (auto window, d->mainWindows) {
             window->close();
         }
 
         if (d->sessionManager) {
             d->sessionManager->close();
         }
     }
 
     d->closingSession = false;
     return true;
 }
 
 void KisPart::slotDocumentSaved()
 {
     KisDocument *doc = qobject_cast<KisDocument*>(sender());
     emit sigDocumentSaved(doc->url().toLocalFile());
 }
 
 void KisPart::removeMainWindow(KisMainWindow *mainWindow)
 {
     dbgUI <<"mainWindow" << (void*)mainWindow <<"removed from doc" << this;
     if (mainWindow) {
         d->mainWindows.removeAll(mainWindow);
     }
 }
 
 const QList<QPointer<KisMainWindow> > &KisPart::mainWindows() const
 {
     return d->mainWindows;
 }
 
 int KisPart::mainwindowCount() const
 {
     return d->mainWindows.count();
 }
 
 
 KisMainWindow *KisPart::currentMainwindow() const
 {
     QWidget *widget = qApp->activeWindow();
     KisMainWindow *mainWindow = qobject_cast<KisMainWindow*>(widget);
     while (!mainWindow && widget) {
         widget = widget->parentWidget();
         mainWindow = qobject_cast<KisMainWindow*>(widget);
     }
 
     if (!mainWindow && mainWindows().size() > 0) {
         mainWindow = mainWindows().first();
     }
     return mainWindow;
 
 }
 
 KisMainWindow * KisPart::windowById(QUuid id) const
 {
     Q_FOREACH(QPointer<KisMainWindow> mainWindow, d->mainWindows) {
         if (mainWindow->id() == id) {
             return mainWindow;
         }
     }
 
     return nullptr;
 }
 
 KisIdleWatcher* KisPart::idleWatcher() const
 {
     return &d->idleWatcher;
 }
 
 KisAnimationCachePopulator* KisPart::cachePopulator() const
 {
     return &d->animationCachePopulator;
 }
 
+void KisPart::prioritizeFrameForCache(KisImageSP image, int frame) {
+    KisImageAnimationInterface* animInterface = image->animationInterface();
+    KIS_SAFE_ASSERT_RECOVER_RETURN(animInterface->fullClipRange().contains(frame));
+
+    d->animationCachePopulator.requestRegenerationWithPriorityFrame(image, frame);
+
+}
+
 void KisPart::openExistingFile(const QUrl &url)
 {
     // TODO: refactor out this method!
 
     KisMainWindow *mw = currentMainwindow();
     KIS_SAFE_ASSERT_RECOVER_RETURN(mw);
 
     mw->openDocument(url, KisMainWindow::None);
 }
 
 void KisPart::updateShortcuts()
 {
     // Update any non-UI actionCollections.  That includes:
     // Now update the UI actions.
     Q_FOREACH (KisMainWindow *mainWindow, d->mainWindows) {
         KActionCollection *ac = mainWindow->actionCollection();
 
         ac->updateShortcuts();
 
         // Loop through mainWindow->actionCollections() to modify tooltips
         // so that they list shortcuts at the end in parentheses
         Q_FOREACH ( QAction* action, ac->actions())
         {
             // Remove any existing suffixes from the tooltips.
             // Note this regexp starts with a space, e.g. " (Ctrl-a)"
             QString strippedTooltip = action->toolTip().remove(QRegExp("\\s\\(.*\\)"));
 
             // Now update the tooltips with the new shortcut info.
             if (action->shortcut() == QKeySequence(0))
                 action->setToolTip(strippedTooltip);
             else
                 action->setToolTip( strippedTooltip + " (" + action->shortcut().toString() + ")");
         }
     }
 }
 
 void KisPart::openTemplate(const QUrl &url)
 {
     qApp->setOverrideCursor(Qt::BusyCursor);
     KisDocument *document = createDocument();
 
     bool ok = document->loadNativeFormat(url.toLocalFile());
     document->setModified(false);
     document->undoStack()->clear();
 
     if (ok) {
         QString mimeType = KisMimeDatabase::mimeTypeForFile(url.toLocalFile());
         // in case this is a open document template remove the -template from the end
         mimeType.remove( QRegExp( "-template$" ) );
         document->setMimeTypeAfterLoading(mimeType);
         document->resetURL();
         document->setReadWrite(true);
     }
     else {
         if (document->errorMessage().isEmpty()) {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not create document from template\n%1", document->localFilePath()));
         }
         else {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not create document from template\n%1\nReason: %2", document->localFilePath(), document->errorMessage()));
         }
         delete document;
         return;
     }
     addDocument(document);
 
     KisMainWindow *mw = currentMainwindow();
     mw->addViewAndNotifyLoadingCompleted(document);
 
     KisOpenPane *pane = qobject_cast<KisOpenPane*>(sender());
     if (pane) {
         pane->hide();
         pane->deleteLater();
 
     }
 
     qApp->restoreOverrideCursor();
 }
 
 void KisPart::addRecentURLToAllMainWindows(QUrl url, QUrl oldUrl)
 {
     // Add to recent actions list in our mainWindows
     Q_FOREACH (KisMainWindow *mainWindow, d->mainWindows) {
         mainWindow->addRecentURL(url, oldUrl);
     }
 }
 
 
 void KisPart::startCustomDocument(KisDocument* doc)
 {
     addDocument(doc);
     KisMainWindow *mw = currentMainwindow();
     KisOpenPane *pane = qobject_cast<KisOpenPane*>(sender());
     if (pane) {
         pane->hide();
         pane->deleteLater();
     }
     mw->addViewAndNotifyLoadingCompleted(doc);
 
 }
 
 KisInputManager* KisPart::currentInputManager()
 {
     KisMainWindow *mw = currentMainwindow();
     KisViewManager *manager = mw ? mw->viewManager() : 0;
     return manager ? manager->inputManager() : 0;
 }
 
 void KisPart::showSessionManager()
 {
     if (d->sessionManager.isNull()) {
         d->sessionManager.reset(new KisSessionManagerDialog());
     }
 
     d->sessionManager->show();
     d->sessionManager->activateWindow();
 }
 
 void KisPart::startBlankSession()
 {
     KisMainWindow *window = createMainWindow();
     window->initializeGeometry();
     window->show();
 
 }
 
 bool KisPart::restoreSession(const QString &sessionName)
 {
     if (sessionName.isNull()) return false;
 
     KoResourceServer<KisSessionResource> *rserver = KisResourceServerProvider::instance()->sessionServer();
     KisSessionResourceSP session = rserver->resourceByName(sessionName);
     if (!session || !session->valid()) return false;
 
     return restoreSession(session);
 }
 
 bool KisPart::restoreSession(KisSessionResourceSP session)
 {
     session->restore();
     d->currentSession = session;
     return true;
 }
 
 void KisPart::setCurrentSession(KisSessionResourceSP session)
 {
     d->currentSession = session;
 }
diff --git a/libs/ui/KisPart.h b/libs/ui/KisPart.h
index 7759e81107..4db76df8e3 100644
--- a/libs/ui/KisPart.h
+++ b/libs/ui/KisPart.h
@@ -1,289 +1,298 @@
 /* This file is part of the KDE project
    Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
    Copyright (C) 2000-2005 David Faure  <faure@kde.org>
    Copyright (C) 2007 Thorsten Zachmann <zachmann@kde.org>
    Copyright (C) 2010 Boudewijn Rempt   <boud@valdyas.org>
    Copyright (C) 2015 Michael Abrahams  <miabraha@gmail.com>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #ifndef KIS_PART_H
 #define KIS_PART_H
 
 #include <QList>
 #include <QPointer>
 #include <QUrl>
 #include <QUuid>
 
 #include <KisSessionResource.h>
 
 #include "kritaui_export.h"
 #include <KConfigCore/kconfiggroup.h>
 #include <KoConfig.h>
 #include <KisMainWindow.h>
 
 namespace KIO {
 }
 
 class KisAction;
 class KisDocument;
 class KisView;
 class KisDocument;
 class KisIdleWatcher;
 class KisAnimationCachePopulator;
 
 
 /**
  * KisPart a singleton class which provides the main entry point to the application.
  * Krita supports multiple documents, multiple main windows, and multiple
  * components.  KisPart manages these resources and provides them to the rest of
  * Krita.  It manages lists of Actions and shortcuts as well.
  *
  * The terminology comes from KParts, which is a system allowing one KDE app
  * to be run from inside another, like pressing F4 inside dophin to run konsole.
  *
  * Needless to say, KisPart hasn't got much to do with KParts anymore.
  */
 class KRITAUI_EXPORT KisPart : public QObject
 {
     Q_OBJECT
 
 public:
 
     static KisPart *instance();
 
     /**
      * Constructor.
      *
      * @param parent may be another KisDocument, or anything else.
      *        Usually passed by KPluginFactory::create.
      */
     explicit KisPart();
 
     /**
      *  Destructor.
      *
      * The destructor does not delete any attached KisView objects and it does not
      * delete the attached widget as returned by widget().
      */
     ~KisPart() override;
 
     // ----------------- Document management -----------------
 
     /**
      * create an empty document. The document is not automatically registered with the part.
      */
     KisDocument *createDocument() const;
 
     /**
      * create a throwaway empty document. The document does not register a resource storage
      */
     KisDocument *createTemporaryDocument() const;
 
     /**
      * Add the specified document to the list of documents this KisPart manages.
      */
     void addDocument(KisDocument *document);
 
     /**
      * @return a list of all documents this part manages
      */
     QList<QPointer<KisDocument> > documents() const;
 
     /**
      * @return number of documents this part manages.
      */
     int documentCount() const;
 
     void removeDocument(KisDocument *document);
 
     // ----------------- MainWindow management -----------------
 
 
     /**
      * Create a new main window.
      */
     KisMainWindow *createMainWindow(QUuid id = QUuid());
 
     /**
      * Removes a main window from the list of managed windows.
      *
      * This is called by the MainWindow after it finishes its shutdown routine.
      */
     void removeMainWindow(KisMainWindow *mainWindow);
 
     /**
      * @return the list of main windows.
      */
     const QList<QPointer<KisMainWindow> >& mainWindows() const;
 
     /**
      * @return the number of shells for the main window
      */
     int mainwindowCount() const;
 
     void addRecentURLToAllMainWindows(QUrl url, QUrl oldUrl = QUrl());
 
     /**
      * @return the currently active main window.
      */
     KisMainWindow *currentMainwindow() const;
 
     KisMainWindow *windowById(QUuid id) const;
 
     /**
      * @return the application-wide KisIdleWatcher.
      */
     KisIdleWatcher *idleWatcher() const;
 
+    // ----------------- Cache Populator Management -----------------
     /**
      * @return the application-wide AnimationCachePopulator.
      */
     KisAnimationCachePopulator *cachePopulator() const;
 
+    /**
+     * Adds a frame time index to a priority stack, which should be
+     * cached immediately and irregardless of whether it is the
+     * the currently occupied frame. The process of regeneration is
+     * started immediately.
+     */
+    void prioritizeFrameForCache(KisImageSP image, int frame);
+
 public Q_SLOTS:
 
     /**
      * This slot loads an existing file.
      * @param url the file to load
      */
     void openExistingFile(const QUrl &url);
 
     /**
      * This slot loads a template and deletes the sender.
      * @param url the template to load
      */
     void openTemplate(const QUrl &url);
 
 
     /**
      * @brief startCustomDocument adds the given document to the document list and deletes the sender()
      * @param doc
      */
     void startCustomDocument(KisDocument *doc);
 
 private Q_SLOTS:
 
     void updateIdleWatcherConnections();
 
     void updateShortcuts();
 
 Q_SIGNALS:
     /**
      * emitted when a new document is opened. (for the idle watcher)
      */
     void documentOpened(const QString &ref);
 
     /**
      * emitted when an old document is closed. (for the idle watcher)
      */
     void documentClosed(const QString &ref);
 
     // These signals are for libkis or sketch
     void sigViewAdded(KisView *view);
     void sigViewRemoved(KisView *view);
     void sigDocumentAdded(KisDocument *document);
     void sigDocumentSaved(const QString &url);
     void sigDocumentRemoved(const QString &filename);
     void sigWindowAdded(KisMainWindow *window);
 
 public:
 
     KisInputManager *currentInputManager();
 
     //------------------ View management ------------------
 
     /**
      * Create a new view for the document. The view is added to the list of
      * views, and if the document wasn't known yet, it's registered as well.
      */
     KisView *createView(KisDocument *document,
                         KisViewManager *viewManager,
                         QWidget *parent);
 
     /**
      * Adds a view to the document. If the part doesn't know yet about
      * the document, it is registered.
      *
      * This calls KisView::updateReadWrite to tell the new view
      * whether the document is readonly or not.
      */
     void addView(KisView *view);
 
     /**
      * Removes a view of the document.
      */
     void removeView(KisView *view);
 
     /**
      * @return a list of views this document is displayed in
      */
     QList<QPointer<KisView> > views() const;
 
     /**
      * @return number of views this document is displayed in
      */
     int viewCount(KisDocument *doc) const;
 
     //------------------ Session management ------------------
 
     void showSessionManager();
 
     void startBlankSession();
 
     /**
      * Restores a saved session by name
      */
     bool restoreSession(const QString &sessionName);
     bool restoreSession(KisSessionResourceSP session);
 
     void setCurrentSession(KisSessionResourceSP session);
 
     /**
      * Attempts to save the session and close all windows.
      * This may involve asking the user to save open files.
      * @return false, if closing was cancelled by the user
      */
     bool closeSession(bool keepWindows = false);
 
     /**
      * Are we in the process of closing the application through closeSession().
      */
     bool closingSession() const;
 
     /**
      * This function returns true if the instance has already been initialized,
      * false otherwise. This to prevent premature initialization that causes crash
      * on android see `1fbb25506a`
      * @see QGlobalStatic::exists()
      */
     static bool exists();
 
 private Q_SLOTS:
 
     void slotDocumentSaved();
 
 private:
 
     Q_DISABLE_COPY(KisPart)
 
     class Private;
     Private *const d;
 
 };
 
 #endif
diff --git a/libs/ui/KisWelcomePageWidget.cpp b/libs/ui/KisWelcomePageWidget.cpp
index be32b39b20..652bdb46bf 100644
--- a/libs/ui/KisWelcomePageWidget.cpp
+++ b/libs/ui/KisWelcomePageWidget.cpp
@@ -1,459 +1,460 @@
 /* This file is part of the KDE project
  * Copyright (C) 2018 Scott Petrovic <scottpetrovic@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "KisWelcomePageWidget.h"
 #include <QDebug>
 #include <QDesktopServices>
 #include <QFileInfo>
 #include <QMimeData>
 #include <QPixmap>
 #include <QImage>
 
 #include <KisMimeDatabase.h>
 #include "kis_action_manager.h"
 #include "kactioncollection.h"
 #include "kis_action.h"
 
 #include "KConfigGroup"
 #include "KSharedConfig"
 
 #include <QListWidget>
 #include <QListWidgetItem>
 
 #include "kis_icon_utils.h"
 #include "krita_utils.h"
 #include "KoStore.h"
 #include "kis_config.h"
 #include "KisDocument.h"
 #include <kis_image.h>
 #include <kis_paint_device.h>
 #include <KisPart.h>
 
 
 KisWelcomePageWidget::KisWelcomePageWidget(QWidget *parent)
     : QWidget(parent)
 {
     setupUi(this);
     recentDocumentsListView->setDragEnabled(false);
     recentDocumentsListView->viewport()->setAutoFillBackground(false);
     recentDocumentsListView->setSpacing(2);
 
     // set up URLs that go to web browser
     manualLink->setTextFormat(Qt::RichText);
     manualLink->setTextInteractionFlags(Qt::TextBrowserInteraction);
     manualLink->setOpenExternalLinks(true);
 
     gettingStartedLink->setTextFormat(Qt::RichText);
     gettingStartedLink->setTextInteractionFlags(Qt::TextBrowserInteraction);
     gettingStartedLink->setOpenExternalLinks(true);
 
     supportKritaLink->setTextFormat(Qt::RichText);
     supportKritaLink->setTextInteractionFlags(Qt::TextBrowserInteraction);
     supportKritaLink->setOpenExternalLinks(true);
 
     userCommunityLink->setTextFormat(Qt::RichText);
     userCommunityLink->setTextInteractionFlags(Qt::TextBrowserInteraction);
     userCommunityLink->setOpenExternalLinks(true);
 
 
     kritaWebsiteLink->setTextFormat(Qt::RichText);
     kritaWebsiteLink->setTextInteractionFlags(Qt::TextBrowserInteraction);
     kritaWebsiteLink->setOpenExternalLinks(true);
 
 
     sourceCodeLink->setTextFormat(Qt::RichText);
     sourceCodeLink->setTextInteractionFlags(Qt::TextBrowserInteraction);
     sourceCodeLink->setOpenExternalLinks(true);
 
     poweredByKDELink->setTextFormat(Qt::RichText);
     poweredByKDELink->setTextInteractionFlags(Qt::TextBrowserInteraction);
     poweredByKDELink->setOpenExternalLinks(true);
     kdeIcon->setIconSize(QSize(20, 20));
     kdeIcon->setIcon(KisIconUtils::loadIcon(QStringLiteral("kde")).pixmap(20));
 
 
     versionNotificationLabel->setTextFormat(Qt::RichText);
     versionNotificationLabel->setTextInteractionFlags(Qt::TextBrowserInteraction);
     versionNotificationLabel->setOpenExternalLinks(true);
 
     connect(chkShowNews, SIGNAL(toggled(bool)), newsWidget, SLOT(toggleNews(bool)));
 
     connect(newsWidget, SIGNAL(newsDataChanged()), this, SLOT(slotUpdateVersionMessage()));
 
 #ifdef Q_OS_ANDROID
     // checking this widgets crashes the app, so it is better for it to be hidden for now
     newsWidget->hide();
     helpTitleLabel_2->hide();
     chkShowNews->hide();
 #endif
 
 
     // configure the News area
     KisConfig cfg(true);
     bool m_getNews = cfg.readEntry<bool>("FetchNews", false);
     chkShowNews->setChecked(m_getNews);
 
     setAcceptDrops(true);
 
 }
 
 KisWelcomePageWidget::~KisWelcomePageWidget()
 {
 }
 
 void KisWelcomePageWidget::setMainWindow(KisMainWindow* mainWin)
 {
     if (mainWin) {
         m_mainWindow = mainWin;
 
         // set the shortcut links from actions (only if a shortcut exists)
         if ( mainWin->viewManager()->actionManager()->actionByName("file_new")->shortcut().toString() != "") {
             newFileLinkShortcut->setText(QString("(") + mainWin->viewManager()->actionManager()->actionByName("file_new")->shortcut().toString() + QString(")"));
         }
         if (mainWin->viewManager()->actionManager()->actionByName("file_open")->shortcut().toString()  != "") {
             openFileShortcut->setText(QString("(") + mainWin->viewManager()->actionManager()->actionByName("file_open")->shortcut().toString() + QString(")"));
         }
         connect(recentDocumentsListView, SIGNAL(clicked(QModelIndex)), this, SLOT(recentDocumentClicked(QModelIndex)));
         // we need the view manager to actually call actions, so don't create the connections
         // until after the view manager is set
         connect(newFileLink, SIGNAL(clicked(bool)), this, SLOT(slotNewFileClicked()));
         connect(openFileLink, SIGNAL(clicked(bool)), this, SLOT(slotOpenFileClicked()));
         connect(clearRecentFilesLink, SIGNAL(clicked(bool)), mainWin, SLOT(clearRecentFiles()));
 
         slotUpdateThemeColors();
 
         // allows RSS news items to apply analytics tracking.
         newsWidget->setAnalyticsTracking("?" + analyticsString);
 
     }
 }
 
 
 void KisWelcomePageWidget::showDropAreaIndicator(bool show)
 {
     if (!show) {
         QString dropFrameStyle = "QFrame#dropAreaIndicator { border: 0px }";
         dropFrameBorder->setStyleSheet(dropFrameStyle);
     } else {
         QColor textColor = qApp->palette().color(QPalette::Text);
         QColor backgroundColor = qApp->palette().color(QPalette::Background);
         QColor blendedColor = KritaUtils::blendColors(textColor, backgroundColor, 0.8);
 
         // QColor.name() turns it into a hex/web format
         QString dropFrameStyle = QString("QFrame#dropAreaIndicator { border: 2px dotted ").append(blendedColor.name()).append(" }") ;
         dropFrameBorder->setStyleSheet(dropFrameStyle);
     }
 }
 
 void KisWelcomePageWidget::slotUpdateThemeColors()
 {
 
     textColor = qApp->palette().color(QPalette::Text);
     backgroundColor = qApp->palette().color(QPalette::Background);
 
     // make the welcome screen labels a subtle color so it doesn't clash with the main UI elements
     blendedColor = KritaUtils::blendColors(textColor, backgroundColor, 0.8);
     blendedStyle = QString("color: ").append(blendedColor.name());
 
 
     // what labels to change the color...
     startTitleLabel->setStyleSheet(blendedStyle);
     recentDocumentsLabel->setStyleSheet(blendedStyle);
     helpTitleLabel->setStyleSheet(blendedStyle);
     newFileLinkShortcut->setStyleSheet(blendedStyle);
     openFileShortcut->setStyleSheet(blendedStyle);
     clearRecentFilesLink->setStyleSheet(blendedStyle);
     recentDocumentsListView->setStyleSheet(blendedStyle);
 
     newFileLink->setStyleSheet(blendedStyle);
     openFileLink->setStyleSheet(blendedStyle);
 
 
     // giving the drag area messaging a dotted border
     QString dottedBorderStyle = QString("border: 2px dotted ").append(blendedColor.name()).append("; color:").append(blendedColor.name()).append( ";");
     dragImageHereLabel->setStyleSheet(dottedBorderStyle);
 
 
     // make drop area QFrame have a dotted line
     dropFrameBorder->setObjectName("dropAreaIndicator");
     QString dropFrameStyle = QString("QFrame#dropAreaIndicator { border: 4px dotted ").append(blendedColor.name()).append("}");
     dropFrameBorder->setStyleSheet(dropFrameStyle);
 
     // only show drop area when we have a document over the empty area
     showDropAreaIndicator(false);
 
     // add icons for new and open settings to make them stand out a bit more
     openFileLink->setIconSize(QSize(30, 30));
     newFileLink->setIconSize(QSize(30, 30));
     openFileLink->setIcon(KisIconUtils::loadIcon("document-open"));
     newFileLink->setIcon(KisIconUtils::loadIcon("document-new"));
 
 
     kdeIcon->setIcon(KisIconUtils::loadIcon(QStringLiteral("kde")).pixmap(20));
 
     // HTML links seem to be a bit more stubborn with theme changes... setting inline styles to help with color change
     userCommunityLink->setText(QString("<a style=\"color: " + blendedColor.name() + " \" href=\"https://forum.kde.org/viewforum.php?f=136&" + analyticsString + "user-community" + "\">")
                                .append(i18n("User Community")).append("</a>"));
 
     gettingStartedLink->setText(QString("<a style=\"color: " + blendedColor.name() + " \" href=\"https://docs.krita.org/en/user_manual/getting_started.html?" + analyticsString + "getting-started" + "\">")
                                 .append(i18n("Getting Started")).append("</a>"));
 
     manualLink->setText(QString("<a style=\"color: " + blendedColor.name() + " \" href=\"https://docs.krita.org?" + analyticsString + "documentation-site" + "\">")
                         .append(i18n("User Manual")).append("</a>"));
 
     supportKritaLink->setText(QString("<a style=\"color: " + blendedColor.name() + " \" href=\"https://krita.org/en/support-us/donations?" + analyticsString + "donations" + "\">")
                               .append(i18n("Support Krita")).append("</a>"));
 
     kritaWebsiteLink->setText(QString("<a style=\"color: " + blendedColor.name() + " \" href=\"https://www.krita.org?" + analyticsString + "marketing-site" + "\">")
                               .append(i18n("Krita Website")).append("</a>"));
 
     sourceCodeLink->setText(QString("<a style=\"color: " + blendedColor.name() + " \" href=\"https://invent.kde.org/kde/krita?" + analyticsString + "source-code" + "\">")
                             .append(i18n("Source Code")).append("</a>"));
 
     poweredByKDELink->setText(QString("<a style=\"color: " + blendedColor.name() + " \" href=\"https://userbase.kde.org/What_is_KDE?" + analyticsString + "what-is-kde" + "\">")
                               .append(i18n("Powered by KDE")).append("</a>"));
 
 
     slotUpdateVersionMessage(); // text set from RSS feed
 
     // re-populate recent files since they might have themed icons
     populateRecentDocuments();
 
 }
 
 void KisWelcomePageWidget::populateRecentDocuments()
 {
+
     m_recentFilesModel.clear(); // clear existing data before it gets re-populated
 
     // grab recent files data
     int numRecentFiles = m_mainWindow->recentFilesUrls().length() > 5 ? 5 : m_mainWindow->recentFilesUrls().length(); // grab at most 5
 
     for (int i = 0; i < numRecentFiles; i++ ) {
 
         QStandardItem *recentItem = new QStandardItem(1,2); // 1 row, 1 column
         recentItem->setIcon(KisIconUtils::loadIcon("document-export"));
 
         QString recentFileUrlPath = m_mainWindow->recentFilesUrls().at(i).toLocalFile();
-        QString fileName = recentFileUrlPath.split("/").last();
+
+        QString fileName = QFileInfo(recentFileUrlPath).fileName();
 
         QList<QUrl> brokenUrls;
 
         if (m_thumbnailMap.contains(recentFileUrlPath)) {
             recentItem->setIcon(m_thumbnailMap[recentFileUrlPath]);
         }
         else {
             QFileInfo fi(recentFileUrlPath);
-
             if (fi.exists()) {
                 QString mimeType = KisMimeDatabase::mimeTypeForFile(recentFileUrlPath);
                 if (mimeType == KisDocument::nativeFormatMimeType()
                        || mimeType == "image/openraster") {
 
                     QScopedPointer<KoStore> store(KoStore::createStore(recentFileUrlPath, KoStore::Read));
                     if (store) {
                         QString thumbnailpath;
                         if (store->hasFile(QString("Thumbnails/thumbnail.png"))){
                             thumbnailpath = QString("Thumbnails/thumbnail.png");
                         } else if (store->hasFile(QString("preview.png"))) {
                             thumbnailpath = QString("preview.png");
                         }
                         if (!thumbnailpath.isEmpty()) {
                             if (store->open(thumbnailpath)) {
 
                                 QByteArray bytes = store->read(store->size());
                                 store->close();
                                 QImage img;
                                 img.loadFromData(bytes);
                                 img.setDevicePixelRatio(devicePixelRatioF());
                                 recentItem->setIcon(QIcon(QPixmap::fromImage(img)));
                             }
                         }
                     }
                     else {
                         brokenUrls << m_mainWindow->recentFilesUrls().at(i);
                     }
                 }
                 else if (mimeType == "image/tiff" || mimeType == "image/x-tiff") {
                     // Workaround for a bug in Qt tiff QImageIO plugin
                     QScopedPointer<KisDocument> doc;
                     doc.reset(KisPart::instance()->createTemporaryDocument());
                     doc->setFileBatchMode(true);
                     bool r = doc->openUrl(QUrl::fromLocalFile(recentFileUrlPath), KisDocument::DontAddToRecent);
                     if (r) {
                         KisPaintDeviceSP projection = doc->image()->projection();
                         recentItem->setIcon(QIcon(QPixmap::fromImage(projection->createThumbnail(48, 48, projection->exactBounds()))));
                     }
                     else {
                         brokenUrls << m_mainWindow->recentFilesUrls().at(i);
                     }
                 }
                 else {
                     QImage img;
                     img.setDevicePixelRatio(devicePixelRatioF());
                     img.load(recentFileUrlPath);
                     if (!img.isNull()) {
                         recentItem->setIcon(QIcon(QPixmap::fromImage(img.scaledToWidth(48))));
                     }
                     else {
                         brokenUrls << m_mainWindow->recentFilesUrls().at(i);
                     }
                 }
-                if (brokenUrls.size() > 0 && brokenUrls.last().toLocalFile() != recentFileUrlPath) {
+                if (brokenUrls.size() == 0 || brokenUrls.last().toLocalFile() != recentFileUrlPath) {
                     m_thumbnailMap[recentFileUrlPath] = recentItem->icon();
                 }
             }
         }
         Q_FOREACH(const QUrl &url, brokenUrls) {
             m_mainWindow->removeRecentUrl(url);
         }
         // set the recent object with the data
         if (brokenUrls.isEmpty() || brokenUrls.last().toLocalFile() != recentFileUrlPath) {
             recentItem->setText(fileName); // what to display for the item
             recentItem->setToolTip(recentFileUrlPath);
             m_recentFilesModel.appendRow(recentItem);
         }
     }
 
     // hide clear and Recent files title if there are none
     bool hasRecentFiles = m_mainWindow->recentFilesUrls().length() > 0;
 
     recentDocumentsLabel->setVisible(hasRecentFiles);
     clearRecentFilesLink->setVisible(hasRecentFiles);
 
     recentDocumentsListView->setIconSize(QSize(48, 48));
     recentDocumentsListView->setModel(&m_recentFilesModel);
 }
 
 void KisWelcomePageWidget::slotUpdateVersionMessage()
 {
 
     alertIcon->setIcon(KisIconUtils::loadIcon("warning"));
     alertIcon->setVisible(false);
 
     // find out if we need an update...or if this is a development version:
     // dev builds contain GIT hash in it and the word git
     // stable versions do not contain this.
     if (qApp->applicationVersion().contains("git")) {
         // Development build
         QString versionLabelText = QString("<a style=\"color: " +
                                            blendedColor.name() +
                                            " \" href=\"https://docs.krita.org/en/untranslatable_pages/triaging_bugs.html?"
                                            + analyticsString + "dev-build" + "\">")
                                   .append(i18n("DEV BUILD")).append("</a>");
 
         versionNotificationLabel->setText(versionLabelText);
         alertIcon->setVisible(true);
         versionNotificationLabel->setVisible(true);
 
     } else if (newsWidget->hasUpdateAvailable()) {
 
         // build URL for label
         QString versionLabelText = QString("<a style=\"color: " +
                                            blendedColor.name() +
                                            " \" href=\"" +
                                            newsWidget->versionLink() + "?" +
                                            analyticsString + "version-update" + "\">")
                            .append(i18n("New Version Available!")).append("</a>");
 
         versionNotificationLabel->setVisible(true);
         versionNotificationLabel->setText(versionLabelText);
         alertIcon->setVisible(true);
 
     } else {
         // no message needed... exit
         versionNotificationLabel->setVisible(false);
         return;
     }
 
     if (!blendedStyle.isNull()) {
         versionNotificationLabel->setStyleSheet(blendedStyle);
     }
 
 }
 
 void KisWelcomePageWidget::dragEnterEvent(QDragEnterEvent *event)
 {
     //qDebug() << "dragEnterEvent formats" << event->mimeData()->formats() << "urls" << event->mimeData()->urls() << "has images" << event->mimeData()->hasImage();
     showDropAreaIndicator(true);
     if (event->mimeData()->hasUrls() ||
         event->mimeData()->hasFormat("application/x-krita-node") ||
         event->mimeData()->hasFormat("application/x-qt-image")) {
 
         event->accept();
     }
 }
 
 void KisWelcomePageWidget::dropEvent(QDropEvent *event)
 {
     //qDebug() << "KisWelcomePageWidget::dropEvent() formats" << event->mimeData()->formats() << "urls" << event->mimeData()->urls() << "has images" << event->mimeData()->hasImage();
 
     showDropAreaIndicator(false);
 
     if (event->mimeData()->hasUrls() && event->mimeData()->urls().size() > 0) {
         Q_FOREACH (const QUrl &url, event->mimeData()->urls()) {
             if (url.toLocalFile().endsWith(".bundle")) {
                 bool r = m_mainWindow->installBundle(url.toLocalFile());
                 if (!r) {
                     qWarning() << "Could not install bundle" << url.toLocalFile();
                 }
             }
             else {
                 m_mainWindow->openDocument(url, KisMainWindow::None);
             }
         }
     }
 }
 
 void KisWelcomePageWidget::dragMoveEvent(QDragMoveEvent *event)
 {
     //qDebug() << "dragMoveEvent";
     m_mainWindow->dragMoveEvent(event);
     if (event->mimeData()->hasUrls() ||
         event->mimeData()->hasFormat("application/x-krita-node") ||
         event->mimeData()->hasFormat("application/x-qt-image")) {
 
         event->accept();
     }
 
 }
 
 void KisWelcomePageWidget::dragLeaveEvent(QDragLeaveEvent */*event*/)
 {
     //qDebug() << "dragLeaveEvent";
     showDropAreaIndicator(false);
     m_mainWindow->dragLeave();
 }
 
 void KisWelcomePageWidget::recentDocumentClicked(QModelIndex index)
 {
     QString fileUrl = index.data(Qt::ToolTipRole).toString();
     m_mainWindow->openDocument(QUrl::fromLocalFile(fileUrl), KisMainWindow::None );
 }
 
 
 void KisWelcomePageWidget::slotNewFileClicked()
 {
     m_mainWindow->slotFileNew();
 }
 
 void KisWelcomePageWidget::slotOpenFileClicked()
 {
     m_mainWindow->slotFileOpen();
 }
 
diff --git a/libs/ui/canvas/kis_animation_player.h b/libs/ui/canvas/kis_animation_player.h
index d540dcc697..28996485a9 100644
--- a/libs/ui/canvas/kis_animation_player.h
+++ b/libs/ui/canvas/kis_animation_player.h
@@ -1,88 +1,90 @@
 /*
  *  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_ANIMATION_PLAYER_H
 #define KIS_ANIMATION_PLAYER_H
 
 #include <QScopedPointer>
 #include <QObject>
 
 #include "kritaui_export.h"
 
 
 class KisCanvas2;
 
 class KRITAUI_EXPORT KisAnimationPlayer : public QObject
 {
     Q_OBJECT
 
 public:
     KisAnimationPlayer(KisCanvas2 *canvas);
     ~KisAnimationPlayer() override;
 
     void play();
     void stop();
     void displayFrame(int time);
 
     bool isPlaying();
     int currentTime();
 
     qreal playbackSpeed();
 
     void forcedStopOnExit();
 
     qreal effectiveFps() const;
     qreal realFps() const;
     qreal framesDroppedPortion() const;
 
+Q_SIGNALS:
+    void sigFrameChanged();
+    void sigPlaybackStarted();
+    void sigPlaybackStopped();
+    void sigPlaybackStatisticsUpdated();
+    void sigFullClipRangeChanged();
+
 public Q_SLOTS:
     void slotUpdate();
     void slotCancelPlayback();
     void slotCancelPlaybackSafe();
     void slotUpdatePlaybackSpeed(double value);
     void slotUpdatePlaybackTimer();
     void slotUpdateDropFramesMode();
 
 private Q_SLOTS:
     void slotSyncScrubbingAudio(int msecTime);
     void slotTryStopScrubbingAudio();
     void slotUpdateAudioChunkLength();
     void slotAudioChannelChanged();
     void slotAudioVolumeChanged();
     void slotOnAudioError(const QString &fileName, const QString &message);
 
 
-Q_SIGNALS:
-    void sigFrameChanged();
-    void sigPlaybackStarted();
-    void sigPlaybackStopped();
-    void sigPlaybackStatisticsUpdated();
-    void sigFullClipRangeChanged();
+
 
 private:
     void connectCancelSignals();
     void disconnectCancelSignals();
     void uploadFrame(int time, bool forceSyncAudio);
 
 private:
     struct Private;
     QScopedPointer<Private> m_d;
 };
 
 
 #endif
diff --git a/libs/ui/canvas/kis_image_pyramid.cpp b/libs/ui/canvas/kis_image_pyramid.cpp
index 75d2a4f786..f7e46d0b75 100644
--- a/libs/ui/canvas/kis_image_pyramid.cpp
+++ b/libs/ui/canvas/kis_image_pyramid.cpp
@@ -1,537 +1,507 @@
 /*
  *  Copyright (c) 2009 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "kis_image_pyramid.h"
 
 #include <QBitArray>
 #include <KoChannelInfo.h>
 #include <KoCompositeOp.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorModelStandardIds.h>
 #include <KoColorSpaceMaths.h>
 
 #include "kis_display_filter.h"
 #include "kis_painter.h"
 #include "kis_iterator_ng.h"
 #include "kis_datamanager.h"
 #include "kis_config_notifier.h"
 #include "kis_debug.h"
 #include "kis_config.h"
 #include "kis_image_config.h"
 
 //#define DEBUG_PYRAMID
 
 #include <config-ocio.h>
 #ifdef HAVE_OCIO
 #include <OpenColorIO/OpenColorIO.h>
 #include <OpenColorIO/OpenColorTransforms.h>
 #endif
 
 #define ORIGINAL_INDEX           0
 #define FIRST_NOT_ORIGINAL_INDEX 1
 #define SCALE_FROM_INDEX(idx) (1./qreal(1<<(idx)))
 
 
 /************* AUXILIARY FUNCTIONS **********************************/
 
 #include <KoConfig.h>
 #ifdef HAVE_OPENEXR
 #include <half.h>
 #endif
 
 #define ceiledSize(sz) QSize(ceil((sz).width()), ceil((sz).height()))
 #define isOdd(x) ((x) & 0x01)
 
 /**
  * Aligns @p value to the lowest integer not smaller than @p value and
  * that is a divident of alignment
  */
 inline void alignByPow2Hi(qint32 &value, qint32 alignment)
 {
     qint32 mask = alignment - 1;
     value |= mask;
     value++;
 }
 
 /**
  * Aligns @p value to the lowest integer not smaller than @p value and
  * that is, increased by one, a divident of alignment
  */
 inline void alignByPow2ButOneHi(qint32 &value, qint32 alignment)
 {
     qint32 mask = alignment - 1;
     value |= mask;
 }
 
 /**
  * Aligns @p value to the highest integer not exceeding @p value and
  * that is a divident of @p alignment
  */
 inline void alignByPow2Lo(qint32 &value, qint32 alignment)
 {
     qint32 mask = alignment - 1;
     value &= ~mask;
 }
 
 inline void alignRectBy2(qint32 &x, qint32 &y, qint32 &w, qint32 &h)
 {
     x -= isOdd(x);
     y -= isOdd(y);
     w += isOdd(x);
     w += isOdd(w);
     h += isOdd(y);
     h += isOdd(h);
 }
 
 
 /************* class KisImagePyramid ********************************/
 
 KisImagePyramid::KisImagePyramid(qint32 pyramidHeight)
         : m_monitorProfile(0)
         , m_monitorColorSpace(0)
         , m_pyramidHeight(pyramidHeight)
 {
     configChanged();
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), this, SLOT(configChanged()));
 }
 
 KisImagePyramid::~KisImagePyramid()
 {
     setImage(0);
 }
 
 void KisImagePyramid::setMonitorProfile(const KoColorProfile* monitorProfile,
                                         KoColorConversionTransformation::Intent renderingIntent,
                                         KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     m_monitorProfile = monitorProfile;
     /**
      * If you change pixel size here, don't forget to change it
      * in optimized function downsamplePixels()
      */
     m_monitorColorSpace = KoColorSpaceRegistry::instance()->rgb8(monitorProfile);
     m_renderingIntent = renderingIntent;
     m_conversionFlags = conversionFlags;
 
     rebuildPyramid();
 }
 
 void KisImagePyramid::setChannelFlags(const QBitArray &channelFlags)
 {
     m_channelFlags = channelFlags;
     int selectedChannels = 0;
     const KoColorSpace *projectionCs = m_originalImage->projection()->colorSpace();
     QList<KoChannelInfo*> channelInfo = projectionCs->channels();
 
     if (channelInfo.size() != m_channelFlags.size()) {
         m_channelFlags = QBitArray();
     }
 
     for (int i = 0; i < m_channelFlags.size(); ++i) {
         if (m_channelFlags.testBit(i) && channelInfo[i]->channelType() == KoChannelInfo::COLOR) {
             selectedChannels++;
             m_selectedChannelIndex = i;
         }
     }
     m_allChannelsSelected = (selectedChannels == m_channelFlags.size());
     m_onlyOneChannelSelected = (selectedChannels == 1);
 }
 
 void KisImagePyramid::setDisplayFilter(QSharedPointer<KisDisplayFilter> displayFilter)
 {
     m_displayFilter = displayFilter;
 }
 
 void KisImagePyramid::rebuildPyramid()
 {
     m_pyramid.clear();
     for (qint32 i = 0; i < m_pyramidHeight; i++) {
         m_pyramid.append(new KisPaintDevice(m_monitorColorSpace));
     }
 }
 
 void KisImagePyramid::clearPyramid()
 {
     for (qint32 i = 0; i < m_pyramidHeight; i++) {
         m_pyramid[i]->clear();
     }
 }
 
 void KisImagePyramid::setImage(KisImageWSP newImage)
 {
     if (newImage) {
         m_originalImage = newImage;
 
         clearPyramid();
         setImageSize(m_originalImage->width(), m_originalImage->height());
 
         // Get the full image size
         QRect rc = m_originalImage->projection()->exactBounds();
 
         KisImageConfig config(true);
 
         int patchWidth = config.updatePatchWidth();
         int patchHeight = config.updatePatchHeight();
 
         if (rc.width() * rc.height() <= patchWidth * patchHeight) {
             retrieveImageData(rc);
         }
         else {
             qint32 firstCol = rc.x() / patchWidth;
             qint32 firstRow = rc.y() / patchHeight;
 
             qint32 lastCol = (rc.x() + rc.width()) / patchWidth;
             qint32 lastRow = (rc.y() + rc.height()) / patchHeight;
 
             for(qint32 i = firstRow; i <= lastRow; i++) {
                 for(qint32 j = firstCol; j <= lastCol; j++) {
                     QRect maxPatchRect(j * patchWidth,
                                        i * patchHeight,
                                        patchWidth, patchHeight);
                     QRect patchRect = rc & maxPatchRect;
                     retrieveImageData(patchRect);
                 }
             }
 
         }
         //TODO: check whether there is needed recalculateCache()
     }
 }
 
 void KisImagePyramid::setImageSize(qint32 w, qint32 h)
 {
     Q_UNUSED(w);
     Q_UNUSED(h);
     /* nothing interesting */
 }
 
 void KisImagePyramid::updateCache(const QRect &dirtyImageRect)
 {
     retrieveImageData(dirtyImageRect);
 }
 
 void KisImagePyramid::retrieveImageData(const QRect &rect)
 {
     // XXX: use QThreadStorage to cache the two patches (512x512) of pixels. Note
     // that when we do that, we need to reset that cache when the projection's
     // colorspace changes.
     const KoColorSpace *projectionCs = m_originalImage->projection()->colorSpace();
     KisPaintDeviceSP originalProjection = m_originalImage->projection();
     quint32 numPixels = rect.width() * rect.height();
 
     QScopedArrayPointer<quint8> originalBytes(
         new quint8[originalProjection->colorSpace()->pixelSize() * numPixels]);
 
     originalProjection->readBytes(originalBytes.data(), rect);
 
     if (m_displayFilter &&
         m_useOcio &&
         projectionCs->colorModelId() == RGBAColorModelID) {
 
 #ifdef HAVE_OCIO
         const KoColorProfile *destinationProfile =
             m_displayFilter->useInternalColorManagement() ?
             m_monitorProfile : projectionCs->profile();
 
         const KoColorSpace *floatCs =
             KoColorSpaceRegistry::instance()->colorSpace(
                 RGBAColorModelID.id(),
                 Float32BitsColorDepthID.id(),
                 destinationProfile);
 
         const KoColorSpace *modifiedMonitorCs =
             KoColorSpaceRegistry::instance()->colorSpace(
                 RGBAColorModelID.id(),
                 Integer8BitsColorDepthID.id(),
                 destinationProfile);
 
         if (projectionCs->colorDepthId() == Float32BitsColorDepthID) {
             m_displayFilter->filter(originalBytes.data(), numPixels);
         } else {
             QScopedArrayPointer<quint8> dst(new quint8[floatCs->pixelSize() * numPixels]);
             projectionCs->convertPixelsTo(originalBytes.data(), dst.data(), floatCs, numPixels, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
             m_displayFilter->filter(dst.data(), numPixels);
             originalBytes.swap(dst);
         }
 
         {
             QScopedArrayPointer<quint8> dst(new quint8[modifiedMonitorCs->pixelSize() * numPixels]);
             floatCs->convertPixelsTo(originalBytes.data(), dst.data(), modifiedMonitorCs, numPixels, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
             originalBytes.swap(dst);
         }
 #endif
     }
     else {
         QList<KoChannelInfo*> channelInfo = projectionCs->channels();
         if (m_channelFlags.size() != channelInfo.size()) {
             setChannelFlags(QBitArray());
         }
         if (!m_channelFlags.isEmpty() && !m_allChannelsSelected) {
             QScopedArrayPointer<quint8> dst(new quint8[projectionCs->pixelSize() * numPixels]);
 
-            int channelSize = channelInfo[m_selectedChannelIndex]->size();
-            int pixelSize = projectionCs->pixelSize();
-
             KisConfig cfg(true);
 
             if (m_onlyOneChannelSelected && !cfg.showSingleChannelAsColor()) {
-                int selectedChannelPos = channelInfo[m_selectedChannelIndex]->pos();
-                for (uint pixelIndex = 0; pixelIndex < numPixels; ++pixelIndex) {
-                    for (uint channelIndex = 0; channelIndex < projectionCs->channelCount(); ++channelIndex) {
-
-                        if (channelInfo[channelIndex]->channelType() == KoChannelInfo::COLOR) {
-                            memcpy(dst.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize),
-                                   originalBytes.data() + (pixelIndex * pixelSize) + selectedChannelPos,
-                                   channelSize);
-                        }
-                        else if (channelInfo[channelIndex]->channelType() == KoChannelInfo::ALPHA) {
-                            memcpy(dst.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize),
-                                   originalBytes.data()  + (pixelIndex * pixelSize) + (channelIndex * channelSize),
-                                   channelSize);
-                        }
-                    }
-                }
+                projectionCs->convertChannelToVisualRepresentation(originalBytes.data(), dst.data(), numPixels, m_selectedChannelIndex);
             }
             else {
-                for (uint pixelIndex = 0; pixelIndex < numPixels; ++pixelIndex) {
-                    for (uint channelIndex = 0; channelIndex < projectionCs->channelCount(); ++channelIndex) {
-                        if (m_channelFlags.testBit(channelIndex)) {
-                            memcpy(dst.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize),
-                                   originalBytes.data()  + (pixelIndex * pixelSize) + (channelIndex * channelSize),
-                                   channelSize);
-                        }
-                        else {
-                            memset(dst.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize), 0, channelSize);
-                        }
-                    }
-                }
-
+                projectionCs->convertChannelToVisualRepresentation(originalBytes.data(), dst.data(), numPixels, m_channelFlags);
             }
             originalBytes.swap(dst);
         }
 
         QScopedArrayPointer<quint8> dst(new quint8[m_monitorColorSpace->pixelSize() * numPixels]);
         projectionCs->convertPixelsTo(originalBytes.data(), dst.data(), m_monitorColorSpace, numPixels, m_renderingIntent, m_conversionFlags);
         originalBytes.swap(dst);
     }
 
     m_pyramid[ORIGINAL_INDEX]->writeBytes(originalBytes.data(), rect);
 }
 
 void KisImagePyramid::recalculateCache(KisPPUpdateInfoSP info)
 {
     KisPaintDevice *src;
     KisPaintDevice *dst;
     QRect currentSrcRect = info->dirtyImageRectVar;
 
     for (int i = FIRST_NOT_ORIGINAL_INDEX; i < m_pyramidHeight; i++) {
         src = m_pyramid[i-1].data();
         dst = m_pyramid[i].data();
         if (!currentSrcRect.isEmpty()) {
             currentSrcRect = downsampleByFactor2(currentSrcRect, src, dst);
         }
     }
 
 #ifdef DEBUG_PYRAMID
     QImage image = m_pyramid[ORIGINAL_INDEX]->convertToQImage(m_monitorProfile, m_renderingIntent, m_conversionFlags);
     image.save("./PYRAMID_BASE.png");
 
     image = m_pyramid[1]->convertToQImage(m_monitorProfile, m_renderingIntent, m_conversionFlags);
     image.save("./LEVEL1.png");
 
     image = m_pyramid[2]->convertToQImage(m_monitorProfile, m_renderingIntent, m_conversionFlags);
     image.save("./LEVEL2.png");
     image = m_pyramid[3]->convertToQImage(m_monitorProfile, m_renderingIntent, m_conversionFlags);
     image.save("./LEVEL3.png");
 #endif
 }
 
 QRect KisImagePyramid::downsampleByFactor2(const QRect& srcRect,
         KisPaintDevice* src,
         KisPaintDevice* dst)
 {
     qint32 srcX, srcY, srcWidth, srcHeight;
     srcRect.getRect(&srcX, &srcY, &srcWidth, &srcHeight);
     alignRectBy2(srcX, srcY, srcWidth, srcHeight);
 
     // Nothing to do
     if (srcWidth < 1) return QRect();
     if (srcHeight < 1) return QRect();
 
     qint32 dstX = srcX / 2;
     qint32 dstY = srcY / 2;
     qint32 dstWidth = srcWidth / 2;
     qint32 dstHeight = srcHeight / 2;
 
     KisHLineConstIteratorSP srcIt0 = src->createHLineConstIteratorNG(srcX, srcY, srcWidth);
     KisHLineConstIteratorSP srcIt1 = src->createHLineConstIteratorNG(srcX, srcY + 1, srcWidth);
     KisHLineIteratorSP dstIt = dst->createHLineIteratorNG(dstX, dstY, dstWidth);
 
     int conseqPixels = 0;
     for (int row = 0; row < dstHeight; ++row) {
         do {
             int srcItConseq = srcIt0->nConseqPixels();
             int dstItConseq = dstIt->nConseqPixels();
             conseqPixels = qMin(srcItConseq, dstItConseq * 2);
 
             Q_ASSERT(!isOdd(conseqPixels));
 
             downsamplePixels(srcIt0->oldRawData(), srcIt1->oldRawData(),
                              dstIt->rawData(), conseqPixels);
 
 
             srcIt1->nextPixels(conseqPixels);
             dstIt->nextPixels(conseqPixels / 2);
         } while (srcIt0->nextPixels(conseqPixels));
         srcIt0->nextRow();
         srcIt0->nextRow();
         srcIt1->nextRow();
         srcIt1->nextRow();
         dstIt->nextRow();
     }
     return QRect(dstX, dstY, dstWidth, dstHeight);
 }
 
 void  KisImagePyramid::downsamplePixels(const quint8 *srcRow0,
                                         const quint8 *srcRow1,
                                         quint8 *dstRow,
                                         qint32 numSrcPixels)
 {
     /**
      * FIXME (mandatory): Use SSE and friends here.
      */
 
     qint16 b = 0;
     qint16 g = 0;
     qint16 r = 0;
     qint16 a = 0;
 
     static const qint32 pixelSize = 4; // This is preview argb8 mode
 
     for (qint32 i = 0; i < numSrcPixels / 2; i++) {
         b = srcRow0[0] + srcRow1[0] + srcRow0[4] + srcRow1[4];
         g = srcRow0[1] + srcRow1[1] + srcRow0[5] + srcRow1[5];
         r = srcRow0[2] + srcRow1[2] + srcRow0[6] + srcRow1[6];
         a = srcRow0[3] + srcRow1[3] + srcRow0[7] + srcRow1[7];
 
         dstRow[0] = b / 4;
         dstRow[1] = g / 4;
         dstRow[2] = r / 4;
         dstRow[3] = a / 4;
 
         dstRow += pixelSize;
         srcRow0 += 2 * pixelSize;
         srcRow1 += 2 * pixelSize;
     }
 }
 
 int KisImagePyramid::findFirstGoodPlaneIndex(qreal scale,
         QSize originalSize)
 {
     qint32 nearest = 0;
 
     for (qint32 i = 0; i < m_pyramidHeight; i++) {
         qreal planeScale = SCALE_FROM_INDEX(i);
         if (planeScale < scale) {
             if (originalSize*scale == originalSize*planeScale)
                 nearest = i;
             break;
         }
         nearest = i;
     }
 
     // FOR DEBUGGING
     //nearest = 0;
     //nearest = qMin(1, nearest);
 
     dbgRender << "First good plane:" << nearest << "(sc:" << scale << ")";
     return nearest;
 }
 
 void KisImagePyramid::alignSourceRect(QRect& rect, qreal scale)
 {
     qint32 index = findFirstGoodPlaneIndex(scale, rect.size());
     qint32 alignment = 1 << index;
 
     dbgRender << "Before alignment:\t" << rect;
 
     /**
      * Assume that KisImage pixels are always positive
      * It allows us to use binary op-s for aligning
      */
     Q_ASSERT(rect.left() >= 0 && rect.top() >= 0);
 
     qint32 x1, y1, x2, y2;
     rect.getCoords(&x1, &y1, &x2, &y2);
 
     alignByPow2Lo(x1, alignment);
     alignByPow2Lo(y1, alignment);
     /**
      * Here is a workaround of Qt's QRect::right()/bottom()
      * "historical reasons". It should be one pixel smaller
      * than actual right/bottom position
      */
     alignByPow2ButOneHi(x2, alignment);
     alignByPow2ButOneHi(y2, alignment);
 
     rect.setCoords(x1, y1, x2, y2);
 
     dbgRender << "After alignment:\t" << rect;
 }
 
 KisImagePatch KisImagePyramid::getNearestPatch(KisPPUpdateInfoSP info)
 {
     qint32 index = findFirstGoodPlaneIndex(qMax(info->scaleX, info->scaleY),
                                            info->imageRect.size());
     qreal planeScale = SCALE_FROM_INDEX(index);
     qint32 alignment = 1 << index;
 
     alignByPow2Hi(info->borderWidth, alignment);
 
     KisImagePatch patch(info->imageRect, info->borderWidth,
                         planeScale, planeScale);
 
     patch.setImage(convertToQImageFast(m_pyramid[index],
                                        patch.patchRect()));
     return patch;
 }
 
 void KisImagePyramid::drawFromOriginalImage(QPainter& gc, KisPPUpdateInfoSP info)
 {
     KisImagePatch patch = getNearestPatch(info);
     patch.drawMe(gc, info->viewportRect, info->renderHints);
 }
 
 QImage KisImagePyramid::convertToQImageFast(KisPaintDeviceSP paintDevice,
         const QRect& unscaledRect)
 {
     qint32 x, y, w, h;
     unscaledRect.getRect(&x, &y, &w, &h);
 
     QImage image = QImage(w, h, QImage::Format_ARGB32);
 
     paintDevice->dataManager()->readBytes(image.bits(), x, y, w, h);
 
     return image;
 }
 
 void KisImagePyramid::configChanged()
 {
     KisConfig cfg(true);
     m_useOcio = cfg.useOcio();
 }
 
diff --git a/libs/ui/kis_animation_cache_populator.cpp b/libs/ui/kis_animation_cache_populator.cpp
index c730a52d09..89bd40050b 100644
--- a/libs/ui/kis_animation_cache_populator.cpp
+++ b/libs/ui/kis_animation_cache_populator.cpp
@@ -1,317 +1,340 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_animation_cache_populator.h"
 
 #include <functional>
 
 #include <QTimer>
 #include <QMutex>
 #include <QtConcurrent>
 
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "KisPart.h"
 #include "KisDocument.h"
 #include "kis_image.h"
 #include "kis_image_animation_interface.h"
 #include "kis_canvas2.h"
 #include "kis_time_range.h"
 #include "kis_animation_frame_cache.h"
 #include "kis_update_info.h"
 #include "kis_signal_auto_connection.h"
 #include "kis_idle_watcher.h"
 #include "KisViewManager.h"
 #include "kis_node_manager.h"
 #include "kis_keyframe_channel.h"
 
 #include "KisAsyncAnimationCacheRenderer.h"
 #include "dialogs/KisAsyncAnimationCacheRenderDialog.h"
 
 
 struct KisAnimationCachePopulator::Private
 {
     KisAnimationCachePopulator *q;
     KisPart *part;
 
     QTimer timer;
 
     /**
      * Counts up the number of subsequent times Krita has been detected idle.
      */
     int idleCounter;
+    QStack<QPair<KisImageSP, int>> priorityFrames;
     static const int IDLE_COUNT_THRESHOLD = 4;
     static const int IDLE_CHECK_INTERVAL = 500;
     static const int BETWEEN_FRAMES_INTERVAL = 10;
 
     int requestedFrame;
     KisAnimationFrameCacheSP requestCache;
     KisOpenGLUpdateInfoSP requestInfo;
     KisSignalAutoConnectionsStore imageRequestConnections;
 
     QFutureWatcher<void> infoConversionWatcher;
 
     KisAsyncAnimationCacheRenderer regenerator;
     bool calculateAnimationCacheInBackground = true;
 
 
 
     enum State {
         NotWaitingForAnything,
         WaitingForIdle,
         WaitingForFrame,
         BetweenFrames
     };
     State state;
 
     Private(KisAnimationCachePopulator *_q, KisPart *_part)
         : q(_q),
           part(_part),
           idleCounter(0),
+          priorityFrames(),
           requestedFrame(-1),
           state(WaitingForIdle)
     {
         timer.setSingleShot(true);
     }
 
     void timerTimeout() {
         switch (state) {
         case WaitingForIdle:
         case BetweenFrames:
             generateIfIdle();
             break;
         case WaitingForFrame:
             KIS_ASSERT_RECOVER_NOOP(0 && "WaitingForFrame cannot have a timeout. Just skip this message and report a bug");
             break;
         case NotWaitingForAnything:
             KIS_ASSERT_RECOVER_NOOP(0 && "NotWaitingForAnything cannot have a timeout. Just skip this message and report a bug");
             break;
         }
     }
 
     void generateIfIdle()
     {
         if (part->idleWatcher()->isIdle()) {
             idleCounter++;
 
             if (idleCounter >= IDLE_COUNT_THRESHOLD) {
                 if (!tryRequestGeneration()) {
                     enterState(NotWaitingForAnything);
                 }
                 return;
             }
         } else {
             idleCounter = 0;
         }
 
         enterState(WaitingForIdle);
     }
 
 
     bool tryRequestGeneration()
     {
+        if (!priorityFrames.isEmpty()) {
+            KisImageSP image = priorityFrames.top().first;
+            const int priorityFrame = priorityFrames.top().second;
+            priorityFrames.pop();
+
+            KisAnimationFrameCacheSP cache = KisAnimationFrameCache::cacheForImage(image);
+            KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(cache, false);
+
+            bool requested = tryRequestGeneration(cache, KisTimeRange(), priorityFrame);
+            if (requested) return true;
+        }
+
         // Prioritize the active document
         KisAnimationFrameCacheSP activeDocumentCache = KisAnimationFrameCacheSP(0);
 
         KisMainWindow *activeWindow = part->currentMainwindow();
         if (activeWindow && activeWindow->activeView()) {
             KisCanvas2 *activeCanvas = activeWindow->activeView()->canvasBase();
 
             if (activeCanvas && activeCanvas->frameCache()) {
                 activeDocumentCache = activeCanvas->frameCache();
 
                 // Let's skip frames affected by changes to the active node (on the active document)
                 // This avoids constant invalidation and regeneration while drawing
                 KisNodeSP activeNode = activeCanvas->viewManager()->nodeManager()->activeNode();
                 KisTimeRange skipRange;
                 if (activeNode) {
-                    int currentTime = activeCanvas->currentImage()->animationInterface()->currentUITime();
+                    const int currentTime = activeCanvas->currentImage()->animationInterface()->currentUITime();
 
                     if (!activeNode->keyframeChannels().isEmpty()) {
                         Q_FOREACH (const KisKeyframeChannel *channel, activeNode->keyframeChannels()) {
                             skipRange |= channel->affectedFrames(currentTime);
                         }
                     } else {
                         skipRange = KisTimeRange::infinite(0);
                     }
                 }
 
-                bool requested = tryRequestGeneration(activeDocumentCache, skipRange);
+                bool requested = tryRequestGeneration(activeDocumentCache, skipRange, -1);
                 if (requested) return true;
             }
         }
 
         QList<KisAnimationFrameCache*> caches = KisAnimationFrameCache::caches();
         KisAnimationFrameCache *cache;
         Q_FOREACH (cache, caches) {
             if (cache == activeDocumentCache.data()) {
                 // We already handled this one...
                 continue;
             }
 
-            bool requested = tryRequestGeneration(cache, KisTimeRange());
+            bool requested = tryRequestGeneration(cache, KisTimeRange(), -1);
             if (requested) return true;
         }
 
         return false;
     }
 
-    bool tryRequestGeneration(KisAnimationFrameCacheSP cache, KisTimeRange skipRange)
+    bool tryRequestGeneration(KisAnimationFrameCacheSP cache, KisTimeRange skipRange, int priorityFrame)
     {
         KisImageSP image = cache->image();
         if (!image) return false;
 
         KisImageAnimationInterface *animation = image->animationInterface();
         KisTimeRange currentRange = animation->fullClipRange();
 
-        const int frame = KisAsyncAnimationCacheRenderDialog::calcFirstDirtyFrame(cache, currentRange, skipRange);
+        const int frame = priorityFrame >= 0 ? priorityFrame : KisAsyncAnimationCacheRenderDialog::calcFirstDirtyFrame(cache, currentRange, skipRange);
 
         if (frame >= 0) {
             return regenerate(cache, frame);
         }
 
         return false;
     }
 
     bool regenerate(KisAnimationFrameCacheSP cache, int frame)
     {
         if (state == WaitingForFrame) {
             // Already busy, deny request
             return false;
         }
 
         /**
          * We should enter the state before the frame is
          * requested. Otherwise the signal may come earlier than we
          * enter it.
          */
         enterState(WaitingForFrame);
 
         regenerator.setFrameCache(cache);
 
         // if we ever decide to add ROI to background cache
         // regeneration, it should be added here :)
         regenerator.startFrameRegeneration(cache->image(), frame);
 
         return true;
     }
 
     QString debugStateToString(State newState) {
         QString str = "<unknown>";
 
         switch (newState) {
         case WaitingForIdle:
             str = "WaitingForIdle";
             break;
         case WaitingForFrame:
             str = "WaitingForFrame";
             break;
         case NotWaitingForAnything:
             str = "NotWaitingForAnything";
             break;
         case BetweenFrames:
             str = "BetweenFrames";
             break;
         }
 
         return str;
     }
 
     void enterState(State newState)
     {
         //ENTER_FUNCTION() << debugStateToString(state) << "->" << debugStateToString(newState);
 
         state = newState;
         int timerTimeout = -1;
 
         switch (state) {
         case WaitingForIdle:
             timerTimeout = IDLE_CHECK_INTERVAL;
             break;
         case WaitingForFrame:
             // the timeout is handled by the regenerator now
             timerTimeout = -1;
             break;
         case NotWaitingForAnything:
             // frame conversion cannot be cancelled,
             // so there is no timeout
             timerTimeout = -1;
             break;
         case BetweenFrames:
             timerTimeout = BETWEEN_FRAMES_INTERVAL;
             break;
         }
 
         if (timerTimeout >= 0) {
             timer.start(timerTimeout);
         } else {
             timer.stop();
         }
     }
 };
 
 KisAnimationCachePopulator::KisAnimationCachePopulator(KisPart *part)
     : m_d(new Private(this, part))
 {
     connect(&m_d->timer, SIGNAL(timeout()), this, SLOT(slotTimer()));
 
     connect(&m_d->regenerator, SIGNAL(sigFrameCancelled(int)), SLOT(slotRegeneratorFrameCancelled()));
     connect(&m_d->regenerator, SIGNAL(sigFrameCompleted(int)), SLOT(slotRegeneratorFrameReady()));
 
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
     slotConfigChanged();
 }
 
 KisAnimationCachePopulator::~KisAnimationCachePopulator()
 {}
 
 bool KisAnimationCachePopulator::regenerate(KisAnimationFrameCacheSP cache, int frame)
 {
     return m_d->regenerate(cache, frame);
 }
 
+void KisAnimationCachePopulator::requestRegenerationWithPriorityFrame(KisImageSP image, int frameIndex)
+{
+    m_d->priorityFrames.append(qMakePair(image, frameIndex));
+
+    if (m_d->state == Private::NotWaitingForAnything) {
+        m_d->generateIfIdle();
+    }
+}
+
 void KisAnimationCachePopulator::slotTimer()
 {
     m_d->timerTimeout();
 }
 
 void KisAnimationCachePopulator::slotRequestRegeneration()
 {
     // skip if the user forbade background regeneration
     if (!m_d->calculateAnimationCacheInBackground) return;
 
     m_d->enterState(Private::WaitingForIdle);
 }
 
 void KisAnimationCachePopulator::slotRegeneratorFrameCancelled()
 {
     KIS_ASSERT_RECOVER_RETURN(m_d->state == Private::WaitingForFrame);
     m_d->enterState(Private::NotWaitingForAnything);
 }
 
 void KisAnimationCachePopulator::slotRegeneratorFrameReady()
 {
     m_d->enterState(Private::BetweenFrames);
 }
 
 void KisAnimationCachePopulator::slotConfigChanged()
 {
     KisConfig cfg(true);
     m_d->calculateAnimationCacheInBackground = cfg.calculateAnimationCacheInBackground();
     QTimer::singleShot(1000, this, SLOT(slotRequestRegeneration()));
 }
diff --git a/libs/ui/kis_animation_cache_populator.h b/libs/ui/kis_animation_cache_populator.h
index 4900d36d3c..a4a8bf686f 100644
--- a/libs/ui/kis_animation_cache_populator.h
+++ b/libs/ui/kis_animation_cache_populator.h
@@ -1,58 +1,59 @@
 /*
  *  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_ANIMATION_CACHE_POPULATOR_H
 #define KIS_ANIMATION_CACHE_POPULATOR_H
 
 #include <QObject>
 #include "kis_types.h"
 
 class KisPart;
 
 class KisAnimationCachePopulator : public QObject
 {
     Q_OBJECT
 
 public:
     KisAnimationCachePopulator(KisPart *part);
     ~KisAnimationCachePopulator() override;
 
     /**
      * Request generation of given frame. The request will
      * be ignored if the populator is already requesting a frame.
      * @return true if generation requested, false if busy
      */
     bool regenerate(KisAnimationFrameCacheSP cache, int frame);
+    void requestRegenerationWithPriorityFrame(KisImageSP image, int frameIndex);
 
 public Q_SLOTS:
     void slotRequestRegeneration();
 
 private Q_SLOTS:
     void slotTimer();
 
     void slotRegeneratorFrameCancelled();
     void slotRegeneratorFrameReady();
 
     void slotConfigChanged();
 
 private:
     struct Private;
     QScopedPointer<Private> m_d;
 };
 
 #endif
diff --git a/libs/ui/kis_animation_frame_cache.cpp b/libs/ui/kis_animation_frame_cache.cpp
index 4f924b2366..0a761c193c 100644
--- a/libs/ui/kis_animation_frame_cache.cpp
+++ b/libs/ui/kis_animation_frame_cache.cpp
@@ -1,414 +1,422 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_animation_frame_cache.h"
 
 #include <QMap>
 
 #include "kis_debug.h"
 
 #include "kis_image.h"
 #include "kis_image_animation_interface.h"
 #include "kis_time_range.h"
 #include "KisPart.h"
 #include "kis_animation_cache_populator.h"
 
 #include <KisAbstractFrameCacheSwapper.h>
 #include "KisFrameCacheSwapper.h"
 #include "KisInMemoryFrameCacheSwapper.h"
 
 #include "kis_image_config.h"
 #include "kis_config_notifier.h"
 
 #include "opengl/kis_opengl_image_textures.h"
 
 #include <kis_algebra_2d.h>
 #include <cmath>
 
 
 struct KisAnimationFrameCache::Private
 {
     Private(KisOpenGLImageTexturesSP _textures)
         : textures(_textures)
     {
         image = textures->image();
     }
 
     ~Private()
     {
     }
 
     KisOpenGLImageTexturesSP textures;
     KisImageWSP image;
 
     QScopedPointer<KisAbstractFrameCacheSwapper> swapper;
     int frameSizeLimit = 777;
 
     KisOpenGLUpdateInfoSP fetchFrameDataImpl(KisImageSP image, const QRect &requestedRect, int lod);
 
     struct Frame
     {
         KisOpenGLUpdateInfoSP openGlFrame;
         int length;
 
         Frame(KisOpenGLUpdateInfoSP info, int length)
             : openGlFrame(info), length(length)
         {}
     };
 
     QMap<int, int> newFrames;
 
     int getFrameIdAtTime(int time) const
     {
         if (newFrames.isEmpty()) return -1;
 
         auto it = newFrames.upperBound(time);
 
         if (it != newFrames.constBegin()) it--;
 
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(it != newFrames.constEnd(), 0);
         const int start = it.key();
         const int length = it.value();
 
         bool foundFrameValid = false;
 
         if (length == -1) {
             if (start <= time) {
                 foundFrameValid = true;
             }
         } else {
             int end = start + length - 1;
             if (start <= time && time <= end) {
                 foundFrameValid = true;
             }
         }
 
         return foundFrameValid ? start : -1;
     }
 
     bool hasFrame(int time) const {
         return getFrameIdAtTime(time) >= 0;
     }
 
     KisOpenGLUpdateInfoSP getFrame(int time)
     {
         const int frameId = getFrameIdAtTime(time);
         return frameId >= 0 ? swapper->loadFrame(frameId) : 0;
     }
 
     void addFrame(KisOpenGLUpdateInfoSP info, const KisTimeRange& range)
     {
         invalidate(range);
 
         const int length = range.isInfinite() ? -1 : range.end() - range.start() + 1;
         newFrames.insert(range.start(), length);
         swapper->saveFrame(range.start(), info, image->bounds());
     }
 
     /**
      * Invalidate any cached frames within the given time range.
      * @param range
      * @return true if frames were invalidated, false if nothing was changed
      */
     bool invalidate(const KisTimeRange& range)
     {
         if (newFrames.isEmpty()) return false;
 
         bool cacheChanged = false;
 
         auto it = newFrames.lowerBound(range.start());
         if (it.key() != range.start() && it != newFrames.begin()) it--;
 
         while (it != newFrames.end()) {
             const int start = it.key();
             const int length = it.value();
             const bool frameIsInfinite = (length == -1);
             const int end = start + length - 1;
 
             if (start >= range.start()) {
                 if (!range.isInfinite() && start > range.end()) {
                     break;
                 }
 
                 if (!range.isInfinite() && (frameIsInfinite || end > range.end())) {
                     // Reinsert with a later start
                     int newStart = range.end() + 1;
                     int newLength = frameIsInfinite ? -1 : (end - newStart + 1);
 
                     newFrames.insert(newStart, newLength);
                     swapper->moveFrame(start, newStart);
                 } else {
                     swapper->forgetFrame(start);
                 }
 
                 it = newFrames.erase(it);
 
                 cacheChanged = true;
                 continue;
 
             } else if (frameIsInfinite || end >= range.start()) {
                 const int newEnd = range.start() - 1;
                 *it = newEnd - start + 1;
 
                 cacheChanged = true;
             }
 
             it++;
         }
 
         return cacheChanged;
     }
 
     int effectiveLevelOfDetail(const QRect &rc) const {
         if (!frameSizeLimit) return 0;
 
         const int maxDimension = KisAlgebra2D::maxDimension(rc);
 
         const qreal minLod = -std::log2(qreal(frameSizeLimit) / maxDimension);
         const int lodLimit = qMax(0, qCeil(minLod));
         return lodLimit;
     }
 
 
     // TODO: verify that we don't have any leak here!
     typedef QMap<KisOpenGLImageTexturesSP, KisAnimationFrameCache*> CachesMap;
     static CachesMap caches;
 };
 
 KisAnimationFrameCache::Private::CachesMap KisAnimationFrameCache::Private::caches;
 
 KisAnimationFrameCacheSP KisAnimationFrameCache::getFrameCache(KisOpenGLImageTexturesSP textures)
 {
     KisAnimationFrameCache *cache;
 
     Private::CachesMap::iterator it = Private::caches.find(textures);
     if (it == Private::caches.end()) {
         cache = new KisAnimationFrameCache(textures);
         Private::caches.insert(textures, cache);
     } else {
         cache = it.value();
     }
 
     return cache;
 }
 
 const QList<KisAnimationFrameCache *> KisAnimationFrameCache::caches()
 {
     return Private::caches.values();
 }
 
+const KisAnimationFrameCacheSP KisAnimationFrameCache::cacheForImage(KisImageWSP image)
+{
+    auto it = std::find_if(Private::caches.begin(), Private::caches.end(),
+                           [image] (KisAnimationFrameCache *cache) { return cache->image() == image; });
+
+    return it != Private::caches.end() ? *it : nullptr;
+}
+
 KisAnimationFrameCache::KisAnimationFrameCache(KisOpenGLImageTexturesSP textures)
     : m_d(new Private(textures))
 {
     // create swapping backend
     slotConfigChanged();
 
     connect(m_d->image->animationInterface(), SIGNAL(sigFramesChanged(KisTimeRange,QRect)), this, SLOT(framesChanged(KisTimeRange,QRect)));
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
 }
 
 KisAnimationFrameCache::~KisAnimationFrameCache()
 {
     Private::caches.remove(m_d->textures);
 }
 
 bool KisAnimationFrameCache::uploadFrame(int time)
 {
     KisOpenGLUpdateInfoSP info = m_d->getFrame(time);
 
     if (!info) {
         // Do nothing!
         //
         // Previously we were trying to start cache regeneration in this point,
         // but it caused even bigger slowdowns when scrubbing
     } else {
         m_d->textures->recalculateCache(info, false);
     }
 
     return bool(info);
 }
 
 bool KisAnimationFrameCache::shouldUploadNewFrame(int newTime, int oldTime) const
 {
     if (oldTime < 0) return true;
 
     const int oldKeyframeStart = m_d->getFrameIdAtTime(oldTime);
     if (oldKeyframeStart < 0) return true;
 
     const int oldKeyFrameLength = m_d->newFrames[oldKeyframeStart];
     return !(newTime >= oldKeyframeStart && (newTime < oldKeyframeStart + oldKeyFrameLength || oldKeyFrameLength == -1));
 }
 
 KisAnimationFrameCache::CacheStatus KisAnimationFrameCache::frameStatus(int time) const
 {
     return m_d->hasFrame(time) ? Cached : Uncached;
 }
 
 KisImageWSP KisAnimationFrameCache::image()
 {
     return m_d->image;
 }
 
 void KisAnimationFrameCache::framesChanged(const KisTimeRange &range, const QRect &rect)
 {
     Q_UNUSED(rect);
 
     if (!range.isValid()) return;
 
     bool cacheChanged = m_d->invalidate(range);
 
     if (cacheChanged) {
         emit changed();
     }
 }
 
 void KisAnimationFrameCache::slotConfigChanged()
 {
     m_d->newFrames.clear();
 
     KisImageConfig cfg(true);
 
     if (cfg.useOnDiskAnimationCacheSwapping()) {
         m_d->swapper.reset(new KisFrameCacheSwapper(m_d->textures->updateInfoBuilder(), cfg.swapDir()));
     } else {
         m_d->swapper.reset(new KisInMemoryFrameCacheSwapper());
     }
 
     m_d->frameSizeLimit = cfg.useAnimationCacheFrameSizeLimit() ? cfg.animationCacheFrameSizeLimit() : 0;
     emit changed();
 }
 
 KisOpenGLUpdateInfoSP KisAnimationFrameCache::Private::fetchFrameDataImpl(KisImageSP image, const QRect &requestedRect, int lod)
 {
     if (lod > 0) {
         KisPaintDeviceSP tempDevice = new KisPaintDevice(image->projection()->colorSpace());
         tempDevice->prepareClone(image->projection());
         image->projection()->generateLodCloneDevice(tempDevice, image->projection()->extent(), lod);
 
         const QRect fetchRect = KisLodTransform::alignedRect(requestedRect, lod);
         return textures->updateInfoBuilder().buildUpdateInfo(fetchRect, tempDevice, image->bounds(), lod, true);
     } else {
         return textures->updateCache(requestedRect, image);
     }
 }
 
 KisOpenGLUpdateInfoSP KisAnimationFrameCache::fetchFrameData(int time, KisImageSP image, const KisRegion &requestedRegion) const
 {
     if (time != image->animationInterface()->currentTime()) {
         qWarning() << "WARNING: KisAnimationFrameCache::frameReady image's time doesn't coincide with the requested time!";
         qWarning() << "    "  << ppVar(image->animationInterface()->currentTime()) << ppVar(time);
     }
 
     // the frames are always generated at full scale
     KIS_SAFE_ASSERT_RECOVER_NOOP(image->currentLevelOfDetail() == 0);
 
     const int lod = m_d->effectiveLevelOfDetail(requestedRegion.boundingRect());
 
     KisOpenGLUpdateInfoSP totalInfo;
 
     Q_FOREACH (const QRect &rc, requestedRegion.rects()) {
         KisOpenGLUpdateInfoSP info = m_d->fetchFrameDataImpl(image, rc, lod);
         if (!totalInfo) {
             totalInfo = info;
         } else {
             const bool result = totalInfo->tryMergeWith(*info);
             KIS_SAFE_ASSERT_RECOVER_NOOP(result);
         }
     }
 
     return totalInfo;
 }
 
 void KisAnimationFrameCache::addConvertedFrameData(KisOpenGLUpdateInfoSP info, int time)
 {
     const KisTimeRange identicalRange =
         KisTimeRange::calculateIdenticalFramesRecursive(m_d->image->root(), time);
 
     m_d->addFrame(info, identicalRange);
 
     emit changed();
 }
 
 void KisAnimationFrameCache::dropLowQualityFrames(const KisTimeRange &range, const QRect &regionOfInterest, const QRect &minimalRect)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(!range.isInfinite());
     if (m_d->newFrames.isEmpty()) return;
 
     auto it = m_d->newFrames.upperBound(range.start());
 
     // the vector is guaranteed to be non-empty,
     // so decrementing iterator is safe
     if (it != m_d->newFrames.begin()) it--;
 
     while (it != m_d->newFrames.end() && it.key() <= range.end()) {
         const int frameId = it.key();
         const int frameLength = it.value();
 
         if (frameId + frameLength - 1 < range.start()) {
             ++it;
             continue;
         }
 
         const QRect frameRect = m_d->swapper->frameDirtyRect(frameId);
         const int frameLod = m_d->swapper->frameLevelOfDetail(frameId);
 
         if (frameLod > m_d->effectiveLevelOfDetail(regionOfInterest) || !frameRect.contains(minimalRect)) {
             m_d->swapper->forgetFrame(frameId);
             it = m_d->newFrames.erase(it);
         } else {
             ++it;
         }
     }
 }
 
 bool KisAnimationFrameCache::framesHaveValidRoi(const KisTimeRange &range, const QRect &regionOfInterest)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!range.isInfinite(), false);
     if (m_d->newFrames.isEmpty()) return false;
 
     auto it = m_d->newFrames.upperBound(range.start());
 
     if (it != m_d->newFrames.begin()) it--;
 
     int expectedNextFrameStart = it.key();
 
     while (it.key() <= range.end()) {
         const int frameId = it.key();
         const int frameLength = it.value();
 
         if (frameId + frameLength - 1 < range.start()) {
             expectedNextFrameStart = frameId + frameLength;
             ++it;
             continue;
         }
 
         if (expectedNextFrameStart != frameId) {
             KIS_SAFE_ASSERT_RECOVER_NOOP(expectedNextFrameStart < frameId);
             return false;
         }
 
         if (!m_d->swapper->frameDirtyRect(frameId).contains(regionOfInterest)) {
             return false;
         }
 
         expectedNextFrameStart = frameId + frameLength;
         ++it;
     }
 
     return true;
 }
diff --git a/libs/ui/kis_animation_frame_cache.h b/libs/ui/kis_animation_frame_cache.h
index b738d502a7..05975c5c74 100644
--- a/libs/ui/kis_animation_frame_cache.h
+++ b/libs/ui/kis_animation_frame_cache.h
@@ -1,90 +1,91 @@
 /*
  *  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_ANIMATION_FRAME_CACHE_H
 #define KIS_ANIMATION_FRAME_CACHE_H
 
 #include <QImage>
 #include <QObject>
 
 #include "kritaui_export.h"
 #include "kis_types.h"
 #include "kis_shared.h"
 
 class KisImage;
 class KisImageAnimationInterface;
 class KisTimeRange;
 class KisRegion;
 
 class KisOpenGLImageTextures;
 typedef KisSharedPtr<KisOpenGLImageTextures> KisOpenGLImageTexturesSP;
 
 class KisOpenGLUpdateInfo;
 typedef KisSharedPtr<KisOpenGLUpdateInfo> KisOpenGLUpdateInfoSP;
 
 class KRITAUI_EXPORT KisAnimationFrameCache : public QObject, public KisShared
 {
     Q_OBJECT
 
 public:
 
     static KisAnimationFrameCacheSP getFrameCache(KisOpenGLImageTexturesSP textures);
     static const QList<KisAnimationFrameCache*> caches();
+    static const KisAnimationFrameCacheSP cacheForImage(KisImageWSP image);
 
     KisAnimationFrameCache(KisOpenGLImageTexturesSP textures);
     ~KisAnimationFrameCache() override;
 
     QImage getFrame(int time);
     bool uploadFrame(int time);
 
     bool shouldUploadNewFrame(int newTime, int oldTime) const;
 
     enum CacheStatus {
         Cached,
         Uncached,
     };
 
     CacheStatus frameStatus(int time) const;
 
     KisImageWSP image();
 
     KisOpenGLUpdateInfoSP fetchFrameData(int time, KisImageSP image, const KisRegion &requestedRegion) const;
     void addConvertedFrameData(KisOpenGLUpdateInfoSP info, int time);
 
     /**
      * Drops all the frames with worse level of detail values than the current
      * desired level of detail.
      */
     void dropLowQualityFrames(const KisTimeRange &range, const QRect &regionOfInterest, const QRect &minimalRect);
 
     bool framesHaveValidRoi(const KisTimeRange &range, const QRect &regionOfInterest);
 
 Q_SIGNALS:
     void changed();
 
 private:
 
     struct Private;
     QScopedPointer<Private> m_d;
 
 private Q_SLOTS:
     void framesChanged(const KisTimeRange &range, const QRect &rect);
     void slotConfigChanged();
 };
 
 #endif
diff --git a/libs/ui/opengl/kis_texture_tile_update_info.h b/libs/ui/opengl/kis_texture_tile_update_info.h
index 60900c9d58..aa4edc7440 100644
--- a/libs/ui/opengl/kis_texture_tile_update_info.h
+++ b/libs/ui/opengl/kis_texture_tile_update_info.h
@@ -1,375 +1,345 @@
 /*
  *  Copyright (c) 2010, Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef KIS_TEXTURE_TILE_UPDATE_INFO_H_
 #define KIS_TEXTURE_TILE_UPDATE_INFO_H_
 
 #include <QMessageBox>
 #include <QThreadStorage>
 #include <QScopedArrayPointer>
 
-#include <KoColorSpace.h>
+#include "kis_config.h"
 #include "kis_image.h"
 #include "kis_paint_device.h"
-#include "kis_config.h"
-#include <KoColorConversionTransformation.h>
+#include "kis_texture_tile_info_pool.h"
 #include <KoChannelInfo.h>
+#include <KoColorConversionTransformation.h>
+#include <KoColorModelStandardIds.h>
+#include <KoColorSpace.h>
 #include <kis_lod_transform.h>
-#include "kis_texture_tile_info_pool.h"
-
 
 class KisTextureTileUpdateInfo;
 typedef QSharedPointer<KisTextureTileUpdateInfo> KisTextureTileUpdateInfoSP;
 typedef QVector<KisTextureTileUpdateInfoSP> KisTextureTileUpdateInfoSPList;
 
 /**
  * A buffer object for temporary data needed during the update process.
  *
  * - the buffer is allocated from the common pool to avoid memory
  *   fragmentation
  *
  * - the buffer's lifetime defines the lifetime of the allocated chunk
  *   of memory, so you don't have to thing about free'ing the memory
  */
 
 class DataBuffer
 {
 public:
     DataBuffer(KisTextureTileInfoPoolSP pool)
         : m_data(0),
           m_pixelSize(0),
           m_pool(pool)
     {
     }
 
     DataBuffer(int pixelSize, KisTextureTileInfoPoolSP pool)
         : m_data(0),
           m_pixelSize(0),
           m_pool(pool)
     {
         allocate(pixelSize);
     }
 
     DataBuffer(DataBuffer &&rhs)
         : m_data(rhs.m_data),
           m_pixelSize(rhs.m_pixelSize),
           m_pool(rhs.m_pool)
     {
         rhs.m_data = 0;
     }
 
     DataBuffer& operator=(DataBuffer &&rhs) {
         swap(rhs);
         return *this;
     }
 
     ~DataBuffer() {
         if (m_data) {
             m_pool->free(m_data, m_pixelSize);
         }
     }
 
     void allocate(int pixelSize) {
         Q_ASSERT(!m_data);
 
         m_pixelSize = pixelSize;
         m_data = m_pool->malloc(m_pixelSize);
     }
 
     inline quint8* data() const {
         return m_data;
     }
 
     void swap(DataBuffer &other) {
         std::swap(other.m_pixelSize, m_pixelSize);
         std::swap(other.m_data, m_data);
         std::swap(other.m_pool, m_pool);
     }
 
     int size() const {
         return m_data ? m_pool->chunkSize(m_pixelSize) : 0;
     }
 
     KisTextureTileInfoPoolSP pool() const {
         return m_pool;
     }
 
     int pixelSize() const {
         return m_pixelSize;
     }
 
 private:
     Q_DISABLE_COPY(DataBuffer)
 
     quint8 *m_data;
     int m_pixelSize;
     KisTextureTileInfoPoolSP m_pool;
 };
 
 class KisTextureTileUpdateInfo
 {
 public:
     KisTextureTileUpdateInfo(KisTextureTileInfoPoolSP pool)
         : m_patchPixels(pool),
           m_pool(pool)
     {
     }
 
     KisTextureTileUpdateInfo(qint32 col, qint32 row,
                              const QRect &tileRect, const QRect &updateRect, const QRect &currentImageRect,
                              int levelOfDetail,
                              KisTextureTileInfoPoolSP pool)
         : m_patchPixels(pool),
           m_pool(pool)
     {
         m_tileCol = col;
         m_tileRow = row;
         m_tileRect = tileRect;
         m_originalTileRect = m_tileRect;
         m_patchRect = m_tileRect & updateRect;
         m_originalPatchRect = m_patchRect;
         m_currentImageRect = currentImageRect;
 
         m_patchLevelOfDetail = levelOfDetail;
 
         if (m_patchLevelOfDetail) {
             // TODO: check if isBottommost() works correctly when m_originalPatchRect gets aligned
             //       and m_currentImageRect has non-aligned size
             m_originalPatchRect = KisLodTransform::alignedRect(m_originalPatchRect, m_patchLevelOfDetail);
             m_patchRect = KisLodTransform::scaledRect(m_originalPatchRect, m_patchLevelOfDetail);
             m_tileRect = KisLodTransform::scaledRect(m_originalTileRect, m_patchLevelOfDetail);
         }
     }
 
     ~KisTextureTileUpdateInfo() {
     }
 
     void retrieveData(KisPaintDeviceSP projectionDevice, const QBitArray &channelFlags, bool onlyOneChannelSelected, int selectedChannelIndex)
     {
         m_patchColorSpace = projectionDevice->colorSpace();
         m_patchPixels.allocate(m_patchColorSpace->pixelSize());
 
         projectionDevice->readBytes(m_patchPixels.data(),
                                        m_patchRect.x(), m_patchRect.y(),
                                        m_patchRect.width(), m_patchRect.height());
 
         // XXX: if the paint colorspace is rgb, we should do the channel swizzling in
         //      the display shader
         if (!channelFlags.isEmpty() && selectedChannelIndex >= 0 && selectedChannelIndex < m_patchColorSpace->channels().size()) {
             DataBuffer conversionCache(m_patchColorSpace->pixelSize(), m_pool);
 
             QList<KoChannelInfo*> channelInfo = m_patchColorSpace->channels();
-            int channelSize = channelInfo[selectedChannelIndex]->size();
-            int pixelSize = m_patchColorSpace->pixelSize();
             quint32 numPixels = m_patchRect.width() * m_patchRect.height();
 
             KisConfig cfg(true);
 
             if (onlyOneChannelSelected && !cfg.showSingleChannelAsColor()) {
-                int selectedChannelPos = channelInfo[selectedChannelIndex]->pos();
-                for (uint pixelIndex = 0; pixelIndex < numPixels; ++pixelIndex) {
-                    for (uint channelIndex = 0; channelIndex < m_patchColorSpace->channelCount(); ++channelIndex) {
-
-                        if (channelInfo[channelIndex]->channelType() == KoChannelInfo::COLOR) {
-                            memcpy(conversionCache.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize),
-                                   m_patchPixels.data() + (pixelIndex * pixelSize) + selectedChannelPos,
-                                   channelSize);
-                        }
-                        else if (channelInfo[channelIndex]->channelType() == KoChannelInfo::ALPHA) {
-                            memcpy(conversionCache.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize),
-                                   m_patchPixels.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize),
-                                   channelSize);
-                        }
-                    }
-                }
-            }
-            else {
-                for (uint pixelIndex = 0; pixelIndex < numPixels; ++pixelIndex) {
-                    for (uint channelIndex = 0; channelIndex < m_patchColorSpace->channelCount(); ++channelIndex) {
-                        if (channelFlags.testBit(channelIndex)) {
-                            memcpy(conversionCache.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize),
-                                   m_patchPixels.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize),
-                                   channelSize);
-                        }
-                        else {
-                            memset(conversionCache.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize), 0, channelSize);
-                        }
-                    }
-                }
-
+                m_patchColorSpace->convertChannelToVisualRepresentation(m_patchPixels.data(), conversionCache.data(), numPixels, selectedChannelIndex);
+            } else {
+                m_patchColorSpace->convertChannelToVisualRepresentation(m_patchPixels.data(), conversionCache.data(), numPixels, channelFlags);
             }
 
             conversionCache.swap(m_patchPixels);
         }
 
     }
 
     void convertTo(const KoColorSpace* dstCS,
                    KoColorConversionTransformation::Intent renderingIntent,
                    KoColorConversionTransformation::ConversionFlags conversionFlags)
     {
         // we use two-stage check of the color space equivalence:
         // first check pointers, and if not, check the spaces themselves
         if ((dstCS == m_patchColorSpace || *dstCS == *m_patchColorSpace) &&
             conversionFlags == KoColorConversionTransformation::Empty) {
 
             return;
         }
 
         if (m_patchRect.isValid()) {
             const qint32 numPixels = m_patchRect.width() * m_patchRect.height();
             DataBuffer conversionCache(dstCS->pixelSize(), m_pool);
 
             m_patchColorSpace->convertPixelsTo(m_patchPixels.data(), conversionCache.data(), dstCS, numPixels, renderingIntent, conversionFlags);
 
             m_patchColorSpace = dstCS;
             conversionCache.swap(m_patchPixels);
         }
     }
 
     void proofTo(const KoColorSpace* dstCS,
                    KoColorConversionTransformation::ConversionFlags conversionFlags,
                    KoColorConversionTransformation *proofingTransform)
     {
         if (dstCS == m_patchColorSpace && conversionFlags == KoColorConversionTransformation::Empty) return;
 
         if (m_patchRect.isValid()) {
             const qint32 numPixels = m_patchRect.width() * m_patchRect.height();
             DataBuffer conversionCache(dstCS->pixelSize(), m_pool);
 
             m_patchColorSpace->proofPixelsTo(m_patchPixels.data(), conversionCache.data(), numPixels, proofingTransform);
 
             m_patchColorSpace = dstCS;
             conversionCache.swap(m_patchPixels);
         }
     }
 
     static KoColorConversionTransformation *generateProofingTransform(const KoColorSpace* srcCS,
                                                                       const KoColorSpace* dstCS, const KoColorSpace* proofingSpace,
                                                                       KoColorConversionTransformation::Intent renderingIntent,
                                                                       KoColorConversionTransformation::Intent proofingIntent,
                                                                       KoColorConversionTransformation::ConversionFlags conversionFlags,
                                                                       KoColor gamutWarning,
                                                                       double adaptationState)
     {
         return srcCS->createProofingTransform(dstCS, proofingSpace, renderingIntent, proofingIntent, conversionFlags, gamutWarning.data(), adaptationState);
     }
 
     inline quint8* data() const {
         return m_patchPixels.data();
     }
 
     inline int patchLevelOfDetail() const {
         return m_patchLevelOfDetail;
     }
 
     inline QPoint realPatchOffset() const {
         return QPoint(m_patchRect.x() - m_tileRect.x(),
                       m_patchRect.y() - m_tileRect.y());
     }
 
     inline QSize realPatchSize() const {
         return m_patchRect.size();
     }
 
     inline QRect realPatchRect() const {
         return m_patchRect;
     }
 
     inline QSize realTileSize() const {
         return m_tileRect.size();
     }
 
     inline bool isTopmost() const {
         return m_originalPatchRect.top() == m_currentImageRect.top();
     }
 
     inline bool isLeftmost() const {
         return m_originalPatchRect.left() == m_currentImageRect.left();
     }
 
     inline bool isRightmost() const {
         return m_originalPatchRect.right() == m_currentImageRect.right();
     }
 
     inline bool isBottommost() const {
         return m_originalPatchRect.bottom() == m_currentImageRect.bottom();
     }
 
     inline bool isEntireTileUpdated() const {
         return m_patchRect == m_tileRect;
     }
 
     inline qint32 tileCol() const {
         return m_tileCol;
     }
 
     inline qint32 tileRow() const {
         return m_tileRow;
     }
 
     inline int pixelSize() const {
         return m_patchColorSpace->pixelSize();
     }
 
     inline const KoColorSpace* patchColorSpace() const {
         return m_patchColorSpace;
     }
 
     inline quint32 patchPixelsLength() const {
         return m_patchPixels.size();
     }
 
     inline bool valid() const {
         return m_patchRect.isValid();
     }
 
     inline DataBuffer&& takePixelData() {
         return std::move(m_patchPixels);
     }
 
     inline void putPixelData(DataBuffer &&buffer, const KoColorSpace *colorSpace) {
         m_patchPixels = std::move(buffer);
         m_patchColorSpace = colorSpace;
     }
 
 private:
     Q_DISABLE_COPY(KisTextureTileUpdateInfo)
 
 private:
     qint32 m_tileCol;
     qint32 m_tileRow;
     QRect m_currentImageRect;
     QRect m_tileRect;
     QRect m_patchRect;
     const KoColorSpace* m_patchColorSpace;
 
     QRect m_realPatchRect;
     QRect m_realPatchOffset;
     QRect m_realTileSize;
     int m_patchLevelOfDetail;
 
     QRect m_originalPatchRect;
     QRect m_originalTileRect;
 
     DataBuffer m_patchPixels;
     KisTextureTileInfoPoolSP m_pool;
 };
 
 
 #endif /* KIS_TEXTURE_TILE_UPDATE_INFO_H_ */
 
diff --git a/libs/widgets/KisVisualColorSelector.cpp b/libs/widgets/KisVisualColorSelector.cpp
index e18eb62ee9..b5dd58e1c3 100644
--- a/libs/widgets/KisVisualColorSelector.cpp
+++ b/libs/widgets/KisVisualColorSelector.cpp
@@ -1,563 +1,564 @@
 /*
  * Copyright (C) Wolthera van Hovell tot Westerflier <griffinvalley@gmail.com>, (C) 2016
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "KisVisualColorSelector.h"
 
 #include <QColor>
 #include <QPixmap>
 #include <QPainter>
 #include <QPainterPath>
 #include <QRect>
 #include <QVector>
 #include <QVector3D>
 #include <QVector4D>
 #include <QVBoxLayout>
 #include <QList>
 #include <QPolygon>
 #include <QtMath>
 
 #include <KSharedConfig>
 #include <KConfigGroup>
 
 #include "KoColorConversions.h"
 #include "KoColorDisplayRendererInterface.h"
 #include "KoColorProfile.h"
 #include "KoChannelInfo.h"
 #include <KoColorModelStandardIds.h>
 #include <QPointer>
 #include "kis_signal_compressor.h"
 #include "kis_debug.h"
 
 #include "KisVisualColorSelectorShape.h"
 #include "KisVisualRectangleSelectorShape.h"
 #include "KisVisualTriangleSelectorShape.h"
 #include "KisVisualEllipticalSelectorShape.h"
 
 struct KisVisualColorSelector::Private
 {
     KoColor currentcolor;
     const KoColorSpace *currentCS {0};
     QList<KisVisualColorSelectorShape*> widgetlist;
-    bool updateLonesome {false}; // currently redundant; remove?
     bool circular {false};
-    bool exposureSupported = false;
-    bool isRGBA = false;
-    bool isLinear = false;
+    bool exposureSupported {false};
+    bool isRGBA {false};
+    bool isLinear {false};
     int displayPosition[4]; // map channel index to storage index for display
-    int colorChannelCount;
+    int colorChannelCount {0};
     QVector4D channelValues;
     QVector4D channelMaxValues;
-    ColorModel model;
+    ColorModel model {ColorModel::None};
     const KoColorDisplayRendererInterface *displayRenderer {0};
     KisColorSelectorConfiguration acs_config;
     KisSignalCompressor *updateTimer {0};
 };
 
 KisVisualColorSelector::KisVisualColorSelector(QWidget *parent)
     : KisColorSelectorInterface(parent)
     , m_d(new Private)
 {
     this->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
 
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
     m_d->acs_config = KisColorSelectorConfiguration::fromString(cfg.readEntry("colorSelectorConfiguration", KisColorSelectorConfiguration().toString()));
     m_d->updateTimer = new KisSignalCompressor(100 /* ms */, KisSignalCompressor::POSTPONE);
     connect(m_d->updateTimer, SIGNAL(timeout()), SLOT(slotRebuildSelectors()), Qt::UniqueConnection);
 }
 
 KisVisualColorSelector::~KisVisualColorSelector()
 {
     delete m_d->updateTimer;
 }
 
 void KisVisualColorSelector::slotSetColor(const KoColor &c)
 {
     m_d->currentcolor = c;
     if (m_d->currentCS != c.colorSpace()) {
         slotsetColorSpace(c.colorSpace());
     }
     else {
         m_d->channelValues = convertKoColorToShapeCoordinates(m_d->currentcolor);
         Q_FOREACH (KisVisualColorSelectorShape *shape, m_d->widgetlist) {
             shape->setChannelValues(m_d->channelValues, true);
         }
     }
 }
 
 void KisVisualColorSelector::slotsetColorSpace(const KoColorSpace *cs)
 {
     if (m_d->currentCS != cs) {
         m_d->currentCS = cs;
         slotRebuildSelectors();
     }
 }
 
 void KisVisualColorSelector::setConfig(bool forceCircular, bool forceSelfUpdate)
 {
+    Q_UNUSED(forceSelfUpdate)
     m_d->circular = forceCircular;
-    m_d->updateLonesome = forceSelfUpdate;
 }
 
 KoColor KisVisualColorSelector::getCurrentColor() const
 {
     return m_d->currentcolor;
 }
 
 QVector4D KisVisualColorSelector::getChannelValues() const
 {
     return m_d->channelValues;
 }
 
 KoColor KisVisualColorSelector::convertShapeCoordsToKoColor(const QVector4D &coordinates) const
 {
     KoColor c(m_d->currentCS);
     QVector4D baseValues(coordinates);
     QVector <float> channelValues(c.colorSpace()->channelCount());
     channelValues.fill(1.0);
 
     if (m_d->model != ColorModel::Channel && m_d->isRGBA == true) {
 
         if (m_d->model == ColorModel::HSV) {
             HSVToRGB(coordinates.x()*360, coordinates.y(), coordinates.z(), &baseValues[0], &baseValues[1], &baseValues[2]);
         }
         else if (m_d->model == ColorModel::HSL) {
             HSLToRGB(coordinates.x()*360, coordinates.y(), coordinates.z(), &baseValues[0], &baseValues[1], &baseValues[2]);
         }
         else if (m_d->model == ColorModel::HSI) {
             // why suddenly qreal?
             qreal temp[3];
             HSIToRGB(coordinates.x(), coordinates.y(), coordinates.z(), &temp[0], &temp[1], &temp[2]);
             baseValues.setX(temp[0]);
             baseValues.setY(temp[1]);
             baseValues.setZ(temp[2]);
         }
         else /*if (m_d->model == ColorModel::HSY)*/ {
             QVector <qreal> luma= m_d->currentCS->lumaCoefficients();
             qreal temp[3];
             HSYToRGB(coordinates.x(), coordinates.y(), coordinates.z(), &temp[0], &temp[1], &temp[2],
                     luma[0], luma[1], luma[2]);
             baseValues.setX(temp[0]);
             baseValues.setY(temp[1]);
             baseValues.setZ(temp[2]);
         }
         if (m_d->isLinear) {
             for (int i=0; i<3; i++) {
                 baseValues[i] = pow(baseValues[i], 2.2);
             }
         }
     }
 
     if (m_d->exposureSupported) {
         baseValues *= m_d->channelMaxValues;
     }
 
     for (int i=0; i<m_d->colorChannelCount; i++) {
-        // TODO: proper exposure control
-        channelValues[m_d->displayPosition[i]] = baseValues[i] /* *(maxvalue[i]) */;
+        channelValues[m_d->displayPosition[i]] = baseValues[i];
     }
 
     c.colorSpace()->fromNormalisedChannelsValue(c.data(), channelValues);
 
     return c;
 
 }
 
 QVector4D KisVisualColorSelector::convertKoColorToShapeCoordinates(KoColor c) const
 {
     if (c.colorSpace() != m_d->currentCS) {
         c.convertTo(m_d->currentCS);
     }
     QVector <float> channelValues (c.colorSpace()->channelCount());
     channelValues.fill(1.0);
     m_d->currentCS->normalisedChannelsValue(c.data(), channelValues);
     QVector4D channelValuesDisplay(0, 0, 0, 0), coordinates(0, 0, 0, 0);
-    // TODO: L*a*b is apparently not [0, 1]^3 as "normalized" values, needs extra transform (old bug)
+
     for (int i =0; i<m_d->colorChannelCount; i++) {
         channelValuesDisplay[i] = channelValues[m_d->displayPosition[i]];
     }
 
     if (m_d->exposureSupported) {
         channelValuesDisplay /= m_d->channelMaxValues;
     }
     if (m_d->model != ColorModel::Channel && m_d->isRGBA == true) {
         if (m_d->isRGBA == true) {
             if (m_d->isLinear) {
                 for (int i=0; i<3; i++) {
                     channelValuesDisplay[i] = pow(channelValuesDisplay[i], 1/2.2);
                 }
             }
-            if (m_d->model == ColorModel::HSV){
+            if (m_d->model == ColorModel::HSV) {
                 QVector3D hsv;
-                // TODO: handle undefined hue case (returns -1)
                 RGBToHSV(channelValuesDisplay[0], channelValuesDisplay[1], channelValuesDisplay[2], &hsv[0], &hsv[1], &hsv[2]);
                 hsv[0] /= 360;
                 coordinates = QVector4D(hsv, 0.f);
             } else if (m_d->model == ColorModel::HSL) {
                 QVector3D hsl;
                 RGBToHSL(channelValuesDisplay[0], channelValuesDisplay[1], channelValuesDisplay[2], &hsl[0], &hsl[1], &hsl[2]);
                 hsl[0] /= 360;
                 coordinates = QVector4D(hsl, 0.f);
             } else if (m_d->model == ColorModel::HSI) {
                 qreal hsi[3];
                 RGBToHSI(channelValuesDisplay[0], channelValuesDisplay[1], channelValuesDisplay[2], &hsi[0], &hsi[1], &hsi[2]);
                 coordinates = QVector4D(hsi[0], hsi[1], hsi[2], 0.f);
             } else if (m_d->model == ColorModel::HSY) {
                 QVector <qreal> luma = m_d->currentCS->lumaCoefficients();
                 qreal hsy[3];
                 RGBToHSY(channelValuesDisplay[0], channelValuesDisplay[1], channelValuesDisplay[2], &hsy[0], &hsy[1], &hsy[2], luma[0], luma[1], luma[2]);
                 coordinates = QVector4D(hsy[0], hsy[1], hsy[2], 0.f);
             }
+            // if we couldn't determine a hue, keep last value
+            if (coordinates[0] < 0) {
+                coordinates[0] = m_d->channelValues[0];
+            }
             for (int i=0; i<3; i++) {
                 coordinates[i] = qBound(0.f, coordinates[i], 1.f);
             }
         }
     } else {
         for (int i=0; i<4; i++) {
             coordinates[i] = qBound(0.f, channelValuesDisplay[i], 1.f);
         }
     }
     return coordinates;
 }
 
 void KisVisualColorSelector::configurationChanged()
 {
     if (m_d->updateTimer) {
         m_d->updateTimer->start();
     }
 }
 
 void KisVisualColorSelector::slotDisplayConfigurationChanged()
 {
     Q_ASSERT(m_d->displayRenderer);
 
     if (m_d->currentCS)
     {
         m_d->channelMaxValues = QVector4D(1, 1, 1, 1);
         QList<KoChannelInfo *> channels = m_d->currentCS->channels();
         for (int i=0; i<m_d->colorChannelCount; ++i)
         {
             m_d->channelMaxValues[i] = m_d->displayRenderer->maxVisibleFloatValue(channels[m_d->displayPosition[i]]);
         }
         // need to re-scale our normalized channel values on exposure changes:
         m_d->channelValues = convertKoColorToShapeCoordinates(m_d->currentcolor);
         Q_FOREACH (KisVisualColorSelectorShape *shape, m_d->widgetlist) {
             shape->setChannelValues(m_d->channelValues, true);
         }
     }
 }
 
 void KisVisualColorSelector::slotRebuildSelectors()
 {
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
     m_d->acs_config = KisColorSelectorConfiguration::fromString(cfg.readEntry("colorSelectorConfiguration", KisColorSelectorConfiguration().toString()));
 
     QList<KoChannelInfo *> channelList = m_d->currentCS->channels();
     int cCount = 0;
     Q_FOREACH(const KoChannelInfo *channel, channelList)
     {
         if (channel->channelType() != KoChannelInfo::ALPHA)
         {
             m_d->displayPosition[cCount] = channel->displayPosition();
             ++cCount;
         }
     }
     Q_ASSERT_X(cCount < 5, "", "unsupported channel count!");
     m_d->colorChannelCount = cCount;
 
     // TODO: The following is done because the IDs are actually strings. Ideally, in the future, we
     // refactor everything so that the IDs are actually proper enums or something faster.
     if (m_d->displayRenderer
             && (m_d->currentCS->colorDepthId() == Float16BitsColorDepthID
                 || m_d->currentCS->colorDepthId() == Float32BitsColorDepthID
                 || m_d->currentCS->colorDepthId() == Float64BitsColorDepthID)
             && m_d->currentCS->colorModelId() != LABAColorModelID
             && m_d->currentCS->colorModelId() != CMYKAColorModelID) {
         m_d->exposureSupported = true;
     } else {
         m_d->exposureSupported = false;
     }
     m_d->isRGBA = (m_d->currentCS->colorModelId() == RGBAColorModelID);
     const KoColorProfile *profile = m_d->currentCS->profile();
     m_d->isLinear = (profile && profile->isLinear());
 
     qDeleteAll(children());
     m_d->widgetlist.clear();
     // TODO: Layout only used for monochrome selector currently, but always present
     QLayout *layout = new QHBoxLayout;
     //recreate all the widgets.
     m_d->model = KisVisualColorSelector::Channel;
 
     if (m_d->currentCS->colorChannelCount() == 1) {
 
         KisVisualColorSelectorShape *bar;
 
         if (m_d->circular==false) {
             bar = new KisVisualRectangleSelectorShape(this, KisVisualColorSelectorShape::onedimensional, m_d->currentCS, 0, 0,m_d->displayRenderer, 20);
             bar->setMaximumWidth(width()*0.1);
             bar->setMaximumHeight(height());
         }
         else {
             bar = new KisVisualEllipticalSelectorShape(this, KisVisualColorSelectorShape::onedimensional, m_d->currentCS, 0, 0,m_d->displayRenderer, 20, KisVisualEllipticalSelectorShape::borderMirrored);
             layout->setMargin(0);
         }
 
         connect(bar, SIGNAL(sigCursorMoved(QPointF)), SLOT(slotCursorMoved(QPointF)));
         layout->addWidget(bar);
         m_d->widgetlist.append(bar);
     }
     else if (m_d->currentCS->colorChannelCount() == 3) {
         KisVisualColorSelector::ColorModel modelS = KisVisualColorSelector::HSV;
         int channel1 = 0;
         int channel2 = 1;
         int channel3 = 2;
 
         switch(m_d->acs_config.subTypeParameter)
         {
         case KisColorSelectorConfiguration::H:
             channel1 = 0;
             break;
         case KisColorSelectorConfiguration::hsyS:
         case KisColorSelectorConfiguration::hsiS:
         case KisColorSelectorConfiguration::hslS:
         case KisColorSelectorConfiguration::hsvS:
             channel1 = 1;
             break;
         case KisColorSelectorConfiguration::V:
         case KisColorSelectorConfiguration::L:
         case KisColorSelectorConfiguration::I:
         case KisColorSelectorConfiguration::Y:
             channel1 = 2;
             break;
         default:
             Q_ASSERT_X(false, "", "Invalid acs_config.subTypeParameter");
         }
 
         switch(m_d->acs_config.mainTypeParameter)
         {
         case KisColorSelectorConfiguration::hsySH:
             modelS = KisVisualColorSelector::HSY;
             channel2 = 0;
             channel3 = 1;
             break;
         case KisColorSelectorConfiguration::hsiSH:
             modelS = KisVisualColorSelector::HSI;
             channel2 = 0;
             channel3 = 1;
             break;
         case KisColorSelectorConfiguration::hslSH:
             modelS = KisVisualColorSelector::HSL;
             channel2 = 0;
             channel3 = 1;
             break;
         case KisColorSelectorConfiguration::hsvSH:
             modelS = KisVisualColorSelector::HSV;
             channel2 = 0;
             channel3 = 1;
             break;
         case KisColorSelectorConfiguration::YH:
             modelS = KisVisualColorSelector::HSY;
             channel2 = 0;
             channel3 = 2;
             break;
         case KisColorSelectorConfiguration::LH:
             modelS = KisVisualColorSelector::HSL;
             channel2 = 0;
             channel3 = 2;
             break;
         case KisColorSelectorConfiguration::IH:
             modelS = KisVisualColorSelector::HSL;
             channel2 = 0;
             channel3 = 2;
             break;
         case KisColorSelectorConfiguration::VH:
             modelS = KisVisualColorSelector::HSV;
             channel2 = 0;
             channel3 = 2;
             break;
         case KisColorSelectorConfiguration::SY:
             modelS = KisVisualColorSelector::HSY;
             channel2 = 1;
             channel3 = 2;
             break;
         case KisColorSelectorConfiguration::SI:
             modelS = KisVisualColorSelector::HSI;
             channel2 = 1;
             channel3 = 2;
             break;
         case KisColorSelectorConfiguration::SL:
             modelS = KisVisualColorSelector::HSL;
             channel2 = 1;
             channel3 = 2;
             break;
         case KisColorSelectorConfiguration::SV:
         case KisColorSelectorConfiguration::SV2:
             modelS = KisVisualColorSelector::HSV;
             channel2 = 1;
             channel3 = 2;
             break;
         default:
             Q_ASSERT_X(false, "", "Invalid acs_config.mainTypeParameter");
         }
         if (m_d->acs_config.mainType == KisColorSelectorConfiguration::Triangle) {
             modelS = KisVisualColorSelector::HSV;
             //Triangle only really works in HSV mode.
         }
 
         m_d->model = modelS;
         KisVisualColorSelectorShape *bar;
         if (m_d->acs_config.subType == KisColorSelectorConfiguration::Ring) {
             bar = new KisVisualEllipticalSelectorShape(this,
                                                        KisVisualColorSelectorShape::onedimensional,
                                                        m_d->currentCS, channel1, channel1,
                                                        m_d->displayRenderer, 20,KisVisualEllipticalSelectorShape::border);
         }
         else if (m_d->acs_config.subType == KisColorSelectorConfiguration::Slider && m_d->circular == false) {
             bar = new KisVisualRectangleSelectorShape(this,
                                                       KisVisualColorSelectorShape::onedimensional,
                                                       m_d->currentCS, channel1, channel1,
                                                       m_d->displayRenderer, 20);
         }
         else if (m_d->acs_config.subType == KisColorSelectorConfiguration::Slider && m_d->circular == true) {
             bar = new KisVisualEllipticalSelectorShape(this,
                                                        KisVisualColorSelectorShape::onedimensional,
                                                        m_d->currentCS, channel1, channel1,
                                                        m_d->displayRenderer, 20, KisVisualEllipticalSelectorShape::borderMirrored);
         } else {
             // Accessing bar below would crash since it's not initialized.
             // Hopefully this can never happen.
             warnUI << "Invalid subType, cannot initialize KisVisualColorSelectorShape";
             Q_ASSERT_X(false, "", "Invalid subType, cannot initialize KisVisualColorSelectorShape");
             return;
         }
 
         m_d->widgetlist.append(bar);
 
         KisVisualColorSelectorShape *block;
         if (m_d->acs_config.mainType == KisColorSelectorConfiguration::Triangle) {
             block = new KisVisualTriangleSelectorShape(this, KisVisualColorSelectorShape::twodimensional,
                                                        m_d->currentCS, channel2, channel3,
                                                        m_d->displayRenderer);
         }
         else if (m_d->acs_config.mainType == KisColorSelectorConfiguration::Square) {
             block = new KisVisualRectangleSelectorShape(this, KisVisualColorSelectorShape::twodimensional,
                                                         m_d->currentCS, channel2, channel3,
                                                         m_d->displayRenderer);
         }
         else {
             block = new KisVisualEllipticalSelectorShape(this, KisVisualColorSelectorShape::twodimensional,
                                                          m_d->currentCS, channel2, channel3,
                                                          m_d->displayRenderer);
         }
 
         connect(bar, SIGNAL(sigCursorMoved(QPointF)), SLOT(slotCursorMoved(QPointF)));
         connect(block, SIGNAL(sigCursorMoved(QPointF)), SLOT(slotCursorMoved(QPointF)));
         m_d->widgetlist.append(block);
     }
     else if (m_d->currentCS->colorChannelCount() == 4) {
         KisVisualRectangleSelectorShape *block =  new KisVisualRectangleSelectorShape(this, KisVisualRectangleSelectorShape::twodimensional, m_d->currentCS, 0, 1);
         KisVisualRectangleSelectorShape *block2 =  new KisVisualRectangleSelectorShape(this, KisVisualRectangleSelectorShape::twodimensional, m_d->currentCS, 2, 3);
         connect(block, SIGNAL(sigCursorMoved(QPointF)), SLOT(slotCursorMoved(QPointF)));
         connect(block2, SIGNAL(sigCursorMoved(QPointF)), SLOT(slotCursorMoved(QPointF)));
         m_d->widgetlist.append(block);
         m_d->widgetlist.append(block2);
     }
 
     this->setLayout(layout);
     // make sure we call "our" resize function
     KisVisualColorSelector::resizeEvent(0);
 
     // finally recalculate channel values and update widgets
     if (m_d->displayRenderer) {
         slotDisplayConfigurationChanged();
     }
     m_d->channelValues = convertKoColorToShapeCoordinates(m_d->currentcolor);
     Q_FOREACH (KisVisualColorSelectorShape *shape, m_d->widgetlist) {
         shape->setChannelValues(m_d->channelValues, true);
         // if this widget is currently visible, new children are hidden by default
         shape->show();
     }
 }
 
 void KisVisualColorSelector::setDisplayRenderer (const KoColorDisplayRendererInterface *displayRenderer) {
     m_d->displayRenderer = displayRenderer;
     if (m_d->widgetlist.size()>0) {
         Q_FOREACH (KisVisualColorSelectorShape *shape, m_d->widgetlist) {
             shape->setDisplayRenderer(displayRenderer);
         }
     }
     connect(m_d->displayRenderer, SIGNAL(displayConfigurationChanged()),
             SLOT(slotDisplayConfigurationChanged()), Qt::UniqueConnection);
     slotDisplayConfigurationChanged();
 }
 
 void KisVisualColorSelector::slotCursorMoved(QPointF pos)
 {
     const KisVisualColorSelectorShape *shape = qobject_cast<KisVisualColorSelectorShape *>(sender());
     Q_ASSERT(shape);
     QVector<int> channels = shape->getChannels();
     m_d->channelValues[channels.at(0)] = pos.x();
     if (shape->getDimensions() == KisVisualColorSelectorShape::twodimensional) {
         m_d->channelValues[channels.at(1)] = pos.y();
     }
     KoColor newColor = convertShapeCoordsToKoColor(m_d->channelValues);
     if (newColor != m_d->currentcolor) {
         m_d->currentcolor = newColor;
         emit sigNewColor(m_d->currentcolor);
     }
     Q_FOREACH (KisVisualColorSelectorShape *widget, m_d->widgetlist) {
         if (widget != shape){
             widget->setChannelValues(m_d->channelValues, false);
         }
     }
 }
 
 void KisVisualColorSelector::resizeEvent(QResizeEvent *) {
     int sizeValue = qMin(width(), height());
     int borderWidth = qMax(sizeValue*0.1, 20.0);
     QRect newrect(0,0, this->geometry().width(), this->geometry().height());
     if (!m_d->currentCS) {
         slotsetColorSpace(m_d->currentcolor.colorSpace());
     }
     if (m_d->currentCS->colorChannelCount()==3) {
         // set border width first, else the resized painting may have happened already, and we'd have to re-render
         m_d->widgetlist.at(0)->setBorderWidth(borderWidth);
         if (m_d->acs_config.subType == KisColorSelectorConfiguration::Ring) {
             m_d->widgetlist.at(0)->resize(sizeValue,sizeValue);
         }
         else if (m_d->acs_config.subType == KisColorSelectorConfiguration::Slider && m_d->circular==false) {
             m_d->widgetlist.at(0)->resize(borderWidth, sizeValue);
         }
         else if (m_d->acs_config.subType == KisColorSelectorConfiguration::Slider && m_d->circular==true) {
             m_d->widgetlist.at(0)->resize(sizeValue,sizeValue);
         }
 
         if (m_d->acs_config.mainType == KisColorSelectorConfiguration::Triangle) {
             m_d->widgetlist.at(1)->setGeometry(m_d->widgetlist.at(0)->getSpaceForTriangle(newrect));
         }
         else if (m_d->acs_config.mainType == KisColorSelectorConfiguration::Square) {
             m_d->widgetlist.at(1)->setGeometry(m_d->widgetlist.at(0)->getSpaceForSquare(newrect));
         }
         else if (m_d->acs_config.mainType == KisColorSelectorConfiguration::Wheel) {
             m_d->widgetlist.at(1)->setGeometry(m_d->widgetlist.at(0)->getSpaceForCircle(newrect));
         }
     }
     else if (m_d->currentCS->colorChannelCount() == 4) {
         int sizeBlock = qMin(width()/2 - 8, height());
         m_d->widgetlist.at(0)->setGeometry(0, 0, sizeBlock, sizeBlock);
         m_d->widgetlist.at(1)->setGeometry(sizeBlock + 8, 0, sizeBlock, sizeBlock);
     }
 }
diff --git a/libs/widgets/KisVisualColorSelector.h b/libs/widgets/KisVisualColorSelector.h
index fe5eb1c40b..529909f7c1 100644
--- a/libs/widgets/KisVisualColorSelector.h
+++ b/libs/widgets/KisVisualColorSelector.h
@@ -1,88 +1,86 @@
 /*
  * Copyright (C) Wolthera van Hovell tot Westerflier <griffinvalley@gmail.com>, (C) 2016
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public 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_VISUAL_COLOR_SELECTOR_H
 #define KIS_VISUAL_COLOR_SELECTOR_H
 
 #include <QWidget>
 #include <QScopedPointer>
 #include <QPixmap>
 #include <QRegion>
 #include <QMouseEvent>
 
 #include <KoColor.h>
 #include <KoColorSpace.h>
 #include "KoColorDisplayRendererInterface.h"
 
 #include "KisColorSelectorConfiguration.h"
 #include "KisColorSelectorInterface.h"
 #include "kritawidgets_export.h"
 
 /**
  * @brief The KisVisualColorSelector class
  *
  * This gives a color selector box that draws gradients and everything.
  *
  * Unlike other color selectors, this one draws the full gamut of the given
  * colorspace.
  */
 class KRITAWIDGETS_EXPORT KisVisualColorSelector : public KisColorSelectorInterface
 {
     Q_OBJECT
 public:
-    enum ColorModel{Channel, HSV, HSL, HSI, HSY, YUV};
+    enum ColorModel { None, Channel, HSV, HSL, HSI, HSY, YUV };
 
     explicit KisVisualColorSelector(QWidget *parent = 0);
     ~KisVisualColorSelector() override;
 
     /**
      * @brief setConfig
      * @param forceCircular
      * Force circular is for space where you only have room for a circular selector.
      * @param forceSelfUpdate
-     * force self-update is for making it update itself when using a modal dialog.
+     * ignored, can possibly be removed from parent class now
      */
     void setConfig(bool forceCircular, bool forceSelfUpdate) override;
     KoColor getCurrentColor() const override;
     QVector4D getChannelValues() const;
     KoColor convertShapeCoordsToKoColor(const QVector4D &coordinates) const;
     QVector4D convertKoColorToShapeCoordinates(KoColor c) const;
 
 public Q_SLOTS:
 
     void slotSetColor(const KoColor &c) override;
     void slotsetColorSpace(const KoColorSpace *cs);
     void configurationChanged();
     void setDisplayRenderer (const KoColorDisplayRendererInterface *displayRenderer) override;
 
 private Q_SLOTS:
     void slotCursorMoved(QPointF pos);
     void slotDisplayConfigurationChanged();
     void slotRebuildSelectors();
 
 protected:
     void resizeEvent(QResizeEvent *) override;
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 
-    void drawGradients();
-
 };
 
 #endif
diff --git a/packaging/macos/osxbuild.sh b/packaging/macos/osxbuild.sh
index 66f1e3b68f..9c9b1efdcc 100755
--- a/packaging/macos/osxbuild.sh
+++ b/packaging/macos/osxbuild.sh
@@ -1,536 +1,537 @@
 #!/usr/bin/env bash
 
 # osxbuild.sh automates building and installing of krita and krita dependencies
 # for OSX, the script only needs you to set BUILDROOT environment to work
 # properly.
 #
 
 # Run with no args for a short help about each command.
 
 # builddeps: Attempts to build krita dependencies in the necessary order,
 #     intermediate steps for creating symlinks and fixing rpath of some
 #     packages midway is also managed. Order goes from top to bottom, to add
 #     new steps just place them in the proper place.
 
 # rebuilddeps: This re-runs all make and make install of dependencies 3rdparty
 #     this was needed as deleting the entire install directory an rerunning build
 #     step for dependencies does not install if they are already built. This step
 #     forces installation. Have not tested it lately so it might not be needed anymore
 
 # build: Runs cmake build and make step for krita sources. It always run cmake step, so
 #     it might take a bit longer than a pure <make> on the source tree. The script tries
 #     to set the make flag -jN to a proper N.
 
 # install: Runs install step for krita sources.
 
 # fixboost: Search for all libraries using boost and sets a proper @rpath for boost as by
 #     default it fails to set a proper @rpath
 
 # buildinstall: Runs build, install and fixboost steps.#
 
 if test -z $BUILDROOT; then
     echo "ERROR: BUILDROOT env not set, exiting!"
     echo "\t Must point to the root of the buildfiles as stated in 3rdparty Readme"
     exit
 fi
 echo "BUILDROOT set to ${BUILDROOT}"
 
 export KIS_SRC_DIR=${BUILDROOT}/krita
 export KIS_TBUILD_DIR=${BUILDROOT}/depbuild
 export KIS_TDEPINSTALL_DIR=${BUILDROOT}/depinstall
 export KIS_DOWN_DIR=${BUILDROOT}/down
 export KIS_BUILD_DIR=${BUILDROOT}/kisbuild
 export KIS_INSTALL_DIR=${BUILDROOT}/i
 
 # flags for OSX environment
 # Qt only supports from 10.12 up, and https://doc.qt.io/qt-5/macos.html#target-platforms warns against setting it lower
 export MACOSX_DEPLOYMENT_TARGET=10.12
 export QMAKE_MACOSX_DEPLOYMENT_TARGET=10.12
 
 # Build time variables
 if test -z $(which cmake); then
     echo "ERROR: cmake not found, exiting!"
     exit
 fi
 
 export PATH=${KIS_INSTALL_DIR}/bin:$PATH
 export C_INCLUDE_PATH=${KIS_INSTALL_DIR}/include:/usr/include:${C_INCLUDE_PATH}
 export CPLUS_INCLUDE_PATH=${KIS_INSTALL_DIR}/include:/usr/include:${CPLUS_INCLUDE_PATH}
 export LIBRARY_PATH=${KIS_INSTALL_DIR}/lib:/usr/lib:${LIBRARY_PATH}
 # export CPPFLAGS=-I${KIS_INSTALL_DIR}/include
 # export LDFLAGS=-L${KIS_INSTALL_DIR}/lib
 export FRAMEWORK_PATH=${KIS_INSTALL_DIR}/lib/
 
 # export PYTHONHOME=${KIS_INSTALL_DIR}
 # export PYTHONPATH=${KIS_INSTALL_DIR}/sip:${KIS_INSTALL_DIR}/lib/python3.8/site-packages:${KIS_INSTALL_DIR}/lib/python3.8
 
 # This will make the debug output prettier
 export KDE_COLOR_DEBUG=1
 export QTEST_COLORED=1
 
 export OUPUT_LOG="${BUILDROOT}/osxbuild.log"
 export ERROR_LOG="${BUILDROOT}/osxbuild-error.log"
 printf "" > "${OUPUT_LOG}"
 printf "" > "${ERROR_LOG}"
 
 # configure max core for make compile
 ((MAKE_THREADS=1))
 if test ${OSTYPE} == "darwin*"; then
-    ((MAKE_THREADS = $(sysctl -n hw.ncpu) - 1))
+    ((MAKE_THREADS = $(sysctl -n hw.logicalcpu)))
 fi
 
 # Prints stderr and stdout to log files
 # >(tee) works but breaks sigint
 log_cmd () {
     if [[ "${VERBOSE}" ]]; then
         "$@" 1>> ${OUPUT_LOG} 2>> ${ERROR_LOG}
     else
         "$@" 2>> ${ERROR_LOG} | tee -a ${OUPUT_LOG} > /dev/null
     fi
 }
 
 # Log messages to logfile
 log () {
     if [[ "${VERBOSE}" ]]; then
         printf "%s\n" "${@}"  | tee -a ${OUPUT_LOG}
     else
         printf "%s\n" "${@}" | tee -a ${OUPUT_LOG} > /dev/null
     fi
 }
 
 # if previous command gives error
 # print msg
 print_if_error() {
     error_stat="${?}"
     if [ ${error_stat} -ne 0 ]; then
         printf "\e[31m%s %s\e[0m\n" "Error:" "${1}" 2>> ${ERROR_LOG}
         printf "%s\r" "${error_stat}"
     fi
 }
 
 # print status messages
 print_msg() {
     printf "\e[32m%s\e[0m\n" "${1}"
     printf "%s\n" "${1}" >> ${OUPUT_LOG}
 }
 
 check_dir_path () {
     printf "%s" "Checking if ${1} exists and is dir... "
     if test -d ${1}; then
         echo -e "OK"
 
     elif test -e ${1}; then
         echo -e "\n\tERROR: file ${1} exists but is not a directory!" >&2
         return 1
     else
         echo -e "Creating ${1}"
         mkdir ${1}
     fi
     return 0
 }
 # builds dependencies for the first time
 cmake_3rdparty () {
     cd ${KIS_TBUILD_DIR}
 
     local build_pkgs=("${@}") # convert to array
 
     if [[ ${2} = "1" ]]; then
         local nofix="true"
         local build_pkgs=(${build_pkgs[@]:0:1})
     fi
 
     for package in ${build_pkgs[@]} ; do
         print_msg "Building ${package}"
         log_cmd cmake --build . --config RelWithDebInfo --target ${package}
         if [[ ! $(print_if_error "Failed build ${package}") ]]; then
             print_msg "Build Success! ${package}"
         fi
         # fixes does not depend on failure
         if [[ ! ${nofix} ]]; then
             build_3rdparty_fixes ${package}
         fi
     done
 }
 
 build_3rdparty_fixes(){
     pkg=${1}
     if [[ "${pkg}" = "ext_qt" && -e "${KIS_INSTALL_DIR}/bin/qmake" ]]; then
         ln -sf qmake "${KIS_INSTALL_DIR}/bin/qmake-qt5"
 
     elif [[ "${pkg}" = "ext_openexr" ]]; then
         # open exr will fail the first time is called
         # rpath needs to be fixed an build rerun
         log "Fixing rpath on openexr file: b44ExpLogTable"
         log "Fixing rpath on openexr file: dwaLookups"
         log_cmd install_name_tool -add_rpath ${KIS_INSTALL_DIR}/lib $(find ${KIS_TBUILD_DIR}/ext_openexr/ext_openexr-prefix/src/ext_openexr-build -name b44ExpLogTable)
         log_cmd install_name_tool -add_rpath ${KIS_INSTALL_DIR}/lib $(find ${KIS_TBUILD_DIR}/ext_openexr/ext_openexr-prefix/src/ext_openexr-build -name dwaLookups)
         # we must rerun build!
         cmake_3rdparty ext_openexr "1"
 
     elif [[ "${pkg}" = "ext_fontconfig" ]]; then
         log "fixing rpath on fc-cache"
         log_cmd install_name_tool -add_rpath ${KIS_INSTALL_DIR}/lib ${KIS_TBUILD_DIR}/ext_fontconfig/ext_fontconfig-prefix/src/ext_fontconfig-build/fc-cache/.libs/fc-cache
         # rerun rebuild
         cmake_3rdparty ext_fontconfig "1"
     fi
 }
 
 build_3rdparty () {
     print_msg "building in ${KIS_TBUILD_DIR}"
 
     log "$(check_dir_path ${KIS_TBUILD_DIR})"
     log "$(check_dir_path ${KIS_DOWN_DIR})"
     log "$(check_dir_path ${KIS_INSTALL_DIR})"
 
     cd ${KIS_TBUILD_DIR}
 
     log_cmd cmake ${KIS_SRC_DIR}/3rdparty/ \
         -DCMAKE_OSX_DEPLOYMENT_TARGET=10.12 \
         -DCMAKE_INSTALL_PREFIX=${KIS_INSTALL_DIR} \
         -DEXTERNALS_DOWNLOAD_DIR=${KIS_DOWN_DIR} \
         -DINSTALL_ROOT=${KIS_INSTALL_DIR}
 
         # -DCPPFLAGS=-I${KIS_INSTALL_DIR}/include \
         # -DLDFLAGS=-L${KIS_INSTALL_DIR}/lib
 
     print_msg "finished 3rdparty build setup"
     
     if [[ -n ${1} ]]; then
         cmake_3rdparty "${@}"
         exit
     fi
 
     # build 3rdparty tools
     # The order must not be changed!
     cmake_3rdparty \
         ext_pkgconfig \
         ext_gettext \
         ext_openssl \
         ext_qt \
         ext_zlib \
         ext_boost \
         ext_eigen3 \
         ext_exiv2 \
         ext_fftw3 \
         ext_ilmbase \
         ext_jpeg \
         ext_lcms2 \
         ext_ocio \
         ext_openexr
 
     cmake_3rdparty \
         ext_png \
         ext_tiff \
         ext_gsl \
         ext_vc \
         ext_libraw \
         ext_giflib \
         ext_freetype \
         ext_fontconfig \
         ext_poppler
 
     # Stop if qmake link was not created
     # this meant qt build fail and further builds will
     # also fail.
     log_cmd test -L "${KIS_INSTALL_DIR}/bin/qmake-qt5"
     if [[ $(print_if_error "qmake link missing!") ]]; then
         printf "
     link: ${KIS_INSTALL_DIR}/bin/qmake-qt5 missing!
     It probably means ext_qt failed!!
     check, fix and rerun!\n"
         exit
     fi
 
     # for python
     cmake_3rdparty \
         ext_python \
         ext_sip \
         ext_pyqt
 
     cmake_3rdparty ext_libheif
 
     cmake_3rdparty \
         ext_extra_cmake_modules \
         ext_kconfig \
         ext_kwidgetsaddons \
         ext_kcompletion \
         ext_kcoreaddons \
         ext_kguiaddons \
         ext_ki18n \
         ext_kitemmodels \
         ext_kitemviews \
         ext_kimageformats \
         ext_kwindowsystem \
         ext_quazip
 }
 
 # Recall cmake for all 3rd party packages
 # make is only on target first run
 # subsequent runs only call make install
 rebuild_3rdparty () {
     print_msg "starting rebuild of 3rdparty packages"
     build_install_ext() {
         for pkg in ${@:1:${#@}}; do
             {
                 cd ${KIS_TBUILD_DIR}/${pkg}/${pkg}-prefix/src/${pkg}-stamp
             } || {
                 cd ${KIS_TBUILD_DIR}/ext_frameworks/${pkg}-prefix/src/${pkg}-stamp
             } || {
                 cd ${KIS_TBUILD_DIR}/ext_heif/${pkg}-prefix/src/${pkg}-stamp
             }
             log "Installing ${pkg} files..."
             rm ${pkg}-configure ${pkg}-build ${pkg}-install
 
             cmake_3rdparty ${pkg}
 
             cd ${KIS_TBUILD_DIR}
         done
     }
     # Do not process complete list only pkgs given.
     if ! test -z ${1}; then
         build_install_ext ${@}
         exit
     fi
 
     build_install_ext \
         ext_pkgconfig \
         ext_iconv \
         ext_gettext \
         ext_openssl \
         ext_qt \
         ext_zlib \
         ext_boost \
         ext_eigen3 \
         ext_expat \
         ext_exiv2 \
         ext_fftw3 \
         ext_ilmbase \
         ext_jpeg \
         ext_patch \
         ext_lcms2 \
         ext_ocio \
         ext_ilmbase \
         ext_openexr \
         ext_png \
         ext_tiff \
         ext_gsl \
         ext_vc \
         ext_libraw \
         ext_giflib \
         ext_fontconfig \
         ext_freetype \
         ext_poppler \
         ext_python \
         ext_sip \
         ext_pyqt \
 
     build_install_ext \
         ext_yasm \
         ext_nasm \
         ext_libx265 \
         ext_libde265 \
         ext_libheif \
 
     # Build kde_frameworks
     build_install_ext \
         ext_extra_cmake_modules \
         ext_kconfig \
         ext_kwidgetsaddons \
         ext_kcompletion \
         ext_kcoreaddons \
         ext_kguiaddons \
         ext_ki18n \
         ext_kitemmodels \
         ext_kitemviews \
         ext_kimageformats \
         ext_kwindowsystem \
-        ext_quazip
+        ext_quazip \
+        ext_openjpeg
 }
 
 #not tested
 set_krita_dirs() {
     if [[ -n ${1} ]]; then
         KIS_BUILD_DIR=${BUILDROOT}/b_${1}
         KIS_INSTALL_DIR=${BUILDROOT}/i_${1}
         KIS_SRC_DIR=${BUILDROOT}/src_${1}
     fi
 }
 # build_krita
 # run cmake krita
 build_krita () {
     export DYLD_FRAMEWORK_PATH=${FRAMEWORK_PATH}
     echo ${KIS_BUILD_DIR}
     echo ${KIS_INSTALL_DIR}
     log_cmd check_dir_path ${KIS_BUILD_DIR}
     cd ${KIS_BUILD_DIR}
 
     cmake ${KIS_SRC_DIR} \
         -DFOUNDATION_BUILD=ON \
         -DBoost_INCLUDE_DIR=${KIS_INSTALL_DIR}/include \
         -DCMAKE_INSTALL_PREFIX=${KIS_INSTALL_DIR} \
         -DDEFINE_NO_DEPRECATED=1 \
         -DBUILD_TESTING=OFF \
         -DHIDE_SAFE_ASSERTS=ON \
         -DKDE_INSTALL_BUNDLEDIR=${KIS_INSTALL_DIR}/bin \
         -DPYQT_SIP_DIR_OVERRIDE=${KIS_INSTALL_DIR}/share/sip/ \
         -DCMAKE_BUILD_TYPE=RelWithDebInfo \
         -DCMAKE_OSX_DEPLOYMENT_TARGET=10.12 \
         -DPYTHON_INCLUDE_DIR=${KIS_INSTALL_DIR}/lib/Python.framework/Headers
 
     # copiling phase
     make -j${MAKE_THREADS}
 
     # compile integrations
     if test ${OSTYPE} == "darwin*"; then
         cd ${KIS_BUILD_DIR}/krita/integration/kritaquicklook
         make -j${MAKE_THREADS}
     fi
 }
 
 build_krita_tarball () {
     filename="$(basename ${1})"
     KIS_CUSTOM_BUILD="${BUILDROOT}/releases/${filename%.tar.gz}"
     print_msg "Tarball BUILDROOT is ${KIS_CUSTOM_BUILD}"
 
     filename_dir=$(dirname "${1}")
     cd "${filename_dir}"
     file_abspath="$(pwd)/${1##*/}"
 
     mkdir "${KIS_CUSTOM_BUILD}" 2> /dev/null
     cd "${KIS_CUSTOM_BUILD}"
 
     mkdir "src" "build" 2> /dev/null
     tar -xzf "${file_abspath}" --strip-components=1 --directory "src"
     if [[ $(print_if_error "Untar ${file_abspath} failed!") ]]; then
         exit
     fi
 
     KIS_BUILD_DIR="${KIS_CUSTOM_BUILD}/build"
     KIS_SRC_DIR="${KIS_CUSTOM_BUILD}/src"
 
     build_krita
 
     print_msg "Build done!"
     print_msg "to install run
 osxbuild.sh install ${KIS_BUILD_DIR}"
 
 }
 
 install_krita () {
     # custom install provided
     if [[ -n "${1}" ]]; then
         KIS_BUILD_DIR="${1}"
     fi
     print_msg "Install krita from ${KIS_BUILD_DIR}"
     log_cmd check_dir_path ${KIS_BUILD_DIR}
 
     cd ${KIS_BUILD_DIR}
     if [[ $(print_if_error "could not cd to ${KIS_BUILD_DIR}") ]]; then
         exit
     fi
 
     make install
 
     # compile integrations
     if test ${OSTYPE} == "darwin*"; then
         cd ${KIS_BUILD_DIR}/krita/integration/kritaquicklook
         make install
     fi
 }
 
 # Runs all fixes for path and packages.
 # Historically only fixed boost @rpath
 fix_boost_rpath () {
     # helpers to define function only once
     fixboost_find () {
         for FILE in "${@}"; do
             if [[ -n "$(otool -L $FILE | grep boost)" ]]; then
                 log "Fixing -- $FILE"
                 log_cmd install_name_tool -change libboost_system.dylib @rpath/libboost_system.dylib $FILE
             fi
         done
     }
 
     batch_fixboost() {
         xargs -P4 -I FILE bash -c 'fixboost_find "FILE"'
     }
 
     export -f fixboost_find
     export -f log
     export -f log_cmd
 
     print_msg "Fixing boost in... ${KIS_INSTALL_DIR}"
     # install_name_tool -add_rpath ${KIS_INSTALL_DIR}/lib $BUILDROOT/$KRITA_INSTALL/bin/krita.app/Contents/MacOS/gmic_krita_qt
     log_cmd install_name_tool -add_rpath ${KIS_INSTALL_DIR}/lib ${KIS_INSTALL_DIR}/bin/krita.app/Contents/MacOS/krita
     # echo "Added rpath ${KIS_INSTALL_DIR}/lib to krita bin"
     # install_name_tool -add_rpath ${BUILDROOT}/deps/lib ${KIS_INSTALL_DIR}/bin/krita.app/Contents/MacOS/krita
     log_cmd install_name_tool -change libboost_system.dylib @rpath/libboost_system.dylib ${KIS_INSTALL_DIR}/bin/krita.app/Contents/MacOS/krita
 
     find -L "${KIS_INSTALL_DIR}" -name '*so' -o -name '*dylib' | batch_fixboost
 
     log "Fixing boost done!"
 }
 
 print_usage () {
     printf "USAGE: osxbuild.sh <buildstep> [pkg|file]\n"
     printf "BUILDSTEPS:\t\t"
     printf "\n builddeps \t\t Run cmake step for 3rd party dependencies, optionally takes a [pkg] arg"
     printf "\n rebuilddeps \t\t Rerun make and make install step for 3rd party deps, optionally takes a [pkg] arg
     \t\t\t useful for cleaning install directory and quickly reinstall all deps."
     printf "\n fixboost \t\t Fixes broken boost \@rpath on OSX"
     printf "\n build \t\t\t Builds krita"
     printf "\n buildtarball \t\t\t Builds krita from provided [file] tarball"
     printf "\n install \t\t Installs krita. Optionally accepts a [build dir] as argument
     \t\t\t this will install krita from given directory"
     printf "\n buildinstall \t\t Build and Installs krita, running fixboost after installing"
     printf "\n"
 }
 
 if [[ ${#} -eq 0 ]]; then
     echo "ERROR: No option given!"
     print_usage
     exit 1
 fi
 
 if [[ ${1} = "builddeps" ]]; then
     build_3rdparty "${@:2}"
 
 elif [[ ${1} = "rebuilddeps" ]]; then
     rebuild_3rdparty "${@:2}"
 
 elif [[ ${1} = "fixboost" ]]; then
     if [[ -d ${1} ]]; then
         KIS_BUILD_DIR="${1}"
     fi
     fix_boost_rpath
 
 elif [[ ${1} = "build" ]]; then
     build_krita ${2}
 
 elif [[ ${1} = "buildtarball" ]]; then
     # uncomment line to optionally change
     # install directory providing a third argument
     # This is not on by default as build success requires all
     # deps installed in the given dir beforehand.
     # KIS_INSTALL_DIR=${3}
     build_krita_tarball ${2}
 
 elif [[ ${1} = "install" ]]; then
     install_krita ${2}
     fix_boost_rpath
 
 elif [[ ${1} = "buildinstall" ]]; then
     build_krita ${2}
     install_krita ${2}
     fix_boost_rpath ${2}
 
 elif [[ ${1} = "test" ]]; then
     ${KIS_INSTALL_DIR}/bin/krita.app/Contents/MacOS/krita
 
 else
     echo "Option ${1} not supported"
     print_usage
     exit 1
 fi
 
 # after finishig sometimes it complains about missing matching quotes.
diff --git a/plugins/color/lcms2engine/colorspaces/lab_f32/LabF32ColorSpace.cpp b/plugins/color/lcms2engine/colorspaces/lab_f32/LabF32ColorSpace.cpp
index a11749a3d0..78f3a54d25 100644
--- a/plugins/color/lcms2engine/colorspaces/lab_f32/LabF32ColorSpace.cpp
+++ b/plugins/color/lcms2engine/colorspaces/lab_f32/LabF32ColorSpace.cpp
@@ -1,118 +1,206 @@
 /*
  *  Copyright (c) 2006 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2020 L. E. Segovia <amy@amyspark.me>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #include "LabF32ColorSpace.h"
 
 #include <QDomElement>
 
 #include <klocalizedstring.h>
 
 #include "../compositeops/KoCompositeOps.h"
 #include <KoColorConversions.h>
 #include <kis_dom_utils.h>
 
 LabF32ColorSpace::LabF32ColorSpace(const QString &name, KoColorProfile *p)
     : LcmsColorSpace<KoLabF32Traits>(colorSpaceId(), name, TYPE_LabA_FLT, cmsSigLabData, p)
 {
     const IccColorProfile *icc_p = dynamic_cast<const IccColorProfile *>(p);
     Q_ASSERT(icc_p);
     QVector<KoChannelInfo::DoubleRange> uiRanges(icc_p->getFloatUIMinMax());
     Q_ASSERT(uiRanges.size() == 3);
 
     addChannel(new KoChannelInfo(i18n("Lightness"), 0 * sizeof(float), 0, KoChannelInfo::COLOR, KoChannelInfo::FLOAT32, sizeof(float), QColor(100, 100, 100), uiRanges[0]));
     addChannel(new KoChannelInfo(i18n("a*"),        1 * sizeof(float), 1, KoChannelInfo::COLOR, KoChannelInfo::FLOAT32, sizeof(float), QColor(150, 150, 150), uiRanges[1]));
     addChannel(new KoChannelInfo(i18n("b*"),        2 * sizeof(float), 2, KoChannelInfo::COLOR, KoChannelInfo::FLOAT32, sizeof(float), QColor(200, 200, 200), uiRanges[2]));
     addChannel(new KoChannelInfo(i18n("Alpha"),     3 * sizeof(float), 3, KoChannelInfo::ALPHA, KoChannelInfo::FLOAT32, sizeof(float)));
 
     init();
 
     addStandardCompositeOps<KoLabF32Traits>(this);
 
     dbgPlugins << "La*b* (float) channel bounds for: " << icc_p->name();
     dbgPlugins << "L: " << uiRanges[0].minVal << uiRanges[0].maxVal;
     dbgPlugins << "a: " << uiRanges[1].minVal << uiRanges[1].maxVal;
     dbgPlugins << "b: " << uiRanges[2].minVal << uiRanges[2].maxVal;
 }
 
 bool LabF32ColorSpace::willDegrade(ColorSpaceIndependence independence) const
 {
     if (independence == TO_RGBA16) {
         return true;
     } else {
         return false;
     }
 }
 
 KoColorSpace *LabF32ColorSpace::clone() const
 {
     return new LabF32ColorSpace(name(), profile()->clone());
 }
 
 void LabF32ColorSpace::colorToXML(const quint8 *pixel, QDomDocument &doc, QDomElement &colorElt) const
 {
     const KoLabF32Traits::Pixel *p = reinterpret_cast<const KoLabF32Traits::Pixel *>(pixel);
     QDomElement labElt = doc.createElement("Lab");
 
     // XML expects 0-1, we need 0-100, -128-+127
     // Get the bounds from the channels and adjust the calculations
     labElt.setAttribute("L", KisDomUtils::toString(KoColorSpaceMaths< KoLabF32Traits::channels_type, qreal>::scaleToA(1.f / this->channels()[0]->getUIUnitValue() * (p->L - this->channels()[0]->getUIMin()))));
     labElt.setAttribute("a", KisDomUtils::toString(KoColorSpaceMaths< KoLabF32Traits::channels_type, qreal>::scaleToA(1.f / this->channels()[1]->getUIUnitValue() * (p->a - this->channels()[1]->getUIMin()))));
     labElt.setAttribute("b", KisDomUtils::toString(KoColorSpaceMaths< KoLabF32Traits::channels_type, qreal>::scaleToA(1.f / this->channels()[2]->getUIUnitValue() * (p->b - this->channels()[2]->getUIMin()))));
     labElt.setAttribute("space", profile()->name());
     colorElt.appendChild(labElt);
 }
 
 void LabF32ColorSpace::colorFromXML(quint8 *pixel, const QDomElement &elt) const
 {
     KoLabF32Traits::Pixel *p = reinterpret_cast<KoLabF32Traits::Pixel *>(pixel);
     p->L = this->channels()[0]->getUIMin() + KoColorSpaceMaths< qreal, KoLabF32Traits::channels_type >::scaleToA(KisDomUtils::toDouble(elt.attribute("L"))) * this->channels()[0]->getUIUnitValue();
     p->a = this->channels()[1]->getUIMin() + KoColorSpaceMaths< qreal, KoLabF32Traits::channels_type >::scaleToA(KisDomUtils::toDouble(elt.attribute("a"))) * this->channels()[1]->getUIUnitValue();
     p->b = this->channels()[2]->getUIMin() + KoColorSpaceMaths< qreal, KoLabF32Traits::channels_type >::scaleToA(KisDomUtils::toDouble(elt.attribute("b"))) * this->channels()[2]->getUIUnitValue();
     p->alpha = 1.0;
 }
 
 void LabF32ColorSpace::toHSY(const QVector<double> &channelValues, qreal *hue, qreal *sat, qreal *luma) const
 {
     LabToLCH(channelValues[0],channelValues[1],channelValues[2], luma, sat, hue);
 }
 
 QVector <double> LabF32ColorSpace::fromHSY(qreal *hue, qreal *sat, qreal *luma) const
 {
     QVector <double> channelValues(4);
     LCHToLab(*luma, *sat, *hue, &channelValues[0],&channelValues[1],&channelValues[2]);
     channelValues[3]=1.0;
     return channelValues;
 }
 void LabF32ColorSpace::toYUV(const QVector<double> &channelValues, qreal *y, qreal *u, qreal *v) const
 {
     *y =channelValues[0];
     *u=channelValues[1];
     *v=channelValues[2];
 }
 
 QVector <double> LabF32ColorSpace::fromYUV(qreal *y, qreal *u, qreal *v) const
 {
     QVector <double> channelValues(4);
     channelValues[0]=*y;
     channelValues[1]=*u;
     channelValues[2]=*v;
     channelValues[3]=1.0;
     return channelValues;
 }
+
+quint8 LabF32ColorSpace::scaleToU8(const quint8 *srcPixel, qint32 channelIndex) const
+{
+    typename ColorSpaceTraits::channels_type c = ColorSpaceTraits::nativeArray(srcPixel)[channelIndex];
+    qreal b = 0;
+    switch (channelIndex) {
+    case ColorSpaceTraits::L_pos:
+        b = ((qreal)c) / ColorSpaceTraits::math_trait::unitValueL;
+        break;
+    case ColorSpaceTraits::a_pos:
+    case ColorSpaceTraits::b_pos:
+        if (c <= ColorSpaceTraits::math_trait::halfValueAB) {
+            b = ((qreal)c - ColorSpaceTraits::math_trait::zeroValueAB) / (2.0 * (ColorSpaceTraits::math_trait::halfValueAB - ColorSpaceTraits::math_trait::zeroValueAB));
+        } else {
+            b = 0.5 + ((qreal)c - ColorSpaceTraits::math_trait::halfValueAB) / (2.0 * (ColorSpaceTraits::math_trait::unitValueAB - ColorSpaceTraits::math_trait::halfValueAB));
+        }
+        break;
+    default:
+        b = ((qreal)c) / ColorSpaceTraits::math_trait::unitValue;
+        break;
+    }
+
+    return KoColorSpaceMaths<qreal, quint8>::scaleToA(b);
+}
+
+void LabF32ColorSpace::convertChannelToVisualRepresentation(const quint8 *src, quint8 *dst, quint32 nPixels, const qint32 selectedChannelIndex) const
+{
+    for (uint pixelIndex = 0; pixelIndex < nPixels; ++pixelIndex) {
+        for (uint channelIndex = 0; channelIndex < this->channelCount(); ++channelIndex) {
+            KoChannelInfo *channel = this->channels().at(channelIndex);
+            qint32 channelSize = channel->size();
+            if (channel->channelType() == KoChannelInfo::COLOR) {
+                if (channelIndex == ColorSpaceTraits::L_pos) {
+                    ColorSpaceTraits::channels_type c = ColorSpaceTraits::parent::nativeArray((src + (pixelIndex * ColorSpaceTraits::pixelSize)))[selectedChannelIndex];
+                    switch (selectedChannelIndex) {
+                    case ColorSpaceTraits::L_pos:
+                        break;
+                    case ColorSpaceTraits::a_pos:
+                    case ColorSpaceTraits::b_pos:
+                        if (c <= ColorSpaceTraits::math_trait::halfValueAB) {
+                            c = ColorSpaceTraits::math_trait::unitValueL * (((qreal)c - ColorSpaceTraits::math_trait::zeroValueAB) / (2.0 * (ColorSpaceTraits::math_trait::halfValueAB - ColorSpaceTraits::math_trait::zeroValueAB)));
+                        } else {
+                            c = ColorSpaceTraits::math_trait::unitValueL * (0.5 + ((qreal)c - ColorSpaceTraits::math_trait::halfValueAB) / (2.0 * (ColorSpaceTraits::math_trait::unitValueAB - ColorSpaceTraits::math_trait::halfValueAB)));
+                        }
+                        break;
+                    // As per KoChannelInfo alpha channels are [0..1]
+                    default:
+                        c = ColorSpaceTraits::math_trait::unitValueL * (qreal)c / ColorSpaceTraits::math_trait::unitValue;
+                        break;
+                    }
+                    ColorSpaceTraits::parent::nativeArray(dst + (pixelIndex * ColorSpaceTraits::pixelSize))[channelIndex] = c;
+                } else {
+                    ColorSpaceTraits::parent::nativeArray(dst + (pixelIndex * ColorSpaceTraits::pixelSize))[channelIndex] = ColorSpaceTraits::math_trait::halfValueAB;
+                }
+            } else if (channel->channelType() == KoChannelInfo::ALPHA) {
+                memcpy(dst + (pixelIndex * ColorSpaceTraits::pixelSize) + (channelIndex * channelSize), src + (pixelIndex * ColorSpaceTraits::pixelSize) + (channelIndex * channelSize), channelSize);
+            }
+        }
+    }
+}
+
+void LabF32ColorSpace::convertChannelToVisualRepresentation(const quint8 *src, quint8 *dst, quint32 nPixels, const QBitArray selectedChannels) const
+{
+    for (uint pixelIndex = 0; pixelIndex < nPixels; ++pixelIndex) {
+        for (uint channelIndex = 0; channelIndex < this->channelCount(); ++channelIndex) {
+            KoChannelInfo *channel = this->channels().at(channelIndex);
+            qint32 channelSize = channel->size();
+            if (selectedChannels.testBit(channelIndex)) {
+                memcpy(dst + (pixelIndex * ColorSpaceTraits::pixelSize) + (channelIndex * channelSize), src + (pixelIndex * ColorSpaceTraits::pixelSize) + (channelIndex * channelSize), channelSize);
+            } else {
+                ColorSpaceTraits::channels_type v;
+                switch (channelIndex) {
+                case ColorSpaceTraits::L_pos:
+                    v = ColorSpaceTraits::math_trait::halfValueL;
+                    break;
+                case ColorSpaceTraits::a_pos:
+                case ColorSpaceTraits::b_pos:
+                    v = ColorSpaceTraits::math_trait::halfValueAB;
+                    break;
+                default:
+                    v = ColorSpaceTraits::math_trait::zeroValue;
+                    break;
+                }
+                reinterpret_cast<ColorSpaceTraits::channels_type *>(dst + (pixelIndex * ColorSpaceTraits::pixelSize) + (channelIndex * channelSize))[0] = v;
+            }
+        }
+    }
+}
diff --git a/plugins/color/lcms2engine/colorspaces/lab_f32/LabF32ColorSpace.h b/plugins/color/lcms2engine/colorspaces/lab_f32/LabF32ColorSpace.h
index aa62bb726b..c9e422d31a 100644
--- a/plugins/color/lcms2engine/colorspaces/lab_f32/LabF32ColorSpace.h
+++ b/plugins/color/lcms2engine/colorspaces/lab_f32/LabF32ColorSpace.h
@@ -1,122 +1,125 @@
 /*
  *  Copyright (c) 2006 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #ifndef LabF32ColorSpace_H_
 #define LabF32ColorSpace_H_
 
 #include "LcmsColorSpace.h"
 #include "KoColorModelStandardIds.h"
 
 // XXX: implement normalizedChannelValues?
 
 struct KoLabF32Traits;
 
 class LabF32ColorSpace : public LcmsColorSpace<KoLabF32Traits>
 {
 public:
     LabF32ColorSpace(const QString &name, KoColorProfile *p);
 
     bool willDegrade(ColorSpaceIndependence independence) const override;
 
     static QString colorSpaceId()
     {
         return QString("LABAF32");
     }
 
     KoID colorModelId() const override
     {
         return LABAColorModelID;
     }
 
     KoID colorDepthId() const override
     {
         return Float32BitsColorDepthID;
     }
 
     virtual KoColorSpace *clone() const;
 
     void colorToXML(const quint8 *pixel, QDomDocument &doc, QDomElement &colorElt) const override;
 
     void colorFromXML(quint8* pixel, const QDomElement& elt) const override;
     void toHSY(const QVector<double> &channelValues, qreal *hue, qreal *sat, qreal *luma) const override;
     QVector <double> fromHSY(qreal *hue, qreal *sat, qreal *luma) const override;
     void toYUV(const QVector<double> &channelValues, qreal *y, qreal *u, qreal *v) const override;
     QVector <double> fromYUV(qreal *y, qreal *u, qreal *v) const override;
+    quint8 scaleToU8(const quint8 * srcPixel, qint32 channelIndex) const override;
+    void convertChannelToVisualRepresentation(const quint8 *src, quint8 *dst, quint32 nPixels, const qint32 selectedChannelIndex) const override;
+    void convertChannelToVisualRepresentation(const quint8 *src, quint8 *dst, quint32 nPixels, const QBitArray selectedChannels) const override;
 
     bool hasHighDynamicRange() const override
     {
         return true;
     }
 };
 
 class LabF32ColorSpaceFactory : public LcmsColorSpaceFactory
 {
 public:
     LabF32ColorSpaceFactory()
         : LcmsColorSpaceFactory(TYPE_LabA_FLT, cmsSigLabData)
     {
     }
 
     bool userVisible() const override
     {
         return true;
     }
 
     QString id() const override
     {
         return LabF32ColorSpace::colorSpaceId();
     }
 
     QString name() const override
     {
         return QString("%1 (%2)").arg(LABAColorModelID.name()).arg(Float32BitsColorDepthID.name());
     }
 
     KoID colorModelId() const override
     {
         return LABAColorModelID;
     }
 
     KoID colorDepthId() const override
     {
         return Float32BitsColorDepthID;
 
     }
     int referenceDepth() const override
     {
         return 32;
     }
 
     KoColorSpace *createColorSpace(const KoColorProfile *p) const override
     {
         return new LabF32ColorSpace(name(), p->clone());
     }
 
     QString defaultProfile() const override
     {
         return "Lab identity built-in";
     }
 
     bool isHdr() const override
     {
         return true;
     }
 };
 
 #endif
diff --git a/plugins/color/lcms2engine/colorspaces/lab_u16/LabColorSpace.cpp b/plugins/color/lcms2engine/colorspaces/lab_u16/LabColorSpace.cpp
index 84280ce765..99ae8bf600 100644
--- a/plugins/color/lcms2engine/colorspaces/lab_u16/LabColorSpace.cpp
+++ b/plugins/color/lcms2engine/colorspaces/lab_u16/LabColorSpace.cpp
@@ -1,144 +1,232 @@
 /*
  *  Copyright (c) 2006 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #include "LabColorSpace.h"
 
 #include <QDomElement>
 
 #include <klocalizedstring.h>
 
 #include "../compositeops/KoCompositeOps.h"
 #include <KoColorConversions.h>
 #include <kis_dom_utils.h>
 
 LabU16ColorSpace::LabU16ColorSpace(const QString &name, KoColorProfile *p)
     : LcmsColorSpace<KoLabU16Traits>(colorSpaceId(), name, TYPE_LABA_16, cmsSigLabData, p)
 {
     addChannel(new KoChannelInfo(i18n("Lightness"), 0 * sizeof(quint16), 0, KoChannelInfo::COLOR, KoChannelInfo::UINT16, sizeof(quint16), QColor(100, 100, 100)));
     addChannel(new KoChannelInfo(i18n("a*"),        1 * sizeof(quint16), 1, KoChannelInfo::COLOR, KoChannelInfo::UINT16, sizeof(quint16), QColor(150, 150, 150)));
     addChannel(new KoChannelInfo(i18n("b*"),        2 * sizeof(quint16), 2, KoChannelInfo::COLOR, KoChannelInfo::UINT16, sizeof(quint16), QColor(200, 200, 200)));
     addChannel(new KoChannelInfo(i18n("Alpha"),     3 * sizeof(quint16), 3, KoChannelInfo::ALPHA, KoChannelInfo::UINT16, sizeof(quint16)));
 
     init();
 
     addStandardCompositeOps<KoLabU16Traits>(this);
 }
 
 bool LabU16ColorSpace::willDegrade(ColorSpaceIndependence independence) const
 {
     if (independence == TO_RGBA8) {
         return true;
     } else {
         return false;
     }
 }
 
 KoColorSpace *LabU16ColorSpace::clone() const
 {
     return new LabU16ColorSpace(name(), profile()->clone());
 }
 
 void LabU16ColorSpace::colorToXML(const quint8 *pixel, QDomDocument &doc, QDomElement &colorElt) const
 {
     const KoLabU16Traits::Pixel *p = reinterpret_cast<const KoLabU16Traits::Pixel *>(pixel);
     QDomElement labElt = doc.createElement("Lab");
 
     qreal a, b;
 
     if (p->a <= KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::halfValueAB) {
         a = (p->a - KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::zeroValueAB) /
             (2.0 * (KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::halfValueAB - KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::zeroValueAB));
     } else {
         a = 0.5 +
             (p->a - KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::halfValueAB) /
                 (2.0 * (KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::unitValueAB - KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::halfValueAB));
     }
 
     if (p->b <= KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::halfValueAB) {
         b = (p->b - KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::zeroValueAB) /
             (2.0 * (KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::halfValueAB - KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::zeroValueAB));
     } else {
         b = 0.5 +
             (p->b - KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::halfValueAB) /
                 (2.0 * (KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::unitValueAB - KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::halfValueAB));
     }
 
     labElt.setAttribute("L", KisDomUtils::toString(KoColorSpaceMaths<KoLabU16Traits::channels_type, qreal>::scaleToA(p->L)));
     labElt.setAttribute("a", KisDomUtils::toString(a));
     labElt.setAttribute("b", KisDomUtils::toString(b));
     labElt.setAttribute("space", profile()->name());
     colorElt.appendChild(labElt);
 }
 
 void LabU16ColorSpace::colorFromXML(quint8 *pixel, const QDomElement &elt) const
 {
     KoLabU16Traits::Pixel *p = reinterpret_cast<KoLabU16Traits::Pixel *>(pixel);
 
     double a = KisDomUtils::toDouble(elt.attribute("a"));
     double b = KisDomUtils::toDouble(elt.attribute("b"));
 
     p->L = KoColorSpaceMaths<qreal, KoLabU16Traits::channels_type>::scaleToA(KisDomUtils::toDouble(elt.attribute("L")));
 
     if (a <= 0.5) {
         p->a = KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::zeroValueAB +
             2.0 * a * (KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::halfValueAB - KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::zeroValueAB);
     } else {
         p->a = (KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::halfValueAB +
                 2.0 * (a - 0.5) * (KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::unitValueAB - KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::halfValueAB));
     }
 
     if (b <= 0.5) {
         p->b = KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::zeroValueAB +
             2.0 * b * (KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::halfValueAB - KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::zeroValueAB);
     } else {
         p->b = (KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::halfValueAB +
                 2.0 * (b - 0.5) * (KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::unitValueAB - KoLabColorSpaceMathsTraits<KoLabU16Traits::channels_type>::halfValueAB));
     }
 
     p->alpha = KoColorSpaceMathsTraits<quint16>::max;
 }
 void LabU16ColorSpace::toHSY(const QVector<double> &channelValues, qreal *hue, qreal *sat, qreal *luma) const
 {
     LabToLCH(channelValues[0],channelValues[1],channelValues[2], luma, sat, hue);
 }
 
 QVector <double> LabU16ColorSpace::fromHSY(qreal *hue, qreal *sat, qreal *luma) const
 {
     QVector <double> channelValues(4);
     LCHToLab(*luma, *sat, *hue, &channelValues[0],&channelValues[1],&channelValues[2]);
     channelValues[3]=1.0;
     return channelValues;
 }
 
 void LabU16ColorSpace::toYUV(const QVector<double> &channelValues, qreal *y, qreal *u, qreal *v) const
 {
     *y =channelValues[0];
     *u=channelValues[1];
     *v=channelValues[2];
 }
 
 QVector <double> LabU16ColorSpace::fromYUV(qreal *y, qreal *u, qreal *v) const
 {
     QVector <double> channelValues(4);
     channelValues[0]=*y;
     channelValues[1]=*u;
     channelValues[2]=*v;
     channelValues[3]=1.0;
     return channelValues;
 }
+
+quint8 LabU16ColorSpace::scaleToU8(const quint8 *srcPixel, qint32 channelIndex) const
+{
+    typename ColorSpaceTraits::channels_type c = ColorSpaceTraits::nativeArray(srcPixel)[channelIndex];
+    qreal b = 0;
+    switch (channelIndex) {
+    case ColorSpaceTraits::L_pos:
+        b = ((qreal)c) / ColorSpaceTraits::math_trait::unitValueL;
+        break;
+    case ColorSpaceTraits::a_pos:
+    case ColorSpaceTraits::b_pos:
+        if (c <= ColorSpaceTraits::math_trait::halfValueAB) {
+            b = ((qreal)c - ColorSpaceTraits::math_trait::zeroValueAB) / (2.0 * (ColorSpaceTraits::math_trait::halfValueAB - ColorSpaceTraits::math_trait::zeroValueAB));
+        } else {
+            b = 0.5 + ((qreal)c - ColorSpaceTraits::math_trait::halfValueAB) / (2.0 * (ColorSpaceTraits::math_trait::unitValueAB - ColorSpaceTraits::math_trait::halfValueAB));
+        }
+        break;
+    default:
+        b = ((qreal)c) / ColorSpaceTraits::math_trait::unitValue;
+        break;
+    }
+
+    return KoColorSpaceMaths<qreal, quint8>::scaleToA(b);
+}
+
+void LabU16ColorSpace::convertChannelToVisualRepresentation(const quint8 *src, quint8 *dst, quint32 nPixels, const qint32 selectedChannelIndex) const
+{
+    for (uint pixelIndex = 0; pixelIndex < nPixels; ++pixelIndex) {
+        for (uint channelIndex = 0; channelIndex < this->channelCount(); ++channelIndex) {
+            KoChannelInfo *channel = this->channels().at(channelIndex);
+            qint32 channelSize = channel->size();
+            if (channel->channelType() == KoChannelInfo::COLOR) {
+                if (channelIndex == ColorSpaceTraits::L_pos) {
+                    ColorSpaceTraits::channels_type c = ColorSpaceTraits::parent::nativeArray((src + (pixelIndex * ColorSpaceTraits::pixelSize)))[selectedChannelIndex];
+                    switch (selectedChannelIndex) {
+                    case ColorSpaceTraits::L_pos:
+                        break;
+                    case ColorSpaceTraits::a_pos:
+                    case ColorSpaceTraits::b_pos:
+                        if (c <= ColorSpaceTraits::math_trait::halfValueAB) {
+                            c = ColorSpaceTraits::math_trait::unitValueL * (((qreal)c - ColorSpaceTraits::math_trait::zeroValueAB) / (2.0 * (ColorSpaceTraits::math_trait::halfValueAB - ColorSpaceTraits::math_trait::zeroValueAB)));
+                        } else {
+                            c = ColorSpaceTraits::math_trait::unitValueL * (0.5 + ((qreal)c - ColorSpaceTraits::math_trait::halfValueAB) / (2.0 * (ColorSpaceTraits::math_trait::unitValueAB - ColorSpaceTraits::math_trait::halfValueAB)));
+                        }
+                        break;
+                    // As per KoChannelInfo alpha channels are [0..1]
+                    default:
+                        c = ColorSpaceTraits::math_trait::unitValueL * (qreal)c / ColorSpaceTraits::math_trait::unitValue;
+                        break;
+                    }
+                    ColorSpaceTraits::parent::nativeArray(dst + (pixelIndex * ColorSpaceTraits::pixelSize))[channelIndex] = c;
+                } else {
+                    ColorSpaceTraits::parent::nativeArray(dst + (pixelIndex * ColorSpaceTraits::pixelSize))[channelIndex] = ColorSpaceTraits::math_trait::halfValueAB;
+                }
+            } else if (channel->channelType() == KoChannelInfo::ALPHA) {
+                memcpy(dst + (pixelIndex * ColorSpaceTraits::pixelSize) + (channelIndex * channelSize), src + (pixelIndex * ColorSpaceTraits::pixelSize) + (channelIndex * channelSize), channelSize);
+            }
+        }
+    }
+}
+
+void LabU16ColorSpace::convertChannelToVisualRepresentation(const quint8 *src, quint8 *dst, quint32 nPixels, const QBitArray selectedChannels) const
+{
+    for (uint pixelIndex = 0; pixelIndex < nPixels; ++pixelIndex) {
+        for (uint channelIndex = 0; channelIndex < this->channelCount(); ++channelIndex) {
+            KoChannelInfo *channel = this->channels().at(channelIndex);
+            qint32 channelSize = channel->size();
+            if (selectedChannels.testBit(channelIndex)) {
+                memcpy(dst + (pixelIndex * ColorSpaceTraits::pixelSize) + (channelIndex * channelSize), src + (pixelIndex * ColorSpaceTraits::pixelSize) + (channelIndex * channelSize), channelSize);
+            } else {
+                ColorSpaceTraits::channels_type v;
+                switch (channelIndex) {
+                case ColorSpaceTraits::L_pos:
+                    v = ColorSpaceTraits::math_trait::halfValueL;
+                    break;
+                case ColorSpaceTraits::a_pos:
+                case ColorSpaceTraits::b_pos:
+                    v = ColorSpaceTraits::math_trait::halfValueAB;
+                    break;
+                default:
+                    v = ColorSpaceTraits::math_trait::zeroValue;
+                    break;
+                }
+                reinterpret_cast<ColorSpaceTraits::channels_type *>(dst + (pixelIndex * ColorSpaceTraits::pixelSize) + (channelIndex * channelSize))[0] = v;
+            }
+        }
+    }
+}
diff --git a/plugins/color/lcms2engine/colorspaces/lab_u16/LabColorSpace.h b/plugins/color/lcms2engine/colorspaces/lab_u16/LabColorSpace.h
index 7785273a93..bb9fed6ba5 100644
--- a/plugins/color/lcms2engine/colorspaces/lab_u16/LabColorSpace.h
+++ b/plugins/color/lcms2engine/colorspaces/lab_u16/LabColorSpace.h
@@ -1,113 +1,116 @@
 /*
  *  Copyright (c) 2006 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #ifndef LabU16ColorSpace_H_
 #define LabU16ColorSpace_H_
 
 #include "LcmsColorSpace.h"
 #include "KoColorModelStandardIds.h"
 
 #define TYPE_LABA_16 (COLORSPACE_SH(PT_Lab) | CHANNELS_SH(3) | BYTES_SH(2) | EXTRA_SH(1))
 
 struct KoLabF32Traits;
 
 class LabU16ColorSpace : public LcmsColorSpace<KoLabU16Traits>
 {
 public:
 
     LabU16ColorSpace(const QString &name, KoColorProfile *p);
 
     bool willDegrade(ColorSpaceIndependence independence) const override;
 
     static QString colorSpaceId()
     {
         return QString("LABA");
     }
 
     KoID colorModelId() const override
     {
         return LABAColorModelID;
     }
 
     KoID colorDepthId() const override
     {
         return Integer16BitsColorDepthID;
     }
 
     virtual KoColorSpace *clone() const;
 
     void colorToXML(const quint8 *pixel, QDomDocument &doc, QDomElement &colorElt) const override;
 
     void colorFromXML(quint8* pixel, const QDomElement& elt) const override;
     void toHSY(const QVector<double> &channelValues, qreal *hue, qreal *sat, qreal *luma) const override;
     QVector <double> fromHSY(qreal *hue, qreal *sat, qreal *luma) const override;
     void toYUV(const QVector<double> &channelValues, qreal *y, qreal *u, qreal *v) const override;
     QVector <double> fromYUV(qreal *y, qreal *u, qreal *v) const override;
+    quint8 scaleToU8(const quint8 * srcPixel, qint32 channelIndex) const override;
+    void convertChannelToVisualRepresentation(const quint8 *src, quint8 *dst, quint32 nPixels, const qint32 selectedChannelIndex) const override;
+    void convertChannelToVisualRepresentation(const quint8 *src, quint8 *dst, quint32 nPixels, const QBitArray selectedChannels) const override;
 };
 
 class LabU16ColorSpaceFactory : public LcmsColorSpaceFactory
 {
 public:
     LabU16ColorSpaceFactory()
         : LcmsColorSpaceFactory(TYPE_LABA_16, cmsSigLabData)
     {
     }
 
     bool userVisible() const override
     {
         return true;
     }
 
     QString id() const override
     {
         return LabU16ColorSpace::colorSpaceId();
     }
 
     QString name() const override
     {
         return QString("%1 (%2)").arg(LABAColorModelID.name()).arg(Integer16BitsColorDepthID.name());
     }
 
     KoID colorModelId() const override
     {
         return LABAColorModelID;
     }
 
     KoID colorDepthId() const override
     {
         return Integer16BitsColorDepthID;
     }
 
     int referenceDepth() const override
     {
         return 16;
     }
 
     KoColorSpace *createColorSpace(const KoColorProfile *p) const override
     {
         return new LabU16ColorSpace(name(), p->clone());
     }
 
     QString defaultProfile() const override
     {
         return "Lab identity built-in";
     }
 };
 
 #endif
diff --git a/plugins/color/lcms2engine/colorspaces/lab_u8/LabU8ColorSpace.cpp b/plugins/color/lcms2engine/colorspaces/lab_u8/LabU8ColorSpace.cpp
index ae21504f96..1eff58fb4d 100644
--- a/plugins/color/lcms2engine/colorspaces/lab_u8/LabU8ColorSpace.cpp
+++ b/plugins/color/lcms2engine/colorspaces/lab_u8/LabU8ColorSpace.cpp
@@ -1,139 +1,227 @@
 /*
  *  Copyright (c) 2006 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #include "LabU8ColorSpace.h"
 
 #include <QDomElement>
 
 #include <klocalizedstring.h>
 
 #include "../compositeops/KoCompositeOps.h"
 #include <KoColorConversions.h>
 #include <kis_dom_utils.h>
 
 LabU8ColorSpace::LabU8ColorSpace(const QString &name, KoColorProfile *p) :
     LcmsColorSpace<KoLabU8Traits>(colorSpaceId(), name, TYPE_LABA_8, cmsSigLabData, p)
 {
     addChannel(new KoChannelInfo(i18n("Lightness"), 0 * sizeof(quint8), 0, KoChannelInfo::COLOR, KoChannelInfo::UINT8, sizeof(quint8), QColor(100, 100, 100)));
     addChannel(new KoChannelInfo(i18n("a*"),        1 * sizeof(quint8), 1, KoChannelInfo::COLOR, KoChannelInfo::UINT8, sizeof(quint8), QColor(150, 150, 150)));
     addChannel(new KoChannelInfo(i18n("b*"),        2 * sizeof(quint8), 2, KoChannelInfo::COLOR, KoChannelInfo::UINT8, sizeof(quint8), QColor(200, 200, 200)));
     addChannel(new KoChannelInfo(i18n("Alpha"),     3 * sizeof(quint8), 3, KoChannelInfo::ALPHA, KoChannelInfo::UINT8, sizeof(quint8)));
     init();
     addStandardCompositeOps<KoLabU8Traits>(this);
 }
 
 bool LabU8ColorSpace::willDegrade(ColorSpaceIndependence /*independence*/) const
 {
     return false;
 }
 
 KoColorSpace *LabU8ColorSpace::clone() const
 {
     return new LabU8ColorSpace(name(), profile()->clone());
 }
 
 void LabU8ColorSpace::colorToXML(const quint8 *pixel, QDomDocument &doc, QDomElement &colorElt) const
 {
     const KoLabU8Traits::Pixel *p = reinterpret_cast<const KoLabU8Traits::Pixel *>(pixel);
     QDomElement labElt = doc.createElement("Lab");
 
     double a, b;
 
     if (p->a <= KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::halfValueAB) {
         a = (p->a - KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::zeroValueAB) /
             (2.0 * (KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::halfValueAB - KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::zeroValueAB));
     } else {
         a = 0.5 +
             (p->a - KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::halfValueAB) /
                 (2.0 * (KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::unitValueAB - KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::halfValueAB));
     }
 
     if (p->b <= KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::halfValueAB) {
         b = (p->b - KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::zeroValueAB) /
             (2.0 * (KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::halfValueAB - KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::zeroValueAB));
     } else {
         b = 0.5 +
             (p->b - KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::halfValueAB) /
                 (2.0 * (KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::unitValueAB - KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::halfValueAB));
     }
 
     labElt.setAttribute("L", KisDomUtils::toString(KoColorSpaceMaths<KoLabU8Traits::channels_type, qreal>::scaleToA(p->L)));
     labElt.setAttribute("a", KisDomUtils::toString(a));
     labElt.setAttribute("b", KisDomUtils::toString(b));
     labElt.setAttribute("space", profile()->name());
     colorElt.appendChild(labElt);
 }
 
 void LabU8ColorSpace::colorFromXML(quint8 *pixel, const QDomElement &elt) const
 {
     KoLabU8Traits::Pixel *p = reinterpret_cast<KoLabU8Traits::Pixel *>(pixel);
 
     double a = KisDomUtils::toDouble(elt.attribute("a"));
     double b = KisDomUtils::toDouble(elt.attribute("b"));
 
     p->L = KoColorSpaceMaths<qreal, KoLabU8Traits::channels_type>::scaleToA(KisDomUtils::toDouble(elt.attribute("L")));
 
     if (a <= 0.5) {
         p->a =
             KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::zeroValueAB + 2.0 * a * (KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::halfValueAB - KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::zeroValueAB);
     } else {
         p->a = (KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::halfValueAB +
                 2.0 * (a - 0.5) * (KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::unitValueAB - KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::halfValueAB));
     }
 
     if (b <= 0.5) {
         p->b =
             KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::zeroValueAB + 2.0 * b * (KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::halfValueAB - KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::zeroValueAB);
     } else {
         p->b = (KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::halfValueAB +
                 2.0 * (b - 0.5) * (KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::unitValueAB - KoLabColorSpaceMathsTraits<KoLabU8Traits::channels_type>::halfValueAB));
     }
 
     p->alpha = KoColorSpaceMathsTraits<quint8>::max;
 }
 
 void LabU8ColorSpace::toHSY(const QVector<double> &channelValues, qreal *hue, qreal *sat, qreal *luma) const
 {
     LabToLCH(channelValues[0],channelValues[1],channelValues[2], luma, sat, hue);
 }
 
 QVector <double> LabU8ColorSpace::fromHSY(qreal *hue, qreal *sat, qreal *luma) const
 {
     QVector <double> channelValues(4);
     LCHToLab(*luma, *sat, *hue, &channelValues[0],&channelValues[1],&channelValues[2]);
     channelValues[3]=1.0;
     return channelValues;
 }
 
 void LabU8ColorSpace::toYUV(const QVector<double> &channelValues, qreal *y, qreal *u, qreal *v) const
 {
     *y =channelValues[0];
     *u=channelValues[1];
     *v=channelValues[2];
 }
 
 QVector <double> LabU8ColorSpace::fromYUV(qreal *y, qreal *u, qreal *v) const
 {
     QVector <double> channelValues(4);
     channelValues[0]=*y;
     channelValues[1]=*u;
     channelValues[2]=*v;
     channelValues[3]=1.0;
     return channelValues;
 }
+
+quint8 LabU8ColorSpace::scaleToU8(const quint8 *srcPixel, qint32 channelIndex) const
+{
+    typename ColorSpaceTraits::channels_type c = ColorSpaceTraits::nativeArray(srcPixel)[channelIndex];
+    qreal b = 0;
+    switch (channelIndex) {
+    case ColorSpaceTraits::L_pos:
+        b = ((qreal)c) / ColorSpaceTraits::math_trait::unitValueL;
+        break;
+    case ColorSpaceTraits::a_pos:
+    case ColorSpaceTraits::b_pos:
+        if (c <= ColorSpaceTraits::math_trait::halfValueAB) {
+            b = ((qreal)c - ColorSpaceTraits::math_trait::zeroValueAB) / (2.0 * (ColorSpaceTraits::math_trait::halfValueAB - ColorSpaceTraits::math_trait::zeroValueAB));
+        } else {
+            b = 0.5 + ((qreal)c - ColorSpaceTraits::math_trait::halfValueAB) / (2.0 * (ColorSpaceTraits::math_trait::unitValueAB - ColorSpaceTraits::math_trait::halfValueAB));
+        }
+        break;
+    default:
+        b = ((qreal)c) / ColorSpaceTraits::math_trait::unitValue;
+        break;
+    }
+
+    return KoColorSpaceMaths<qreal, quint8>::scaleToA(b);
+}
+
+void LabU8ColorSpace::convertChannelToVisualRepresentation(const quint8 *src, quint8 *dst, quint32 nPixels, const qint32 selectedChannelIndex) const
+{
+    for (uint pixelIndex = 0; pixelIndex < nPixels; ++pixelIndex) {
+        for (uint channelIndex = 0; channelIndex < this->channelCount(); ++channelIndex) {
+            KoChannelInfo *channel = this->channels().at(channelIndex);
+            qint32 channelSize = channel->size();
+            if (channel->channelType() == KoChannelInfo::COLOR) {
+                if (channelIndex == ColorSpaceTraits::L_pos) {
+                    ColorSpaceTraits::channels_type c = ColorSpaceTraits::parent::nativeArray((src + (pixelIndex * ColorSpaceTraits::pixelSize)))[selectedChannelIndex];
+                    switch (selectedChannelIndex) {
+                    case ColorSpaceTraits::L_pos:
+                        break;
+                    case ColorSpaceTraits::a_pos:
+                    case ColorSpaceTraits::b_pos:
+                        if (c <= ColorSpaceTraits::math_trait::halfValueAB) {
+                            c = ColorSpaceTraits::math_trait::unitValueL * (((qreal)c - ColorSpaceTraits::math_trait::zeroValueAB) / (2.0 * (ColorSpaceTraits::math_trait::halfValueAB - ColorSpaceTraits::math_trait::zeroValueAB)));
+                        } else {
+                            c = ColorSpaceTraits::math_trait::unitValueL * (0.5 + ((qreal)c - ColorSpaceTraits::math_trait::halfValueAB) / (2.0 * (ColorSpaceTraits::math_trait::unitValueAB - ColorSpaceTraits::math_trait::halfValueAB)));
+                        }
+                        break;
+                    // As per KoChannelInfo alpha channels are [0..1]
+                    default:
+                        c = ColorSpaceTraits::math_trait::unitValueL * (qreal)c / ColorSpaceTraits::math_trait::unitValue;
+                        break;
+                    }
+                    ColorSpaceTraits::parent::nativeArray(dst + (pixelIndex * ColorSpaceTraits::pixelSize))[channelIndex] = c;
+                } else {
+                    ColorSpaceTraits::parent::nativeArray(dst + (pixelIndex * ColorSpaceTraits::pixelSize))[channelIndex] = ColorSpaceTraits::math_trait::halfValueAB;
+                }
+            } else if (channel->channelType() == KoChannelInfo::ALPHA) {
+                memcpy(dst + (pixelIndex * ColorSpaceTraits::pixelSize) + (channelIndex * channelSize), src + (pixelIndex * ColorSpaceTraits::pixelSize) + (channelIndex * channelSize), channelSize);
+            }
+        }
+    }
+}
+
+void LabU8ColorSpace::convertChannelToVisualRepresentation(const quint8 *src, quint8 *dst, quint32 nPixels, const QBitArray selectedChannels) const
+{
+    for (uint pixelIndex = 0; pixelIndex < nPixels; ++pixelIndex) {
+        for (uint channelIndex = 0; channelIndex < this->channelCount(); ++channelIndex) {
+            KoChannelInfo *channel = this->channels().at(channelIndex);
+            qint32 channelSize = channel->size();
+            if (selectedChannels.testBit(channelIndex)) {
+                memcpy(dst + (pixelIndex * ColorSpaceTraits::pixelSize) + (channelIndex * channelSize), src + (pixelIndex * ColorSpaceTraits::pixelSize) + (channelIndex * channelSize), channelSize);
+            } else {
+                ColorSpaceTraits::channels_type v;
+                switch (channelIndex) {
+                case ColorSpaceTraits::L_pos:
+                    v = ColorSpaceTraits::math_trait::halfValueL;
+                    break;
+                case ColorSpaceTraits::a_pos:
+                case ColorSpaceTraits::b_pos:
+                    v = ColorSpaceTraits::math_trait::halfValueAB;
+                    break;
+                default:
+                    v = ColorSpaceTraits::math_trait::zeroValue;
+                    break;
+                }
+                reinterpret_cast<ColorSpaceTraits::channels_type *>(dst + (pixelIndex * ColorSpaceTraits::pixelSize) + (channelIndex * channelSize))[0] = v;
+            }
+        }
+    }
+}
diff --git a/plugins/color/lcms2engine/colorspaces/lab_u8/LabU8ColorSpace.h b/plugins/color/lcms2engine/colorspaces/lab_u8/LabU8ColorSpace.h
index 5a7e98b1f6..fe2b62f62e 100644
--- a/plugins/color/lcms2engine/colorspaces/lab_u8/LabU8ColorSpace.h
+++ b/plugins/color/lcms2engine/colorspaces/lab_u8/LabU8ColorSpace.h
@@ -1,106 +1,109 @@
 /*
  *  Copyright (c) 2006 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #ifndef LabU8ColorSpace_H_
 #define LabU8ColorSpace_H_
 
 #include "LcmsColorSpace.h"
 #include "KoColorModelStandardIds.h"
 
 #define TYPE_LABA_8 (COLORSPACE_SH(PT_Lab) | CHANNELS_SH(3) | BYTES_SH(1) | EXTRA_SH(1))
 
 struct KoLabU8Traits;
 
 class LabU8ColorSpace : public LcmsColorSpace<KoLabU8Traits>
 {
 public:
     LabU8ColorSpace(const QString &name, KoColorProfile *p);
     bool willDegrade(ColorSpaceIndependence independence) const override;
 
     static QString colorSpaceId()
     {
         return QString("LABAU8");
     }
 
     KoID colorModelId() const override
     {
         return LABAColorModelID;
     }
 
     KoID colorDepthId() const override
     {
         return Integer8BitsColorDepthID;
     }
 
     virtual KoColorSpace* clone() const;
     void colorToXML(const quint8* pixel, QDomDocument& doc, QDomElement& colorElt) const override;
     void colorFromXML(quint8* pixel, const QDomElement& elt) const override;
     void toHSY(const QVector<double> &channelValues, qreal *hue, qreal *sat, qreal *luma) const override;
     QVector <double> fromHSY(qreal *hue, qreal *sat, qreal *luma) const override;
     void toYUV(const QVector<double> &channelValues, qreal *y, qreal *u, qreal *v) const override;
     QVector <double> fromYUV(qreal *y, qreal *u, qreal *v) const override;
+    quint8 scaleToU8(const quint8 * srcPixel, qint32 channelIndex) const override;
+    void convertChannelToVisualRepresentation(const quint8 *src, quint8 *dst, quint32 nPixels, const qint32 selectedChannelIndex) const override;
+    void convertChannelToVisualRepresentation(const quint8 *src, quint8 *dst, quint32 nPixels, const QBitArray selectedChannels) const override;
 };
 
 class LabU8ColorSpaceFactory : public LcmsColorSpaceFactory
 {
 public:
     LabU8ColorSpaceFactory() : LcmsColorSpaceFactory(TYPE_LABA_8, cmsSigLabData) {}
 
     bool userVisible() const override
     {
         return true;
     }
 
     QString id() const override
     {
         return LabU8ColorSpace::colorSpaceId();
     }
 
     QString name() const override
     {
         return QString("%1 (%2)").arg(LABAColorModelID.name()).arg(Integer8BitsColorDepthID.name());
     }
 
     KoID colorModelId() const override
     {
         return LABAColorModelID;
     }
 
     KoID colorDepthId() const override
     {
         return Integer8BitsColorDepthID;
     }
 
     int referenceDepth() const override
     {
         return 8;
     }
 
     KoColorSpace *createColorSpace(const KoColorProfile *p) const override
     {
         return new LabU8ColorSpace(name(), p->clone());
     }
 
     QString defaultProfile() const override
     {
         return "Lab identity built-in";
     }
 };
 
 #endif
diff --git a/plugins/dockers/advancedcolorselector/kis_color_selector_base.cpp b/plugins/dockers/advancedcolorselector/kis_color_selector_base.cpp
index 0394623b61..4faee542a5 100644
--- a/plugins/dockers/advancedcolorselector/kis_color_selector_base.cpp
+++ b/plugins/dockers/advancedcolorselector/kis_color_selector_base.cpp
@@ -1,580 +1,584 @@
 /*
  *  Copyright (c) 2010 Adam Celarek <kdedev at xibo dot at>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  */
 
 #include "kis_color_selector_base.h"
 
 #include <QMouseEvent>
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QScreen>
 #include <QTimer>
 #include <QCursor>
 #include <QPainter>
 #include <QMimeData>
 
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 
 #include "KoColorSpace.h"
 #include "KoColorSpaceRegistry.h"
 
 #include "kis_canvas2.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_node.h"
 #include "KisViewManager.h"
 #include <KisView.h>
 #include "kis_image.h"
 #include "kis_global.h"
 #include "kis_display_color_converter.h"
 
 #include <resources/KoGamutMask.h>
 
 class KisColorPreviewPopup : public QWidget {
 public:
     KisColorPreviewPopup(KisColorSelectorBase* parent)
         : QWidget(parent), m_parent(parent)
     {
         setWindowFlags(Qt::ToolTip | Qt::NoDropShadowWindowHint);
         setQColor(QColor(0,0,0));
         m_baseColor = QColor(0,0,0,0);
         m_previousColor = QColor(0,0,0,0);
         m_lastUsedColor = QColor(0,0,0,0);
     }
 
     void show()
     {
         updatePosition();
         QWidget::show();
     }
 
     void updatePosition()
     {
         QPoint parentPos = m_parent->mapToGlobal(QPoint(0,0));
         const QRect availRect = QApplication::desktop()->availableGeometry(this);
         QPoint targetPos;
         if ( parentPos.x() - 100 > availRect.x() ) {
             targetPos =  QPoint(parentPos.x() - 100, parentPos.y());
         } else if ( parentPos.x() + m_parent->width() + 100 < availRect.right()) {
             targetPos = m_parent->mapToGlobal(QPoint(m_parent->width(), 0));
         } else if ( parentPos.y() - 100 > availRect.y() ) {
             targetPos =  QPoint(parentPos.x(), parentPos.y() - 100);
         } else {
             targetPos =  QPoint(parentPos.x(), parentPos.y() + m_parent->height());
         }
         setGeometry(targetPos.x(), targetPos.y(), 100, 150);
         setAttribute(Qt::WA_TranslucentBackground);
     }
 
     void setQColor(const QColor& color)
     {
         m_color = color;
         update();
     }
 
     void setPreviousColor()
     {
         m_previousColor = m_baseColor;
     }
 
     void setBaseColor(const QColor& color)
     {
         m_baseColor = color;
         update();
     }
 
     void setLastUsedColor(const QColor& color)
     {
         m_lastUsedColor = color;
         update();
     }
 
 protected:
     void paintEvent(QPaintEvent *e) override {
         Q_UNUSED(e);
         QPainter p(this);
         p.fillRect(0, 0, width(), width(), m_color);
         p.fillRect(50, width(), width(), height(), m_previousColor);
         p.fillRect(0, width(), 50, height(), m_lastUsedColor);
     }
 
     void enterEvent(QEvent *e) override {
         QWidget::enterEvent(e);
         m_parent->tryHideAllPopups();
     }
 
     void leaveEvent(QEvent *e) override {
         QWidget::leaveEvent(e);
         m_parent->tryHideAllPopups();
     }
 
 private:
     KisColorSelectorBase* m_parent;
     QColor m_color;
     QColor m_baseColor;
     QColor m_previousColor;
     QColor m_lastUsedColor;
 };
 
 KisColorSelectorBase::KisColorSelectorBase(QWidget *parent) :
     QWidget(parent),
     m_canvas(0),
     m_popup(0),
     m_parent(0),
     m_colorUpdateAllowed(true),
     m_colorUpdateSelf(false),
     m_hideTimer(new QTimer(this)),
     m_popupOnMouseOver(false),
     m_popupOnMouseClick(true),
     m_colorSpace(0),
     m_isPopup(false),
     m_hideOnMouseClick(false),
     m_colorPreviewPopup(new KisColorPreviewPopup(this))
 {
     m_hideTimer->setInterval(0);
     m_hideTimer->setSingleShot(true);
     connect(m_hideTimer, SIGNAL(timeout()), this, SLOT(hidePopup()));
 
     using namespace std::placeholders; // For _1 placeholder
     auto function = std::bind(&KisColorSelectorBase::slotUpdateColorAndPreview, this, _1);
     m_updateColorCompressor.reset(new ColorCompressorType(20 /* ms */, function));
 }
 
 KisColorSelectorBase::~KisColorSelectorBase()
 {
     delete m_popup;
     delete m_colorPreviewPopup;
 }
 
 void KisColorSelectorBase::setPopupBehaviour(bool onMouseOver, bool onMouseClick)
 {
     m_popupOnMouseClick = onMouseClick;
     m_popupOnMouseOver = onMouseOver;
     if(onMouseClick) {
         m_popupOnMouseOver = false;
     }
 
     if(m_popupOnMouseOver) {
         setMouseTracking(true);
     }
 }
 
 void KisColorSelectorBase::setColorSpace(const KoColorSpace *colorSpace)
 {
     m_colorSpace = colorSpace;
 }
 
 void KisColorSelectorBase::setCanvas(KisCanvas2 *canvas)
 {
     if (m_canvas) {
         m_canvas->disconnectCanvasObserver(this);
     }
     m_canvas = canvas;
     if (m_canvas) {
         connect(m_canvas->resourceManager(), SIGNAL(canvasResourceChanged(int,QVariant)),
                 SLOT(canvasResourceChanged(int,QVariant)), Qt::UniqueConnection);
 
         connect(m_canvas->displayColorConverter(), SIGNAL(displayConfigurationChanged()),
                 SLOT(reset()), Qt::UniqueConnection);
 
         connect(canvas->imageView()->resourceProvider(), SIGNAL(sigFGColorUsed(KoColor)),
                 this,                               SLOT(updateLastUsedColorPreview(KoColor)), Qt::UniqueConnection);
 
         if (m_canvas->viewManager() && m_canvas->viewManager()->canvasResourceProvider()) {
             setColor(Acs::currentColor(m_canvas->viewManager()->canvasResourceProvider(), Acs::Foreground));
         }
     }
     if (m_popup) {
         m_popup->setCanvas(canvas);
     }
 
     reset();
 }
 
 void KisColorSelectorBase::unsetCanvas()
 {
     if (m_popup) {
         m_popup->unsetCanvas();
     }
     m_canvas = 0;
 }
 
 
 
 void KisColorSelectorBase::mousePressEvent(QMouseEvent* event)
 {
     event->accept();
 
     if(!m_isPopup && m_popupOnMouseClick &&
        event->button() == Qt::MidButton) {
 
         lazyCreatePopup();
 
         int x = event->globalX();
         int y = event->globalY();
         int popupsize = m_popup->width();
         x-=popupsize/2;
         y-=popupsize/2;
 
         const QRect availRect = QApplication::desktop()->availableGeometry(this);
 
         if(x<availRect.x())
             x = availRect.x();
         if(y<availRect.y())
             y = availRect.y();
         if(x+m_popup->width()>availRect.x()+availRect.width())
             x = availRect.x()+availRect.width()-m_popup->width();
         if(y+m_popup->height()>availRect.y()+availRect.height())
             y = availRect.y()+availRect.height()-m_popup->height();
 
         m_colorUpdateSelf=false;
         m_popup->move(x, y);
         m_popup->setHidingTime(200);
         showPopup(DontMove);
 
     } else if (m_isPopup && event->button() == Qt::MidButton) {
         if (m_colorPreviewPopup) {
             m_colorPreviewPopup->hide();
         }
         hide();
     } else {
         m_colorUpdateSelf=true;
         showColorPreview();
         event->ignore();
     }
 }
 
 void KisColorSelectorBase::mouseReleaseEvent(QMouseEvent *e) {
 
    Q_UNUSED(e);
 
     if (e->button() == Qt::MidButton) {
         e->accept();
     } else if (m_isPopup &&
                (m_hideOnMouseClick && !m_popupOnMouseOver) &&
                !m_hideTimer->isActive()) {
         if (m_colorPreviewPopup) {
             m_colorPreviewPopup->hide();
         }
         hide();
     }
 }
 
 void KisColorSelectorBase::enterEvent(QEvent *e)
 {
     if (m_popup && m_popup->isVisible()) {
         m_popup->m_hideTimer->stop();
     }
 
     if (m_isPopup && m_hideTimer->isActive()) {
         m_hideTimer->stop();
     }
 
     // do not show the popup when boxed in
     // the configuration dialog (m_canvas == 0)
 
     if (m_canvas &&
         !m_isPopup && m_popupOnMouseOver &&
         (!m_popup || m_popup->isHidden())) {
 
         lazyCreatePopup();
 
         const QRect availRect = QApplication::desktop()->availableGeometry(this);
 
         QPoint proposedTopLeft = rect().center() - m_popup->rect().center();
         proposedTopLeft = mapToGlobal(proposedTopLeft);
 
         QRect popupRect = QRect(proposedTopLeft, m_popup->size());
         popupRect = kisEnsureInRect(popupRect, availRect);
 
         m_popup->setGeometry(popupRect);
         m_popup->setHidingTime(200);
         showPopup(DontMove);
     }
 
     QWidget::enterEvent(e);
 }
 
 void KisColorSelectorBase::leaveEvent(QEvent *e)
 {
     tryHideAllPopups();
     QWidget::leaveEvent(e);
 }
 
 void KisColorSelectorBase::keyPressEvent(QKeyEvent *)
 {
     if (m_isPopup) {
         hidePopup();
     }
 }
 
 void KisColorSelectorBase::dragEnterEvent(QDragEnterEvent *e)
 {
     if(e->mimeData()->hasColor())
         e->acceptProposedAction();
     if(e->mimeData()->hasText() && QColor(e->mimeData()->text()).isValid())
         e->acceptProposedAction();
 }
 
 void KisColorSelectorBase::dropEvent(QDropEvent *e)
 {
     QColor color;
     if(e->mimeData()->hasColor()) {
         color = qvariant_cast<QColor>(e->mimeData()->colorData());
     }
     else if(e->mimeData()->hasText()) {
         color.setNamedColor(e->mimeData()->text());
         if(!color.isValid())
             return;
     }
 
     KoColor kocolor(color , KoColorSpaceRegistry::instance()->rgb8());
     updateColor(kocolor, Acs::Foreground, true);
 }
 
 void KisColorSelectorBase::updateColor(const KoColor &color, Acs::ColorRole role, bool needsExplicitColorReset)
 {
     commitColor(color, role);
 
     if (needsExplicitColorReset) {
         setColor(color);
     }
 }
 
 void KisColorSelectorBase::requestUpdateColorAndPreview(const KoColor &color, Acs::ColorRole role)
 {
     m_updateColorCompressor->start(qMakePair(color, role));
 }
 
 void KisColorSelectorBase::slotUpdateColorAndPreview(QPair<KoColor, Acs::ColorRole> color)
 {
     updateColorPreview(color.first);
     updateColor(color.first, color.second, false);
 }
 
 void KisColorSelectorBase::setColor(const KoColor& color)
 {
     Q_UNUSED(color);
 }
 
 void KisColorSelectorBase::setHidingTime(int time)
 {
     KIS_ASSERT_RECOVER_NOOP(m_isPopup);
 
     m_hideTimer->setInterval(time);
 }
 
 void KisColorSelectorBase::lazyCreatePopup()
 {
     if (!m_popup) {
         m_popup = createPopup();
         Q_ASSERT(m_popup);
         m_popup->setParent(this);
 
         // Setting Qt::BypassWindowManagerHint will prevent
         // the WM from showing another taskbar entry,
         // but will require that we handle window activation manually
         m_popup->setWindowFlags(Qt::FramelessWindowHint |
+#ifdef Q_OS_MACOS
                                 Qt::Popup |
+#else
+                                Qt::Tool |
+#endif
                                 Qt::NoDropShadowWindowHint |
                                 Qt::BypassWindowManagerHint);
         m_popup->m_parent = this;
         m_popup->m_isPopup = true;
     }
     m_popup->setCanvas(m_canvas);
     m_popup->updateSettings();
 }
 
 void KisColorSelectorBase::showPopup(Move move)
 {
     // This slot may be called by some action,
     // so we need to be able to handle it
     lazyCreatePopup();
 
     QPoint cursorPos = QCursor::pos();
     QScreen *activeScreen = 0;
 #if (QT_VERSION >= QT_VERSION_CHECK(5, 10, 0))
     activeScreen = QGuiApplication::screenAt(cursorPos);
 #endif
     const QRect availRect = (activeScreen)? activeScreen->availableGeometry() : QApplication::desktop()->availableGeometry(this);
 
     if (move == MoveToMousePosition) {
         m_popup->move(QPoint(cursorPos.x()-m_popup->width()/2, cursorPos.y()-m_popup->height()/2));
         QRect rc = m_popup->geometry();
         if (rc.x() < availRect.x()) rc.setX(availRect.x());
         if (rc.y() < availRect.y()) rc.setY(availRect.y());
         m_popup->setGeometry(rc);
     }
 
     if (m_colorPreviewPopup) {
         m_colorPreviewPopup->hide();
     }
 
     m_popup->show();
     m_popup->m_colorPreviewPopup->show();
 }
 
 void KisColorSelectorBase::hidePopup()
 {
     KIS_ASSERT_RECOVER_RETURN(m_isPopup);
 
     m_colorPreviewPopup->hide();
     hide();
 }
 
 void KisColorSelectorBase::commitColor(const KoColor& color, Acs::ColorRole role)
 {
     if (!m_canvas)
         return;
 
     m_colorUpdateAllowed=false;
 
     if (role == Acs::Foreground)
         m_canvas->resourceManager()->setForegroundColor(color);
     else
         m_canvas->resourceManager()->setBackgroundColor(color);
 
     m_colorUpdateAllowed=true;
 }
 
 void KisColorSelectorBase::showColorPreview()
 {
     if(m_colorPreviewPopup->isHidden()) {
         m_colorPreviewPopup->show();
     }
 }
 
 void KisColorSelectorBase::updateColorPreview(const KoColor &color)
 {
     m_colorPreviewPopup->setQColor(converter()->toQColor(color));
 }
 
 void KisColorSelectorBase::canvasResourceChanged(int key, const QVariant &v)
 {
     if (key == KoCanvasResourceProvider::ForegroundColor || key == KoCanvasResourceProvider::BackgroundColor) {
         KoColor realColor(v.value<KoColor>());
         updateColorPreview(realColor);
         if (m_colorUpdateAllowed && !m_colorUpdateSelf) {
             setColor(realColor);
         }
     }
 }
 
 const KoColorSpace* KisColorSelectorBase::colorSpace() const
 {
     return converter()->paintingColorSpace();
 }
 
 void KisColorSelectorBase::updateSettings()
 {
     if(m_popup) {
         m_popup->updateSettings();
     }
 
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
 
 
    int zoomSelectorOptions =  (int) cfg.readEntry("zoomSelectorOptions", 0) ;
    if (zoomSelectorOptions == 0)   {
        setPopupBehaviour(false, true);   // middle mouse button click will open zoom selector
    } else if (zoomSelectorOptions == 1)   {
        setPopupBehaviour(true, false);   // move over will open the zoom selector
    }
    else
    {
         setPopupBehaviour(false, false); // do not show zoom selector
    }
 
 
     if(m_isPopup) {
         m_hideOnMouseClick = cfg.readEntry("hidePopupOnClickCheck", false);
         const int zoomSize = cfg.readEntry("zoomSize", 280);
         resize(zoomSize, zoomSize);
     }
 
     reset();
 }
 
 void KisColorSelectorBase::reset()
 {
     update();
 }
 
 void KisColorSelectorBase::updateBaseColorPreview(const KoColor &color)
 {
     m_colorPreviewPopup->setBaseColor(converter()->toQColor(color));
 }
 
 void KisColorSelectorBase::updatePreviousColorPreview()
 {
     m_colorPreviewPopup->setPreviousColor();
 }
 
 void KisColorSelectorBase::updateLastUsedColorPreview(const KoColor &color)
 {
     m_colorPreviewPopup->setLastUsedColor(converter()->toQColor(color));
 }
 
 KisDisplayColorConverter* KisColorSelectorBase::converter() const
 {
     return m_canvas ?
         m_canvas->displayColorConverter() :
                 KisDisplayColorConverter::dumbConverterInstance();
 }
 
 void KisColorSelectorBase::tryHideAllPopups()
 {
     if (m_colorPreviewPopup->isVisible()) {
         m_colorUpdateSelf=false; //this is for allowing advanced selector to listen to outside color-change events.
         m_colorPreviewPopup->hide();
     }
 
     if (m_popup && m_popup->isVisible()) {
         m_popup->m_hideTimer->start();
     }
 
     if (m_isPopup && !m_hideTimer->isActive()) {
         m_hideTimer->start();
     }
 }
 
 
 void KisColorSelectorBase::mouseMoveEvent(QMouseEvent *event)
 {
     event->accept();
 }
 
 
 void KisColorSelectorBase::changeEvent(QEvent *event)
 {
     // hide the popup when another window becomes active, e.g. due to alt+tab
     if(m_isPopup && event->type() == QEvent::ActivationChange && !isActiveWindow()) {
         hidePopup();
     }
 
     QWidget::changeEvent(event);
 }
 
 void KisColorSelectorBase::showEvent(QShowEvent *event)
 {
     QWidget::showEvent(event);
 
     // manual activation required due to Qt::BypassWindowManagerHint
     if(m_isPopup) {
         activateWindow();
     }
 }
diff --git a/plugins/dockers/animation/animation_docker.cpp b/plugins/dockers/animation/animation_docker.cpp
index f6d3e7897a..73583b99fc 100644
--- a/plugins/dockers/animation/animation_docker.cpp
+++ b/plugins/dockers/animation/animation_docker.cpp
@@ -1,678 +1,685 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "animation_docker.h"
 
 #include "kis_global.h"
 
 #include "kis_canvas2.h"
 #include "kis_image.h"
 #include <QMenu>
 #include <kis_icon.h>
 #include <kis_transform_mask.h>
 #include "KisViewManager.h"
 #include "kis_action_manager.h"
 #include "kis_image_animation_interface.h"
 #include "kis_animation_player.h"
 #include "kis_time_range.h"
 #include "kundo2command.h"
 #include "kis_post_execution_undo_adapter.h"
 #include "kis_keyframe_channel.h"
 #include "kis_animation_utils.h"
 #include "krita_utils.h"
 #include "kis_image_config.h"
 #include "kis_config.h"
 #include "kis_signals_blocker.h"
 #include "kis_node_manager.h"
 #include "kis_transform_mask_params_factory_registry.h"
 
 
 #include "ui_wdg_animation.h"
 
 void setupActionButton(const QString &text,
                        KisAction::ActivationFlags flags,
                        bool defaultValue,
                        QToolButton *button,
                        KisAction **action)
 {
     *action = new KisAction(text, button);
     (*action)->setActivationFlags(flags);
     (*action)->setCheckable(true);
     (*action)->setChecked(defaultValue);
     button->setDefaultAction(*action);
 }
 
 AnimationDocker::AnimationDocker()
     : QDockWidget(i18n("Animation"))
     , m_canvas(0)
     , m_animationWidget(new Ui_WdgAnimation)
     , m_mainWindow(0)
 {
     QWidget* mainWidget = new QWidget(this);
     setWidget(mainWidget);
 
     m_animationWidget->setupUi(mainWidget);
 }
 
 AnimationDocker::~AnimationDocker()
 {
     delete m_animationWidget;
 }
 
 void AnimationDocker::setCanvas(KoCanvasBase * canvas)
 {
     if(m_canvas == canvas)
         return;
 
     setEnabled(canvas != 0);
 
     if (m_canvas) {
         m_canvas->disconnectCanvasObserver(this);
         m_canvas->image()->disconnect(this);
         m_canvas->image()->animationInterface()->disconnect(this);
         m_canvas->animationPlayer()->disconnect(this);
         m_canvas->viewManager()->nodeManager()->disconnect(this);
     }
 
     m_canvas = dynamic_cast<KisCanvas2*>(canvas);
 
     if (m_canvas && m_canvas->image()) {
 
         KisImageAnimationInterface *animation = m_canvas->image()->animationInterface();
         {
             KisSignalsBlocker bloker(m_animationWidget->spinFromFrame,
                                      m_animationWidget->spinToFrame,
                                      m_animationWidget->intFramerate);
 
             m_animationWidget->spinFromFrame->setValue(animation->fullClipRange().start());
             m_animationWidget->spinToFrame->setValue(animation->fullClipRange().end());
             m_animationWidget->intFramerate->setValue(animation->framerate());
         }
 
 
         connect(animation, SIGNAL(sigUiTimeChanged(int)), this, SLOT(slotGlobalTimeChanged()));
         connect(animation, SIGNAL(sigFramerateChanged()), this, SLOT(slotFrameRateChanged()));
 
 
         connect(m_canvas->animationPlayer(), SIGNAL(sigFrameChanged()), this, SLOT(slotGlobalTimeChanged()));
         connect(m_canvas->animationPlayer(), SIGNAL(sigPlaybackStopped()), this, SLOT(slotGlobalTimeChanged()));
         connect(m_canvas->animationPlayer(), SIGNAL(sigPlaybackStopped()), this, SLOT(updatePlayPauseIcon()));
         connect(m_canvas->animationPlayer(), SIGNAL(sigPlaybackStarted()), this, SLOT(updatePlayPauseIcon()));
         connect(m_canvas->animationPlayer(), SIGNAL(sigPlaybackStatisticsUpdated()), this, SLOT(updateDropFramesIcon()));
         connect(m_animationWidget->doublePlaySpeed,
                 SIGNAL(valueChanged(double)),
                 m_canvas->animationPlayer(),
                 SLOT(slotUpdatePlaybackSpeed(double)));
 
 
         connect(m_canvas->viewManager()->nodeManager(), SIGNAL(sigNodeActivated(KisNodeSP)),
                 this, SLOT(slotCurrentNodeChanged(KisNodeSP)));
 
         connect (animation, SIGNAL(sigFullClipRangeChanged()), this, SLOT(updateClipRange()));
 
 
 
         slotGlobalTimeChanged();
         slotCurrentNodeChanged(m_canvas->viewManager()->nodeManager()->activeNode());
     }
 
     slotUpdateIcons();
 }
 
 void AnimationDocker::unsetCanvas()
 {
     setCanvas(0);
 }
 
 void AnimationDocker::setViewManager(KisViewManager *view)
 {
     setActions(view->actionManager());
 
     slotUpdateIcons();
     connect(view->mainWindow(), SIGNAL(themeChanged()), this, SLOT(slotUpdateIcons()));
     m_mainWindow = view->mainWindow();
 }
 
 void AnimationDocker::slotAddOpacityKeyframe()
 {
+    // remember current node's opacity and set it once we create a new opacity keyframe
+    KisNodeSP node = m_canvas->viewManager()->activeNode();
+    KIS_SAFE_ASSERT_RECOVER_RETURN(node);
+
     addKeyframe(KisKeyframeChannel::Opacity.id(), false);
 }
 
 void AnimationDocker::slotDeleteOpacityKeyframe()
 {
     deleteKeyframe(KisKeyframeChannel::Opacity.id());
 }
 
 void AnimationDocker::slotAddTransformKeyframe()
 {
     if (!m_canvas) return;
 
     KisTransformMask *mask = dynamic_cast<KisTransformMask*>(m_canvas->viewManager()->activeNode().data());
     if (!mask) return;
 
     const int time = m_canvas->image()->animationInterface()->currentTime();
 
     KUndo2Command *command = new KUndo2Command(kundo2_i18n("Add transform keyframe"));
     KisTransformMaskParamsFactoryRegistry::instance()->autoAddKeyframe(mask, time, KisTransformMaskParamsInterfaceSP(), command);
 
     command->redo();
     m_canvas->currentImage()->postExecutionUndoAdapter()->addCommand(toQShared(command));
 }
 
 void AnimationDocker::slotDeleteTransformKeyframe()
 {
     deleteKeyframe(KisKeyframeChannel::TransformArguments.id());
 }
 
 void AnimationDocker::slotUIRangeChanged()
 {
     if (!m_canvas || !m_canvas->image()) return;
 
     int fromTime = m_animationWidget->spinFromFrame->value();
     int toTime = m_animationWidget->spinToFrame->value();
 
     m_canvas->image()->animationInterface()->setFullClipRange(KisTimeRange::fromTime(fromTime, toTime));
 }
 
 void AnimationDocker::slotUIFramerateChanged()
 {
     if (!m_canvas || !m_canvas->image()) return;
 
     m_canvas->image()->animationInterface()->setFramerate(m_animationWidget->intFramerate->value());
 }
 
 void AnimationDocker::slotOnionSkinOptions()
 {
     if (m_mainWindow) {
         QDockWidget *docker = m_mainWindow->dockWidget("OnionSkinsDocker");
         if (docker) {
             docker->setVisible(!docker->isVisible());
         }
     }
 }
 
 void AnimationDocker::slotGlobalTimeChanged()
 {
     int time = m_canvas->animationPlayer()->isPlaying() ?
                 m_canvas->animationPlayer()->currentTime() :
                 m_canvas->image()->animationInterface()->currentUITime();
 
     m_animationWidget->intCurrentTime->setValue(time);
 
     const int frameRate = m_canvas->image()->animationInterface()->framerate();
     const int msec = 1000 * time / frameRate;
 
     QTime realTime;
     realTime = realTime.addMSecs(msec);
 
     QString realTimeString = realTime.toString("hh:mm:ss.zzz");
     m_animationWidget->intCurrentTime->setToolTip(realTimeString);
 }
 
 void AnimationDocker::slotFrameRateChanged()
 {
     if (!m_canvas || !m_canvas->image()) return;
 
     int fpsOnUI = m_animationWidget->intFramerate->value();
     KisImageAnimationInterface *animation = m_canvas->image()->animationInterface();
 
     if (animation->framerate() != fpsOnUI) {
         m_animationWidget->intFramerate->setValue(animation->framerate());
     }
 
 }
 
 void AnimationDocker::slotTimeSpinBoxChanged()
 {
     if (!m_canvas || !m_canvas->image()) return;
 
     int newTime = m_animationWidget->intCurrentTime->value();
     KisImageAnimationInterface *animation = m_canvas->image()->animationInterface();
 
     if (m_canvas->animationPlayer()->isPlaying() ||
         newTime == animation->currentUITime()) {
 
         return;
     }
 
     animation->requestTimeSwitchWithUndo(newTime);
 }
 
 void AnimationDocker::slotPreviousFrame()
 {
     if (!m_canvas) return;
     KisImageAnimationInterface *animation = m_canvas->image()->animationInterface();
 
     int time = animation->currentUITime() - 1;
     if (time >= 0) {
         animation->requestTimeSwitchWithUndo(time);
     }
 }
 
 void AnimationDocker::slotNextFrame()
 {
     if (!m_canvas) return;
     KisImageAnimationInterface *animation = m_canvas->image()->animationInterface();
 
     int time = animation->currentUITime() + 1;
     animation->requestTimeSwitchWithUndo(time);
 }
 
 void AnimationDocker::slotPreviousKeyFrame()
 {
     if (!m_canvas) return;
 
     KisNodeSP node = m_canvas->viewManager()->activeNode();
     if (!node) return;
 
     KisImageAnimationInterface *animation = m_canvas->image()->animationInterface();
     int time = animation->currentUITime();
 
     KisKeyframeChannel *content =
         node->getKeyframeChannel(KisKeyframeChannel::Content.id());
 
     if (!content) return;
 
     KisKeyframeSP dstKeyframe;
     KisKeyframeSP keyframe = content->keyframeAt(time);
 
     if (!keyframe) {
         dstKeyframe = content->activeKeyframeAt(time);
     } else {
         dstKeyframe = content->previousKeyframe(keyframe);
     }
 
     if (dstKeyframe) {
         animation->requestTimeSwitchWithUndo(dstKeyframe->time());
     }
 }
 
 void AnimationDocker::slotNextKeyFrame()
 {
     if (!m_canvas) return;
 
     KisNodeSP node = m_canvas->viewManager()->activeNode();
     if (!node) return;
 
     KisImageAnimationInterface *animation = m_canvas->image()->animationInterface();
     int time = animation->currentUITime();
 
     KisKeyframeChannel *content =
         node->getKeyframeChannel(KisKeyframeChannel::Content.id());
 
     if (!content) return;
 
     KisKeyframeSP dstKeyframe;
     KisKeyframeSP keyframe = content->activeKeyframeAt(time);
 
     if (keyframe) {
         dstKeyframe = content->nextKeyframe(keyframe);
     }
 
     if (dstKeyframe) {
         animation->requestTimeSwitchWithUndo(dstKeyframe->time());
     }
 }
 
 
 void AnimationDocker::slotFirstFrame()
 {
     if (!m_canvas) return;
 
     KisImageAnimationInterface *animation = m_canvas->image()->animationInterface();
     animation->requestTimeSwitchWithUndo(0);
 }
 
 void AnimationDocker::slotLastFrame()
 {
     if (!m_canvas) return;
 
     KisImageAnimationInterface *animation = m_canvas->image()->animationInterface();
     animation->requestTimeSwitchWithUndo(animation->totalLength() - 1);
 }
 
 
 void AnimationDocker::slotPlayPause()
 {
     if (!m_canvas) return;
 
     if (m_canvas->animationPlayer()->isPlaying()) {
         m_canvas->animationPlayer()->stop();
     } else {
         m_canvas->animationPlayer()->play();
     }
 
     updatePlayPauseIcon();
 }
 
 void AnimationDocker::updatePlayPauseIcon()
 {
     bool isPlaying = m_canvas && m_canvas->animationPlayer() && m_canvas->animationPlayer()->isPlaying();
 
     m_playPauseAction->setIcon(isPlaying ?
                                KisIconUtils::loadIcon("animation_stop") :
                                KisIconUtils::loadIcon("animation_play"));
 }
 
 void AnimationDocker::updateLazyFrameIcon()
 {
     KisImageConfig cfg(true);
 
     const bool value = cfg.lazyFrameCreationEnabled();
 
     m_lazyFrameAction->setIcon(value ?
                                KisIconUtils::loadIcon("lazyframeOn") :
                                KisIconUtils::loadIcon("lazyframeOff"));
 
     m_lazyFrameAction->setText(QString("%1 (%2)")
                                .arg(KisAnimationUtils::lazyFrameCreationActionName)
                                .arg(KritaUtils::toLocalizedOnOff(value)));
 }
 
 void AnimationDocker::updateDropFramesIcon()
 {
     qreal effectiveFps = 0.0;
     qreal realFps = 0.0;
     qreal framesDropped = 0.0;
     bool isPlaying = false;
 
     KisAnimationPlayer *player =
         m_canvas && m_canvas->animationPlayer() ?
         m_canvas->animationPlayer() : 0;
 
     if (player) {
         effectiveFps = player->effectiveFps();
         realFps = player->realFps();
         framesDropped = player->framesDroppedPortion();
         isPlaying = player->isPlaying();
     }
 
     KisConfig cfg(true);
     const bool value = cfg.animationDropFrames();
 
     m_dropFramesAction->setIcon(value ?
                                 KisIconUtils::loadIcon(framesDropped > 0.05 ? "droppedframes" : "dropframe") :
                                 KisIconUtils::loadIcon("dropframe"));
 
 
     QString text;
 
     if (!isPlaying) {
         text = QString("%1 (%2)")
             .arg(KisAnimationUtils::dropFramesActionName)
             .arg(KritaUtils::toLocalizedOnOff(value));
     } else {
         text = QString("%1 (%2)\n"
                        "%3\n"
                        "%4\n"
                        "%5")
             .arg(KisAnimationUtils::dropFramesActionName)
             .arg(KritaUtils::toLocalizedOnOff(value))
             .arg(i18n("Effective FPS:\t%1", effectiveFps))
             .arg(i18n("Real FPS:\t%1", realFps))
             .arg(i18n("Frames dropped:\t%1\%", framesDropped * 100));
     }
 
     m_dropFramesAction->setText(text);
 }
 
 void AnimationDocker::slotUpdateIcons()
 {
     m_previousFrameAction->setIcon(KisIconUtils::loadIcon("prevframe"));
     m_nextFrameAction->setIcon(KisIconUtils::loadIcon("nextframe"));
 
     m_previousKeyFrameAction->setIcon(KisIconUtils::loadIcon("prevkeyframe"));
     m_nextKeyFrameAction->setIcon(KisIconUtils::loadIcon("nextkeyframe"));
 
     m_firstFrameAction->setIcon(KisIconUtils::loadIcon("firstframe"));
     m_lastFrameAction->setIcon(KisIconUtils::loadIcon("lastframe"));
 
     updatePlayPauseIcon();
     updateLazyFrameIcon();
     updateDropFramesIcon();
 
     m_animationWidget->btnOnionSkinOptions->setIcon(KisIconUtils::loadIcon("onion_skin_options"));
     m_animationWidget->btnOnionSkinOptions->setIconSize(QSize(22, 22));
 
 
     m_animationWidget->btnNextKeyFrame->setIconSize(QSize(22, 22));
     m_animationWidget->btnPreviousKeyFrame->setIconSize(QSize(22, 22));
     m_animationWidget->btnFirstFrame->setIconSize(QSize(22, 22));
     m_animationWidget->btnLastFrame->setIconSize(QSize(22, 22));
 
     m_animationWidget->btnPreviousFrame->setIconSize(QSize(22, 22));
     m_animationWidget->btnPlay->setIconSize(QSize(22, 22));
     m_animationWidget->btnNextFrame->setIconSize(QSize(22, 22));
     m_animationWidget->btnAddKeyframe->setIconSize(QSize(22, 22));
     m_animationWidget->btnAddDuplicateFrame->setIconSize(QSize(22, 22));
     m_animationWidget->btnDeleteKeyframe->setIconSize(QSize(22, 22));
     m_animationWidget->btnLazyFrame->setIconSize(QSize(22, 22));
     m_animationWidget->btnDropFrames->setIconSize(QSize(22, 22));
 }
 
 void AnimationDocker::slotLazyFrameChanged(bool value)
 {
     KisImageConfig cfg(false);
 
     if (value != cfg.lazyFrameCreationEnabled()) {
         cfg.setLazyFrameCreationEnabled(value);
         updateLazyFrameIcon();
     }
 }
 
 void AnimationDocker::slotDropFramesChanged(bool value)
 {
     KisConfig cfg(false);
 
     if (value != cfg.animationDropFrames()) {
         cfg.setAnimationDropFrames(value);
         updateDropFramesIcon();
     }
 }
 
 void AnimationDocker::slotCurrentNodeChanged(KisNodeSP node)
 {
     bool isNodeAnimatable = false;
 
     m_newKeyframeMenu->clear();
     m_deleteKeyframeMenu->clear();
 
     if (!node.isNull()) {
         if (KisAnimationUtils::supportsContentFrames(node)) {
             isNodeAnimatable = true;
             KisActionManager::safePopulateMenu(m_newKeyframeMenu, "add_blank_frame", m_actionManager);
             KisActionManager::safePopulateMenu(m_deleteKeyframeMenu, "remove_frames", m_actionManager);
         }
 
         if (node->inherits("KisLayer")) {
             isNodeAnimatable = true;
             m_newKeyframeMenu->addAction(m_addOpacityKeyframeAction);
             m_deleteKeyframeMenu->addAction(m_deleteOpacityKeyframeAction);
         }
 
         /*
         if (node->inherits("KisTransformMask")) {
             isNodeAnimatable = true;
             m_newKeyframeMenu->addAction(m_addTransformKeyframeAction);
             m_deleteKeyframeMenu->addAction(m_deleteTransformKeyframeAction);
         }
         */
     }
 
     m_animationWidget->btnAddKeyframe->setEnabled(isNodeAnimatable);
     m_animationWidget->btnAddDuplicateFrame->setEnabled(isNodeAnimatable);
     m_animationWidget->btnDeleteKeyframe->setEnabled(isNodeAnimatable);
 }
 
 void AnimationDocker::updateClipRange()
 {
     m_animationWidget->spinFromFrame->setValue(m_canvas->image()->animationInterface()->fullClipRange().start());
     m_animationWidget->spinToFrame->setValue(m_canvas->image()->animationInterface()->fullClipRange().end());
 }
 
 void AnimationDocker::addKeyframe(const QString &channel, bool copy)
 {
     if (!m_canvas) return;
 
     KisNodeSP node = m_canvas->viewManager()->activeNode();
     if (!node) return;
 
     const int time = m_canvas->image()->animationInterface()->currentTime();
     KisAnimationUtils::createKeyframeLazy(m_canvas->image(), node, channel, time, copy);
 }
 
 void AnimationDocker::deleteKeyframe(const QString &channel)
 {
     if (!m_canvas) return;
 
     KisNodeSP node = m_canvas->viewManager()->activeNode();
     if (!node) return;
 
     const int time = m_canvas->image()->animationInterface()->currentTime();
     KisAnimationUtils::removeKeyframe(m_canvas->image(), node, channel, time);
 }
 
 void AnimationDocker::setActions(KisActionManager *actionMan)
 {
     m_actionManager = actionMan;
     if (!m_actionManager) return;
 
     m_previousFrameAction = new KisAction(i18n("Previous Frame"), m_animationWidget->btnPreviousFrame);
     m_previousFrameAction->setActivationFlags(KisAction::ACTIVE_IMAGE);
     m_animationWidget->btnPreviousFrame->setDefaultAction(m_previousFrameAction);
 
     m_nextFrameAction = new KisAction(i18n("Next Frame"), m_animationWidget->btnNextFrame);
     m_nextFrameAction->setActivationFlags(KisAction::ACTIVE_IMAGE);
     m_animationWidget->btnNextFrame->setDefaultAction(m_nextFrameAction);
 
     m_previousKeyFrameAction = new KisAction(i18n("Previous Key Frame"), m_animationWidget->btnPreviousKeyFrame);
     m_previousKeyFrameAction->setActivationFlags(KisAction::ACTIVE_IMAGE);
     m_animationWidget->btnPreviousKeyFrame->setDefaultAction(m_previousKeyFrameAction);
 
     m_nextKeyFrameAction = new KisAction(i18n("Next Key Frame"), m_animationWidget->btnNextKeyFrame);
     m_nextKeyFrameAction->setActivationFlags(KisAction::ACTIVE_IMAGE);
     m_animationWidget->btnNextKeyFrame->setDefaultAction(m_nextKeyFrameAction);
 
     m_firstFrameAction = new KisAction(i18n("First Frame"), m_animationWidget->btnFirstFrame);
     m_firstFrameAction->setActivationFlags(KisAction::ACTIVE_IMAGE);
     m_animationWidget->btnFirstFrame->setDefaultAction(m_firstFrameAction);
 
     m_lastFrameAction = new KisAction(i18n("Last Frame"), m_animationWidget->btnLastFrame);
     m_lastFrameAction->setActivationFlags(KisAction::ACTIVE_IMAGE);
     m_animationWidget->btnLastFrame->setDefaultAction(m_lastFrameAction);
 
 
     m_playPauseAction = new KisAction(i18n("Play / Stop"), m_animationWidget->btnPlay);
     m_playPauseAction->setActivationFlags(KisAction::ACTIVE_IMAGE);
     m_animationWidget->btnPlay->setDefaultAction(m_playPauseAction);
 
     KisAction *action = 0;
 
     action = m_actionManager->createAction("add_blank_frame");
     m_animationWidget->btnAddKeyframe->setDefaultAction(action);
 
     action = m_actionManager->createAction("add_duplicate_frame");
     m_animationWidget->btnAddDuplicateFrame->setDefaultAction(action);
 
     action = m_actionManager->createAction("remove_frames");
     m_animationWidget->btnDeleteKeyframe->setDefaultAction(action);
 
     m_newKeyframeMenu = new QMenu(this);
     m_animationWidget->btnAddKeyframe->setMenu(m_newKeyframeMenu);
     m_animationWidget->btnAddKeyframe->setPopupMode(QToolButton::MenuButtonPopup);
 
     m_deleteKeyframeMenu = new QMenu(this);
     m_animationWidget->btnDeleteKeyframe->setMenu(m_deleteKeyframeMenu);
     m_animationWidget->btnDeleteKeyframe->setPopupMode(QToolButton::MenuButtonPopup);
 
-    m_addOpacityKeyframeAction = new KisAction(KisAnimationUtils::addOpacityKeyframeActionName);
-    m_deleteOpacityKeyframeAction = new KisAction(KisAnimationUtils::removeOpacityKeyframeActionName);
+
+    m_addOpacityKeyframeAction = m_actionManager->createAction("insert_opacity_keyframe");
+    m_deleteOpacityKeyframeAction = m_actionManager->createAction("remove_opacity_keyframe");
+
+
 
     m_addTransformKeyframeAction = new KisAction(KisAnimationUtils::addTransformKeyframeActionName, this);
     m_deleteTransformKeyframeAction = new KisAction(KisAnimationUtils::removeTransformKeyframeActionName, this);
 
 
     // other new stuff
     m_actionManager->addAction("previous_frame", m_previousFrameAction);
     m_actionManager->addAction("next_frame", m_nextFrameAction);
 
     m_actionManager->addAction("previous_keyframe", m_previousKeyFrameAction);
     m_actionManager->addAction("next_keyframe", m_nextKeyFrameAction);
 
     m_actionManager->addAction("first_frame", m_firstFrameAction);
     m_actionManager->addAction("last_frame", m_lastFrameAction);
 
     {
         KisImageConfig cfg(true);
         setupActionButton(KisAnimationUtils::lazyFrameCreationActionName,
                           KisAction::ACTIVE_IMAGE,
                           cfg.lazyFrameCreationEnabled(),
                           m_animationWidget->btnLazyFrame,
                           &m_lazyFrameAction);
     }
 
     {
         KisConfig cfg(true);
         setupActionButton(KisAnimationUtils::dropFramesActionName,
                           KisAction::ACTIVE_IMAGE,
                           cfg.animationDropFrames(),
                           m_animationWidget->btnDropFrames,
                           &m_dropFramesAction);
     }
 
 
      // these actions are created in the setupActionButton() above, so we need to add actions after that
      m_actionManager->addAction("lazy_frame", m_lazyFrameAction);
      m_actionManager->addAction("drop_frames", m_dropFramesAction);
 
      m_actionManager->addAction("toggle_playback", m_playPauseAction);
 
     QFont font;
     font.setPointSize(1.7 * font.pointSize());
     font.setBold(true);
     m_animationWidget->intCurrentTime->setFont(font);
 
     connect(m_previousFrameAction, SIGNAL(triggered()), this, SLOT(slotPreviousFrame()));
     connect(m_nextFrameAction, SIGNAL(triggered()), this, SLOT(slotNextFrame()));
 
     connect(m_previousKeyFrameAction, SIGNAL(triggered()), this, SLOT(slotPreviousKeyFrame()));
     connect(m_nextKeyFrameAction, SIGNAL(triggered()), this, SLOT(slotNextKeyFrame()));
 
     connect(m_firstFrameAction, SIGNAL(triggered()), this, SLOT(slotFirstFrame()));
     connect(m_lastFrameAction, SIGNAL(triggered()), this, SLOT(slotLastFrame()));
 
     connect(m_playPauseAction, SIGNAL(triggered()), this, SLOT(slotPlayPause()));
 
     connect(m_lazyFrameAction, SIGNAL(toggled(bool)), this, SLOT(slotLazyFrameChanged(bool)));
     connect(m_dropFramesAction, SIGNAL(toggled(bool)), this, SLOT(slotDropFramesChanged(bool)));
 
     connect(m_addOpacityKeyframeAction, SIGNAL(triggered(bool)), this, SLOT(slotAddOpacityKeyframe()));
     connect(m_deleteOpacityKeyframeAction, SIGNAL(triggered(bool)), this, SLOT(slotDeleteOpacityKeyframe()));
 
     connect(m_addTransformKeyframeAction, SIGNAL(triggered(bool)), this, SLOT(slotAddTransformKeyframe()));
     connect(m_deleteTransformKeyframeAction, SIGNAL(triggered(bool)), this, SLOT(slotDeleteTransformKeyframe()));
 
     m_animationWidget->btnOnionSkinOptions->setToolTip(i18n("Onion Skins"));
     connect(m_animationWidget->btnOnionSkinOptions, SIGNAL(clicked()), this, SLOT(slotOnionSkinOptions()));
 
     connect(m_animationWidget->spinFromFrame, SIGNAL(valueChanged(int)), this, SLOT(slotUIRangeChanged()));
     connect(m_animationWidget->spinToFrame, SIGNAL(valueChanged(int)), this, SLOT(slotUIRangeChanged()));
     connect(m_animationWidget->intFramerate, SIGNAL(valueChanged(int)), this, SLOT(slotUIFramerateChanged()));
 
     connect(m_animationWidget->intCurrentTime, SIGNAL(valueChanged(int)), SLOT(slotTimeSpinBoxChanged()));
 }
diff --git a/plugins/dockers/animation/kis_animation_curves_keyframe_delegate.cpp b/plugins/dockers/animation/kis_animation_curves_keyframe_delegate.cpp
index cad623b6f4..2c5143085c 100644
--- a/plugins/dockers/animation/kis_animation_curves_keyframe_delegate.cpp
+++ b/plugins/dockers/animation/kis_animation_curves_keyframe_delegate.cpp
@@ -1,209 +1,225 @@
 /*
  *  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_animation_curves_keyframe_delegate.h"
 
 #include <QPainter>
 #include <QApplication>
 #include <QVector2D>
 
 #include "kis_animation_curves_model.h"
 #include "kis_keyframe.h"
 
-const int NODE_RENDER_RADIUS = 2;
+const int NODE_RENDER_RADIUS = 4;
 const int NODE_UI_RADIUS = 8;
 
 struct KisAnimationCurvesKeyframeDelegate::Private
 {
     Private(const TimelineRulerHeader *horizontalRuler, const KisAnimationCurvesValueRuler *verticalRuler)
         : horizontalRuler(horizontalRuler)
         , verticalRuler(verticalRuler)
     {}
     const TimelineRulerHeader *horizontalRuler;
     const KisAnimationCurvesValueRuler *verticalRuler;
     QPointF selectionOffset;
 
     int adjustedHandle;
     QPointF handleAdjustment;
+
 };
 
 KisAnimationCurvesKeyframeDelegate::KisAnimationCurvesKeyframeDelegate(const TimelineRulerHeader *horizontalRuler, const KisAnimationCurvesValueRuler *verticalRuler, QObject *parent)
     : QAbstractItemDelegate(parent)
     , m_d(new Private(horizontalRuler, verticalRuler))
-{}
+{
+}
 
 KisAnimationCurvesKeyframeDelegate::~KisAnimationCurvesKeyframeDelegate()
 {}
 
+
 void KisAnimationCurvesKeyframeDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     bool selected = option.state & QStyle::State_Selected;
     bool active = option.state & QStyle::State_HasFocus;
     QPointF center = nodeCenter(index, selected);
 
     QColor color;
     QColor bgColor = qApp->palette().color(QPalette::Window);
     if (selected) {
         color = (bgColor.value() > 128) ? Qt::black : Qt::white;
     } else {
         color = index.data(KisAnimationCurvesModel::CurveColorRole).value<QColor>();
     }
 
     painter->setPen(QPen(color, 0));
     painter->setBrush(color);
     painter->drawEllipse(center, NODE_RENDER_RADIUS, NODE_RENDER_RADIUS);
 
     if (selected) {
         painter->setPen(QPen(color, 1));
         painter->setBrush(bgColor);
 
         if (hasHandle(index, 0)) {
             QPointF leftTangent = leftHandle(index, active);
             paintHandle(painter, center, leftTangent);
         }
 
         if (hasHandle(index, 1)) {
             QPointF rightTangent = rightHandle(index, active);
             paintHandle(painter, center, rightTangent);
         }
     }
 }
 
 QSize KisAnimationCurvesKeyframeDelegate::sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     Q_UNUSED(option);
     Q_UNUSED(index);
     return QSize(2*NODE_UI_RADIUS, 2*NODE_UI_RADIUS);
 }
 
 QPointF KisAnimationCurvesKeyframeDelegate::nodeCenter(const QModelIndex index, bool selected) const
 {
     int section = m_d->horizontalRuler->logicalIndex(index.column());
     int x = m_d->horizontalRuler->sectionViewportPosition(section)
             + (m_d->horizontalRuler->sectionSize(section) / 2);
 
     float value = index.data(KisAnimationCurvesModel::ScalarValueRole).toReal();
     float y = m_d->verticalRuler->mapValueToView(value);
 
     QPointF center = QPointF(x, y);
     if (selected) center += m_d->selectionOffset;
     return center;
 }
 
 bool KisAnimationCurvesKeyframeDelegate::hasHandle(const QModelIndex index, int handle) const
 {
     QModelIndex interpolatedIndex;
 
     if (handle == 0) {
         // Left handle: use previous keyframe's interpolation mode
 
         QVariant previous = index.data(KisAnimationCurvesModel::PreviousKeyframeTime);
         if (!previous.isValid()) return false;
 
         interpolatedIndex = index.model()->index(index.row(), previous.toInt());
     } else {
         interpolatedIndex = index;
     }
 
     return (interpolatedIndex.data(KisAnimationCurvesModel::InterpolationModeRole).toInt() == KisKeyframe::Bezier);
 }
 
 QPointF KisAnimationCurvesKeyframeDelegate::leftHandle(const QModelIndex index, bool active) const
 {
     return handlePosition(index, active, 0);
 }
 
 QPointF KisAnimationCurvesKeyframeDelegate::rightHandle(const QModelIndex index, bool active) const
 {
     return handlePosition(index, active, 1);
 }
 
 QPointF KisAnimationCurvesKeyframeDelegate::handlePosition(const QModelIndex index, bool active, int handle) const
 {
     int role = (handle == 0) ? KisAnimationCurvesModel::LeftTangentRole : KisAnimationCurvesModel::RightTangentRole;
     QPointF tangent = index.data(role).toPointF();
 
     float x = tangent.x() * m_d->horizontalRuler->defaultSectionSize();
     float y = tangent.y() * m_d->verticalRuler->scaleFactor();
     QPointF handlePos = QPointF(x, y);
 
     if (active && !m_d->handleAdjustment.isNull()) {
         if (handle == m_d->adjustedHandle) {
             handlePos += m_d->handleAdjustment;
             if ((handle == 0 && handlePos.x() > 0) ||
                 (handle == 1 && handlePos.x() < 0)) {
                 handlePos.setX(0);
             }
         } else if (index.data(KisAnimationCurvesModel::TangentsModeRole).toInt() == KisKeyframe::Smooth) {
             qreal length = QVector2D(handlePos).length();
             QVector2D opposite(handlePosition(index, active, 1-handle));
             handlePos = (-length * opposite.normalized()).toPointF();
         }
     }
 
     return handlePos;
 }
 
 void KisAnimationCurvesKeyframeDelegate::setSelectedItemVisualOffset(QPointF offset)
 {
     m_d->selectionOffset = offset;
 }
 
 void KisAnimationCurvesKeyframeDelegate::setHandleAdjustment(QPointF offset, int handle)
 {
     m_d->adjustedHandle = handle;
     m_d->handleAdjustment = offset;
 }
 
 QPointF KisAnimationCurvesKeyframeDelegate::unscaledTangent(QPointF handlePosition) const
 {
     qreal x = handlePosition.x() / m_d->horizontalRuler->defaultSectionSize();
     qreal y = handlePosition.y() / m_d->verticalRuler->scaleFactor();
 
     return QPointF(x, y);
 }
 
 void KisAnimationCurvesKeyframeDelegate::paintHandle(QPainter *painter, QPointF nodePos, QPointF tangent) const
 {
     QPointF handlePos = nodePos + tangent;
 
     painter->drawLine(nodePos, handlePos);
     painter->drawEllipse(handlePos, NODE_RENDER_RADIUS, NODE_RENDER_RADIUS);
 }
 
 QRect KisAnimationCurvesKeyframeDelegate::itemRect(const QModelIndex index) const
 {
     QPointF center = nodeCenter(index, false);
 
     return QRect(center.x() - NODE_UI_RADIUS, center.y() - NODE_UI_RADIUS, 2*NODE_UI_RADIUS, 2*NODE_UI_RADIUS);
 }
 
+QRect KisAnimationCurvesKeyframeDelegate::frameRect(const QModelIndex index) const
+{
+    int section = m_d->horizontalRuler->logicalIndex(index.column());
+    int x = m_d->horizontalRuler->sectionViewportPosition(section);
+    int xSize = m_d->horizontalRuler->sectionSize(section);
+
+    float value = index.data(KisAnimationCurvesModel::ScalarValueRole).toReal();
+    float y = m_d->verticalRuler->mapValueToView(value);
+    int ySize = m_d->verticalRuler->height();
+
+   return QRect(x, y, xSize, ySize);
+}
+
 QRect KisAnimationCurvesKeyframeDelegate::visualRect(const QModelIndex index) const
 {
     QPointF center = nodeCenter(index, false);
     QPointF leftHandlePos = center + leftHandle(index, false);
     QPointF rightHandlePos = center + rightHandle(index, false);
 
     int minX = qMin(center.x(), leftHandlePos.x()) - NODE_RENDER_RADIUS;
     int maxX = qMax(center.x(), rightHandlePos.x()) + NODE_RENDER_RADIUS;
 
     int minY = qMin(center.y(), qMin(leftHandlePos.y(), rightHandlePos.y())) - NODE_RENDER_RADIUS;
     int maxY = qMax(center.y(), qMax(leftHandlePos.y(), rightHandlePos.y())) + NODE_RENDER_RADIUS;
 
     return QRect(QPoint(minX, minY), QPoint(maxX, maxY));
 }
diff --git a/plugins/dockers/animation/kis_animation_curves_keyframe_delegate.h b/plugins/dockers/animation/kis_animation_curves_keyframe_delegate.h
index 2182b480fa..c1e7a8078a 100644
--- a/plugins/dockers/animation/kis_animation_curves_keyframe_delegate.h
+++ b/plugins/dockers/animation/kis_animation_curves_keyframe_delegate.h
@@ -1,59 +1,61 @@
 /*
  *  Copyright (c) 2016 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef _KIS_ANIMATION_CURVES_KEYFRAME_DELEGATE_H
 #define _KIS_ANIMATION_CURVES_KEYFRAME_DELEGATE_H
 
 #include <qabstractitemdelegate.h>
 
 #include "timeline_ruler_header.h"
 #include "kis_animation_curves_value_ruler.h"
 
 class KisAnimationCurvesKeyframeDelegate : public QAbstractItemDelegate
 {
     Q_OBJECT
 
 public:
     KisAnimationCurvesKeyframeDelegate(const TimelineRulerHeader *horizontalRuler, const KisAnimationCurvesValueRuler *verticalRuler,  QObject *parent);
     ~KisAnimationCurvesKeyframeDelegate() override;
 
     void paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const override;
     QSize sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const override;
 
     QPointF nodeCenter(const QModelIndex index, bool selected) const;
     bool hasHandle(const QModelIndex index, int handle) const;
     QPointF leftHandle(const QModelIndex index, bool active) const;
     QPointF rightHandle(const QModelIndex index, bool active) const;
     void setSelectedItemVisualOffset(QPointF offset);
     void setHandleAdjustment(QPointF offset, int handle);
     QPointF unscaledTangent(QPointF handlePosition) const;
 
     QRect itemRect(const QModelIndex index) const;
+    QRect frameRect(const QModelIndex index) const;
     QRect visualRect(const QModelIndex index) const;
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 
     void paintHandle(QPainter *painter, QPointF nodePos, QPointF tangent) const;
     QPointF handlePosition(const QModelIndex index, bool active, int handle) const;
+
 };
 
 #endif
 
 
diff --git a/plugins/dockers/animation/kis_animation_curves_view.cpp b/plugins/dockers/animation/kis_animation_curves_view.cpp
index 1f6d8e97f5..caadb945ef 100644
--- a/plugins/dockers/animation/kis_animation_curves_view.cpp
+++ b/plugins/dockers/animation/kis_animation_curves_view.cpp
@@ -1,738 +1,788 @@
 /*
  *  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_animation_curves_view.h"
 
 #include <QPaintEvent>
 #include <QMouseEvent>
 #include <QApplication>
 #include <QScrollBar>
 #include <qpainter.h>
 #include <QtMath>
 
 #include "kis_animation_curves_model.h"
 #include "timeline_ruler_header.h"
 #include "kis_animation_curves_value_ruler.h"
 #include "kis_animation_curves_keyframe_delegate.h"
 #include "kis_scalar_keyframe_channel.h"
 #include "kis_zoom_button.h"
 #include "kis_custom_modifiers_catcher.h"
+#include "krita_utils.h"
+
 
 const int VERTICAL_PADDING = 30;
 
 struct KisAnimationCurvesView::Private
 {
     Private()
     {}
 
     KisAnimationCurvesModel *model {0};
     TimelineRulerHeader *horizontalHeader {0};
     KisAnimationCurvesValueRuler *verticalHeader {0};
     KisAnimationCurvesKeyframeDelegate *itemDelegate {0};
     KisZoomButton *horizontalZoomButton {0};
     KisZoomButton *verticalZoomButton {0};
     KisCustomModifiersCatcher *modifiersCatcher {0};
 
     bool isDraggingKeyframe {false};
     bool isAdjustingHandle {false};
     int adjustedHandle {0}; // 0 = left, 1 = right
     QPoint dragStart;
     QPoint dragOffset;
 
     int horizontalZoomStillPointIndex {0};
     int horizontalZoomStillPointOriginalOffset {0};
     qreal verticalZoomStillPoint {0.0};
     qreal verticalZoomStillPointOriginalOffset {0.0};
 
     bool panning {false};
     QPoint panStartOffset;
 };
 
 KisAnimationCurvesView::KisAnimationCurvesView(QWidget *parent)
     : QAbstractItemView(parent)
     , m_d(new Private())
 {
     m_d->horizontalHeader = new TimelineRulerHeader(this);
+
     m_d->verticalHeader = new KisAnimationCurvesValueRuler(this);
     m_d->itemDelegate = new KisAnimationCurvesKeyframeDelegate(m_d->horizontalHeader, m_d->verticalHeader, this);
 
     m_d->modifiersCatcher = new KisCustomModifiersCatcher(this);
     m_d->modifiersCatcher->addModifier("pan-zoom", Qt::Key_Space);
 
     setSelectionMode(QAbstractItemView::ExtendedSelection);
 
     setHorizontalScrollMode(QAbstractItemView::ScrollPerPixel);
     setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
 
     QScroller *scroller = KisKineticScroller::createPreconfiguredScroller(this);
     if (scroller){
         connect(scroller, SIGNAL(stateChanged(QScroller::State)),
                 this, SLOT(slotScrollerStateChanged(QScroller::State)));
     }
+
 }
 
 KisAnimationCurvesView::~KisAnimationCurvesView()
 {}
 
 void KisAnimationCurvesView::setModel(QAbstractItemModel *model)
 {
     m_d->model = dynamic_cast<KisAnimationCurvesModel*>(model);
 
     QAbstractItemView::setModel(model);
     m_d->horizontalHeader->setModel(model);
 
     connect(model, &QAbstractItemModel::rowsInserted,
             this, &KisAnimationCurvesView::slotRowsChanged);
 
     connect(model, &QAbstractItemModel::rowsRemoved,
             this, &KisAnimationCurvesView::slotRowsChanged);
 
     connect(model, &QAbstractItemModel::dataChanged,
             this, &KisAnimationCurvesView::slotDataChanged);
 
     connect(model, &QAbstractItemModel::headerDataChanged,
             this, &KisAnimationCurvesView::slotHeaderDataChanged);
+
 }
 
 void KisAnimationCurvesView::setZoomButtons(KisZoomButton *horizontal, KisZoomButton *vertical)
 {
     m_d->horizontalZoomButton = horizontal;
     m_d->verticalZoomButton = vertical;
 
     connect(horizontal, &KisZoomButton::zoomStarted, this, &KisAnimationCurvesView::slotHorizontalZoomStarted);
     connect(horizontal, &KisZoomButton::zoomLevelChanged, this, &KisAnimationCurvesView::slotHorizontalZoomLevelChanged);
     connect(vertical, &KisZoomButton::zoomStarted, this, &KisAnimationCurvesView::slotVerticalZoomStarted);
     connect(vertical, &KisZoomButton::zoomLevelChanged, this, &KisAnimationCurvesView::slotVerticalZoomLevelChanged);
 }
 
 QRect KisAnimationCurvesView::visualRect(const QModelIndex &index) const
 {
     return m_d->itemDelegate->itemRect(index);
 }
 
 void KisAnimationCurvesView::scrollTo(const QModelIndex &index, QAbstractItemView::ScrollHint hint)
 {
     // TODO
     Q_UNUSED(index);
     Q_UNUSED(hint);
 }
 
 QModelIndex KisAnimationCurvesView::indexAt(const QPoint &point) const
 {
     if (!model()) return QModelIndex();
 
     int time = m_d->horizontalHeader->logicalIndexAt(point.x());
 
     int rows = model()->rowCount();
     for (int row=0; row < rows; row++) {
         QModelIndex index = model()->index(row, time);
 
         if (index.data(KisTimeBasedItemModel::SpecialKeyframeExists).toBool()) {
             QRect nodePos = m_d->itemDelegate->itemRect(index);
 
             if (nodePos.contains(point)) {
                 return index;
             }
         }
     }
 
     return QModelIndex();
 }
 
 void KisAnimationCurvesView::paintEvent(QPaintEvent *e)
 {
     QPainter painter(viewport());
 
     QRect r = e->rect();
     r.translate(dirtyRegionOffset());
 
     int firstFrame = m_d->horizontalHeader->logicalIndexAt(r.left());
     int lastFrame = m_d->horizontalHeader->logicalIndexAt(r.right());
     if (lastFrame == -1) lastFrame = model()->columnCount();
 
+
+    paintFrames(painter);
+
     paintCurves(painter, firstFrame, lastFrame);
     paintKeyframes(painter, firstFrame, lastFrame);
 }
 
+void KisAnimationCurvesView::paintFrames(QPainter &painter)
+{
+    const QColor textColor = qApp->palette().text().color();
+    const QColor backgroundColor = qApp->palette().background().color();
+
+
+    // paint vertical lines so it is easier to tell where each frame starts/stops
+    QColor blendedColor = KritaUtils::blendColors(textColor, backgroundColor, 0.2);
+    painter.setPen(QPen(blendedColor, 1));
+    int channels = model()->rowCount();
+    for (int channel = 0; channel < channels; channel++) {
+
+        // draw border around entire frame, so override the height and Y position
+        for (int time = 0; time <= model()->columnCount(); time++) {
+
+            QModelIndex index = model()->index(channel, time);
+
+            int offset = 0;
+            if (m_d->horizontalHeader && m_d->horizontalHeader->offset()) {
+                offset = m_d->horizontalHeader->offset();
+            }
+
+            int horizontalStepSize = m_d->horizontalHeader->defaultSectionSize();
+            int xPosition = horizontalStepSize * time - offset;
+            QRect frameRect = QRect(xPosition, -10, horizontalStepSize, 9999);
+
+            painter.drawLine(frameRect.topRight(), frameRect.bottomRight());
+        }
+
+    }
+}
+
 void KisAnimationCurvesView::paintCurves(QPainter &painter, int firstFrame, int lastFrame)
 {
     int channels = model()->rowCount();
     for (int channel = 0; channel < channels; channel++) {
         QModelIndex index0 = model()->index(channel, 0);
 
         if (!isIndexHidden(index0)) {
             QColor color = index0.data(KisAnimationCurvesModel::CurveColorRole).value<QColor>();
             painter.setPen(QPen(color, 1));
 
             paintCurve(channel, firstFrame, lastFrame, painter);
         }
     }
 }
 
 void KisAnimationCurvesView::paintCurve(int channel, int firstFrame, int lastFrame, QPainter &painter)
 {
     int selectionOffset = m_d->isDraggingKeyframe ? (m_d->dragOffset.x() / m_d->horizontalHeader->defaultSectionSize()) : 0;
 
     QModelIndex index = findNextKeyframeIndex(channel, firstFrame+1, selectionOffset, true);
     if (!index.isValid()) {
         index = findNextKeyframeIndex(channel, firstFrame, selectionOffset, false);
     }
     if (!index.isValid()) return;
 
     QPointF previousKeyPos = m_d->itemDelegate->nodeCenter(index, selectionModel()->isSelected(index));
     QPointF rightTangent = m_d->itemDelegate->rightHandle(index, index == currentIndex());
 
     while(index.column() <= lastFrame) {
         int interpolationMode = index.data(KisAnimationCurvesModel::InterpolationModeRole).toInt();
 
         int time = (m_d->isDraggingKeyframe && selectionModel()->isSelected(index)) ? index.column() + selectionOffset : index.column();
         index = findNextKeyframeIndex(channel, time, selectionOffset, false);
         if (!index.isValid()) return;
 
         bool active = (index == currentIndex());
         QPointF nextKeyPos = m_d->itemDelegate->nodeCenter(index, selectionModel()->isSelected(index));
         QPointF leftTangent = m_d->itemDelegate->leftHandle(index, active);
 
         if (interpolationMode == KisKeyframe::Constant) {
             painter.drawLine(previousKeyPos, QPointF(nextKeyPos.x(), previousKeyPos.y()));
         } else if (interpolationMode == KisKeyframe::Linear) {
             painter.drawLine(previousKeyPos, nextKeyPos);
         } else {
             paintCurveSegment(painter, previousKeyPos, rightTangent, leftTangent, nextKeyPos);
         }
 
         previousKeyPos = nextKeyPos;
         rightTangent = m_d->itemDelegate->rightHandle(index, active);
     }
 }
 
 void KisAnimationCurvesView::paintCurveSegment(QPainter &painter, QPointF pos1, QPointF rightTangent, QPointF leftTangent, QPointF pos2) {
     const int steps = 16;
     QPointF previousPos;
 
     for (int step = 0; step <= steps; step++) {
         qreal t = 1.0 * step / steps;
 
         QPointF nextPos = KisScalarKeyframeChannel::interpolate(pos1, rightTangent, leftTangent, pos2, t);
 
         if (step > 0) {
             painter.drawLine(previousPos, nextPos);
         }
 
         previousPos = nextPos;
     }
 }
 
 void KisAnimationCurvesView::paintKeyframes(QPainter &painter, int firstFrame, int lastFrame)
 {
     int channels = model()->rowCount();
     for (int channel = 0; channel < channels; channel++) {
         for (int time=firstFrame; time <= lastFrame; time++) {
             QModelIndex index = model()->index(channel, time);
             bool keyframeExists = model()->data(index, KisAnimationCurvesModel::SpecialKeyframeExists).toReal();
 
             if (keyframeExists && !isIndexHidden(index)) {
                 QStyleOptionViewItem opt;
 
                 if (selectionModel()->isSelected(index)) {
                     opt.state |= QStyle::State_Selected;
                 }
 
                 if (index == selectionModel()->currentIndex()) {
                     opt.state |= QStyle::State_HasFocus;
                 }
 
                 m_d->itemDelegate->paint(&painter, opt, index);
             }
         }
     }
 }
 
 QModelIndex KisAnimationCurvesView::findNextKeyframeIndex(int channel, int time, int selectionOffset, bool backward)
 {
     KisAnimationCurvesModel::ItemDataRole role =
             backward ? KisAnimationCurvesModel::PreviousKeyframeTime : KisAnimationCurvesModel::NextKeyframeTime;
     QModelIndex currentIndex = model()->index(channel, time);
 
     if (!selectionOffset) {
         QVariant next = currentIndex.data(role);
         return (next.isValid()) ? model()->index(channel, next.toInt()) : QModelIndex();
     } else {
         // Find the next unselected index
         QModelIndex nextIndex = currentIndex;
         do {
             QVariant next = nextIndex.data(role);
             nextIndex = (next.isValid()) ? model()->index(channel, next.toInt()) : QModelIndex();
         } while(nextIndex.isValid() && selectionModel()->isSelected(nextIndex));
 
         // Find the next selected index, accounting for D&D offset
         QModelIndex draggedIndex = model()->index(channel, qMax(0, time - selectionOffset));
         do {
             QVariant next = draggedIndex.data(role);
             draggedIndex = (next.isValid()) ? model()->index(channel, next.toInt()) : QModelIndex();
         } while(draggedIndex.isValid() && !selectionModel()->isSelected(draggedIndex));
 
         // Choose the earlier of the two
         if (draggedIndex.isValid() && nextIndex.isValid()) {
             if (draggedIndex.column() + selectionOffset <= nextIndex.column()) {
                 return draggedIndex;
             } else {
                 return nextIndex;
             }
         } else if (draggedIndex.isValid()) {
             return draggedIndex;
         } else {
             return nextIndex;
         }
     }
 }
 
 void KisAnimationCurvesView::findExtremes(qreal *minimum, qreal *maximum)
 {
     if (!model()) return;
 
     qreal min = qInf();
     qreal max = -qInf();
 
     int rows = model()->rowCount();
     for (int row = 0; row < rows; row++) {
         QModelIndex index = model()->index(row, 0);
 
         if (isIndexHidden(index)) continue;
 
         QVariant nextTime;
         do {
             qreal value = index.data(KisAnimationCurvesModel::ScalarValueRole).toReal();
 
             if (value < min) min = value;
             if (value > max) max = value;
 
             nextTime = index.data(KisAnimationCurvesModel::NextKeyframeTime);
             if (nextTime.isValid()) index = model()->index(row, nextTime.toInt());
         } while (nextTime.isValid());
     }
 
     if (qIsFinite(min)) *minimum = min;
     if (qIsFinite(max)) *maximum = max;
 }
 
 void KisAnimationCurvesView::updateVerticalRange()
 {
     if (!model()) return;
 
     qreal minimum = 0;
     qreal maximum = 0;
     findExtremes(&minimum, &maximum);
 
     int viewMin = maximum * m_d->verticalHeader->scaleFactor();
     int viewMax = minimum * m_d->verticalHeader->scaleFactor();
 
     viewMin -= VERTICAL_PADDING;
     viewMax += VERTICAL_PADDING;
 
     verticalScrollBar()->setRange(viewMin, viewMax - viewport()->height());
 }
 
 void KisAnimationCurvesView::startPan(QPoint mousePos)
 {
     m_d->dragStart = mousePos;
     m_d->panStartOffset = QPoint(horizontalOffset(), verticalOffset());
     m_d->panning = true;
 }
 
 QModelIndex KisAnimationCurvesView::moveCursor(QAbstractItemView::CursorAction cursorAction, Qt::KeyboardModifiers modifiers)
 {
     // TODO
     Q_UNUSED(cursorAction);
     Q_UNUSED(modifiers);
     return QModelIndex();
 }
 
 int KisAnimationCurvesView::horizontalOffset() const
 {
     return m_d->horizontalHeader->offset();
 }
 
 int KisAnimationCurvesView::verticalOffset() const
 {
     return m_d->verticalHeader->offset();
 }
 
 bool KisAnimationCurvesView::isIndexHidden(const QModelIndex &index) const
 {
     return !index.data(KisAnimationCurvesModel::CurveVisibleRole).toBool();
 }
 
 void KisAnimationCurvesView::setSelection(const QRect &rect, QItemSelectionModel::SelectionFlags command)
 {
     int timeFrom = m_d->horizontalHeader->logicalIndexAt(rect.left());
     int timeTo = m_d->horizontalHeader->logicalIndexAt(rect.right());
 
     QItemSelection selection;
 
     int rows = model()->rowCount();
     for (int row=0; row < rows; row++) {
         for (int time = timeFrom; time <= timeTo; time++) {
             QModelIndex index = model()->index(row, time);
 
             if (index.data(KisTimeBasedItemModel::SpecialKeyframeExists).toBool()) {
                 QRect itemRect = m_d->itemDelegate->itemRect(index);
 
                 if (itemRect.intersects(rect)) {
                     selection.select(index, index);
                 }
             }
         }
     }
 
     selectionModel()->select(selection, command);
 }
 
 QRegion KisAnimationCurvesView::visualRegionForSelection(const QItemSelection &selection) const
 {
     QRegion region;
 
     Q_FOREACH(QModelIndex index, selection.indexes()) {
         region += m_d->itemDelegate->visualRect(index);
     }
 
     return region;
 }
 
 void KisAnimationCurvesView::mousePressEvent(QMouseEvent *e)
 {
     if (m_d->modifiersCatcher->modifierPressed("pan-zoom")) {
         if (e->button() == Qt::LeftButton) {
             startPan(e->pos());
         } else {
             qreal horizontalStaticPoint = m_d->horizontalHeader->logicalIndexAt(e->pos().x());
             qreal verticalStaticPoint = m_d->verticalHeader->mapViewToValue(e->pos().y());
 
             m_d->horizontalZoomButton->beginZoom(QPoint(e->pos().x(), 0), horizontalStaticPoint);
             m_d->verticalZoomButton->beginZoom(QPoint(0, e->pos().y()), verticalStaticPoint);
         }
     } else if (e->button() == Qt::LeftButton) {
         m_d->dragStart = e->pos();
 
         Q_FOREACH(QModelIndex index, selectedIndexes()) {
             QPointF center = m_d->itemDelegate->nodeCenter(index, false);
             bool hasLeftHandle = m_d->itemDelegate->hasHandle(index, 0);
             bool hasRightHandle = m_d->itemDelegate->hasHandle(index, 1);
 
             QPointF leftHandle = center + m_d->itemDelegate->leftHandle(index, false);
             QPointF rightHandle = center + m_d->itemDelegate->rightHandle(index, false);
 
             if (hasLeftHandle && (e->localPos() - leftHandle).manhattanLength() < 8) {
                 m_d->isAdjustingHandle = true;
                 m_d->adjustedHandle = 0;
                 setCurrentIndex(index);
                 return;
             } else if (hasRightHandle && (e->localPos() - rightHandle).manhattanLength() < 8) {
                 m_d->isAdjustingHandle = true;
                 m_d->adjustedHandle = 1;
                 setCurrentIndex(index);
                 return;
             }
         }
     }
 
     QAbstractItemView::mousePressEvent(e);
 }
 
 void KisAnimationCurvesView::mouseMoveEvent(QMouseEvent *e)
 {
     if (m_d->modifiersCatcher->modifierPressed("pan-zoom")) {
         if (e->buttons() & Qt::LeftButton) {
             if (!m_d->panning) startPan(e->pos());
 
             QPoint diff = e->pos() - m_d->dragStart;
             QPoint newOffset = m_d->panStartOffset - diff;
 
             horizontalScrollBar()->setValue(newOffset.x());
             verticalScrollBar()->setValue(newOffset.y());
             m_d->verticalHeader->setOffset(newOffset.y());
             viewport()->update();
         } else {
             m_d->horizontalZoomButton->continueZoom(QPoint(e->pos().x(), 0));
             m_d->verticalZoomButton->continueZoom(QPoint(0, e->pos().y()));
         }
     } else if (e->buttons() & Qt::LeftButton) {
+
         m_d->dragOffset = e->pos() - m_d->dragStart;
 
         if (m_d->isAdjustingHandle) {
             m_d->itemDelegate->setHandleAdjustment(m_d->dragOffset, m_d->adjustedHandle);
             viewport()->update();
             return;
         } else if (m_d->isDraggingKeyframe) {
             m_d->itemDelegate->setSelectedItemVisualOffset(m_d->dragOffset);
             viewport()->update();
             return;
         } else if (selectionModel()->hasSelection()) {
             if ((e->pos() - m_d->dragStart).manhattanLength() > QApplication::startDragDistance()) {
                 m_d->isDraggingKeyframe = true;
             }
         }
     }
 
     QAbstractItemView::mouseMoveEvent(e);
 }
 
 void KisAnimationCurvesView::mouseReleaseEvent(QMouseEvent *e)
 {
+
     if (e->button() == Qt::LeftButton) {
         m_d->panning = false;
 
         if (m_d->isDraggingKeyframe) {
             QModelIndexList indexes = selectedIndexes();
             int timeOffset = m_d->dragOffset.x() / m_d->horizontalHeader->defaultSectionSize();
             qreal valueOffset = m_d->dragOffset.y() / m_d->verticalHeader->scaleFactor();
 
             KisAnimationCurvesModel *curvesModel = dynamic_cast<KisAnimationCurvesModel*>(model());
             curvesModel->adjustKeyframes(indexes, timeOffset, valueOffset);
 
             m_d->isDraggingKeyframe = false;
             m_d->itemDelegate->setSelectedItemVisualOffset(QPointF());
             viewport()->update();
         } else if (m_d->isAdjustingHandle) {
             QModelIndex index = currentIndex();
             int mode = index.data(KisAnimationCurvesModel::TangentsModeRole).toInt();
 
             m_d->model->beginCommand(kundo2_i18n("Adjust tangent"));
 
             if (mode == KisKeyframe::Smooth) {
                 QPointF leftHandle = m_d->itemDelegate->leftHandle(index, true);
                 QPointF rightHandle = m_d->itemDelegate->rightHandle(index, true);
 
                 QPointF leftTangent = m_d->itemDelegate->unscaledTangent(leftHandle);
                 QPointF rightTangent = m_d->itemDelegate->unscaledTangent(rightHandle);
 
                 model()->setData(index, leftTangent, KisAnimationCurvesModel::LeftTangentRole);
                 model()->setData(index, rightTangent, KisAnimationCurvesModel::RightTangentRole);
             } else {
                 if (m_d->adjustedHandle == 0) {
                     QPointF leftHandle = m_d->itemDelegate->leftHandle(index, true);
                     model()->setData(index, m_d->itemDelegate->unscaledTangent(leftHandle), KisAnimationCurvesModel::LeftTangentRole);
                 } else {
                     QPointF rightHandle = m_d->itemDelegate->rightHandle(index, true);
                     model()->setData(index, m_d->itemDelegate->unscaledTangent(rightHandle), KisAnimationCurvesModel::RightTangentRole);
                 }
             }
 
             m_d->model->endCommand();
 
             m_d->isAdjustingHandle = false;
             m_d->itemDelegate->setHandleAdjustment(QPointF(), m_d->adjustedHandle);
         }
     }
 
     QAbstractItemView::mouseReleaseEvent(e);
 }
 
 void KisAnimationCurvesView::scrollContentsBy(int dx, int dy)
 {
     m_d->horizontalHeader->setOffset(horizontalScrollBar()->value());
     m_d->verticalHeader->setOffset(verticalScrollBar()->value());
 
     scrollDirtyRegion(dx, dy);
     viewport()->scroll(dx, dy);
+    viewport()->update();
 }
 
 void KisAnimationCurvesView::updateGeometries()
 {
     int topMargin = qMax(m_d->horizontalHeader->minimumHeight(),
                          m_d->horizontalHeader->sizeHint().height());
 
     int leftMargin = m_d->verticalHeader->sizeHint().width();
 
     setViewportMargins(leftMargin, topMargin, 0, 0);
 
     QRect viewRect = viewport()->geometry();
     m_d->horizontalHeader->setGeometry(leftMargin, 0, viewRect.width(), topMargin);
     m_d->verticalHeader->setGeometry(0, topMargin, leftMargin, viewRect.height());
 
     horizontalScrollBar()->setRange(0, m_d->horizontalHeader->length() - viewport()->width());
     updateVerticalRange();
 
     QAbstractItemView::updateGeometries();
 }
 
 void KisAnimationCurvesView::slotRowsChanged(const QModelIndex &parentIndex, int first, int last)
 {
     Q_UNUSED(parentIndex);
     Q_UNUSED(first);
     Q_UNUSED(last);
 
     updateVerticalRange();
     viewport()->update();
 }
 
 void KisAnimationCurvesView::slotDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight)
 {
     Q_UNUSED(topLeft);
     Q_UNUSED(bottomRight);
+
     updateVerticalRange();
     viewport()->update();
+
+    // this forces the horizontal ruler to refresh. Repaint() doesn't do it for some reason
+    // If you remove this, scrubbing the timeline will probably stop updating the indicator
+    m_d->horizontalHeader->resize(m_d->horizontalHeader->width()-1, m_d->horizontalHeader->height());
+    m_d->horizontalHeader->resize(m_d->horizontalHeader->width()+1, m_d->horizontalHeader->height());
 }
 
 void KisAnimationCurvesView::slotHeaderDataChanged(Qt::Orientation orientation, int first, int last)
 {
     Q_UNUSED(orientation);
     Q_UNUSED(first);
     Q_UNUSED(last);
     viewport()->update();
 }
 
 void KisAnimationCurvesView::slotHorizontalZoomStarted(qreal staticPoint)
 {
     m_d->horizontalZoomStillPointIndex =
         qIsNaN(staticPoint) ? currentIndex().column() : staticPoint;
 
     const int w = m_d->horizontalHeader->defaultSectionSize();
 
     m_d->horizontalZoomStillPointOriginalOffset =
         w * m_d->horizontalZoomStillPointIndex -
         horizontalScrollBar()->value();
 }
 
 void KisAnimationCurvesView::slotHorizontalZoomLevelChanged(qreal zoomLevel)
 {
     if (m_d->horizontalHeader->setZoom(zoomLevel)) {
         const int w = m_d->horizontalHeader->defaultSectionSize();
         horizontalScrollBar()->setValue(w * m_d->horizontalZoomStillPointIndex - m_d->horizontalZoomStillPointOriginalOffset);
 
         viewport()->update();
     }
 }
 
 void KisAnimationCurvesView::slotVerticalZoomStarted(qreal staticPoint)
 {
     m_d->verticalZoomStillPoint = qIsNaN(staticPoint) ? 0 : staticPoint;
 
     const float scale = m_d->verticalHeader->scaleFactor();
 
     m_d->verticalZoomStillPointOriginalOffset =
         scale * m_d->verticalZoomStillPoint - m_d->verticalHeader->offset();
 }
 
 void KisAnimationCurvesView::slotVerticalZoomLevelChanged(qreal zoomLevel)
 {
     if (!qFuzzyCompare((float)zoomLevel, m_d->verticalHeader->scaleFactor())) {
         m_d->verticalHeader->setScale(zoomLevel);
         m_d->verticalHeader->setOffset(-zoomLevel * m_d->verticalZoomStillPoint - m_d->verticalZoomStillPointOriginalOffset);
         verticalScrollBar()->setValue(m_d->verticalHeader->offset());
 
         viewport()->update();
     }
 }
 
 void KisAnimationCurvesView::applyConstantMode()
 {
     m_d->model->beginCommand(kundo2_i18n("Set interpolation mode"));
     Q_FOREACH(QModelIndex index, selectedIndexes()) {
         m_d->model->setData(index, KisKeyframe::Constant, KisAnimationCurvesModel::InterpolationModeRole);
     }
     m_d->model->endCommand();
 }
 
 void KisAnimationCurvesView::applyLinearMode()
 {
     m_d->model->beginCommand(kundo2_i18n("Set interpolation mode"));
     Q_FOREACH(QModelIndex index, selectedIndexes()) {
         m_d->model->setData(index, KisKeyframe::Linear, KisAnimationCurvesModel::InterpolationModeRole);
     }
     m_d->model->endCommand();
 }
 
 void KisAnimationCurvesView::applyBezierMode()
 {
     m_d->model->beginCommand(kundo2_i18n("Set interpolation mode"));
     Q_FOREACH(QModelIndex index, selectedIndexes()) {
         m_d->model->setData(index, KisKeyframe::Bezier, KisAnimationCurvesModel::InterpolationModeRole);
     }
     m_d->model->endCommand();
 }
 
 void KisAnimationCurvesView::applySmoothMode()
 {
     m_d->model->beginCommand(kundo2_i18n("Set interpolation mode"));
     Q_FOREACH(QModelIndex index, selectedIndexes()) {
         QVector2D leftVisualTangent(m_d->itemDelegate->leftHandle(index, false));
         QVector2D rightVisualTangent(m_d->itemDelegate->rightHandle(index, false));
 
         if (leftVisualTangent.lengthSquared() > 0 && rightVisualTangent.lengthSquared() > 0) {
             float leftAngle = qAtan2(-leftVisualTangent.y(), -leftVisualTangent.x());
             float rightAngle = qAtan2(rightVisualTangent.y(), rightVisualTangent.x());
             float angle = (leftAngle + rightAngle) / 2;
             QVector2D unit(qCos(angle), qSin(angle));
 
             leftVisualTangent = -unit * QVector2D(leftVisualTangent).length();
             rightVisualTangent = unit * QVector2D(rightVisualTangent).length();
 
             QPointF leftTangent = m_d->itemDelegate->unscaledTangent(leftVisualTangent.toPointF());
             QPointF rightTangent = m_d->itemDelegate->unscaledTangent(rightVisualTangent.toPointF());
 
             model()->setData(index, leftTangent, KisAnimationCurvesModel::LeftTangentRole);
             model()->setData(index, rightTangent, KisAnimationCurvesModel::RightTangentRole);
         }
 
         model()->setData(index, KisKeyframe::Smooth, KisAnimationCurvesModel::TangentsModeRole);
     }
     m_d->model->endCommand();
 }
 
 void KisAnimationCurvesView::applySharpMode()
 {
     m_d->model->beginCommand(kundo2_i18n("Set interpolation mode"));
     Q_FOREACH(QModelIndex index, selectedIndexes()) {
         model()->setData(index, KisKeyframe::Sharp, KisAnimationCurvesModel::TangentsModeRole);
     }
     m_d->model->endCommand();
 }
 
 void KisAnimationCurvesView::createKeyframe()
 {
     QModelIndex active = currentIndex();
     int channel = active.isValid() ? active.row() : 0;
 
     int time = m_d->model->currentTime();
     QModelIndex index = m_d->model->index(channel, time);
 
     qreal value = index.data(KisAnimationCurvesModel::ScalarValueRole).toReal();
     m_d->model->setData(index, value, KisAnimationCurvesModel::ScalarValueRole);
 }
 
 void KisAnimationCurvesView::removeKeyframes()
 {
     m_d->model->removeFrames(selectedIndexes());
 }
 
+
 void KisAnimationCurvesView::zoomToFit()
 {
     if (!model()) return;
 
     qreal minimum, maximum;
     findExtremes(&minimum, &maximum);
     if (minimum == maximum) return;
 
     qreal zoomLevel = (viewport()->height() - 2 * VERTICAL_PADDING) / (maximum - minimum);
     qreal offset = -VERTICAL_PADDING - zoomLevel * maximum;
 
     m_d->verticalHeader->setScale(zoomLevel);
     m_d->verticalHeader->setOffset(offset);
     verticalScrollBar()->setValue(offset);
     viewport()->update();
 }
diff --git a/plugins/dockers/animation/kis_animation_curves_view.h b/plugins/dockers/animation/kis_animation_curves_view.h
index adbff9f7b9..1b666930ed 100644
--- a/plugins/dockers/animation/kis_animation_curves_view.h
+++ b/plugins/dockers/animation/kis_animation_curves_view.h
@@ -1,100 +1,103 @@
 /*
  *  Copyright (c) 2016 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef _KIS_ANIMATION_CURVES_VIEW_H
 #define _KIS_ANIMATION_CURVES_VIEW_H
 
 #include <QScopedPointer>
 #include <QTableView>
 #include <KisKineticScroller.h>
 
 class KisAction;
 class KisZoomButton;
 
 class KisAnimationCurvesView : public QAbstractItemView
 {
     Q_OBJECT
 public:
     KisAnimationCurvesView(QWidget *parent);
     ~KisAnimationCurvesView() override;
 
     void setModel(QAbstractItemModel *model) override;
     void setZoomButtons(KisZoomButton *horizontal, KisZoomButton *vertical);
 
     QRect visualRect(const QModelIndex &index) const override;
     void scrollTo(const QModelIndex &index, ScrollHint hint) override;
     QModelIndex indexAt(const QPoint &point) const override;
 
 protected:
     void paintEvent(QPaintEvent *) override;
     QModelIndex moveCursor(CursorAction cursorAction, Qt::KeyboardModifiers modifiers) override;
     int horizontalOffset() const override;
     int verticalOffset() const override;
     bool isIndexHidden(const QModelIndex &index) const override;
     void setSelection(const QRect &rect, QItemSelectionModel::SelectionFlags command) override;
     QRegion visualRegionForSelection(const QItemSelection &selection) const override;
     void scrollContentsBy(int dx, int dy) override;
 
     void mousePressEvent(QMouseEvent *) override;
     void mouseMoveEvent(QMouseEvent *) override;
     void mouseReleaseEvent(QMouseEvent *) override;
 
 public Q_SLOTS:
     void applyConstantMode();
     void applyLinearMode();
     void applyBezierMode();
     void applySmoothMode();
     void applySharpMode();
 
     void createKeyframe();
     void removeKeyframes();
 
     void zoomToFit();
 
     void slotScrollerStateChanged(QScroller::State state){KisKineticScroller::updateCursor(this, state);}
 
 protected Q_SLOTS:
     void updateGeometries() override;
 
 private Q_SLOTS:
     void slotRowsChanged(const QModelIndex &parentIndex, int first, int last);
     void slotDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight);
     void slotHeaderDataChanged(Qt::Orientation orientation, int first, int last);
 
     void slotHorizontalZoomStarted(qreal staticPoint);
     void slotVerticalZoomStarted(qreal staticPoint);
     void slotHorizontalZoomLevelChanged(qreal level);
     void slotVerticalZoomLevelChanged(qreal level);
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 
+    void paintFrames(QPainter &painter);
     void paintCurves(QPainter &painter, int firstFrame, int lastFrame);
     void paintCurve(int channel, int firstFrame, int lastFrame, QPainter &painter);
     void paintCurveSegment(QPainter &painter, QPointF pos1, QPointF rightTangent, QPointF leftTangent, QPointF pos2);
     void paintKeyframes(QPainter &painter, int firstFrame, int lastFrame);
     QModelIndex findNextKeyframeIndex(int channel, int time, int selectionOffset, bool backward);
 
     void findExtremes(qreal *minimum, qreal *maximum);
     void updateVerticalRange();
 
+
+
     void startPan(QPoint mousePos);
 };
 
 #endif
diff --git a/plugins/dockers/animation/kis_animation_utils.cpp b/plugins/dockers/animation/kis_animation_utils.cpp
index 82a19a0b6e..b436ade6de 100644
--- a/plugins/dockers/animation/kis_animation_utils.cpp
+++ b/plugins/dockers/animation/kis_animation_utils.cpp
@@ -1,354 +1,354 @@
 /*
  *  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_animation_utils.h"
 
 #include "kundo2command.h"
 #include "kis_algebra_2d.h"
 #include "kis_image.h"
 #include "kis_node.h"
 #include "kis_keyframe_channel.h"
 #include "kis_post_execution_undo_adapter.h"
 #include "kis_global.h"
 #include "kis_tool_utils.h"
 #include "kis_image_animation_interface.h"
 #include "kis_command_utils.h"
 #include "kis_processing_applicator.h"
 #include "kis_transaction.h"
 
 
 namespace KisAnimationUtils {
-    const QString addFrameActionName = i18n("New Frame");
-    const QString duplicateFrameActionName = i18n("Copy Frame");
-    const QString removeFrameActionName = i18n("Remove Frame");
-    const QString removeFramesActionName = i18n("Remove Frames");
     const QString lazyFrameCreationActionName = i18n("Auto Frame Mode");
     const QString dropFramesActionName = i18n("Drop Frames");
-    const QString showLayerActionName = i18n("Show in Timeline");
 
     const QString newLayerActionName = i18n("New Layer");
     const QString addExistingLayerActionName = i18n("Add Existing Layer");
     const QString removeLayerActionName = i18n("Remove Layer");
 
-    const QString addOpacityKeyframeActionName = i18n("Add opacity keyframe");
     const QString addTransformKeyframeActionName = i18n("Add transform keyframe");
-    const QString removeOpacityKeyframeActionName = i18n("Remove opacity keyframe");
     const QString removeTransformKeyframeActionName = i18n("Remove transform keyframe");
 
     KUndo2Command* createKeyframeCommand(KisImageSP image, KisNodeSP node, const QString &channelId, int time, bool copy, KUndo2Command *parentCommand) {
         KUndo2Command *cmd = new KisCommandUtils::LambdaCommand(
             copy ? kundo2_i18n("Copy Keyframe") :
                    kundo2_i18n("Add Keyframe"),
             parentCommand,
 
             [image, node, channelId, time, copy] () mutable -> KUndo2Command* {
                 bool result = false;
 
                 QScopedPointer<KUndo2Command> cmd(new KUndo2Command());
 
                 KisKeyframeChannel *channel = node->getKeyframeChannel(channelId);
+                quint8 originalOpacity = node->opacity();
                 bool createdChannel = false;
 
                 if (!channel) {
                     node->enableAnimation();
                     channel = node->getKeyframeChannel(channelId, true);
                     if (!channel) return nullptr;
 
                     createdChannel = true;
                 }
 
                 if (copy) {
                     if (!channel->keyframeAt(time)) {
                         KisKeyframeSP srcFrame = channel->activeKeyframeAt(time);
                         channel->copyKeyframe(srcFrame, time, cmd.data());
                         result = true;
                     }
                 } else {
                     if (channel->keyframeAt(time) && !createdChannel) {
                         if (image->animationInterface()->currentTime() == time && channelId == KisKeyframeChannel::Content.id()) {
 
                             //shortcut: clearing the image instead
                             KisPaintDeviceSP device = node->paintDevice();
                             if (device) {
                                 const QRect dirtyRect = device->extent();
 
                                 KisTransaction transaction(kundo2_i18n("Clear"), device, cmd.data());
                                 device->clear();
                                 (void) transaction.endAndTake(); // saved as 'parent'
 
                                 node->setDirty(dirtyRect);
 
                                 result = true;
                             }
                         }
                     } else {
                         channel->addKeyframe(time, cmd.data());
                         result = true;
                     }
                 }
 
+                // when a new opacity keyframe is created, the opacity is set to 0
+                // this makes sure to use the opacity that was previously used
+                // maybe there is a better way to do this
+                node->setOpacity(originalOpacity);
+
                 return result ? new KisCommandUtils::SkipFirstRedoWrapper(cmd.take()) : nullptr;
         });
 
         return cmd;
     }
 
-    void createKeyframeLazy(KisImageSP image, KisNodeSP node, const QString &channelId, int time, bool copy) {
+    void createKeyframeLazy(KisImageSP image, KisNodeSP node, const QString &channelId, int time, bool copy)
+    {
         KUndo2Command *cmd = createKeyframeCommand(image, node, channelId, time, copy);
         KisProcessingApplicator::runSingleCommandStroke(image, cmd,
                                                         KisStrokeJobData::BARRIER,
                                                         KisStrokeJobData::EXCLUSIVE);
     }
 
     void removeKeyframes(KisImageSP image, const FrameItemList &frames) {
         KIS_SAFE_ASSERT_RECOVER_RETURN(!image->locked());
 
         KUndo2Command *cmd = new KisCommandUtils::LambdaCommand(
             kundo2_i18np("Remove Keyframe",
                          "Remove Keyframes",
                          frames.size()),
 
             [image, frames] () {
                 bool result = false;
 
                 QScopedPointer<KUndo2Command> cmd(new KUndo2Command());
 
                 Q_FOREACH (const FrameItem &item, frames) {
                     const int time = item.time;
                     KisNodeSP node = item.node;
                     KisKeyframeChannel *channel = 0;
                     if (node) {
                         channel = node->getKeyframeChannel(item.channel);
                     }
                     if (!channel) continue;
 
                     KisKeyframeSP keyframe = channel->keyframeAt(time);
                     if (!keyframe) continue;
 
                     channel->deleteKeyframe(keyframe, cmd.data());
 
                     result = true;
                 }
 
                 return result ? new KisCommandUtils::SkipFirstRedoWrapper(cmd.take()) : 0;
         });
 
         KisProcessingApplicator::runSingleCommandStroke(image, cmd,
                                                         KisStrokeJobData::BARRIER,
                                                         KisStrokeJobData::EXCLUSIVE);
     }
 
     void removeKeyframe(KisImageSP image, KisNodeSP node, const QString &channel, int time) {
         QVector<FrameItem> frames;
         frames << FrameItem(node, channel, time);
         removeKeyframes(image, frames);
     }
 
 
     struct LessOperator {
         LessOperator(const QPoint &offset)
             : m_columnCoeff(-KisAlgebra2D::signPZ(offset.x())),
               m_rowCoeff(-1000000 * KisAlgebra2D::signZZ(offset.y()))
         {
         }
 
         bool operator()(const QModelIndex &lhs, const QModelIndex &rhs) {
             return
                 m_columnCoeff * lhs.column() + m_rowCoeff * lhs.row() <
                 m_columnCoeff * rhs.column() + m_rowCoeff * rhs.row();
         }
 
     private:
         int m_columnCoeff;
         int m_rowCoeff;
     };
 
     void sortPointsForSafeMove(QModelIndexList *points, const QPoint &offset)
     {
         std::sort(points->begin(), points->end(), LessOperator(offset));
     }
 
     bool supportsContentFrames(KisNodeSP node)
     {
         return node->inherits("KisPaintLayer") || node->inherits("KisFilterMask") || node->inherits("KisTransparencyMask") || node->inherits("KisSelectionBasedLayer");
     }
 
     void swapOneFrameItem(const FrameItem &src, const FrameItem &dst, KUndo2Command *parentCommand)
     {
         const int srcTime = src.time;
         KisNodeSP srcNode = src.node;
         KisKeyframeChannel *srcChannel = srcNode->getKeyframeChannel(src.channel);
 
         const int dstTime = dst.time;
         KisNodeSP dstNode = dst.node;
         KisKeyframeChannel *dstChannel = dstNode->getKeyframeChannel(dst.channel, true);
 
         if (srcNode == dstNode) {
             if (!srcChannel) return; // TODO: add warning!
 
             srcChannel->swapFrames(srcTime, dstTime, parentCommand);
         } else {
             if (!srcChannel || !dstChannel) return; // TODO: add warning!
 
             dstChannel->swapExternalKeyframe(srcChannel, srcTime, dstTime, parentCommand);
         }
     }
 
     void moveOneFrameItem(const FrameItem &src, const FrameItem &dst, bool copy, bool moveEmptyFrames, KUndo2Command *parentCommand)
     {
         const int srcTime = src.time;
         KisNodeSP srcNode = src.node;
         KisKeyframeChannel *srcChannel = srcNode->getKeyframeChannel(src.channel);
 
         const int dstTime = dst.time;
         KisNodeSP dstNode = dst.node;
         KisKeyframeChannel *dstChannel = dstNode->getKeyframeChannel(dst.channel, true);
 
         if (srcNode == dstNode) {
             if (!srcChannel) return; // TODO: add warning!
 
             KisKeyframeSP srcKeyframe = srcChannel->keyframeAt(srcTime);
             KisKeyframeSP dstKeyFrame = srcChannel->keyframeAt(dstTime);
             if (srcKeyframe) {
                 if (copy) {
                     srcChannel->copyKeyframe(srcKeyframe, dstTime, parentCommand);
                 } else {
                     srcChannel->moveKeyframe(srcKeyframe, dstTime, parentCommand);
                 }
             } else {
                 if (dstKeyFrame && moveEmptyFrames && !copy) {
                     //Destination is effectively replaced by an empty frame.
                     dstChannel->deleteKeyframe(dstKeyFrame, parentCommand);
                 }
             }
         } else {
             if (!srcChannel || !dstChannel) return; // TODO: add warning!
 
             KisKeyframeSP srcKeyframe = srcChannel->keyframeAt(srcTime);
 
             if (!srcKeyframe) return; // TODO: add warning!
 
             dstChannel->copyExternalKeyframe(srcChannel, srcTime, dstTime, parentCommand);
 
             if (!copy) {
                 srcChannel->deleteKeyframe(srcKeyframe, parentCommand);
             }
         }
     }
 
     KUndo2Command* createMoveKeyframesCommand(const FrameItemList &srcFrames,
                                               const FrameItemList &dstFrames,
                                               bool copy,
                                               bool moveEmpty,
                                               KUndo2Command *parentCommand)
     {
         FrameMovePairList srcDstPairs;
         for (int i = 0; i < srcFrames.size(); i++) {
             srcDstPairs << std::make_pair(srcFrames[i], dstFrames[i]);
         }
         return createMoveKeyframesCommand(srcDstPairs, copy, moveEmpty, parentCommand);
     }
 
     KUndo2Command* createMoveKeyframesCommand(const FrameMovePairList &srcDstPairs,
                                               bool copy,
                                               bool moveEmptyFrames,
                                               KUndo2Command *parentCommand)
     {
         KUndo2Command *cmd = new KisCommandUtils::LambdaCommand(
 
             !copy ?
                 kundo2_i18np("Move Keyframe",
                              "Move %1 Keyframes",
                              srcDstPairs.size()) :
                 kundo2_i18np("Copy Keyframe",
                              "Copy %1 Keyframes",
                              srcDstPairs.size()),
 
             parentCommand,
 
             [srcDstPairs, copy, moveEmptyFrames] () -> KUndo2Command* {
                 bool result = false;
 
                 QScopedPointer<KUndo2Command> cmd(new KUndo2Command());
 
                 using MoveChain = QList<FrameItem>;
                 QHash<FrameItem, MoveChain> moveMap;
                 Q_FOREACH (const FrameMovePair &pair, srcDstPairs) {
                     moveMap.insert(pair.first, {pair.second});
                 }
 
                 auto it = moveMap.begin();
                 while (it != moveMap.end()) {
                     MoveChain &chain = it.value();
                     const FrameItem &previousFrame = chain.last();
 
                     auto tailIt = moveMap.find(previousFrame);
 
                     if (tailIt == it || tailIt == moveMap.end()) {
                         ++it;
                         continue;
                     }
 
                     chain.append(tailIt.value());
                     tailIt = moveMap.erase(tailIt);
                     // no incrementing! we are going to check the new tail now!
                 }
 
                 for (it = moveMap.begin(); it != moveMap.end(); ++it) {
                     MoveChain &chain = it.value();
                     chain.prepend(it.key());
                     KIS_SAFE_ASSERT_RECOVER(chain.size() > 1) { continue; }
 
                     bool isCycle = false;
                     if (chain.last() == chain.first()) {
                         isCycle = true;
                         chain.takeLast();
                     }
 
                     auto frameIt = chain.rbegin();
 
                     FrameItem dstItem = *frameIt++;
 
                     while (frameIt != chain.rend()) {
                         FrameItem srcItem = *frameIt++;
 
                         if (!isCycle) {
                             moveOneFrameItem(srcItem, dstItem, copy, moveEmptyFrames, cmd.data());
                         } else {
                             swapOneFrameItem(srcItem, dstItem, cmd.data());
                         }
 
                         dstItem = srcItem;
                         result = true;
                     }
                 }
 
                 return result ? new KisCommandUtils::SkipFirstRedoWrapper(cmd.take()) : 0;
         });
 
         return cmd;
     }
 
     QDebug operator<<(QDebug dbg, const FrameItem &item)
     {
         dbg.nospace() << "FrameItem(" << item.node->name() << ", " << item.channel << ", " << item.time << ")";
         return dbg.space();
     }
 
 }
 
diff --git a/plugins/dockers/animation/kis_animation_utils.h b/plugins/dockers/animation/kis_animation_utils.h
index aa86fc14a2..0cf8d07720 100644
--- a/plugins/dockers/animation/kis_animation_utils.h
+++ b/plugins/dockers/animation/kis_animation_utils.h
@@ -1,104 +1,99 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KIS_ANIMATION_UTILS_H
 #define __KIS_ANIMATION_UTILS_H
 
 #include "kis_types.h"
 
 #include <boost/operators.hpp>
 #include <QModelIndexList>
 
 #include <kritaanimationdocker_export.h>
 
 
 namespace KisAnimationUtils
 {
     KUndo2Command* createKeyframeCommand(KisImageSP image, KisNodeSP node, const QString &channelId, int time, bool copy, KUndo2Command *parentCommand = 0);
     void createKeyframeLazy(KisImageSP image, KisNodeSP node, const QString &channel, int time, bool copy);
 
     struct KRITAANIMATIONDOCKER_EXPORT FrameItem : public boost::equality_comparable<FrameItem>
     {
         FrameItem() : time(-1) {}
         FrameItem(KisNodeSP _node, const QString &_channel, int _time) : node(_node), channel(_channel), time(_time) {}
 
         bool operator==(const FrameItem &rhs) const {
             return rhs.node == node && rhs.channel == channel && rhs.time == time;
         }
 
         KisNodeSP node;
         QString channel;
         int time;
     };
 
     KRITAANIMATIONDOCKER_EXPORT QDebug operator<<(QDebug dbg, const FrameItem &item);
 
     inline uint qHash(const FrameItem &item)
     {
         return ::qHash(item.node.data()) + ::qHash(item.channel) + ::qHash(item.time);
     }
 
 
     typedef QVector<FrameItem> FrameItemList;
     typedef std::pair<FrameItem, FrameItem> FrameMovePair;
     typedef QVector<FrameMovePair> FrameMovePairList;
 
 
     void removeKeyframes(KisImageSP image, const FrameItemList &frames);
     void removeKeyframe(KisImageSP image, KisNodeSP node, const QString &channel, int time);
 
     void sortPointsForSafeMove(QModelIndexList *points, const QPoint &offset);
 
     KUndo2Command* createMoveKeyframesCommand(const FrameItemList &srcFrames, const FrameItemList &dstFrames,
                                               bool copy, bool moveEmpty, KUndo2Command *parentCommand = 0);
 
 
     /**
      * @brief implements safe moves of the frames (even if there are cycling move dependencies)
      * @param movePairs the jobs for the moves
      * @param copy shows if the frames should be copied or not
      * @param moveEmpty allows an empty frame to replace a populated one
      * @param parentCommand the command that should be a parent of the created command
      * @return a created undo command
      */
     KRITAANIMATIONDOCKER_EXPORT
     KUndo2Command* createMoveKeyframesCommand(const FrameMovePairList &movePairs,
                                               bool copy, bool moveEmptyFrames, KUndo2Command *parentCommand = 0);
 
     bool supportsContentFrames(KisNodeSP node);
 
-    extern const QString addFrameActionName;
-    extern const QString duplicateFrameActionName;
-    extern const QString removeFrameActionName;
-    extern const QString removeFramesActionName;
     extern const QString lazyFrameCreationActionName;
     extern const QString dropFramesActionName;
-    extern const QString showLayerActionName;
 
     extern const QString newLayerActionName;
     extern const QString addExistingLayerActionName;
     extern const QString removeLayerActionName;
 
     extern const QString addOpacityKeyframeActionName;
     extern const QString addTransformKeyframeActionName;
     extern const QString removeOpacityKeyframeActionName;
     extern const QString removeTransformKeyframeActionName;
 };
 
 
 #endif /* __KIS_ANIMATION_UTILS_H */
diff --git a/plugins/dockers/animation/kis_time_based_item_model.cpp b/plugins/dockers/animation/kis_time_based_item_model.cpp
index 38f429ecf3..7fe0fa950a 100644
--- a/plugins/dockers/animation/kis_time_based_item_model.cpp
+++ b/plugins/dockers/animation/kis_time_based_item_model.cpp
@@ -1,516 +1,524 @@
 /*
  *  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"
+#include "KisPart.h"
+#include "kis_animation_cache_populator.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)
 {
     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,
                                                     KisStrokeJobData::EXCLUSIVE);
     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,
                                                     KisStrokeJobData::EXCLUSIVE);
     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) {
+        const int currentFrame = m_d->image->animationInterface()->currentUITime();
+        const bool hasCurrentFrameInCache = m_d->framesCache->frameStatus(currentFrame) == KisAnimationFrameCache::Cached;
+        if(!hasCurrentFrameInCache) {
+            KisPart::instance()->prioritizeFrameForCache(m_d->image, currentFrame);
+        }
+
         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_view.cpp b/plugins/dockers/animation/timeline_frames_view.cpp
index bab6a9b8ed..8173407cf5 100644
--- a/plugins/dockers/animation/timeline_frames_view.cpp
+++ b/plugins/dockers/animation/timeline_frames_view.cpp
@@ -1,1547 +1,1564 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "timeline_frames_view.h"
 
 #include "timeline_frames_model.h"
 #include "timeline_ruler_header.h"
 #include "timeline_layers_header.h"
 #include "timeline_insert_keyframe_dialog.h"
 #include "timeline_frames_item_delegate.h"
 
 #include <QPainter>
 #include <QApplication>
 #include <QDropEvent>
 #include <QMenu>
 #include <QScrollBar>
 #include <QScroller>
 #include <QDrag>
 #include <QInputDialog>
 #include <QClipboard>
 #include <QMimeData>
 #include "config-qtmultimedia.h"
 
 #include "KSharedConfig"
 #include "KisKineticScroller.h"
 
 #include "kis_zoom_button.h"
 #include "kis_icon_utils.h"
 #include "kis_animation_utils.h"
 #include "kis_custom_modifiers_catcher.h"
 #include "kis_action.h"
 #include "kis_signal_compressor.h"
 #include "kis_time_range.h"
 #include "kis_color_label_selector_widget.h"
 #include "kis_keyframe_channel.h"
 #include "kis_slider_spin_box.h"
 #include <KisImportExportManager.h>
 #include <kis_signals_blocker.h>
 #include <kis_image_config.h>
 
 #include <KoFileDialog.h>
 #include <KisIconToolTip.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;
 
     KisIconToolTip tip;
 
     KisActionManager *actionMan = 0;
 };
 
 TimelineFramesView::TimelineFramesView(QWidget *parent)
     : QTableView(parent),
       m_d(new Private(this))
 {
     m_d->modifiersCatcher = new KisCustomModifiersCatcher(this);
     m_d->modifiersCatcher->addModifier("pan-zoom", Qt::Key_Space);
     m_d->modifiersCatcher->addModifier("offset-frame", Qt::Key_Alt);
 
     setCornerButtonEnabled(false);
     setSelectionBehavior(QAbstractItemView::SelectItems);
     setSelectionMode(QAbstractItemView::ExtendedSelection);
 
     setItemDelegate(new TimelineFramesItemDelegate(this));
 
     setDragEnabled(true);
     setDragDropMode(QAbstractItemView::DragDrop);
     setAcceptDrops(true);
     setDropIndicatorShown(true);
     setDefaultDropAction(Qt::MoveAction);
 
     m_d->horizontalRuler = new TimelineRulerHeader(this);
     this->setHorizontalHeader(m_d->horizontalRuler);
 
     connect(m_d->horizontalRuler, SIGNAL(sigInsertColumnLeft()), SLOT(slotInsertKeyframeColumnLeft()));
     connect(m_d->horizontalRuler, SIGNAL(sigInsertColumnRight()), SLOT(slotInsertKeyframeColumnRight()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigInsertMultipleColumns()), SLOT(slotInsertMultipleKeyframeColumns()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigRemoveColumns()), SLOT(slotRemoveSelectedColumns()));
     connect(m_d->horizontalRuler, SIGNAL(sigRemoveColumnsAndShift()), SLOT(slotRemoveSelectedColumnsAndShift()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigInsertHoldColumns()), SLOT(slotInsertHoldFrameColumn()));
     connect(m_d->horizontalRuler, SIGNAL(sigRemoveHoldColumns()), SLOT(slotRemoveHoldFrameColumn()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigInsertHoldColumnsCustom()), SLOT(slotInsertMultipleHoldFrameColumns()));
     connect(m_d->horizontalRuler, SIGNAL(sigRemoveHoldColumnsCustom()), SLOT(slotRemoveMultipleHoldFrameColumns()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigMirrorColumns()), SLOT(slotMirrorColumns()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigCopyColumns()), SLOT(slotCopyColumns()));
     connect(m_d->horizontalRuler, SIGNAL(sigCutColumns()), SLOT(slotCutColumns()));
     connect(m_d->horizontalRuler, SIGNAL(sigPasteColumns()), SLOT(slotPasteColumns()));
 
     m_d->layersHeader = new TimelineLayersHeader(this);
 
     m_d->layersHeader->setSectionResizeMode(QHeaderView::Fixed);
 
     m_d->layersHeader->setDefaultSectionSize(24);
     m_d->layersHeader->setMinimumWidth(60);
     m_d->layersHeader->setHighlightSections(true);
 
     this->setVerticalHeader(m_d->layersHeader);
 
     connect(horizontalScrollBar(), SIGNAL(valueChanged(int)), SLOT(slotUpdateInfiniteFramesCount()));
     connect(horizontalScrollBar(), SIGNAL(sliderReleased()), SLOT(slotUpdateInfiniteFramesCount()));
 
     /********** New Layer Menu ***********************************************************/
 
     m_d->addLayersButton = new QToolButton(this);
     m_d->addLayersButton->setAutoRaise(true);
     m_d->addLayersButton->setIcon(KisIconUtils::loadIcon("addlayer"));
     m_d->addLayersButton->setIconSize(QSize(20, 20));
     m_d->addLayersButton->setPopupMode(QToolButton::InstantPopup);
 
     m_d->layerEditingMenu = new QMenu(this);
     m_d->layerEditingMenu->addAction(KisAnimationUtils::newLayerActionName, this, SLOT(slotAddNewLayer()));
     m_d->existingLayersMenu = m_d->layerEditingMenu->addMenu(KisAnimationUtils::addExistingLayerActionName);
     m_d->layerEditingMenu->addSeparator();
 
     m_d->layerEditingMenu->addAction(KisAnimationUtils::removeLayerActionName, this, SLOT(slotRemoveLayer()));
 
     connect(m_d->existingLayersMenu, SIGNAL(aboutToShow()), SLOT(slotUpdateLayersMenu()));
     connect(m_d->existingLayersMenu, SIGNAL(triggered(QAction*)), SLOT(slotAddExistingLayer(QAction*)));
 
     connect(m_d->layersHeader, SIGNAL(sigRequestContextMenu(QPoint)), SLOT(slotLayerContextMenuRequested(QPoint)));
 
     m_d->addLayersButton->setMenu(m_d->layerEditingMenu);
 
     /********** Audio Channel Menu *******************************************************/
 
     m_d->audioOptionsButton = new QToolButton(this);
     m_d->audioOptionsButton->setAutoRaise(true);
     m_d->audioOptionsButton->setIcon(KisIconUtils::loadIcon("audio-none"));
     m_d->audioOptionsButton->setIconSize(QSize(20, 20)); // very small on windows if not explicitly set
     m_d->audioOptionsButton->setPopupMode(QToolButton::InstantPopup);
 
     m_d->audioOptionsMenu = new QMenu(this);
 
 #ifndef HAVE_QT_MULTIMEDIA
     m_d->audioOptionsMenu->addSection(i18nc("@item:inmenu", "Audio playback is not supported in this build!"));
 #endif
 
     m_d->openAudioAction= new QAction("XXX", this);
     connect(m_d->openAudioAction, SIGNAL(triggered()), this, SLOT(slotSelectAudioChannelFile()));
     m_d->audioOptionsMenu->addAction(m_d->openAudioAction);
 
     m_d->audioMuteAction = new QAction(i18nc("@item:inmenu", "Mute"), this);
     m_d->audioMuteAction->setCheckable(true);
     connect(m_d->audioMuteAction, SIGNAL(triggered(bool)), SLOT(slotAudioChannelMute(bool)));
 
     m_d->audioOptionsMenu->addAction(m_d->audioMuteAction);
     m_d->audioOptionsMenu->addAction(i18nc("@item:inmenu", "Remove audio"), this, SLOT(slotAudioChannelRemove()));
 
     m_d->audioOptionsMenu->addSeparator();
 
     m_d->volumeSlider = new KisSliderSpinBox(this);
     m_d->volumeSlider->setRange(0, 100);
     m_d->volumeSlider->setSuffix(i18n("%"));
     m_d->volumeSlider->setPrefix(i18nc("@item:inmenu, slider", "Volume:"));
     m_d->volumeSlider->setSingleStep(1);
     m_d->volumeSlider->setPageStep(10);
     m_d->volumeSlider->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Fixed);
 
     connect(m_d->volumeSlider, SIGNAL(valueChanged(int)), SLOT(slotAudioVolumeChanged(int)));
 
     QWidgetAction *volumeAction = new QWidgetAction(m_d->audioOptionsMenu);
     volumeAction->setDefaultWidget(m_d->volumeSlider);
     m_d->audioOptionsMenu->addAction(volumeAction);
 
     m_d->audioOptionsButton->setMenu(m_d->audioOptionsMenu);
 
     /********** Frame Editing Context Menu ***********************************************/
 
     m_d->colorSelector = new KisColorLabelSelectorWidget(this);
     m_d->colorSelectorAction = new QWidgetAction(this);
     m_d->colorSelectorAction->setDefaultWidget(m_d->colorSelector);
     connect(m_d->colorSelector, &KisColorLabelSelectorWidget::currentIndexChanged, this, &TimelineFramesView::slotColorLabelChanged);
 
     m_d->multiframeColorSelector = new KisColorLabelSelectorWidget(this);
     m_d->multiframeColorSelectorAction = new QWidgetAction(this);
     m_d->multiframeColorSelectorAction->setDefaultWidget(m_d->multiframeColorSelector);
     connect(m_d->multiframeColorSelector, &KisColorLabelSelectorWidget::currentIndexChanged, this, &TimelineFramesView::slotColorLabelChanged);
 
     /********** Insert Keyframes Dialog **************************************************/
 
     m_d->insertKeyframeDialog = new TimelineInsertKeyframeDialog(this);
 
     /********** Zoom Button **************************************************************/
 
     m_d->zoomDragButton = new KisZoomButton(this);
     m_d->zoomDragButton->setAutoRaise(true);
     m_d->zoomDragButton->setIcon(KisIconUtils::loadIcon("zoom-horizontal"));
     m_d->zoomDragButton->setIconSize(QSize(20, 20)); // this icon is very small on windows if no explicitly set
 
     m_d->zoomDragButton->setToolTip(i18nc("@info:tooltip", "Zoom Timeline. Hold down and drag left or right."));
     m_d->zoomDragButton->setPopupMode(QToolButton::InstantPopup);
     connect(m_d->zoomDragButton, SIGNAL(zoomLevelChanged(qreal)), SLOT(slotZoomButtonChanged(qreal)));
     connect(m_d->zoomDragButton, SIGNAL(zoomStarted(qreal)), SLOT(slotZoomButtonPressed(qreal)));
 
     setFramesPerSecond(12);
     setHorizontalScrollMode(QAbstractItemView::ScrollPerPixel);
 
     {
         QScroller *scroller = KisKineticScroller::createPreconfiguredScroller(this);
         if( scroller ) {
             connect(scroller, SIGNAL(stateChanged(QScroller::State)),
                     this, SLOT(slotScrollerStateChanged(QScroller::State)));
         }
     }
 
     connect(&m_d->selectionChangedCompressor, SIGNAL(timeout()),
             SLOT(slotSelectionChanged()));
     connect(&m_d->selectionChangedCompressor, SIGNAL(timeout()),
             SLOT(slotUpdateFrameActions()));
 
     {
         QClipboard *cb = QApplication::clipboard();
         connect(cb, SIGNAL(dataChanged()), SLOT(slotUpdateFrameActions()));
     }
 }
 
 TimelineFramesView::~TimelineFramesView()
 {
 }
 
 void TimelineFramesView::setShowInTimeline(KisAction *action)
 {
     m_d->showHideLayerAction = action;
     m_d->layerEditingMenu->addAction(m_d->showHideLayerAction);
 }
 
 void TimelineFramesView::setActionManager(KisActionManager *actionManager)
 {
     m_d->actionMan = actionManager;
     m_d->horizontalRuler->setActionManager(actionManager);
 
 
     if (actionManager) {
         KisAction *action = 0;
 
         action = m_d->actionMan->createAction("add_blank_frame");
         connect(action, SIGNAL(triggered()), SLOT(slotAddBlankFrame()));
 
         action = m_d->actionMan->createAction("add_duplicate_frame");
         connect(action, SIGNAL(triggered()), SLOT(slotAddDuplicateFrame()));
 
         action = m_d->actionMan->createAction("insert_keyframe_left");
         connect(action, SIGNAL(triggered()), SLOT(slotInsertKeyframeLeft()));
 
         action = m_d->actionMan->createAction("insert_keyframe_right");
         connect(action, SIGNAL(triggered()), SLOT(slotInsertKeyframeRight()));
 
         action = m_d->actionMan->createAction("insert_multiple_keyframes");
         connect(action, SIGNAL(triggered()), SLOT(slotInsertMultipleKeyframes()));
 
         action = m_d->actionMan->createAction("remove_frames_and_pull");
         connect(action, SIGNAL(triggered()), SLOT(slotRemoveSelectedFramesAndShift()));
 
         action = m_d->actionMan->createAction("remove_frames");
         connect(action, SIGNAL(triggered()), SLOT(slotRemoveSelectedFrames()));
 
         action = m_d->actionMan->createAction("insert_hold_frame");
         connect(action, SIGNAL(triggered()), SLOT(slotInsertHoldFrame()));
 
         action = m_d->actionMan->createAction("insert_multiple_hold_frames");
         connect(action, SIGNAL(triggered()), SLOT(slotInsertMultipleHoldFrames()));
 
         action = m_d->actionMan->createAction("remove_hold_frame");
         connect(action, SIGNAL(triggered()), SLOT(slotRemoveHoldFrame()));
 
         action = m_d->actionMan->createAction("remove_multiple_hold_frames");
         connect(action, SIGNAL(triggered()), SLOT(slotRemoveMultipleHoldFrames()));
 
         action = m_d->actionMan->createAction("mirror_frames");
         connect(action, SIGNAL(triggered()), SLOT(slotMirrorFrames()));
 
         action = m_d->actionMan->createAction("copy_frames_to_clipboard");
         connect(action, SIGNAL(triggered()), SLOT(slotCopyFrames()));
 
         action = m_d->actionMan->createAction("cut_frames_to_clipboard");
         connect(action, SIGNAL(triggered()), SLOT(slotCutFrames()));
 
         action = m_d->actionMan->createAction("paste_frames_from_clipboard");
         connect(action, SIGNAL(triggered()), SLOT(slotPasteFrames()));
 
         action = m_d->actionMan->createAction("set_start_time");
         connect(action, SIGNAL(triggered()), SLOT(slotSetStartTimeToCurrentPosition()));
 
         action = m_d->actionMan->createAction("set_end_time");
         connect(action, SIGNAL(triggered()), SLOT(slotSetEndTimeToCurrentPosition()));
 
         action = m_d->actionMan->createAction("update_playback_range");
         connect(action, SIGNAL(triggered()), SLOT(slotUpdatePlackbackRange()));
     }
 }
 
 void resizeToMinimalSize(QAbstractButton *w, int minimalSize) {
     QSize buttonSize = w->sizeHint();
     if (buttonSize.height() > minimalSize) {
         buttonSize = QSize(minimalSize, minimalSize);
     }
     w->resize(buttonSize);
 }
 
 void TimelineFramesView::updateGeometries()
 {
     QTableView::updateGeometries();
 
     const int availableHeight = m_d->horizontalRuler->height();
     const int margin = 2;
     const int minimalSize = availableHeight - 2 * margin;
 
     resizeToMinimalSize(m_d->addLayersButton, minimalSize);
     resizeToMinimalSize(m_d->audioOptionsButton, minimalSize);
     resizeToMinimalSize(m_d->zoomDragButton, minimalSize);
 
     int x = 2 * margin;
     int y = (availableHeight - minimalSize) / 2;
     m_d->addLayersButton->move(x, 2 * y);
     m_d->audioOptionsButton->move(x + minimalSize + 2 * margin, 2 * y);
 
     const int availableWidth = m_d->layersHeader->width();
 
     x = availableWidth - margin - minimalSize;
     m_d->zoomDragButton->move(x, 2 * y);
 }
 
 void TimelineFramesView::setModel(QAbstractItemModel *model)
 {
     TimelineFramesModel *framesModel = qobject_cast<TimelineFramesModel*>(model);
     m_d->model = framesModel;
 
     QTableView::setModel(model);
 
     connect(m_d->model, SIGNAL(headerDataChanged(Qt::Orientation,int,int)),
             this, SLOT(slotHeaderDataChanged(Qt::Orientation,int,int)));
 
     connect(m_d->model, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
             this, SLOT(slotDataChanged(QModelIndex,QModelIndex)));
 
     connect(m_d->model, SIGNAL(rowsRemoved(QModelIndex,int,int)),
             this, SLOT(slotReselectCurrentIndex()));
 
     connect(m_d->model, SIGNAL(sigInfiniteTimelineUpdateNeeded()),
             this, SLOT(slotUpdateInfiniteFramesCount()));
 
     connect(m_d->model, SIGNAL(sigAudioChannelChanged()),
             this, SLOT(slotUpdateAudioActions()));
 
     connect(selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
             &m_d->selectionChangedCompressor, SLOT(start()));
 
     connect(m_d->model, SIGNAL(sigEnsureRowVisible(int)), SLOT(slotEnsureRowVisible(int)));
     slotUpdateAudioActions();
 }
 
 void TimelineFramesView::setFramesPerSecond(int fps)
 {
     m_d->fps = fps;
     m_d->horizontalRuler->setFramePerSecond(fps);
 
     // For some reason simple update sometimes doesn't work here, so
     // reset the whole header
     //
     // m_d->horizontalRuler->reset();
 }
 
 void TimelineFramesView::slotZoomButtonPressed(qreal staticPoint)
 {
     m_d->zoomStillPointIndex =
             qIsNaN(staticPoint) ? currentIndex().column() : staticPoint;
 
     const int w = m_d->horizontalRuler->defaultSectionSize();
 
     m_d->zoomStillPointOriginalOffset =
             w * m_d->zoomStillPointIndex -
             horizontalScrollBar()->value();
 }
 
 void TimelineFramesView::slotZoomButtonChanged(qreal zoomLevel)
 {
     if (m_d->horizontalRuler->setZoom(zoomLevel)) {
         slotUpdateInfiniteFramesCount();
 
         const int w = m_d->horizontalRuler->defaultSectionSize();
         horizontalScrollBar()->setValue(w * m_d->zoomStillPointIndex - m_d->zoomStillPointOriginalOffset);
 
         viewport()->update();
     }
 }
 
 void TimelineFramesView::slotColorLabelChanged(int label)
 {
     Q_FOREACH(QModelIndex index, selectedIndexes()) {
         m_d->model->setData(index, label, TimelineFramesModel::FrameColorLabelIndexRole);
     }
     KisImageConfig(false).setDefaultFrameColorLabel(label);
 }
 
 void TimelineFramesView::slotSelectAudioChannelFile()
 {
     if (!m_d->model) return;
 
     QString defaultDir = QStandardPaths::writableLocation(QStandardPaths::MusicLocation);
 
     const QString currentFile = m_d->model->audioChannelFileName();
     QDir baseDir = QFileInfo(currentFile).absoluteDir();
     if (baseDir.exists()) {
         defaultDir = baseDir.absolutePath();
     }
 
     const QString result = KisImportExportManager::askForAudioFileName(defaultDir, this);
     const QFileInfo info(result);
 
     if (info.exists()) {
         m_d->model->setAudioChannelFileName(info.absoluteFilePath());
     }
 }
 
 void TimelineFramesView::slotAudioChannelMute(bool value)
 {
     if (!m_d->model) return;
 
     if (value != m_d->model->isAudioMuted()) {
         m_d->model->setAudioMuted(value);
     }
 }
 
 void TimelineFramesView::slotUpdateIcons()
 {
     m_d->addLayersButton->setIcon(KisIconUtils::loadIcon("addlayer"));
     m_d->audioOptionsButton->setIcon(KisIconUtils::loadIcon("audio-none"));
     m_d->zoomDragButton->setIcon(KisIconUtils::loadIcon("zoom-horizontal"));
 }
 
 void TimelineFramesView::slotAudioChannelRemove()
 {
     if (!m_d->model) return;
     m_d->model->setAudioChannelFileName(QString());
 }
 
 void TimelineFramesView::slotUpdateAudioActions()
 {
     if (!m_d->model) return;
 
     const QString currentFile = m_d->model->audioChannelFileName();
 
     if (currentFile.isEmpty()) {
         m_d->openAudioAction->setText(i18nc("@item:inmenu", "Open audio..."));
     } else {
         QFileInfo info(currentFile);
         m_d->openAudioAction->setText(i18nc("@item:inmenu", "Change audio (%1)...", info.fileName()));
     }
 
     m_d->audioMuteAction->setChecked(m_d->model->isAudioMuted());
 
     QIcon audioIcon;
     if (currentFile.isEmpty()) {
         audioIcon = KisIconUtils::loadIcon("audio-none");
     } else {
         if (m_d->model->isAudioMuted()) {
             audioIcon = KisIconUtils::loadIcon("audio-volume-mute");
         } else {
             audioIcon = KisIconUtils::loadIcon("audio-volume-high");
         }
     }
 
     m_d->audioOptionsButton->setIcon(audioIcon);
 
     m_d->volumeSlider->setEnabled(!m_d->model->isAudioMuted());
 
     KisSignalsBlocker b(m_d->volumeSlider);
     m_d->volumeSlider->setValue(qRound(m_d->model->audioVolume() * 100.0));
 }
 
 void TimelineFramesView::slotAudioVolumeChanged(int value)
 {
     m_d->model->setAudioVolume(qreal(value) / 100.0);
 }
 
 void TimelineFramesView::slotUpdateInfiniteFramesCount()
 {
     if (horizontalScrollBar()->isSliderDown()) return;
 
     const int sectionWidth = m_d->horizontalRuler->defaultSectionSize();
     const int calculatedIndex =
             (horizontalScrollBar()->value() +
              m_d->horizontalRuler->width() - 1) / sectionWidth;
 
     m_d->model->setLastVisibleFrame(calculatedIndex);
 }
 
 void TimelineFramesView::slotScrollerStateChanged( QScroller::State state ) {
     KisKineticScroller::updateCursor(this, state);
 }
 
 void TimelineFramesView::currentChanged(const QModelIndex &current, const QModelIndex &previous)
 {
     QTableView::currentChanged(current, previous);
 
     if (previous.column() != current.column()) {
         m_d->model->setData(previous, false, TimelineFramesModel::ActiveFrameRole);
         m_d->model->setData(current, true, TimelineFramesModel::ActiveFrameRole);
     }
 }
 
 QItemSelectionModel::SelectionFlags TimelineFramesView::selectionCommand(const QModelIndex &index,
                                                                          const QEvent *event) const
 {
     // WARNING: Copy-pasted from KisNodeView! Please keep in sync!
 
     /**
      * Qt has a bug: when we Ctrl+click on an item, the item's
      * selections gets toggled on mouse *press*, whereas usually it is
      * done on mouse *release*.  Therefore the user cannot do a
      * Ctrl+D&D with the default configuration. This code fixes the
      * problem by manually returning QItemSelectionModel::NoUpdate
      * flag when the user clicks on an item and returning
      * QItemSelectionModel::Toggle on release.
      */
 
     if (event &&
             (event->type() == QEvent::MouseButtonPress ||
              event->type() == QEvent::MouseButtonRelease) &&
             index.isValid()) {
 
         const QMouseEvent *mevent = static_cast<const QMouseEvent*>(event);
 
         if (mevent->button() == Qt::RightButton &&
                 selectionModel()->selectedIndexes().contains(index)) {
 
             // Allow calling context menu for multiple layers
             return QItemSelectionModel::NoUpdate;
         }
 
         if (event->type() == QEvent::MouseButtonPress &&
                 (mevent->modifiers() & Qt::ControlModifier)) {
 
             return QItemSelectionModel::NoUpdate;
         }
 
         if (event->type() == QEvent::MouseButtonRelease &&
                 (mevent->modifiers() & Qt::ControlModifier)) {
 
             return QItemSelectionModel::Toggle;
         }
     }
 
     return QAbstractItemView::selectionCommand(index, event);
 }
 
 void TimelineFramesView::slotSelectionChanged()
 {
     int minColumn = std::numeric_limits<int>::max();
     int maxColumn = std::numeric_limits<int>::min();
 
     foreach (const QModelIndex &idx, selectedIndexes()) {
         if (idx.column() > maxColumn) {
             maxColumn = idx.column();
         }
 
         if (idx.column() < minColumn) {
             minColumn = idx.column();
         }
     }
 
     KisTimeRange range;
     if (maxColumn > minColumn) {
         range = KisTimeRange(minColumn, maxColumn - minColumn + 1);
     }
     m_d->model->setPlaybackRange(range);
 }
 
 void TimelineFramesView::slotReselectCurrentIndex()
 {
     QModelIndex index = currentIndex();
     currentChanged(index, index);
 }
 
 void TimelineFramesView::slotEnsureRowVisible(int row)
 {
     QModelIndex index = currentIndex();
     if (!index.isValid() || row < 0) return;
 
     index = m_d->model->index(row, index.column());
     scrollTo(index);
 }
 
 void TimelineFramesView::slotDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight)
 {
     if (m_d->model->isPlaybackActive()) return;
 
     int selectedColumn = -1;
 
     for (int j = topLeft.column(); j <= bottomRight.column(); j++) {
         QVariant value = m_d->model->data(
                     m_d->model->index(topLeft.row(), j),
                     TimelineFramesModel::ActiveFrameRole);
 
         if (value.isValid() && value.toBool()) {
             selectedColumn = j;
             break;
         }
     }
 
     QModelIndex index = currentIndex();
 
     if (!index.isValid() && selectedColumn < 0) {
         return;
     }
 
 
     if (selectedColumn == -1) {
         selectedColumn = index.column();
     }
 
     if (selectedColumn != index.column() && !m_d->dragInProgress) {
         int row= index.isValid() ? index.row() : 0;
         selectionModel()->setCurrentIndex(m_d->model->index(row, selectedColumn), QItemSelectionModel::ClearAndSelect);
     }
+
 }
 
 void TimelineFramesView::slotHeaderDataChanged(Qt::Orientation orientation, int first, int last)
 {
     Q_UNUSED(first);
     Q_UNUSED(last);
 
     if (orientation == Qt::Horizontal) {
         const int newFps = m_d->model->headerData(0, Qt::Horizontal, TimelineFramesModel::FramesPerSecondRole).toInt();
 
         if (newFps != m_d->fps) {
             setFramesPerSecond(newFps);
         }
     }
 }
 
 void TimelineFramesView::rowsInserted(const QModelIndex& parent, int start, int end)
 {
     QTableView::rowsInserted(parent, start, end);
 }
 
 inline bool isIndexDragEnabled(QAbstractItemModel *model, const QModelIndex &index) {
     return (model->flags(index) & Qt::ItemIsDragEnabled);
 }
 
 QStyleOptionViewItem TimelineFramesView::Private::viewOptionsV4() const
 {
     QStyleOptionViewItem option = q->viewOptions();
     option.locale = q->locale();
     option.locale.setNumberOptions(QLocale::OmitGroupSeparator);
     option.widget = q;
     return option;
 }
 
 QItemViewPaintPairs TimelineFramesView::Private::draggablePaintPairs(const QModelIndexList &indexes, QRect *r) const
 {
     Q_ASSERT(r);
     QRect &rect = *r;
     const QRect viewportRect = q->viewport()->rect();
     QItemViewPaintPairs ret;
     for (int i = 0; i < indexes.count(); ++i) {
         const QModelIndex &index = indexes.at(i);
         const QRect current = q->visualRect(index);
         if (current.intersects(viewportRect)) {
             ret += qMakePair(current, index);
             rect |= current;
         }
     }
     rect &= viewportRect;
     return ret;
 }
 
 QPixmap TimelineFramesView::Private::renderToPixmap(const QModelIndexList &indexes, QRect *r) const
 {
     Q_ASSERT(r);
     QItemViewPaintPairs paintPairs = draggablePaintPairs(indexes, r);
     if (paintPairs.isEmpty())
         return QPixmap();
     QPixmap pixmap(r->size());
     pixmap.fill(Qt::transparent);
     QPainter painter(&pixmap);
     QStyleOptionViewItem option = viewOptionsV4();
     option.state |= QStyle::State_Selected;
     for (int j = 0; j < paintPairs.count(); ++j) {
         option.rect = paintPairs.at(j).first.translated(-r->topLeft());
         const QModelIndex &current = paintPairs.at(j).second;
         //adjustViewOptionsForIndex(&option, current);
 
         q->itemDelegate(current)->paint(&painter, option, current);
     }
     return pixmap;
 }
 
 void TimelineFramesView::startDrag(Qt::DropActions supportedActions)
 {
     QModelIndexList indexes = selectionModel()->selectedIndexes();
 
     if (!indexes.isEmpty() && m_d->modifiersCatcher->modifierPressed("offset-frame")) {
         QVector<int> rows;
         int leftmostColumn = std::numeric_limits<int>::max();
 
         Q_FOREACH (const QModelIndex &index, indexes) {
             leftmostColumn = qMin(leftmostColumn, index.column());
             if (!rows.contains(index.row())) {
                 rows.append(index.row());
             }
         }
 
         const int lastColumn = m_d->model->columnCount() - 1;
 
         selectionModel()->clear();
         Q_FOREACH (const int row, rows) {
             QItemSelection sel(m_d->model->index(row, leftmostColumn), m_d->model->index(row, lastColumn));
             selectionModel()->select(sel, QItemSelectionModel::Select);
         }
 
         supportedActions = Qt::MoveAction;
 
         {
             QModelIndexList indexes = selectedIndexes();
             for(int i = indexes.count() - 1 ; i >= 0; --i) {
                 if (!isIndexDragEnabled(m_d->model, indexes.at(i)))
                     indexes.removeAt(i);
             }
 
             selectionModel()->clear();
 
             if (indexes.count() > 0) {
                 QMimeData *data = m_d->model->mimeData(indexes);
                 if (!data)
                     return;
                 QRect rect;
                 QPixmap pixmap = m_d->renderToPixmap(indexes, &rect);
                 rect.adjust(horizontalOffset(), verticalOffset(), 0, 0);
                 QDrag *drag = new QDrag(this);
                 drag->setPixmap(pixmap);
                 drag->setMimeData(data);
                 drag->setHotSpot(m_d->lastPressedPosition - rect.topLeft());
                 drag->exec(supportedActions, Qt::MoveAction);
                 setCurrentIndex(currentIndex());
             }
         }
     } else {
 
         /**
          * Workaround for Qt5's bug: if we start a dragging action right during
          * Shift-selection, Qt will get crazy. We cannot workaround it easily,
          * because we would need to fork mouseMoveEvent() for that (where the
          * decision about drag state is done). So we just abort dragging in that
          * case.
          *
          * BUG:373067
          */
         if (m_d->lastPressedModifier & Qt::ShiftModifier) {
             return;
         }
 
         /**
          * Workaround for Qt5's bugs:
          *
          * 1) Qt doesn't treat selection the selection on D&D
          *    correctly, so we save it in advance and restore
          *    afterwards.
          *
          * 2) There is a private variable in QAbstractItemView:
          *    QAbstractItemView::Private::currentSelectionStartIndex.
          *    It is initialized *only* when the setCurrentIndex() is called
          *    explicitly on the view object, not on the selection model.
          *    Therefore we should explicitly call setCurrentIndex() after
          *    D&D, even if it already has *correct* value!
          *
          * 2) We should also call selectionModel()->select()
          *    explicitly.  There are two reasons for it: 1) Qt doesn't
          *    maintain selection over D&D; 2) when reselecting single
          *    element after D&D, Qt goes crazy, because it tries to
          *    read *global* keyboard modifiers. Therefore if we are
          *    dragging with Shift or Ctrl pressed it'll get crazy. So
          *    just reset it explicitly.
          */
 
         QModelIndexList selectionBefore = selectionModel()->selectedIndexes();
         QModelIndex currentBefore = selectionModel()->currentIndex();
 
         // initialize a global status variable
         m_d->dragWasSuccessful = false;
         QAbstractItemView::startDrag(supportedActions);
 
         QModelIndex newCurrent;
         QPoint selectionOffset;
 
         if (m_d->dragWasSuccessful) {
             newCurrent = currentIndex();
             selectionOffset = QPoint(newCurrent.column() - currentBefore.column(),
                                      newCurrent.row() - currentBefore.row());
         } else {
             newCurrent = currentBefore;
             selectionOffset = QPoint();
         }
 
         setCurrentIndex(newCurrent);
         selectionModel()->clearSelection();
         Q_FOREACH (const QModelIndex &idx, selectionBefore) {
             QModelIndex newIndex =
                     model()->index(idx.row() + selectionOffset.y(),
                                    idx.column() + selectionOffset.x());
             selectionModel()->select(newIndex, QItemSelectionModel::Select);
         }
     }
 }
 
 void TimelineFramesView::dragEnterEvent(QDragEnterEvent *event)
 {
     m_d->dragInProgress = true;
     m_d->model->setScrubState(true);
 
     QTableView::dragEnterEvent(event);
 }
 
 void TimelineFramesView::dragMoveEvent(QDragMoveEvent *event)
 {
     m_d->dragInProgress = true;
     m_d->model->setScrubState(true);
 
     QTableView::dragMoveEvent(event);
 
     if (event->isAccepted()) {
         QModelIndex index = indexAt(event->pos());
         if (!m_d->model->canDropFrameData(event->mimeData(), index)) {
             event->ignore();
         } else {
             selectionModel()->setCurrentIndex(index, QItemSelectionModel::NoUpdate);
         }
     }
 }
 
 void TimelineFramesView::dropEvent(QDropEvent *event)
 {
     m_d->dragInProgress = false;
     m_d->model->setScrubState(false);
 
     if (event->keyboardModifiers() & Qt::ControlModifier) {
         event->setDropAction(Qt::CopyAction);
     }
     QAbstractItemView::dropEvent(event);
     m_d->dragWasSuccessful = event->isAccepted();
 }
 
 void TimelineFramesView::dragLeaveEvent(QDragLeaveEvent *event)
 {
     m_d->dragInProgress = false;
     m_d->model->setScrubState(false);
 
     QAbstractItemView::dragLeaveEvent(event);
 }
 
 void TimelineFramesView::createFrameEditingMenuActions(QMenu *menu, bool addFrameCreationActions)
 {
     slotUpdateFrameActions();
 
     // calculate if selection range is set. This will determine if the update playback range is available
     QSet<int> rows;
     int minColumn = 0;
     int maxColumn = 0;
     calculateSelectionMetrics(minColumn, maxColumn, rows);
 
     bool selectionExists = minColumn != maxColumn;
 
 
     if (selectionExists) {
         KisActionManager::safePopulateMenu(menu, "update_playback_range", m_d->actionMan);
     } else {
         KisActionManager::safePopulateMenu(menu, "set_start_time", m_d->actionMan);
         KisActionManager::safePopulateMenu(menu, "set_end_time", m_d->actionMan);
     }
 
     menu->addSeparator();
 
     KisActionManager::safePopulateMenu(menu, "cut_frames_to_clipboard", m_d->actionMan);
     KisActionManager::safePopulateMenu(menu, "copy_frames_to_clipboard", m_d->actionMan);
     KisActionManager::safePopulateMenu(menu, "paste_frames_from_clipboard", m_d->actionMan);
 
     menu->addSeparator();
 
+    {   // Tween submenu.
+        QMenu *frames = menu->addMenu(i18nc("@item:inmenu", "Tweening"));
+
+        KisActionManager::safePopulateMenu(frames, "insert_opacity_keyframe", m_d->actionMan);
+        KisActionManager::safePopulateMenu(frames, "remove_opacity_keyframe", m_d->actionMan);
+
+        // only allow to add an opacity keyframe if one doesn't exist
+        bool opacityKeyframeExists = model()->data(currentIndex(), TimelineFramesModel::SpecialKeyframeExists).toBool();
+        m_d->actionMan->actionByName("insert_opacity_keyframe")->setEnabled(!opacityKeyframeExists);
+        m_d->actionMan->actionByName("remove_opacity_keyframe")->setEnabled(opacityKeyframeExists);
+    }
+
+
     {   //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);
 
+    enableAction("insert_opacity_keyframe", hasEditableFrames);
+    enableAction("remove_opacity_keyframe", hasEditableFrames);
+
     QClipboard *cp = QApplication::clipboard();
     const QMimeData *data = cp->mimeData();
 
-    enableAction("paste_frames_from_clipboard", data && data->hasFormat("application/x-krita-frame"));
 
     //TODO: update column actions!
 }
 
 void TimelineFramesView::slotSetStartTimeToCurrentPosition()
 {
      m_d->model->setFullClipRangeStart(this->currentIndex().column());
 }
 
 void TimelineFramesView::slotSetEndTimeToCurrentPosition()
 {
     m_d->model->setFullClipRangeEnd(this->currentIndex().column());
 }
 
 void TimelineFramesView::slotUpdatePlackbackRange()
 {
     QSet<int> rows;
     int minColumn = 0;
     int maxColumn = 0;
 
     calculateSelectionMetrics(minColumn, maxColumn, rows);
 
     m_d->model->setFullClipRangeStart(minColumn);
     m_d->model->setFullClipRangeEnd(maxColumn);
 }
 
 void TimelineFramesView::slotLayerContextMenuRequested(const QPoint &globalPos)
 {
     m_d->layerEditingMenu->exec(globalPos);
 }
 
 void TimelineFramesView::slotAddNewLayer()
 {
     QModelIndex index = currentIndex();
     const int newRow = index.isValid() ? index.row() : 0;
     model()->insertRow(newRow);
 }
 
 void TimelineFramesView::slotAddExistingLayer(QAction *action)
 {
     QVariant value = action->data();
 
     if (value.isValid()) {
         QModelIndex index = currentIndex();
         const int newRow = index.isValid() ? index.row() + 1 : 0;
 
         m_d->model->insertOtherLayer(value.toInt(), newRow);
     }
 }
 
 void TimelineFramesView::slotRemoveLayer()
 {
     QModelIndex index = currentIndex();
     if (!index.isValid()) return;
 
     model()->removeRow(index.row());
 }
 
 void TimelineFramesView::slotAddBlankFrame()
 {
     QModelIndex index = currentIndex();
     if (!index.isValid() ||
         !m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) {
 
         return;
     }
 
     m_d->model->createFrame(index);
 }
 
 void TimelineFramesView::slotAddDuplicateFrame()
 {
     QModelIndex index = currentIndex();
     if (!index.isValid() ||
         !m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) {
 
         return;
     }
 
     m_d->model->copyFrame(index);
 }
 
 void TimelineFramesView::calculateSelectionMetrics(int &minColumn, int &maxColumn, QSet<int> &rows) const
 {
     minColumn = std::numeric_limits<int>::max();
     maxColumn = std::numeric_limits<int>::min();
 
     Q_FOREACH (const QModelIndex &index, selectionModel()->selectedIndexes()) {
         if (!m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) continue;
 
         rows.insert(index.row());
         minColumn = qMin(minColumn, index.column());
         maxColumn = qMax(maxColumn, index.column());
     }
 }
 
 void TimelineFramesView::insertKeyframes(int count, int timing, TimelineDirection direction, bool entireColumn)
 {
     QSet<int> rows;
     int minColumn = 0, maxColumn = 0;
 
     calculateSelectionMetrics(minColumn, maxColumn, rows);
 
     if (count <= 0) { //Negative count? Use number of selected frames.
         count = qMax(1, maxColumn - minColumn + 1);
     }
 
     const int insertionColumn =
         direction == TimelineDirection::RIGHT ?
         maxColumn + 1 : minColumn;
 
     if (entireColumn) {
         rows.clear();
         for (int i = 0; i < m_d->model->rowCount(); i++) {
             if (!m_d->model->data(m_d->model->index(i, insertionColumn), TimelineFramesModel::FrameEditableRole).toBool()) continue;
             rows.insert(i);
         }
     }
 
     if (!rows.isEmpty()) {
         m_d->model->insertFrames(insertionColumn, rows.toList(), count, timing);
     }
 }
 
 void TimelineFramesView::insertMultipleKeyframes(bool entireColumn)
 {
     int count, timing;
     TimelineDirection direction;
 
     if (m_d->insertKeyframeDialog->promptUserSettings(count, timing, direction)) {
         insertKeyframes(count, timing, direction, entireColumn);
     }
 }
 
 QModelIndexList TimelineFramesView::calculateSelectionSpan(bool entireColumn, bool editableOnly) const
 {
     QModelIndexList indexes;
 
     if (entireColumn) {
         QSet<int> rows;
         int minColumn = 0;
         int maxColumn = 0;
 
         calculateSelectionMetrics(minColumn, maxColumn, rows);
 
         rows.clear();
         for (int i = 0; i < m_d->model->rowCount(); i++) {
             if (editableOnly &&
                 !m_d->model->data(m_d->model->index(i, minColumn), TimelineFramesModel::FrameEditableRole).toBool()) continue;
 
             for (int column = minColumn; column <= maxColumn; column++) {
                 indexes << m_d->model->index(i, column);
             }
         }
     } else {
         Q_FOREACH (const QModelIndex &index, selectionModel()->selectedIndexes()) {
             if (!editableOnly || m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) {
                 indexes << index;
             }
         }
     }
 
     return indexes;
 }
 
 void TimelineFramesView::slotRemoveSelectedFrames(bool entireColumn, bool pull)
 {
     const QModelIndexList selectedIndices = calculateSelectionSpan(entireColumn);
 
     if (!selectedIndices.isEmpty()) {
         if (pull) {
             m_d->model->removeFramesAndOffset(selectedIndices);
         } else {
             m_d->model->removeFrames(selectedIndices);
         }
     }
 }
 
 void TimelineFramesView::insertOrRemoveHoldFrames(int count, bool entireColumn)
 {
     QModelIndexList indexes;
 
     if (!entireColumn) {
         Q_FOREACH (const QModelIndex &index, selectionModel()->selectedIndexes()) {
             if (m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) {
                 indexes << index;
             }
         }
     } else {
         const int column = selectionModel()->currentIndex().column();
 
         for (int i = 0; i < m_d->model->rowCount(); i++) {
             const QModelIndex index = m_d->model->index(i, column);
             if (m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) {
                 indexes << index;
             }
         }
     }
 
     if (!indexes.isEmpty()) {
 
         // add extra columns to the end of the timeline if we are adding hold frames
         // they will be truncated if we don't do this
         if (count > 0) {
             // Scan all the layers and find out what layer has the most keyframes
             // only keep a reference of layer that has the most keyframes
             int keyframesInLayerNode = 0;
             Q_FOREACH (const QModelIndex &index, indexes) {
                 KisNodeSP layerNode = m_d->model->nodeAt(index);
 
                 KisKeyframeChannel *channel = layerNode->getKeyframeChannel(KisKeyframeChannel::Content.id());
                 if (!channel) continue;
 
                 if (keyframesInLayerNode < channel->allKeyframeIds().count()) {
                    keyframesInLayerNode = channel->allKeyframeIds().count();
                 }
             }
             m_d->model->setLastVisibleFrame(m_d->model->columnCount() + count*keyframesInLayerNode);
         }
 
 
         m_d->model->insertHoldFrames(indexes, count);
 
         // bulk adding frames can add too many
         // trim timeline to clean up extra frames that might have been added
         slotUpdateInfiniteFramesCount();
     }
 }
 
 void TimelineFramesView::insertOrRemoveMultipleHoldFrames(bool insertion, bool entireColumn)
 {
     bool ok = false;
     const int count = QInputDialog::getInt(this,
                                            i18nc("@title:window", "Insert or Remove Hold Frames"),
                                            i18nc("@label:spinbox", "Enter number of frames"),
                                            insertion ?
                                                m_d->insertKeyframeDialog->defaultTimingOfAddedFrames() :
                                                m_d->insertKeyframeDialog->defaultNumberOfHoldFramesToRemove(),
                                            1, 10000, 1, &ok);
 
     if (ok) {
         if (insertion) {
             m_d->insertKeyframeDialog->setDefaultTimingOfAddedFrames(count);
             insertOrRemoveHoldFrames(count, entireColumn);
         } else {
             m_d->insertKeyframeDialog->setDefaultNumberOfHoldFramesToRemove(count);
             insertOrRemoveHoldFrames(-count, entireColumn);
         }
 
     }
 }
 
 void TimelineFramesView::slotMirrorFrames(bool entireColumn)
 {
     const QModelIndexList indexes = calculateSelectionSpan(entireColumn);
 
     if (!indexes.isEmpty()) {
         m_d->model->mirrorFrames(indexes);
     }
 }
 
 void TimelineFramesView::cutCopyImpl(bool entireColumn, bool copy)
 {
     const QModelIndexList selectedIndices = calculateSelectionSpan(entireColumn, !copy);
     if (selectedIndices.isEmpty()) return;
 
     int minColumn = std::numeric_limits<int>::max();
     int minRow = std::numeric_limits<int>::max();
 
     Q_FOREACH (const QModelIndex &index, selectedIndices) {
         minRow = qMin(minRow, index.row());
         minColumn = qMin(minColumn, index.column());
     }
 
     const QModelIndex baseIndex = m_d->model->index(minRow, minColumn);
 
     QMimeData *data = m_d->model->mimeDataExtended(selectedIndices,
                                                    baseIndex,
                                                    copy ?
                                                        TimelineFramesModel::CopyFramesPolicy :
                                                        TimelineFramesModel::MoveFramesPolicy);
 
     if (data) {
         QClipboard *cb = QApplication::clipboard();
         cb->setMimeData(data);
     }
 }
 
 void TimelineFramesView::slotPasteFrames(bool entireColumn)
 {
     const QModelIndex currentIndex =
         !entireColumn ? this->currentIndex() : m_d->model->index(0, this->currentIndex().column());
 
     if (!currentIndex.isValid()) return;
 
     QClipboard *cb = QApplication::clipboard();
     const QMimeData *data = cb->mimeData();
 
     if (data && data->hasFormat("application/x-krita-frame")) {
 
         bool dataMoved = false;
         bool result = m_d->model->dropMimeDataExtended(data, Qt::MoveAction, currentIndex, &dataMoved);
 
         if (result && dataMoved) {
             cb->clear();
         }
     }
 }
 
 bool TimelineFramesView::viewportEvent(QEvent *event)
 {
     if (event->type() == QEvent::ToolTip && model()) {
         QHelpEvent *he = static_cast<QHelpEvent *>(event);
         QModelIndex index = model()->buddy(indexAt(he->pos()));
         if (index.isValid()) {
             QStyleOptionViewItem option = viewOptions();
             option.rect = visualRect(index);
             // The offset of the headers is needed to get the correct position inside the view.
             m_d->tip.showTip(this, he->pos() + QPoint(verticalHeader()->width(), horizontalHeader()->height()), option, index);
             return true;
         }
     }
 
     return QTableView::viewportEvent(event);
 }
diff --git a/plugins/dockers/animation/timeline_ruler_header.cpp b/plugins/dockers/animation/timeline_ruler_header.cpp
index c62e737bda..481149a618 100644
--- a/plugins/dockers/animation/timeline_ruler_header.cpp
+++ b/plugins/dockers/animation/timeline_ruler_header.cpp
@@ -1,542 +1,547 @@
 /*
  *  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_ruler_header.h"
 
 #include <limits>
 
 #include <QMenu>
 #include <QAction>
 #include <QPainter>
 #include <QPaintEvent>
 
 #include <klocalizedstring.h>
 
 #include "kis_time_based_item_model.h"
 #include "timeline_color_scheme.h"
 #include "kis_action.h"
 
 #include "kis_debug.h"
 
 struct TimelineRulerHeader::Private
 {
     Private() : fps(12), lastPressSectionIndex(-1) {}
 
     int fps;
 
     KisTimeBasedItemModel *model;
     int lastPressSectionIndex;
 
     int calcSpanWidth(const int sectionWidth);
     QModelIndexList prepareFramesSlab(int startCol, int endCol);
 
     KisActionManager* actionMan = 0;
 
 };
 
 TimelineRulerHeader::TimelineRulerHeader(QWidget *parent)
     : QHeaderView(Qt::Horizontal, parent),
       m_d(new Private)
 {
     setSectionResizeMode(QHeaderView::Fixed);
     setDefaultSectionSize(18);
     setMinimumSectionSize(8);
 }
 
 TimelineRulerHeader::~TimelineRulerHeader()
 {
 }
 
 
 void TimelineRulerHeader::setActionManager(KisActionManager *actionManager)
 {
     m_d->actionMan = actionManager;
 
     if (actionManager) {
         KisAction *action;
 
         action = actionManager->createAction("insert_column_left");
         connect(action, SIGNAL(triggered()), SIGNAL(sigInsertColumnLeft()));
 
         action = actionManager->createAction("insert_column_right");
         connect(action, SIGNAL(triggered()), SIGNAL(sigInsertColumnRight()));
 
         action = actionManager->createAction("insert_multiple_columns");
         connect(action, SIGNAL(triggered()), SIGNAL(sigInsertMultipleColumns()));
 
         action = actionManager->createAction("remove_columns_and_pull");
         connect(action, SIGNAL(triggered()), SIGNAL(sigRemoveColumnsAndShift()));
 
         action = actionManager->createAction("remove_columns");
         connect(action, SIGNAL(triggered()), SIGNAL(sigRemoveColumns()));
 
         action = actionManager->createAction("insert_hold_column");
         connect(action, SIGNAL(triggered()), SIGNAL(sigInsertHoldColumns()));
 
         action = actionManager->createAction("insert_multiple_hold_columns");
         connect(action, SIGNAL(triggered()), SIGNAL(sigInsertHoldColumnsCustom()));
 
         action = actionManager->createAction("remove_hold_column");
         connect(action, SIGNAL(triggered()), SIGNAL(sigRemoveHoldColumns()));
 
         action = actionManager->createAction("remove_multiple_hold_columns");
         connect(action, SIGNAL(triggered()), SIGNAL(sigRemoveHoldColumnsCustom()));
 
         action = actionManager->createAction("mirror_columns");
         connect(action, SIGNAL(triggered()), SIGNAL(sigMirrorColumns()));
 
         action = actionManager->createAction("copy_columns_to_clipboard");
         connect(action, SIGNAL(triggered()), SIGNAL(sigCopyColumns()));
 
         action = actionManager->createAction("cut_columns_to_clipboard");
         connect(action, SIGNAL(triggered()), SIGNAL(sigCutColumns()));
 
         action = actionManager->createAction("paste_columns_from_clipboard");
         connect(action, SIGNAL(triggered()), SIGNAL(sigPasteColumns()));
     }
 }
 
 
 void TimelineRulerHeader::paintEvent(QPaintEvent *e)
 {
     QHeaderView::paintEvent(e);
 
     // Copied from Qt 4.8...
 
     if (count() == 0)
         return;
 
     QPainter painter(viewport());
     const QPoint offset = dirtyRegionOffset();
     QRect translatedEventRect = e->rect();
     translatedEventRect.translate(offset);
 
     int start = -1;
     int end = -1;
     if (orientation() == Qt::Horizontal) {
         start = visualIndexAt(translatedEventRect.left());
         end = visualIndexAt(translatedEventRect.right());
     } else {
         start = visualIndexAt(translatedEventRect.top());
         end = visualIndexAt(translatedEventRect.bottom());
     }
 
     const bool reverseImpl = orientation() == Qt::Horizontal && isRightToLeft();
 
     if (reverseImpl) {
         start = (start == -1 ? count() - 1 : start);
         end = (end == -1 ? 0 : end);
     } else {
         start = (start == -1 ? 0 : start);
         end = (end == -1 ? count() - 1 : end);
     }
 
     int tmp = start;
     start = qMin(start, end);
     end = qMax(tmp, end);
 
     ///////////////////////////////////////////////////
     /// Krita specific code. We should update in spans!
 
     const int spanStart = start - start % m_d->fps;
     const int spanEnd = end - end % m_d->fps + m_d->fps - 1;
 
     start = spanStart;
     end = qMin(count() - 1, spanEnd);
 
     /// End of Krita specific code
     ///////////////////////////////////////////////////
 
     QRect currentSectionRect;
     int logical;
     const int width = viewport()->width();
     const int height = viewport()->height();
+
     for (int i = start; i <= end; ++i) {
         // DK: cannot copy-paste easily...
         // if (d->isVisualIndexHidden(i))
         //     continue;
         painter.save();
         logical = logicalIndex(i);
         if (orientation() == Qt::Horizontal) {
             currentSectionRect.setRect(sectionViewportPosition(logical), 0, sectionSize(logical), height);
         } else {
             currentSectionRect.setRect(0, sectionViewportPosition(logical), width, sectionSize(logical));
         }
         currentSectionRect.translate(offset);
 
         QVariant variant = model()->headerData(logical, orientation(),
                                                 Qt::FontRole);
         if (variant.isValid() && variant.canConvert<QFont>()) {
             QFont sectionFont = qvariant_cast<QFont>(variant);
             painter.setFont(sectionFont);
         }
         paintSection1(&painter, currentSectionRect, logical);
         painter.restore();
     }
 }
 
 void TimelineRulerHeader::paintSection(QPainter *painter, const QRect &rect, int logicalIndex) const
 {
     // Base paint event should paint nothing in the sections area
 
     Q_UNUSED(painter);
     Q_UNUSED(rect);
     Q_UNUSED(logicalIndex);
 }
 
 void TimelineRulerHeader::paintSpan(QPainter *painter, int userFrameId,
                                     const QRect &spanRect,
                                     bool isIntegralLine,
                                     bool isPrevIntegralLine,
                                     QStyle *style,
                                     const QPalette &palette,
                                     const QPen &gridPen) const
 {
     painter->fillRect(spanRect, palette.brush(QPalette::Button));
 
     int safeRight = spanRect.right();
 
     QPen oldPen = painter->pen();
     painter->setPen(gridPen);
 
     int adjustedTop = spanRect.top() + (!isIntegralLine ? spanRect.height() / 2 : 0);
     painter->drawLine(safeRight, adjustedTop, safeRight, spanRect.bottom());
 
     if (isPrevIntegralLine) {
         painter->drawLine(spanRect.left() + 1, spanRect.top(), spanRect.left() + 1, spanRect.bottom());
     }
 
     painter->setPen(oldPen);
 
     QString frameIdText = QString::number(userFrameId);
     QRect textRect(spanRect.topLeft() + QPoint(2, 0), QSize(spanRect.width() - 2, spanRect.height()));
 
     QStyleOptionHeader opt;
     initStyleOption(&opt);
 
     QStyle::State state = QStyle::State_None;
     if (isEnabled())
         state |= QStyle::State_Enabled;
     if (window()->isActiveWindow())
         state |= QStyle::State_Active;
     opt.state |= state;
     opt.selectedPosition = QStyleOptionHeader::NotAdjacent;
 
     opt.textAlignment = Qt::AlignLeft | Qt::AlignTop;
     opt.rect = textRect;
     opt.text = frameIdText;
     style->drawControl(QStyle::CE_HeaderLabel, &opt, painter, this);
 }
 
 int TimelineRulerHeader::Private::calcSpanWidth(const int sectionWidth) {
     const int minWidth = 36;
 
     int spanWidth = this->fps;
 
     while (spanWidth * sectionWidth < minWidth) {
         spanWidth *= 2;
     }
 
     bool splitHappened = false;
 
     do {
         splitHappened = false;
 
         if (!(spanWidth & 0x1) &&
             spanWidth * sectionWidth / 2 > minWidth) {
 
             spanWidth /= 2;
             splitHappened = true;
 
         } else if (!(spanWidth % 3) &&
                    spanWidth * sectionWidth / 3 > minWidth) {
 
             spanWidth /= 3;
             splitHappened = true;
 
         } else if (!(spanWidth % 5) &&
                    spanWidth * sectionWidth / 5 > minWidth) {
 
             spanWidth /= 5;
             splitHappened = true;
         }
 
     } while (splitHappened);
 
 
     if (sectionWidth > minWidth) {
         spanWidth = 1;
     }
 
     return spanWidth;
 }
 
 void TimelineRulerHeader::paintSection1(QPainter *painter, const QRect &rect, int logicalIndex) const
-{
+{   
+
     if (!rect.isValid())
         return;
 
     QFontMetrics metrics(this->font());
     const int textHeight = metrics.height();
 
     QPoint p1 = rect.topLeft() + QPoint(0, textHeight);
     QPoint p2 = rect.topRight() + QPoint(0, textHeight);
 
     QRect frameRect = QRect(p1, QSize(rect.width(), rect.height() - textHeight));
 
     const int width = rect.width();
 
     int spanWidth = m_d->calcSpanWidth(width);
 
     const int internalIndex = logicalIndex % spanWidth;
     const int userFrameId = logicalIndex;
 
     const int spanEnd = qMin(count(), logicalIndex + spanWidth);
     QRect spanRect(rect.topLeft(), QSize(width * (spanEnd - logicalIndex), textHeight));
 
     QStyleOptionViewItem option = viewOptions();
     const int gridHint = style()->styleHint(QStyle::SH_Table_GridLineColor, &option, this);
     const QColor gridColor = static_cast<QRgb>(gridHint);
     const QPen gridPen = QPen(gridColor);
 
     if (!internalIndex) {
         bool isIntegralLine = (logicalIndex + spanWidth) % m_d->fps == 0;
         bool isPrevIntegralLine = logicalIndex % m_d->fps == 0;
         paintSpan(painter, userFrameId, spanRect, isIntegralLine, isPrevIntegralLine, style(), palette(), gridPen);
     }
 
     {
         QBrush fillColor = TimelineColorScheme::instance()->headerEmpty();
 
         QVariant activeValue = model()->headerData(logicalIndex, orientation(),
                                                    KisTimeBasedItemModel::ActiveFrameRole);
 
         QVariant cachedValue = model()->headerData(logicalIndex, orientation(),
                                                    KisTimeBasedItemModel::FrameCachedRole);
 
         if (activeValue.isValid() && activeValue.toBool()) {
             fillColor = TimelineColorScheme::instance()->headerActive();
         } else if (cachedValue.isValid() && cachedValue.toBool()) {
             fillColor = TimelineColorScheme::instance()->headerCachedFrame();
         }
 
         painter->fillRect(frameRect, fillColor);
 
         QVector<QLine> lines;
         lines << QLine(p1, p2);
         lines << QLine(frameRect.topRight(), frameRect.bottomRight());
         lines << QLine(frameRect.bottomLeft(), frameRect.bottomRight());
 
         QPen oldPen = painter->pen();
         painter->setPen(gridPen);
         painter->drawLines(lines);
         painter->setPen(oldPen);
     }
 }
 
 void TimelineRulerHeader::changeEvent(QEvent *event)
 {
     Q_UNUSED(event);
 
     updateMinimumSize();
 }
 
 void TimelineRulerHeader::setFramePerSecond(int fps)
 {
     m_d->fps = fps;
     update();
 }
 
 bool TimelineRulerHeader::setZoom(qreal zoom)
 {
     const int minSectionSize = 4;
     const int unitSectionSize = 18;
 
     int newSectionSize = zoom * unitSectionSize;
 
     if (newSectionSize < minSectionSize) {
         newSectionSize = minSectionSize;
         zoom = qreal(newSectionSize) / unitSectionSize;
     }
 
     if (newSectionSize != defaultSectionSize()) {
         setDefaultSectionSize(newSectionSize);
         return true;
     }
 
     return false;
 }
 
 void TimelineRulerHeader::updateMinimumSize()
 {
     QFontMetrics metrics(this->font());
     const int textHeight = metrics.height();
 
     setMinimumSize(0, 1.5 * textHeight);
 }
 
 void TimelineRulerHeader::setModel(QAbstractItemModel *model)
 {
     KisTimeBasedItemModel *framesModel = qobject_cast<KisTimeBasedItemModel*>(model);
     m_d->model = framesModel;
 
     QHeaderView::setModel(model);
 }
 
 int getColumnCount(const QModelIndexList &indexes, int *leftmostCol, int *rightmostCol)
 {
     QVector<int> columns;
     int leftmost = std::numeric_limits<int>::max();
     int rightmost = std::numeric_limits<int>::min();
 
     Q_FOREACH (const QModelIndex &index, indexes) {
         leftmost = qMin(leftmost, index.column());
         rightmost = qMax(rightmost, index.column());
         if (!columns.contains(index.column())) {
             columns.append(index.column());
         }
     }
 
     if (leftmostCol) *leftmostCol = leftmost;
     if (rightmostCol) *rightmostCol = rightmost;
 
     return columns.size();
 }
 
 void TimelineRulerHeader::mousePressEvent(QMouseEvent *e)
 {
     int logical = logicalIndexAt(e->pos());
     if (logical != -1) {
         QModelIndexList selectedIndexes = selectionModel()->selectedIndexes();
         int numSelectedColumns = getColumnCount(selectedIndexes, 0, 0);
 
         if (e->button() == Qt::RightButton) {
             if (numSelectedColumns <= 1) {
                 model()->setHeaderData(logical, orientation(), true, KisTimeBasedItemModel::ActiveFrameRole);
             }
 
             /* Fix for safe-assert involving kis_animation_curve_docker.
              * There should probably be a more elagant way for dealing
              * with reused timeline_ruler_header instances in other
              * timeline views instead of simply animation_frame_view.
              *
              * This works for now though... */
             if(!m_d->actionMan){
                 return;
             }
 
             QMenu menu;
             KisActionManager::safePopulateMenu(&menu, "cut_columns_to_clipboard", m_d->actionMan);
             KisActionManager::safePopulateMenu(&menu, "copy_columns_to_clipboard", m_d->actionMan);
             KisActionManager::safePopulateMenu(&menu, "paste_columns_from_clipboard", m_d->actionMan);
 
             menu.addSeparator();
 
             {   //Frame Columns Submenu
                 QMenu *frames = menu.addMenu(i18nc("@item:inmenu", "Keyframe Columns"));
                 KisActionManager::safePopulateMenu(frames, "insert_column_left", m_d->actionMan);
                 KisActionManager::safePopulateMenu(frames, "insert_column_right", m_d->actionMan);
                 frames->addSeparator();
                 KisActionManager::safePopulateMenu(frames, "insert_multiple_columns", m_d->actionMan);
             }
 
             {   //Hold Columns Submenu
                 QMenu *hold = menu.addMenu(i18nc("@item:inmenu", "Hold Frame Columns"));
                 KisActionManager::safePopulateMenu(hold, "insert_hold_column", m_d->actionMan);
                 KisActionManager::safePopulateMenu(hold, "remove_hold_column", m_d->actionMan);
                 hold->addSeparator();
                 KisActionManager::safePopulateMenu(hold, "insert_multiple_hold_columns", m_d->actionMan);
                 KisActionManager::safePopulateMenu(hold, "remove_multiple_hold_columns", m_d->actionMan);
             }
 
             menu.addSeparator();
 
             KisActionManager::safePopulateMenu(&menu, "remove_columns", m_d->actionMan);
             KisActionManager::safePopulateMenu(&menu, "remove_columns_and_pull", m_d->actionMan);
 
             if (numSelectedColumns > 1) {
                 menu.addSeparator();
                 KisActionManager::safePopulateMenu(&menu, "mirror_columns", m_d->actionMan);
             }
 
             menu.exec(e->globalPos());
 
             return;
 
-        } else if (e->button() == Qt::LeftButton) {
+        } else if (e->button() == Qt::LeftButton) {           
             m_d->lastPressSectionIndex = logical;
             model()->setHeaderData(logical, orientation(), true, KisTimeBasedItemModel::ActiveFrameRole);
         }
     }
 
     QHeaderView::mousePressEvent(e);
 }
 
 void TimelineRulerHeader::mouseMoveEvent(QMouseEvent *e)
 {
     int logical = logicalIndexAt(e->pos());
     if (logical != -1) {
+
         if (e->buttons() & Qt::LeftButton) {
+
             m_d->model->setScrubState(true);
             model()->setHeaderData(logical, orientation(), true, KisTimeBasedItemModel::ActiveFrameRole);
 
             if (m_d->lastPressSectionIndex >= 0 &&
                 logical != m_d->lastPressSectionIndex &&
                 e->modifiers() & Qt::ShiftModifier) {
 
                 const int minCol = qMin(m_d->lastPressSectionIndex, logical);
                 const int maxCol = qMax(m_d->lastPressSectionIndex, logical);
 
                 QItemSelection sel(m_d->model->index(0, minCol), m_d->model->index(0, maxCol));
                 selectionModel()->select(sel,
                                          QItemSelectionModel::Columns |
                                          QItemSelectionModel::SelectCurrent);
             }
 
         }
+
     }
 
     QHeaderView::mouseMoveEvent(e);
 }
 
 void TimelineRulerHeader::mouseReleaseEvent(QMouseEvent *e)
 {
     if (e->button() == Qt::LeftButton) {
         m_d->model->setScrubState(false);
     }
     QHeaderView::mouseReleaseEvent(e);
 }
 
 QModelIndexList TimelineRulerHeader::Private::prepareFramesSlab(int startCol, int endCol)
 {
     QModelIndexList frames;
 
     const int numRows = model->rowCount();
 
     for (int i = 0; i < numRows; i++) {
         for (int j = startCol; j <= endCol; j++) {
             QModelIndex index = model->index(i, j);
             const bool exists = model->data(index, KisTimeBasedItemModel::FrameExistsRole).toBool();
             if (exists) {
                 frames << index;
             }
         }
     }
 
     return frames;
 }
diff --git a/plugins/dockers/animation/timeline_ruler_header.h b/plugins/dockers/animation/timeline_ruler_header.h
index a99baf516b..290de58e25 100644
--- a/plugins/dockers/animation/timeline_ruler_header.h
+++ b/plugins/dockers/animation/timeline_ruler_header.h
@@ -1,87 +1,90 @@
 /*
  *  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_RULER_HEADER_H
 #define TIMELINE_RULER_HEADER_H
 
 #include <QHeaderView>
 #include <QScopedPointer>
 #include "kis_action_manager.h"
 
 class QPaintEvent;
 
 class TimelineRulerHeader : public QHeaderView
 {
     Q_OBJECT
 public:
     TimelineRulerHeader(QWidget *parent = 0);
     ~TimelineRulerHeader() override;
 
     void setFramePerSecond(int fps);
     bool setZoom(qreal zoomLevel);
 
     void setModel(QAbstractItemModel *model) override;
 
     void setActionManager(KisActionManager *actionManager);
 
+     void mouseMoveEvent(QMouseEvent *e) override;
+
 protected:
     void mousePressEvent(QMouseEvent *e) override;
-    void mouseMoveEvent(QMouseEvent *e) override;
+
     void mouseReleaseEvent(QMouseEvent *e) override;
 
     void paintEvent(QPaintEvent *e) override;
     void paintSection(QPainter *painter, const QRect &rect, int logicalIndex) const override;
     void paintSection1(QPainter *painter, const QRect &rect, int logicalIndex) const;
     void changeEvent(QEvent *event) override;
 
 private:
     void updateMinimumSize();
 
     void paintSpan(QPainter *painter, int userFrameId,
                    const QRect &spanRect,
                    bool isIntegralLine,
                    bool isPrevIntegralLine,
                    QStyle *style,
                    const QPalette &palette,
                    const QPen &gridPen) const;
 
 Q_SIGNALS:
     void sigInsertColumnLeft();
     void sigInsertColumnRight();
     void sigInsertMultipleColumns();
 
     void sigRemoveColumns();
     void sigRemoveColumnsAndShift();
 
     void sigInsertHoldColumns();
     void sigRemoveHoldColumns();
     void sigInsertHoldColumnsCustom();
     void sigRemoveHoldColumnsCustom();
 
     void sigMirrorColumns();
 
     void sigCutColumns();
     void sigCopyColumns();
     void sigPasteColumns();
 
+
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 #endif // TIMELINE_RULER_HEADER_H
diff --git a/plugins/dockers/layerdocker/LayerBox.cpp b/plugins/dockers/layerdocker/LayerBox.cpp
index 6f3facf0f3..5b0bccfb54 100644
--- a/plugins/dockers/layerdocker/LayerBox.cpp
+++ b/plugins/dockers/layerdocker/LayerBox.cpp
@@ -1,1110 +1,1109 @@
 /*
  *  LayerBox.cc - part of Krita aka Krayon aka KimageShop
  *
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (C) 2006 Gábor Lehel <illissius@gmail.com>
  *  Copyright (C) 2007 Thomas Zander <zander@kde.org>
  *  Copyright (C) 2007 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2011 José Luis Vergara <pentalis@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "LayerBox.h"
 
 #include <QToolButton>
 #include <QLayout>
 #include <QMouseEvent>
 #include <QPainter>
 #include <QPoint>
 #include <QRect>
 #include <QString>
 #include <QToolTip>
 #include <QWidget>
 #include <QComboBox>
 #include <QCheckBox>
 #include <QVBoxLayout>
 #include <QPixmap>
 #include <QList>
 #include <QVector>
 #include <QLabel>
 #include <QMenu>
 #include <QWidgetAction>
 #include <QProxyStyle>
 
 #include <kis_debug.h>
 #include <klocalizedstring.h>
 
 #include <kis_icon.h>
 #include <KoColorSpace.h>
 #include <KoCompositeOpRegistry.h>
 #include <KisDocument.h>
 
 #include <kis_types.h>
 #include <kis_image.h>
 #include <kis_paint_device.h>
 #include <kis_layer.h>
 #include <kis_group_layer.h>
 #include <kis_mask.h>
 #include <kis_node.h>
 #include <kis_base_node.h>
 #include <kis_composite_ops_model.h>
 #include <kis_keyframe_channel.h>
 #include <kis_image_animation_interface.h>
 #include <KoProperties.h>
 
 #include <kis_action.h>
 #include "kis_action_manager.h"
 #include "widgets/kis_cmb_composite.h"
 #include "widgets/kis_slider_spin_box.h"
 #include "KisViewManager.h"
 #include "kis_node_manager.h"
 #include "kis_node_model.h"
 
 #include "canvas/kis_canvas2.h"
 #include "kis_dummies_facade_base.h"
 #include "kis_shape_controller.h"
 #include "kis_selection_mask.h"
 #include "kis_config.h"
 #include "KisView.h"
 #include "krita_utils.h"
 #include "kis_color_label_selector_widget.h"
 #include "kis_signals_blocker.h"
 #include "kis_color_filter_combo.h"
 #include "kis_node_filter_proxy_model.h"
 
 #include "kis_selection.h"
 #include "kis_processing_applicator.h"
 #include "commands/kis_set_global_selection_command.h"
 #include "KisSelectionActionsAdapter.h"
 
 #include "kis_layer_utils.h"
 
 #include "ui_WdgLayerBox.h"
 #include "NodeView.h"
 #include "SyncButtonAndAction.h"
 
 
 class LayerBoxStyle : public QProxyStyle
 {
 public:
     LayerBoxStyle(QStyle *baseStyle = 0) : QProxyStyle(baseStyle) {}
 
     void drawPrimitive(PrimitiveElement element, const QStyleOption *option,
                        QPainter *painter, const QWidget *widget) const
     {
         if (element == QStyle::PE_IndicatorItemViewItemDrop)
         {
             QColor color(widget->palette().color(QPalette::Highlight).lighter());
 
             if (option->rect.height() == 0) {
                 QBrush brush(color);
 
                 QRect r(option->rect);
                 r.setTop(r.top() - 2);
                 r.setBottom(r.bottom() + 2);
 
                 painter->fillRect(r, brush);
             } else {
                 color.setAlpha(200);
                 QBrush brush(color);
                 painter->fillRect(option->rect, brush);
             }
         }
         else
         {
             QProxyStyle::drawPrimitive(element, option, painter, widget);
         }
     }
 };
 
 inline void LayerBox::connectActionToButton(KisViewManager* viewManager, QAbstractButton *button, const QString &id)
 {
     if (!viewManager || !button) return;
 
     KisAction *action = viewManager->actionManager()->actionByName(id);
 
     if (!action) return;
 
     connect(button, SIGNAL(clicked()), action, SLOT(trigger()));
     connect(action, SIGNAL(sigEnableSlaves(bool)), button, SLOT(setEnabled(bool)));
     connect(viewManager->mainWindow(), SIGNAL(themeChanged()), this, SLOT(slotUpdateIcons()));
 }
 
 inline void LayerBox::addActionToMenu(QMenu *menu, const QString &id)
 {
     if (m_canvas) {
         menu->addAction(m_canvas->viewManager()->actionManager()->actionByName(id));
     }
 }
 
 LayerBox::LayerBox()
     : QDockWidget(i18n("Layers"))
     , m_canvas(0)
     , m_wdgLayerBox(new Ui_WdgLayerBox)
     , m_thumbnailCompressor(500, KisSignalCompressor::FIRST_INACTIVE)
     , m_colorLabelCompressor(900, KisSignalCompressor::FIRST_INACTIVE)
     , m_thumbnailSizeCompressor(100, KisSignalCompressor::FIRST_INACTIVE)
 {
     KisConfig cfg(false);
 
     QWidget* mainWidget = new QWidget(this);
     setWidget(mainWidget);
     m_opacityDelayTimer.setSingleShot(true);
 
     m_wdgLayerBox->setupUi(mainWidget);
 
     m_wdgLayerBox->listLayers->setStyle(new LayerBoxStyle(m_wdgLayerBox->listLayers->style()));
 
     connect(m_wdgLayerBox->listLayers,
             SIGNAL(contextMenuRequested(QPoint,QModelIndex)),
             this, SLOT(slotContextMenuRequested(QPoint,QModelIndex)));
     connect(m_wdgLayerBox->listLayers,
             SIGNAL(collapsed(QModelIndex)), SLOT(slotCollapsed(QModelIndex)));
     connect(m_wdgLayerBox->listLayers,
             SIGNAL(expanded(QModelIndex)), SLOT(slotExpanded(QModelIndex)));
     connect(m_wdgLayerBox->listLayers,
             SIGNAL(selectionChanged(QModelIndexList)), SLOT(selectionChanged(QModelIndexList)));
 
     slotUpdateIcons();
 
     m_wdgLayerBox->bnDelete->setIconSize(QSize(22, 22));
     m_wdgLayerBox->bnRaise->setIconSize(QSize(22, 22));
     m_wdgLayerBox->bnLower->setIconSize(QSize(22, 22));
     m_wdgLayerBox->bnProperties->setIconSize(QSize(22, 22));
     m_wdgLayerBox->bnDuplicate->setIconSize(QSize(22, 22));
 
     m_wdgLayerBox->bnLower->setEnabled(false);
     m_wdgLayerBox->bnRaise->setEnabled(false);
 
     if (cfg.sliderLabels()) {
         m_wdgLayerBox->opacityLabel->hide();
         m_wdgLayerBox->doubleOpacity->setPrefix(QString("%1:  ").arg(i18n("Opacity")));
     }
     m_wdgLayerBox->doubleOpacity->setRange(0, 100, 0);
     m_wdgLayerBox->doubleOpacity->setSuffix(i18n("%"));
 
     connect(m_wdgLayerBox->doubleOpacity, SIGNAL(valueChanged(qreal)), SLOT(slotOpacitySliderMoved(qreal)));
     connect(&m_opacityDelayTimer, SIGNAL(timeout()), SLOT(slotOpacityChanged()));
 
     connect(m_wdgLayerBox->cmbComposite, SIGNAL(activated(int)), SLOT(slotCompositeOpChanged(int)));
 
     m_newLayerMenu = new QMenu(this);
     m_wdgLayerBox->bnAdd->setMenu(m_newLayerMenu);
     m_wdgLayerBox->bnAdd->setPopupMode(QToolButton::MenuButtonPopup);
 
     m_nodeModel = new KisNodeModel(this);
     m_filteringModel = new KisNodeFilterProxyModel(this);
     m_filteringModel->setNodeModel(m_nodeModel);
 
     /**
      * Connect model updateUI() to enable/disable controls.
      * Note: nodeActivated() is connected separately in setImage(), because
      *       it needs particular order of calls: first the connection to the
      *       node manager should be called, then updateUI()
      */
     connect(m_nodeModel, SIGNAL(rowsInserted(QModelIndex,int,int)), SLOT(updateUI()));
     connect(m_nodeModel, SIGNAL(rowsRemoved(QModelIndex,int,int)), SLOT(updateUI()));
     connect(m_nodeModel, SIGNAL(rowsMoved(QModelIndex,int,int,QModelIndex,int)), SLOT(updateUI()));
     connect(m_nodeModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)), SLOT(updateUI()));
     connect(m_nodeModel, SIGNAL(modelReset()), SLOT(slotModelReset()));
 
     KisAction *showGlobalSelectionMask = new KisAction(i18n("&Show Global Selection Mask"), this);
     showGlobalSelectionMask->setObjectName("show-global-selection-mask");
     showGlobalSelectionMask->setActivationFlags(KisAction::ACTIVE_IMAGE);
     showGlobalSelectionMask->setToolTip(i18nc("@info:tooltip", "Shows global selection as a usual selection mask in <b>Layers</b> docker"));
     showGlobalSelectionMask->setCheckable(true);
     connect(showGlobalSelectionMask, SIGNAL(triggered(bool)), SLOT(slotEditGlobalSelection(bool)));
     m_actions.append(showGlobalSelectionMask);
 
     showGlobalSelectionMask->setChecked(cfg.showGlobalSelection());
 
     m_colorSelector = new KisColorLabelSelectorWidget(this);
     connect(m_colorSelector, SIGNAL(currentIndexChanged(int)), SLOT(slotColorLabelChanged(int)));
     m_colorSelectorAction = new QWidgetAction(this);
     m_colorSelectorAction->setDefaultWidget(m_colorSelector);
 
     connect(m_nodeModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
             &m_colorLabelCompressor, SLOT(start()));
 
     m_wdgLayerBox->listLayers->setModel(m_filteringModel);
     // this connection should be done *after* the setModel() call to
     // happen later than the internal selection model
     connect(m_filteringModel.data(), &KisNodeFilterProxyModel::rowsAboutToBeRemoved,
             this, &LayerBox::slotAboutToRemoveRows);
 
     connect(m_wdgLayerBox->cmbFilter, SIGNAL(selectedColorsChanged()), SLOT(updateLayerFiltering()));
 
     setEnabled(false);
 
     connect(&m_thumbnailCompressor, SIGNAL(timeout()), SLOT(updateThumbnail()));
     connect(&m_colorLabelCompressor, SIGNAL(timeout()), SLOT(updateAvailableLabels()));
 
 
 
     // set up the configure menu for changing thumbnail size
     QMenu* configureMenu = new QMenu(this);
     configureMenu->setStyleSheet("margin: 6px");
     configureMenu->addSection(i18n("Thumbnail Size"));
 
     m_wdgLayerBox->configureLayerDockerToolbar->setMenu(configureMenu);
     m_wdgLayerBox->configureLayerDockerToolbar->setIcon(KisIconUtils::loadIcon("configure"));
 
     m_wdgLayerBox->configureLayerDockerToolbar->setPopupMode(QToolButton::InstantPopup);
 
 
     // add horizontal slider
     thumbnailSizeSlider = new QSlider(this);
     thumbnailSizeSlider->setOrientation(Qt::Horizontal);
     thumbnailSizeSlider->setRange(20, 80);
 
     thumbnailSizeSlider->setValue(cfg.layerThumbnailSize(false)); // grab this from the kritarc
 
     thumbnailSizeSlider->setMinimumHeight(20);
     thumbnailSizeSlider->setMinimumWidth(40);
     thumbnailSizeSlider->setTickInterval(5);
 
 
     QWidgetAction *sliderAction= new QWidgetAction(this);
     sliderAction->setDefaultWidget(thumbnailSizeSlider);
     configureMenu->addAction(sliderAction);
 
 
     connect(thumbnailSizeSlider, SIGNAL(sliderMoved(int)), &m_thumbnailSizeCompressor, SLOT(start()));
     connect(&m_thumbnailSizeCompressor, SIGNAL(timeout()), SLOT(slotUpdateThumbnailIconSize()));
 
 }
 
 LayerBox::~LayerBox()
 {
     delete m_wdgLayerBox;
 }
 
 
 void expandNodesRecursively(KisNodeSP root, QPointer<KisNodeFilterProxyModel> filteringModel, NodeView *nodeView)
 {
     if (!root) return;
     if (filteringModel.isNull()) return;
     if (!nodeView) return;
 
     nodeView->blockSignals(true);
 
     KisNodeSP node = root->firstChild();
     while (node) {
         QModelIndex idx = filteringModel->indexFromNode(node);
         if (idx.isValid()) {
             nodeView->setExpanded(idx, !node->collapsed());
         }
         if (!node->collapsed() && node->childCount() > 0) {
             expandNodesRecursively(node, filteringModel, nodeView);
         }
         node = node->nextSibling();
     }
     nodeView->blockSignals(false);
 }
 
 void LayerBox::slotAddLayerBnClicked()
 {
     if (m_canvas) {
         KisNodeList nodes = m_nodeManager->selectedNodes();
 
         if (nodes.size() == 1) {
             KisAction *action = m_canvas->viewManager()->actionManager()->actionByName("add_new_paint_layer");
             action->trigger();
         } else {
             KisAction *action = m_canvas->viewManager()->actionManager()->actionByName("create_quick_group");
             action->trigger();
         }
     }
 }
 
 void LayerBox::setViewManager(KisViewManager* kisview)
 {
     m_nodeManager = kisview->nodeManager();
 
     Q_FOREACH (KisAction *action, m_actions) {
         kisview->actionManager()->
                 addAction(action->objectName(),
                           action);
     }
 
     connect(m_wdgLayerBox->bnAdd, SIGNAL(clicked()), this, SLOT(slotAddLayerBnClicked()));
     connectActionToButton(kisview, m_wdgLayerBox->bnDuplicate, "duplicatelayer");
 
     KisActionManager *actionManager = kisview->actionManager();
 
     KisAction *action = actionManager->createAction("RenameCurrentLayer");
     Q_ASSERT(action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotRenameCurrentNode()));
 
     m_propertiesAction = actionManager->createAction("layer_properties");
     Q_ASSERT(m_propertiesAction);
     new SyncButtonAndAction(m_propertiesAction, m_wdgLayerBox->bnProperties, this);
     connect(m_propertiesAction, SIGNAL(triggered()), this, SLOT(slotPropertiesClicked()));
 
     m_removeAction = actionManager->createAction("remove_layer");
     Q_ASSERT(m_removeAction);
     new SyncButtonAndAction(m_removeAction, m_wdgLayerBox->bnDelete, this);
     connect(m_removeAction, SIGNAL(triggered()), this, SLOT(slotRmClicked()));
 
     action = actionManager->createAction("move_layer_up");
     Q_ASSERT(action);
     new SyncButtonAndAction(action, m_wdgLayerBox->bnRaise, this);
     connect(action, SIGNAL(triggered()), this, SLOT(slotRaiseClicked()));
 
     action = actionManager->createAction("move_layer_down");
     Q_ASSERT(action);
     new SyncButtonAndAction(action, m_wdgLayerBox->bnLower, this);
     connect(action, SIGNAL(triggered()), this, SLOT(slotLowerClicked()));
 
     m_changeCloneSourceAction = actionManager->createAction("set-copy-from");
     Q_ASSERT(m_changeCloneSourceAction);
     connect(m_changeCloneSourceAction, &KisAction::triggered,
             this, &LayerBox::slotChangeCloneSourceClicked);
 }
 
 void LayerBox::setCanvas(KoCanvasBase *canvas)
 {
     if (m_canvas == canvas)
         return;
 
     setEnabled(canvas != 0);
 
     if (m_canvas) {
         m_canvas->disconnectCanvasObserver(this);
         m_nodeModel->setDummiesFacade(0, 0, 0, 0, 0);
         m_selectionActionsAdapter.reset();
 
         if (m_image) {
             KisImageAnimationInterface *animation = m_image->animationInterface();
             animation->disconnect(this);
         }
 
         disconnect(m_image, 0, this, 0);
         disconnect(m_nodeManager, 0, this, 0);
         disconnect(m_nodeModel, 0, m_nodeManager, 0);
         m_nodeManager->slotSetSelectedNodes(KisNodeList());
     }
 
     m_canvas = dynamic_cast<KisCanvas2*>(canvas);
 
     if (m_canvas) {
         m_image = m_canvas->image();
         connect(m_image, SIGNAL(sigImageUpdated(QRect)), &m_thumbnailCompressor, SLOT(start()));
 
         KisDocument* doc = static_cast<KisDocument*>(m_canvas->imageView()->document());
         KisShapeController *kritaShapeController =
                 dynamic_cast<KisShapeController*>(doc->shapeController());
         KisDummiesFacadeBase *kritaDummiesFacade =
                 static_cast<KisDummiesFacadeBase*>(kritaShapeController);
 
 
         m_selectionActionsAdapter.reset(new KisSelectionActionsAdapter(m_canvas->viewManager()->selectionManager()));
         m_nodeModel->setDummiesFacade(kritaDummiesFacade,
                                       m_image,
                                       kritaShapeController,
                                       m_selectionActionsAdapter.data(),
                                       m_nodeManager);
 
         connect(m_image, SIGNAL(sigAboutToBeDeleted()), SLOT(notifyImageDeleted()));
         connect(m_image, SIGNAL(sigNodeCollapsedChanged()), SLOT(slotNodeCollapsedChanged()));
 
         // cold start
         if (m_nodeManager) {
             setCurrentNode(m_nodeManager->activeNode());
             // Connection KisNodeManager -> LayerBox
             connect(m_nodeManager, SIGNAL(sigUiNeedChangeActiveNode(KisNodeSP)),
                     this, SLOT(setCurrentNode(KisNodeSP)));
 
             connect(m_nodeManager,
                     SIGNAL(sigUiNeedChangeSelectedNodes(QList<KisNodeSP>)),
                     SLOT(slotNodeManagerChangedSelection(QList<KisNodeSP>)));
         }
         else {
             setCurrentNode(m_canvas->imageView()->currentNode());
         }
 
         // Connection LayerBox -> KisNodeManager (isolate layer)
         connect(m_nodeModel, SIGNAL(toggleIsolateActiveNode()),
                 m_nodeManager, SLOT(toggleIsolateActiveNode()));
 
         KisImageAnimationInterface *animation = m_image->animationInterface();
         connect(animation, &KisImageAnimationInterface::sigUiTimeChanged, this, &LayerBox::slotImageTimeChanged);
 
         expandNodesRecursively(m_image->rootLayer(), m_filteringModel, m_wdgLayerBox->listLayers);
         m_wdgLayerBox->listLayers->scrollTo(m_wdgLayerBox->listLayers->currentIndex());
         updateAvailableLabels();
 
         addActionToMenu(m_newLayerMenu, "add_new_paint_layer");
         addActionToMenu(m_newLayerMenu, "add_new_group_layer");
         addActionToMenu(m_newLayerMenu, "add_new_clone_layer");
         addActionToMenu(m_newLayerMenu, "add_new_shape_layer");
         addActionToMenu(m_newLayerMenu, "add_new_adjustment_layer");
         addActionToMenu(m_newLayerMenu, "add_new_fill_layer");
         addActionToMenu(m_newLayerMenu, "add_new_file_layer");
         m_newLayerMenu->addSeparator();
         addActionToMenu(m_newLayerMenu, "add_new_transparency_mask");
         addActionToMenu(m_newLayerMenu, "add_new_filter_mask");
         addActionToMenu(m_newLayerMenu, "add_new_colorize_mask");
         addActionToMenu(m_newLayerMenu, "add_new_transform_mask");
         addActionToMenu(m_newLayerMenu, "add_new_selection_mask");
     }
 
 }
 
 
 void LayerBox::unsetCanvas()
 {
     setEnabled(false);
     if (m_canvas) {
         m_newLayerMenu->clear();
     }
 
     m_filteringModel->unsetDummiesFacade();
     disconnect(m_image, 0, this, 0);
     disconnect(m_nodeManager, 0, this, 0);
     disconnect(m_nodeModel, 0, m_nodeManager, 0);
     m_nodeManager->slotSetSelectedNodes(KisNodeList());
 
     m_canvas = 0;
 }
 
 void LayerBox::notifyImageDeleted()
 {
     setCanvas(0);
 }
 
 void LayerBox::updateUI()
 {
     if (!m_canvas) return;
     if (!m_nodeManager) return;
 
     KisNodeSP activeNode = m_nodeManager->activeNode();
 
     if (activeNode != m_activeNode) {
         if( !m_activeNode.isNull() )
             m_activeNode->disconnect(this);
         m_activeNode = activeNode;
 
         if (activeNode) {
             KisKeyframeChannel *opacityChannel = activeNode->getKeyframeChannel(KisKeyframeChannel::Opacity.id(), false);
             if (opacityChannel) {
                 watchOpacityChannel(opacityChannel);
             } else {
                 watchOpacityChannel(0);
                 connect(activeNode.data(), &KisNode::keyframeChannelAdded, this, &LayerBox::slotKeyframeChannelAdded);
             }
         }
     }
 
     m_wdgLayerBox->bnRaise->setEnabled(activeNode && activeNode->isEditable(false) && (activeNode->nextSibling()
                                                                                        || (activeNode->parent() && activeNode->parent() != m_image->root())));
     m_wdgLayerBox->bnLower->setEnabled(activeNode && activeNode->isEditable(false) && (activeNode->prevSibling()
                                                                                        || (activeNode->parent() && activeNode->parent() != m_image->root())));
 
     m_wdgLayerBox->doubleOpacity->setEnabled(activeNode && activeNode->isEditable(false));
 
     m_wdgLayerBox->cmbComposite->setEnabled(activeNode && activeNode->isEditable(false));
     m_wdgLayerBox->cmbComposite->validate(m_image->colorSpace());
 
     if (activeNode) {
-        if (activeNode->inherits("KisColorizeMask") ||
-                activeNode->inherits("KisLayer")) {
+        if (activeNode->inherits("KisColorizeMask") || activeNode->inherits("KisLayer")) {
 
             m_wdgLayerBox->doubleOpacity->setEnabled(true);
 
             if (!m_wdgLayerBox->doubleOpacity->isDragging()) {
                 slotSetOpacity(activeNode->opacity() * 100.0 / 255);
             }
 
             const KoCompositeOp* compositeOp = activeNode->compositeOp();
             if (compositeOp) {
                 slotSetCompositeOp(compositeOp);
             } else {
                 m_wdgLayerBox->cmbComposite->setEnabled(false);
             }
 
             const KisGroupLayer *group = qobject_cast<const KisGroupLayer*>(activeNode.data());
             bool compositeSelectionActive = !(group && group->passThroughMode());
 
             m_wdgLayerBox->cmbComposite->setEnabled(compositeSelectionActive);
         } else if (activeNode->inherits("KisMask")) {
             m_wdgLayerBox->cmbComposite->setEnabled(false);
             m_wdgLayerBox->doubleOpacity->setEnabled(false);
         }
     }
 }
 
 
 /**
  * This method is called *only* when non-GUI code requested the
  * change of the current node
  */
 void LayerBox::setCurrentNode(KisNodeSP node)
 {
     m_filteringModel->setActiveNode(node);
 
     QModelIndex index = node ? m_filteringModel->indexFromNode(node) : QModelIndex();
     m_filteringModel->setData(index, true, KisNodeModel::ActiveRole);
     updateUI();
 }
 
 void LayerBox::slotModelReset()
 {
     if(m_nodeModel->hasDummiesFacade()) {
         QItemSelection selection;
         Q_FOREACH (const KisNodeSP node, m_nodeManager->selectedNodes()) {
             const QModelIndex &idx = m_filteringModel->indexFromNode(node);
             if(idx.isValid()){
                 QItemSelectionRange selectionRange(idx);
                 selection << selectionRange;
             }
         }
 
         m_wdgLayerBox->listLayers->selectionModel()->select(selection, QItemSelectionModel::ClearAndSelect);
     }
 
     updateUI();
 }
 
 void LayerBox::slotSetCompositeOp(const KoCompositeOp* compositeOp)
 {
     KoID opId = KoCompositeOpRegistry::instance().getKoID(compositeOp->id());
 
     m_wdgLayerBox->cmbComposite->blockSignals(true);
     m_wdgLayerBox->cmbComposite->selectCompositeOp(opId);
     m_wdgLayerBox->cmbComposite->blockSignals(false);
 }
 
 // range: 0-100
 void LayerBox::slotSetOpacity(double opacity)
 {
     Q_ASSERT(opacity >= 0 && opacity <= 100);
     m_wdgLayerBox->doubleOpacity->blockSignals(true);
     m_wdgLayerBox->doubleOpacity->setValue(opacity);
     m_wdgLayerBox->doubleOpacity->blockSignals(false);
 }
 
 void LayerBox::slotContextMenuRequested(const QPoint &pos, const QModelIndex &index)
 {
     KisNodeList nodes = m_nodeManager->selectedNodes();
     KisNodeSP activeNode = m_nodeManager->activeNode();
     if (nodes.isEmpty() || !activeNode) return;
 
     if (m_canvas) {
         QMenu menu;
 
         const bool singleLayer = nodes.size() == 1;
 
         if (index.isValid()) {
             menu.addAction(m_propertiesAction);
 
             if (singleLayer) {
                 addActionToMenu(&menu, "layer_style");
             }
 
             Q_FOREACH(KisNodeSP node, nodes) {
                 if (node && node->inherits("KisCloneLayer")) {
                     menu.addAction(m_changeCloneSourceAction);
                     break;
                 }
             }
 
             {
                 KisSignalsBlocker b(m_colorSelector);
                 m_colorSelector->setCurrentIndex(singleLayer ? activeNode->colorLabelIndex() : -1);
             }
             menu.addAction(m_colorSelectorAction);
 
             menu.addSeparator();
 
             addActionToMenu(&menu, "cut_layer_clipboard");
             addActionToMenu(&menu, "copy_layer_clipboard");
             addActionToMenu(&menu, "paste_layer_from_clipboard");
             menu.addAction(m_removeAction);
             addActionToMenu(&menu, "duplicatelayer");
             addActionToMenu(&menu, "merge_layer");
             addActionToMenu(&menu, "new_from_visible");
 
 
             if (singleLayer) {
                 addActionToMenu(&menu, "flatten_image");
                 addActionToMenu(&menu, "flatten_layer");
             }
 
             menu.addSeparator();
             QMenu *selectMenu = menu.addMenu(i18n("&Select"));
             addActionToMenu(selectMenu, "select_all_layers");
             addActionToMenu(selectMenu, "select_visible_layers");
             addActionToMenu(selectMenu, "select_invisible_layers");
             addActionToMenu(selectMenu, "select_locked_layers");
             addActionToMenu(selectMenu, "select_unlocked_layers");
             QMenu *groupMenu = menu.addMenu(i18n("&Group"));
             addActionToMenu(groupMenu, "create_quick_group");
             addActionToMenu(groupMenu, "create_quick_clipping_group");
             addActionToMenu(groupMenu, "quick_ungroup");
             QMenu *locksMenu = menu.addMenu(i18n("&Toggle Locks && Visibility"));
             addActionToMenu(locksMenu, "toggle_layer_visibility");
             addActionToMenu(locksMenu, "toggle_layer_lock");
             addActionToMenu(locksMenu, "toggle_layer_inherit_alpha");
             addActionToMenu(locksMenu, "toggle_layer_alpha_lock");
 
             if (singleLayer) {
                 QMenu *addLayerMenu = menu.addMenu(i18n("&Add"));
                 addActionToMenu(addLayerMenu, "add_new_transparency_mask");
                 addActionToMenu(addLayerMenu, "add_new_filter_mask");
                 addActionToMenu(addLayerMenu, "add_new_colorize_mask");
                 addActionToMenu(addLayerMenu, "add_new_transform_mask");
                 addActionToMenu(addLayerMenu, "add_new_selection_mask");
                 addLayerMenu->addSeparator();
                 addActionToMenu(addLayerMenu, "add_new_clone_layer");
 
 
                 QMenu *convertToMenu = menu.addMenu(i18n("&Convert"));
                 addActionToMenu(convertToMenu, "convert_to_paint_layer");
                 addActionToMenu(convertToMenu, "convert_to_transparency_mask");
                 addActionToMenu(convertToMenu, "convert_to_filter_mask");
                 addActionToMenu(convertToMenu, "convert_to_selection_mask");
                 addActionToMenu(convertToMenu, "convert_to_file_layer");
 
                 QMenu *splitAlphaMenu = menu.addMenu(i18n("S&plit Alpha"));
                 addActionToMenu(splitAlphaMenu, "split_alpha_into_mask");
                 addActionToMenu(splitAlphaMenu, "split_alpha_write");
                 addActionToMenu(splitAlphaMenu, "split_alpha_save_merged");
             } else {
                 QMenu *addLayerMenu = menu.addMenu(i18n("&Add"));
                 addActionToMenu(addLayerMenu, "add_new_clone_layer");
             }
 
             menu.addSeparator();
 
             addActionToMenu(&menu, "show_in_timeline");
 
             if (singleLayer) {
                 KisNodeSP node = m_filteringModel->nodeFromIndex(index);
                 if (node && !node->inherits("KisTransformMask")) {
                     addActionToMenu(&menu, "isolate_layer");
                 }
 
                 addActionToMenu(&menu, "selectopaque");
 
             }
         }
         menu.exec(pos);
     }
 }
 
 void LayerBox::slotMinimalView()
 {
     m_wdgLayerBox->listLayers->setDisplayMode(NodeView::MinimalMode);
 }
 
 void LayerBox::slotDetailedView()
 {
     m_wdgLayerBox->listLayers->setDisplayMode(NodeView::DetailedMode);
 }
 
 void LayerBox::slotThumbnailView()
 {
     m_wdgLayerBox->listLayers->setDisplayMode(NodeView::ThumbnailMode);
 }
 
 void LayerBox::slotRmClicked()
 {
     if (!m_canvas) return;
     m_nodeManager->removeNode();
 }
 
 void LayerBox::slotRaiseClicked()
 {
     if (!m_canvas) return;
     m_nodeManager->raiseNode();
 }
 
 void LayerBox::slotLowerClicked()
 {
     if (!m_canvas) return;
     m_nodeManager->lowerNode();
 }
 
 void LayerBox::slotPropertiesClicked()
 {
     if (!m_canvas) return;
     if (KisNodeSP active = m_nodeManager->activeNode()) {
         m_nodeManager->nodeProperties(active);
     }
 }
 
 void LayerBox::slotChangeCloneSourceClicked()
 {
     if (!m_canvas) return;
     m_nodeManager->changeCloneSource();
 }
 
 void LayerBox::slotCompositeOpChanged(int index)
 {
     Q_UNUSED(index);
     if (!m_canvas) return;
 
     QString compositeOp = m_wdgLayerBox->cmbComposite->selectedCompositeOp().id();
     m_nodeManager->nodeCompositeOpChanged(m_nodeManager->activeColorSpace()->compositeOp(compositeOp));
 }
 
 void LayerBox::slotOpacityChanged()
 {
     if (!m_canvas) return;
     m_blockOpacityUpdate = true;
     m_nodeManager->nodeOpacityChanged(m_newOpacity);
     m_blockOpacityUpdate = false;
 }
 
 void LayerBox::slotOpacitySliderMoved(qreal opacity)
 {
     m_newOpacity = opacity;
     m_opacityDelayTimer.start(200);
 }
 
 void LayerBox::slotCollapsed(const QModelIndex &index)
 {
     KisNodeSP node = m_filteringModel->nodeFromIndex(index);
     if (node) {
         node->setCollapsed(true);
     }
 }
 
 void LayerBox::slotExpanded(const QModelIndex &index)
 {
     KisNodeSP node = m_filteringModel->nodeFromIndex(index);
     if (node) {
         node->setCollapsed(false);
     }
 }
 
 void LayerBox::slotSelectOpaque()
 {
     if (!m_canvas) return;
     QAction *action = m_canvas->viewManager()->actionManager()->actionByName("selectopaque");
     if (action) {
         action->trigger();
     }
 }
 
 void LayerBox::slotNodeCollapsedChanged()
 {
     expandNodesRecursively(m_image->rootLayer(), m_filteringModel, m_wdgLayerBox->listLayers);
 }
 
 inline bool isSelectionMask(KisNodeSP node)
 {
     return dynamic_cast<KisSelectionMask*>(node.data());
 }
 
 KisNodeSP LayerBox::findNonHidableNode(KisNodeSP startNode)
 {
     if (KisNodeManager::isNodeHidden(startNode, true) &&
             startNode->parent() &&
             !startNode->parent()->parent()) {
 
 
         KisNodeSP node = startNode->prevSibling();
         while (node && KisNodeManager::isNodeHidden(node, true)) {
             node = node->prevSibling();
         }
 
         if (!node) {
             node = startNode->nextSibling();
             while (node && KisNodeManager::isNodeHidden(node, true)) {
                 node = node->nextSibling();
             }
         }
 
         if (!node) {
             node = m_image->root()->lastChild();
             while (node && KisNodeManager::isNodeHidden(node, true)) {
                 node = node->prevSibling();
             }
         }
 
         KIS_ASSERT_RECOVER_NOOP(node && "cannot activate any node!");
         startNode = node;
     }
 
     return startNode;
 }
 
 void LayerBox::slotEditGlobalSelection(bool showSelections)
 {
     KisNodeSP lastActiveNode = m_nodeManager->activeNode();
     KisNodeSP activateNode = lastActiveNode;
     KisSelectionMaskSP globalSelectionMask;
 
     if (!showSelections) {
         activateNode = findNonHidableNode(activateNode);
     }
 
     m_nodeModel->setShowGlobalSelection(showSelections);
 
     globalSelectionMask = m_image->rootLayer()->selectionMask();
 
     // try to find deactivated, but visible masks
     if (!globalSelectionMask) {
         KoProperties properties;
         properties.setProperty("visible", true);
         QList<KisNodeSP> masks = m_image->rootLayer()->childNodes(QStringList("KisSelectionMask"), properties);
         if (!masks.isEmpty()) {
             globalSelectionMask = dynamic_cast<KisSelectionMask*>(masks.first().data());
         }
     }
 
     // try to find at least any selection mask
     if (!globalSelectionMask) {
         KoProperties properties;
         QList<KisNodeSP> masks = m_image->rootLayer()->childNodes(QStringList("KisSelectionMask"), properties);
         if (!masks.isEmpty()) {
             globalSelectionMask = dynamic_cast<KisSelectionMask*>(masks.first().data());
         }
     }
 
     if (globalSelectionMask) {
         if (showSelections) {
             activateNode = globalSelectionMask;
         }
     }
 
     if (activateNode != lastActiveNode) {
         m_nodeManager->slotNonUiActivatedNode(activateNode);
     } else if (lastActiveNode) {
         setCurrentNode(lastActiveNode);
     }
 
     if (showSelections && !globalSelectionMask) {
         KisProcessingApplicator applicator(m_image, 0,
                                            KisProcessingApplicator::NONE,
                                            KisImageSignalVector() << ModifiedSignal,
                                            kundo2_i18n("Quick Selection Mask"));
 
         applicator.applyCommand(
             new KisLayerUtils::KeepNodesSelectedCommand(
                 m_nodeManager->selectedNodes(), KisNodeList(),
                 lastActiveNode, 0, m_image, false),
             KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
         applicator.applyCommand(new KisSetEmptyGlobalSelectionCommand(m_image),
                                 KisStrokeJobData::SEQUENTIAL,
                                 KisStrokeJobData::EXCLUSIVE);
         applicator.applyCommand(new KisLayerUtils::SelectGlobalSelectionMask(m_image),
                                 KisStrokeJobData::SEQUENTIAL,
                                 KisStrokeJobData::EXCLUSIVE);
 
         applicator.end();
     } else if (!showSelections &&
                globalSelectionMask &&
                globalSelectionMask->selection()->selectedRect().isEmpty()) {
 
         KisProcessingApplicator applicator(m_image, 0,
                                            KisProcessingApplicator::NONE,
                                            KisImageSignalVector() << ModifiedSignal,
                                            kundo2_i18n("Cancel Quick Selection Mask"));
         applicator.applyCommand(new KisSetGlobalSelectionCommand(m_image, 0), KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
         applicator.end();
     }
 
 }
 
 void LayerBox::selectionChanged(const QModelIndexList selection)
 {
     if (!m_nodeManager) return;
 
     /**
      * When the user clears the extended selection by clicking on the
      * empty area of the docker, the selection should be reset on to
      * the active layer, which might be even unselected(!).
      */
     if (selection.isEmpty() && m_nodeManager->activeNode()) {
         QModelIndex selectedIndex =
                 m_filteringModel->indexFromNode(m_nodeManager->activeNode());
 
         m_wdgLayerBox->listLayers->selectionModel()->
                 setCurrentIndex(selectedIndex, QItemSelectionModel::ClearAndSelect);
         return;
     }
 
     QList<KisNodeSP> selectedNodes;
     Q_FOREACH (const QModelIndex &idx, selection) {
         selectedNodes << m_filteringModel->nodeFromIndex(idx);
     }
 
     m_nodeManager->slotSetSelectedNodes(selectedNodes);
     updateUI();
 }
 
 void LayerBox::slotAboutToRemoveRows(const QModelIndex &parent, int start, int end)
 {
     /**
      * Qt has changed its behavior when deleting an item. Previously
      * the selection priority was on the next item in the list, and
      * now it has shanged to the previous item. Here we just adjust
      * the selected item after the node removal. Please take care that
      * this method overrides what was done by the corresponding method
      * of QItemSelectionModel, which *has already done* its work. That
      * is why we use (start - 1) and (end + 1) in the activation
      * condition.
      *
      * See bug: https://bugs.kde.org/show_bug.cgi?id=345601
      */
 
     QModelIndex currentIndex = m_wdgLayerBox->listLayers->currentIndex();
     QAbstractItemModel *model = m_filteringModel;
 
     if (currentIndex.isValid() && parent == currentIndex.parent()
             && currentIndex.row() >= start - 1 && currentIndex.row() <= end + 1) {
         QModelIndex old = currentIndex;
 
         if (model && end < model->rowCount(parent) - 1) // there are rows left below the change
             currentIndex = model->index(end + 1, old.column(), parent);
         else if (model && start > 0) // there are rows left above the change
             currentIndex = model->index(start - 1, old.column(), parent);
         else // there are no rows left in the table
             currentIndex = QModelIndex();
 
         if (currentIndex.isValid() && currentIndex != old) {
             m_wdgLayerBox->listLayers->setCurrentIndex(currentIndex);
         }
     }
 }
 
 void LayerBox::slotNodeManagerChangedSelection(const KisNodeList &nodes)
 {
     if (!m_nodeManager) return;
 
     QModelIndexList newSelection;
     Q_FOREACH(KisNodeSP node, nodes) {
         newSelection << m_filteringModel->indexFromNode(node);
     }
 
     QItemSelectionModel *model = m_wdgLayerBox->listLayers->selectionModel();
 
     if (KritaUtils::compareListsUnordered(newSelection, model->selectedIndexes())) {
         return;
     }
 
     QItemSelection selection;
     Q_FOREACH(const QModelIndex &idx, newSelection) {
         selection.select(idx, idx);
     }
 
     model->select(selection, QItemSelectionModel::ClearAndSelect);
 }
 
 void LayerBox::updateThumbnail()
 {
     m_wdgLayerBox->listLayers->updateNode(m_wdgLayerBox->listLayers->currentIndex());
 }
 
 void LayerBox::slotRenameCurrentNode()
 {
     m_wdgLayerBox->listLayers->edit(m_wdgLayerBox->listLayers->currentIndex());
 }
 
 void LayerBox::slotColorLabelChanged(int label)
 {
     KisNodeList nodes = m_nodeManager->selectedNodes();
 
     Q_FOREACH(KisNodeSP node, nodes) {
         auto applyLabelFunc =
                 [label](KisNodeSP node) {
             node->setColorLabelIndex(label);
         };
 
         KisLayerUtils::recursiveApplyNodes(node, applyLabelFunc);
     }
 }
 
 void LayerBox::updateAvailableLabels()
 {
     if (!m_image) return;
     m_wdgLayerBox->cmbFilter->updateAvailableLabels(m_image->root());
 }
 
 void LayerBox::updateLayerFiltering()
 {
     m_filteringModel->setAcceptedLabels(m_wdgLayerBox->cmbFilter->selectedColors());
 }
 
 void LayerBox::slotKeyframeChannelAdded(KisKeyframeChannel *channel)
 {
     if (channel->id() == KisKeyframeChannel::Opacity.id()) {
         watchOpacityChannel(channel);
     }
 }
 
 void LayerBox::watchOpacityChannel(KisKeyframeChannel *channel)
 {
     if (m_opacityChannel) {
         m_opacityChannel->disconnect(this);
     }
 
     m_opacityChannel = channel;
     if (m_opacityChannel) {
         connect(m_opacityChannel, SIGNAL(sigKeyframeAdded(KisKeyframeSP)), this, SLOT(slotOpacityKeyframeChanged(KisKeyframeSP)));
         connect(m_opacityChannel, SIGNAL(sigKeyframeRemoved(KisKeyframeSP)), this, SLOT(slotOpacityKeyframeChanged(KisKeyframeSP)));
         connect(m_opacityChannel, SIGNAL(sigKeyframeMoved(KisKeyframeSP)), this, SLOT(slotOpacityKeyframeMoved(KisKeyframeSP)));
         connect(m_opacityChannel, SIGNAL(sigKeyframeChanged(KisKeyframeSP)), this, SLOT(slotOpacityKeyframeChanged(KisKeyframeSP)));
     }
 }
 
 void LayerBox::slotOpacityKeyframeChanged(KisKeyframeSP keyframe)
 {
     Q_UNUSED(keyframe);
     if (m_blockOpacityUpdate) return;
     updateUI();
 }
 
 void LayerBox::slotOpacityKeyframeMoved(KisKeyframeSP keyframe, int fromTime)
 {
     Q_UNUSED(fromTime);
     slotOpacityKeyframeChanged(keyframe);
 }
 
 void LayerBox::slotImageTimeChanged(int time)
 {
     Q_UNUSED(time);
     updateUI();
 }
 
 void LayerBox::slotUpdateIcons() {
     m_wdgLayerBox->bnAdd->setIcon(KisIconUtils::loadIcon("addlayer"));
     m_wdgLayerBox->bnRaise->setIcon(KisIconUtils::loadIcon("arrowupblr"));
     m_wdgLayerBox->bnDelete->setIcon(KisIconUtils::loadIcon("deletelayer"));
     m_wdgLayerBox->bnLower->setIcon(KisIconUtils::loadIcon("arrowdown"));
     m_wdgLayerBox->bnProperties->setIcon(KisIconUtils::loadIcon("properties"));
     m_wdgLayerBox->bnDuplicate->setIcon(KisIconUtils::loadIcon("duplicatelayer"));
 
     // call child function about needing to update icons
     m_wdgLayerBox->listLayers->slotUpdateIcons();
 }
 
 void LayerBox::slotUpdateThumbnailIconSize()
 {
     KisConfig cfg(false);
     cfg.setLayerThumbnailSize(thumbnailSizeSlider->value());
 
     // this is a hack to force the layers list to update its display and
     // re-layout all the layers with the new thumbnail size
     resize(this->width()+1, this->height()+1);
     resize(this->width()-1, this->height()-1);
 }
 
 
 #include "moc_LayerBox.cpp"
diff --git a/plugins/extensions/pykrita/plugin/plugin.cpp b/plugins/extensions/pykrita/plugin/plugin.cpp
index 61cd856b12..028798e2f4 100644
--- a/plugins/extensions/pykrita/plugin/plugin.cpp
+++ b/plugins/extensions/pykrita/plugin/plugin.cpp
@@ -1,95 +1,99 @@
 /*
  * Copyright (c) 2014 Boudewijn Rempt (boud@valdyas.org)
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2 of the License.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "plugin.h"
 
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 #include <kpluginfactory.h>
 
 #include <kis_preference_set_registry.h>
 #include "pyqtpluginsettings.h"
 
 #include <Krita.h>
 
 K_PLUGIN_FACTORY_WITH_JSON(KritaPyQtPluginFactory, "kritapykrita.json", registerPlugin<KritaPyQtPlugin>();)
 
 KritaPyQtPlugin::KritaPyQtPlugin(QObject *parent, const QVariantList &)
     : QObject(parent)
     , m_autoReload(false)
 {
     dbgScript << "Loading Python plugin";
 
     PyKrita::InitResult initResult = PyKrita::initialize();
     switch (initResult) {
         case PyKrita::INIT_OK:
             break;
         case PyKrita::INIT_CANNOT_LOAD_PYTHON_LIBRARY:
             qWarning() << i18n("Cannot load Python library");
             return;
         case PyKrita::INIT_CANNOT_SET_PYTHON_PATHS:
             qWarning() << i18n("Cannot set Python paths");
             return;
         case PyKrita::INIT_CANNOT_LOAD_PYKRITA_MODULE:
             qWarning() << i18n("Cannot load built-in pykrita module");
             return;
         default:
             qWarning() << i18n("Unexpected error initializing python plugin.");
             return;
     }
 
     pluginManager = PyKrita::pluginManager();
 
     KisPreferenceSetRegistry *preferenceSetRegistry = KisPreferenceSetRegistry::instance();
     PyQtPluginSettingsFactory* settingsFactory = new PyQtPluginSettingsFactory(pluginManager);
 
     //load and save preferences
     //if something in kritarc is missing, then the default from this load function will be used and saved back to kconfig.
     //this way, cfg.readEntry() in any part won't be able to set its own default
     KisPreferenceSet* settings = settingsFactory->createPreferenceSet();
     KIS_SAFE_ASSERT_RECOVER_RETURN(settings);
     settings->loadPreferences();
     settings->savePreferences();
     delete settings;
 
     preferenceSetRegistry->add("PyQtPluginSettingsFactory", settingsFactory);
 
     // Try to import the `pykrita` module
     PyKrita::Python py = PyKrita::Python();
     PyObject* pykritaPackage = py.moduleImport("pykrita");
     pykritaPackage = py.moduleImport("krita");
 
     if (pykritaPackage) {
         dbgScript << "Loaded pykrita, now load plugins";
         pluginManager->scanPlugins();
         pluginManager->tryLoadEnabledPlugins();
         //py.functionCall("_pykritaLoaded", PyKrita::Python::PYKRITA_ENGINE);
     } else  {
         dbgScript << "Cannot load pykrita module";
     }
 
     Q_FOREACH (Extension *extension, Krita::instance()->extensions()) {
         extension->setup();
     }
 }
 
 KritaPyQtPlugin::~KritaPyQtPlugin()
 {
+    // XXX: With Qt 5.14, this crashes Krita on exit. See https://bugs.kde.org/show_bug.cgi?id=417465
+    //      So, for now, we just don't call finalize...
+#if QT_VERSION < QT_VERSION_CHECK(5,14,0)
     PyKrita::finalize();
+#endif
 }
 
 #include "plugin.moc"
diff --git a/plugins/impex/raw/kis_raw_import.cpp b/plugins/impex/raw/kis_raw_import.cpp
index 29709cc1c9..440ba6dc2a 100644
--- a/plugins/impex/raw/kis_raw_import.cpp
+++ b/plugins/impex/raw/kis_raw_import.cpp
@@ -1,199 +1,199 @@
 /*
  *  Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 #include "kis_raw_import.h"
 
 #include <kpluginfactory.h>
 #include <KoDialog.h>
 
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KisImportExportErrorCode.h>
 #include <KoColorSpaceTraits.h>
 
 #include "kis_debug.h"
 #include "KisDocument.h"
 #include "kis_image.h"
 #include "kis_paint_device.h"
 #include "kis_transaction.h"
 #include "kis_group_layer.h"
 #include "kis_paint_layer.h"
 #include "kis_iterator_ng.h"
 
 #include <kdcraw.h>
 #include <libkdcraw_version.h>
 
 using namespace KDcrawIface;
 
 K_PLUGIN_FACTORY_WITH_JSON(KisRawImportFactory, "krita_raw_import.json",
                            registerPlugin<KisRawImport>();)
 
 KisRawImport::KisRawImport(QObject *parent, const QVariantList &)
         : KisImportExportFilter(parent)
 {
     m_dialog = new KoDialog();
     m_dialog->enableButtonApply(false);
     QWidget* widget = new QWidget;
     m_rawWidget.setupUi(widget);
     m_dialog->setMainWidget(widget);
     connect(m_rawWidget.pushButtonUpdate, SIGNAL(clicked()), this, SLOT(slotUpdatePreview()));
 }
 
 KisRawImport::~KisRawImport()
 {
     delete m_dialog;
 }
 
 inline quint16 correctIndian(quint16 v)
 {
 #if KDCRAW_VERSION < 0x000400
     return ((v & 0x00FF) << 8) | ((v & 0xFF00 >> 8));
 #else
     return v;
 #endif
 }
 
 KisImportExportErrorCode KisRawImport::convert(KisDocument *document, QIODevice */*io*/,  KisPropertiesConfigurationSP /*configuration*/)
 {
     // Show dialog
     m_dialog->setCursor(Qt::ArrowCursor);
     QApplication::setOverrideCursor(Qt::ArrowCursor);
 
 #if KDCRAW_VERSION < 0x010200
     m_rawWidget.rawSettings->setDefaultSettings();
 #else
     m_rawWidget.rawSettings->resetToDefault();
 #endif
 
     slotUpdatePreview();
 
     int r = QDialog::Accepted;
     if (!batchMode()) {
         r = m_dialog->exec();
     }
 
     if (r == QDialog::Accepted) {
 
         QApplication::setOverrideCursor(Qt::WaitCursor);
         // Do the decoding
         // TODO: it would probably be better done in a thread, while an other thread simulate that the application is still living (or even better if libkdcraw was giving us some progress report
         QByteArray imageData;
         RawDecodingSettings settings = rawDecodingSettings();
         settings.sixteenBitsImage =  true;
         int width, height, rgbmax;
         KDcraw dcraw;
         if (!dcraw.decodeRAWImage(filename(), settings, imageData, width, height, rgbmax))
             return ImportExportCodes::FileFormatIncorrect;
 
         QApplication::restoreOverrideCursor();
 
         // Init the image
         const KoColorSpace* cs = KoColorSpaceRegistry::instance()->rgb16();
         KisImageSP image = new KisImage(document->createUndoStore(), width, height, cs, filename());
         KIS_ASSERT_RECOVER_RETURN_VALUE(!image.isNull(), ImportExportCodes::InternalError);
 
         KisPaintLayerSP layer = new KisPaintLayer(image, image->nextLayerName(), quint8_MAX);
 
         image->addNode(layer, image->rootLayer());
         KIS_ASSERT_RECOVER_RETURN_VALUE(!layer.isNull(), ImportExportCodes::InternalError);
 
         KisPaintDeviceSP device = layer->paintDevice();
         KIS_ASSERT_RECOVER_RETURN_VALUE(!device.isNull(), ImportExportCodes::InternalError);
 
         // Copy the data
         KisHLineIteratorSP it = device->createHLineIteratorNG(0, 0, width);
         for (int y = 0; y < height; ++y) {
             do {
                 KoBgrU16Traits::Pixel* pixel = reinterpret_cast<KoBgrU16Traits::Pixel*>(it->rawData());
-                quint16* ptr = ((quint16*)imageData.data()) + (y * width + it->x()) * 3;
+                quint16* ptr = (reinterpret_cast<quint16*>(imageData.data())) + (y * width + it->x()) * 3;
 #if KDCRAW_VERSION < 0x000400
                 pixel->red = correctIndian(ptr[2]);
                 pixel->green = correctIndian(ptr[1]);
                 pixel->blue = correctIndian(ptr[0]);
 #else
                 pixel->red = correctIndian(ptr[0]);
                 pixel->green = correctIndian(ptr[1]);
                 pixel->blue = correctIndian(ptr[2]);
 #endif
                 pixel->alpha = 0xFFFF;
             } while (it->nextPixel());
             it->nextRow();
         }
 
         QApplication::restoreOverrideCursor();
         document->setCurrentImage(image);
         return ImportExportCodes::OK;
     }
 
     QApplication::restoreOverrideCursor();
     return ImportExportCodes::Cancelled;
 }
 
 void KisRawImport::slotUpdatePreview()
 {
     QByteArray imageData;
     RawDecodingSettings settings = rawDecodingSettings();
     settings.sixteenBitsImage =  false;
     int width, height, rgbmax;
     KDcraw dcraw;
     if (dcraw.decodeHalfRAWImage(filename(), settings, imageData, width, height, rgbmax)) {
         QImage image(width, height, QImage::Format_RGB32);
         for (int y = 0; y < height; ++y) {
             QRgb *pixel= reinterpret_cast<QRgb *>(image.scanLine(y));
             for (int x = 0; x < width; ++x) {
                 quint8* ptr = ((quint8*)imageData.data()) + (y * width + x) * 3;
                 pixel[x] = qRgb(ptr[0], ptr[1], ptr[2]);
             }
         }
         m_rawWidget.preview->setPixmap(QPixmap::fromImage(image));
     }
 }
 
 RawDecodingSettings KisRawImport::rawDecodingSettings()
 {
 #if KDCRAW_VERSION < 0x010200
     RawDecodingSettings settings;
     settings.sixteenBitsImage = true;
     settings.brightness = m_rawWidget.rawSettings->brightness();
     settings.RAWQuality = m_rawWidget.rawSettings->quality();
     settings.outputColorSpace = m_rawWidget.rawSettings->outputColorSpace();
     settings.RGBInterpolate4Colors = m_rawWidget.rawSettings->useFourColor();
     settings.DontStretchPixels = m_rawWidget.rawSettings->useDontStretchPixels();
     settings.unclipColors = m_rawWidget.rawSettings->unclipColor();
     settings.whiteBalance = m_rawWidget.rawSettings->whiteBalance();
     settings.customWhiteBalance = m_rawWidget.rawSettings->customWhiteBalance();
     settings.customWhiteBalanceGreen = m_rawWidget.rawSettings->customWhiteBalanceGreen();
 
     settings.enableBlackPoint = m_rawWidget.rawSettings->useBlackPoint();
     settings.blackPoint = m_rawWidget.rawSettings->blackPoint();
 
     settings.enableNoiseReduction = m_rawWidget.rawSettings->useNoiseReduction();
     settings.NRThreshold = m_rawWidget.rawSettings->NRThreshold();
 
     settings.enableCACorrection = m_rawWidget.rawSettings->useCACorrection();
     settings.caMultiplier[0] = m_rawWidget.rawSettings->caRedMultiplier();
     settings.caMultiplier[1] = m_rawWidget.rawSettings->caBlueMultiplier();
 
 
     return settings;
 #else
     return m_rawWidget.rawSettings->settings();
 #endif
 }
 
 #include "kis_raw_import.moc"
diff --git a/plugins/python/mixer_slider_docker/kritapykrita_mixer_slider_docker.desktop b/plugins/python/mixer_slider_docker/kritapykrita_mixer_slider_docker.desktop
index 446a05ad34..1841cd0915 100644
--- a/plugins/python/mixer_slider_docker/kritapykrita_mixer_slider_docker.desktop
+++ b/plugins/python/mixer_slider_docker/kritapykrita_mixer_slider_docker.desktop
@@ -1,32 +1,34 @@
 [Desktop Entry]
 Type=Service
 ServiceTypes=Krita/PythonPlugin
 X-KDE-Library=mixer_slider_docker
 X-Python-2-Compatible=false
 X-Krita-Manual=Manual.html
 Name=Mixer Slider docker
 Name[ca]=Acoblador Control lliscant del mesclador
 Name[ca@valencia]=Acoblador Control lliscant del mesclador
 Name[es]=Panel del deslizador del mezclador
 Name[et]=Mikseri liuguri dokk
 Name[it]=Area di aggancio cursore di miscelazione
 Name[ko]=믹서 슬라이더 도커
 Name[nl]=Vastzetter van schuifregelaar van mixer
+Name[nn]=Fargeblandingsdokk
 Name[pt]=Área da Barra de Mistura
 Name[sv]=Dockningsfönster för blandningsreglage
 Name[uk]=Бічна панель повзунка мікшера
 Name[x-test]=xxMixer Slider dockerxx
 Name[zh_TW]=混色滑動條工具面板
 Comment=A color slider.
 Comment[ca]=Un control lliscant per al color.
 Comment[ca@valencia]=Un control lliscant per al color.
 Comment[es]=Deslizador de color.
 Comment[et]=Värviliugur.
 Comment[it]=Cursore del colore.
 Comment[ko]=컬러 슬라이더입니다.
 Comment[nl]=Een schuifregelaar voor kleur
+Comment[nn]=Palett med fargeovergangar
 Comment[pt]=Uma barra de cores.
 Comment[sv]=Ett färgreglage.
 Comment[uk]=Повзунок кольору.
 Comment[x-test]=xxA color slider.xx
 Comment[zh_TW]=色彩滑動條。