diff --git a/CMakeLists.txt b/CMakeLists.txt
index bb7a668df2..cdf8f95877 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,740 +1,740 @@
 project(krita)
 
 message(STATUS "Using CMake version: ${CMAKE_VERSION}")
 
 cmake_minimum_required(VERSION 2.8.12 FATAL_ERROR)
 
 set(MIN_QT_VERSION 5.6.0)
 
 set(MIN_FRAMEWORKS_VERSION 5.18.0)
 
 if (POLICY CMP0002)
     cmake_policy(SET CMP0002 OLD)
 endif()
 
 if (POLICY CMP0017)
     cmake_policy(SET CMP0017 NEW)
 endif ()
 
 if (POLICY CMP0022)
     cmake_policy(SET CMP0022 OLD)
 endif ()
 
 if (POLICY CMP0026)
     cmake_policy(SET CMP0026 OLD)
 endif()
 
 if (POLICY CMP0042)
     cmake_policy(SET CMP0042 NEW)
 endif()
 
 if (POLICY CMP0046)
     cmake_policy(SET CMP0046 OLD)
 endif ()
 
 if (POLICY CMP0059)
     cmake_policy(SET CMP0059 OLD)
 endif()
 
 if (POLICY CMP0063)
     cmake_policy(SET CMP0063 OLD)
 endif()
 
 if (POLICY CMP0054)
     cmake_policy(SET CMP0054 OLD)
 endif()
 
 if (POLICY CMP0064)
     cmake_policy(SET CMP0064 OLD)
 endif()
 
 
 if (APPLE)
     set(APPLE_SUPPRESS_X11_WARNING TRUE)
     set(KDE_SKIP_RPATH_SETTINGS TRUE)
     set(CMAKE_MACOSX_RPATH 1)
     set(BUILD_WITH_INSTALL_RPATH 1)
     add_definitions(-mmacosx-version-min=10.11 -Wno-macro-redefined -Wno-deprecated-register)
 endif()
 
 if (CMAKE_COMPILER_IS_GNUCXX AND NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.9 AND NOT WIN32)
     add_definitions(-Werror=delete-incomplete)
 endif()
 
  ######################
 #######################
 ## Constants defines ##
 #######################
 ######################
 
 # define common versions of Krita applications, used to generate kritaversion.h
 # update these version for every release:
-set(KRITA_VERSION_STRING "4.1.0-pre-alpha")
+set(KRITA_VERSION_STRING "4.2.0-pre-alpha")
 # Major version: 3 for 3.x, 4 for 4.x, etc.
 set(KRITA_STABLE_VERSION_MAJOR 4)
 # Minor version: 0 for 4.0, 1 for 4.1, etc.
-set(KRITA_STABLE_VERSION_MINOR 1)
+set(KRITA_STABLE_VERSION_MINOR 2)
 # Bugfix release version, or 0 for before the first stable release
 set(KRITA_VERSION_RELEASE 0)
 # the 4th digit, really only used for the Windows installer:
 # - [Pre-]Alpha: Starts from 0, increment 1 per release
 # - Beta: Starts from 50, increment 1 per release
 # - Stable: Set to 100, bump to 101 if emergency update is needed
 set(KRITA_VERSION_REVISION 0)
 set(KRITA_ALPHA 1) # uncomment only for Alpha
 #set(KRITA_BETA 1) # uncomment only for Beta
 #set(KRITA_RC 1) # uncomment only for RC
 set(KRITA_YEAR 2018) # update every year
 
 if(NOT DEFINED KRITA_ALPHA AND NOT DEFINED KRITA_BETA AND NOT DEFINED KRITA_RC)
     set(KRITA_STABLE 1) # do not edit
 endif()
 
 message(STATUS "Krita version: ${KRITA_VERSION_STRING}")
 
 # Define the generic version of the Krita libraries here
 # This makes it easy to advance it when the next Krita release comes.
 # 14 was the last GENERIC_KRITA_LIB_VERSION_MAJOR of the previous Krita series
 # (2.x) so we're starting with 15 in 3.x series, 16 in 4.x series
 if(KRITA_STABLE_VERSION_MAJOR EQUAL 4)
     math(EXPR GENERIC_KRITA_LIB_VERSION_MAJOR "${KRITA_STABLE_VERSION_MINOR} + 16")
 else()
     # let's make sure we won't forget to update the "16"
     message(FATAL_ERROR "Reminder: please update offset == 16 used to compute GENERIC_KRITA_LIB_VERSION_MAJOR to something bigger")
 endif()
 set(GENERIC_KRITA_LIB_VERSION "${GENERIC_KRITA_LIB_VERSION_MAJOR}.0.0")
 set(GENERIC_KRITA_LIB_SOVERSION "${GENERIC_KRITA_LIB_VERSION_MAJOR}")
 
 LIST (APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/modules")
 LIST (APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/kde_macro")
 
 # fetch git revision for the current build
 
 set(KRITA_GIT_SHA1_STRING "")
 set(KRITA_GIT_BRANCH_STRING "")
 
 include(GetGitRevisionDescription)
 get_git_head_hash(GIT_SHA1)
 get_git_branch(GIT_BRANCH)
 
 if(GIT_SHA1)
    string(SUBSTRING ${GIT_SHA1} 0 7 GIT_SHA1)
    set(KRITA_GIT_SHA1_STRING ${GIT_SHA1})
    if(GIT_BRANCH)
        set(KRITA_GIT_BRANCH_STRING ${GIT_BRANCH})
    else()
        set(KRITA_GIT_BRANCH_STRING "(detached HEAD)")
    endif()
 endif()
 
 # create test make targets
 enable_testing()
 # collect list of broken tests, empty here to start fresh with each cmake run
 set(KRITA_BROKEN_TESTS "" CACHE INTERNAL "KRITA_BROKEN_TESTS")
 
  ############
 #############
 ## Options ##
 #############
 ############
 
 include(FeatureSummary)
 
 if (WIN32)
     option(USE_DRMINGW "Support the Dr. Mingw crash handler (only on windows)" ON)
     add_feature_info("Dr. Mingw" USE_DRMINGW "Enable the Dr. Mingw crash handler")
 
     if (MINGW)
         option(USE_MINGW_HARDENING_LINKER "Enable DEP (NX), ASLR and high-entropy ASLR linker flags (mingw-w64)" ON)
         add_feature_info("Linker Security Flags" USE_MINGW_HARDENING_LINKER "Enable DEP (NX), ASLR and high-entropy ASLR linker flags")
         if (USE_MINGW_HARDENING_LINKER)
             set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--dynamicbase -Wl,--nxcompat -Wl,--disable-auto-image-base")
             set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--dynamicbase -Wl,--nxcompat -Wl,--disable-auto-image-base")
             set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -Wl,--dynamicbase -Wl,--nxcompat -Wl,--disable-auto-image-base")
             if ("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
                 # Enable high-entropy ASLR for 64-bit
                 # The image base has to be >4GB for HEASLR to be enabled.
                 # The values used here are kind of arbitrary.
                 set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--high-entropy-va -Wl,--image-base,0x140000000")
                 set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--high-entropy-va -Wl,--image-base,0x180000000")
                 set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -Wl,--high-entropy-va -Wl,--image-base,0x180000000")
             endif ("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
         else (USE_MINGW_HARDENING_LINKER)
             message(WARNING "Linker Security Flags not enabled!")
         endif (USE_MINGW_HARDENING_LINKER)
     endif (MINGW)
 endif ()
 
 option(HIDE_SAFE_ASSERTS "Don't show message box for \"safe\" asserts, just ignore them automatically and dump a message to the terminal." ON)
 configure_file(config-hide-safe-asserts.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-hide-safe-asserts.h)
 add_feature_info("Safe Asserts" HIDE_SAFE_ASSERTS "Don't show message box for \"safe\" asserts, just ignore them automatically and dump a message to the terminal.")
 
 option(FOUNDATION_BUILD "A Foundation build is a binary release build that can package some extra things like color themes. Linux distributions that build and install Krita into a default system location should not define this option to true." OFF)
 add_feature_info("Foundation Build" FOUNDATION_BUILD "A Foundation build is a binary release build that can package some extra things like color themes. Linux distributions that build and install Krita into a default system location should not define this option to true.")
 
 option(KRITA_ENABLE_BROKEN_TESTS "Enable tests that are marked as broken" OFF)
 add_feature_info("Enable Broken Tests" KRITA_ENABLE_BROKEN_TESTS "Runs broken test when \"make test\" is invoked (use -DKRITA_ENABLE_BROKEN_TESTS=ON to enable).")
 
 option(ENABLE_PYTHON_2 "Enables the compiler to look for Python 2.7 instead of Python 3. Some packaged scripts are not compatible with Python 2 and this should only be used if you really have to use 2.7." OFF)
 
 include(MacroJPEG)
 
  #########################################################
 ## Look for Python3 It is also searched by KF5,         ##
 ## so we should request the correct version in advance  ##
 #########################################################
 
 function(TestCompileLinkPythonLibs OUTPUT_VARNAME)
     include(CheckCXXSourceCompiles)
     set(CMAKE_REQUIRED_INCLUDES ${PYTHON_INCLUDE_PATH})
     set(CMAKE_REQUIRED_LIBRARIES ${PYTHON_LIBRARIES})
     if (MINGW)
         set(CMAKE_REQUIRED_DEFINITIONS -D_hypot=hypot)
     endif (MINGW)
     unset(${OUTPUT_VARNAME} CACHE)
     CHECK_CXX_SOURCE_COMPILES("
 #include <Python.h>
 int main(int argc, char *argv[]) {
     Py_InitializeEx(0);
 }" ${OUTPUT_VARNAME})
 endfunction()
 
 if(MINGW)
     if(ENABLE_PYTHON_2)
         message(FATAL_ERROR "Python 2.7 is not supported on Windows at the moment.")
     else(ENABLE_PYTHON_2)
         find_package(PythonInterp 3.6 EXACT)
         find_package(PythonLibs 3.6 EXACT)
     endif(ENABLE_PYTHON_2)
     if (PYTHONLIBS_FOUND AND PYTHONINTERP_FOUND)
         if(ENABLE_PYTHON_2)
             find_package(PythonLibrary 2.7)
         else(ENABLE_PYTHON_2)
             find_package(PythonLibrary 3.6)
         endif(ENABLE_PYTHON_2)
         TestCompileLinkPythonLibs(CAN_USE_PYTHON_LIBS)
         if (NOT CAN_USE_PYTHON_LIBS)
             message(FATAL_ERROR "Compiling with Python library failed, please check whether the architecture is correct. Python will be disabled.")
         endif (NOT CAN_USE_PYTHON_LIBS)
     endif (PYTHONLIBS_FOUND AND PYTHONINTERP_FOUND)
 else(MINGW)
     if(ENABLE_PYTHON_2)
         find_package(PythonInterp 2.7)
         find_package(PythonLibrary 2.7)
     else(ENABLE_PYTHON_2)
         find_package(PythonInterp 3.0)
         find_package(PythonLibrary 3.0)
     endif(ENABLE_PYTHON_2)
 endif(MINGW)
 
  ########################
 #########################
 ## Look for KDE and Qt ##
 #########################
 ########################
 
 find_package(ECM 5.22 REQUIRED NOMODULE)
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${ECM_MODULE_PATH} ${ECM_KDE_MODULE_DIR})
 include(ECMOptionalAddSubdirectory)
 include(ECMAddAppIcon)
 include(ECMSetupVersion)
 include(ECMMarkNonGuiExecutable)
 include(ECMGenerateHeaders)
 include(GenerateExportHeader)
 include(ECMMarkAsTest)
 include(ECMInstallIcons)
 
 include(CMakePackageConfigHelpers)
 include(WriteBasicConfigVersionFile)
 include(CheckFunctionExists)
 
 include(KDEInstallDirs)
 include(KDECMakeSettings)
 include(KDECompilerSettings)
 
 # do not reorder to be alphabetical: this is the order in which the frameworks
 # depend on each other.
 find_package(KF5 ${MIN_FRAMEWORKS_VERSION} REQUIRED COMPONENTS
         Archive
         Config
         WidgetsAddons
         Completion
         CoreAddons
         GuiAddons
         I18n
         ItemModels
         ItemViews
         WindowSystem
 )
 
 # KConfig deprecated authorizeKAction. In order to be warning free,
 # compile with the updated function when the dependency is new enough.
 # Remove this (and the uses of the define) when the minimum KF5
 # version is >= 5.24.0.
 if (${KF5Config_VERSION} VERSION_LESS "5.24.0" )
     message("Old KConfig (< 5.24.0) found.")
     add_definitions(-DKCONFIG_BEFORE_5_24)
 endif()
 
 find_package(Qt5 ${MIN_QT_VERSION}
         REQUIRED COMPONENTS
         Core
         Gui
         Widgets
         Xml
         Network
         PrintSupport
         Svg
         Test
         Concurrent
 )
 
 include (MacroAddFileDependencies)
 include (MacroBoolTo01)
 include (MacroEnsureOutOfSourceBuild)
 macro_ensure_out_of_source_build("Compiling Krita inside the source directory is not possible. Please refer to the build instruction https://community.kde.org/Krita#Build_Instructions")
 
 
 
 # Note: OPTIONAL_COMPONENTS does not seem to be reliable
 # (as of ECM 5.15.0, CMake 3.2)
 
 find_package(Qt5Multimedia ${MIN_QT_VERSION})
 set_package_properties(Qt5Multimedia PROPERTIES
         DESCRIPTION "Qt multimedia integration"
         URL "http://www.qt.io/"
         TYPE OPTIONAL
         PURPOSE "Optionally used to provide sound support for animations")
 
 macro_bool_to_01(Qt5Multimedia_FOUND HAVE_QT_MULTIMEDIA)
 configure_file(config-qtmultimedia.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-qtmultimedia.h )
 
 if (NOT APPLE)
 find_package(Qt5Quick ${MIN_QT_VERSION})
 set_package_properties(Qt5Quick PROPERTIES
         DESCRIPTION "QtQuick"
         URL "http://www.qt.io/"
         TYPE OPTIONAL
         PURPOSE "Optionally used for the touch gui for Krita")
 
 macro_bool_to_01(Qt5Quick_FOUND HAVE_QT_QUICK)
 
 find_package(Qt5QuickWidgets ${MIN_QT_VERSION})
 set_package_properties(Qt5QuickWidgets PROPERTIES
         DESCRIPTION "QtQuickWidgets"
         URL "http://www.qt.io/"
         TYPE OPTIONAL
         PURPOSE "Optionally used for the touch gui for Krita")
 endif()
 
 if (NOT WIN32 AND NOT APPLE)
 
     find_package(Qt5 ${MIN_QT_VERSION} REQUIRED X11Extras)
 
     find_package(Qt5DBus ${MIN_QT_VERSION})
     set(HAVE_DBUS ${Qt5DBus_FOUND})
     set_package_properties(Qt5DBus PROPERTIES
         DESCRIPTION "Qt DBUS integration"
         URL "http://www.qt.io/"
         TYPE OPTIONAL
         PURPOSE "Optionally used to provide a dbus api on Linux")
 
     find_package(KF5KIO ${MIN_FRAMEWORKS_VERSION})
     macro_bool_to_01(KF5KIO_FOUND HAVE_KIO)
     set_package_properties(KF5KIO PROPERTIES
         DESCRIPTION "KDE's KIO Framework"
         URL "http://api.kde.org/frameworks-api/frameworks5-apidocs/kio/html/index.html"
         TYPE OPTIONAL
         PURPOSE "Optionally used for recent document handling")
 
     find_package(KF5Crash ${MIN_FRAMEWORKS_VERSION})
     macro_bool_to_01(KF5Crash_FOUND HAVE_KCRASH)
     set_package_properties(KF5Crash PROPERTIES
         DESCRIPTION "KDE's Crash Handler"
         URL "http://api.kde.org/frameworks-api/frameworks5-apidocs/kcrash/html/index.html"
         TYPE OPTIONAL
         PURPOSE "Optionally used to provide crash reporting on Linux")
 
     find_package(X11 REQUIRED COMPONENTS Xinput)
     set(HAVE_X11 TRUE)
     add_definitions(-DHAVE_X11)
 
     find_package(XCB COMPONENTS XCB ATOM)
     set(HAVE_XCB ${XCB_FOUND})
 else()
     set(HAVE_DBUS FALSE)
     set(HAVE_X11 FALSE)
     set(HAVE_XCB FALSE)
 endif()
 
 
 add_definitions(
   -DQT_USE_QSTRINGBUILDER
   -DQT_STRICT_ITERATORS
   -DQT_NO_SIGNALS_SLOTS_KEYWORDS
   -DQT_USE_FAST_OPERATOR_PLUS
   -DQT_USE_FAST_CONCATENATION
   -DQT_NO_URL_CAST_FROM_STRING
 )
 
 if (${Qt5_VERSION} VERSION_GREATER "5.8.0" )
     add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x50900)
 elseif(${Qt5_VERSION} VERSION_GREATER "5.7.0" )
     add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x50800)
 elseif(${Qt5_VERSION} VERSION_GREATER "5.6.0" )
     add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x50700)
 else()
     add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x50600)
 endif()
 
 add_definitions(-DTRANSLATION_DOMAIN=\"krita\")
 
 #
 # The reason for this mode is that the Debug mode disable inlining
 #
 if(CMAKE_COMPILER_IS_GNUCXX)
     set(CMAKE_CXX_FLAGS_KRITADEVS "-O3 -g" CACHE STRING "" FORCE)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}  -fext-numeric-literals")
 endif()
 
 if(UNIX)
     set(CMAKE_REQUIRED_LIBRARIES "${CMAKE_REQUIRED_LIBRARIES};m")
 endif()
 
 if(WIN32)
     if(MSVC)
         # C4522: 'class' : multiple assignment operators specified
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -wd4522")
     endif()
 endif()
 
 # KDECompilerSettings adds the `--export-all-symbols` linker flag.
 # We don't really need it.
 if(MINGW)
     string(REPLACE "-Wl,--export-all-symbols" "" CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS}")
     string(REPLACE "-Wl,--export-all-symbols" "" CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS}")
 endif(MINGW)
 
 # enable exceptions globally
 kde_enable_exceptions()
 
 set(KRITA_DEFAULT_TEST_DATA_DIR ${CMAKE_SOURCE_DIR}/sdk/tests/data/)
 macro(macro_add_unittest_definitions)
   add_definitions(-DFILES_DATA_DIR="${CMAKE_CURRENT_SOURCE_DIR}/data/")
   add_definitions(-DFILES_OUTPUT_DIR="${CMAKE_CURRENT_BINARY_DIR}")
   add_definitions(-DFILES_DEFAULT_DATA_DIR="${KRITA_DEFAULT_TEST_DATA_DIR}")
   add_definitions(-DSYSTEM_RESOURCES_DATA_DIR="${CMAKE_SOURCE_DIR}/krita/data/")
 endmacro()
 
 
 
 
 # overcome some platform incompatibilities
 if(WIN32)
     include_directories(${CMAKE_CURRENT_SOURCE_DIR}/winquirks)
     add_definitions(-D_USE_MATH_DEFINES)
     add_definitions(-DNOMINMAX)
     set(WIN32_PLATFORM_NET_LIBS ws2_32.lib netapi32.lib)
 endif()
 
 # set custom krita plugin installdir
 set(KRITA_PLUGIN_INSTALL_DIR ${LIB_INSTALL_DIR}/kritaplugins)
 
  ###########################
 ############################
 ## Required dependencies  ##
 ############################
 ###########################
 
 find_package(PNG REQUIRED)
 
 if (APPLE)
     # this is not added correctly on OSX -- see http://forum.kde.org/viewtopic.php?f=139&t=101867&p=221242#p221242
     include_directories(SYSTEM ${PNG_INCLUDE_DIR})
 endif()
 
 add_definitions(-DBOOST_ALL_NO_LIB)
 find_package(Boost 1.55 REQUIRED COMPONENTS system)
 include_directories(SYSTEM ${Boost_INCLUDE_DIRS})
 ##
 ## Test for GNU Scientific Library
 ##
 find_package(GSL)
 set_package_properties(GSL PROPERTIES
     URL "http://www.gnu.org/software/gsl"
     TYPE RECOMMENDED
     PURPOSE "Required by Krita's Transform tool.")
 macro_bool_to_01(GSL_FOUND HAVE_GSL)
 configure_file(config-gsl.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-gsl.h )
 
  ###########################
 ############################
 ## Optional dependencies  ##
 ############################
 ###########################
 
 
 find_package(ZLIB)
 set_package_properties(ZLIB PROPERTIES
     DESCRIPTION "Compression library"
     URL "http://www.zlib.net/"
     TYPE OPTIONAL
     PURPOSE "Optionally used by the G'Mic and the PSD plugins")
 macro_bool_to_01(ZLIB_FOUND HAVE_ZLIB)
 
 find_package(OpenEXR)
 set_package_properties(OpenEXR PROPERTIES
     DESCRIPTION "High dynamic-range (HDR) image file format"
     URL "http://www.openexr.com"
     TYPE OPTIONAL
     PURPOSE "Required by the Krita OpenEXR filter")
 macro_bool_to_01(OPENEXR_FOUND HAVE_OPENEXR)
 set(LINK_OPENEXR_LIB)
 if(OPENEXR_FOUND)
     include_directories(SYSTEM ${OPENEXR_INCLUDE_DIR})
     set(LINK_OPENEXR_LIB ${OPENEXR_LIBRARIES})
     add_definitions(${OPENEXR_DEFINITIONS})
 endif()
 
 find_package(TIFF)
 set_package_properties(TIFF PROPERTIES
     DESCRIPTION "TIFF Library and Utilities"
     URL "http://www.remotesensing.org/libtiff"
     TYPE OPTIONAL
     PURPOSE "Required by the Krita TIFF filter")
 
 find_package(JPEG)
 set_package_properties(JPEG PROPERTIES
     DESCRIPTION "Free library for JPEG image compression. Note: libjpeg8 is NOT supported."
     URL "http://www.libjpeg-turbo.org"
     TYPE OPTIONAL
     PURPOSE "Required by the Krita JPEG filter")
 
 find_package(GIF)
 set_package_properties(GIF PROPERTIES
     DESCRIPTION "Library for loading and saving gif files."
     URL "http://giflib.sourceforge.net/"
     TYPE OPTIONAL
     PURPOSE "Required by the Krita GIF filter")
 
 find_package(HEIF "1.3.0")
 set_package_properties(HEIF PROPERTIES
     DESCRIPTION "Library for loading and saving heif files."
     URL "https://github.com/strukturag/libheif"
     TYPE OPTIONAL
     PURPOSE "Required by the Krita HEIF filter")
 
 set(LIBRAW_MIN_VERSION  "0.16")
 find_package(LibRaw ${LIBRAW_MIN_VERSION})
 set_package_properties(LibRaw PROPERTIES
     DESCRIPTION "Library to decode RAW images"
     URL "http://www.libraw.org"
     TYPE OPTIONAL
     PURPOSE "Required to build the raw import plugin")
 
 find_package(FFTW3)
 set_package_properties(FFTW3 PROPERTIES
     DESCRIPTION "A fast, free C FFT library"
     URL "http://www.fftw.org/"
     TYPE OPTIONAL
     PURPOSE "Required by the Krita for fast convolution operators and some G'Mic features")
 macro_bool_to_01(FFTW3_FOUND HAVE_FFTW3)
 
 find_package(OCIO)
 set_package_properties(OCIO PROPERTIES
     DESCRIPTION "The OpenColorIO Library"
     URL "http://www.opencolorio.org"
     TYPE OPTIONAL
     PURPOSE "Required by the Krita LUT docker")
 macro_bool_to_01(OCIO_FOUND HAVE_OCIO)
 
 set_package_properties(PythonLibrary PROPERTIES
     DESCRIPTION "Python Library"
     URL "http://www.python.org"
     TYPE OPTIONAL
     PURPOSE "Required by the Krita PyQt plugin")
 macro_bool_to_01(PYTHONLIBS_FOUND HAVE_PYTHONLIBS)
 
 find_package(SIP "4.18.0")
 set_package_properties(SIP PROPERTIES
     DESCRIPTION "Support for generating SIP Python bindings"
     URL "https://www.riverbankcomputing.com/software/sip/download"
     TYPE OPTIONAL
     PURPOSE "Required by the Krita PyQt plugin")
 macro_bool_to_01(SIP_FOUND HAVE_SIP)
 
 find_package(PyQt5 "5.6.0")
 set_package_properties(PyQt5 PROPERTIES
     DESCRIPTION "Python bindings for Qt5."
     URL "https://www.riverbankcomputing.com/software/pyqt/download5"
     TYPE OPTIONAL
     PURPOSE "Required by the Krita PyQt plugin")
 macro_bool_to_01(PYQT5_FOUND HAVE_PYQT5)
 
 
 ##
 ## Look for OpenGL
 ##
 # TODO: see if there is a better check for QtGui being built with opengl support (and thus the QOpenGL* classes)
 if(Qt5Gui_OPENGL_IMPLEMENTATION)
     message(STATUS "Found QtGui OpenGL support")
 else()
     message(FATAL_ERROR  "Did NOT find QtGui OpenGL support. Check your Qt configuration. You cannot build Krita without Qt OpenGL support.")
 endif()
 
 ##
 ## Test for eigen3
 ##
 find_package(Eigen3 3.0 REQUIRED)
 set_package_properties(Eigen3 PROPERTIES
     DESCRIPTION "C++ template library for linear algebra"
     URL "http://eigen.tuxfamily.org"
     TYPE REQUIRED)
 
 ##
 ## Test for exiv2
 ##
 find_package(Exiv2 0.16 REQUIRED)
 set_package_properties(Exiv2 PROPERTIES
     DESCRIPTION "Image metadata library and tools"
     URL "http://www.exiv2.org"
     PURPOSE "Required by Krita")
 
 ##
 ## Test for lcms
 ##
 find_package(LCMS2 2.4 REQUIRED)
 set_package_properties(LCMS2 PROPERTIES
     DESCRIPTION "LittleCMS Color management engine"
     URL "http://www.littlecms.com"
     TYPE REQUIRED
     PURPOSE "Will be used for color management and is necessary for Krita")
 if(LCMS2_FOUND)
     if(NOT ${LCMS2_VERSION} VERSION_LESS 2040 )
         set(HAVE_LCMS24 TRUE)
     endif()
     set(HAVE_REQUIRED_LCMS_VERSION TRUE)
     set(HAVE_LCMS2 TRUE)
 endif()
 
 ##
 ## Test for Vc
 ##
 set(OLD_CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} )
 set(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/modules )
 set(HAVE_VC FALSE)
 if (NOT ${CMAKE_SYSTEM_PROCESSOR} MATCHES "arm")
     if(NOT MSVC)
         find_package(Vc 1.1.0)
         set_package_properties(Vc PROPERTIES
             DESCRIPTION "Portable, zero-overhead SIMD library for C++"
             URL "https://github.com/VcDevel/Vc"
             TYPE OPTIONAL
             PURPOSE "Required by the Krita for vectorization")
         macro_bool_to_01(Vc_FOUND HAVE_VC)
     endif()
 endif()
 configure_file(config-vc.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-vc.h )
 
 if(HAVE_VC)
     message(STATUS "Vc found!")
     set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH}
                         "${CMAKE_SOURCE_DIR}/cmake/vc")
 
     include (VcMacros)
 
     if(Vc_COMPILER_IS_CLANG)
         set(ADDITIONAL_VC_FLAGS "-Wabi -ffp-contract=fast")
         if(NOT WIN32)
             set(ADDITIONAL_VC_FLAGS "${ADDITIONAL_VC_FLAGS} -fPIC")
         endif()
     elseif (NOT MSVC)
         set(ADDITIONAL_VC_FLAGS "-Wabi -fabi-version=0 -ffp-contract=fast")
         if(NOT WIN32)
             set(ADDITIONAL_VC_FLAGS "${ADDITIONAL_VC_FLAGS} -fPIC")
         endif()
     endif()
 
     #Handle Vc master
     if(Vc_COMPILER_IS_GCC OR Vc_COMPILER_IS_CLANG)
         AddCompilerFlag("-std=c++11" _ok)
         if(NOT _ok)
             AddCompilerFlag("-std=c++0x" _ok)
         endif()
     endif()
 
     macro(ko_compile_for_all_implementations_no_scalar _objs _src)
         vc_compile_for_all_implementations(${_objs} ${_src} FLAGS ${ADDITIONAL_VC_FLAGS} ONLY SSE2 SSSE3 SSE4_1 AVX AVX2+FMA+BMI2)
     endmacro()
 
     macro(ko_compile_for_all_implementations _objs _src)
         vc_compile_for_all_implementations(${_objs} ${_src} FLAGS ${ADDITIONAL_VC_FLAGS} ONLY Scalar SSE2 SSSE3 SSE4_1 AVX AVX2+FMA+BMI2)
     endmacro()
 endif()
 set(CMAKE_MODULE_PATH ${OLD_CMAKE_MODULE_PATH} )
 
 add_definitions(${QT_DEFINITIONS} ${QT_QTDBUS_DEFINITIONS})
 
 ##
 ## Test endianness
 ##
 include (TestBigEndian)
 test_big_endian(CMAKE_WORDS_BIGENDIAN)
 
 ##
 ## Test for qt-poppler
 ##
 find_package(Poppler COMPONENTS Qt5)
 set_package_properties(Poppler PROPERTIES
     DESCRIPTION "A PDF rendering library"
     URL "http://poppler.freedesktop.org"
     TYPE OPTIONAL
     PURPOSE "Required by the Krita PDF filter.")
 
  ############################
 #############################
 ## Add Krita helper macros ##
 #############################
 ############################
 
 include(MacroKritaAddBenchmark)
 
  ####################
 #####################
 ## Define includes ##
 #####################
 ####################
 
 # for config.h and <toplevel/foo.h> includes (if any?)
 include_directories(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}
                            ${CMAKE_CURRENT_BINARY_DIR}
                            ${CMAKE_SOURCE_DIR}/interfaces
 )
 
 add_subdirectory(libs)
 add_subdirectory(plugins)
 add_subdirectory(benchmarks)
 add_subdirectory(krita)
 
 configure_file(KoConfig.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/KoConfig.h )
 configure_file(config_convolution.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config_convolution.h)
 configure_file(config-ocio.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-ocio.h )
 
 check_function_exists(powf HAVE_POWF)
 configure_file(config-powf.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-powf.h)
 
 if(WIN32)
     include(${CMAKE_CURRENT_LIST_DIR}/packaging/windows/installer/ConfigureInstallerNsis.cmake)
 endif()
 
 message("\nBroken tests:")
 foreach(tst ${KRITA_BROKEN_TESTS})
     message("    * ${tst}")
 endforeach()
 
 feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)
 
 if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/po OR EXISTS ${CMAKE_CURRENT_BINARY_DIR}/po )
   find_package(KF5I18n CONFIG REQUIRED)
   ki18n_install(po)
 endif()
diff --git a/krita/data/actions/InteractionTool.action b/krita/data/actions/InteractionTool.action
index ecfd190dd7..bb16227db8 100644
--- a/krita/data/actions/InteractionTool.action
+++ b/krita/data/actions/InteractionTool.action
@@ -1,302 +1,302 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ActionCollection version="2" name="Tools">
   <Actions category="Interaction Tool">
     <text>Interaction Tool</text>
     <Action name="object_order_raise">
       <iconText>Raise</iconText>
-      <shortcut>Ctrl+]</shortcut>
+      <shortcut>Ctrl+Alt+]</shortcut>
       <toolTip>Raise</toolTip>
       <icon>object-order-raise-calligra</icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
       <text>&amp;Raise</text>
     </Action>
     <Action name="object_align_horizontal_right">
       <iconText>Align Right</iconText>
       <shortcut></shortcut>
       <toolTip>Align Right</toolTip>
       <icon>object-align-horizontal-right-calligra</icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
       <text>Align Right</text>
     </Action>
     <Action name="object_ungroup">
       <iconText>Ungroup</iconText>
       <shortcut></shortcut>
       <toolTip>Ungroup</toolTip>
       <icon>object-ungroup-calligra</icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
       <text>Ungroup</text>
     </Action>
     <Action name="object_order_back">
       <iconText>Send to Back</iconText>
       <shortcut>Ctrl+Shift+[</shortcut>
       <toolTip>Send to Back</toolTip>
       <icon>object-order-back-calligra</icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
       <text>Send to &amp;Back</text>
     </Action>
     <Action name="object_order_front">
       <iconText>Bring to Front</iconText>
       <shortcut>Ctrl+Shift+]</shortcut>
       <toolTip>Bring to Front</toolTip>
       <icon>object-order-front-calligra</icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
       <text>Bring to &amp;Front</text>
     </Action>
     <Action name="object_align_vertical_center">
       <iconText>Vertically Center</iconText>
       <shortcut></shortcut>
       <toolTip>Vertically Center</toolTip>
       <icon>object-align-vertical-center-calligra</icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
       <text>Vertically Center</text>
     </Action>
     <Action name="object_group">
       <iconText>Group</iconText>
       <shortcut></shortcut>
       <toolTip>Group</toolTip>
       <icon>object-group-calligra</icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
       <text>Group</text>
     </Action>
     <Action name="object_align_horizontal_left">
       <iconText>Align Left</iconText>
       <shortcut></shortcut>
       <toolTip>Align Left</toolTip>
       <icon>object-align-horizontal-left-calligra</icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
       <text>Align Left</text>
     </Action>
     <Action name="object_align_vertical_top">
       <iconText>Align Top</iconText>
       <shortcut></shortcut>
       <toolTip>Align Top</toolTip>
       <icon>object-align-vertical-top-calligra</icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
       <text>Align Top</text>
     </Action>
     <Action name="object_align_horizontal_center">
       <iconText>Horizontally Center</iconText>
       <shortcut></shortcut>
       <toolTip>Horizontally Center</toolTip>
       <icon>object-align-horizontal-center-calligra</icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
       <text>Horizontally Center</text>
     </Action>
     <Action name="object_order_lower">
       <iconText>Lower</iconText>
-      <shortcut>Ctrl+[</shortcut>
+      <shortcut>Ctrl+Alt+[</shortcut>
       <toolTip>Lower</toolTip>
       <icon>object-order-lower-calligra</icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
       <text>&amp;Lower</text>
     </Action>
     <Action name="object_align_vertical_bottom">
       <iconText>Align Bottom</iconText>
       <shortcut></shortcut>
       <toolTip>Align Bottom</toolTip>
       <icon>object-align-vertical-bottom-calligra</icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
       <text>Align Bottom</text>
     </Action>
 
     <Action name="object_distribute_horizontal_left">
       <text>Distribute Left</text>
       <toolTip>Distribute left edges equidistantly</toolTip>
       <shortcut></shortcut>
       <icon>distribute-horizontal-left</icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
     </Action>
     <Action name="object_distribute_horizontal_center">
       <text>Distribute Centers Horizontally</text>
       <toolTip>Distribute centers equidistantly horizontally</toolTip>
       <shortcut></shortcut>
       <icon>distribute-horizontal-center</icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
     </Action>
     <Action name="object_distribute_horizontal_right">
       <text>Distribute Right</text>
       <toolTip>Distribute right edges equidistantly</toolTip>
       <shortcut></shortcut>
       <icon>distribute-horizontal-right</icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
     </Action>
     <Action name="object_distribute_horizontal_gaps">
       <text>Distribute Horizontal Gap</text>
       <toolTip>Make horizontal gaps between objects equal</toolTip>
       <shortcut></shortcut>
       <icon>distribute-horizontal</icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
     </Action>
 
     <Action name="object_distribute_vertical_top">
       <text>Distribute Top</text>
       <toolTip>Distribute top edges equidistantly</toolTip>
       <shortcut></shortcut>
       <icon>distribute-vertical-top</icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
     </Action>
     <Action name="object_distribute_vertical_center">
       <text>Distribute Centers Vertically</text>
       <toolTip>Distribute centers equidistantly vertically</toolTip>
       <shortcut></shortcut>
       <icon>distribute-vertical-center</icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
     </Action>
     <Action name="object_distribute_vertical_bottom">
       <text>Distribute Bottom</text>
       <toolTip>Distribute bottom edges equidistantly</toolTip>
       <shortcut></shortcut>
       <icon>distribute-vertical-bottom</icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
     </Action>
     <Action name="object_distribute_vertical_gaps">
       <text>Distribute Vertical Gap</text>
       <toolTip>Make vertical gaps between objects equal</toolTip>
       <shortcut></shortcut>
       <icon>distribute-vertical</icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
     </Action>
 
     <Action name="object_transform_rotate_90_cw">
       <text>Rotate 90° CW</text>
       <toolTip>Rotate object 90° clockwise</toolTip>
       <shortcut></shortcut>
       <icon>object-rotate-right</icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
     </Action>
 
     <Action name="object_transform_rotate_90_ccw">
       <text>Rotate 90° CCW</text>
       <toolTip>Rotate object 90° counterclockwise</toolTip>
       <shortcut></shortcut>
       <icon>object-rotate-left</icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
     </Action>
 
     <Action name="object_transform_rotate_180">
       <text>Rotate 180°</text>
       <toolTip>Rotate object 180°</toolTip>
       <shortcut></shortcut>
       <icon></icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
     </Action>
 
     <Action name="object_transform_mirror_horizontally">
       <text>Mirror Horizontally</text>
       <toolTip>Mirror object horizontally</toolTip>
       <shortcut></shortcut>
       <icon>symmetry-horizontal</icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
     </Action>
 
     <Action name="object_transform_mirror_vertically">
       <text>Mirror Vertically</text>
       <toolTip>Mirror object vertically</toolTip>
       <shortcut></shortcut>
       <icon>symmetry-vertical</icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
     </Action>
 
     <Action name="object_transform_reset">
       <text>Reset Transformations</text>
       <toolTip>Reset object transformations</toolTip>
       <shortcut></shortcut>
       <icon></icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
     </Action>
 
     <Action name="object_unite">
       <text>Unite</text>
       <toolTip>Create boolean union of multiple objects</toolTip>
       <shortcut></shortcut>
       <icon></icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
     </Action>
 
     <Action name="object_intersect">
       <text>Intersect</text>
       <toolTip>Create boolean intersection of multiple objects</toolTip>
       <shortcut></shortcut>
       <icon></icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
     </Action>
 
     <Action name="object_subtract">
       <text>Subtract</text>
       <toolTip>Subtract multiple objects from the first selected one</toolTip>
       <shortcut></shortcut>
       <icon></icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
     </Action>
 
     <Action name="object_split">
       <text>Split</text>
       <toolTip>Split objects with multiple subpaths into multiple objects</toolTip>
       <shortcut></shortcut>
       <icon></icon>
       <whatsThis></whatsThis>
       <statusTip></statusTip>
       <isCheckable>false</isCheckable>
     </Action>
 
 
   </Actions>
 </ActionCollection>
diff --git a/krita/main.cc b/krita/main.cc
index 764bdb3af7..7add3ee8ef 100644
--- a/krita/main.cc
+++ b/krita/main.cc
@@ -1,403 +1,404 @@
 /*
  * Copyright (c) 1999 Matthias Elter <me@kde.org>
  * Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  * Copyright (c) 2015 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include <stdlib.h>
 
 #include <QString>
 #include <QPixmap>
 #include <kis_debug.h>
 #include <QProcess>
 #include <QProcessEnvironment>
 #include <QStandardPaths>
 #include <QDir>
 #include <QDate>
 #include <QLocale>
 #include <QSettings>
 #include <QByteArray>
 
 #include <time.h>
 
 #include <KisApplication.h>
 #include <KisLoggingManager.h>
 #include <KoConfig.h>
 #include <KoResourcePaths.h>
 
 #include "data/splash/splash_screen.xpm"
 #include "data/splash/splash_holidays.xpm"
 #include "data/splash/splash_screen_x2.xpm"
 #include "data/splash/splash_holidays_x2.xpm"
 #include "KisDocument.h"
 #include "kis_splash_screen.h"
 #include "KisPart.h"
 #include "KisApplicationArguments.h"
 #include <opengl/kis_opengl.h>
 #include "input/KisQtWidgetsTweaker.h"
+#include <kis_debug.h>
 
 #if defined Q_OS_WIN
 #include <windows.h>
 #include <stdlib.h>
 #include <kis_tablet_support_win.h>
 #include <kis_tablet_support_win8.h>
 #include <kis_config.h>
 #include <QLibrary>
 #include <QMessageBox>
 
 #elif defined HAVE_X11
 #include <kis_xi2_event_filter.h>
 #endif
 
 #if defined HAVE_KCRASH
 #include <kcrash.h>
 #elif defined USE_DRMINGW
 namespace
 {
 void tryInitDrMingw()
 {
     wchar_t path[MAX_PATH];
     QString pathStr = QCoreApplication::applicationDirPath().replace(L'/', L'\\') + QStringLiteral("\\exchndl.dll");
     if (pathStr.size() > MAX_PATH - 1) {
         return;
     }
     int pathLen = pathStr.toWCharArray(path);
     path[pathLen] = L'\0'; // toWCharArray doesn't add NULL terminator
     HMODULE hMod = LoadLibraryW(path);
     if (!hMod) {
         return;
     }
     // No need to call ExcHndlInit since the crash handler is installed on DllMain
     auto myExcHndlSetLogFileNameA = reinterpret_cast<BOOL (APIENTRY *)(const char *)>(GetProcAddress(hMod, "ExcHndlSetLogFileNameA"));
     if (!myExcHndlSetLogFileNameA) {
         return;
     }
     // Set the log file path to %LocalAppData%\kritacrash.log
     QString logFile = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation).replace(L'/', L'\\') + QStringLiteral("\\kritacrash.log");
     myExcHndlSetLogFileNameA(logFile.toLocal8Bit());
 }
 
 typedef enum ORIENTATION_PREFERENCE {
     ORIENTATION_PREFERENCE_NONE = 0x0,
     ORIENTATION_PREFERENCE_LANDSCAPE = 0x1,
     ORIENTATION_PREFERENCE_PORTRAIT = 0x2,
     ORIENTATION_PREFERENCE_LANDSCAPE_FLIPPED = 0x4,
     ORIENTATION_PREFERENCE_PORTRAIT_FLIPPED = 0x8
 } ORIENTATION_PREFERENCE;
 typedef BOOL WINAPI (*pSetDisplayAutoRotationPreferences_t)(
         ORIENTATION_PREFERENCE orientation
         );
 void resetRotation()
 {
     QLibrary user32Lib("user32");
     if (!user32Lib.load()) {
         qWarning() << "Failed to load user32.dll! This really should not happen.";
         return;
     }
     pSetDisplayAutoRotationPreferences_t pSetDisplayAutoRotationPreferences
             = reinterpret_cast<pSetDisplayAutoRotationPreferences_t>(user32Lib.resolve("SetDisplayAutoRotationPreferences"));
     if (!pSetDisplayAutoRotationPreferences) {
-        qDebug() << "Failed to load function SetDisplayAutoRotationPreferences";
+        dbgKrita << "Failed to load function SetDisplayAutoRotationPreferences";
         return;
     }
     bool result = pSetDisplayAutoRotationPreferences(ORIENTATION_PREFERENCE_NONE);
-    qDebug() << "SetDisplayAutoRotationPreferences(ORIENTATION_PREFERENCE_NONE) returned" << result;
+    dbgKrita << "SetDisplayAutoRotationPreferences(ORIENTATION_PREFERENCE_NONE) returned" << result;
 }
 } // namespace
 #endif
 extern "C" int main(int argc, char **argv)
 {
 
     // The global initialization of the random generator
     qsrand(time(0));
     bool runningInKDE = !qgetenv("KDE_FULL_SESSION").isEmpty();
 
 #if defined HAVE_X11
     qputenv("QT_QPA_PLATFORM", "xcb");
 #endif
 
     KisLoggingManager::initialize();
 
     // A per-user unique string, without /, because QLocalServer cannot use names with a / in it
     QString key = "Krita3" + QStandardPaths::writableLocation(QStandardPaths::HomeLocation).replace("/", "_");
     key = key.replace(":", "_").replace("\\","_");
 
     QCoreApplication::setAttribute(Qt::AA_ShareOpenGLContexts, true);
 
     QCoreApplication::setAttribute(Qt::AA_DontCreateNativeWidgetSiblings, true);
     QCoreApplication::setAttribute(Qt::AA_UseHighDpiPixmaps, true);
 
 #if QT_VERSION >= 0x050900
     QCoreApplication::setAttribute(Qt::AA_DisableShaderDiskCache, true);
 #endif
 
     const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
 
     bool singleApplication = true;
     bool enableOpenGLDebug = false;
     bool openGLDebugSynchronous = false;
     {
         QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
         singleApplication = kritarc.value("EnableSingleApplication", true).toBool();
 #if QT_VERSION >= 0x050600
         if (kritarc.value("EnableHiDPI", false).toBool()) {
             QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
         }
         if (!qgetenv("KRITA_HIDPI").isEmpty()) {
             QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
         }
 #endif
         if (!qgetenv("KRITA_OPENGL_DEBUG").isEmpty()) {
             enableOpenGLDebug = true;
         } else {
             enableOpenGLDebug = kritarc.value("EnableOpenGLDebug", false).toBool();
         }
         if (enableOpenGLDebug && (qgetenv("KRITA_OPENGL_DEBUG") == "sync" || kritarc.value("OpenGLDebugSynchronous", false).toBool())) {
             openGLDebugSynchronous = true;
         }
 
         KisOpenGL::setDefaultFormat(enableOpenGLDebug, openGLDebugSynchronous);
 
 #ifdef Q_OS_WIN
         QString preferredOpenGLRenderer = kritarc.value("OpenGLRenderer", "auto").toString();
 
         // Force ANGLE to use Direct3D11. D3D9 doesn't support OpenGL ES 3 and WARP
         //  might get weird crashes atm.
         qputenv("QT_ANGLE_PLATFORM", "d3d11");
 
         // Probe QPA auto OpenGL detection
         char *fakeArgv[2] = { argv[0], nullptr }; // Prevents QCoreApplication from modifying the real argc/argv
         KisOpenGL::probeWindowsQpaOpenGL(1, fakeArgv, preferredOpenGLRenderer);
 
         // HACK: https://bugs.kde.org/show_bug.cgi?id=390651
         resetRotation();
 #endif
     }
 
 
     QString root;
     QString language;
     {
         // Create a temporary application to get the root
         QCoreApplication app(argc, argv);
         Q_UNUSED(app);
         root = KoResourcePaths::getApplicationRoot();
         QSettings languageoverride(configPath + QStringLiteral("/klanguageoverridesrc"), QSettings::IniFormat);
         languageoverride.beginGroup(QStringLiteral("Language"));
         language = languageoverride.value(qAppName(), "").toString();
     }
 
 
 #ifdef Q_OS_LINUX
     {
         QByteArray originalXdgDataDirs = qgetenv("XDG_DATA_DIRS");
         if (originalXdgDataDirs.isEmpty()) {
             // We don't want to completely override the default
             originalXdgDataDirs = "/usr/local/share/:/usr/share/";
         }
         qputenv("XDG_DATA_DIRS", QFile::encodeName(root + "share") + ":" + originalXdgDataDirs);
     }
 #else
     qputenv("XDG_DATA_DIRS", QFile::encodeName(root + "share"));
 #endif
 
-    qDebug() << "Setting XDG_DATA_DIRS" << qgetenv("XDG_DATA_DIRS");
+    dbgKrita << "Setting XDG_DATA_DIRS" << qgetenv("XDG_DATA_DIRS");
 
     // Now that the paths are set, set the language. First check the override from the language
     // selection dialog.
 
-    qDebug() << "Override language:" << language;
+    dbgKrita << "Override language:" << language;
 
     if (!language.isEmpty()) {
         KLocalizedString::setLanguages(language.split(":"));
         // And override Qt's locale, too
         qputenv("LANG", language.split(":").first().toLocal8Bit());
         QLocale locale(language.split(":").first());
         QLocale::setDefault(locale);
     }
 #ifndef Q_OS_LINUX
     else {
         // And if there isn't one, check the one set by the system.
         QLocale locale = QLocale::system();
         if (locale.name() != QStringLiteral("en")) {
             QStringList uiLanguages = locale.uiLanguages();
             for (QString &uiLanguage : uiLanguages) {
                 uiLanguage.replace(QChar('-'), QChar('_'));
             }
             for (int i = 0; i < uiLanguages.size(); i++) {
                 QString uiLanguage = uiLanguages[i];
                 // Strip the country code
                 int idx = uiLanguage.indexOf(QChar('_'));
                 if (idx != -1) {
                     uiLanguage = uiLanguage.left(idx);
                     uiLanguages.insert(i + 1, uiLanguage);
                     i++;
                 }
             }
-            qDebug() << "Setting Krita's language to:" << uiLanguages;
+            dbgKrita << "Setting Krita's language to:" << uiLanguages;
             qputenv("LANG", uiLanguages.first().toLocal8Bit());
             KLocalizedString::setLanguages(uiLanguages);
         }
     }
 #endif
     // first create the application so we can create a pixmap
     KisApplication app(key, argc, argv);
     KLocalizedString::setApplicationDomain("krita");
 
-    qDebug() << "Available translations" << KLocalizedString::availableApplicationTranslations();
-    qDebug() << "Available domain translations" << KLocalizedString::availableDomainTranslations("krita");
-    qDebug() << "Qt UI languages" << QLocale::system().uiLanguages() << qgetenv("LANG");
+    dbgKrita << "Available translations" << KLocalizedString::availableApplicationTranslations();
+    dbgKrita << "Available domain translations" << KLocalizedString::availableDomainTranslations("krita");
+    dbgKrita << "Qt UI languages" << QLocale::system().uiLanguages() << qgetenv("LANG");
 
 
 #ifdef Q_OS_WIN
     QDir appdir(KoResourcePaths::getApplicationRoot());
     QString path = qgetenv("PATH");
     qputenv("PATH", QFile::encodeName(appdir.absolutePath() + "/bin" + ";"
                                       + appdir.absolutePath() + "/lib" + ";"
                                       + appdir.absolutePath() + "/Frameworks" + ";"
                                       + appdir.absolutePath() + ";"
                                       + path));
 
-    qDebug() << "PATH" << qgetenv("PATH");
+    dbgKrita << "PATH" << qgetenv("PATH");
 #endif
 
     if (qApp->applicationDirPath().contains(KRITA_BUILD_DIR)) {
         qFatal("FATAL: You're trying to run krita from the build location. You can only run Krita from the installation location.");
     }
 
 
 #if defined HAVE_KCRASH
     KCrash::initialize();
 #elif defined USE_DRMINGW
     tryInitDrMingw();
 #endif
 
     // If we should clear the config, it has to be done as soon as possible after
     // KisApplication has been created. Otherwise the config file may have been read
     // and stored in a KConfig object we have no control over.
     app.askClearConfig();
 
     KisApplicationArguments args(app);
 
     if (singleApplication && app.isRunning()) {
         // only pass arguments to main instance if they are not for batch processing
         // any batch processing would be done in this separate instance
         const bool batchRun = args.exportAs();
 
         if (!batchRun) {
             QByteArray ba = args.serialize();
             if (app.sendMessage(ba)) {
                 return 0;
             }
         }
     }
 
     if (!runningInKDE) {
         // Icons in menus are ugly and distracting
         app.setAttribute(Qt::AA_DontShowIconsInMenus);
     }
 
 #if defined HAVE_X11
     app.installNativeEventFilter(KisXi2EventFilter::instance());
 #endif
     app.installEventFilter(KisQtWidgetsTweaker::instance());
 
 
     if (!args.noSplash()) {
         // then create the pixmap from an xpm: we cannot get the
         // location of our datadir before we've started our components,
         // so use an xpm.
         QDate currentDate = QDate::currentDate();
         QWidget *splash = 0;
         if (currentDate > QDate(currentDate.year(), 12, 4) ||
                 currentDate < QDate(currentDate.year(), 1, 9)) {
             splash = new KisSplashScreen(app.applicationVersion(), QPixmap(splash_holidays_xpm), QPixmap(splash_holidays_x2_xpm));
         }
         else {
             splash = new KisSplashScreen(app.applicationVersion(), QPixmap(splash_screen_xpm), QPixmap(splash_screen_x2_xpm));
         }
 
         app.setSplashScreen(splash);
     }
 
 
 #if defined Q_OS_WIN
     {
         KisConfig cfg;
         if (cfg.useWin8PointerInput() && !KisTabletSupportWin8::isAvailable()) {
             cfg.setUseWin8PointerInput(false);
         }
         if (!cfg.useWin8PointerInput()) {
             bool hasWinTab = KisTabletSupportWin::init();
             if (!hasWinTab) {
                 if (KisTabletSupportWin8::isPenDeviceAvailable()) {
                     // Use WinInk automatically
                     cfg.setUseWin8PointerInput(true);
                 } else if (!cfg.readEntry("WarnedAboutMissingWinTab", false)) {
                     if (KisTabletSupportWin8::isAvailable()) {
                         QMessageBox::information(nullptr,
                                 i18n("Krita Tablet Support"),
                                 i18n("Cannot load WinTab driver and no Windows Ink pen devices are found. If you have a drawing tablet, please make sure the tablet driver is properly installed."),
                                 QMessageBox::Ok, QMessageBox::Ok);
                     } else {
                         QMessageBox::information(nullptr,
                                 i18n("Krita Tablet Support"),
                                 i18n("Cannot load WinTab driver. If you have a drawing tablet, please make sure the tablet driver is properly installed."),
                                 QMessageBox::Ok, QMessageBox::Ok);
                     }
                     cfg.writeEntry("WarnedAboutMissingWinTab", true);
                 }
             }
         }
         if (cfg.useWin8PointerInput()) {
             KisTabletSupportWin8 *penFilter = new KisTabletSupportWin8();
             if (penFilter->init()) {
                 // penFilter.registerPointerDeviceNotifications();
                 app.installNativeEventFilter(penFilter);
-                qDebug() << "Using Win8 Pointer Input for tablet support";
+                dbgKrita << "Using Win8 Pointer Input for tablet support";
             } else {
-                qDebug() << "No Win8 Pointer Input available";
+                dbgKrita << "No Win8 Pointer Input available";
                 delete penFilter;
             }
         }
     }
 #endif
 
     if (!app.start(args)) {
         return 1;
     }
 
 #if QT_VERSION >= 0x050700
     app.setAttribute(Qt::AA_CompressHighFrequencyEvents, false);
 #endif
 
     // Set up remote arguments.
     QObject::connect(&app, SIGNAL(messageReceived(QByteArray,QObject*)),
                      &app, SLOT(remoteArguments(QByteArray,QObject*)));
 
     QObject::connect(&app, SIGNAL(fileOpenRequest(QString)),
                      &app, SLOT(fileOpenRequested(QString)));
 
     int state = app.exec();
 
     {
         QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
         kritarc.setValue("canvasState", "OPENGL_SUCCESS");
     }
 
     return state;
 }
diff --git a/krita/org.kde.krita.appdata.xml b/krita/org.kde.krita.appdata.xml
index 1291966d0e..60ace37b65 100644
--- a/krita/org.kde.krita.appdata.xml
+++ b/krita/org.kde.krita.appdata.xml
@@ -1,247 +1,248 @@
 <?xml version="1.0" encoding="utf-8"?>
 <component type="desktop">
   <id>org.kde.krita</id>
   <launchable type="desktop-id">org.kde.krita.desktop</launchable>
   <metadata_license>CC0-1.0</metadata_license>
   <project_license>GPL-3.0-only</project_license>
   <developer_name>Krita Foundation</developer_name>
   <developer_name xml:lang="ca">Fundació Krita</developer_name>
   <developer_name xml:lang="ca-valencia">Fundació Krita</developer_name>
+  <developer_name xml:lang="cs">Krita Foundation</developer_name>
   <developer_name xml:lang="es">Fundación Krita</developer_name>
   <developer_name xml:lang="it">Fondazione Krita</developer_name>
   <developer_name xml:lang="nl">Krita Foundation</developer_name>
   <developer_name xml:lang="pl">Fundacja Krity</developer_name>
   <developer_name xml:lang="pt">Fundação do Krita</developer_name>
   <developer_name xml:lang="pt-BR">Krita Foundation</developer_name>
   <developer_name xml:lang="sv">Krita-stiftelsen</developer_name>
   <developer_name xml:lang="uk">Фундація Krita</developer_name>
   <developer_name xml:lang="x-test">xxKrita Foundationxx</developer_name>
   <developer_name xml:lang="zh-CN">Krita 基金会</developer_name>
   <update_contact>foundation@krita.org</update_contact>
   <name>Krita</name>
   <name xml:lang="ar">كريتا</name>
   <name xml:lang="ast">Krita</name>
   <name xml:lang="ca">Krita</name>
   <name xml:lang="ca-valencia">Krita</name>
   <name xml:lang="cs">Krita</name>
   <name xml:lang="de">Krita</name>
   <name xml:lang="el">Krita</name>
   <name xml:lang="en-GB">Krita</name>
   <name xml:lang="es">Krita</name>
   <name xml:lang="fr">Krita</name>
   <name xml:lang="gl">Krita</name>
   <name xml:lang="id">Krita</name>
   <name xml:lang="it">Krita</name>
   <name xml:lang="nl">Krita</name>
   <name xml:lang="pl">Krita</name>
   <name xml:lang="pt">Krita</name>
   <name xml:lang="pt-BR">Krita</name>
   <name xml:lang="sk">Krita</name>
   <name xml:lang="sv">Krita</name>
   <name xml:lang="tr">Krita</name>
   <name xml:lang="uk">Krita</name>
   <name xml:lang="x-test">xxKritaxx</name>
   <name xml:lang="zh-CN">Krita</name>
   <name xml:lang="zh-TW">Krita</name>
   <summary>Digital Painting, Creative Freedom</summary>
   <summary xml:lang="ar">رسم رقميّ، حريّة إبداعيّة</summary>
   <summary xml:lang="ast">Pintura dixital, llibertá creativa</summary>
   <summary xml:lang="bs">Digitalno crtanje, kreativna sloboda</summary>
   <summary xml:lang="ca">Dibuix digital, Llibertat creativa</summary>
   <summary xml:lang="ca-valencia">Dibuix digital, Llibertat creativa</summary>
   <summary xml:lang="cs">Digitální malování, svoboda tvorby</summary>
   <summary xml:lang="da">Digital tegning, kunstnerisk frihed</summary>
   <summary xml:lang="de">Digitales Malen, kreative Freiheit</summary>
   <summary xml:lang="el">Ψηφιακή ζωγραφική, δημιουργική ελευθερία</summary>
   <summary xml:lang="en-GB">Digital Painting, Creative Freedom</summary>
   <summary xml:lang="es">Pintura digital, libertad creativa</summary>
   <summary xml:lang="et">Digitaalne joonistamine, loominguline vabadus</summary>
   <summary xml:lang="fi">Digitaalimaalaus, luova vapaus</summary>
   <summary xml:lang="fr">Peinture numérique, liberté créatrice</summary>
   <summary xml:lang="gl">Debuxo dixital, liberdade creativa</summary>
   <summary xml:lang="ia">Pictura digital, Libertate creative</summary>
   <summary xml:lang="id">Pelukisan Digital, Kebebasan Berkreatif</summary>
   <summary xml:lang="it">Pittura digitale, libertà creativa</summary>
   <summary xml:lang="nl">Digital Painting, Creative Freedom</summary>
   <summary xml:lang="pl">Cyfrowe malowanie, Wolność Twórcza</summary>
   <summary xml:lang="pt">Pintura Digital, Liberdade Criativa</summary>
   <summary xml:lang="pt-BR">Pintura digital, liberdade criativa</summary>
   <summary xml:lang="ru">Цифровое рисование. Творческая свобода</summary>
   <summary xml:lang="sk">Digitálne maľovanie, kreatívna sloboda</summary>
   <summary xml:lang="sv">Digital målning, kreativ frihet</summary>
   <summary xml:lang="tr">Sayısal Boyama, Yaratıcı Özgürlük</summary>
   <summary xml:lang="uk">Цифрове малювання, творча свобода</summary>
   <summary xml:lang="x-test">xxDigital Painting, Creative Freedomxx</summary>
   <summary xml:lang="zh-CN">自由挥洒数字绘画的无限创意</summary>
   <summary xml:lang="zh-TW">數位繪畫，創作自由</summary>
   <description>
     <p>Krita is the full-featured digital art studio.</p>
     <p xml:lang="ast">Krita ye l'estudiu completu d'arte dixital.</p>
     <p xml:lang="bs">Krita je potpuni digitalni umjetnički studio.</p>
     <p xml:lang="ca">Krita és l'estudi d'art digital ple de funcionalitats.</p>
     <p xml:lang="ca-valencia">Krita és l'estudi d'art digital ple de funcionalitats.</p>
     <p xml:lang="de">Krita ist ein digitales Designstudio mit umfangreichen Funktionen.</p>
     <p xml:lang="el">Το Krita είναι ένα πλήρες χαρακτηριστικών ψηφιακό ατελιέ.</p>
     <p xml:lang="en-GB">Krita is the full-featured digital art studio.</p>
     <p xml:lang="es">Krita es un estudio de arte digital completo</p>
     <p xml:lang="et">Krita on rohkete võimalustega digitaalkunstistuudio.</p>
     <p xml:lang="fi">Krita on täyspiirteinen digitaiteen ateljee.</p>
     <p xml:lang="fr">Krita est le studio d'art numérique complet.</p>
     <p xml:lang="gl">Krita é un estudio completo de arte dixital.</p>
     <p xml:lang="ia">Krita es le studio de arte digital complete.</p>
     <p xml:lang="id">Krita adalah studio seni digital yang penuh dengan fitur.</p>
     <p xml:lang="it">Krita è uno studio d'arte digitale completo.</p>
     <p xml:lang="ja">Krita は、フル機能を備えたデジタルなアートスタジオです。</p>
     <p xml:lang="nl">Krita is de digitale kunststudio vol mogelijkheden.</p>
     <p xml:lang="pl">Krita jest pełnowymiarowym, cyfrowym studiem artystycznym</p>
     <p xml:lang="pt">O Krita é o estúdio de arte digital completo.</p>
     <p xml:lang="pt-BR">O Krita é o estúdio de arte digital completo.</p>
     <p xml:lang="ru">Krita полнофункциональный инструмент для создания цифровой графики.</p>
     <p xml:lang="sk">Krita je plne vybavené digitálne umelecké štúdio.</p>
     <p xml:lang="sv">Krita är den fullfjädrade digitala konststudion.</p>
     <p xml:lang="tr">Krita, tam özellikli dijital sanat stüdyosudur.</p>
     <p xml:lang="uk">Krita — повноцінний комплекс для створення цифрових художніх творів.</p>
     <p xml:lang="x-test">xxKrita is the full-featured digital art studio.xx</p>
     <p xml:lang="zh-CN">Krita 是一款功能齐全的数字绘画工作室软件。</p>
     <p xml:lang="zh-TW">Krita 是全功能的數位藝術工作室。</p>
     <p>It is perfect for sketching and painting, and presents an end–to–end solution for creating digital painting files from scratch by masters.</p>
     <p xml:lang="bs">On je savršen za skiciranje i slikanje i predstavlja finalno rješenje za kreiranje digitalnih slika od nule s majstorima</p>
     <p xml:lang="ca">És perfecte per fer esbossos i pintar, i presenta una solució final per crear fitxers de dibuix digital des de zero per a mestres.</p>
     <p xml:lang="ca-valencia">És perfecte per fer esbossos i pintar, i presenta una solució final per crear fitxers de dibuix digital des de zero per a mestres.</p>
     <p xml:lang="el">Είναι ιδανικό για σκιτσογραφία και ζωγραφική, και παρουσιάζει μια από άκρη σε άκρη λύση για τη δημιουργία από το μηδέν αρχείων ψηφιακης ζωγραφικής από τους δασκάλους της τέχνης.</p>
     <p xml:lang="en-GB">It is perfect for sketching and painting, and presents an end–to–end solution for creating digital painting files from scratch by masters.</p>
     <p xml:lang="es">Es perfecto para diseñar y pintar, y ofrece una solución completa para crear desde cero archivos de pintura digital apta para profesionales.</p>
     <p xml:lang="et">See on suurepärane töövahend visandite ja joonistuste valmistamiseks ning annab andekatele kunstnikele võimaluse luua digitaalpilt algusest lõpuni just oma käe järgi.</p>
     <p xml:lang="fi">Se on täydellinen luonnosteluun ja maalaukseen ja tarjoaa kokonaisratkaisun digitaalisten kuvatiedostojen luomiseen alusta alkaen.</p>
     <p xml:lang="fr">Il est parfait pour crayonner et peindre, et constitue une solution de bout en bout pour créer des fichier de peinture numérique depuis la feuille blanche jusqu'au épreuves finales.</p>
     <p xml:lang="gl">Resulta perfecto para debuxar e pintar, e presenta unha solución completa que permite aos mestres crear ficheiros de debuxo dixital desde cero.</p>
     <p xml:lang="ia">Illo es perfecte pro schizzar e pinger, e presenta un solution ab fin al fin pro crear files de pictura digital ab grattamentos per maestros.</p>
     <p xml:lang="id">Ini adalah sempurna untuk mensketsa dan melukis, dan menghadirkan sebuah solusi untuk menciptakan file-file pelukisan digital dari goresan si pelukis ulung.</p>
     <p xml:lang="it">Perfetto per fare schizzi e dipingere, prevede una soluzione completa che consente agli artisti di creare file di dipinti digitali partendo da zero.</p>
     <p xml:lang="nl">Het is perfect voor schetsen en schilderen en zet een end–to–end oplossing voor het maken van digitale bestanden voor schilderingen vanuit het niets door meesters.</p>
     <p xml:lang="pl">Nadaje się perfekcyjnie do szkicowania i malowania i dostarcza zupełnego rozwiązania dla tworzenia plików malowideł cyfrowych od zalążka.</p>
     <p xml:lang="pt">É perfeito para desenhos e pinturas, oferecendo uma solução final para criar ficheiros de pintura digital do zero por mestres.</p>
     <p xml:lang="pt-BR">É perfeito para desenhos e pinturas, oferecendo uma solução final para criar arquivos de desenho digital feitos a partir do zero por mestres.</p>
     <p xml:lang="ru">Она превосходно подходит для набросков и рисования, предоставляя мастерам самодостаточный инструмент для создания цифровой живописи с нуля.</p>
     <p xml:lang="sk">Je ideálna na skicovanie a maľovanie a poskytuje end-to-end riešenie na vytváranie súborov digitálneho maľovania od základu od profesionálov.</p>
     <p xml:lang="sv">Den är perfekt för att skissa och måla, samt erbjuder en helomfattande lösning för att skapa digitala målningsfiler från grunden av mästare.</p>
     <p xml:lang="tr">Eskiz ve boyama için mükemmeldir ve ustaların sıfırdan dijital boyama dosyaları oluşturmak için uçtan-uca bir çözüm sunar.</p>
     <p xml:lang="uk">Цей комплекс чудово пасує для створення ескізів та художніх зображень і є самодостатнім набором для створення файлів цифрових полотен «з нуля» для справжніх художників.</p>
     <p xml:lang="x-test">xxIt is perfect for sketching and painting, and presents an end–to–end solution for creating digital painting files from scratch by masters.xx</p>
     <p xml:lang="zh-CN">它专门为数字绘画设计，为美术工作者提供了一个从起草、上色到完成作品等整个创作流程的完整解决方案。</p>
     <p xml:lang="zh-TW">它是素描和繪畫的完美選擇，並提供了一個從零開始建立數位繪畫檔的端到端解決方案。</p>
     <p>
       Krita is a great choice for creating concept art, comics, textures for rendering and matte paintings. Krita supports many colorspaces like RGB and CMYK
       at 8 and 16 bits integer channels, as well as 16 and 32 bits floating point channels.
     </p>
     <p xml:lang="bs">Krita je odličan izbor za kreiranje konceptualne umjetnosti, stripove, teksture za obradu i mat slike. Krita podržava mnoge prostore boja kao RGB i CMIK na 8 i 16 bitnim cjelobrojnim kanalimaa, kao i 16 i 32 bita floating point kanalima.</p>
     <p xml:lang="ca">El Krita és una gran elecció per crear art conceptual, còmics, textures per renderitzar i pintures «matte». El Krita permet molts espais de color com el RGB i el CMYK a 8 i 16 bits de canals sencers, així com 16 i 32 bits de canals de coma flotant.</p>
     <p xml:lang="ca-valencia">El Krita és una gran elecció per crear art conceptual, còmics, textures per renderitzar i pintures «matte». El Krita permet molts espais de color com el RGB i el CMYK a 8 i 16 bits de canals sencers, així com 16 i 32 bits de canals de coma flotant.</p>
     <p xml:lang="el">Το Krita είναι μια εξαιρετική επιλογή για τη δημιουργία αφηρημένης τέχνης, ιστοριών με εικόνες, υφής για ζωγραφική αποτύπωσης και διάχυσης φωτός. Το Krita υποστηρίζει πολλούς χρωματικούς χώρους όπως τα RGB και CMYK σε 8 και 16 bit κανάλια ακεραίων καθώς επίσης και σε 16 και 32 bit κανάλια κινητής υποδιαστολής,</p>
     <p xml:lang="en-GB">Krita is a great choice for creating concept art, comics, textures for rendering and matte paintings. Krita supports many colourspaces like RGB and CMYK at 8 and 16 bits integer channels, as well as 16 and 32 bits floating point channels.</p>
     <p xml:lang="es">Krita es una gran elección para crear arte conceptual, cómics, texturas para renderizar y «matte paintings». Krita permite el uso de muchos espacios de color, como, por ejemplo, RGB y CMYK, tanto en canales de enteros de 8 y 16 bits, así como en canales de coma flotante de 16 y 32 bits.</p>
     <p xml:lang="et">Krita on üks paremaid valikuid kontseptuaalkunsti, koomiksite, tekstuuride ja digitaalmaalide loomiseks. Krita toetab paljusid värviruume, näiteks RGB ja CMYK 8 ja 16 täisarvulise bitiga kanali kohta, samuti 16 ja 32 ujukomabitiga kanali kohta.</p>
     <p xml:lang="fi">Krita on hyvä valinta konseptikuvituksen, sarjakuvien, pintakuvioiden ja maalausten luomiseen. Krita tukee useita väriavaruuksia kuten RGB:tä ja CMYK:ta 8 ja 16 bitin kokonaisluku- samoin kuin 16 ja 32 bitin liukulukukanavin.</p>
     <p xml:lang="fr">Krita est un très bon choix pour créer des concepts arts, des bandes-dessinées, des textures de rendu et des peintures. Krita prend en charge plusieurs espaces de couleurs comme RVB et CMJN avec les canaux de 8 et 16 bits entiers ainsi que les canaux de 16 et 32 bits flottants.</p>
     <p xml:lang="gl">Krita é unha gran opción para crear arte conceptual, texturas para renderización e pinturas mate. Krita permite usar moitos espazos de cores como RGB e CMYK con canles de 8 e 16 bits, así como canles de coma flotante de 16 e 32 bits.</p>
     <p xml:lang="ia">Krita es un grande selection pro crear arte de concepto, comics, texturas pro rendering e picturas opac. Krita supporta multe spatios de colores como RGB e CMYK con canales de integer a  8 e 16 bits, como anque canales floating point a 16 e 32 bits.</p>
     <p xml:lang="id">Krita adalah pilihan yang cocok untuk menciptakan konsep seni, komik, tekstur untuk rendering dan lukisan matte. Krita mendukung banyak ruang warna seperti RGB dan CMYK pada channel integer 8 dan 16 bit, serta 16 dan 32 bit channel titik mengambang.</p>
     <p xml:lang="it">Krita rappresenta una scelta ottimale per  la creazione di arte concettuale, fumetti e texture per il rendering e il matte painting. Krita supporta molti spazi colori come RGB e CMYK a 8 e 16 bit per canali interi e 16 e 32 bit per canali a virgola mobile.</p>
     <p xml:lang="ja">コンセプトアート、コミック、3DCG 用テクスチャ、マットペイントを制作する方にとって、Krita は最適な選択です。Krita は、8/16 ビット整数/チャンネル、および 16/32 ビット浮動小数点/チャンネルの RGB や CMYK をはじめ、さまざまな色空間をサポートしています。</p>
     <p xml:lang="nl">Krita is een goede keuze voor het maken van kunstconcepten, strips, textuur voor weergeven en matte schilderijen. Krita ondersteunt vele kleurruimten zoals RGB en CMYK in 8 en 16 bits kanalen met gehele getallen, evenals 16 en 32 bits kanalen met drijvende komma.</p>
     <p xml:lang="pl">Krita jest świetnym wyborem przy tworzeniu koncepcyjnej sztuki, komiksów, tekstur do wyświetlania i kaszet. Krita obsługuje wiele przestrzeni barw takich jak RGB oraz CMYK dla kanałów 8 oraz 16 bitowych wyrażonych w l. całkowitych, a także  16 oraz 32 bitowych wyrażonych w l. zmiennoprzecinkowych.</p>
     <p xml:lang="pt">O Krita é uma óptima escolha para criar arte conceptual, banda desenhada, texturas para desenho e pinturas. O Krita suporta diversos espaços de cores como o RGB e o CMYK com canais de cores inteiros a 8 e 16 bits, assim como canais de vírgula flutuante a 16 e a 32 bits.</p>
     <p xml:lang="pt-BR">O Krita é uma ótima escolha para criação de arte conceitual, histórias em quadrinhos, texturas para desenhos e pinturas. O Krita tem suporte a diversos espaços de cores como RGB e CMYK com canais de cores inteiros de 8 e 16 bits, assim como canais de ponto flutuante de 16 e 32 bits.</p>
     <p xml:lang="ru">Krita - отличный выбор для создания концепт-артов, комиксов, текстур для рендеринга и рисования. Она поддерживает множество цветовых пространств включая RGB и CMYK с 8 и 16 целыми битами на канал, а также 16 и 32 битами с плавающей запятой на канал.</p>
     <p xml:lang="sk">Krita je výborná voľba pre vytváranie konceptového umenia, textúr na renderovanie a matné kresby. Krita podporuje mnoho farebných priestorov ako RGB a CMYK na 8 a 16 bitových celočíselných kanáloch ako aj 16 a 32 bitových reálnych kanáloch.</p>
     <p xml:lang="sv">Krita är ett utmärkt val för att skapa concept art, serier, strukturer för återgivning och bakgrundsmålningar. Krita stöder många färgrymder som RGB och CMYK med 8- och 16-bitars heltal, samt 16- och 32-bitars flyttal.</p>
     <p xml:lang="tr">Krita, konsept sanat, çizgi roman, kaplama ve mat resimler için dokular oluşturmak için mükemmel bir seçimdir. Krita, 8 ve 16 bit tamsayı kanallarında RGB ve CMYK gibi birçok renk alanını ve 16 ve 32 bit kayan nokta kanallarını desteklemektedir.</p>
     <p xml:lang="uk">Krita — чудовий інструмент для створення концептуального живопису, коміксів, текстур для моделей та декорацій. У Krita передбачено підтримку багатьох просторів кольорів, зокрема RGB та CMYK з 8-бітовими та 16-бітовими цілими значеннями, а також 16-бітовими та 32-бітовими значеннями з рухомою крапкою для каналів кольорів.</p>
     <p xml:lang="x-test">xxKrita is a great choice for creating concept art, comics, textures for rendering and matte paintings. Krita supports many colorspaces like RGB and CMYK at 8 and 16 bits integer channels, as well as 16 and 32 bits floating point channels.xx</p>
     <p xml:lang="zh-CN">Krita 是绘制概念美术、漫画、纹理和电影布景的理想选择。Krita 支持多种色彩空间，如 8 位和 16 位整数及 16 位和 32 位浮点的 RGB 和 CMYK 颜色模型。</p>
     <p xml:lang="zh-TW">Krita 是創造概念藝術、漫畫、彩現紋理和場景繪畫的絕佳選擇。Krita 在 8 位元和 16 位元整數色版，以及 16 位元和 32 位元浮點色版中支援 RGB 和 CMYK 等多種色彩空間。</p>
     <p>Have fun painting with the advanced brush engines, amazing filters and many handy features that make Krita enormously productive.</p>
     <p xml:lang="bs">Zabavite se kreirajući napredne pogone četki, filtere i mnoge praktične osobine koje čine Krita vrlo produktivnim.</p>
     <p xml:lang="ca">Gaudiu pintant amb els motors de pinzells avançats, els filtres impressionants i moltes funcionalitats útils que fan el Krita molt productiu.</p>
     <p xml:lang="ca-valencia">Gaudiu pintant amb els motors de pinzells avançats, els filtres impressionants i moltes funcionalitats útils que fan el Krita molt productiu.</p>
     <p xml:lang="el">Διασκεδάστε ζωγραφίζοντας με τις προηγμένες μηχανές πινέλων, με εκπληκτικά φίλτρα και πολλά εύκολης χρήσης χαρακτηριστικά που παρέχουν στο Krita εξαιρετικά αυξημένη παραγωγικότητα.</p>
     <p xml:lang="en-GB">Have fun painting with the advanced brush engines, amazing filters and many handy features that make Krita enormously productive.</p>
     <p xml:lang="es">Diviértase pintando con los avanzados motores de pinceles, los espectaculares filtros y muchas funcionalidades prácticas que hacen que Krita sea enormemente productivo.</p>
     <p xml:lang="et">Joonistamise muudavad tunduvalt lõbusamaks võimsad pintslimootorid, imetabased filtrid ja veel paljud käepärased võimalused, mis muudavad Krita kasutaja tohutult tootlikuks.</p>
     <p xml:lang="fi">Pidä hauskaa maalatessasi edistyneillä sivellinmoottoreilla, hämmästyttävillä suotimilla ja monilla muilla kätevillä ominaisuuksilla, jotka tekevät Kritasta tavattoman tehokkaan.</p>
     <p xml:lang="fr">Amusez-vous à peindre avec les outils de brosse avancés, les filtres incroyables et les nombreuses fonctionnalités pratiques qui rendent Krita extrêmement productif.</p>
     <p xml:lang="gl">Goza debuxando con motores de pincel avanzados, filtros fantásticos e moitas outras funcionalidades útiles que fan de Krita un programa extremadamente produtivo.</p>
     <p xml:lang="ia">Amusa te a pinger con le motores de pincel avantiate, filtros stupende e multe characteristicas amical que face Krita enormemente productive.</p>
     <p xml:lang="id">Bersenang-senanglah melukis dengan mesin kuas canggih, filter luar biasa dan banyak fitur berguna yang membuat Krita sangat produktif.</p>
     <p xml:lang="it">Divertiti a dipingere con gli avanzati sistemi di pennelli, i sorprendenti filtri e molte altre utili caratteristiche che fanno di Krita un software enormemente produttivo.</p>
     <p xml:lang="ja">Krita のソフトウェアとしての生産性を高めている先進的なブラシエンジンや素晴らしいフィルタのほか、便利な機能の数々をお楽しみください。</p>
     <p xml:lang="nl">Veel plezier met schilderen met the geavanceerde penseel-engines, filters vol verbazing en vele handige mogelijkheden die maken dat Krita enorm productief is.</p>
     <p xml:lang="pl">Baw się przy malowaniu przy użyciu zaawansowanych silników pędzli, zadziwiających filtrów i wielu innych przydatnych cech, które czynią z Krity bardzo produktywną.</p>
     <p xml:lang="pt">Divirta-se a pintar com os motores de pincéis avançados, os filtros espantosos e muitas outras funcionalidades úteis que tornam o Krita altamente produtivo.</p>
     <p xml:lang="pt-BR">Divirta-se pintando com os mecanismos de pincéis avançados, filtros maravilhosos e muitas outras funcionalidades úteis que tornam o Krita altamente produtivo.</p>
     <p xml:lang="ru">Получайте удовольствие от использования особых кистевых движков, впечатляющих фильтров и множества других функций, делающих Krita сверхпродуктивной.</p>
     <p xml:lang="sk">Užívajte si maľovanie s pokročilými kresliacimi enginmi, úžasnými filtrami a mnohými užitočnými funkciami, ktoré robia Kritu veľmi produktívnu.</p>
     <p xml:lang="sv">Ha det så kul vid målning med de avancerade penselfunktionerna, fantastiska filtren och många praktiska funktioner som gör Krita så enormt produktiv.</p>
     <p xml:lang="tr">Gelişmiş fırça motorları, şaşırtıcı filtreler ve Krita'yı son derece üretken yapan bir çok kullanışlı özellikli boya ile iyi eğlenceler.</p>
     <p xml:lang="uk">Отримуйте задоволення від малювання за допомогою пензлів з найширшими можливостями, чудових фільтрів та багатьох зручних можливостей, які роблять Krita надзвичайно продуктивним засобом малювання.</p>
     <p xml:lang="x-test">xxHave fun painting with the advanced brush engines, amazing filters and many handy features that make Krita enormously productive.xx</p>
     <p xml:lang="zh-CN">Krita 具有功能强大的笔刷引擎、种类繁多的滤镜以及便于操作的交互设计，可让你尽情、高效地挥洒无限创意。</p>
     <p xml:lang="zh-TW">使用先進的筆刷引擎、驚人的濾鏡和許多方便的功能來開心地繪畫，讓 Krita 擁有巨大的生產力。</p>
   </description>
   <url type="homepage">https://www.krita.org/</url>
   <url type="faq">https://krita.org/about/faq/</url>
   <url type="donation">https://krita.org/support-us/donations/</url>
   <url type="help">https://docs.krita.org/Category:Tutorials</url>
   <screenshots>
     <screenshot type="default">
       <image>https://cdn.kde.org/screenshots/krita/2018-03-17_screenshot_001.png</image>
     </screenshot>
     <screenshot type="default">
       <image>https://cdn.kde.org/screenshots/krita/2018-03-17_screenshot_002.png</image>
     </screenshot>
     <screenshot type="default">
       <image>https://cdn.kde.org/screenshots/krita/2018-03-17_screenshot_003.png</image>
     </screenshot>
     <screenshot type="default">
       <image>https://cdn.kde.org/screenshots/krita/2018-03-17_screenshot_004.png</image>
     </screenshot>
     <screenshot type="default">
       <image>https://cdn.kde.org/screenshots/krita/2018-03-17_screenshot_005.png</image>
     </screenshot>
     <screenshot type="default">
       <image>https://cdn.kde.org/screenshots/krita/2018-03-17_screenshot_006.png</image>
     </screenshot>
   </screenshots>
   <content_rating type="oars-1.0">
     <content_attribute id="violence-cartoon">none</content_attribute>
     <content_attribute id="violence-fantasy">none</content_attribute>
     <content_attribute id="violence-realistic">none</content_attribute>
     <content_attribute id="violence-bloodshed">none</content_attribute>
     <content_attribute id="violence-sexual">none</content_attribute>
     <content_attribute id="drugs-alcohol">none</content_attribute>
     <content_attribute id="drugs-narcotics">none</content_attribute>
     <content_attribute id="drugs-tobacco">none</content_attribute>
     <content_attribute id="sex-nudity">none</content_attribute>
     <content_attribute id="sex-themes">none</content_attribute>
     <content_attribute id="language-profanity">none</content_attribute>
     <content_attribute id="language-humor">none</content_attribute>
     <content_attribute id="language-discrimination">none</content_attribute>
     <content_attribute id="social-chat">none</content_attribute>
     <content_attribute id="social-info">none</content_attribute>
     <content_attribute id="social-audio">none</content_attribute>
     <content_attribute id="social-location">none</content_attribute>
     <content_attribute id="social-contacts">none</content_attribute>
     <content_attribute id="money-purchasing">none</content_attribute>
     <content_attribute id="money-gambling">none</content_attribute>
   </content_rating>
   <categories>
     <category>Graphics</category>
   </categories>
   <project_group>KDE</project_group>
   <provides>
     <binary>krita</binary>
   </provides>
   <releases>
     <release date="2018-01-11" version="4.0.0.51 (beta 1)"/>
   </releases>
 </component>
diff --git a/libs/brush/kis_brush_registry.cpp b/libs/brush/kis_brush_registry.cpp
index e832974f35..811de1a003 100644
--- a/libs/brush/kis_brush_registry.cpp
+++ b/libs/brush/kis_brush_registry.cpp
@@ -1,76 +1,75 @@
 /*
  *  Copyright (c) 2008 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "kis_brush_registry.h"
 
 #include <QString>
 
 #include <QGlobalStatic>
 #include <klocalizedstring.h>
 
 #include <KoPluginLoader.h>
 
 #include <kis_debug.h>
 
 #include "kis_brush_server.h"
 #include "kis_auto_brush_factory.h"
 #include "kis_text_brush_factory.h"
 #include "kis_predefined_brush_factory.h"
 
 Q_GLOBAL_STATIC(KisBrushRegistry, s_instance)
 
 
 KisBrushRegistry::KisBrushRegistry()
 {
     KisBrushServer::instance();
 }
 
 KisBrushRegistry::~KisBrushRegistry()
 {
     Q_FOREACH (const QString & id, keys()) {
         delete get(id);
     }
     dbgRegistry << "deleting KisBrushRegistry";
 }
 
 KisBrushRegistry* KisBrushRegistry::instance()
 {
     if (!s_instance.exists()) {
         s_instance->add(new KisAutoBrushFactory());
         s_instance->add(new KisPredefinedBrushFactory("gbr_brush"));
         s_instance->add(new KisPredefinedBrushFactory("abr_brush"));
         s_instance->add(new KisTextBrushFactory());
         s_instance->add(new KisPredefinedBrushFactory("png_brush"));
         s_instance->add(new KisPredefinedBrushFactory("svg_brush"));
-        KoPluginLoader::instance()->load("Krita/Brush", "Type == 'Service' and ([X-Krita-Version] == 28)");
     }
     return s_instance;
 }
 
 
 KisBrushSP KisBrushRegistry::createBrush(const QDomElement& element)
 {
     QString brushType = element.attribute("type");
 
     if (brushType.isEmpty()) return 0;
 
     KisBrushFactory* factory = get(brushType);
     if (!factory) return 0;
 
     return factory->createBrush(element);
 }
 
diff --git a/libs/flake/tools/KoPathToolFactory.cpp b/libs/flake/tools/KoPathToolFactory.cpp
index bdcdd8dc08..aa82b36d16 100644
--- a/libs/flake/tools/KoPathToolFactory.cpp
+++ b/libs/flake/tools/KoPathToolFactory.cpp
@@ -1,44 +1,44 @@
 /* This file is part of the KDE project
  * Copyright (C) 2006 Jan Hambrecht <jaham@gmx.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "KoPathToolFactory.h"
 #include "KoPathTool.h"
 #include "KoPathShape.h"
 
 #include <KoIcon.h>
 #include <klocalizedstring.h>
 
 KoPathToolFactory::KoPathToolFactory()
         : KoToolFactoryBase("PathTool")
 {
     setToolTip(i18n("Edit Shapes Tool"));
     setSection(mainToolType());
     setIconName(koIconNameCStr("shape_handling"));
-    setPriority(1);
+    setPriority(2);
     setActivationShapeId("flake/always,KoPathShape");
 }
 
 KoPathToolFactory::~KoPathToolFactory()
 {
 }
 
 KoToolBase * KoPathToolFactory::createTool(KoCanvasBase *canvas)
 {
     return new KoPathTool(canvas);
 }
diff --git a/libs/image/kis_convolution_painter.cc b/libs/image/kis_convolution_painter.cc
index 78a72523d7..a1596c2dc9 100644
--- a/libs/image/kis_convolution_painter.cc
+++ b/libs/image/kis_convolution_painter.cc
@@ -1,158 +1,175 @@
 /*
  *  Copyright (c) 2005 Cyrille Berger <cberger@cberger.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_convolution_painter.h"
 
 #include <stdlib.h>
 #include <string.h>
 #include <cfloat>
 
 #include <QBrush>
 #include <QColor>
 #include <QPen>
 #include <QMatrix>
 #include <QImage>
 #include <QMap>
 #include <QPainter>
 #include <QRect>
 #include <QString>
 #include <QVector>
 
 #include <kis_debug.h>
 #include <klocalizedstring.h>
 
 #include "kis_convolution_kernel.h"
 #include "kis_global.h"
 #include "kis_image.h"
 #include "kis_layer.h"
 #include "kis_paint_device.h"
 #include "kis_painter.h"
 #include "KoColorSpace.h"
 #include <KoChannelInfo.h>
 #include "kis_types.h"
 
 #include "kis_selection.h"
 
 #include "kis_convolution_worker.h"
 #include "kis_convolution_worker_spatial.h"
 
 #include "config_convolution.h"
 
 #ifdef HAVE_FFTW3
 #include "kis_convolution_worker_fft.h"
 #endif
 
 
+bool KisConvolutionPainter::useFFTImplemenation(const KisConvolutionKernelSP kernel) const
+{
+    bool result = false;
+
+#ifdef HAVE_FFTW3
+    #define THRESHOLD_SIZE 5
+
+    result =
+        m_enginePreference == FFTW ||
+        (m_enginePreference == NONE &&
+         kernel->width() > THRESHOLD_SIZE &&
+         kernel->height() > THRESHOLD_SIZE);
+#else
+    Q_UNUSED(kernel);
+#endif
+
+    return result;
+}
+
 template<class factory>
 KisConvolutionWorker<factory>* KisConvolutionPainter::createWorker(const KisConvolutionKernelSP kernel,
                                                                    KisPainter *painter,
                                                                    KoUpdater *progress)
 {
     KisConvolutionWorker<factory> *worker;
 
 #ifdef HAVE_FFTW3
-    #define THRESHOLD_SIZE 5
-
-    if(m_enginePreference == SPATIAL ||
-       (m_enginePreference != FFTW &&
-        kernel->width() <= THRESHOLD_SIZE &&
-        kernel->height() <= THRESHOLD_SIZE)) {
-
-        worker = new KisConvolutionWorkerSpatial<factory>(painter, progress);
-    }
-    else {
+    if (useFFTImplemenation(kernel)) {
         worker = new KisConvolutionWorkerFFT<factory>(painter, progress);
+    } else {
+        worker = new KisConvolutionWorkerSpatial<factory>(painter, progress);
     }
 #else
     Q_UNUSED(kernel);
     worker = new KisConvolutionWorkerSpatial<factory>(painter, progress);
 #endif
 
     return worker;
 }
 
 
 KisConvolutionPainter::KisConvolutionPainter()
     : KisPainter(),
       m_enginePreference(NONE)
 {
 }
 
 KisConvolutionPainter::KisConvolutionPainter(KisPaintDeviceSP device)
     : KisPainter(device),
       m_enginePreference(NONE)
 {
 }
 
 KisConvolutionPainter::KisConvolutionPainter(KisPaintDeviceSP device, KisSelectionSP selection)
     : KisPainter(device, selection),
       m_enginePreference(NONE)
 {
 }
 
 KisConvolutionPainter::KisConvolutionPainter(KisPaintDeviceSP device, TestingEnginePreference enginePreference)
     : KisPainter(device),
       m_enginePreference(enginePreference)
 {
 }
 
 void KisConvolutionPainter::applyMatrix(const KisConvolutionKernelSP kernel, const KisPaintDeviceSP src, QPoint srcPos, QPoint dstPos, QSize areaSize, KisConvolutionBorderOp borderOp)
 {
     /**
      * Force BORDER_IGNORE op for the wraparound mode,
      * because the paint device has its own special
      * iterators, which do everything for us.
      */
     if (src->defaultBounds()->wrapAroundMode()) {
         borderOp = BORDER_IGNORE;
     }
 
     // Determine whether we convolve border pixels, or not.
     switch (borderOp) {
     case BORDER_REPEAT: {
         const QRect boundsRect = src->exactBounds();
         const QRect requestedRect = QRect(srcPos, areaSize);
         QRect dataRect = requestedRect | boundsRect;
 
         /**
          * FIXME: Implementation can return empty destination device
          * on faults and has no way to report this. This will cause a crash
          * on sequential convolutions inside iteratiors.
          *
          * o implementation should do it's work or assert otherwise
          *   (or report the issue somehow)
          * o check other cases of the switch for the vulnerability
          */
 
         if(dataRect.isValid()) {
             KisConvolutionWorker<RepeatIteratorFactory> *worker;
             worker = createWorker<RepeatIteratorFactory>(kernel, this, progressUpdater());
             worker->execute(kernel, src, srcPos, dstPos, areaSize, dataRect);
             delete worker;
         }
         break;
     }
     case BORDER_IGNORE:
     default: {
         KisConvolutionWorker<StandardIteratorFactory> *worker;
         worker = createWorker<StandardIteratorFactory>(kernel, this, progressUpdater());
         worker->execute(kernel, src, srcPos, dstPos, areaSize, QRect());
         delete worker;
     }
     }
 }
+
+bool KisConvolutionPainter::needsTransaction(const KisConvolutionKernelSP kernel) const
+{
+    return !useFFTImplemenation(kernel);
+}
diff --git a/libs/image/kis_convolution_painter.h b/libs/image/kis_convolution_painter.h
index 1438feba92..2cb6b09a90 100644
--- a/libs/image/kis_convolution_painter.h
+++ b/libs/image/kis_convolution_painter.h
@@ -1,91 +1,100 @@
 /*
  *  Copyright (c) 2005 Cyrille Berger <cberger@cberger.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef KIS_CONVOLUTION_PAINTER_H_
 #define KIS_CONVOLUTION_PAINTER_H_
 
 #include "kis_types.h"
 #include "kis_painter.h"
 #include "kis_image.h"
 #include "kritaimage_export.h"
 
 template<class factory> class KisConvolutionWorker;
 
 
 enum KisConvolutionBorderOp {
     BORDER_IGNORE = 0, // read the pixels outside of the application rect
     BORDER_REPEAT = 1  // Use the border for the missing pixels
 };
 
 /**
  * @brief The KisConvolutionPainter class applies a convolution kernel to a paint device.
  *
  *
  * Note: https://bugs.kde.org/show_bug.cgi?id=220310 shows that there's something here
  * that we need to fix...
  */
 class KRITAIMAGE_EXPORT KisConvolutionPainter : public KisPainter
 {
 
 public:
 
     KisConvolutionPainter();
     KisConvolutionPainter(KisPaintDeviceSP device);
     KisConvolutionPainter(KisPaintDeviceSP device, KisSelectionSP selection);
 
     /**
      * Convolve all channels in src using the specified kernel; there is only one kernel for all
      * channels possible. By default the border pixels are not convolved, that is, convolving
      * starts with at (x + kernel.width/2, y + kernel.height/2) and stops at w - (kernel.width/2)
      * and h - (kernel.height/2)
      *
      * The border op decides what to do with pixels too close to the edge of the rect as defined above.
      *
      * The channels flag determines which set out of color channels, alpha channels.
      * channels we convolve.
      *
      * Note that we do not (currently) support different kernels for
      * different channels _or_ channel types.
      *
      * If you want to convolve a subset of the channels in a pixel,
      * set those channels with KisPainter::setChannelFlags();
      */
     void applyMatrix(const KisConvolutionKernelSP kernel, const KisPaintDeviceSP src, QPoint srcPos, QPoint dstPos, QSize areaSize,
                      KisConvolutionBorderOp borderOp = BORDER_REPEAT);
 
+    /**
+     * The caller should ask if the painter needs an explicit transaction iff
+     * the source and destination devices coincide. Otherwise, the transaction is
+     * just not needed.
+     */
+    bool needsTransaction(const KisConvolutionKernelSP kernel) const;
+
 protected:
     friend class KisConvolutionPainterTest;
     enum TestingEnginePreference {
         NONE,
         SPATIAL,
         FFTW
     };
 
 
     KisConvolutionPainter(KisPaintDeviceSP device, TestingEnginePreference enginePreference);
 
 
 private:
     template<class factory>
         KisConvolutionWorker<factory>* createWorker(const KisConvolutionKernelSP kernel,
                                                     KisPainter *painter,
                                                     KoUpdater *progress);
 
+     bool useFFTImplemenation(const KisConvolutionKernelSP kernel) const;
+
 private:
     TestingEnginePreference m_enginePreference;
 };
 #endif //KIS_CONVOLUTION_PAINTER_H_
diff --git a/libs/image/kis_filter_mask.cpp b/libs/image/kis_filter_mask.cpp
index 5eab3273c2..0ef0e01088 100644
--- a/libs/image/kis_filter_mask.cpp
+++ b/libs/image/kis_filter_mask.cpp
@@ -1,179 +1,182 @@
 /*
  *  Copyright (c) 2007 Boudewijn Rempt <boud@valdyas.org>
  *
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include <KoIcon.h>
 #include <kis_icon.h>
 #include <KoCompositeOpRegistry.h>
 
 #include "kis_layer.h"
 #include "kis_filter_mask.h"
 #include "filter/kis_filter.h"
 #include "filter/kis_filter_configuration.h"
 #include "filter/kis_filter_registry.h"
 #include "kis_selection.h"
 #include "kis_processing_information.h"
 #include "kis_node.h"
 #include "kis_node_visitor.h"
 #include "kis_processing_visitor.h"
 #include "kis_busy_progress_indicator.h"
 #include "kis_transaction.h"
 #include "kis_painter.h"
 
 KisFilterMask::KisFilterMask()
     : KisEffectMask(),
       KisNodeFilterInterface(0, false)
 {
     setCompositeOpId(COMPOSITE_COPY);
 }
 
 KisFilterMask::~KisFilterMask()
 {
 }
 
 KisFilterMask::KisFilterMask(const KisFilterMask& rhs)
         : KisEffectMask(rhs)
         , KisNodeFilterInterface(rhs)
 {
 }
 
 QIcon KisFilterMask::icon() const
 {
     return KisIconUtils::loadIcon("filterMask");
 }
 
 void KisFilterMask::setFilter(KisFilterConfigurationSP  filterConfig)
 {
     if (parent() && parent()->inherits("KisLayer")) {
         filterConfig->setChannelFlags(qobject_cast<KisLayer*>(parent().data())->channelFlags());
     }
     KisNodeFilterInterface::setFilter(filterConfig);
 }
 
 QRect KisFilterMask::decorateRect(KisPaintDeviceSP &src,
                                   KisPaintDeviceSP &dst,
                                   const QRect & rc,
                                   PositionToFilthy maskPos) const
 {
     Q_UNUSED(maskPos);
 
     KisFilterConfigurationSP filterConfig = filter();
 
-    Q_ASSERT(nodeProgressProxy());
-    Q_ASSERT_X(src != dst, "KisFilterMask::decorateRect",
-               "src must be != dst, because we can't create transactions "
-               "during merge, as it breaks reentrancy");
+    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(nodeProgressProxy(), rc);
+    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(
+        src != dst &&
+            "KisFilterMask::decorateRect: "
+            "src must be != dst, because we can't create transactions "
+            "during merge, as it breaks reentrancy",
+        rc);
 
     if (!filterConfig) {
         return QRect();
     }
 
     KisFilterSP filter =
         KisFilterRegistry::instance()->value(filterConfig->name());
 
     if (!filter) {
         warnKrita << "Could not retrieve filter \"" << filterConfig->name() << "\"";
         return QRect();
     }
 
     KIS_ASSERT_RECOVER_NOOP(this->busyProgressIndicator());
     this->busyProgressIndicator()->update();
 
     filter->process(src, dst, 0, rc, filterConfig.data(), 0);
 
     QRect r = filter->changedRect(rc, filterConfig.data(), dst->defaultBounds()->currentLevelOfDetail());
     return r;
 }
 
 bool KisFilterMask::accept(KisNodeVisitor &v)
 {
     return v.visit(this);
 }
 
 void KisFilterMask::accept(KisProcessingVisitor &visitor, KisUndoAdapter *undoAdapter)
 {
     return visitor.visit(this, undoAdapter);
 }
 
 /**
  * FIXME: try to cache filter pointer inside a Private block
  */
 QRect KisFilterMask::changeRect(const QRect &rect, PositionToFilthy pos) const
 {
     /**
      * FIXME: This check of the emptiness should be done
      * on the higher/lower level
      */
     if(rect.isEmpty()) return rect;
 
     QRect filteredRect = rect;
 
     KisFilterConfigurationSP filterConfig = filter();
     if (filterConfig) {
         KisNodeSP parent = this->parent();
         const int lod = parent && parent->projection() ?
             parent->projection()->defaultBounds()->currentLevelOfDetail() : 0;
 
         KisFilterSP filter = KisFilterRegistry::instance()->value(filterConfig->name());
         filteredRect = filter->changedRect(rect, filterConfig.data(), lod);
     }
 
     /**
      * We can't paint outside a selection, that is why we call
      * KisMask::changeRect to crop actual change area in the end
      */
     filteredRect = KisMask::changeRect(filteredRect, pos);
     /**
      * FIXME: Think over this solution
      * Union of rects means that changeRect returns NOT the rect
      * changed by this very layer, but an accumulated rect changed
      * by all underlying layers. Just take into account and change
      * documentation accordingly
      */
     return rect | filteredRect;
 }
 
 QRect KisFilterMask::needRect(const QRect& rect, PositionToFilthy pos) const
 {
     Q_UNUSED(pos);
 
     /**
      * FIXME: This check of the emptiness should be done
      * on the higher/lower level
      */
 
     if(rect.isEmpty()) return rect;
 
     KisFilterConfigurationSP filterConfig = filter();
     if (!filterConfig) return rect;
 
     KisNodeSP parent = this->parent();
     const int lod = parent && parent->projection() ?
         parent->projection()->defaultBounds()->currentLevelOfDetail() : 0;
 
     KisFilterSP filter = KisFilterRegistry::instance()->value(filterConfig->name());
 
     /**
      * If we need some additional pixels even outside of a selection
      * for accurate layer filtering, we'll get them!
      * And no KisMask::needRect will prevent us from doing this! ;)
      * That's why simply we do not call KisMask::needRect here :)
      */
     return filter->neededRect(rect, filterConfig.data(), lod);
 }
 
diff --git a/libs/image/kis_gaussian_kernel.cpp b/libs/image/kis_gaussian_kernel.cpp
index 0788240921..e6ba32a841 100644
--- a/libs/image/kis_gaussian_kernel.cpp
+++ b/libs/image/kis_gaussian_kernel.cpp
@@ -1,318 +1,332 @@
 /*
  *  Copyright (c) 2014 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_gaussian_kernel.h"
 
 #include "kis_global.h"
 #include "kis_convolution_kernel.h"
 #include <kis_convolution_painter.h>
+#include <kis_transaction.h>
 #include <QRect>
 
 
 qreal KisGaussianKernel::sigmaFromRadius(qreal radius)
 {
     return 0.3 * radius + 0.3;
 }
 
 int KisGaussianKernel::kernelSizeFromRadius(qreal radius)
 {
     return 6 * ceil(sigmaFromRadius(radius)) + 1;
 }
 
 
 Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic>
 KisGaussianKernel::createHorizontalMatrix(qreal radius)
 {
     int kernelSize = kernelSizeFromRadius(radius);
     Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> matrix(1, kernelSize);
 
     const qreal sigma = sigmaFromRadius(radius);
     const qreal multiplicand = 1 / (sqrt(2 * M_PI * sigma * sigma));
     const qreal exponentMultiplicand = 1 / (2 * sigma * sigma);
 
     /**
      * The kernel size should always be odd, then the position of the
      * central pixel can be easily calculated
      */
     KIS_ASSERT_RECOVER_NOOP(kernelSize & 0x1);
     const int center = kernelSize / 2;
 
     for (int x = 0; x < kernelSize; x++) {
         qreal xDistance = center - x;
         matrix(0, x) = multiplicand * exp( -xDistance * xDistance * exponentMultiplicand );
     }
 
     return matrix;
 }
 
 Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic>
 KisGaussianKernel::createVerticalMatrix(qreal radius)
 {
     int kernelSize = kernelSizeFromRadius(radius);
     Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> matrix(kernelSize, 1);
 
     const qreal sigma = sigmaFromRadius(radius);
     const qreal multiplicand = 1 / (sqrt(2 * M_PI * sigma * sigma));
     const qreal exponentMultiplicand = 1 / (2 * sigma * sigma);
 
     /**
      * The kernel size should always be odd, then the position of the
      * central pixel can be easily calculated
      */
     KIS_ASSERT_RECOVER_NOOP(kernelSize & 0x1);
     const int center = kernelSize / 2;
 
     for (int y = 0; y < kernelSize; y++) {
         qreal yDistance = center - y;
         matrix(y, 0) = multiplicand * exp( -yDistance * yDistance * exponentMultiplicand );
     }
 
     return matrix;
 }
 
 KisConvolutionKernelSP
 KisGaussianKernel::createHorizontalKernel(qreal radius)
 {
     Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> matrix = createHorizontalMatrix(radius);
     return KisConvolutionKernel::fromMatrix(matrix, 0, matrix.sum());
 }
 
 KisConvolutionKernelSP
 KisGaussianKernel::createVerticalKernel(qreal radius)
 {
     Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> matrix = createVerticalMatrix(radius);
     return KisConvolutionKernel::fromMatrix(matrix, 0, matrix.sum());
 }
 
 void KisGaussianKernel::applyGaussian(KisPaintDeviceSP device,
                                       const QRect& rect,
                                       qreal xRadius, qreal yRadius,
                                       const QBitArray &channelFlags,
-                                      KoUpdater *progressUpdater)
+                                      KoUpdater *progressUpdater,
+                                      bool createTransaction)
 {
     QPoint srcTopLeft = rect.topLeft();
 
     if (xRadius > 0.0 && yRadius > 0.0) {
         KisPaintDeviceSP interm = new KisPaintDevice(device->colorSpace());
 
         KisConvolutionKernelSP kernelHoriz = KisGaussianKernel::createHorizontalKernel(xRadius);
         KisConvolutionKernelSP kernelVertical = KisGaussianKernel::createVerticalKernel(yRadius);
 
         qreal verticalCenter = qreal(kernelVertical->height()) / 2.0;
 
         KisConvolutionPainter horizPainter(interm);
         horizPainter.setChannelFlags(channelFlags);
         horizPainter.setProgress(progressUpdater);
         horizPainter.applyMatrix(kernelHoriz, device,
                                  srcTopLeft - QPoint(0, ceil(verticalCenter)),
                                  srcTopLeft - QPoint(0, ceil(verticalCenter)),
                                  rect.size() + QSize(0, 2 * ceil(verticalCenter)), BORDER_REPEAT);
 
 
         KisConvolutionPainter verticalPainter(device);
         verticalPainter.setChannelFlags(channelFlags);
         verticalPainter.setProgress(progressUpdater);
         verticalPainter.applyMatrix(kernelVertical, interm, srcTopLeft, srcTopLeft, rect.size(), BORDER_REPEAT);
 
     } else if (xRadius > 0.0) {
         KisConvolutionPainter painter(device);
         painter.setChannelFlags(channelFlags);
         painter.setProgress(progressUpdater);
 
         KisConvolutionKernelSP kernelHoriz = KisGaussianKernel::createHorizontalKernel(xRadius);
+
+        QScopedPointer<KisTransaction> transaction;
+        if (createTransaction && painter.needsTransaction(kernelHoriz)) {
+            transaction.reset(new KisTransaction(device));
+        }
+
         painter.applyMatrix(kernelHoriz, device, srcTopLeft, srcTopLeft, rect.size(), BORDER_REPEAT);
 
     } else if (yRadius > 0.0) {
         KisConvolutionPainter painter(device);
         painter.setChannelFlags(channelFlags);
         painter.setProgress(progressUpdater);
 
         KisConvolutionKernelSP kernelVertical = KisGaussianKernel::createVerticalKernel(yRadius);
+
+        QScopedPointer<KisTransaction> transaction;
+        if (createTransaction && painter.needsTransaction(kernelVertical)) {
+            transaction.reset(new KisTransaction(device));
+        }
+
         painter.applyMatrix(kernelVertical, device, srcTopLeft, srcTopLeft, rect.size(), BORDER_REPEAT);
     }
 }
 
 Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic>
 KisGaussianKernel::createLoGMatrix(qreal radius, qreal coeff)
 {
     int kernelSize = 4 * std::ceil(radius) + 1;
     Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> matrix(kernelSize, kernelSize);
 
     const qreal sigma = radius/* / sqrt(2)*/;
     const qreal multiplicand = -1.0 / (M_PI * pow2(pow2(sigma)));
     const qreal exponentMultiplicand = 1 / (2 * pow2(sigma));
 
     /**
      * The kernel size should always be odd, then the position of the
      * central pixel can be easily calculated
      */
     KIS_ASSERT_RECOVER_NOOP(kernelSize & 0x1);
     const int center = kernelSize / 2;
 
     for (int y = 0; y < kernelSize; y++) {
         const qreal yDistance = center - y;
         for (int x = 0; x < kernelSize; x++) {
             const qreal xDistance = center - x;
             const qreal distance = pow2(xDistance) + pow2(yDistance);
             const qreal normalizedDistance = exponentMultiplicand * distance;
 
             matrix(x, y) = multiplicand *
                 (1.0 - normalizedDistance) *
                 exp(-normalizedDistance);
         }
     }
 
     qreal lateral = matrix.sum() - matrix(center, center);
     matrix(center, center) = -lateral;
 
     qreal positiveSum = 0;
     qreal sideSum = 0;
     qreal quarterSum = 0;
 
     for (int y = 0; y < kernelSize; y++) {
         for (int x = 0; x < kernelSize; x++) {
             const qreal value = matrix(x, y);
             if (value > 0) {
                 positiveSum += value;
             }
             if (x > center) {
                 sideSum += value;
             }
             if (x > center && y > center) {
                 quarterSum += value;
             }
         }
     }
 
 
     const qreal scale = coeff * 2.0 / positiveSum;
     matrix *= scale;
     positiveSum *= scale;
     sideSum *= scale;
     quarterSum *= scale;
 
     //qDebug() << ppVar(positiveSum) << ppVar(sideSum) << ppVar(quarterSum);
 
     return matrix;
 }
 
 void KisGaussianKernel::applyLoG(KisPaintDeviceSP device,
                                  const QRect& rect,
                                  qreal radius, qreal coeff,
                                  const QBitArray &channelFlags,
                                  KoUpdater *progressUpdater)
 {
     QPoint srcTopLeft = rect.topLeft();
 
     KisConvolutionPainter painter(device);
     painter.setChannelFlags(channelFlags);
     painter.setProgress(progressUpdater);
 
     Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> matrix = createLoGMatrix(radius, coeff);
     KisConvolutionKernelSP kernel =
         KisConvolutionKernel::fromMatrix(matrix,
                                          0,
                                          0);
 
     painter.applyMatrix(kernel, device, srcTopLeft, srcTopLeft, rect.size(), BORDER_REPEAT);
 }
 
 Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> KisGaussianKernel::createDilateMatrix(qreal radius)
 {
-    int kernelSize = 2 * std::ceil(radius) + 1;
+    const int kernelSize = 2 * std::ceil(radius) + 1;
     Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> matrix(kernelSize, kernelSize);
 
-
-    struct UnionFade {
-        quint8 value(qreal) const {
-            return 255;
-        }
-    };
-
-    const qreal fadeStart = radius - 1.0;
+    const qreal fadeStart = qMax(1.0, radius - 1.0);
 
     /**
      * The kernel size should always be odd, then the position of the
      * central pixel can be easily calculated
      */
     KIS_ASSERT_RECOVER_NOOP(kernelSize & 0x1);
     const int center = kernelSize / 2;
 
     for (int y = 0; y < kernelSize; y++) {
         const qreal yDistance = center - y;
         for (int x = 0; x < kernelSize; x++) {
             const qreal xDistance = center - x;
 
             const qreal distance = std::sqrt(pow2(xDistance) + pow2(yDistance));
 
             qreal value = 1.0;
 
             if (distance >= radius) {
                 value = 0.0;
             } else if (distance > fadeStart) {
                 value = radius - distance;
             }
 
             matrix(x, y) = value;
         }
     }
 
     return matrix;
 }
 
-void KisGaussianKernel::applyDilate(KisPaintDeviceSP device, const QRect &rect, qreal radius, const QBitArray &channelFlags, KoUpdater *progressUpdater)
+void KisGaussianKernel::applyDilate(KisPaintDeviceSP device, const QRect &rect, qreal radius, const QBitArray &channelFlags, KoUpdater *progressUpdater, bool createTransaction)
 {
+    KIS_SAFE_ASSERT_RECOVER_RETURN(device->colorSpace()->pixelSize() == 1);
+
     QPoint srcTopLeft = rect.topLeft();
 
     KisConvolutionPainter painter(device);
     painter.setChannelFlags(channelFlags);
     painter.setProgress(progressUpdater);
 
     Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> matrix = createDilateMatrix(radius);
     KisConvolutionKernelSP kernel =
         KisConvolutionKernel::fromMatrix(matrix,
                                          0,
-                                         0);
+                                         1.0);
+
+    QScopedPointer<KisTransaction> transaction;
+    if (createTransaction && painter.needsTransaction(kernel)) {
+        transaction.reset(new KisTransaction(device));
+    }
 
     painter.applyMatrix(kernel, device, srcTopLeft, srcTopLeft, rect.size(), BORDER_REPEAT);
 }
 
 #include "kis_sequential_iterator.h"
 
-void KisGaussianKernel::applyErodeU8(KisPaintDeviceSP device, const QRect &rect, qreal radius, const QBitArray &channelFlags, KoUpdater *progressUpdater)
+void KisGaussianKernel::applyErodeU8(KisPaintDeviceSP device, const QRect &rect, qreal radius, const QBitArray &channelFlags, KoUpdater *progressUpdater, bool createTransaction)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(device->colorSpace()->pixelSize() == 1);
 
     {
         KisSequentialIterator dstIt(device, rect);
         while (dstIt.nextPixel()) {
             quint8 *dstPtr = dstIt.rawData();
             *dstPtr = 255 - *dstPtr;
         }
     }
 
-    applyDilate(device, rect, radius, channelFlags, progressUpdater);
+    applyDilate(device, rect, radius, channelFlags, progressUpdater, createTransaction);
 
     {
         KisSequentialIterator dstIt(device, rect);
         while (dstIt.nextPixel()) {
             quint8 *dstPtr = dstIt.rawData();
             *dstPtr = 255 - *dstPtr;
         }
     }
 }
diff --git a/libs/image/kis_gaussian_kernel.h b/libs/image/kis_gaussian_kernel.h
index ef145a032f..51a6b8195d 100644
--- a/libs/image/kis_gaussian_kernel.h
+++ b/libs/image/kis_gaussian_kernel.h
@@ -1,77 +1,80 @@
 /*
  *  Copyright (c) 2014 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KIS_GAUSSIAN_KERNEL_H
 #define __KIS_GAUSSIAN_KERNEL_H
 
 #include "kritaimage_export.h"
 #include "kis_types.h"
 
 #include <Eigen/Core>
 
 class QRect;
 
 class KRITAIMAGE_EXPORT KisGaussianKernel
 {
 public:
     static Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic>
         createHorizontalMatrix(qreal radius);
 
     static Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic>
         createVerticalMatrix(qreal radius);
 
     static KisConvolutionKernelSP
         createHorizontalKernel(qreal radius);
 
     static KisConvolutionKernelSP
         createVerticalKernel(qreal radius);
 
     static qreal sigmaFromRadius(qreal radius);
     static int kernelSizeFromRadius(qreal radius);
 
     static void applyGaussian(KisPaintDeviceSP device,
                               const QRect& rect,
                               qreal xRadius, qreal yRadius,
                               const QBitArray &channelFlags,
-                              KoUpdater *updater);
+                              KoUpdater *updater,
+                              bool createTransaction = false);
 
     static Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> createLoGMatrix(qreal radius, qreal coeff = 1.0);
 
     static void applyLoG(KisPaintDeviceSP device,
                          const QRect& rect,
                          qreal radius,
                          qreal coeff,
                          const QBitArray &channelFlags,
                          KoUpdater *progressUpdater);
 
     static Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> createDilateMatrix(qreal radius);
 
     static void applyDilate(KisPaintDeviceSP device,
                             const QRect& rect,
                             qreal radius,
                             const QBitArray &channelFlags,
-                            KoUpdater *progressUpdater);
+                            KoUpdater *progressUpdater,
+                            bool createTransaction = false);
 
     static void applyErodeU8(KisPaintDeviceSP device,
                              const QRect& rect,
                              qreal radius,
                              const QBitArray &channelFlags,
-                             KoUpdater *progressUpdater);
+                             KoUpdater *progressUpdater,
+                             bool createTransaction = false);
 };
 
 #endif /* __KIS_GAUSSIAN_KERNEL_H */
diff --git a/libs/image/kis_layer.cc b/libs/image/kis_layer.cc
index 005a079d17..8829b009ba 100644
--- a/libs/image/kis_layer.cc
+++ b/libs/image/kis_layer.cc
@@ -1,948 +1,964 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2005 C. Boemann <cbo@boemann.dk>
  *  Copyright (c) 2009 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_layer.h"
 
 
 #include <klocalizedstring.h>
 #include <QImage>
 #include <QBitArray>
 #include <QStack>
 #include <QMutex>
 #include <QMutexLocker>
 
 #include <KoIcon.h>
 #include <kis_icon.h>
 #include <KoProperties.h>
 #include <KoCompositeOpRegistry.h>
 #include <KoColorSpace.h>
 
 #include "kis_debug.h"
 #include "kis_image.h"
 
 #include "kis_painter.h"
 #include "kis_mask.h"
 #include "kis_effect_mask.h"
 #include "kis_selection_mask.h"
 #include "kis_meta_data_store.h"
 #include "kis_selection.h"
 #include "kis_paint_layer.h"
 #include "kis_raster_keyframe_channel.h"
 
 #include "kis_clone_layer.h"
 
 #include "kis_psd_layer_style.h"
 #include "kis_layer_projection_plane.h"
 #include "layerstyles/kis_layer_style_projection_plane.h"
 
 #include "krita_utils.h"
 #include "kis_layer_properties_icons.h"
 #include "kis_layer_utils.h"
 
 
 class KisSafeProjection {
 public:
     KisPaintDeviceSP getDeviceLazy(KisPaintDeviceSP prototype) {
         QMutexLocker locker(&m_lock);
 
         if (!m_reusablePaintDevice) {
             m_reusablePaintDevice = new KisPaintDevice(*prototype);
         }
         if(!m_projection ||
            *m_projection->colorSpace() != *prototype->colorSpace()) {
             m_projection = m_reusablePaintDevice;
             m_projection->makeCloneFromRough(prototype, prototype->extent());
             m_projection->setProjectionDevice(true);
         }
 
         return m_projection;
     }
 
+    void tryCopyFrom(const KisSafeProjection &rhs) {
+        QMutexLocker locker(&m_lock);
+
+        if (!rhs.m_projection) return;
+
+        if (!m_reusablePaintDevice) {
+            m_reusablePaintDevice = new KisPaintDevice(*rhs.m_projection);
+            m_projection = m_reusablePaintDevice;
+        } else {
+            m_projection = m_reusablePaintDevice;
+            m_projection->makeCloneFromRough(rhs.m_projection, rhs.m_projection->extent());
+        }
+    }
+
     void freeDevice() {
         QMutexLocker locker(&m_lock);
         m_projection = 0;
         if(m_reusablePaintDevice) {
             m_reusablePaintDevice->clear();
         }
     }
 
 private:
     QMutex m_lock;
     KisPaintDeviceSP m_projection;
     KisPaintDeviceSP m_reusablePaintDevice;
 };
 
 class KisCloneLayersList {
 public:
     void addClone(KisCloneLayerWSP cloneLayer) {
         m_clonesList.append(cloneLayer);
     }
 
     void removeClone(KisCloneLayerWSP cloneLayer) {
         m_clonesList.removeOne(cloneLayer);
     }
 
     void setDirty(const QRect &rect) {
         Q_FOREACH (KisCloneLayerSP clone, m_clonesList) {
             if (clone) {
                 clone->setDirtyOriginal(rect);
             }
         }
     }
 
     const QList<KisCloneLayerWSP> registeredClones() const {
         return m_clonesList;
     }
 
     bool hasClones() const {
         return !m_clonesList.isEmpty();
     }
 
 private:
     QList<KisCloneLayerWSP> m_clonesList;
 };
 
 struct Q_DECL_HIDDEN KisLayer::Private
 {
     KisImageWSP image;
     QBitArray channelFlags;
     KisMetaData::Store* metaDataStore;
     KisSafeProjection safeProjection;
     KisCloneLayersList clonesList;
 
     KisPSDLayerStyleSP layerStyle;
     KisAbstractProjectionPlaneSP layerStyleProjectionPlane;
 
     KisAbstractProjectionPlaneSP projectionPlane;
 
     KisSelectionMaskSP selectionMask;
     QList<KisEffectMaskSP> effectMasks;
 };
 
 
 KisLayer::KisLayer(KisImageWSP image, const QString &name, quint8 opacity)
         : KisNode()
         , m_d(new Private)
 {
     setName(name);
     setOpacity(opacity);
     m_d->image = image;
     m_d->metaDataStore = new KisMetaData::Store();
     m_d->projectionPlane = toQShared(new KisLayerProjectionPlane(this));
     notifyChildMaskChanged(KisNodeSP());
 }
 
 KisLayer::KisLayer(const KisLayer& rhs)
         : KisNode(rhs)
         , m_d(new Private())
 {
     if (this != &rhs) {
         m_d->image = rhs.m_d->image;
         m_d->metaDataStore = new KisMetaData::Store(*rhs.m_d->metaDataStore);
         m_d->channelFlags = rhs.m_d->channelFlags;
 
+        m_d->safeProjection.tryCopyFrom(rhs.m_d->safeProjection);
+
         setName(rhs.name());
         m_d->projectionPlane = toQShared(new KisLayerProjectionPlane(this));
 
         if (rhs.m_d->layerStyle) {
             setLayerStyle(rhs.m_d->layerStyle->clone());
         }
         notifyChildMaskChanged(KisNodeSP());
     }
 }
 
 KisLayer::~KisLayer()
 {
     delete m_d->metaDataStore;
     delete m_d;
 }
 
 const KoColorSpace * KisLayer::colorSpace() const
 {
     KisImageSP image = m_d->image.toStrongRef();
     if (!image) {
         return nullptr;
     }
     return image->colorSpace();
 }
 
 const KoCompositeOp * KisLayer::compositeOp() const
 {
     /**
      * FIXME: This function duplicates the same function from
      * KisMask. We can't move it to KisBaseNode as it doesn't
      * know anything about parent() method of KisNode
      * Please think it over...
      */
 
     KisNodeSP parentNode = parent();
     if (!parentNode) return 0;
 
     if (!parentNode->colorSpace()) return 0;
     const KoCompositeOp* op = parentNode->colorSpace()->compositeOp(compositeOpId());
     return op ? op : parentNode->colorSpace()->compositeOp(COMPOSITE_OVER);
 }
 
 KisPSDLayerStyleSP KisLayer::layerStyle() const
 {
     return m_d->layerStyle;
 }
 
 void KisLayer::setLayerStyle(KisPSDLayerStyleSP layerStyle)
 {
     if (layerStyle) {
         m_d->layerStyle = layerStyle;
 
         KisAbstractProjectionPlaneSP plane = !layerStyle->isEmpty() ?
             KisAbstractProjectionPlaneSP(new KisLayerStyleProjectionPlane(this)) :
             KisAbstractProjectionPlaneSP(0);
 
         m_d->layerStyleProjectionPlane = plane;
     } else {
         m_d->layerStyleProjectionPlane.clear();
         m_d->layerStyle.clear();
     }
 }
 
 KisBaseNode::PropertyList KisLayer::sectionModelProperties() const
 {
     KisBaseNode::PropertyList l = KisBaseNode::sectionModelProperties();
     l << KisBaseNode::Property(KoID("opacity", i18n("Opacity")), i18n("%1%", percentOpacity()));
 
     const KoCompositeOp * compositeOp = this->compositeOp();
 
     if (compositeOp) {
         l << KisBaseNode::Property(KoID("compositeop", i18n("Blending Mode")), compositeOp->description());
     }
 
     if (m_d->layerStyle && !m_d->layerStyle->isEmpty()) {
         l << KisLayerPropertiesIcons::getProperty(KisLayerPropertiesIcons::layerStyle, m_d->layerStyle->isEnabled());
     }
 
     l << KisLayerPropertiesIcons::getProperty(KisLayerPropertiesIcons::inheritAlpha, alphaChannelDisabled());
 
     return l;
 }
 
 void KisLayer::setSectionModelProperties(const KisBaseNode::PropertyList &properties)
 {
     KisBaseNode::setSectionModelProperties(properties);
 
     Q_FOREACH (const KisBaseNode::Property &property, properties) {
         if (property.id == KisLayerPropertiesIcons::inheritAlpha.id()) {
             disableAlphaChannel(property.state.toBool());
         }
 
         if (property.id == KisLayerPropertiesIcons::layerStyle.id()) {
             if (m_d->layerStyle &&
                 m_d->layerStyle->isEnabled() != property.state.toBool()) {
 
                 m_d->layerStyle->setEnabled(property.state.toBool());
 
                 baseNodeChangedCallback();
                 baseNodeInvalidateAllFramesCallback();
             }
         }
     }
 }
 
 void KisLayer::disableAlphaChannel(bool disable)
 {
     QBitArray newChannelFlags = m_d->channelFlags;
 
     if(newChannelFlags.isEmpty())
         newChannelFlags = colorSpace()->channelFlags(true, true);
 
     if(disable)
         newChannelFlags &= colorSpace()->channelFlags(true, false);
     else
         newChannelFlags |= colorSpace()->channelFlags(false, true);
 
     setChannelFlags(newChannelFlags);
 }
 
 bool KisLayer::alphaChannelDisabled() const
 {
     QBitArray flags = colorSpace()->channelFlags(false, true) & m_d->channelFlags;
     return flags.count(true) == 0 && !m_d->channelFlags.isEmpty();
 }
 
 
 void KisLayer::setChannelFlags(const QBitArray & channelFlags)
 {
     Q_ASSERT(channelFlags.isEmpty() ||((quint32)channelFlags.count() == colorSpace()->channelCount()));
 
     if (KritaUtils::compareChannelFlags(channelFlags,
                                         this->channelFlags())) {
         return;
     }
 
     if (!channelFlags.isEmpty() &&
         channelFlags == QBitArray(channelFlags.size(), true)) {
 
         m_d->channelFlags.clear();
     } else {
         m_d->channelFlags = channelFlags;
     }
 
     baseNodeChangedCallback();
     baseNodeInvalidateAllFramesCallback();
 }
 
 QBitArray & KisLayer::channelFlags() const
 {
     return m_d->channelFlags;
 }
 
 bool KisLayer::temporary() const
 {
     return nodeProperties().boolProperty("temporary", false);
 }
 
 void KisLayer::setTemporary(bool t)
 {
     setNodeProperty("temporary", t);
 }
 
 KisImageWSP KisLayer::image() const
 {
     return m_d->image;
 }
 
 void KisLayer::setImage(KisImageWSP image)
 {
     m_d->image = image;
 
     // we own the projection device, so we should take care about it
     KisPaintDeviceSP projection = this->projection();
     if (projection && projection != original()) {
         projection->setDefaultBounds(new KisDefaultBounds(image));
     }
 
     KisNodeSP node = firstChild();
     while (node) {
         KisLayerUtils::recursiveApplyNodes(node,
                                            [image] (KisNodeSP node) {
                                                node->setImage(image);
                                            });
 
         node = node->nextSibling();
     }
 }
 
 bool KisLayer::canMergeAndKeepBlendOptions(KisLayerSP otherLayer)
 {
     return
         this->compositeOpId() == otherLayer->compositeOpId() &&
         this->opacity() == otherLayer->opacity() &&
         this->channelFlags() == otherLayer->channelFlags() &&
         !this->layerStyle() && !otherLayer->layerStyle() &&
         (this->colorSpace() == otherLayer->colorSpace() ||
          *this->colorSpace() == *otherLayer->colorSpace());
 }
 
 KisLayerSP KisLayer::createMergedLayerTemplate(KisLayerSP prevLayer)
 {
     const bool keepBlendingOptions = canMergeAndKeepBlendOptions(prevLayer);
 
     KisLayerSP newLayer = new KisPaintLayer(image(), prevLayer->name(), OPACITY_OPAQUE_U8);
 
     if (keepBlendingOptions) {
         newLayer->setCompositeOpId(compositeOpId());
         newLayer->setOpacity(opacity());
         newLayer->setChannelFlags(channelFlags());
     }
 
     return newLayer;
 }
 
 void KisLayer::fillMergedLayerTemplate(KisLayerSP dstLayer, KisLayerSP prevLayer)
 {
     const bool keepBlendingOptions = canMergeAndKeepBlendOptions(prevLayer);
 
     QRect layerProjectionExtent = this->projection()->extent();
     QRect prevLayerProjectionExtent = prevLayer->projection()->extent();
     bool alphaDisabled = this->alphaChannelDisabled();
     bool prevAlphaDisabled = prevLayer->alphaChannelDisabled();
 
     KisPaintDeviceSP mergedDevice = dstLayer->paintDevice();
 
     if (!keepBlendingOptions) {
         KisPainter gc(mergedDevice);
 
         KisImageSP imageSP = image().toStrongRef();
         if (!imageSP) {
             return;
         }
 
         //Copy the pixels of previous layer with their actual alpha value
         prevLayer->disableAlphaChannel(false);
 
         prevLayer->projectionPlane()->apply(&gc, prevLayerProjectionExtent | imageSP->bounds());
 
         //Restore the previous prevLayer disableAlpha status for correct undo/redo
         prevLayer->disableAlphaChannel(prevAlphaDisabled);
 
         //Paint the pixels of the current layer, using their actual alpha value
         if (alphaDisabled == prevAlphaDisabled) {
             this->disableAlphaChannel(false);
         }
 
         this->projectionPlane()->apply(&gc, layerProjectionExtent | imageSP->bounds());
 
         //Restore the layer disableAlpha status for correct undo/redo
         this->disableAlphaChannel(alphaDisabled);
     }
     else {
         //Copy prevLayer
         KisPaintDeviceSP srcDev = prevLayer->projection();
         mergedDevice->makeCloneFrom(srcDev, srcDev->extent());
 
         //Paint layer on the copy
         KisPainter gc(mergedDevice);
         gc.bitBlt(layerProjectionExtent.topLeft(), this->projection(), layerProjectionExtent);
     }
 }
 
 void KisLayer::registerClone(KisCloneLayerWSP clone)
 {
     m_d->clonesList.addClone(clone);
 }
 
 void KisLayer::unregisterClone(KisCloneLayerWSP clone)
 {
     m_d->clonesList.removeClone(clone);
 }
 
 const QList<KisCloneLayerWSP> KisLayer::registeredClones() const
 {
     return m_d->clonesList.registeredClones();
 }
 
 bool KisLayer::hasClones() const
 {
     return m_d->clonesList.hasClones();
 }
 
 void KisLayer::updateClones(const QRect &rect)
 {
     m_d->clonesList.setDirty(rect);
 }
 
 void KisLayer::notifyChildMaskChanged(KisNodeSP changedChildMask)
 {
     Q_UNUSED(changedChildMask);
 
     updateSelectionMask();
     updateEffectMasks();
 }
 
 KisSelectionMaskSP KisLayer::selectionMask() const
 {
     return m_d->selectionMask;
 }
 
 void KisLayer::updateSelectionMask()
 {
     KoProperties properties;
     properties.setProperty("active", true);
     properties.setProperty("visible", true);
     QList<KisNodeSP> masks = childNodes(QStringList("KisSelectionMask"), properties);
 
     // return the first visible mask
     Q_FOREACH (KisNodeSP mask, masks) {
         if (mask) {
             m_d->selectionMask = dynamic_cast<KisSelectionMask*>(mask.data());
             return;
         }
     }
     m_d->selectionMask = KisSelectionMaskSP();
 }
 
 KisSelectionSP KisLayer::selection() const
 {
     KisSelectionMaskSP mask = selectionMask();
 
     if (mask) {
         return mask->selection();
     }
 
     KisImageSP image = m_d->image.toStrongRef();
     if (image) {
         return image->globalSelection();
     }
     return KisSelectionSP();
 }
 
 ///////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////
 
 const QList<KisEffectMaskSP> &KisLayer::effectMasks() const
 {
     return m_d->effectMasks;
 }
 
 QList<KisEffectMaskSP> KisLayer::effectMasks(KisNodeSP lastNode) const
 {
     if (lastNode.isNull()) {
         return effectMasks();
     } else {
         // happens rarely.
         return searchEffectMasks(lastNode);
     }
 }
 
 void KisLayer::updateEffectMasks()
 {
     m_d->effectMasks = searchEffectMasks(KisNodeSP());
 }
 
 QList<KisEffectMaskSP> KisLayer::searchEffectMasks(KisNodeSP lastNode) const
 {
     QList<KisEffectMaskSP> masks;
 
     if (childCount() > 0) {
         KoProperties properties;
         properties.setProperty("visible", true);
         QList<KisNodeSP> nodes = childNodes(QStringList("KisEffectMask"), properties);
 
         Q_FOREACH (const KisNodeSP& node, nodes) {
             if (node == lastNode) break;
 
             KisEffectMaskSP mask = dynamic_cast<KisEffectMask*>(const_cast<KisNode*>(node.data()));
             if (mask)
                 masks.append(mask);
         }
     }
 
     return masks;
 }
 
 bool KisLayer::hasEffectMasks() const
 {
     return  !m_d->effectMasks.empty();
 }
 
 QRect KisLayer::masksChangeRect(const QList<KisEffectMaskSP> &masks,
                                 const QRect &requestedRect,
                                 bool &rectVariesFlag) const
 {
     rectVariesFlag = false;
 
     QRect prevChangeRect = requestedRect;
 
     /**
      * We set default value of the change rect for the case
      * when there is no mask at all
      */
     QRect changeRect = requestedRect;
 
     Q_FOREACH (const KisEffectMaskSP& mask, masks) {
         changeRect = mask->changeRect(prevChangeRect);
 
         if (changeRect != prevChangeRect)
             rectVariesFlag = true;
 
         prevChangeRect = changeRect;
     }
 
     return changeRect;
 }
 
 QRect KisLayer::masksNeedRect(const QList<KisEffectMaskSP> &masks,
                               const QRect &changeRect,
                               QStack<QRect> &applyRects,
                               bool &rectVariesFlag) const
 {
     rectVariesFlag = false;
 
     QRect prevNeedRect = changeRect;
     QRect needRect;
 
     for (qint32 i = masks.size() - 1; i >= 0; i--) {
         applyRects.push(prevNeedRect);
 
         needRect = masks[i]->needRect(prevNeedRect);
 
         if (prevNeedRect != needRect)
             rectVariesFlag = true;
 
         prevNeedRect = needRect;
     }
 
     return needRect;
 }
 
 KisNode::PositionToFilthy calculatePositionToFilthy(KisNodeSP nodeInQuestion,
                                            KisNodeSP filthy,
                                            KisNodeSP parent)
 {
     if (parent == filthy || parent != filthy->parent()) {
         return KisNode::N_ABOVE_FILTHY;
     }
 
     if (nodeInQuestion == filthy) {
         return KisNode::N_FILTHY;
     }
 
     KisNodeSP node = nodeInQuestion->prevSibling();
     while (node) {
         if (node == filthy) {
             return KisNode::N_ABOVE_FILTHY;
         }
         node = node->prevSibling();
     }
 
     return KisNode::N_BELOW_FILTHY;
 }
 
 QRect KisLayer::applyMasks(const KisPaintDeviceSP source,
                            KisPaintDeviceSP destination,
                            const QRect &requestedRect,
                            KisNodeSP filthyNode,
                            KisNodeSP lastNode) const
 {
     Q_ASSERT(source);
     Q_ASSERT(destination);
 
     QList<KisEffectMaskSP> masks = effectMasks(lastNode);
     QRect changeRect;
     QRect needRect;
 
     if (masks.isEmpty()) {
         changeRect = requestedRect;
         if (source != destination) {
             copyOriginalToProjection(source, destination, requestedRect);
         }
     } else {
         QStack<QRect> applyRects;
         bool changeRectVaries;
         bool needRectVaries;
 
         /**
          * FIXME: Assume that varying of the changeRect has already
          * been taken into account while preparing walkers
          */
         changeRectVaries = false;
         changeRect = requestedRect;
         //changeRect = masksChangeRect(masks, requestedRect,
         //                             changeRectVaries);
 
         needRect = masksNeedRect(masks, changeRect,
                                  applyRects, needRectVaries);
 
         if (!changeRectVaries && !needRectVaries) {
             /**
              * A bit of optimization:
              * All filters will read/write exactly from/to the requested
              * rect so we needn't create temporary paint device,
              * just apply it onto destination
              */
             Q_ASSERT(needRect == requestedRect);
 
             if (source != destination) {
                 copyOriginalToProjection(source, destination, needRect);
             }
 
             Q_FOREACH (const KisEffectMaskSP& mask, masks) {
                 const QRect maskApplyRect = applyRects.pop();
                 const QRect maskNeedRect =
                     applyRects.isEmpty() ? needRect : applyRects.top();
 
                 PositionToFilthy maskPosition = calculatePositionToFilthy(mask, filthyNode, const_cast<KisLayer*>(this));
                 mask->apply(destination, maskApplyRect, maskNeedRect, maskPosition);
             }
             Q_ASSERT(applyRects.isEmpty());
         } else {
             /**
              * We can't eliminate additional copy-op
              * as filters' behaviour may be quite insane here,
              * so let them work on their own paintDevice =)
              */
 
             KisPaintDeviceSP tempDevice = new KisPaintDevice(colorSpace());
             tempDevice->prepareClone(source);
             copyOriginalToProjection(source, tempDevice, needRect);
 
             QRect maskApplyRect = applyRects.pop();
             QRect maskNeedRect = needRect;
 
             Q_FOREACH (const KisEffectMaskSP& mask, masks) {
                 PositionToFilthy maskPosition = calculatePositionToFilthy(mask, filthyNode, const_cast<KisLayer*>(this));
                 mask->apply(tempDevice, maskApplyRect, maskNeedRect, maskPosition);
 
                 if (!applyRects.isEmpty()) {
                     maskNeedRect = maskApplyRect;
                     maskApplyRect = applyRects.pop();
                 }
             }
             Q_ASSERT(applyRects.isEmpty());
 
             KisPainter::copyAreaOptimized(changeRect.topLeft(), tempDevice, destination, changeRect);
         }
     }
 
     return changeRect;
 }
 
 QRect KisLayer::updateProjection(const QRect& rect, KisNodeSP filthyNode)
 {
     QRect updatedRect = rect;
     KisPaintDeviceSP originalDevice = original();
     if (!rect.isValid() ||
             !visible() ||
             !originalDevice) return QRect();
 
     if (!needProjection() && !hasEffectMasks()) {
         m_d->safeProjection.freeDevice();
     } else {
 
         if (!updatedRect.isEmpty()) {
             KisPaintDeviceSP projection =
                 m_d->safeProjection.getDeviceLazy(originalDevice);
 
             updatedRect = applyMasks(originalDevice, projection,
                                      updatedRect, filthyNode, 0);
         }
     }
 
     return updatedRect;
 }
 
 QRect KisLayer::partialChangeRect(KisNodeSP lastNode, const QRect& rect)
 {
     bool changeRectVaries = false;
     QRect changeRect = outgoingChangeRect(rect);
     changeRect = masksChangeRect(effectMasks(lastNode), changeRect,
                                  changeRectVaries);
 
     return changeRect;
 }
 
 /**
  * \p rect is a dirty rect in layer's original() coordinates!
  */
 void KisLayer::buildProjectionUpToNode(KisPaintDeviceSP projection, KisNodeSP lastNode, const QRect& rect)
 {
     QRect changeRect = partialChangeRect(lastNode, rect);
 
     KisPaintDeviceSP originalDevice = original();
 
     KIS_ASSERT_RECOVER_RETURN(needProjection() || hasEffectMasks());
 
     if (!changeRect.isEmpty()) {
         applyMasks(originalDevice, projection,
                    changeRect, this, lastNode);
     }
 }
 
 bool KisLayer::needProjection() const
 {
     return false;
 }
 
 void KisLayer::copyOriginalToProjection(const KisPaintDeviceSP original,
                                         KisPaintDeviceSP projection,
                                         const QRect& rect) const
 {
     KisPainter::copyAreaOptimized(rect.topLeft(), original, projection, rect);
 }
 
 KisAbstractProjectionPlaneSP KisLayer::projectionPlane() const
 {
     return m_d->layerStyleProjectionPlane ?
         m_d->layerStyleProjectionPlane : m_d->projectionPlane;
 }
 
 KisAbstractProjectionPlaneSP KisLayer::internalProjectionPlane() const
 {
     return m_d->projectionPlane;
 }
 
 KisPaintDeviceSP KisLayer::projection() const
 {
     KisPaintDeviceSP originalDevice = original();
 
     return needProjection() || hasEffectMasks() ?
         m_d->safeProjection.getDeviceLazy(originalDevice) : originalDevice;
 }
 
 QRect KisLayer::changeRect(const QRect &rect, PositionToFilthy pos) const
 {
     QRect changeRect = rect;
     changeRect = incomingChangeRect(changeRect);
 
     if(pos == KisNode::N_FILTHY) {
         QRect projectionToBeUpdated = projection()->exactBoundsAmortized() & changeRect;
 
         bool changeRectVaries;
         changeRect = outgoingChangeRect(changeRect);
         changeRect = masksChangeRect(effectMasks(), changeRect, changeRectVaries);
 
         /**
          * If the projection contains some dirty areas we should also
          * add them to the change rect, because they might have
          * changed. E.g. when a visibility of the mask has chnaged
          * while the parent layer was invinisble.
          */
 
         if (!projectionToBeUpdated.isEmpty() &&
             !changeRect.contains(projectionToBeUpdated)) {
 
             changeRect |= projectionToBeUpdated;
         }
     }
 
     // TODO: string comparizon: optimize!
     if (pos != KisNode::N_FILTHY &&
         pos != KisNode::N_FILTHY_PROJECTION &&
         compositeOpId() != COMPOSITE_COPY) {
 
         changeRect |= rect;
     }
 
     return changeRect;
 }
 
 void KisLayer::childNodeChanged(KisNodeSP changedChildNode)
 {
     if (dynamic_cast<KisMask*>(changedChildNode.data())) {
         notifyChildMaskChanged(changedChildNode);
     }
 }
 
 QRect KisLayer::incomingChangeRect(const QRect &rect) const
 {
     return rect;
 }
 
 QRect KisLayer::outgoingChangeRect(const QRect &rect) const
 {
     return rect;
 }
 
 QImage KisLayer::createThumbnail(qint32 w, qint32 h)
 {
     if (w == 0 || h == 0) {
         return QImage();
     }
 
     KisPaintDeviceSP originalDevice = original();
 
     return originalDevice ?
            originalDevice->createThumbnail(w, h, 1,
                                            KoColorConversionTransformation::internalRenderingIntent(),
                                            KoColorConversionTransformation::internalConversionFlags()) : QImage();
 }
 
 QImage KisLayer::createThumbnailForFrame(qint32 w, qint32 h, int time)
 {
     if (w == 0 || h == 0) {
         return QImage();
     }
 
     KisPaintDeviceSP originalDevice = original();
     if (originalDevice) {
         KisRasterKeyframeChannel *channel = originalDevice->keyframeChannel();
 
         if (channel) {
             KisPaintDeviceSP targetDevice = new KisPaintDevice(colorSpace());
             KisKeyframeSP keyframe = channel->activeKeyframeAt(time);
             channel->fetchFrame(keyframe, targetDevice);
             return targetDevice->createThumbnail(w, h, 1,
                                                  KoColorConversionTransformation::internalRenderingIntent(),
                                                  KoColorConversionTransformation::internalConversionFlags());
         }
     }
 
     return createThumbnail(w, h);
 }
 
 qint32 KisLayer::x() const
 {
     KisPaintDeviceSP originalDevice = original();
     return originalDevice ? originalDevice->x() : 0;
 }
 qint32 KisLayer::y() const
 {
     KisPaintDeviceSP originalDevice = original();
     return originalDevice ? originalDevice->y() : 0;
 }
 void KisLayer::setX(qint32 x)
 {
     KisPaintDeviceSP originalDevice = original();
     if (originalDevice)
         originalDevice->setX(x);
 }
 void KisLayer::setY(qint32 y)
 {
     KisPaintDeviceSP originalDevice = original();
     if (originalDevice)
         originalDevice->setY(y);
 }
 
 QRect KisLayer::layerExtentImpl(bool needExactBounds) const
 {
     QRect additionalMaskExtent = QRect();
     QList<KisEffectMaskSP> effectMasks = this->effectMasks();
 
     Q_FOREACH(KisEffectMaskSP mask, effectMasks) {
         additionalMaskExtent |= mask->nonDependentExtent();
     }
 
     KisPaintDeviceSP originalDevice = original();
     QRect layerExtent;
 
     if (originalDevice) {
         layerExtent = needExactBounds ?
             originalDevice->exactBounds() :
             originalDevice->extent();
     }
 
     QRect additionalCompositeOpExtent;
     if (compositeOpId() == COMPOSITE_DESTINATION_IN ||
         compositeOpId() == COMPOSITE_DESTINATION_ATOP) {
 
         additionalCompositeOpExtent = originalDevice->defaultBounds()->bounds();
     }
 
     return layerExtent | additionalMaskExtent | additionalCompositeOpExtent;
 }
 
 QRect KisLayer::extent() const
 {
     return layerExtentImpl(false);
 }
 
 QRect KisLayer::exactBounds() const
 {
     return layerExtentImpl(true);
 }
 
 KisLayerSP KisLayer::parentLayer() const
 {
     return qobject_cast<KisLayer*>(parent().data());
 }
 
 KisMetaData::Store* KisLayer::metaData()
 {
     return m_d->metaDataStore;
 }
 
diff --git a/libs/image/layerstyles/kis_ls_bevel_emboss_filter.cpp b/libs/image/layerstyles/kis_ls_bevel_emboss_filter.cpp
index a04f8166b2..45d2c1bc49 100644
--- a/libs/image/layerstyles/kis_ls_bevel_emboss_filter.cpp
+++ b/libs/image/layerstyles/kis_ls_bevel_emboss_filter.cpp
@@ -1,492 +1,492 @@
 /*
  *  Copyright (c) 2014 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  See LayerFX plugin for Gimp as a reference implementation of this style:
  *  http://registry.gimp.org/node/186
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_ls_bevel_emboss_filter.h"
 
 #include <cstdlib>
 
 #include <QBitArray>
 
 #include <KoUpdater.h>
 #include <resources/KoPattern.h>
 
 #include <resources/KoAbstractGradient.h>
 
 #include "psd.h"
 
 #include "kis_convolution_kernel.h"
 #include "kis_convolution_painter.h"
 #include "kis_gaussian_kernel.h"
 
 #include "kis_pixel_selection.h"
 #include "kis_fill_painter.h"
 #include "kis_gradient_painter.h"
 #include "kis_iterator_ng.h"
 #include "kis_random_accessor_ng.h"
 
 #include "kis_psd_layer_style.h"
 #include "kis_layer_style_filter_environment.h"
 
 #include "kis_ls_utils.h"
 
 #include "gimp_bump_map.h"
 #include "kis_transaction.h"
 #include "kis_multiple_projection.h"
 
 
 KisLsBevelEmbossFilter::KisLsBevelEmbossFilter()
     : KisLayerStyleFilter(KoID("lsstroke", i18n("Stroke (style)")))
 {
 }
 
 void paintBevelSelection(KisPixelSelectionSP srcSelection,
                          KisPixelSelectionSP dstSelection,
                          const QRect &applyRect,
                          int size,
                          int initialSize,
                          bool invert)
 {
     KisSelectionSP tmpBaseSelection = new KisSelection(new KisSelectionEmptyBounds(0));
     KisPixelSelectionSP tmpSelection = tmpBaseSelection->pixelSelection();
 
     // NOTE: we are not using createCompositionSourceDevice() intentionally,
     //       because the source device doesn't have alpha channel
     KisPixelSelectionSP fillDevice = new KisPixelSelection();
 
     KisPainter gc(dstSelection);
     gc.setCompositeOp(COMPOSITE_COPY);
 
     for (int i = 0; i < size; i++) {
         const int growSize = initialSize - i - 1;
 
         quint8 selectedness = invert ?
             qRound(qreal(size - i - 1) / size * 255.0) :
             qRound(qreal(i + 1) / size * 255.0);
         fillDevice->setDefaultPixel(KoColor(&selectedness, fillDevice->colorSpace()));
 
         tmpSelection->makeCloneFromRough(srcSelection, srcSelection->selectedRect());
 
         QRect changeRect = KisLsUtils::growSelectionUniform(tmpSelection, growSize, applyRect);
 
         gc.setSelection(tmpBaseSelection);
         gc.bitBlt(changeRect.topLeft(), fillDevice, changeRect);
     }
 }
 
 struct ContrastOp {
     static const bool supportsCaching = false;
 
     ContrastOp(qreal contrast)
         : m_contrast(contrast)
     {
     }
 
     int operator() (int iValue) {
         qreal value = qreal(iValue - 127) / 127.0;
 
         qreal slant = std::tan ((m_contrast + 1) * M_PI_4);
         value = (value - 0.5) * slant + 0.5;
 
         return qRound(value * 255.0);
     }
 
 private:
     qreal m_contrast;
 };
 
 struct HighlightsFetchOp {
     static const bool supportsCaching = true;
 
     int operator() (int value) {
         return qRound(qMax(0, value - 127) * (255.0 / (255 - 127)));
     }
 };
 
 struct ShadowsFetchOp {
     static const bool supportsCaching = true;
 
     int operator() (int value) {
         return 255 - qRound(qMin(value, 127) * (255.0 / 127.0));
     }
 };
 
 template <class MapOp>
 void mapPixelValues(KisPixelSelectionSP srcSelection,
                     KisPixelSelectionSP dstSelection,
                     MapOp mapOp,
                     const QRect &applyRect)
 {
     static quint8 mapTable[256];
     static bool mapInitialized = false;
 
     if (!MapOp::supportsCaching || !mapInitialized) {
         mapInitialized = true;
 
         for (int i = 0; i < 256; i++) {
             mapTable[i] = mapOp(i);
         }
     }
 
     KisSequentialConstIterator srcIt(srcSelection, applyRect);
     KisSequentialIterator dstIt(dstSelection, applyRect);
 
     while (srcIt.nextPixel() && dstIt.nextPixel()) {
         const quint8 *srcPtr = srcIt.rawDataConst();
         quint8 *dstPtr = dstIt.rawData();
         *dstPtr = mapTable[*srcPtr];
     }
 }
 
 template <class MapOp>
 void mapPixelValues(KisPixelSelectionSP dstSelection,
                     MapOp mapOp,
                     const QRect &applyRect)
 {
     static quint8 mapTable[256];
     static bool mapInitialized = false;
 
     if (!MapOp::supportsCaching || !mapInitialized) {
         mapInitialized = true;
 
         for (int i = 0; i < 256; i++) {
             mapTable[i] = mapOp(i);
         }
     }
 
     KisSequentialIterator dstIt(dstSelection, applyRect);
 
     while (dstIt.nextPixel()) {
         quint8 *dstPtr = dstIt.rawData();
         *dstPtr = mapTable[*dstPtr];
     }
 }
 
 struct BevelEmbossRectCalculator
 {
     BevelEmbossRectCalculator(const QRect &applyRect,
                               const psd_layer_effects_bevel_emboss *config) {
 
         shadowHighlightsFinalRect = applyRect;
         applyGaussianRect = shadowHighlightsFinalRect;
         applyGlossContourRect = KisLsUtils::growRectFromRadius(applyGaussianRect, config->soften());
         applyBumpmapRect = applyGlossContourRect;
         applyContourRect = applyBumpmapRect;
         applyTextureRect = applyContourRect;
         applyBevelRect = calcBevelNeedRect(applyTextureRect, config);
         initialFetchRect = kisGrowRect(applyBevelRect, 1);
     }
 
     QRect totalChangeRect(const QRect &applyRect, const psd_layer_effects_bevel_emboss *config) {
         QRect changeRect = calcBevelChangeRect(applyRect, config);
         changeRect = kisGrowRect(changeRect, 1); // bumpmap method
         changeRect = KisLsUtils::growRectFromRadius(changeRect, config->soften());
         return changeRect;
     }
 
     QRect totalNeedRect(const QRect &applyRect, const psd_layer_effects_bevel_emboss *config) {
         QRect changeRect = applyRect;
         changeRect = KisLsUtils::growRectFromRadius(changeRect, config->soften());
         changeRect = kisGrowRect(changeRect, 1); // bumpmap method
         changeRect = calcBevelNeedRect(applyRect, config);
         return changeRect;
     }
 
     QRect initialFetchRect;
     QRect applyBevelRect;
     QRect applyTextureRect;
     QRect applyContourRect;
     QRect applyBumpmapRect;
     QRect applyGlossContourRect;
     QRect applyGaussianRect;
     QRect shadowHighlightsFinalRect;
 
 private:
     QRect calcBevelChangeRect(const QRect &applyRect, const psd_layer_effects_bevel_emboss *config) {
         const int size = config->size();
         int limitingGrowSize = 0;
 
         switch (config->style()) {
         case psd_bevel_outer_bevel:
             limitingGrowSize = size;
             break;
         case psd_bevel_inner_bevel:
             limitingGrowSize = 0;
             break;
         case psd_bevel_emboss: {
             const int initialSize = std::ceil(qreal(size) / 2.0);
             limitingGrowSize = initialSize;
             break;
         }
         case psd_bevel_pillow_emboss: {
             const int halfSizeC = std::ceil(qreal(size) / 2.0);
             limitingGrowSize = halfSizeC;
             break;
         }
         case psd_bevel_stroke_emboss:
             warnKrita << "WARNING: Stroke Emboss style is not implemented yet!";
             return applyRect;
         }
 
         return kisGrowRect(applyRect, limitingGrowSize);
     }
 
     QRect calcBevelNeedRect(const QRect &applyRect, const psd_layer_effects_bevel_emboss *config) {
         const int size = config->size();
         int limitingGrowSize = size;
 
         return kisGrowRect(applyRect, limitingGrowSize);
     }
 };
 
 void KisLsBevelEmbossFilter::applyBevelEmboss(KisPaintDeviceSP srcDevice,
                                               KisMultipleProjection *dst,
                                               const QRect &applyRect,
                                               const psd_layer_effects_bevel_emboss *config,
                                               KisLayerStyleFilterEnvironment *env) const
 {
     if (applyRect.isEmpty()) return;
 
     BevelEmbossRectCalculator d(applyRect, config);
 
     KisSelectionSP baseSelection = KisLsUtils::selectionFromAlphaChannel(srcDevice, d.initialFetchRect);
     KisPixelSelectionSP selection = baseSelection->pixelSelection();
 
     //selection->convertToQImage(0, QRect(0,0,300,300)).save("0_selection_initial.png");
 
     const int size = config->size();
 
     int limitingGrowSize = 0;
     KisPixelSelectionSP bumpmapSelection = new KisPixelSelection(new KisSelectionEmptyBounds(0));
 
     switch (config->style()) {
     case psd_bevel_outer_bevel:
         paintBevelSelection(selection, bumpmapSelection, d.applyBevelRect, size, size, false);
         limitingGrowSize = size;
         break;
     case psd_bevel_inner_bevel:
         paintBevelSelection(selection, bumpmapSelection, d.applyBevelRect, size, 0, false);
         limitingGrowSize = 0;
         break;
     case psd_bevel_emboss: {
         const int initialSize = std::ceil(qreal(size) / 2.0);
         paintBevelSelection(selection, bumpmapSelection, d.applyBevelRect, size, initialSize, false);
         limitingGrowSize = initialSize;
         break;
     }
     case psd_bevel_pillow_emboss: {
         const int halfSizeF = std::floor(qreal(size) / 2.0);
         const int halfSizeC = std::ceil(qreal(size) / 2.0);
         // TODO: probably not correct!
         paintBevelSelection(selection, bumpmapSelection, d.applyBevelRect, halfSizeC, halfSizeC, false);
         paintBevelSelection(selection, bumpmapSelection, d.applyBevelRect, halfSizeF, 0, true);
         limitingGrowSize = halfSizeC;
         break;
     }
     case psd_bevel_stroke_emboss:
         warnKrita << "WARNING: Stroke Emboss style is not implemented yet!";
         return;
     }
 
     KisPixelSelectionSP limitingSelection = new KisPixelSelection(*selection);
     {
         QRect changeRectUnused =
             KisLsUtils::growSelectionUniform(limitingSelection,
                                              limitingGrowSize,
                                              d.applyBevelRect);
         Q_UNUSED(changeRectUnused);
     }
 
     //bumpmapSelection->convertToQImage(0, QRect(0,0,300,300)).save("1_selection_xconv.png");
 
     if (config->textureEnabled()) {
         KisPixelSelectionSP textureSelection = new KisPixelSelection(new KisSelectionEmptyBounds(0));
 
         KisLsUtils::fillPattern(textureSelection, d.applyTextureRect, env,
                                 config->textureScale(),
                                 config->texturePattern(),
                                 config->textureHorizontalPhase(),
                                 config->textureVerticalPhase(),
                                 config->textureAlignWithLayer());
 
         int contrastadj = 0;
 
         {
             using namespace std;
 
             int tex_depth = config->textureDepth();
 
             if (tex_depth >= 0.0) {
                 if (tex_depth <= 100.0) {
                     contrastadj = int(qRound((1-(tex_depth/100.0)) * -127));
                 } else {
                     contrastadj = int(qRound(((tex_depth-100.0)/900.0) * 127));
                 }
             } else {
                 textureSelection->invert();
                 if (tex_depth >= -100.0) {
                     contrastadj = int(qRound((1-(abs(tex_depth)/100.0)) * -127));
                 } else {
                     contrastadj = int(qRound(((abs(tex_depth)-100.0)/900.0) * 127));
                 }
             }
         }
 
         qreal contrast = qBound(-1.0, qreal(contrastadj) / 127.0, 1.0);
         mapPixelValues(textureSelection, ContrastOp(contrast), d.applyTextureRect);
 
         {
             KisPainter gc(bumpmapSelection);
             gc.setCompositeOp(COMPOSITE_MULT);
             gc.bitBlt(d.applyTextureRect.topLeft(), textureSelection, d.applyTextureRect);
             gc.end();
         }
     }
 
     //bumpmapSelection->convertToQImage(0, QRect(0,0,300,300)).save("15_selection_texture.png");
 
     if (config->contourEnabled()) {
         if (config->range() != KisLsUtils::FULL_PERCENT_RANGE) {
             KisLsUtils::adjustRange(bumpmapSelection, d.applyContourRect, config->range());
         }
 
         KisLsUtils::applyContourCorrection(bumpmapSelection,
                                            d.applyContourRect,
                                            config->contourLookupTable(),
                                            config->antiAliased(),
                                            true);
     }
 
     bumpmap_vals_t bmvals;
 
     bmvals.azimuth = config->angle();
     bmvals.elevation = config->altitude();
     bmvals.depth = config->depth();
     bmvals.ambient = 0;
     bmvals.compensate = true;
     bmvals.invert = config->direction() == psd_direction_down;
     bmvals.type = LINEAR;
 
     bumpmap(bumpmapSelection, d.applyBumpmapRect, bmvals);
 
     //bumpmapSelection->convertToQImage(0, QRect(0,0,300,300)).save("3_selection_bumpmap.png");
 
     { // TODO: optimize!
 
         KisLsUtils::applyContourCorrection(bumpmapSelection,
                                            d.applyGlossContourRect,
                                            config->glossContourLookupTable(),
                                            config->glossAntiAliased(),
                                            true);
 
     }
 
     if (config->soften()) {
-        KisLsUtils::applyGaussian(bumpmapSelection, d.applyGaussianRect, config->soften());
+        KisLsUtils::applyGaussianWithTransaction(bumpmapSelection, d.applyGaussianRect, config->soften());
     }
 
 
     if (config->textureEnabled() && config->textureInvert()) {
         bumpmapSelection->invert();
     }
 
     selection->clear();
     mapPixelValues(bumpmapSelection, selection,
                    ShadowsFetchOp(), d.shadowHighlightsFinalRect);
     selection->applySelection(limitingSelection, SELECTION_INTERSECT);
 
     //dstDevice->convertToQImage(0, QRect(0,0,300,300)).save("4_dst_before_apply.png");
     //selection->convertToQImage(0, QRect(0,0,300,300)).save("4_shadows_sel.png");
 
     {
         KisPaintDeviceSP dstDevice = dst->getProjection("00_bevel_shadow",
                                                         config->shadowBlendMode(),
                                                         config->shadowOpacity(),
                                                         QBitArray(),
                                                         srcDevice);
 
         const KoColor fillColor(config->shadowColor(), dstDevice->colorSpace());
         const QRect &fillRect = d.shadowHighlightsFinalRect;
         KisPaintDeviceSP fillDevice = new KisPaintDevice(dstDevice->colorSpace());
         fillDevice->setDefaultPixel(fillColor);
 
         KisPainter::copyAreaOptimized(fillRect.topLeft(), fillDevice, dstDevice, fillRect, baseSelection);
     }
 
     selection->clear();
     mapPixelValues(bumpmapSelection, selection,
                    HighlightsFetchOp(), d.shadowHighlightsFinalRect);
     selection->applySelection(limitingSelection, SELECTION_INTERSECT);
 
     //selection->convertToQImage(0, QRect(0,0,300,300)).save("5_highlights_sel.png");
 
     {
         KisPaintDeviceSP dstDevice = dst->getProjection("01_bevel_highlight",
                                                         config->highlightBlendMode(),
                                                         config->highlightOpacity(),
                                                         QBitArray(),
                                                         srcDevice);
 
         const KoColor fillColor(config->highlightColor(), dstDevice->colorSpace());
         const QRect &fillRect = d.shadowHighlightsFinalRect;
         KisPaintDeviceSP fillDevice = new KisPaintDevice(dstDevice->colorSpace());
         fillDevice->setDefaultPixel(fillColor);
 
         KisPainter::copyAreaOptimized(fillRect.topLeft(), fillDevice, dstDevice, fillRect, baseSelection);
     }
 }
 
 void KisLsBevelEmbossFilter::processDirectly(KisPaintDeviceSP src,
                                              KisMultipleProjection *dst,
                                          const QRect &applyRect,
                                          KisPSDLayerStyleSP style,
                                          KisLayerStyleFilterEnvironment *env) const
 {
     Q_UNUSED(env);
     KIS_ASSERT_RECOVER_RETURN(style);
 
     const psd_layer_effects_bevel_emboss *config = style->bevelAndEmboss();
     if (!KisLsUtils::checkEffectEnabled(config, dst)) return;
 
     KisLsUtils::LodWrapper<psd_layer_effects_bevel_emboss> w(env->currentLevelOfDetail(), config);
     applyBevelEmboss(src, dst, applyRect, w.config, env);
 }
 
 QRect KisLsBevelEmbossFilter::neededRect(const QRect &rect, KisPSDLayerStyleSP style, KisLayerStyleFilterEnvironment *env) const
 {
     const psd_layer_effects_bevel_emboss *config = style->bevelAndEmboss();
     if (!config->effectEnabled()) return rect;
 
     KisLsUtils::LodWrapper<psd_layer_effects_bevel_emboss> w(env->currentLevelOfDetail(), config);
 
     BevelEmbossRectCalculator d(rect, w.config);
     return d.totalNeedRect(rect, w.config);
 }
 
 QRect KisLsBevelEmbossFilter::changedRect(const QRect &rect, KisPSDLayerStyleSP style, KisLayerStyleFilterEnvironment *env) const
 {
     const psd_layer_effects_bevel_emboss *config = style->bevelAndEmboss();
     if (!config->effectEnabled()) return rect;
 
     KisLsUtils::LodWrapper<psd_layer_effects_bevel_emboss> w(env->currentLevelOfDetail(), config);
 
     BevelEmbossRectCalculator d(rect, w.config);
     return d.totalChangeRect(rect, w.config);
 }
diff --git a/libs/image/layerstyles/kis_ls_drop_shadow_filter.cpp b/libs/image/layerstyles/kis_ls_drop_shadow_filter.cpp
index 376b983fc5..6acf58c143 100644
--- a/libs/image/layerstyles/kis_ls_drop_shadow_filter.cpp
+++ b/libs/image/layerstyles/kis_ls_drop_shadow_filter.cpp
@@ -1,284 +1,284 @@
 /*
  *  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_ls_drop_shadow_filter.h"
 
 #include <cstdlib>
 
 #include <QBitArray>
 
 #include <KoUpdater.h>
 #include <resources/KoAbstractGradient.h>
 
 #include "psd.h"
 
 #include "kis_convolution_kernel.h"
 #include "kis_convolution_painter.h"
 #include "kis_gaussian_kernel.h"
 
 #include "kis_pixel_selection.h"
 #include "kis_fill_painter.h"
 #include "kis_iterator_ng.h"
 #include "kis_random_accessor_ng.h"
 
 #include "kis_psd_layer_style.h"
 
 #include "kis_multiple_projection.h"
 #include "kis_ls_utils.h"
 #include "kis_layer_style_filter_environment.h"
 
 
 
 KisLsDropShadowFilter::KisLsDropShadowFilter(Mode mode)
     : KisLayerStyleFilter(KoID("lsdropshadow", i18n("Drop Shadow (style)")))
     , m_mode(mode)
 {
 }
 
 
 struct ShadowRectsData
 {
     enum Direction {
         NEED_RECT,
         CHANGE_RECT
     };
 
     ShadowRectsData(const QRect &applyRect,
                     const psd_layer_effects_context *context,
                     const psd_layer_effects_shadow_base *shadow,
                     Direction direction)
     {
         spread_size = (shadow->spread() * shadow->size() + 50) / 100;
         blur_size = shadow->size() - spread_size;
         offset = shadow->calculateOffset(context);
 
         // need rect calculation in reverse order
         dstRect = applyRect;
 
         const int directionCoeff = direction == NEED_RECT ? -1 : 1;
         srcRect = dstRect.translated(directionCoeff * offset);
 
         noiseNeedRect = shadow->noise() > 0 ?
             kisGrowRect(srcRect, KisLsUtils::noiseNeedBorder) : srcRect;
 
         blurNeedRect = blur_size ?
             KisLsUtils::growRectFromRadius(noiseNeedRect, blur_size) : noiseNeedRect;
 
         spreadNeedRect = spread_size ?
             KisLsUtils::growRectFromRadius(blurNeedRect, spread_size) : blurNeedRect;
 
         // dbgKrita << ppVar(dstRect);
         // dbgKrita << ppVar(srcRect);
         // dbgKrita << ppVar(noiseNeedRect);
         // dbgKrita << ppVar(blurNeedRect);
         // dbgKrita << ppVar(spreadNeedRect);
     }
 
     inline QRect finalNeedRect() const {
         return spreadNeedRect;
     }
 
     inline QRect finalChangeRect() const {
         // TODO: is it correct?
         return spreadNeedRect;
     }
 
     qint32 spread_size;
     qint32 blur_size;
     QPoint offset;
 
     QRect srcRect;
     QRect dstRect;
     QRect noiseNeedRect;
     QRect blurNeedRect;
     QRect spreadNeedRect;
 };
 
 void applyDropShadow(KisPaintDeviceSP srcDevice,
                      KisMultipleProjection *dst,
                      const QRect &applyRect,
                      const psd_layer_effects_context *context,
                      const psd_layer_effects_shadow_base *shadow,
                      const KisLayerStyleFilterEnvironment *env)
 {
     if (applyRect.isEmpty()) return;
 
     ShadowRectsData d(applyRect, context, shadow, ShadowRectsData::NEED_RECT);
 
     KisSelectionSP baseSelection =
         KisLsUtils::selectionFromAlphaChannel(srcDevice, d.spreadNeedRect);
 
     KisPixelSelectionSP selection = baseSelection->pixelSelection();
 
     //selection->convertToQImage(0, QRect(0,0,300,300)).save("0_selection_initial.png");
 
     if (shadow->invertsSelection()) {
         selection->invert();
     }
 
     /**
      * Copy selection which will be erased from the original later
      */
     KisPixelSelectionSP knockOutSelection;
     if (shadow->knocksOut()) {
         knockOutSelection = new KisPixelSelection(*selection);
     }
 
     if (shadow->technique() == psd_technique_precise) {
         KisLsUtils::findEdge(selection, d.blurNeedRect, true);
     }
 
     /**
      * Spread and blur the selection
      */
     if (d.spread_size) {
-        KisLsUtils::applyGaussian(selection, d.blurNeedRect, d.spread_size);
+        KisLsUtils::applyGaussianWithTransaction(selection, d.blurNeedRect, d.spread_size);
 
         // TODO: find out why in libpsd we pass false here. If we do so,
         //       the result is fully black, which is not expected
         KisLsUtils::findEdge(selection, d.blurNeedRect, true /*shadow->edgeHidden()*/);
     }
 
     //selection->convertToQImage(0, QRect(0,0,300,300)).save("1_selection_spread.png");
 
     if (d.blur_size) {
-        KisLsUtils::applyGaussian(selection, d.noiseNeedRect, d.blur_size);
+        KisLsUtils::applyGaussianWithTransaction(selection, d.noiseNeedRect, d.blur_size);
     }
     //selection->convertToQImage(0, QRect(0,0,300,300)).save("2_selection_blur.png");
 
     if (shadow->range() != KisLsUtils::FULL_PERCENT_RANGE) {
         KisLsUtils::adjustRange(selection, d.noiseNeedRect, shadow->range());
     }
 
     const psd_layer_effects_inner_glow *iglow = 0;
     if ((iglow =
          dynamic_cast<const psd_layer_effects_inner_glow *>(shadow)) &&
         iglow->source() == psd_glow_center) {
 
         selection->invert();
     }
 
     /**
      * Contour correction
      */
     KisLsUtils::applyContourCorrection(selection,
                                        d.noiseNeedRect,
                                        shadow->contourLookupTable(),
                                        shadow->antiAliased(),
                                        shadow->edgeHidden());
 
     //selection->convertToQImage(0, QRect(0,0,300,300)).save("3_selection_contour.png");
 
     /**
      * Noise
      */
     if (shadow->noise() > 0) {
         KisLsUtils::applyNoise(selection,
                                d.srcRect,
                                shadow->noise(),
                                context,
                                env);
     }
     //selection->convertToQImage(0, QRect(0,0,300,300)).save("4_selection_noise.png");
 
     if (!d.offset.isNull()) {
         selection->setX(d.offset.x());
         selection->setY(d.offset.y());
     }
 
     /**
      * Knock-out original outline of the device from the resulting shade
      */
     if (shadow->knocksOut()) {
         KIS_ASSERT_RECOVER_RETURN(knockOutSelection);
 
         QRect knockOutRect = !shadow->invertsSelection() ?
             d.srcRect : d.spreadNeedRect;
 
         knockOutRect &= d.dstRect;
 
         KisPainter gc(selection);
         gc.setCompositeOp(COMPOSITE_ERASE);
         gc.bitBlt(knockOutRect.topLeft(), knockOutSelection, knockOutRect);
     }
     //selection->convertToQImage(0, QRect(0,0,300,300)).save("5_selection_knockout.png");
 
     KisLsUtils::applyFinalSelection(KisMultipleProjection::defaultProjectionId(),
                                     baseSelection,
                                     srcDevice,
                                     dst,
                                     d.srcRect,
                                     d.dstRect,
                                     context,
                                     shadow,
                                     env);
 }
 
 const psd_layer_effects_shadow_base*
 KisLsDropShadowFilter::getShadowStruct(KisPSDLayerStyleSP style) const
 {
     const psd_layer_effects_shadow_base *config = 0;
 
     if (m_mode == DropShadow) {
         config = style->dropShadow();
     } else if (m_mode == InnerShadow) {
         config = style->innerShadow();
     } else if (m_mode == OuterGlow) {
         config = style->outerGlow();
     } else if (m_mode == InnerGlow) {
         config = style->innerGlow();
     }
 
     return config;
 }
 
 void KisLsDropShadowFilter::processDirectly(KisPaintDeviceSP src,
                                             KisMultipleProjection *dst,
                                             const QRect &applyRect,
                                             KisPSDLayerStyleSP style,
                                             KisLayerStyleFilterEnvironment *env) const
 {
     KIS_ASSERT_RECOVER_RETURN(style);
 
     const psd_layer_effects_shadow_base *config = getShadowStruct(style);
     if (!KisLsUtils::checkEffectEnabled(config, dst)) return;
 
     KisLsUtils::LodWrapper<psd_layer_effects_shadow_base> w(env->currentLevelOfDetail(), config);
     applyDropShadow(src, dst, applyRect, style->context(), w.config, env);
 }
 
 QRect KisLsDropShadowFilter::neededRect(const QRect &rect, KisPSDLayerStyleSP style, KisLayerStyleFilterEnvironment *env) const
 {
     const psd_layer_effects_shadow_base *shadowStruct = getShadowStruct(style);
     if (!shadowStruct->effectEnabled()) return rect;
 
     KisLsUtils::LodWrapper<psd_layer_effects_shadow_base> w(env->currentLevelOfDetail(), shadowStruct);
     ShadowRectsData d(rect, style->context(), w.config, ShadowRectsData::NEED_RECT);
     return rect | d.finalNeedRect();
 }
 
 QRect KisLsDropShadowFilter::changedRect(const QRect &rect, KisPSDLayerStyleSP style, KisLayerStyleFilterEnvironment *env) const
 {
     const psd_layer_effects_shadow_base *shadowStruct = getShadowStruct(style);
     if (!shadowStruct->effectEnabled()) return rect;
 
     KisLsUtils::LodWrapper<psd_layer_effects_shadow_base> w(env->currentLevelOfDetail(), shadowStruct);
     ShadowRectsData d(rect, style->context(), w.config, ShadowRectsData::CHANGE_RECT);
     return style->context()->keep_original ?
         d.finalChangeRect() : rect | d.finalChangeRect();
 }
diff --git a/libs/image/layerstyles/kis_ls_satin_filter.cpp b/libs/image/layerstyles/kis_ls_satin_filter.cpp
index 5a5603f2e9..2e38d9e1ca 100644
--- a/libs/image/layerstyles/kis_ls_satin_filter.cpp
+++ b/libs/image/layerstyles/kis_ls_satin_filter.cpp
@@ -1,230 +1,230 @@
 /*
  *  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_ls_satin_filter.h"
 
 #include <cstdlib>
 
 #include <QBitArray>
 
 #include <resources/KoAbstractGradient.h>
 
 #include "psd.h"
 
 #include "kis_convolution_kernel.h"
 #include "kis_convolution_painter.h"
 #include "kis_gaussian_kernel.h"
 
 #include "kis_pixel_selection.h"
 #include "kis_fill_painter.h"
 #include "kis_iterator_ng.h"
 #include "kis_random_accessor_ng.h"
 
 #include "kis_psd_layer_style.h"
 
 #include "kis_multiple_projection.h"
 #include "kis_ls_utils.h"
 #include "kis_layer_style_filter_environment.h"
 
 
 KisLsSatinFilter::KisLsSatinFilter()
     : KisLayerStyleFilter(KoID("lssatin", i18n("Satin (style)")))
 {
 }
 
 struct SatinRectsData
 {
     enum Direction {
         NEED_RECT,
         CHANGE_RECT
     };
 
     SatinRectsData(const QRect &applyRect,
                     const psd_layer_effects_context *context,
                     const psd_layer_effects_satin *shadow,
                     Direction direction)
     {
         Q_UNUSED(direction);
 
         blur_size = shadow->size();
         offset = shadow->calculateOffset(context);
 
         // need rect calculation in reverse order
         dstRect = applyRect;
 
         srcRect = dstRect;
 
         int xGrow = qAbs(offset.x());
         int yGrow = qAbs(offset.y());
         satinNeedRect = srcRect.adjusted(-xGrow, -yGrow, xGrow, yGrow);
 
         blurNeedRect = blur_size ?
             KisLsUtils::growRectFromRadius(satinNeedRect, blur_size) : satinNeedRect;
     }
 
     inline QRect finalNeedRect() const {
         return blurNeedRect;
     }
 
     inline QRect finalChangeRect() const {
         // TODO: is it correct?
         return blurNeedRect;
     }
 
     qint32 blur_size;
     QPoint offset;
 
     QRect srcRect;
     QRect dstRect;
     QRect satinNeedRect;
     QRect blurNeedRect;
 };
 
 void blendAndOffsetSatinSelection(KisPixelSelectionSP dstSelection,
                                   KisPixelSelectionSP srcSelection,
                                   const bool invert,
                                   const QPoint &offset,
                                   const QRect &applyRect)
 {
     KisSequentialIterator srcIt1(srcSelection, applyRect.translated(offset));
     KisSequentialIterator srcIt2(srcSelection, applyRect.translated(-offset));
     KisSequentialIterator dstIt(dstSelection, applyRect);
 
     while(dstIt.nextPixel() && srcIt1.nextPixel() && srcIt2.nextPixel()) {
 
         quint8 *dstPixelPtr = dstIt.rawData();
         quint8 *src1PixelPtr = srcIt1.rawData();
         quint8 *src2PixelPtr = srcIt2.rawData();
 
         if (!invert) {
             *dstPixelPtr = *dstPixelPtr * qAbs(*src1PixelPtr - *src2PixelPtr) >> 8;
         } else {
             *dstPixelPtr = *dstPixelPtr * (255 - qAbs(*src1PixelPtr - *src2PixelPtr)) >> 8;
         }
     }
 }
 
 void applySatin(KisPaintDeviceSP srcDevice,
                 KisMultipleProjection *dst,
                 const QRect &applyRect,
                 const psd_layer_effects_context *context,
                 const psd_layer_effects_satin *config,
                 const KisLayerStyleFilterEnvironment *env)
 {
     if (applyRect.isEmpty()) return;
 
     SatinRectsData d(applyRect, context, config, SatinRectsData::NEED_RECT);
 
     KisSelectionSP baseSelection =
         KisLsUtils::selectionFromAlphaChannel(srcDevice, d.blurNeedRect);
 
     KisPixelSelectionSP selection = baseSelection->pixelSelection();
 
     //selection->convertToQImage(0, QRect(0,0,300,300)).save("0_selection_initial.png");
 
     KisPixelSelectionSP knockOutSelection = new KisPixelSelection(*selection);
     knockOutSelection->invert();
 
     //knockOutSelection->convertToQImage(0, QRect(0,0,300,300)).save("1_saved_knockout_selection.png");
 
     KisPixelSelectionSP tempSelection = new KisPixelSelection(*selection);
 
-    KisLsUtils::applyGaussian(tempSelection, d.satinNeedRect, d.blur_size);
+    KisLsUtils::applyGaussianWithTransaction(tempSelection, d.satinNeedRect, d.blur_size);
 
     //tempSelection->convertToQImage(0, QRect(0,0,300,300)).save("2_selection_blurred.png");
 
     /**
      * Contour correction
      */
     KisLsUtils::applyContourCorrection(tempSelection,
                                        d.satinNeedRect,
                                        config->contourLookupTable(),
                                        config->antiAliased(),
                                        config->edgeHidden());
 
     //tempSelection->convertToQImage(0, QRect(0,0,300,300)).save("3_selection_contour.png");
 
     blendAndOffsetSatinSelection(selection,
                                  tempSelection,
                                  config->invert(),
                                  d.offset,
                                  d.dstRect);
 
     //selection->convertToQImage(0, QRect(0,0,300,300)).save("3_selection_satin_applied.png");
 
     /**
      * Knock-out original outline of the device from the resulting shade
      */
     if (config->knocksOut()) {
         KisLsUtils::knockOutSelection(selection,
                                       knockOutSelection,
                                       d.srcRect,
                                       d.dstRect,
                                       d.finalNeedRect(),
                                       config->invertsSelection());
     }
     //selection->convertToQImage(0, QRect(0,0,300,300)).save("5_selection_knocked_out.png");
 
     KisLsUtils::applyFinalSelection(KisMultipleProjection::defaultProjectionId(),
                                     baseSelection,
                                     srcDevice,
                                     dst,
                                     d.srcRect,
                                     d.dstRect,
                                     context,
                                     config,
                                     env);
 
     //dstDevice->convertToQImage(0, QRect(0,0,300,300)).save("6_dst_final.png");
 }
 
 void KisLsSatinFilter::processDirectly(KisPaintDeviceSP src,
                                        KisMultipleProjection *dst,
                                        const QRect &applyRect,
                                        KisPSDLayerStyleSP style,
                                        KisLayerStyleFilterEnvironment *env) const
 {
     KIS_ASSERT_RECOVER_RETURN(style);
 
     const psd_layer_effects_satin *config = style->satin();
     if (!KisLsUtils::checkEffectEnabled(config, dst)) return;
 
     KisLsUtils::LodWrapper<psd_layer_effects_satin> w(env->currentLevelOfDetail(), config);
     applySatin(src, dst, applyRect, style->context(), w.config, env);
 }
 
 QRect KisLsSatinFilter::neededRect(const QRect &rect, KisPSDLayerStyleSP style, KisLayerStyleFilterEnvironment *env) const
 {
     const psd_layer_effects_satin *config = style->satin();
     if (!config->effectEnabled()) return rect;
 
     KisLsUtils::LodWrapper<psd_layer_effects_satin> w(env->currentLevelOfDetail(), config);
     SatinRectsData d(rect, style->context(), w.config, SatinRectsData::NEED_RECT);
     return rect | d.finalNeedRect();
 }
 
 QRect KisLsSatinFilter::changedRect(const QRect &rect, KisPSDLayerStyleSP style, KisLayerStyleFilterEnvironment *env) const
 {
     const psd_layer_effects_satin *config = style->satin();
     if (!config->effectEnabled()) return rect;
 
     KisLsUtils::LodWrapper<psd_layer_effects_satin> w(env->currentLevelOfDetail(), config);
     SatinRectsData d(rect, style->context(), w.config, SatinRectsData::CHANGE_RECT);
     return style->context()->keep_original ?
         d.finalChangeRect() : rect | d.finalChangeRect();
 }
diff --git a/libs/image/layerstyles/kis_ls_stroke_filter.cpp b/libs/image/layerstyles/kis_ls_stroke_filter.cpp
index e6236c5a62..12a0366355 100644
--- a/libs/image/layerstyles/kis_ls_stroke_filter.cpp
+++ b/libs/image/layerstyles/kis_ls_stroke_filter.cpp
@@ -1,151 +1,151 @@
 /*
  *  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_ls_stroke_filter.h"
 
 #include <cstdlib>
 
 #include <QBitArray>
 
 #include <resources/KoPattern.h>
 
 #include <resources/KoAbstractGradient.h>
 
 #include "psd.h"
 
 #include "kis_convolution_kernel.h"
 #include "kis_convolution_painter.h"
 #include "kis_gaussian_kernel.h"
 
 #include "kis_pixel_selection.h"
 #include "kis_fill_painter.h"
 #include "kis_gradient_painter.h"
 #include "kis_iterator_ng.h"
 #include "kis_random_accessor_ng.h"
 
 #include "kis_psd_layer_style.h"
 #include "kis_layer_style_filter_environment.h"
 
 #include "kis_ls_utils.h"
 #include "kis_multiple_projection.h"
 
 namespace {
 
 int borderSize(psd_stroke_position position, int size)
 {
     int border = 0;
 
     switch (position) {
     case psd_stroke_outside:
         border = 2 * size + 1;
         break;
     case psd_stroke_center:
         border = size + 1;
         break;
     case psd_stroke_inside:
         border = 1;
         break;
     }
 
     return border;
 }
 
 }
 
 
 KisLsStrokeFilter::KisLsStrokeFilter()
     : KisLayerStyleFilter(KoID("lsstroke", i18n("Stroke (style)")))
 {
 }
 
 void KisLsStrokeFilter::applyStroke(KisPaintDeviceSP srcDevice,
                                     KisMultipleProjection *dst,
                                     const QRect &applyRect,
                                     const psd_layer_effects_stroke *config,
                                     KisLayerStyleFilterEnvironment *env) const
 {
     if (applyRect.isEmpty()) return;
 
     const QRect needRect = kisGrowRect(applyRect, borderSize(config->position(), config->size()));
 
     KisSelectionSP baseSelection = KisLsUtils::selectionFromAlphaChannel(srcDevice, needRect);
     KisPixelSelectionSP selection = baseSelection->pixelSelection();
 
     {
         KisPixelSelectionSP knockOutSelection = new KisPixelSelection(new KisSelectionEmptyBounds(0));
         knockOutSelection->makeCloneFromRough(selection, needRect);
 
         if (config->position() == psd_stroke_outside) {
-            KisGaussianKernel::applyDilate(selection, needRect, 2 * config->size(), QBitArray(), 0);
+            KisGaussianKernel::applyDilate(selection, needRect, 2 * config->size(), QBitArray(), 0, true);
         } else if (config->position() == psd_stroke_inside) {
-            KisGaussianKernel::applyErodeU8(knockOutSelection, needRect, 2 * config->size(), QBitArray(), 0);
+            KisGaussianKernel::applyErodeU8(knockOutSelection, needRect, 2 * config->size(), QBitArray(), 0, true);
         } else if (config->position() == psd_stroke_center) {
-            KisGaussianKernel::applyDilate(selection, needRect, config->size(), QBitArray(), 0);
-            KisGaussianKernel::applyErodeU8(knockOutSelection, needRect, config->size(), QBitArray(), 0);
+            KisGaussianKernel::applyDilate(selection, needRect, config->size(), QBitArray(), 0, true);
+            KisGaussianKernel::applyErodeU8(knockOutSelection, needRect, config->size(), QBitArray(), 0, true);
         }
 
         KisPainter gc(selection);
         gc.setCompositeOp(COMPOSITE_ERASE);
         gc.bitBlt(needRect.topLeft(), knockOutSelection, needRect);
         gc.end();
     }
 
     KisPaintDeviceSP fillDevice = new KisPaintDevice(srcDevice->colorSpace());
     KisLsUtils::fillOverlayDevice(fillDevice, applyRect, config, env);
 
 
     const QString compositeOp = config->blendMode();
     const quint8 opacityU8 = 255.0 / 100.0 * config->opacity();
     KisPaintDeviceSP dstDevice = dst->getProjection(KisMultipleProjection::defaultProjectionId(),
                                                     compositeOp,
                                                     opacityU8,
                                                     QBitArray(),
                                                     srcDevice);
 
     KisPainter::copyAreaOptimized(applyRect.topLeft(), fillDevice, dstDevice, applyRect, baseSelection);
 }
 
 void KisLsStrokeFilter::processDirectly(KisPaintDeviceSP src,
                                         KisMultipleProjection *dst,
                                          const QRect &applyRect,
                                          KisPSDLayerStyleSP style,
                                          KisLayerStyleFilterEnvironment *env) const
 {
     Q_UNUSED(env);
     KIS_ASSERT_RECOVER_RETURN(style);
 
     const psd_layer_effects_stroke *config = style->stroke();
     if (!KisLsUtils::checkEffectEnabled(config, dst)) return;
 
     KisLsUtils::LodWrapper<psd_layer_effects_stroke> w(env->currentLevelOfDetail(), config);
     applyStroke(src, dst, applyRect, w.config, env);
 }
 
 QRect KisLsStrokeFilter::neededRect(const QRect &rect, KisPSDLayerStyleSP style, KisLayerStyleFilterEnvironment *env) const
 {
     const psd_layer_effects_stroke *config = style->stroke();
     if (!config->effectEnabled()) return rect;
 
     KisLsUtils::LodWrapper<psd_layer_effects_stroke> w(env->currentLevelOfDetail(), config);
     return kisGrowRect(rect, borderSize(w.config->position(), w.config->size()));
 }
 
 QRect KisLsStrokeFilter::changedRect(const QRect &rect, KisPSDLayerStyleSP style, KisLayerStyleFilterEnvironment *env) const
 {
     return neededRect(rect, style, env);
 }
diff --git a/libs/image/layerstyles/kis_ls_utils.cpp b/libs/image/layerstyles/kis_ls_utils.cpp
index e5583ba0be..b60a462d62 100644
--- a/libs/image/layerstyles/kis_ls_utils.cpp
+++ b/libs/image/layerstyles/kis_ls_utils.cpp
@@ -1,586 +1,586 @@
 /*
  *  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_ls_utils.h"
 
 #include <resources/KoAbstractGradient.h>
 #include <KoColorSpace.h>
 #include <resources/KoPattern.h>
 
 
 #include "psd.h"
 
 #include "kis_default_bounds.h"
 #include "kis_pixel_selection.h"
 #include "kis_random_accessor_ng.h"
 #include "kis_iterator_ng.h"
 
 #include "kis_convolution_kernel.h"
 #include "kis_convolution_painter.h"
 #include "kis_gaussian_kernel.h"
 
 #include "kis_fill_painter.h"
 #include "kis_gradient_painter.h"
 #include "kis_layer_style_filter_environment.h"
 #include "kis_selection_filters.h"
 #include "kis_multiple_projection.h"
 
 
 namespace KisLsUtils
 {
 
     QRect growSelectionUniform(KisPixelSelectionSP selection, int growSize, const QRect &applyRect)
     {
         QRect changeRect = applyRect;
 
         if (growSize > 0) {
             KisGrowSelectionFilter filter(growSize, growSize);
             changeRect = filter.changeRect(applyRect);
             filter.process(selection, applyRect);
         } else if (growSize < 0) {
             KisShrinkSelectionFilter filter(qAbs(growSize), qAbs(growSize), false);
             changeRect = filter.changeRect(applyRect);
             filter.process(selection, applyRect);
         }
 
         return changeRect;
     }
 
     KisSelectionSP selectionFromAlphaChannel(KisPaintDeviceSP device,
                                              const QRect &srcRect)
     {
         const KoColorSpace *cs = device->colorSpace();
 
         KisSelectionSP baseSelection = new KisSelection(new KisSelectionEmptyBounds(0));
         KisPixelSelectionSP selection = baseSelection->pixelSelection();
 
         KisSequentialConstIterator srcIt(device, srcRect);
         KisSequentialIterator dstIt(selection, srcRect);
 
         while (srcIt.nextPixel() && dstIt.nextPixel()) {
             quint8 *dstPtr = dstIt.rawData();
             const quint8* srcPtr = srcIt.rawDataConst();
             *dstPtr = cs->opacityU8(srcPtr);
         }
 
         return baseSelection;
     }
 
     void findEdge(KisPixelSelectionSP selection, const QRect &applyRect, const bool edgeHidden)
     {
         KisSequentialIterator dstIt(selection, applyRect);
 
         if (edgeHidden) {
             while(dstIt.nextPixel()) {
                 quint8 *pixelPtr = dstIt.rawData();
 
                 *pixelPtr =
                     (*pixelPtr < 24) ?
                     *pixelPtr * 10 : 0xFF;
 
             }
         } else {
             while(dstIt.nextPixel()) {
                 quint8 *pixelPtr = dstIt.rawData();
                 *pixelPtr = 0xFF;
 
             }
         }
     }
 
     QRect growRectFromRadius(const QRect &rc, int radius)
     {
         int halfSize = KisGaussianKernel::kernelSizeFromRadius(radius) / 2;
         return rc.adjusted(-halfSize, -halfSize, halfSize, halfSize);
     }
 
-    void applyGaussian(KisPixelSelectionSP selection,
-                       const QRect &applyRect,
-                       qreal radius)
+    void applyGaussianWithTransaction(KisPixelSelectionSP selection,
+                                      const QRect &applyRect,
+                                      qreal radius)
     {
         KisGaussianKernel::applyGaussian(selection, applyRect,
                                          radius, radius,
-                                         QBitArray(), 0);
+                                         QBitArray(), 0, true);
     }
 
     namespace Private {
         void getGradientTable(const KoAbstractGradient *gradient,
                               QVector<KoColor> *table,
                               const KoColorSpace *colorSpace)
         {
             KIS_ASSERT_RECOVER_RETURN(table->size() == 256);
 
             for (int i = 0; i < 256; i++) {
                 gradient->colorAt(((*table)[i]), qreal(i) / 255.0);
                 (*table)[i].convertTo(colorSpace);
             }
         }
 
         struct LinearGradientIndex
         {
             int popOneIndex(int selectionAlpha) {
                 return 255 - selectionAlpha;
             }
 
             bool nextPixel() {
                 return true;
             }
         };
 
         struct JitterGradientIndex
         {
             JitterGradientIndex(const QRect &applyRect,
                                 int jitter,
                                 const KisLayerStyleFilterEnvironment *env)
                 : randomSelection(env->cachedRandomSelection(applyRect)),
                   noiseIt(randomSelection, applyRect),
                   m_jitterCoeff(jitter * 255 / 100)
                 {
                 }
 
             int popOneIndex(int selectionAlpha) {
                 int gradientIndex = 255 - selectionAlpha;
                 gradientIndex += m_jitterCoeff * *noiseIt.rawDataConst() >> 8;
                 gradientIndex &= 0xFF;
 
                 return gradientIndex;
             }
 
             bool nextPixel() {
                 return noiseIt.nextPixel();
             }
 
         private:
             KisPixelSelectionSP randomSelection;
             KisSequentialConstIterator noiseIt;
             int m_jitterCoeff;
         };
 
         template <class IndexFetcher>
         void applyGradientImpl(KisPaintDeviceSP device,
                                KisPixelSelectionSP selection,
                                const QRect &applyRect,
                                const QVector<KoColor> &table,
                                bool edgeHidden,
                                IndexFetcher &indexFetcher)
         {
             KIS_ASSERT_RECOVER_RETURN(
                 *table.first().colorSpace() == *device->colorSpace());
 
             const KoColorSpace *cs = device->colorSpace();
             const int pixelSize = cs->pixelSize();
 
             KisSequentialConstIterator selIt(selection, applyRect);
             KisSequentialIterator dstIt(device, applyRect);
 
             if (edgeHidden) {
 
                 while (selIt.nextPixel() &&
                        dstIt.nextPixel() &&
                        indexFetcher.nextPixel()) {
 
                     quint8 selAlpha = *selIt.rawDataConst();
                     int gradientIndex = indexFetcher.popOneIndex(selAlpha);
                     const KoColor &color = table[gradientIndex];
                     quint8 tableAlpha = color.opacityU8();
 
                     memcpy(dstIt.rawData(), color.data(), pixelSize);
 
                     if (selAlpha < 24 && tableAlpha == 255) {
                         tableAlpha = int(selAlpha) * 10 * tableAlpha >> 8;
                         cs->setOpacity(dstIt.rawData(), tableAlpha, 1);
                     }
 
                 }
 
             } else {
 
                 while (selIt.nextPixel() &&
                        dstIt.nextPixel() &&
                        indexFetcher.nextPixel()) {
 
                     int gradientIndex = indexFetcher.popOneIndex(*selIt.rawDataConst());
                     const KoColor &color = table[gradientIndex];
                     memcpy(dstIt.rawData(), color.data(), pixelSize);
                 }
             }
         }
 
         void applyGradient(KisPaintDeviceSP device,
                            KisPixelSelectionSP selection,
                            const QRect &applyRect,
                            const QVector<KoColor> &table,
                            bool edgeHidden,
                            int jitter,
                            const KisLayerStyleFilterEnvironment *env)
         {
             if (!jitter) {
                 LinearGradientIndex fetcher;
                 applyGradientImpl(device, selection, applyRect, table, edgeHidden, fetcher);
             } else {
                 JitterGradientIndex fetcher(applyRect, jitter, env);
                 applyGradientImpl(device, selection, applyRect, table, edgeHidden, fetcher);
             }
         }
     }
 
     const int noiseNeedBorder = 8;
 
     void applyNoise(KisPixelSelectionSP selection,
                     const QRect &applyRect,
                     int noise,
                     const psd_layer_effects_context *context,
                     const KisLayerStyleFilterEnvironment *env)
     {
         Q_UNUSED(context);
 
         const QRect overlayRect = kisGrowRect(applyRect, noiseNeedBorder);
 
         KisPixelSelectionSP randomSelection = env->cachedRandomSelection(overlayRect);
         KisPixelSelectionSP randomOverlay = new KisPixelSelection();
 
         KisSequentialConstIterator noiseIt(randomSelection, overlayRect);
         KisSequentialConstIterator srcIt(selection, overlayRect);
         KisRandomAccessorSP dstIt = randomOverlay->createRandomAccessorNG(overlayRect.x(), overlayRect.y());
 
         while (noiseIt.nextPixel() && srcIt.nextPixel()) {
             int itX = noiseIt.x();
             int itY = noiseIt.y();
 
             int x = itX + (*noiseIt.rawDataConst() >> 4) - 8;
             int y = itY + (*noiseIt.rawDataConst() & 0x0F) - 8;
             x = (x + itX) >> 1;
             y = (y + itY) >> 1;
 
             dstIt->moveTo(x, y);
 
             quint8 dstAlpha = *dstIt->rawData();
             quint8 srcAlpha = *srcIt.rawDataConst();
 
             int value = qMin(255, dstAlpha + srcAlpha);
 
             *dstIt->rawData() = value;
         }
 
         noise = noise * 255 / 100;
 
         KisPainter gc(selection);
         gc.setOpacity(noise);
         gc.setCompositeOp(COMPOSITE_COPY);
         gc.bitBlt(applyRect.topLeft(), randomOverlay, applyRect);
     }
 
     //const int FULL_PERCENT_RANGE = 100;
 
     void adjustRange(KisPixelSelectionSP selection, const QRect &applyRect, const int range)
     {
         KIS_ASSERT_RECOVER_RETURN(range >= 1 && range <= 100);
 
         quint8 rangeTable[256];
         for(int i = 0; i < 256; i ++) {
             quint8 value = i * 100 / range;
             rangeTable[i] = qMin(value, quint8(255));
         }
 
         KisSequentialIterator dstIt(selection, applyRect);
 
         while (dstIt.nextPixel()) {
             quint8 *pixelPtr = dstIt.rawData();
             *pixelPtr = rangeTable[*pixelPtr];
         }
     }
 
     void applyContourCorrection(KisPixelSelectionSP selection,
                                 const QRect &applyRect,
                                 const quint8 *lookup_table,
                                 bool antiAliased,
                                 bool edgeHidden)
     {
         quint8 contour[PSD_LOOKUP_TABLE_SIZE] = {
             0x00, 0x0b, 0x16, 0x21, 0x2c, 0x37, 0x42, 0x4d, 0x58, 0x63, 0x6e, 0x79, 0x84, 0x8f, 0x9a, 0xa5,
             0xb0, 0xbb, 0xc6, 0xd1, 0xdc, 0xf2, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
             0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
             0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
             0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
             0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
             0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
             0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
             0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
             0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
             0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
             0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
             0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
             0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
             0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
             0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 
         if (edgeHidden) {
             if (antiAliased) {
                 for (int i = 0; i < PSD_LOOKUP_TABLE_SIZE; i++) {
                     contour[i] = contour[i] * lookup_table[i] >> 8;
                 }
             } else {
                 for (int i = 0; i < PSD_LOOKUP_TABLE_SIZE; i++) {
                     contour[i] = contour[i] * lookup_table[(int)((int)(i / 2.55) * 2.55 + 0.5)] >> 8;
                 }
             }
         } else {
             if (antiAliased) {
                 for (int i = 0; i < PSD_LOOKUP_TABLE_SIZE; i++) {
                     contour[i] = lookup_table[i];
                 }
             } else {
                 for (int i = 0; i < PSD_LOOKUP_TABLE_SIZE; i++) {
                     contour[i] = lookup_table[(int)((int)(i / 2.55) * 2.55 + 0.5)];
                 }
             }
         }
 
         KisSequentialIterator dstIt(selection, applyRect);
         while (dstIt.nextPixel()) {
             quint8 *pixelPtr = dstIt.rawData();
             *pixelPtr = contour[*pixelPtr];
         }
     }
 
     void knockOutSelection(KisPixelSelectionSP selection,
                            KisPixelSelectionSP knockOutSelection,
                            const QRect &srcRect,
                            const QRect &dstRect,
                            const QRect &totalNeedRect,
                            const bool knockOutInverted)
     {
         KIS_ASSERT_RECOVER_RETURN(knockOutSelection);
 
         QRect knockOutRect = !knockOutInverted ? srcRect : totalNeedRect;
         knockOutRect &= dstRect;
 
         KisPainter gc(selection);
         gc.setCompositeOp(COMPOSITE_ERASE);
         gc.bitBlt(knockOutRect.topLeft(), knockOutSelection, knockOutRect);
     }
 
     void fillPattern(KisPaintDeviceSP fillDevice,
                      const QRect &applyRect,
                      KisLayerStyleFilterEnvironment *env,
                      int scale,
                      KoPattern *pattern,
                      int horizontalPhase,
                      int verticalPhase,
                      bool alignWithLayer)
     {
         if (scale != 100) {
             warnKrita << "KisLsOverlayFilter::applyOverlay(): Pattern scaling is NOT implemented!";
         }
 
         QSize psize(pattern->width(), pattern->height());
 
         QPoint patternOffset(qreal(psize.width()) * horizontalPhase / 100,
                              qreal(psize.height()) * verticalPhase / 100);
 
         const QRect boundsRect = alignWithLayer ?
             env->layerBounds() : env->defaultBounds();
 
         patternOffset += boundsRect.topLeft();
 
         patternOffset.rx() %= psize.width();
         patternOffset.ry() %= psize.height();
 
         QRect fillRect = applyRect | applyRect.translated(patternOffset);
 
         KisFillPainter gc(fillDevice);
         gc.fillRect(fillRect.x(), fillRect.y(),
                     fillRect.width(), fillRect.height(), pattern, -patternOffset);
         gc.end();
     }
 
     void fillOverlayDevice(KisPaintDeviceSP fillDevice,
                            const QRect &applyRect,
                            const psd_layer_effects_overlay_base *config,
                            KisLayerStyleFilterEnvironment *env)
     {
         if (config->fillType() == psd_fill_solid_color) {
             KoColor color(config->color(), fillDevice->colorSpace());
             fillDevice->setDefaultPixel(color);
 
         } else if (config->fillType() == psd_fill_pattern) {
             fillPattern(fillDevice, applyRect, env,
                         config->scale(), config->pattern(),
                         config->horizontalPhase(),
                         config->verticalPhase(),
                         config->alignWithLayer());
         } else if (config->fillType() == psd_fill_gradient) {
             const QRect boundsRect = config->alignWithLayer() ?
                 env->layerBounds() : env->defaultBounds();
 
             QPoint center = boundsRect.center();
             center += QPoint(boundsRect.width() * config->gradientXOffset() / 100,
                              boundsRect.height() * config->gradientYOffset() / 100);
 
             int width = (boundsRect.width() * config->scale() + 100) / 200;
             int height = (boundsRect.height() * config->scale() + 100) / 200;
 
             /* copy paste from libpsd */
 
             int angle = config->angle();
             int corner_angle = (int)(atan((qreal)boundsRect.height() / boundsRect.width()) * 180 / M_PI + 0.5);
             int sign_x = 1;
             int sign_y = 1;
 
 
             if(angle < 0) {
                 angle += 360;
             }
 
             if (angle >= 90 && angle < 180) {
                 angle = 180 - angle;
                 sign_x = -1;
             } else if (angle >= 180 && angle < 270) {
                 angle = angle - 180;
                 sign_x = -1;
                 sign_y = -1;
             } else if (angle >= 270 && angle <= 360) {
                 angle = 360 - angle;
                 sign_y = -1;
             }
 
             int radius_x = 0;
             int radius_y = 0;
 
             if (angle <= corner_angle) {
                 radius_x = width;
                 radius_y = (int)(radius_x * tan(kisDegreesToRadians(qreal(angle))) + 0.5);
             } else {
                 radius_y = height;
                 radius_x = (int)(radius_y / tan(kisDegreesToRadians(qreal(angle))) + 0.5);
             }
 
             int radius_corner = (int)(std::sqrt((qreal)(radius_x * radius_x + radius_y * radius_y)) + 0.5);
 
             /* end of copy paste from libpsd */
 
             KisGradientPainter gc(fillDevice);
             gc.setGradient(config->gradient().data());
             QPointF gradStart;
             QPointF gradEnd;
             KisGradientPainter::enumGradientRepeat repeat =
                 KisGradientPainter::GradientRepeatNone;
 
             QPoint rectangularOffset(sign_x * radius_x, -sign_y * radius_y);
 
 
             switch(config->style())
             {
             case psd_gradient_style_linear:
                 gc.setGradientShape(KisGradientPainter::GradientShapeLinear);
                 repeat = KisGradientPainter::GradientRepeatNone;
                 gradStart = center - rectangularOffset;
                 gradEnd = center + rectangularOffset;
                 break;
 
             case psd_gradient_style_radial:
                 gc.setGradientShape(KisGradientPainter::GradientShapeRadial);
                 repeat = KisGradientPainter::GradientRepeatNone;
                 gradStart = center;
                 gradEnd = center + QPointF(radius_corner, 0);
                 break;
 
             case psd_gradient_style_angle:
                 gc.setGradientShape(KisGradientPainter::GradientShapeConical);
                 repeat = KisGradientPainter::GradientRepeatNone;
                 gradStart = center;
                 gradEnd = center + rectangularOffset;
                 break;
 
             case psd_gradient_style_reflected:
                 gc.setGradientShape(KisGradientPainter::GradientShapeLinear);
                 repeat = KisGradientPainter::GradientRepeatAlternate;
                 gradStart = center - rectangularOffset;
                 gradEnd = center;
                 break;
 
             case psd_gradient_style_diamond:
                 gc.setGradientShape(KisGradientPainter::GradientShapeBiLinear);
                 repeat = KisGradientPainter::GradientRepeatNone;
                 gradStart = center - rectangularOffset;
                 gradEnd = center + rectangularOffset;
                 break;
             default:
                 qFatal("Gradient Overlay: unknown switch case!");
                 break;
             }
 
             gc.paintGradient(gradStart, gradEnd,
                              repeat, 0.0,
                              config->reverse(),
                              applyRect);
         }
     }
 
     void applyFinalSelection(const QString &projectionId,
                              KisSelectionSP baseSelection,
                              KisPaintDeviceSP srcDevice,
                              KisMultipleProjection *dst,
                              const QRect &/*srcRect*/,
                              const QRect &dstRect,
                              const psd_layer_effects_context */*context*/,
                              const psd_layer_effects_shadow_base *config,
                              const KisLayerStyleFilterEnvironment *env)
     {
         const KoColor effectColor(config->color(), srcDevice->colorSpace());
 
         const QRect effectRect(dstRect);
         const QString compositeOp = config->blendMode();
         const quint8 opacityU8 = 255.0 / 100.0 * config->opacity();
         KisPaintDeviceSP dstDevice = dst->getProjection(projectionId, compositeOp, opacityU8, QBitArray(), srcDevice);
 
         if (config->fillType() == psd_fill_solid_color) {
             KisFillPainter gc(dstDevice);
             gc.setCompositeOp(COMPOSITE_COPY);
             gc.setSelection(baseSelection);
             gc.fillSelection(effectRect, effectColor);
             gc.end();
 
         } else if (config->fillType() == psd_fill_gradient) {
             if (!config->gradient()) {
                 warnKrita << "KisLsUtils::applyFinalSelection: Gradient object is null! Skipping...";
                 return;
             }
 
             QVector<KoColor> table(256);
             Private::getGradientTable(config->gradient().data(), &table, dstDevice->colorSpace());
 
             Private::applyGradient(dstDevice, baseSelection->pixelSelection(),
                                    effectRect, table,
                                    true, config->jitter(), env);
         }
 
         //dstDevice->convertToQImage(0, QRect(0,0,300,300)).save("6_device_shadow.png");
     }
 
     bool checkEffectEnabled(const psd_layer_effects_shadow_base *config, KisMultipleProjection *dst)
     {
         bool result = config->effectEnabled();
 
         if (!result) {
             dst->freeAllProjections();
         }
 
         return result;
     }
 }
diff --git a/libs/image/layerstyles/kis_ls_utils.h b/libs/image/layerstyles/kis_ls_utils.h
index dc1964b663..4dacfc3e37 100644
--- a/libs/image/layerstyles/kis_ls_utils.h
+++ b/libs/image/layerstyles/kis_ls_utils.h
@@ -1,126 +1,126 @@
 /*
  *  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_LS_UTILS_H
 #define __KIS_LS_UTILS_H
 
 #include "kis_types.h"
 
 #include "kis_lod_transform.h"
 
 
 struct psd_layer_effects_context;
 class psd_layer_effects_shadow_base;
 struct psd_layer_effects_overlay_base;
 class KisLayerStyleFilterEnvironment;
 class KoPattern;
 class KisMultipleProjection;
 
 
 namespace KisLsUtils
 {
 
     QRect growSelectionUniform(KisPixelSelectionSP selection, int growSize, const QRect &applyRect);
 
     KisSelectionSP selectionFromAlphaChannel(KisPaintDeviceSP device,
                                              const QRect &srcRect);
 
     void findEdge(KisPixelSelectionSP selection, const QRect &applyRect, const bool edgeHidden);
     QRect growRectFromRadius(const QRect &rc, int radius);
-    void applyGaussian(KisPixelSelectionSP selection,
-                       const QRect &applyRect,
-                       qreal radius);
+    void applyGaussianWithTransaction(KisPixelSelectionSP selection,
+                                      const QRect &applyRect,
+                                      qreal radius);
 
     static const int FULL_PERCENT_RANGE = 100;
     void adjustRange(KisPixelSelectionSP selection, const QRect &applyRect, const int range);
 
     void applyContourCorrection(KisPixelSelectionSP selection,
                                 const QRect &applyRect,
                                 const quint8 *lookup_table,
                                 bool antiAliased,
                                 bool edgeHidden);
 
     extern const int noiseNeedBorder;
 
     void applyNoise(KisPixelSelectionSP selection,
                     const QRect &applyRect,
                     int noise,
                     const psd_layer_effects_context *context,
                     const KisLayerStyleFilterEnvironment *env);
 
     void knockOutSelection(KisPixelSelectionSP selection,
                            KisPixelSelectionSP knockOutSelection,
                            const QRect &srcRect,
                            const QRect &dstRect,
                            const QRect &totalNeedRect,
                            const bool knockOutInverted);
 
     void fillPattern(KisPaintDeviceSP fillDevice,
                      const QRect &applyRect,
                      KisLayerStyleFilterEnvironment *env,
                      int scale,
                      KoPattern *pattern,
                      int horizontalPhase,
                      int verticalPhase,
                      bool alignWithLayer);
 
     void fillOverlayDevice(KisPaintDeviceSP fillDevice,
                            const QRect &applyRect,
                            const psd_layer_effects_overlay_base *config,
                            KisLayerStyleFilterEnvironment *env);
 
     void applyFinalSelection(const QString &projectionId,
                              KisSelectionSP baseSelection,
                              KisPaintDeviceSP srcDevice,
                              KisMultipleProjection *dst,
                              const QRect &srcRect,
                              const QRect &dstRect,
                              const psd_layer_effects_context *context,
                              const psd_layer_effects_shadow_base *config,
                              const KisLayerStyleFilterEnvironment *env);
 
     bool checkEffectEnabled(const psd_layer_effects_shadow_base *config, KisMultipleProjection *dst);
 
     template<class ConfigStruct>
     struct LodWrapper
     {
         LodWrapper(int lod,
                    const ConfigStruct *srcStruct)
 
             {
                 if (lod > 0) {
                     storage.reset(new ConfigStruct(*srcStruct));
 
                     const qreal lodScale = KisLodTransform::lodToScale(lod);
                     storage->scaleLinearSizes(lodScale);
 
                     config = storage.data();
                 } else {
                     config = srcStruct;
                 }
             }
 
         const ConfigStruct *config;
 
     private:
         QScopedPointer<ConfigStruct> storage;
     };
 
 }
 
 #endif /* __KIS_LS_UTILS_H */
diff --git a/libs/impex/MultiLayerCheck.h b/libs/impex/MultiLayerCheck.h
index dad4f23bf1..759368d18f 100644
--- a/libs/impex/MultiLayerCheck.h
+++ b/libs/impex/MultiLayerCheck.h
@@ -1,71 +1,71 @@
 /*
  * Copyright (C) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #ifndef MultiLayerCheck_H
 #define MultiLayerCheck_H
 
 #include "KisExportCheckRegistry.h"
 #include <KoID.h>
 #include <klocalizedstring.h>
 #include <kis_image.h>
 #include <kis_group_layer.h>
 
 class MultiLayerCheck : public KisExportCheckBase
 {
 public:
 
     MultiLayerCheck(const QString &id, Level level, const QString &customWarning = QString())
         : KisExportCheckBase(id, level, customWarning)
     {
         if (customWarning.isEmpty()) {
-            m_warning = i18nc("image conversion warning", "The image has <b>more than one layer</b>. Only the flattened image will be saved.");
+            m_warning = i18nc("image conversion warning", "The image has <b>more than one layer or a mask or an active selection</b>. Only the flattened image will be saved.");
         }
     }
 
     bool checkNeeded(KisImageSP image) const override
     {
         return (image->rootLayer()->childCount() > 1);
     }
 
     Level check(KisImageSP /*image*/) const override
     {
         return m_level;
     }
 
 };
 
 class MultiLayerCheckFactory : public KisExportCheckFactory
 {
 public:
 
     MultiLayerCheckFactory() {}
 
     ~MultiLayerCheckFactory() override {}
 
     KisExportCheckBase *create(KisExportCheckBase::Level level, const QString &customWarning) override
     {
         return new MultiLayerCheck(id(), level, customWarning);
     }
 
     QString id() const override {
         return "MultiLayerCheck";
     }
 };
 
 #endif // MultiLayerCheck_H
diff --git a/libs/ui/KisApplication.cpp b/libs/ui/KisApplication.cpp
index 1d1c1ef300..aaea1acf51 100644
--- a/libs/ui/KisApplication.cpp
+++ b/libs/ui/KisApplication.cpp
@@ -1,840 +1,839 @@
 /*
  * Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
  * Copyright (C) 2012 Boudewijn Rempt <boud@valdyas.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "KisApplication.h"
 
 #include <stdlib.h>
 #ifdef Q_OS_WIN
 #include <windows.h>
 #include <tchar.h>
 #endif
 
 #ifdef Q_OS_OSX
 #include "osx.h"
 #endif
 
 #include <QStandardPaths>
 #include <QDesktopWidget>
 #include <QDir>
 #include <QFile>
 #include <QLocale>
 #include <QMessageBox>
 #include <QMessageBox>
 #include <QProcessEnvironment>
 #include <QSettings>
 #include <QStandardPaths>
 #include <QStringList>
 #include <QStyle>
 #include <QStyleFactory>
 #include <QSysInfo>
 #include <QTimer>
 #include <QWidget>
 
 #include <klocalizedstring.h>
 #include <kdesktopfile.h>
 #include <kconfig.h>
 #include <kconfiggroup.h>
 
 #include <KoColorSpaceRegistry.h>
 #include <KoPluginLoader.h>
 #include <KoShapeRegistry.h>
 #include <KoDpi.h>
 #include "KoConfig.h"
 #include <resources/KoHashGeneratorProvider.h>
 #include <KoResourcePaths.h>
 #include <KisMimeDatabase.h>
 #include "thememanager.h"
 #include "KisPrintJob.h"
 #include "KisDocument.h"
 #include "KisMainWindow.h"
 #include "KisAutoSaveRecoveryDialog.h"
 #include "KisPart.h"
 #include <kis_icon.h>
 #include "kis_md5_generator.h"
 #include "kis_splash_screen.h"
 #include "kis_config.h"
 #include "flake/kis_shape_selection.h"
 #include <filter/kis_filter.h>
 #include <filter/kis_filter_registry.h>
 #include <filter/kis_filter_configuration.h>
 #include <generator/kis_generator_registry.h>
 #include <generator/kis_generator.h>
 #include <brushengine/kis_paintop_registry.h>
 #include <metadata/kis_meta_data_io_backend.h>
 #include "kisexiv2/kis_exiv2.h"
 #include "KisApplicationArguments.h"
 #include <kis_debug.h>
 #include "kis_action_registry.h"
 #include <kis_brush_server.h>
 #include <KisResourceServerProvider.h>
 #include <KoResourceServerProvider.h>
 #include "kis_image_barrier_locker.h"
 #include "opengl/kis_opengl.h"
 #include "kis_spin_box_unit_manager.h"
 #include "kis_document_aware_spin_box_unit_manager.h"
 #include "KisViewManager.h"
 #include "kis_workspace_resource.h"
 #include <KisAutoSaveRecoveryDialog.h>
 
 #include <KritaVersionWrapper.h>
 #include <dialogs/KisSessionManagerDialog.h>
 
 namespace {
 const QTime appStartTime(QTime::currentTime());
 }
 
 class KisApplication::Private
 {
 public:
     Private() {}
     QPointer<KisSplashScreen> splashScreen;
     KisAutoSaveRecoveryDialog *autosaveDialog {0};
     QPointer<KisMainWindow> mainWindow; // The first mainwindow we create on startup
     bool batchRun {false};
 
 };
 
 class KisApplication::ResetStarting
 {
 public:
     ResetStarting(KisSplashScreen *splash, int fileCount)
         : m_splash(splash)
         , m_fileCount(fileCount)
     {
     }
 
     ~ResetStarting()  {
         if (m_splash) {
 
             KConfigGroup cfg( KSharedConfig::openConfig(), "SplashScreen");
             bool hideSplash = cfg.readEntry("HideSplashAfterStartup", false);
             if (m_fileCount > 0 || hideSplash) {
                 m_splash->hide();
             }
             else {
                 m_splash->setWindowFlags(Qt::Dialog);
                 QRect r(QPoint(), m_splash->size());
                 m_splash->move(QApplication::desktop()->availableGeometry().center() - r.center());
                 m_splash->setWindowTitle(qAppName());
                 m_splash->setParent(0);
                 Q_FOREACH (QObject *o, m_splash->children()) {
                     QWidget *w = qobject_cast<QWidget*>(o);
                     if (w && w->isHidden()) {
                         w->setVisible(true);
                     }
                 }
                 m_splash->show();
                 m_splash->activateWindow();
             }
         }
     }
 
     QPointer<KisSplashScreen> m_splash;
     int m_fileCount;
 };
 
 
 KisApplication::KisApplication(const QString &key, int &argc, char **argv)
     : QtSingleApplication(key, argc, argv)
     , d(new Private)
 {
 #ifdef Q_OS_OSX
     setMouseCoalescingEnabled(false);
 #endif
 
     QCoreApplication::addLibraryPath(QCoreApplication::applicationDirPath());
 
     setApplicationDisplayName("Krita");
     setApplicationName("krita");
     // Note: Qt docs suggest we set this, but if we do, we get resource paths of the form of krita/krita, which is weird.
     //    setOrganizationName("krita");
     setOrganizationDomain("krita.org");
 
     QString version = KritaVersionWrapper::versionString(true);
     setApplicationVersion(version);
     setWindowIcon(KisIconUtils::loadIcon("calligrakrita"));
 
     if (qgetenv("KRITA_NO_STYLE_OVERRIDE").isEmpty()) {
         QStringList styles = QStringList() << "breeze" << "fusion" << "plastique";
         if (!styles.contains(style()->objectName().toLower())) {
             Q_FOREACH (const QString & style, styles) {
                 if (!setStyle(style)) {
                     qDebug() << "No" << style << "available.";
                 }
                 else {
                     qDebug() << "Set style" << style;
                     break;
                 }
             }
         }
     }
     else {
         qDebug() << "Style override disabled, using" << style()->objectName();
     }
 
     KisOpenGL::initialize();
-    qDebug() << "krita has opengl" << KisOpenGL::hasOpenGL();
 }
 
 #if defined(Q_OS_WIN) && defined(ENV32BIT)
 typedef BOOL (WINAPI *LPFN_ISWOW64PROCESS) (HANDLE, PBOOL);
 
 LPFN_ISWOW64PROCESS fnIsWow64Process;
 
 BOOL isWow64()
 {
     BOOL bIsWow64 = FALSE;
 
     //IsWow64Process is not available on all supported versions of Windows.
     //Use GetModuleHandle to get a handle to the DLL that contains the function
     //and GetProcAddress to get a pointer to the function if available.
 
     fnIsWow64Process = (LPFN_ISWOW64PROCESS) GetProcAddress(
                 GetModuleHandle(TEXT("kernel32")),"IsWow64Process");
 
     if(0 != fnIsWow64Process)
     {
         if (!fnIsWow64Process(GetCurrentProcess(),&bIsWow64))
         {
             //handle error
         }
     }
     return bIsWow64;
 }
 #endif
 
 void KisApplication::initializeGlobals(const KisApplicationArguments &args)
 {
     int dpiX = args.dpiX();
     int dpiY = args.dpiY();
     if (dpiX > 0 && dpiY > 0) {
         KoDpi::setDPI(dpiX, dpiY);
     }
 }
 
 void KisApplication::addResourceTypes()
 {
     //    qDebug() << "addResourceTypes();";
     // All Krita's resource types
     KoResourcePaths::addResourceType("kis_pics", "data", "/pics/");
     KoResourcePaths::addResourceType("kis_images", "data", "/images/");
     KoResourcePaths::addResourceType("icc_profiles", "data", "/profiles/");
     KoResourcePaths::addResourceType("metadata_schema", "data", "/metadata/schemas/");
     KoResourcePaths::addResourceType("kis_brushes", "data", "/brushes/");
     KoResourcePaths::addResourceType("kis_taskset", "data", "/taskset/");
     KoResourcePaths::addResourceType("kis_taskset", "data", "/taskset/");
     KoResourcePaths::addResourceType("gmic_definitions", "data", "/gmic/");
     KoResourcePaths::addResourceType("kis_resourcebundles", "data", "/bundles/");
     KoResourcePaths::addResourceType("kis_defaultpresets", "data", "/defaultpresets/");
     KoResourcePaths::addResourceType("kis_paintoppresets", "data", "/paintoppresets/");
     KoResourcePaths::addResourceType("kis_workspaces", "data", "/workspaces/");
     KoResourcePaths::addResourceType("kis_windowlayouts", "data", "/windowlayouts/");
     KoResourcePaths::addResourceType("kis_sessions", "data", "/sessions/");
     KoResourcePaths::addResourceType("psd_layer_style_collections", "data", "/asl");
     KoResourcePaths::addResourceType("ko_patterns", "data", "/patterns/", true);
     KoResourcePaths::addResourceType("ko_gradients", "data", "/gradients/");
     KoResourcePaths::addResourceType("ko_gradients", "data", "/gradients/", true);
     KoResourcePaths::addResourceType("ko_palettes", "data", "/palettes/", true);
     KoResourcePaths::addResourceType("kis_shortcuts", "data", "/shortcuts/");
     KoResourcePaths::addResourceType("kis_actions", "data", "/actions");
     KoResourcePaths::addResourceType("icc_profiles", "data", "/color/icc");
     KoResourcePaths::addResourceType("ko_effects", "data", "/effects/");
     KoResourcePaths::addResourceType("tags", "data", "/tags/");
     KoResourcePaths::addResourceType("templates", "data", "/templates");
     KoResourcePaths::addResourceType("pythonscripts", "data", "/pykrita");
     KoResourcePaths::addResourceType("symbols", "data", "/symbols");
     KoResourcePaths::addResourceType("preset_icons", "data", "/preset_icons");
 
     //    // Extra directories to look for create resources. (Does anyone actually use that anymore?)
     //    KoResourcePaths::addResourceDir("ko_gradients", "/usr/share/create/gradients/gimp");
     //    KoResourcePaths::addResourceDir("ko_gradients", QDir::homePath() + QString("/.create/gradients/gimp"));
     //    KoResourcePaths::addResourceDir("ko_patterns", "/usr/share/create/patterns/gimp");
     //    KoResourcePaths::addResourceDir("ko_patterns", QDir::homePath() + QString("/.create/patterns/gimp"));
     //    KoResourcePaths::addResourceDir("kis_brushes", "/usr/share/create/brushes/gimp");
     //    KoResourcePaths::addResourceDir("kis_brushes", QDir::homePath() + QString("/.create/brushes/gimp"));
     //    KoResourcePaths::addResourceDir("ko_palettes", "/usr/share/create/swatches");
     //    KoResourcePaths::addResourceDir("ko_palettes", QDir::homePath() + QString("/.create/swatches"));
 
     // Make directories for all resources we can save, and tags
     QDir d;
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/tags/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/asl/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/bundles/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/brushes/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/gradients/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/paintoppresets/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/palettes/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/patterns/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/taskset/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/workspaces/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/input/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/pykrita/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/symbols/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/color-schemes/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/preset_icons/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/preset_icons/tool_icons/");
     d.mkpath(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/preset_icons/emblem_icons/");
 
     // Indicate that it is now safe for users of KoResourcePaths to load resources
     KoResourcePaths::setReady();
 }
 
 void KisApplication::loadResources()
 {
     //    qDebug() << "loadResources();";
 
     setSplashScreenLoadingText(i18n("Loading Resources..."));
     processEvents();
     KoResourceServerProvider::instance();
 
     setSplashScreenLoadingText(i18n("Loading Brush Presets..."));
     processEvents();
     KisResourceServerProvider::instance();
 
     setSplashScreenLoadingText(i18n("Loading Brushes..."));
     processEvents();
     KisBrushServer::instance()->brushServer();
 
     setSplashScreenLoadingText(i18n("Loading Bundles..."));
     processEvents();
     KisResourceBundleServerProvider::instance();
 }
 
 void KisApplication::loadResourceTags()
 {
     //    qDebug() << "loadResourceTags()";
 
     KoResourceServerProvider::instance()->patternServer()->loadTags();
     KoResourceServerProvider::instance()->gradientServer()->loadTags();
     KoResourceServerProvider::instance()->paletteServer()->loadTags();
     KoResourceServerProvider::instance()->svgSymbolCollectionServer()->loadTags();
     KisBrushServer::instance()->brushServer()->loadTags();
     KisResourceServerProvider::instance()->workspaceServer()->loadTags();
     KisResourceServerProvider::instance()->layerStyleCollectionServer()->loadTags();
     KisResourceBundleServerProvider::instance()->resourceBundleServer()->loadTags();
     KisResourceServerProvider::instance()->paintOpPresetServer()->loadTags();
 
     KisResourceServerProvider::instance()->paintOpPresetServer()->clearOldSystemTags();
 }
 
 void KisApplication::loadPlugins()
 {
     //    qDebug() << "loadPlugins();";
 
     KoShapeRegistry* r = KoShapeRegistry::instance();
     r->add(new KisShapeSelectionFactory());
 
     KisActionRegistry::instance();
     KisFilterRegistry::instance();
     KisGeneratorRegistry::instance();
     KisPaintOpRegistry::instance();
     KoColorSpaceRegistry::instance();
 }
 
 void KisApplication::loadGuiPlugins()
 {
     //    qDebug() << "loadGuiPlugins();";
     // Load the krita-specific tools
     setSplashScreenLoadingText(i18n("Loading Plugins for Krita/Tool..."));
     processEvents();
     //    qDebug() << "loading tools";
     KoPluginLoader::instance()->load(QString::fromLatin1("Krita/Tool"),
                                      QString::fromLatin1("[X-Krita-Version] == 28"));
 
 
     // Load dockers
     setSplashScreenLoadingText(i18n("Loading Plugins for Krita/Dock..."));
     processEvents();
     //    qDebug() << "loading dockers";
     KoPluginLoader::instance()->load(QString::fromLatin1("Krita/Dock"),
                                      QString::fromLatin1("[X-Krita-Version] == 28"));
 
     // XXX_EXIV: make the exiv io backends real plugins
     setSplashScreenLoadingText(i18n("Loading Plugins Exiv/IO..."));
     processEvents();
     //    qDebug() << "loading exiv2";
     KisExiv2::initialize();
 }
 
 bool KisApplication::start(const KisApplicationArguments &args)
 {
     KisConfig cfg;
 
 #if defined(Q_OS_WIN)
 #ifdef ENV32BIT
 
     if (isWow64() && !cfg.readEntry("WarnedAbout32Bits", false)) {
         QMessageBox::information(0,
                                  i18nc("@title:window", "Krita: Warning"),
                                  i18n("You are running a 32 bits build on a 64 bits Windows.\n"
                                       "This is not recommended.\n"
                                       "Please download and install the x64 build instead."));
         cfg.writeEntry("WarnedAbout32Bits", true);
 
     }
 #endif
 #endif
 
     QString opengl = cfg.canvasState();
     if (opengl == "OPENGL_NOT_TRIED" ) {
         cfg.setCanvasState("TRY_OPENGL");
     }
     else if (opengl != "OPENGL_SUCCESS") {
         cfg.setCanvasState("OPENGL_FAILED");
     }
 
     setSplashScreenLoadingText(i18n("Initializing Globals"));
     processEvents();
     initializeGlobals(args);
 
     const bool doNewImage = args.doNewImage();
     const bool doTemplate = args.doTemplate();
     const bool exportAs = args.exportAs();
     const QString exportFileName = args.exportFileName();
 
     d->batchRun = (exportAs || !exportFileName.isEmpty());
     const bool needsMainWindow = !exportAs;
     // only show the mainWindow when no command-line mode option is passed
     bool showmainWindow = !exportAs; // would be !batchRun;
 
     const bool showSplashScreen = !d->batchRun && qEnvironmentVariableIsEmpty("NOSPLASH");
     if (showSplashScreen && d->splashScreen) {
         d->splashScreen->show();
         d->splashScreen->repaint();
         processEvents();
     }
 
     KoHashGeneratorProvider::instance()->setGenerator("MD5", new KisMD5Generator());
 
     KConfigGroup group(KSharedConfig::openConfig(), "theme");
     Digikam::ThemeManager themeManager;
     themeManager.setCurrentTheme(group.readEntry("Theme", "Krita dark"));
 
     ResetStarting resetStarting(d->splashScreen, args.filenames().count()); // remove the splash when done
     Q_UNUSED(resetStarting);
 
     // Make sure we can save resources and tags
     setSplashScreenLoadingText(i18n("Adding resource types"));
     processEvents();
     addResourceTypes();
 
     // Load the plugins
     loadPlugins();
 
     // Load all resources
     loadResources();
 
     // Load all the tags
     loadResourceTags();
 
     // Load the gui plugins
     loadGuiPlugins();
 
     KisPart *kisPart = KisPart::instance();
     if (needsMainWindow) {
         // show a mainWindow asap, if we want that
         setSplashScreenLoadingText(i18n("Loading Main Window..."));
         processEvents();
 
 
         bool sessionNeeded = true;
         auto sessionMode = cfg.sessionOnStartup();
 
         if (!args.session().isEmpty()) {
             sessionNeeded = !kisPart->restoreSession(args.session());
         } else if (sessionMode == KisConfig::SOS_ShowSessionManager) {
             showmainWindow = false;
             sessionNeeded = false;
             kisPart->showSessionManager();
         } else if (sessionMode == KisConfig::SOS_PreviousSession) {
             KConfigGroup sessionCfg = KSharedConfig::openConfig()->group("session");
             const QString &sessionName = sessionCfg.readEntry("previousSession");
 
             sessionNeeded = !kisPart->restoreSession(sessionName);
         }
 
         if (sessionNeeded) {
             kisPart->startBlankSession();
         }
 
         if (!args.windowLayout().isEmpty()) {
             KoResourceServer<KisWindowLayoutResource> * rserver = KisResourceServerProvider::instance()->windowLayoutServer();
             KisWindowLayoutResource* windowLayout = rserver->resourceByName(args.windowLayout());
             if (windowLayout) {
                 windowLayout->applyLayout();
             }
         }
 
         if (showmainWindow) {
             d->mainWindow = kisPart->currentMainwindow();
 
             if (!args.workspace().isEmpty()) {
                 KoResourceServer<KisWorkspaceResource> * rserver = KisResourceServerProvider::instance()->workspaceServer();
                 KisWorkspaceResource* workspace = rserver->resourceByName(args.workspace());
                 if (workspace) {
                     d->mainWindow->restoreWorkspace(workspace);
                 }
             }
 
             if (args.canvasOnly()) {
                 d->mainWindow->viewManager()->switchCanvasOnly(true);
             }
 
             if (args.fullScreen()) {
                 d->mainWindow->showFullScreen();
             }
         } else {
             d->mainWindow = kisPart->createMainWindow();
         }
     }
     short int numberOfOpenDocuments = 0; // number of documents open
 
     // Check for autosave files that can be restored, if we're not running a batchrun (test)
     if (!d->batchRun) {
         checkAutosaveFiles();
     }
 
     setSplashScreenLoadingText(QString()); // done loading, so clear out label
     processEvents();
 
     //configure the unit manager
     KisSpinBoxUnitManagerFactory::setDefaultUnitManagerBuilder(new KisDocumentAwareSpinBoxUnitManagerBuilder());
     connect(this, &KisApplication::aboutToQuit, &KisSpinBoxUnitManagerFactory::clearUnitManagerBuilder); //ensure the builder is destroyed when the application leave.
     //the new syntax slot syntax allow to connect to a non q_object static method.
 
 
     // Create a new image, if needed
     if (doNewImage) {
         KisDocument *doc = args.image();
         if (doc) {
             kisPart->addDocument(doc);
             d->mainWindow->addViewAndNotifyLoadingCompleted(doc);
         }
     }
 
     // Get the command line arguments which we have to parse
     int argsCount = args.filenames().count();
     if (argsCount > 0) {
         // Loop through arguments
         for (int argNumber = 0; argNumber < argsCount; argNumber++) {
             QString fileName = args.filenames().at(argNumber);
             // are we just trying to open a template?
             if (doTemplate) {
                 // called in mix with batch options? ignore and silently skip
                 if (d->batchRun) {
                     continue;
                 }
                 if (createNewDocFromTemplate(fileName, d->mainWindow)) {
                     ++numberOfOpenDocuments;
                 }
                 // now try to load
             }
             else {
                 if (exportAs) {
                     QString outputMimetype = KisMimeDatabase::mimeTypeForFile(exportFileName, false);
                     if (outputMimetype == "application/octetstream") {
                         dbgKrita << i18n("Mimetype not found, try using the -mimetype option") << endl;
                         return 1;
                     }
 
                     KisDocument *doc = kisPart->createDocument();
                     doc->setFileBatchMode(d->batchRun);
                     doc->openUrl(QUrl::fromLocalFile(fileName));
 
                     qApp->processEvents(); // For vector layers to be updated
 
                     doc->setFileBatchMode(true);
                     if (!doc->exportDocumentSync(QUrl::fromLocalFile(exportFileName), outputMimetype.toLatin1())) {
                         dbgKrita << "Could not export " << fileName << "to" << exportFileName << ":" << doc->errorMessage();
                     }
                     QTimer::singleShot(0, this, SLOT(quit()));
                 }
                 else if (d->mainWindow) {
                     if (fileName.endsWith(".bundle")) {
                         d->mainWindow->installBundle(fileName);
                     }
                     else {
                         KisMainWindow::OpenFlags flags = d->batchRun ? KisMainWindow::BatchMode : KisMainWindow::None;
 
                         if (d->mainWindow->openDocument(QUrl::fromLocalFile(fileName), flags)) {
                             // Normal case, success
                             numberOfOpenDocuments++;
                         }
                     }
                 }
             }
         }
     }
 
     // fixes BUG:369308  - Krita crashing on splash screen when loading.
     // trying to open a file before Krita has loaded can cause it to hang and crash
     if (d->splashScreen) {
         d->splashScreen->displayLinks(true);
         d->splashScreen->displayRecentFiles(true);
     }
 
 
     // not calling this before since the program will quit there.
     return true;
 }
 
 KisApplication::~KisApplication()
 {
 }
 
 void KisApplication::setSplashScreen(QWidget *splashScreen)
 {
     d->splashScreen = qobject_cast<KisSplashScreen*>(splashScreen);
 }
 
 void KisApplication::setSplashScreenLoadingText(QString textToLoad)
 {
     if (d->splashScreen) {
         //d->splashScreen->loadingLabel->setText(textToLoad);
         d->splashScreen->setLoadingText(textToLoad);
         d->splashScreen->repaint();
     }
 }
 
 void KisApplication::hideSplashScreen()
 {
     if (d->splashScreen) {
         // hide the splashscreen to see the dialog
         d->splashScreen->hide();
     }
 }
 
 bool KisApplication::notify(QObject *receiver, QEvent *event)
 {
     try {
         return QApplication::notify(receiver, event);
     } catch (std::exception &e) {
         qWarning("Error %s sending event %i to object %s",
                  e.what(), event->type(), qPrintable(receiver->objectName()));
     } catch (...) {
         qWarning("Error <unknown> sending event %i to object %s",
                  event->type(), qPrintable(receiver->objectName()));
     }
     return false;
 }
 
 
 void KisApplication::remoteArguments(QByteArray message, QObject *socket)
 {
     Q_UNUSED(socket);
 
     // check if we have any mainwindow
     KisMainWindow *mw = qobject_cast<KisMainWindow*>(qApp->activeWindow());
     if (!mw) {
         mw = KisPart::instance()->mainWindows().first();
     }
 
     if (!mw) {
         return;
     }
 
     KisApplicationArguments args = KisApplicationArguments::deserialize(message);
     const bool doTemplate = args.doTemplate();
     const int argsCount = args.filenames().count();
 
     if (argsCount > 0) {
         // Loop through arguments
         for (int argNumber = 0; argNumber < argsCount; ++argNumber) {
             QString filename = args.filenames().at(argNumber);
             // are we just trying to open a template?
             if (doTemplate) {
                 createNewDocFromTemplate(filename, mw);
             }
             else if (QFile(filename).exists()) {
                 KisMainWindow::OpenFlags flags = d->batchRun ? KisMainWindow::BatchMode : KisMainWindow::None;
                 mw->openDocument(QUrl::fromLocalFile(filename), flags);
             }
         }
     }
 }
 
 void KisApplication::fileOpenRequested(const QString &url)
 {
     KisMainWindow *mainWindow = KisPart::instance()->mainWindows().first();
     if (mainWindow) {
         KisMainWindow::OpenFlags flags = d->batchRun ? KisMainWindow::BatchMode : KisMainWindow::None;
         mainWindow->openDocument(QUrl::fromLocalFile(url), flags);
     }
 }
 
 
 void KisApplication::checkAutosaveFiles()
 {
     if (d->batchRun) return;
 
     // Check for autosave files from a previous run. There can be several, and
     // we want to offer a restore for every one. Including a nice thumbnail!
 
     QStringList filters;
     filters << QString(".krita-*-*-autosave.kra");
 
 #ifdef Q_OS_WIN
     QDir dir = QDir::temp();
 #else
     QDir dir = QDir::home();
 #endif
 
     // all autosave files for our application
     QStringList autosaveFiles = dir.entryList(filters, QDir::Files | QDir::Hidden);
 
     // Allow the user to make their selection
     if (autosaveFiles.size() > 0) {
         if (d->splashScreen) {
             // hide the splashscreen to see the dialog
             d->splashScreen->hide();
         }
         d->autosaveDialog = new KisAutoSaveRecoveryDialog(autosaveFiles, activeWindow());
         QDialog::DialogCode result = (QDialog::DialogCode) d->autosaveDialog->exec();
 
         if (result == QDialog::Accepted) {
             QStringList filesToRecover = d->autosaveDialog->recoverableFiles();
             Q_FOREACH (const QString &autosaveFile, autosaveFiles) {
                 if (!filesToRecover.contains(autosaveFile)) {
                     QFile::remove(dir.absolutePath() + "/" + autosaveFile);
                 }
             }
             autosaveFiles = filesToRecover;
         } else {
             autosaveFiles.clear();
         }
 
         if (autosaveFiles.size() > 0) {
             QList<QUrl> autosaveUrls;
             Q_FOREACH (const QString &autoSaveFile, autosaveFiles) {
                 const QUrl url = QUrl::fromLocalFile(dir.absolutePath() + QLatin1Char('/') + autoSaveFile);
                 autosaveUrls << url;
             }
             if (d->mainWindow) {
                 Q_FOREACH (const QUrl &url, autosaveUrls) {
                     KisMainWindow::OpenFlags flags = d->batchRun ? KisMainWindow::BatchMode : KisMainWindow::None;
                     d->mainWindow->openDocument(url, flags | KisMainWindow::RecoveryFile);
                 }
             }
         }
         // cleanup
         delete d->autosaveDialog;
         d->autosaveDialog = nullptr;
     }
 }
 
 bool KisApplication::createNewDocFromTemplate(const QString &fileName, KisMainWindow *mainWindow)
 {
     QString templatePath;
 
     const QUrl templateUrl = QUrl::fromLocalFile(fileName);
     if (QFile::exists(fileName)) {
         templatePath = templateUrl.toLocalFile();
         dbgUI << "using full path...";
     }
     else {
         QString desktopName(fileName);
         const QString templatesResourcePath =  QStringLiteral("templates/");
 
         QStringList paths = KoResourcePaths::findAllResources("data", templatesResourcePath + "*/" + desktopName);
         if (paths.isEmpty()) {
             paths = KoResourcePaths::findAllResources("data", templatesResourcePath + desktopName);
         }
 
         if (paths.isEmpty()) {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"),
                                   i18n("No template found for: %1", desktopName));
         } else if (paths.count() > 1) {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"),
                                   i18n("Too many templates found for: %1", desktopName));
         } else {
             templatePath = paths.at(0);
         }
     }
 
     if (!templatePath.isEmpty()) {
         QUrl templateBase;
         templateBase.setPath(templatePath);
         KDesktopFile templateInfo(templatePath);
 
         QString templateName = templateInfo.readUrl();
         QUrl templateURL;
         templateURL.setPath(templateBase.adjusted(QUrl::RemoveFilename|QUrl::StripTrailingSlash).path() + '/' + templateName);
 
         KisMainWindow::OpenFlags batchFlags = d->batchRun ? KisMainWindow::BatchMode : KisMainWindow::None;
         if (mainWindow->openDocument(templateURL, KisMainWindow::Import | batchFlags)) {
             dbgUI << "Template loaded...";
             return true;
         }
         else {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"),
                                   i18n("Template %1 failed to load.", templateURL.toDisplayString()));
         }
     }
 
     return false;
 }
 
 void KisApplication::clearConfig()
 {
     KIS_ASSERT_RECOVER_RETURN(qApp->thread() == QThread::currentThread());
 
     KSharedConfigPtr config =  KSharedConfig::openConfig();
 
     // find user settings file
     bool createDir = false;
     QString kritarcPath = KoResourcePaths::locateLocal("config", "kritarc", createDir);
 
     QFile configFile(kritarcPath);
     if (configFile.exists()) {
         // clear file
         if (configFile.open(QFile::WriteOnly)) {
             configFile.close();
         }
         else {
             QMessageBox::warning(0,
                                  i18nc("@title:window", "Krita"),
                                  i18n("Failed to clear %1\n\n"
                                       "Please make sure no other program is using the file and try again.",
                                       kritarcPath),
                                  QMessageBox::Ok, QMessageBox::Ok);
         }
     }
 
     // reload from disk; with the user file settings cleared,
     // this should load any default configuration files shipping with the program
     config->reparseConfiguration();
     config->sync();
 }
 
 void KisApplication::askClearConfig()
 {
     Qt::KeyboardModifiers mods = QApplication::queryKeyboardModifiers();
     bool askClearConfig = (mods & Qt::ControlModifier) && (mods & Qt::ShiftModifier) && (mods & Qt::AltModifier);
 
     if (askClearConfig) {
         bool ok = QMessageBox::question(0,
                                         i18nc("@title:window", "Krita"),
                                         i18n("Do you want to clear the settings file?"),
                                         QMessageBox::Yes | QMessageBox::No, QMessageBox::No) == QMessageBox::Yes;
         if (ok) {
             clearConfig();
         }
     }
 }
diff --git a/libs/ui/KisDecorationsManager.cpp b/libs/ui/KisDecorationsManager.cpp
index 5dac34a15b..62b2b5a05a 100644
--- a/libs/ui/KisDecorationsManager.cpp
+++ b/libs/ui/KisDecorationsManager.cpp
@@ -1,128 +1,128 @@
 /*
  *  Copyright (c) 2009 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2014 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "KisDecorationsManager.h"
 
 #include "KisViewManager.h"
 #include "kis_action_manager.h"
 #include "kis_action.h"
 
 #include "kis_canvas2.h"
 #include <klocalizedstring.h>
 #include <kguiitem.h>
 #include <ktoggleaction.h>
 #include <kactioncollection.h>
 
 
 KisDecorationsManager::KisDecorationsManager(KisViewManager* view)
     : QObject(view)
     , m_imageView(0)
 {
 }
 
 KisDecorationsManager::~KisDecorationsManager()
 {
 }
 
 void KisDecorationsManager::setup(KisActionManager * actionManager)
 {
     m_toggleAssistant = actionManager->createAction("view_toggle_painting_assistants");
     m_togglePreview   = actionManager->createAction("view_toggle_assistant_previews");
     m_toggleReferenceImages = actionManager->createAction("view_toggle_reference_images");
 
     updateAction();
 }
 
 void KisDecorationsManager::setView(QPointer<KisView> imageView)
 {
 
     // set view is called twice when a document is open, so we need to disconnect the original signals
     // if m_imageView has already been created. This prevents double signal events firing
     if (m_imageView) {
         m_toggleAssistant->disconnect();
         m_togglePreview->disconnect();
 
         if (assistantsDecoration()) {
             assistantsDecoration()->disconnect(this);
         }
         if (referenceImagesDecoration()) {
             referenceImagesDecoration()->disconnect(this);
         }
     }
 
     m_imageView = imageView;
 
     if (m_imageView && !assistantsDecoration()) {
         KisPaintingAssistantsDecoration *deco = new KisPaintingAssistantsDecoration(m_imageView);
         m_imageView->canvasBase()->addDecoration(deco);
     }
 
     if (m_imageView && !referenceImagesDecoration()) {
-        KisReferenceImagesDecoration *deco = new KisReferenceImagesDecoration(m_imageView);
+        KisReferenceImagesDecoration *deco = new KisReferenceImagesDecoration(m_imageView, imageView->document());
         m_imageView->canvasBase()->addDecoration(deco);
     }
 
     if (m_imageView && assistantsDecoration()) {
         connect(m_toggleAssistant, SIGNAL(triggered()), assistantsDecoration(), SLOT(toggleAssistantVisible()));
         connect(m_togglePreview, SIGNAL(triggered()), assistantsDecoration(), SLOT(toggleOutlineVisible()));
         connect(assistantsDecoration(), SIGNAL(assistantChanged()), SLOT(updateAction()));
     }
 
     if (m_imageView && referenceImagesDecoration()) {
         connect(m_toggleReferenceImages, SIGNAL(triggered(bool)), referenceImagesDecoration(), SLOT(setVisible(bool)));
     }
 
 
     updateAction();
 }
 
 void KisDecorationsManager::updateAction()
 {
     if (assistantsDecoration()) {
         bool enabled = !assistantsDecoration()->assistants().isEmpty();
         m_toggleAssistant->setChecked(assistantsDecoration()->visible());
         m_toggleAssistant->setEnabled(enabled);
         m_togglePreview->setChecked(assistantsDecoration()->outlineVisibility());
         m_togglePreview->setEnabled(enabled);
     } else {
         m_toggleAssistant->setEnabled(false);
     }
 
     if (referenceImagesDecoration()) {
        m_toggleReferenceImages->setEnabled(referenceImagesDecoration()->documentHasReferenceImages());
        m_toggleReferenceImages->setChecked(referenceImagesDecoration()->visible());
     }
 }
 
 KisPaintingAssistantsDecorationSP KisDecorationsManager::assistantsDecoration() const
 {
     if (m_imageView) {
         return m_imageView->canvasBase()->paintingAssistantsDecoration();
     }
     return 0;
 }
 
 KisReferenceImagesDecorationSP KisDecorationsManager::referenceImagesDecoration() const
 {
     if (m_imageView) {
         return m_imageView->canvasBase()->referenceImagesDecoration();
     }
     return 0;
 }
 
diff --git a/libs/ui/KisDocument.cpp b/libs/ui/KisDocument.cpp
index b2b8b6cba5..2f81942877 100644
--- a/libs/ui/KisDocument.cpp
+++ b/libs/ui/KisDocument.cpp
@@ -1,1797 +1,1792 @@
 /* This file is part of the Krita project
  *
  * Copyright (C) 2014 Boudewijn Rempt <boud@valdyas.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "KisMainWindow.h" // XXX: remove
 #include <QMessageBox> // XXX: remove
 
 #include <KisMimeDatabase.h>
 
 #include <KoCanvasBase.h>
 #include <KoColor.h>
 #include <KoColorProfile.h>
 #include <KoColorSpaceEngine.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoDocumentInfoDlg.h>
 #include <KoDocumentInfo.h>
 #include <KoDpi.h>
 #include <KoUnit.h>
 #include <KoID.h>
 #include <KoOdfReadStore.h>
 #include <KoProgressProxy.h>
 #include <KoProgressUpdater.h>
 #include <KoSelection.h>
 #include <KoShape.h>
 #include <KoShapeController.h>
 #include <KoStore.h>
 #include <KoUpdater.h>
 #include <KoXmlWriter.h>
 #include <KoXmlReader.h>
 #include <KoStoreDevice.h>
 #include <KoDialog.h>
 
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 #include <kdesktopfile.h>
 #include <kconfiggroup.h>
 #include <QTemporaryFile>
 #include <kbackup.h>
 
 #include <QTextBrowser>
 #include <QApplication>
 #include <QBuffer>
 #include <QStandardPaths>
 #include <QDir>
 #include <QDomDocument>
 #include <QDomElement>
 #include <QFileInfo>
 #include <QImage>
 #include <QList>
 #include <QPainter>
 #include <QRect>
 #include <QScopedPointer>
 #include <QSize>
 #include <QStringList>
 #include <QtGlobal>
 #include <QTimer>
 #include <QWidget>
 #include <QFuture>
 #include <QFutureWatcher>
 
 // Krita Image
 #include <kis_config.h>
 #include <flake/kis_shape_layer.h>
 #include <kis_debug.h>
 #include <kis_group_layer.h>
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <kis_name_server.h>
 #include <kis_paint_layer.h>
 #include <kis_painter.h>
 #include <kis_selection.h>
 #include <kis_fill_painter.h>
 #include <kis_document_undo_store.h>
 #include <kis_idle_watcher.h>
 #include <kis_signal_auto_connection.h>
 #include <kis_debug.h>
 #include <kis_canvas_widget_base.h>
 #include "kis_layer_utils.h"
 
 // Local
 #include "KisViewManager.h"
 #include "kis_clipboard.h"
 #include "widgets/kis_custom_image_widget.h"
 #include "canvas/kis_canvas2.h"
 #include "flake/kis_shape_controller.h"
 #include "kis_statusbar.h"
 #include "widgets/kis_progress_widget.h"
 #include "kis_canvas_resource_provider.h"
 #include "KisResourceServerProvider.h"
 #include "kis_node_manager.h"
 #include "KisPart.h"
 #include "KisApplication.h"
 #include "KisDocument.h"
 #include "KisImportExportManager.h"
 #include "KisPart.h"
 #include "KisView.h"
 #include "kis_grid_config.h"
 #include "kis_guides_config.h"
 #include "kis_image_barrier_lock_adapter.h"
 #include "KisReferenceImagesLayer.h"
 
 #include <mutex>
 #include "kis_config_notifier.h"
 #include "kis_async_action_feedback.h"
 #include "KisCloneDocumentStroke.h"
 
 
 // Define the protocol used here for embedded documents' URL
 // This used to "store" but QUrl didn't like it,
 // so let's simply make it "tar" !
 #define STORE_PROTOCOL "tar"
 // The internal path is a hack to make QUrl happy and for document children
 #define INTERNAL_PROTOCOL "intern"
 #define INTERNAL_PREFIX "intern:/"
 // Warning, keep it sync in koStore.cc
 
 #include <unistd.h>
 
 using namespace std;
 
 namespace {
 constexpr int errorMessageTimeout = 5000;
 constexpr int successMessageTimeout = 1000;
 }
 
 
 /**********************************************************
  *
  * KisDocument
  *
  **********************************************************/
 
 //static
 QString KisDocument::newObjectName()
 {
     static int s_docIFNumber = 0;
     QString name; name.setNum(s_docIFNumber++); name.prepend("document_");
     return name;
 }
 
 
 class UndoStack : public KUndo2Stack
 {
 public:
     UndoStack(KisDocument *doc)
         : KUndo2Stack(doc),
           m_doc(doc)
     {
     }
 
     void setIndex(int idx) override {
         KisImageWSP image = this->image();
         image->requestStrokeCancellation();
         if(image->tryBarrierLock()) {
             KUndo2Stack::setIndex(idx);
             image->unlock();
         }
     }
 
     void notifySetIndexChangedOneCommand() override {
         KisImageWSP image = this->image();
         image->unlock();
 
         /**
          * Some very weird commands may emit blocking signals to
          * the GUI (e.g. KisGuiContextCommand). Here is the best thing
          * we can do to avoid the deadlock
          */
         while(!image->tryBarrierLock()) {
             QApplication::processEvents();
         }
     }
 
     void undo() override {
         KisImageWSP image = this->image();
         image->requestUndoDuringStroke();
 
         if (image->tryUndoUnfinishedLod0Stroke() == UNDO_OK) {
             return;
         }
 
         if(image->tryBarrierLock()) {
             KUndo2Stack::undo();
             image->unlock();
         }
     }
 
     void redo() override {
         KisImageWSP image = this->image();
         if(image->tryBarrierLock()) {
             KUndo2Stack::redo();
             image->unlock();
         }
     }
 
 private:
     KisImageWSP image() {
         KisImageWSP currentImage = m_doc->image();
         Q_ASSERT(currentImage);
         return currentImage;
     }
 
 private:
     KisDocument *m_doc;
 };
 
 class Q_DECL_HIDDEN KisDocument::Private
 {
 public:
     Private(KisDocument *q)
         : docInfo(new KoDocumentInfo(q)) // deleted by QObject
         , importExportManager(new KisImportExportManager(q)) // deleted manually
         , autoSaveTimer(new QTimer(q))
         , undoStack(new UndoStack(q)) // deleted by QObject
         , m_bAutoDetectedMime(false)
         , modified(false)
         , readwrite(true)
         , firstMod(QDateTime::currentDateTime())
         , lastMod(firstMod)
         , nserver(new KisNameServer(1))
         , imageIdleWatcher(2000 /*ms*/)
         , savingLock(&savingMutex)
         , batchMode(false)
     {
         if (QLocale().measurementSystem() == QLocale::ImperialSystem) {
             unit = KoUnit::Inch;
         } else {
             unit = KoUnit::Centimeter;
         }
     }
 
     Private(const Private &rhs, KisDocument *q)
         : docInfo(new KoDocumentInfo(*rhs.docInfo, q))
         , unit(rhs.unit)
         , importExportManager(new KisImportExportManager(q))
         , mimeType(rhs.mimeType)
         , outputMimeType(rhs.outputMimeType)
         , autoSaveTimer(new QTimer(q))
         , undoStack(new UndoStack(q))
         , guidesConfig(rhs.guidesConfig)
         , m_bAutoDetectedMime(rhs.m_bAutoDetectedMime)
         , m_url(rhs.m_url)
         , m_file(rhs.m_file)
         , modified(rhs.modified)
         , readwrite(rhs.readwrite)
         , firstMod(rhs.firstMod)
         , lastMod(rhs.lastMod)
         , nserver(new KisNameServer(*rhs.nserver))
         , preActivatedNode(0) // the node is from another hierarchy!
         , imageIdleWatcher(2000 /*ms*/)
         , assistants(rhs.assistants) // WARNING: assistants should not store pointers to the document!
         , gridConfig(rhs.gridConfig)
         , savingLock(&savingMutex)
         , batchMode(rhs.batchMode)
     {
     }
 
     ~Private() {
         // Don't delete m_d->shapeController because it's in a QObject hierarchy.
         delete nserver;
     }
 
     KoDocumentInfo *docInfo = 0;
 
     KoUnit unit;
 
     KisImportExportManager *importExportManager = 0; // The filter-manager to use when loading/saving [for the options]
 
     QByteArray mimeType; // The actual mimetype of the document
     QByteArray outputMimeType; // The mimetype to use when saving
 
     QTimer *autoSaveTimer;
     QString lastErrorMessage; // see openFile()
     QString lastWarningMessage;
     int autoSaveDelay = 300; // in seconds, 0 to disable.
     bool modifiedAfterAutosave = false;
     bool isAutosaving = false;
     bool disregardAutosaveFailure = false;
     int autoSaveFailureCount = 0;
 
     KUndo2Stack *undoStack = 0;
 
     KisGuidesConfig guidesConfig;
 
     bool m_bAutoDetectedMime = false; // whether the mimetype in the arguments was detected by the part itself
     QUrl m_url; // local url - the one displayed to the user.
     QString m_file; // Local file - the only one the part implementation should deal with.
 
     QMutex savingMutex;
 
     bool modified = false;
     bool readwrite = false;
 
     QDateTime firstMod;
     QDateTime lastMod;
 
     KisNameServer *nserver;
 
     KisImageSP image;
     KisImageSP savingImage;
 
     KisNodeWSP preActivatedNode;
     KisShapeController* shapeController = 0;
     KoShapeController* koShapeController = 0;
     KisIdleWatcher imageIdleWatcher;
     QScopedPointer<KisSignalAutoConnection> imageIdleConnection;
 
     QList<KisPaintingAssistantSP> assistants;
 
     KisSharedPtr<KisReferenceImagesLayer> referenceImagesLayer;
 
     KisGridConfig gridConfig;
 
     StdLockableWrapper<QMutex> savingLock;
 
     bool modifiedWhileSaving = false;
     QScopedPointer<KisDocument> backgroundSaveDocument;
     QPointer<KoUpdater> savingUpdater;
     QFuture<KisImportExportFilter::ConversionStatus> childSavingFuture;
     KritaUtils::ExportFileJob backgroundSaveJob;
 
     bool isRecovered = false;
 
     bool batchMode { false };
 
     void setImageAndInitIdleWatcher(KisImageSP _image) {
         image = _image;
 
         imageIdleWatcher.setTrackedImage(image);
 
         if (image) {
             imageIdleConnection.reset(
                         new KisSignalAutoConnection(
                             &imageIdleWatcher, SIGNAL(startedIdleMode()),
                             image.data(), SLOT(explicitRegenerateLevelOfDetail())));
         }
     }
 
     class StrippedSafeSavingLocker;
 };
 
 class KisDocument::Private::StrippedSafeSavingLocker {
 public:
     StrippedSafeSavingLocker(QMutex *savingMutex, KisImageSP image)
         : m_locked(false)
         , m_image(image)
         , m_savingLock(savingMutex)
         , m_imageLock(image, true)
 
     {
         /**
          * Initial try to lock both objects. Locking the image guards
          * us from any image composition threads running in the
          * background, while savingMutex guards us from entering the
          * saving code twice by autosave and main threads.
          *
          * Since we are trying to lock multiple objects, so we should
          * do it in a safe manner.
          */
         m_locked = std::try_lock(m_imageLock, m_savingLock) < 0;
 
         if (!m_locked) {
             m_image->requestStrokeEnd();
             QApplication::processEvents();
 
             // one more try...
             m_locked = std::try_lock(m_imageLock, m_savingLock) < 0;
         }
     }
 
     ~StrippedSafeSavingLocker() {
          if (m_locked) {
              m_imageLock.unlock();
              m_savingLock.unlock();
          }
      }
 
     bool successfullyLocked() const {
         return m_locked;
     }
 
 private:
     bool m_locked;
     KisImageSP m_image;
     StdLockableWrapper<QMutex> m_savingLock;
     KisImageBarrierLockAdapter m_imageLock;
 };
 
 KisDocument::KisDocument()
     : d(new Private(this))
 {
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
     connect(d->undoStack, SIGNAL(cleanChanged(bool)), this, SLOT(slotUndoStackCleanChanged(bool)));
     connect(d->autoSaveTimer, SIGNAL(timeout()), this, SLOT(slotAutoSave()));
     setObjectName(newObjectName());
 
     // preload the krita resources
     KisResourceServerProvider::instance();
 
     d->shapeController = new KisShapeController(this, d->nserver),
     d->koShapeController = new KoShapeController(0, d->shapeController),
 
     slotConfigChanged();
 }
 
 KisDocument::KisDocument(const KisDocument &rhs)
     : QObject(),
       d(new Private(*rhs.d, this))
 {
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
     connect(d->undoStack, SIGNAL(cleanChanged(bool)), this, SLOT(slotUndoStackCleanChanged(bool)));
     connect(d->autoSaveTimer, SIGNAL(timeout()), this, SLOT(slotAutoSave()));
     setObjectName(rhs.objectName());
 
     d->shapeController = new KisShapeController(this, d->nserver),
     d->koShapeController = new KoShapeController(0, d->shapeController),
 
     slotConfigChanged();
 
     // clone the image with keeping the GUIDs of the layers intact
     // NOTE: we expect the image to be locked!
     setCurrentImage(rhs.image()->clone(true), false);
 
     if (rhs.d->preActivatedNode) {
         // since we clone uuid's, we can use them for lacating new
         // nodes. Otherwise we would need to use findSymmetricClone()
         d->preActivatedNode =
                 KisLayerUtils::findNodeByUuid(d->image->root(), rhs.d->preActivatedNode->uuid());
     }
 }
 
 KisDocument::~KisDocument()
 {
     // wait until all the pending operations are in progress
     waitForSavingToComplete();
 
     /**
      * Push a timebomb, which will try to release the memory after
      * the document has been deleted
      */
     KisPaintDevice::createMemoryReleaseObject()->deleteLater();
 
     d->autoSaveTimer->disconnect(this);
     d->autoSaveTimer->stop();
 
     delete d->importExportManager;
 
     // Despite being QObject they needs to be deleted before the image
     delete d->shapeController;
 
     delete d->koShapeController;
 
     if (d->image) {
         d->image->notifyAboutToBeDeleted();
 
         /**
          * WARNING: We should wait for all the internal image jobs to
          * finish before entering KisImage's destructor. The problem is,
          * while execution of KisImage::~KisImage, all the weak shared
          * pointers pointing to the image enter an inconsistent
          * state(!). The shared counter is already zero and destruction
          * has started, but the weak reference doesn't know about it,
          * because KisShared::~KisShared hasn't been executed yet. So all
          * the threads running in background and having weak pointers will
          * enter the KisImage's destructor as well.
          */
 
         d->image->requestStrokeCancellation();
         d->image->waitForDone();
 
         // clear undo commands that can still point to the image
         d->undoStack->clear();
         d->image->waitForDone();
 
         KisImageWSP sanityCheckPointer = d->image;
         Q_UNUSED(sanityCheckPointer);
 
         // The following line trigger the deletion of the image
         d->image.clear();
 
         // check if the image has actually been deleted
         KIS_SAFE_ASSERT_RECOVER_NOOP(!sanityCheckPointer.isValid());
     }
 
     delete d;
 }
 
 bool KisDocument::reload()
 {
     // XXX: reimplement!
     return false;
 }
 
 KisDocument *KisDocument::clone()
 {
     return new KisDocument(*this);
 }
 
 bool KisDocument::exportDocumentImpl(const KritaUtils::ExportFileJob &job, KisPropertiesConfigurationSP exportConfiguration)
 {
     QFileInfo filePathInfo(job.filePath);
 
     if (filePathInfo.exists() && !filePathInfo.isWritable()) {
         slotCompleteSavingDocument(job,
                                    KisImportExportFilter::CreationError,
                                    i18n("%1 cannot be written to. Please save under a different name.", job.filePath));
         return false;
     }
 
     KisConfig cfg;
     if (cfg.backupFile() && filePathInfo.exists()) {
         KBackup::backupFile(job.filePath);
     }
 
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!job.mimeType.isEmpty(), false);
 
     const QString actionName =
         job.flags & KritaUtils::SaveIsExporting ?
         i18n("Exporting Document...") :
         i18n("Saving Document...");
 
     bool started =
         initiateSavingInBackground(actionName,
                                    this, SLOT(slotCompleteSavingDocument(KritaUtils::ExportFileJob, KisImportExportFilter::ConversionStatus,QString)),
                                    job, exportConfiguration);
 
     if (!started) {
         emit canceled(QString());
     }
 
     return started;
 }
 
 bool KisDocument::exportDocument(const QUrl &url, const QByteArray &mimeType, bool showWarnings, KisPropertiesConfigurationSP exportConfiguration)
 {
     using namespace KritaUtils;
 
     SaveFlags flags = SaveIsExporting;
     if (showWarnings) {
         flags |= SaveShowWarnings;
     }
 
     return exportDocumentImpl(KritaUtils::ExportFileJob(url.toLocalFile(),
                                                         mimeType,
                                                         flags),
                               exportConfiguration);
 
 }
 
 bool KisDocument::saveAs(const QUrl &url, const QByteArray &mimeType, bool showWarnings, KisPropertiesConfigurationSP exportConfiguration)
 {
     using namespace KritaUtils;
 
     return exportDocumentImpl(ExportFileJob(url.toLocalFile(),
                                             mimeType,
                                             showWarnings ? SaveShowWarnings : SaveNone),
                               exportConfiguration);
 }
 
 bool KisDocument::save(bool showWarnings, KisPropertiesConfigurationSP exportConfiguration)
 {
     return saveAs(url(), mimeType(), showWarnings, exportConfiguration);
 }
 
 QByteArray KisDocument::serializeToNativeByteArray()
 {
     QByteArray byteArray;
     QBuffer buffer(&byteArray);
 
     QScopedPointer<KisImportExportFilter> filter(KisImportExportManager::filterForMimeType(nativeFormatMimeType(), KisImportExportManager::Export));
     filter->setBatchMode(true);
     filter->setMimeType(nativeFormatMimeType());
 
     Private::StrippedSafeSavingLocker locker(&d->savingMutex, d->image);
     if (!locker.successfullyLocked()) {
         return byteArray;
     }
 
     d->savingImage = d->image;
 
     if (filter->convert(this, &buffer) != KisImportExportFilter::OK) {
         qWarning() << "serializeToByteArray():: Could not export to our native format";
     }
 
     return byteArray;
 }
 
 void KisDocument::slotCompleteSavingDocument(const KritaUtils::ExportFileJob &job, KisImportExportFilter::ConversionStatus status, const QString &errorMessage)
 {
     if (status == KisImportExportFilter::UserCancelled)
         return;
 
     const QString fileName = QFileInfo(job.filePath).fileName();
 
     if (status != KisImportExportFilter::OK) {
         emit statusBarMessage(i18nc("%1 --- failing file name, %2 --- error message",
                                     "Error during saving %1: %2",
                                     fileName,
                                     exportErrorToUserMessage(status, errorMessage)), errorMessageTimeout);
 
         if (!fileBatchMode()) {
             const QString filePath = job.filePath;
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not save %1\nReason: %2", filePath, errorMessage));
         }
     } else {
         if (!(job.flags & KritaUtils::SaveIsExporting)) {
             setUrl(QUrl::fromLocalFile(job.filePath));
             setLocalFilePath(job.filePath);
             setMimeType(job.mimeType);
             updateEditingTime(true);
 
             if (!d->modifiedWhileSaving) {
                 d->undoStack->setClean();
             }
             setRecovered(false);
             removeAutoSaveFiles();
         }
 
         emit completed();
         emit sigSavingFinished();
 
         emit statusBarMessage(i18n("Finished saving %1", fileName), successMessageTimeout);
     }
 }
 
 QByteArray KisDocument::mimeType() const
 {
     return d->mimeType;
 }
 
 void KisDocument::setMimeType(const QByteArray & mimeType)
 {
     d->mimeType = mimeType;
 }
 
 bool KisDocument::fileBatchMode() const
 {
     return d->batchMode;
 }
 
 void KisDocument::setFileBatchMode(const bool batchMode)
 {
     d->batchMode = batchMode;
 }
 
 KisDocument* KisDocument::lockAndCloneForSaving()
 {
     // force update of all the asynchronous nodes before cloning
     QApplication::processEvents();
     KisLayerUtils::forceAllDelayedNodesUpdate(d->image->root());
 
     KisMainWindow *window = KisPart::instance()->currentMainwindow();
     if (window) {
         if (window->viewManager()) {
             if (!window->viewManager()->blockUntilOperationsFinished(d->image)) {
                 return 0;
             }
         }
     }
 
     Private::StrippedSafeSavingLocker locker(&d->savingMutex, d->image);
     if (!locker.successfullyLocked()) {
         return 0;
     }
 
     return new KisDocument(*this);
 }
 
 bool KisDocument::exportDocumentSync(const QUrl &url, const QByteArray &mimeType, KisPropertiesConfigurationSP exportConfiguration)
 {
     Private::StrippedSafeSavingLocker locker(&d->savingMutex, d->image);
     if (!locker.successfullyLocked()) {
         return false;
     }
 
     d->savingImage = d->image;
 
     const QString fileName = url.toLocalFile();
 
     KisImportExportFilter::ConversionStatus status =
         d->importExportManager->
             exportDocument(fileName, fileName, mimeType, false, exportConfiguration);
 
     d->savingImage = 0;
 
     return status == KisImportExportFilter::OK;
 }
 
 bool KisDocument::initiateSavingInBackground(const QString actionName,
                                              const QObject *receiverObject, const char *receiverMethod,
                                              const KritaUtils::ExportFileJob &job,
                                              KisPropertiesConfigurationSP exportConfiguration)
 {
     return initiateSavingInBackground(actionName, receiverObject, receiverMethod,
                                       job, exportConfiguration, std::unique_ptr<KisDocument>());
 }
 
 bool KisDocument::initiateSavingInBackground(const QString actionName,
                                              const QObject *receiverObject, const char *receiverMethod,
                                              const KritaUtils::ExportFileJob &job,
                                              KisPropertiesConfigurationSP exportConfiguration,
                                              std::unique_ptr<KisDocument> &&optionalClonedDocument)
 {
     KIS_ASSERT_RECOVER_RETURN_VALUE(job.isValid(), false);
 
     QScopedPointer<KisDocument> clonedDocument;
 
     if (!optionalClonedDocument) {
         clonedDocument.reset(lockAndCloneForSaving());
     } else {
         clonedDocument.reset(optionalClonedDocument.release());
     }
 
     // we block saving until the current saving is finished!
     if (!clonedDocument || !d->savingMutex.tryLock()) {
         return false;
     }
 
     KIS_ASSERT_RECOVER_RETURN_VALUE(!d->backgroundSaveDocument, false);
     KIS_ASSERT_RECOVER_RETURN_VALUE(!d->backgroundSaveJob.isValid(), false);
     d->backgroundSaveDocument.reset(clonedDocument.take());
     d->backgroundSaveJob = job;
     d->modifiedWhileSaving = false;
 
     if (d->backgroundSaveJob.flags & KritaUtils::SaveInAutosaveMode) {
         d->backgroundSaveDocument->d->isAutosaving = true;
     }
 
     connect(d->backgroundSaveDocument.data(),
             SIGNAL(sigBackgroundSavingFinished(KisImportExportFilter::ConversionStatus, const QString&)),
             this,
             SLOT(slotChildCompletedSavingInBackground(KisImportExportFilter::ConversionStatus, const QString&)));
 
 
     connect(this, SIGNAL(sigCompleteBackgroundSaving(KritaUtils::ExportFileJob,KisImportExportFilter::ConversionStatus,QString)),
             receiverObject, receiverMethod, Qt::UniqueConnection);
 
     bool started =
         d->backgroundSaveDocument->startExportInBackground(actionName,
                                                            job.filePath,
                                                            job.filePath,
                                                            job.mimeType,
                                                            job.flags & KritaUtils::SaveShowWarnings,
                                                            exportConfiguration);
 
     if (!started) {
         // the state should have been deinitialized in slotChildCompletedSavingInBackground()
 
         KIS_SAFE_ASSERT_RECOVER (!d->backgroundSaveDocument && !d->backgroundSaveJob.isValid()) {
             d->backgroundSaveDocument.take()->deleteLater();
             d->savingMutex.unlock();
             d->backgroundSaveJob = KritaUtils::ExportFileJob();
         }
     }
 
     return started;
 }
 
 
 void KisDocument::slotChildCompletedSavingInBackground(KisImportExportFilter::ConversionStatus status, const QString &errorMessage)
 {
     KIS_SAFE_ASSERT_RECOVER(!d->savingMutex.tryLock()) {
         d->savingMutex.unlock();
         return;
     }
 
     KIS_SAFE_ASSERT_RECOVER_RETURN(d->backgroundSaveDocument);
 
     if (d->backgroundSaveJob.flags & KritaUtils::SaveInAutosaveMode) {
         d->backgroundSaveDocument->d->isAutosaving = false;
     }
 
     d->backgroundSaveDocument.take()->deleteLater();
     d->savingMutex.unlock();
 
     KIS_SAFE_ASSERT_RECOVER_RETURN(d->backgroundSaveJob.isValid());
     const KritaUtils::ExportFileJob job = d->backgroundSaveJob;
     d->backgroundSaveJob = KritaUtils::ExportFileJob();
 
     emit sigCompleteBackgroundSaving(job, status, errorMessage);
 }
 
 void KisDocument::slotAutoSaveImpl(std::unique_ptr<KisDocument> &&optionalClonedDocument)
 {
     if (!d->modified || !d->modifiedAfterAutosave) return;
     const QString autoSaveFileName = generateAutoSaveFileName(localFilePath());
 
     emit statusBarMessage(i18n("Autosaving... %1", autoSaveFileName), successMessageTimeout);
 
     const bool hadClonedDocument = bool(optionalClonedDocument);
     bool started = false;
 
     if (d->image->isIdle() || hadClonedDocument) {
         started = initiateSavingInBackground(i18n("Autosaving..."),
                                              this, SLOT(slotCompleteAutoSaving(KritaUtils::ExportFileJob, KisImportExportFilter::ConversionStatus, const QString&)),
                                              KritaUtils::ExportFileJob(autoSaveFileName, nativeFormatMimeType(), KritaUtils::SaveIsExporting | KritaUtils::SaveInAutosaveMode),
                                              0,
                                              std::move(optionalClonedDocument));
     } else {
         emit statusBarMessage(i18n("Autosaving postponed: document is busy..."), errorMessageTimeout);
     }
 
     if (!started && !hadClonedDocument && d->autoSaveFailureCount >= 3) {
         KisCloneDocumentStroke *stroke = new KisCloneDocumentStroke(this);
         connect(stroke, SIGNAL(sigDocumentCloned(KisDocument*)),
                 this, SLOT(slotInitiateAsyncAutosaving(KisDocument*)),
                 Qt::BlockingQueuedConnection);
 
         KisStrokeId strokeId = d->image->startStroke(stroke);
         d->image->endStroke(strokeId);
 
         setInfiniteAutoSaveInterval();
 
     } else if (!started) {
         setEmergencyAutoSaveInterval();
     } else {
         d->modifiedAfterAutosave = false;
     }
 }
 
 void KisDocument::slotAutoSave()
 {
     slotAutoSaveImpl(std::unique_ptr<KisDocument>());
 }
 
 void KisDocument::slotInitiateAsyncAutosaving(KisDocument *clonedDocument)
 {
     slotAutoSaveImpl(std::unique_ptr<KisDocument>(clonedDocument));
 }
 
 void KisDocument::slotCompleteAutoSaving(const KritaUtils::ExportFileJob &job, KisImportExportFilter::ConversionStatus status, const QString &errorMessage)
 {
     Q_UNUSED(job);
 
     const QString fileName = QFileInfo(job.filePath).fileName();
 
     if (status != KisImportExportFilter::OK) {
         setEmergencyAutoSaveInterval();
         emit statusBarMessage(i18nc("%1 --- failing file name, %2 --- error message",
                                     "Error during autosaving %1: %2",
                                     fileName,
                                     exportErrorToUserMessage(status, errorMessage)), errorMessageTimeout);
     } else {
         KisConfig cfg;
         d->autoSaveDelay = cfg.autoSaveInterval();
 
         if (!d->modifiedWhileSaving) {
             d->autoSaveTimer->stop(); // until the next change
             d->autoSaveFailureCount = 0;
         } else {
             setNormalAutoSaveInterval();
         }
 
         emit statusBarMessage(i18n("Finished autosaving %1", fileName), successMessageTimeout);
     }
 }
 
 bool KisDocument::startExportInBackground(const QString &actionName,
                                           const QString &location,
                                           const QString &realLocation,
                                           const QByteArray &mimeType,
                                           bool showWarnings,
                                           KisPropertiesConfigurationSP exportConfiguration)
 {
     d->savingImage = d->image;
 
     KisMainWindow *window = KisPart::instance()->currentMainwindow();
     if (window) {
         if (window->viewManager()) {
             d->savingUpdater = window->viewManager()->createThreadedUpdater(actionName);
             d->importExportManager->setUpdater(d->savingUpdater);
         }
     }
 
     KisImportExportFilter::ConversionStatus initializationStatus;
     d->childSavingFuture =
         d->importExportManager->exportDocumentAsyc(location,
                                                    realLocation,
                                                    mimeType,
                                                    initializationStatus,
                                                    showWarnings,
                                                    exportConfiguration);
 
     if (initializationStatus != KisImportExportFilter::ConversionStatus::OK) {
         if (d->savingUpdater) {
             d->savingUpdater->cancel();
         }
         d->savingImage.clear();
         emit sigBackgroundSavingFinished(initializationStatus, this->errorMessage());
         return false;
     }
 
     typedef QFutureWatcher<KisImportExportFilter::ConversionStatus> StatusWatcher;
     StatusWatcher *watcher = new StatusWatcher();
     watcher->setFuture(d->childSavingFuture);
 
     connect(watcher, SIGNAL(finished()), SLOT(finishExportInBackground()));
     connect(watcher, SIGNAL(finished()), watcher, SLOT(deleteLater()));
 
     return true;
 }
 
 void KisDocument::finishExportInBackground()
 {
     KIS_SAFE_ASSERT_RECOVER(d->childSavingFuture.isFinished()) {
         emit sigBackgroundSavingFinished(KisImportExportFilter::InternalError, "");
         return;
     }
 
     KisImportExportFilter::ConversionStatus status =
         d->childSavingFuture.result();
     const QString errorMessage = this->errorMessage();
 
     d->savingImage.clear();
     d->childSavingFuture = QFuture<KisImportExportFilter::ConversionStatus>();
     d->lastErrorMessage.clear();
 
     if (d->savingUpdater) {
         d->savingUpdater->setProgress(100);
     }
 
     emit sigBackgroundSavingFinished(status, errorMessage);
 }
 
 void KisDocument::setReadWrite(bool readwrite)
 {
     d->readwrite = readwrite;
     setNormalAutoSaveInterval();
 
     Q_FOREACH (KisMainWindow *mainWindow, KisPart::instance()->mainWindows()) {
         mainWindow->setReadWrite(readwrite);
     }
 }
 
 void KisDocument::setAutoSaveDelay(int delay)
 {
     if (isReadWrite() && delay > 0) {
         d->autoSaveTimer->start(delay * 1000);
     } else {
         d->autoSaveTimer->stop();
     }
 }
 
 void KisDocument::setNormalAutoSaveInterval()
 {
     setAutoSaveDelay(d->autoSaveDelay);
     d->autoSaveFailureCount = 0;
 }
 
 void KisDocument::setEmergencyAutoSaveInterval()
 {
     const int emergencyAutoSaveInterval = 10; /* sec */
     setAutoSaveDelay(emergencyAutoSaveInterval);
     d->autoSaveFailureCount++;
 }
 
 void KisDocument::setInfiniteAutoSaveInterval()
 {
     setAutoSaveDelay(-1);
 }
 
 KoDocumentInfo *KisDocument::documentInfo() const
 {
     return d->docInfo;
 }
 
 bool KisDocument::isModified() const
 {
     return d->modified;
 }
 
 QPixmap KisDocument::generatePreview(const QSize& size)
 {
     KisImageSP image = d->image;
     if (d->savingImage) image = d->savingImage;
 
     if (image) {
         QRect bounds = image->bounds();
         QSize newSize = bounds.size();
         newSize.scale(size, Qt::KeepAspectRatio);
         QPixmap px = QPixmap::fromImage(image->convertToQImage(newSize, 0));
         if (px.size() == QSize(0,0)) {
             px = QPixmap(newSize);
             QPainter gc(&px);
             QBrush checkBrush = QBrush(KisCanvasWidgetBase::createCheckersImage(newSize.width() / 5));
             gc.fillRect(px.rect(), checkBrush);
             gc.end();
         }
         return px;
     }
     return QPixmap(size);
 }
 
 QString KisDocument::generateAutoSaveFileName(const QString & path) const
 {
     QString retval;
 
     // Using the extension allows to avoid relying on the mime magic when opening
     const QString extension (".kra");
     QRegularExpression autosavePattern("^\\..+-autosave.kra$");
 
     QFileInfo fi(path);
     QString dir = fi.absolutePath();
     QString filename = fi.fileName();
 
     if (path.isEmpty() || autosavePattern.match(filename).hasMatch()) {
         // Never saved?
 #ifdef Q_OS_WIN
         // On Windows, use the temp location (https://bugs.kde.org/show_bug.cgi?id=314921)
         retval = QString("%1%2.%3-%4-%5-autosave%6").arg(QDir::tempPath()).arg(QDir::separator()).arg("krita").arg(qApp->applicationPid()).arg(objectName()).arg(extension);
 #else
         // On Linux, use a temp file in $HOME then. Mark it with the pid so two instances don't overwrite each other's autosave file
         retval = QString("%1%2.%3-%4-%5-autosave%6").arg(QDir::homePath()).arg(QDir::separator()).arg("krita").arg(qApp->applicationPid()).arg(objectName()).arg(extension);
 #endif
     } else {
         retval = QString("%1%2.%3-autosave%4").arg(dir).arg(QDir::separator()).arg(filename).arg(extension);
     }
 
     //qDebug() << "generateAutoSaveFileName() for path" << path << ":" << retval;
     return retval;
 }
 
 bool KisDocument::importDocument(const QUrl &_url)
 {
     bool ret;
 
     dbgUI << "url=" << _url.url();
 
     // open...
     ret = openUrl(_url);
 
     // reset url & m_file (kindly? set by KisParts::openUrl()) to simulate a
     // File --> Import
     if (ret) {
         dbgUI << "success, resetting url";
         resetURL();
         setTitleModified();
     }
 
     return ret;
 }
 
 
 bool KisDocument::openUrl(const QUrl &_url, OpenFlags flags)
 {
     if (!_url.isLocalFile()) {
         return false;
     }
     dbgUI << "url=" << _url.url();
     d->lastErrorMessage.clear();
 
     // Reimplemented, to add a check for autosave files and to improve error reporting
     if (!_url.isValid()) {
         d->lastErrorMessage = i18n("Malformed URL\n%1", _url.url());  // ## used anywhere ?
         return false;
     }
 
     QUrl url(_url);
     bool autosaveOpened = false;
     if (url.isLocalFile() && !fileBatchMode()) {
         QString file = url.toLocalFile();
         QString asf = generateAutoSaveFileName(file);
         if (QFile::exists(asf)) {
             KisApplication *kisApp = static_cast<KisApplication*>(qApp);
             kisApp->hideSplashScreen();
             //dbgUI <<"asf=" << asf;
             // ## TODO compare timestamps ?
             int res = QMessageBox::warning(0,
                                            i18nc("@title:window", "Krita"),
                                            i18n("An autosaved file exists for this document.\nDo you want to open the autosaved file instead?"),
                                            QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel, QMessageBox::Yes);
             switch (res) {
             case QMessageBox::Yes :
                 url.setPath(asf);
                 autosaveOpened = true;
                 break;
             case QMessageBox::No :
                 QFile::remove(asf);
                 break;
             default: // Cancel
                 return false;
             }
         }
     }
 
     bool ret = openUrlInternal(url);
 
     if (autosaveOpened || flags & RecoveryFile) {
         setReadWrite(true); // enable save button
         setModified(true);
         setRecovered(true);
     }
     else {
         if (!(flags & DontAddToRecent)) {
             KisPart::instance()->addRecentURLToAllMainWindows(_url);
         }
 
         if (ret) {
             // Detect readonly local-files; remote files are assumed to be writable
             QFileInfo fi(url.toLocalFile());
             setReadWrite(fi.isWritable());
         }
 
         setRecovered(false);
     }
 
     return ret;
 }
 
 class DlgLoadMessages : public KoDialog {
 public:
     DlgLoadMessages(const QString &title, const QString &message, const QStringList &warnings) {
         setWindowTitle(title);
         setWindowIcon(KisIconUtils::loadIcon("warning"));
         QWidget *page = new QWidget(this);
         QVBoxLayout *layout = new QVBoxLayout(page);
         QHBoxLayout *hlayout = new QHBoxLayout();
         QLabel *labelWarning= new QLabel();
         labelWarning->setPixmap(KisIconUtils::loadIcon("warning").pixmap(32, 32));
         hlayout->addWidget(labelWarning);
         hlayout->addWidget(new QLabel(message));
         layout->addLayout(hlayout);
         QTextBrowser *browser = new QTextBrowser();
         QString warning = "<html><body><p><b>";
         if (warnings.size() == 1) {
             warning += "</b> Reason:</p>";
         }
         else {
             warning += "</b> Reasons:</p>";
         }
         warning += "<p/><ul>";
 
         Q_FOREACH(const QString &w, warnings) {
             warning += "\n<li>" + w + "</li>";
         }
         warning += "</ul>";
         browser->setHtml(warning);
         browser->setMinimumHeight(200);
         browser->setMinimumWidth(400);
         layout->addWidget(browser);
         setMainWidget(page);
         setButtons(KoDialog::Ok);
         resize(minimumSize());
     }
 };
 
 bool KisDocument::openFile()
 {
     //dbgUI <<"for" << localFilePath();
     if (!QFile::exists(localFilePath())) {
         QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("File %1 does not exist.", localFilePath()));
         return false;
     }
 
     QString filename = localFilePath();
     QString typeName = mimeType();
 
     if (typeName.isEmpty()) {
         typeName = KisMimeDatabase::mimeTypeForFile(filename);
     }
 
     //qDebug() << "mimetypes 4:" << typeName;
 
     // Allow to open backup files, don't keep the mimetype application/x-trash.
     if (typeName == "application/x-trash") {
         QString path = filename;
         while (path.length() > 0) {
             path.chop(1);
             typeName = KisMimeDatabase::mimeTypeForFile(path);
             //qDebug() << "\t" << path << typeName;
             if (!typeName.isEmpty()) {
                 break;
             }
         }
         //qDebug() << "chopped" << filename  << "to" << path << "Was trash, is" << typeName;
     }
     dbgUI << localFilePath() << "type:" << typeName;
 
     KisMainWindow *window = KisPart::instance()->currentMainwindow();
     if (window && window->viewManager()) {
         KoUpdaterPtr updater = window->viewManager()->createUnthreadedUpdater(i18n("Opening document"));
         d->importExportManager->setUpdater(updater);
     }
 
     KisImportExportFilter::ConversionStatus status;
 
     status = d->importExportManager->importDocument(localFilePath(), typeName);
 
     if (status != KisImportExportFilter::OK) {
         QString msg = KisImportExportFilter::conversionStatusString(status);
         if (!msg.isEmpty()) {
             DlgLoadMessages dlg(i18nc("@title:window", "Krita"),
                                 i18n("Could not open %2.\nReason: %1.", msg, prettyPathOrUrl()),
                                 errorMessage().split("\n") + warningMessage().split("\n"));
             dlg.exec();
         }
         return false;
     }
     else if (!warningMessage().isEmpty()) {
         DlgLoadMessages dlg(i18nc("@title:window", "Krita"),
                             i18n("There were problems opening %1.", prettyPathOrUrl()),
                             warningMessage().split("\n"));
         dlg.exec();
         setUrl(QUrl());
     }
 
     setMimeTypeAfterLoading(typeName);
     emit sigLoadingFinished();
 
     undoStack()->clear();
 
     return true;
 }
 
 // shared between openFile and koMainWindow's "create new empty document" code
 void KisDocument::setMimeTypeAfterLoading(const QString& mimeType)
 {
     d->mimeType = mimeType.toLatin1();
     d->outputMimeType = d->mimeType;
 }
 
 
 bool KisDocument::loadNativeFormat(const QString & file_)
 {
     return openUrl(QUrl::fromLocalFile(file_));
 }
 
 void KisDocument::setModified()
 {
     d->modified = true;
 
 }
 
 void KisDocument::setModified(bool mod)
 {
     if (mod) {
         updateEditingTime(false);
     }
 
     if (d->isAutosaving)   // ignore setModified calls due to autosaving
         return;
 
     if ( !d->readwrite && d->modified ) {
         errKrita << "Can't set a read-only document to 'modified' !" << endl;
         return;
     }
 
     //dbgUI<<" url:" << url.path();
     //dbgUI<<" mod="<<mod<<" MParts mod="<<KisParts::ReadWritePart::isModified()<<" isModified="<<isModified();
 
     if (mod && !d->modifiedAfterAutosave) {
         // First change since last autosave -> start the autosave timer
         setNormalAutoSaveInterval();
     }
     d->modifiedAfterAutosave |= mod;
     d->modifiedWhileSaving |= mod;
 
     if (mod == isModified())
         return;
 
     d->modified = mod;
 
     if (mod) {
         documentInfo()->updateParameters();
     }
 
     // This influences the title
     setTitleModified();
     emit modified(mod);
 }
 
 void KisDocument::setRecovered(bool value)
 {
     d->isRecovered = value;
 }
 
 bool KisDocument::isRecovered() const
 {
     return d->isRecovered;
 }
 
 void KisDocument::updateEditingTime(bool forceStoreElapsed)
 {
     QDateTime now = QDateTime::currentDateTime();
     int firstModDelta = d->firstMod.secsTo(now);
     int lastModDelta = d->lastMod.secsTo(now);
 
     if (lastModDelta > 30) {
         d->docInfo->setAboutInfo("editing-time", QString::number(d->docInfo->aboutInfo("editing-time").toInt() + d->firstMod.secsTo(d->lastMod)));
         d->firstMod = now;
     } else if (firstModDelta > 60 || forceStoreElapsed) {
         d->docInfo->setAboutInfo("editing-time", QString::number(d->docInfo->aboutInfo("editing-time").toInt() + firstModDelta));
         d->firstMod = now;
     }
 
     d->lastMod = now;
 }
 
 QString KisDocument::prettyPathOrUrl() const
 {
     QString _url(url().toDisplayString());
 #ifdef Q_OS_WIN
     if (url().isLocalFile()) {
         _url = QDir::toNativeSeparators(_url);
     }
 #endif
     return _url;
 }
 
 // Get caption from document info (title(), in about page)
 QString KisDocument::caption() const
 {
     QString c;
     const QString _url(url().fileName());
 
     // if URL is empty...it is probably an unsaved file
     if (_url.isEmpty()) {
         c = " [" + i18n("Not Saved") + "] ";
     } else {
         c = _url; // Fall back to document URL
     }
 
     return c;
 }
 
 void KisDocument::setTitleModified()
 {
     emit titleModified(caption(), isModified());
 }
 
 QDomDocument KisDocument::createDomDocument(const QString& tagName, const QString& version) const
 {
     return createDomDocument("krita", tagName, version);
 }
 
 //static
 QDomDocument KisDocument::createDomDocument(const QString& appName, const QString& tagName, const QString& version)
 {
     QDomImplementation impl;
     QString url = QString("http://www.calligra.org/DTD/%1-%2.dtd").arg(appName).arg(version);
     QDomDocumentType dtype = impl.createDocumentType(tagName,
                                                      QString("-//KDE//DTD %1 %2//EN").arg(appName).arg(version),
                                                      url);
     // The namespace URN doesn't need to include the version number.
     QString namespaceURN = QString("http://www.calligra.org/DTD/%1").arg(appName);
     QDomDocument doc = impl.createDocument(namespaceURN, tagName, dtype);
     doc.insertBefore(doc.createProcessingInstruction("xml", "version=\"1.0\" encoding=\"UTF-8\""), doc.documentElement());
     return doc;
 }
 
 bool KisDocument::isNativeFormat(const QByteArray& mimetype) const
 {
     if (mimetype == nativeFormatMimeType())
         return true;
     return extraNativeMimeTypes().contains(mimetype);
 }
 
 void KisDocument::setErrorMessage(const QString& errMsg)
 {
     d->lastErrorMessage = errMsg;
 }
 
 QString KisDocument::errorMessage() const
 {
     return d->lastErrorMessage;
 }
 
 void KisDocument::setWarningMessage(const QString& warningMsg)
 {
     d->lastWarningMessage = warningMsg;
 }
 
 QString KisDocument::warningMessage() const
 {
     return d->lastWarningMessage;
 }
 
 
 void KisDocument::removeAutoSaveFiles()
 {
     //qDebug() << "removeAutoSaveFiles";
     // Eliminate any auto-save file
     QString asf = generateAutoSaveFileName(localFilePath());   // the one in the current dir
     //qDebug() << "\tfilename:" << asf << "exists:" << QFile::exists(asf);
     if (QFile::exists(asf)) {
         //qDebug() << "\tremoving autosavefile" << asf;
         QFile::remove(asf);
     }
     asf = generateAutoSaveFileName(QString());   // and the one in $HOME
     //qDebug() << "Autsavefile in $home" << asf;
     if (QFile::exists(asf)) {
         //qDebug() << "\tremoving autsavefile 2" << asf;
         QFile::remove(asf);
     }
 }
 
 KoUnit KisDocument::unit() const
 {
     return d->unit;
 }
 
 void KisDocument::setUnit(const KoUnit &unit)
 {
     if (d->unit != unit) {
         d->unit = unit;
         emit unitChanged(unit);
     }
 }
 
 KUndo2Stack *KisDocument::undoStack()
 {
     return d->undoStack;
 }
 
 KisImportExportManager *KisDocument::importExportManager() const
 {
     return d->importExportManager;
 }
 
 void KisDocument::addCommand(KUndo2Command *command)
 {
     if (command)
         d->undoStack->push(command);
 }
 
 void KisDocument::beginMacro(const KUndo2MagicString & text)
 {
     d->undoStack->beginMacro(text);
 }
 
 void KisDocument::endMacro()
 {
     d->undoStack->endMacro();
 }
 
 void KisDocument::slotUndoStackCleanChanged(bool value)
 {
     setModified(!value);
 }
 
 void KisDocument::slotConfigChanged()
 {
     KisConfig cfg;
     d->undoStack->setUndoLimit(cfg.undoStackLimit());
     d->autoSaveDelay = cfg.autoSaveInterval();
     setNormalAutoSaveInterval();
 }
 
 void KisDocument::clearUndoHistory()
 {
     d->undoStack->clear();
 }
 
 KisGridConfig KisDocument::gridConfig() const
 {
     return d->gridConfig;
 }
 
 void KisDocument::setGridConfig(const KisGridConfig &config)
 {
     d->gridConfig = config;
 }
 
 const KisGuidesConfig& KisDocument::guidesConfig() const
 {
     return d->guidesConfig;
 }
 
 void KisDocument::setGuidesConfig(const KisGuidesConfig &data)
 {
     if (d->guidesConfig == data) return;
 
     d->guidesConfig = data;
     emit sigGuidesConfigChanged(d->guidesConfig);
 }
 
 void KisDocument::resetURL() {
     setUrl(QUrl());
     setLocalFilePath(QString());
 }
 
 KoDocumentInfoDlg *KisDocument::createDocumentInfoDialog(QWidget *parent, KoDocumentInfo *docInfo) const
 {
     return new KoDocumentInfoDlg(parent, docInfo);
 }
 
 bool KisDocument::isReadWrite() const
 {
     return d->readwrite;
 }
 
 QUrl KisDocument::url() const
 {
     return d->m_url;
 }
 
 bool KisDocument::closeUrl(bool promptToSave)
 {
     if (promptToSave) {
         if ( isReadWrite() && isModified()) {
             Q_FOREACH (KisView *view, KisPart::instance()->views()) {
                 if (view && view->document() == this) {
                     if (!view->queryClose()) {
                         return false;
                     }
                 }
             }
         }
     }
     // Not modified => ok and delete temp file.
     d->mimeType = QByteArray();
 
     // It always succeeds for a read-only part,
     // but the return value exists for reimplementations
     // (e.g. pressing cancel for a modified read-write part)
     return true;
 }
 
 
 
 void KisDocument::setUrl(const QUrl &url)
 {
     d->m_url = url;
 }
 
 QString KisDocument::localFilePath() const
 {
     return d->m_file;
 }
 
 
 void KisDocument::setLocalFilePath( const QString &localFilePath )
 {
     d->m_file = localFilePath;
 }
 
 bool KisDocument::openUrlInternal(const QUrl &url)
 {
     if ( !url.isValid() )
         return false;
 
     if (d->m_bAutoDetectedMime) {
         d->mimeType = QByteArray();
         d->m_bAutoDetectedMime = false;
     }
 
     QByteArray mimetype = d->mimeType;
 
     if ( !closeUrl() )
         return false;
 
     d->mimeType = mimetype;
     setUrl(url);
 
     d->m_file.clear();
 
     if (d->m_url.isLocalFile()) {
         d->m_file = d->m_url.toLocalFile();
         bool ret;
         // set the mimetype only if it was not already set (for example, by the host application)
         if (d->mimeType.isEmpty()) {
             // get the mimetype of the file
             // using findByUrl() to avoid another string -> url conversion
             QString mime = KisMimeDatabase::mimeTypeForFile(d->m_url.toLocalFile());
             d->mimeType = mime.toLocal8Bit();
             d->m_bAutoDetectedMime = true;
         }
 
         setUrl(d->m_url);
         ret = openFile();
 
         if (ret) {
             emit completed();
         } else {
             emit canceled(QString());
         }
         return ret;
     }
     return false;
 }
 
 bool KisDocument::newImage(const QString& name,
                            qint32 width, qint32 height,
                            const KoColorSpace* cs,
                            const KoColor &bgColor, bool backgroundAsLayer,
                            int numberOfLayers,
                            const QString &description, const double imageResolution)
 {
     Q_ASSERT(cs);
 
     KisConfig cfg;
 
     KisImageSP image;
     KisPaintLayerSP layer;
 
     if (!cs) return false;
 
     QApplication::setOverrideCursor(Qt::BusyCursor);
 
     image = new KisImage(createUndoStore(), width, height, cs, name);
 
     Q_CHECK_PTR(image);
 
     connect(image, SIGNAL(sigImageModified()), this, SLOT(setImageModified()), Qt::UniqueConnection);
     image->setResolution(imageResolution, imageResolution);
 
     image->assignImageProfile(cs->profile());
     documentInfo()->setAboutInfo("title", name);
     documentInfo()->setAboutInfo("abstract", description);
 
     layer = new KisPaintLayer(image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8, cs);
     Q_CHECK_PTR(layer);
 
     if (backgroundAsLayer) {
         image->setDefaultProjectionColor(KoColor(cs));
 
         if (bgColor.opacityU8() == OPACITY_OPAQUE_U8) {
             layer->paintDevice()->setDefaultPixel(bgColor);
         } else {
             // Hack: with a semi-transparent background color, the projection isn't composited right if we just set the default pixel
             KisFillPainter painter;
             painter.begin(layer->paintDevice());
             painter.fillRect(0, 0, width, height, bgColor, bgColor.opacityU8());
         }
     } else {
         image->setDefaultProjectionColor(bgColor);
     }
     layer->setDirty(QRect(0, 0, width, height));
 
     image->addNode(layer.data(), image->rootLayer().data());
     setCurrentImage(image);
 
     for(int i = 1; i < numberOfLayers; ++i) {
         KisPaintLayerSP layer = new KisPaintLayer(image, image->nextLayerName(), OPACITY_OPAQUE_U8, cs);
         image->addNode(layer, image->root(), i);
         layer->setDirty(QRect(0, 0, width, height));
     }
 
     cfg.defImageWidth(width);
     cfg.defImageHeight(height);
     cfg.defImageResolution(imageResolution);
     cfg.defColorModel(image->colorSpace()->colorModelId().id());
     cfg.setDefaultColorDepth(image->colorSpace()->colorDepthId().id());
     cfg.defColorProfile(image->colorSpace()->profile()->name());
 
     QApplication::restoreOverrideCursor();
 
     return true;
 }
 
 bool KisDocument::isSaving() const
 {
     const bool result = d->savingMutex.tryLock();
     if (result) {
         d->savingMutex.unlock();
     }
     return !result;
 }
 
 void KisDocument::waitForSavingToComplete()
 {
     if (isSaving()) {
         KisAsyncActionFeedback f(i18nc("progress dialog message when the user closes the document that is being saved", "Waiting for saving to complete..."), 0);
         f.waitForMutex(&d->savingMutex);
     }
 }
 
 KoShapeBasedDocumentBase *KisDocument::shapeController() const
 {
     return d->shapeController;
 }
 
 KoShapeLayer* KisDocument::shapeForNode(KisNodeSP layer) const
 {
     return d->shapeController->shapeForNode(layer);
 }
 
 QList<KisPaintingAssistantSP> KisDocument::assistants() const
 {
     return d->assistants;
 }
 
 void KisDocument::setAssistants(const QList<KisPaintingAssistantSP> &value)
 {
     d->assistants = value;
 }
 
-KisSharedPtr<KisReferenceImagesLayer> KisDocument::getOrCreateReferenceImagesLayer(KisImageSP targetImage)
-{
-    if (!d->referenceImagesLayer) {
-        if (targetImage.isNull()) targetImage = d->image;
-
-        d->referenceImagesLayer = new KisReferenceImagesLayer(shapeController(), targetImage);
-        targetImage->addNode(d->referenceImagesLayer, targetImage->root());
-    }
-
-    return d->referenceImagesLayer;
-}
-
-// TODO: change signature to return a shared pointer
-KisReferenceImagesLayer *KisDocument::referenceImagesLayer() const
+KisSharedPtr<KisReferenceImagesLayer> KisDocument::referenceImagesLayer() const
 {
     return d->referenceImagesLayer.data();
 }
 
-void KisDocument::setReferenceImagesLayer(KisSharedPtr<KisReferenceImagesLayer> layer)
+void KisDocument::setReferenceImagesLayer(KisSharedPtr<KisReferenceImagesLayer> layer, bool updateImage)
 {
+    if (updateImage) {
+        if (layer) {
+            d->image->addNode(layer);
+        } else {
+            d->image->removeNode(d->referenceImagesLayer);
+        }
+    }
+
     d->referenceImagesLayer = layer;
 }
 
 void KisDocument::setPreActivatedNode(KisNodeSP activatedNode)
 {
     d->preActivatedNode = activatedNode;
 }
 
 KisNodeSP KisDocument::preActivatedNode() const
 {
     return d->preActivatedNode;
 }
 
 KisImageWSP KisDocument::image() const
 {
     return d->image;
 }
 
 KisImageSP KisDocument::savingImage() const
 {
     return d->savingImage;
 }
 
 
 void KisDocument::setCurrentImage(KisImageSP image, bool forceInitialUpdate)
 {
     if (d->image) {
         // Disconnect existing sig/slot connections
         d->image->disconnect(this);
         d->shapeController->setImage(0);
         d->image = 0;
     }
 
     if (!image) return;
 
     d->setImageAndInitIdleWatcher(image);
     d->shapeController->setImage(image);
     setModified(false);
     connect(d->image, SIGNAL(sigImageModified()), this, SLOT(setImageModified()), Qt::UniqueConnection);
 
     if (forceInitialUpdate) {
         d->image->initialRefreshGraph();
     }
 }
 
 void KisDocument::hackPreliminarySetImage(KisImageSP image)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(!d->image);
 
     d->setImageAndInitIdleWatcher(image);
     d->shapeController->setImage(image);
 }
 
 void KisDocument::setImageModified()
 {
     setModified(true);
 }
 
 
 KisUndoStore* KisDocument::createUndoStore()
 {
     return new KisDocumentUndoStore(this);
 }
 
 bool KisDocument::isAutosaving() const
 {
     return d->isAutosaving;
 }
 
 QString KisDocument::exportErrorToUserMessage(KisImportExportFilter::ConversionStatus status, const QString &errorMessage)
 {
     return errorMessage.isEmpty() ? KisImportExportFilter::conversionStatusString(status) : errorMessage;
 }
diff --git a/libs/ui/KisDocument.h b/libs/ui/KisDocument.h
index 71232d2df7..95efd93385 100644
--- a/libs/ui/KisDocument.h
+++ b/libs/ui/KisDocument.h
@@ -1,648 +1,641 @@
 /* This file is part of the Krita project
  *
  * Copyright (C) 2014 Boudewijn Rempt <boud@valdyas.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #ifndef KISDOCUMENT_H
 #define KISDOCUMENT_H
 
 #include <QDateTime>
 #include <QTransform>
 #include <QList>
 
 #include <klocalizedstring.h>
 
 #include <KoPageLayout.h>
 #include <KoDocumentBase.h>
 #include <kundo2stack.h>
 
 #include <kis_image.h>
 #include <KisImportExportFilter.h>
 #include <kis_properties_configuration.h>
 #include <kis_types.h>
 #include <kis_painting_assistant.h>
 #include <KisReferenceImage.h>
 #include <kis_debug.h>
 #include <KisImportExportUtils.h>
 
 #include "kritaui_export.h"
 
 #include <memory>
 
 class QString;
 
 class KUndo2Command;
 class KoUnit;
 
 class KoColor;
 class KoColorSpace;
 class KoShapeBasedDocumentBase;
 class KoShapeLayer;
 class KoStore;
 class KoOdfReadStore;
 class KoDocumentInfo;
 class KoDocumentInfoDlg;
 class KisImportExportManager;
 class KisUndoStore;
 class KisPart;
 class KisGridConfig;
 class KisGuidesConfig;
 class QDomDocument;
 class KisReferenceImagesLayer;
 
 #define KIS_MIME_TYPE "application/x-krita"
 
 /**
  *  The %Calligra document class
  *
  *  This class provides some functionality each %Calligra document should have.
  *
  *  @short The %Calligra document class
  */
 class KRITAUI_EXPORT KisDocument : public QObject, public KoDocumentBase
 {
     Q_OBJECT
 
 protected:
 
     explicit KisDocument();
 
     /**
      * @brief KisDocument makes a deep copy of the document \p rhs.
      *        The caller *must* ensure that the image is properly
      *        locked and is in consistent state before asking for
      *        cloning.
      * @param rhs the source document to copy from
      */
     explicit KisDocument(const KisDocument &rhs);
 
 public:
     enum OpenFlag {
         None = 0,
         DontAddToRecent = 0x1,
         RecoveryFile = 0x2
     };
     Q_DECLARE_FLAGS(OpenFlags, OpenFlag)
 
     /**
      *  Destructor.
      *
      * The destructor does not delete any attached KisView objects and it does not
      * delete the attached widget as returned by widget().
      */
     ~KisDocument() override;
 
     /**
      * @brief reload Reloads the document from the original url
      * @return the result of loading the document
      */
     bool reload();
 
 
     /**
      * @brief creates a clone of the document and returns it. Please make sure that you
      * hold all the necessary locks on the image before asking for a clone!
      */
     KisDocument* clone();
 
     /**
      * @brief openUrl Open an URL
      * @param url The URL to open
      * @param flags Control specific behavior
      * @return success status
      */
     bool openUrl(const QUrl &url, OpenFlags flags = None);
 
     /**
      * Opens the document given by @p url, without storing the URL
      * in the KisDocument.
      * Call this instead of openUrl() to implement KisMainWindow's
      * File --> Import feature.
      *
      * @note This will call openUrl(). To differentiate this from an ordinary
      *       Open operation (in any reimplementation of openUrl() or openFile())
      *       call isImporting().
      */
     bool importDocument(const QUrl &url);
 
     /**
      * Saves the document as @p url without changing the state of the
      * KisDocument (URL, modified flag etc.). Call this instead of
      * KisParts::ReadWritePart::saveAs() to implement KisMainWindow's
      * File --> Export feature.
      */
     bool exportDocument(const QUrl &url, const QByteArray &mimeType, bool showWarnings = false, KisPropertiesConfigurationSP exportConfiguration = 0);
 
     bool exportDocumentSync(const QUrl &url, const QByteArray &mimeType, KisPropertiesConfigurationSP exportConfiguration = 0);
 
 private:
     bool exportDocumentImpl(const KritaUtils::ExportFileJob &job, KisPropertiesConfigurationSP exportConfiguration);
 
 public:
     /**
      * @brief Sets whether the document can be edited or is read only.
      *
      * This recursively applied to all child documents and
      * KisView::updateReadWrite is called for every attached
      * view.
      */
     void setReadWrite(bool readwrite = true);
 
     /**
      * To be preferred when a document exists. It is fast when calling
      * it multiple times since it caches the result that readNativeFormatMimeType()
      * delivers.
      * This comes from the X-KDE-NativeMimeType key in the .desktop file.
      */
     static QByteArray nativeFormatMimeType() { return KIS_MIME_TYPE; }
 
     /// Checks whether a given mimetype can be handled natively.
     bool isNativeFormat(const QByteArray& mimetype) const;
 
     /// Returns a list of the mimetypes considered "native", i.e. which can
     /// be saved by KisDocument without a filter, in *addition* to the main one
     static QStringList extraNativeMimeTypes() { return QStringList() << KIS_MIME_TYPE; }
 
     /**
      * Returns the actual mimetype of the document
      */
     QByteArray mimeType() const override;
 
     /**
      * @brief Sets the mime type for the document.
      *
      * When choosing "save as" this is also the mime type
      * selected by default.
      */
     void setMimeType(const QByteArray & mimeType) override;
 
     /**
      * @return true if file operations should inhibit the option dialog
      */
     bool fileBatchMode() const;
 
     /**
      * @param batchMode if true, do not show the option dialog for file operations.
      */
     void setFileBatchMode(const bool batchMode);
 
     /**
      * Sets the error message to be shown to the user (use i18n()!)
      * when loading or saving fails.
      * If you asked the user about something and they chose "Cancel",
      */
     void setErrorMessage(const QString& errMsg);
 
     /**
      * Return the last error message. Usually KisDocument takes care of
      * showing it; this method is mostly provided for non-interactive use.
      */
     QString errorMessage() const;
 
     /**
      * Sets the warning message to be shown to the user (use i18n()!)
      * when loading or saving fails.
      */
     void setWarningMessage(const QString& warningMsg);
 
     /**
      * Return the last warning message set by loading or saving. Warnings
      * mean that the document could not be completely loaded, but the errors
      * were not absolutely fatal.
      */
     QString warningMessage() const;
 
     /**
      * @brief Generates a preview picture of the document
      * @note The preview is used in the File Dialog and also to create the Thumbnail
      */
     QPixmap generatePreview(const QSize& size);
 
     /**
      *  Tells the document that its title has been modified, either because
      *  the modified status changes (this is done by setModified() ) or
      *  because the URL or the document-info's title changed.
      */
     void setTitleModified();
 
     /**
      *  @brief Sets the document to empty.
      *
      *  Used after loading a template
      *  (which is not empty, but not the user's input).
      *
      *  @see isEmpty()
      */
     void setEmpty(bool empty = true);
 
     /**
      *  Return a correctly created QDomDocument for this KisDocument,
      *  including processing instruction, complete DOCTYPE tag (with systemId and publicId), and root element.
      *  @param tagName the name of the tag for the root element
      *  @param version the DTD version (usually the application's version).
      */
     QDomDocument createDomDocument(const QString& tagName, const QString& version) const;
 
     /**
      *  Return a correctly created QDomDocument for an old (1.3-style) %Calligra document,
      *  including processing instruction, complete DOCTYPE tag (with systemId and publicId), and root element.
      *  This static method can be used e.g. by filters.
      *  @param appName the app's instance name, e.g. words, kspread, kpresenter etc.
      *  @param tagName the name of the tag for the root element, e.g. DOC for words/kpresenter.
      *  @param version the DTD version (usually the application's version).
      */
     static QDomDocument createDomDocument(const QString& appName, const QString& tagName, const QString& version);
 
    /**
      *  Loads a document in the native format from a given URL.
      *  Reimplement if your native format isn't XML.
      *
      *  @param file the file to load - usually KReadOnlyPart::m_file or the result of a filter
      */
     bool loadNativeFormat(const QString & file);
 
     /**
      * Set standard autosave interval that is set by a config file
      */
     void setNormalAutoSaveInterval();
 
     /**
      * Set emergency interval that autosave uses when the image is busy,
      * by default it is 10 sec
      */
     void setEmergencyAutoSaveInterval();
 
     /**
      * Disable autosave
      */
     void setInfiniteAutoSaveInterval();
 
     /**
      * @return the information concerning this document.
      * @see KoDocumentInfo
      */
     KoDocumentInfo *documentInfo() const;
 
     /**
      * Performs a cleanup of unneeded backup files
      */
     void removeAutoSaveFiles();
 
     /**
      * Returns true if this document or any of its internal child documents are modified.
      */
     bool isModified() const override;
 
     /**
      * @return caption of the document
      *
      * Caption is of the form "[title] - [url]",
      * built out of the document info (title) and pretty-printed
      * document URL.
      * If the title is not present, only the URL it returned.
      */
     QString caption() const;
 
     /**
      * Sets the document URL to empty URL
      * KParts doesn't allow this, but %Calligra apps have e.g. templates
      * After using loadNativeFormat on a template, one wants
      * to set the url to QUrl()
      */
     void resetURL();
 
     /**
      * @internal (public for KisMainWindow)
      */
     void setMimeTypeAfterLoading(const QString& mimeType);
 
     /**
      * Returns the unit used to display all measures/distances.
      */
     KoUnit unit() const;
 
     /**
      * Sets the unit used to display all measures/distances.
      */
     void setUnit(const KoUnit &unit);
 
     KisGridConfig gridConfig() const;
     void setGridConfig(const KisGridConfig &config);
 
     /// returns the guides data for this document.
     const KisGuidesConfig& guidesConfig() const;
     void setGuidesConfig(const KisGuidesConfig &data);
 
     void clearUndoHistory();
 
 
     /**
      *  Sets the modified flag on the document. This means that it has
      *  to be saved or not before deleting it.
      */
     void setModified(bool _mod);
 
     void setRecovered(bool value);
     bool isRecovered() const;
 
     void updateEditingTime(bool forceStoreElapsed);
 
     /**
      * Returns the global undo stack
      */
     KUndo2Stack *undoStack();
 
 
     /**
      * @brief importExportManager gives access to the internal import/export manager
      * @return the document's import/export manager
      */
     KisImportExportManager *importExportManager() const;
 
     /**
      * @brief serializeToNativeByteArray daves the document into a .kra file wtitten
      * to a memory-based byte-array
      * @return a byte array containing the .kra file
      */
     QByteArray serializeToNativeByteArray();
 
 
     /**
      * @brief isInSaving shown if the document has any (background) saving process or not
      * @return true if there is some saving in action
      */
     bool isInSaving() const;
 
 public Q_SLOTS:
 
     /**
      * Adds a command to the undo stack and executes it by calling the redo() function.
      * @param command command to add to the undo stack
      */
     void addCommand(KUndo2Command *command);
 
     /**
      * Begins recording of a macro command. At the end endMacro needs to be called.
      * @param text command description
      */
     void beginMacro(const KUndo2MagicString &text);
 
     /**
      * Ends the recording of a macro command.
      */
     void endMacro();
 
 Q_SIGNALS:
 
     /**
      * This signal is emitted when the unit is changed by setUnit().
      * It is common to connect views to it, in order to change the displayed units
      * (e.g. in the rulers)
      */
     void unitChanged(const KoUnit &unit);
 
     /**
      * Emitted e.g. at the beginning of a save operation
      * This is emitted by KisDocument and used by KisView to display a statusbar message
      */
     void statusBarMessage(const QString& text, int timeout = 0);
 
     /**
      * Emitted e.g. at the end of a save operation
      * This is emitted by KisDocument and used by KisView to clear the statusbar message
      */
     void clearStatusBarMessage();
 
     /**
     * Emitted when the document is modified
     */
     void modified(bool);
 
     void titleModified(const QString &caption, bool isModified);
 
     void sigLoadingFinished();
 
     void sigSavingFinished();
 
     void sigGuidesConfigChanged(const KisGuidesConfig &config);
 
     void sigBackgroundSavingFinished(KisImportExportFilter::ConversionStatus status, const QString &errorMessage);
 
     void sigCompleteBackgroundSaving(const KritaUtils::ExportFileJob &job, KisImportExportFilter::ConversionStatus status, const QString &errorMessage);
 
 private Q_SLOTS:
     void finishExportInBackground();
     void slotChildCompletedSavingInBackground(KisImportExportFilter::ConversionStatus status, const QString &errorMessage);
     void slotCompleteAutoSaving(const KritaUtils::ExportFileJob &job, KisImportExportFilter::ConversionStatus status, const QString &errorMessage);
 
     void slotCompleteSavingDocument(const KritaUtils::ExportFileJob &job, KisImportExportFilter::ConversionStatus status, const QString &errorMessage);
 
     void slotInitiateAsyncAutosaving(KisDocument *clonedDocument);
 
 private:
 
     friend class KisPart;
     friend class SafeSavingLocker;
 
     bool initiateSavingInBackground(const QString actionName,
                                     const QObject *receiverObject, const char *receiverMethod,
                                     const KritaUtils::ExportFileJob &job,
                                     KisPropertiesConfigurationSP exportConfiguration,
                                     std::unique_ptr<KisDocument> &&optionalClonedDocument);
 
     bool initiateSavingInBackground(const QString actionName,
                                     const QObject *receiverObject, const char *receiverMethod,
                                     const KritaUtils::ExportFileJob &job,
                                     KisPropertiesConfigurationSP exportConfiguration);
 
     bool startExportInBackground(const QString &actionName, const QString &location,
                                  const QString &realLocation,
                                  const QByteArray &mimeType,
                                  bool showWarnings,
                                  KisPropertiesConfigurationSP exportConfiguration);
 
     /**
      * Activate/deactivate/configure the autosave feature.
      * @param delay in seconds, 0 to disable
      */
     void setAutoSaveDelay(int delay);
 
     /**
      * Generate a name for the document.
      */
     QString newObjectName();
 
     QString generateAutoSaveFileName(const QString & path) const;
 
     /**
      *  Loads a document
      *
      *  Applies a filter if necessary, and calls loadNativeFormat in any case
      *  You should not have to reimplement, except for very special cases.
      *
      * NOTE: this method also creates a new KisView instance!
      *
      * This method is called from the KReadOnlyPart::openUrl method.
      */
     bool openFile();
 
     /** @internal */
     void setModified();
 
 public:
 
     bool isAutosaving() const override;
 
 public:
 
     QString localFilePath() const override;
     void setLocalFilePath( const QString &localFilePath );
 
     KoDocumentInfoDlg* createDocumentInfoDialog(QWidget *parent, KoDocumentInfo *docInfo) const;
 
     bool isReadWrite() const;
 
     QUrl url() const override;
     void setUrl(const QUrl &url) override;
 
     bool closeUrl(bool promptToSave = true);
 
     bool saveAs(const QUrl &url, const QByteArray &mimeType, bool showWarnings, KisPropertiesConfigurationSP exportConfigration = 0);
 
     /**
      * Create a new image that has this document as a parent and
      * replace the current image with this image.
      */
     bool newImage(const QString& name, qint32 width, qint32 height, const KoColorSpace * cs, const KoColor &bgColor, bool backgroundAsLayer,
                   int numberOfLayers, const QString &imageDescription, const double imageResolution);
 
     bool isSaving() const;
     void waitForSavingToComplete();
 
 
     KisImageWSP image() const;
 
     /**
      * @brief savingImage provides a detached, shallow copy of the original image that must be used when saving.
      * Any strokes in progress will not be applied to this image, so the result might be missing some data. On
      * the other hand, it won't block.
      *
      * @return a shallow copy of the original image, or 0 is saving is not in progress
      */
     KisImageSP savingImage() const;
 
     /**
      * Set the current image to the specified image and turn undo on.
      */
     void setCurrentImage(KisImageSP image, bool forceInitialUpdate = true);
 
     /**
      * Set the image of the document preliminary, before the document
      * has completed loading. Some of the document items (shapes) may want
      * to access image properties (bounds and resolution), so we should provide
      * it to them even before the entire image is loaded.
      *
      * Right now, the only use by KoShapeRegistry::createShapeFromOdf(), remove
      * after it is deprecated.
      */
     void hackPreliminarySetImage(KisImageSP image);
 
     KisUndoStore* createUndoStore();
 
     /**
      * The shape controller matches internal krita image layers with
      * the flake shape hierarchy.
      */
     KoShapeBasedDocumentBase * shapeController() const;
 
     KoShapeLayer* shapeForNode(KisNodeSP layer) const;
 
     /**
      * Set the list of nodes that was marked as currently active. Used *only*
      * for saving loading. Never use it for tools or processing.
      */
     void setPreActivatedNode(KisNodeSP activatedNode);
 
     /**
      * @return the node that was set as active during loading. Used *only*
      * for saving loading. Never use it for tools or processing.
      */
     KisNodeSP preActivatedNode() const;
 
     /// @return the list of assistants associated with this document
     QList<KisPaintingAssistantSP> assistants() const;
 
     /// @replace the current list of assistants with @param value
     void setAssistants(const QList<KisPaintingAssistantSP> &value);
 
-    /**
-     * Get existing reference images layer or create new if none exists.
-     *
-     * TODO: use setReferenceImagesLayer() combined with undo commands instead
-     */
-    KRITAUI_DEPRECATED KisSharedPtr<KisReferenceImagesLayer> getOrCreateReferenceImagesLayer(KisImageSP targetImage = KisImageSP());
-
     /**
      * Get existing reference images layer or null if none exists.
      */
-    KisReferenceImagesLayer *referenceImagesLayer() const;
+    KisSharedPtr<KisReferenceImagesLayer> referenceImagesLayer() const;
 
-    void setReferenceImagesLayer(KisSharedPtr<KisReferenceImagesLayer> layer);
+    void setReferenceImagesLayer(KisSharedPtr<KisReferenceImagesLayer> layer, bool updateImage);
 
     bool save(bool showWarnings, KisPropertiesConfigurationSP exportConfiguration);
 
 Q_SIGNALS:
 
     void completed();
     void canceled(const QString &);
 
 private Q_SLOTS:
 
     void setImageModified();
 
     void slotAutoSave();
 
     void slotUndoStackCleanChanged(bool value);
 
     void slotConfigChanged();
 
 
 private:
     /**
      * @brief try to clone the image. This method handles all the locking for you. If locking
      *        has failed, no cloning happens
      * @return cloned document on success, null otherwise
      */
     KisDocument *lockAndCloneForSaving();
 
     QString exportErrorToUserMessage(KisImportExportFilter::ConversionStatus status, const QString &errorMessage);
 
     QString prettyPathOrUrl() const;
 
     bool openUrlInternal(const QUrl &url);
 
     void slotAutoSaveImpl(std::unique_ptr<KisDocument> &&optionalClonedDocument);
 
     class Private;
     Private *const d;
 };
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(KisDocument::OpenFlags)
 Q_DECLARE_METATYPE(KisDocument*)
 
 #endif
diff --git a/libs/ui/KisFrameDataSerializer.cpp b/libs/ui/KisFrameDataSerializer.cpp
index 67f637e901..5894face65 100644
--- a/libs/ui/KisFrameDataSerializer.cpp
+++ b/libs/ui/KisFrameDataSerializer.cpp
@@ -1,360 +1,354 @@
 /*
  *  Copyright (c) 2018 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "KisFrameDataSerializer.h"
 
 #include <cstring>
+
 #include <QTemporaryDir>
-#include "tiles3/swap/kis_lzf_compression.h"
+#include <QElapsedTimer>
 
+#include "tiles3/swap/kis_lzf_compression.h"
 
 struct KRITAUI_NO_EXPORT KisFrameDataSerializer::Private
 {
     Private(const QString &frameCachePath)
         : framesDir(
               (!frameCachePath.isEmpty() ? frameCachePath : QDir::tempPath()) +
               QDir::separator() + "KritaFrameCacheXXXXXX")
     {
         KIS_SAFE_ASSERT_RECOVER_NOOP(framesDir.isValid());
         framesDirObject = QDir(framesDir.path());
         framesDirObject.makeAbsolute();
     }
 
     QString subfolderNameForFrame(int frameId)
     {
         const int subfolderIndex = frameId & 0xff00;
         return QString::number(subfolderIndex);
     }
 
     QString fileNameForFrame(int frameId) {
         return QString("frame_%1").arg(frameId);
     }
 
     QString filePathForFrame(int frameId)
     {
         return framesDirObject.filePath(
                     subfolderNameForFrame(frameId) + QDir::separator() +
                     fileNameForFrame(frameId));
     }
 
     int generateFrameId() {
         // TODO: handle wrapping and range compression
         return nextFrameId++;
     }
 
     quint8* getCompressionBuffer(int size) {
         if (compressionBuffer.size() < size) {
             compressionBuffer.resize(size);
         }
         return reinterpret_cast<quint8*>(compressionBuffer.data());
     }
 
     QTemporaryDir framesDir;
     QDir framesDirObject;
     int nextFrameId = 0;
 
     QByteArray compressionBuffer;
 };
 
 KisFrameDataSerializer::KisFrameDataSerializer()
     : KisFrameDataSerializer(QString())
 {
 }
 
 KisFrameDataSerializer::KisFrameDataSerializer(const QString &frameCachePath)
     : m_d(new Private(frameCachePath))
 {
 }
 
 KisFrameDataSerializer::~KisFrameDataSerializer()
 {
 }
 
 int KisFrameDataSerializer::saveFrame(const KisFrameDataSerializer::Frame &frame)
 {
     KisLzfCompression compression;
 
     const int frameId = m_d->generateFrameId();
 
     const QString frameSubfolder = m_d->subfolderNameForFrame(frameId);
 
     if (!m_d->framesDirObject.exists(frameSubfolder)) {
         m_d->framesDirObject.mkpath(frameSubfolder);
     }
 
     const QString frameRelativePath = frameSubfolder + QDir::separator() + m_d->fileNameForFrame(frameId);
 
     if (m_d->framesDirObject.exists(frameRelativePath)) {
         qWarning() << "WARNING: overwriting existing frame file!" << frameRelativePath;
         forgetFrame(frameId);
     }
 
     const QString frameFilePath = m_d->framesDirObject.filePath(frameRelativePath);
 
     QFile file(frameFilePath);
     file.open(QFile::WriteOnly);
 
     QDataStream stream(&file);
     stream << frameId;
     stream << frame.pixelSize;
 
     stream << int(frame.frameTiles.size());
 
     for (int i = 0; i < int(frame.frameTiles.size()); i++) {
         const FrameTile &tile = frame.frameTiles[i];
 
         stream << tile.col;
         stream << tile.row;
         stream << tile.rect;
 
         const int frameByteSize = frame.pixelSize * tile.rect.width() * tile.rect.height();
         const int maxBufferSize = compression.outputBufferSize(frameByteSize);
         quint8 *buffer = m_d->getCompressionBuffer(maxBufferSize);
 
         const int compressedSize =
             compression.compress(tile.data.data(), frameByteSize, buffer, maxBufferSize);
 
         ENTER_FUNCTION() << ppVar(compressedSize) << ppVar(frameByteSize);
 
         const bool isCompressed = compressedSize < frameByteSize;
         stream << isCompressed;
 
         if (isCompressed) {
             stream << compressedSize;
             stream.writeRawData((char*)buffer, compressedSize);
         } else {
             stream << frameByteSize;
             stream.writeRawData((char*)tile.data.data(), frameByteSize);
         }
     }
 
     file.close();
 
     return frameId;
 }
 
-#include "../sdk/tests/testutil.h"
-#include <QElapsedTimer>
-
-TestUtil::MeasureAvgPortion CC(10);
-
 KisFrameDataSerializer::Frame KisFrameDataSerializer::loadFrame(int frameId, KisTextureTileInfoPoolSP pool)
 {
     KisLzfCompression compression;
 
     QElapsedTimer loadingTime;
     loadingTime.start();
 
     int loadedFrameId = -1;
     KisFrameDataSerializer::Frame frame;
 
     qint64 compressionTime = 0;
 
     const QString framePath = m_d->filePathForFrame(frameId);
 
     QFile file(framePath);
     KIS_SAFE_ASSERT_RECOVER_NOOP(file.exists());
     if (!file.open(QFile::ReadOnly)) return frame;
 
     QDataStream stream(&file);
 
     int numTiles = 0;
 
     stream >> loadedFrameId;
     stream >> frame.pixelSize;
     stream >> numTiles;
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(loadedFrameId == frameId, KisFrameDataSerializer::Frame());
 
 
 
     for (int i = 0; i < numTiles; i++) {
         FrameTile tile(pool);
         stream >> tile.col;
         stream >> tile.row;
         stream >> tile.rect;
 
         const int frameByteSize = frame.pixelSize * tile.rect.width() * tile.rect.height();
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(frameByteSize <= pool->chunkSize(frame.pixelSize),
                                              KisFrameDataSerializer::Frame());
 
         bool isCompressed = false;
         int inputSize = -1;
 
         stream >> isCompressed;
         stream >> inputSize;
 
         if (isCompressed) {
             const int maxBufferSize = compression.outputBufferSize(inputSize);
             quint8 *buffer = m_d->getCompressionBuffer(maxBufferSize);
             stream.readRawData((char*)buffer, inputSize);
 
             tile.data.allocate(frame.pixelSize);
 
             QElapsedTimer compTime;
             compTime.start();
 
             const int decompressedSize =
                 compression.decompress(buffer, inputSize, tile.data.data(), frameByteSize);
 
             compressionTime += compTime.nsecsElapsed();
 
             KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(frameByteSize == decompressedSize,
                                                  KisFrameDataSerializer::Frame());
 
         } else {
             KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(frameByteSize == inputSize,
                                                  KisFrameDataSerializer::Frame());
 
             tile.data.allocate(frame.pixelSize);
             stream.readRawData((char*)tile.data.data(), inputSize);
         }
 
         frame.frameTiles.push_back(std::move(tile));
     }
 
     file.close();
 
-    CC.addVal(compressionTime / 1000);
-    CC.addTotal(loadingTime.nsecsElapsed() / 1000);
-
     return frame;
 }
 
 void KisFrameDataSerializer::moveFrame(int srcFrameId, int dstFrameId)
 {
     const QString srcFramePath = m_d->filePathForFrame(srcFrameId);
     const QString dstFramePath = m_d->filePathForFrame(dstFrameId);
     KIS_SAFE_ASSERT_RECOVER_RETURN(QFileInfo(srcFramePath).exists());
 
     KIS_SAFE_ASSERT_RECOVER(!QFileInfo(dstFramePath).exists()) {
         QFile::remove(dstFramePath);
     }
 
     QFile::rename(srcFramePath, dstFramePath);
 }
 
 bool KisFrameDataSerializer::hasFrame(int frameId) const
 {
     const QString framePath = m_d->filePathForFrame(frameId);
     return QFileInfo(framePath).exists();
 }
 
 void KisFrameDataSerializer::forgetFrame(int frameId)
 {
     const QString framePath = m_d->filePathForFrame(frameId);
     QFile::remove(framePath);
 }
 
 boost::optional<qreal> KisFrameDataSerializer::estimateFrameUniqueness(const KisFrameDataSerializer::Frame &lhs, const KisFrameDataSerializer::Frame &rhs, qreal portion)
 {
     if (lhs.pixelSize != rhs.pixelSize) return boost::none;
     if (lhs.frameTiles.size() != rhs.frameTiles.size()) return boost::none;
 
     const int pixelSize = lhs.pixelSize;
     int numSampledPixels = 0;
     int numUniquePixels = 0;
     const int sampleStep = portion > 0.0 ? qMax(1, qRound(1.0 / portion)) : 0;
 
     for (int i = 0; i < int(lhs.frameTiles.size()); i++) {
         const FrameTile &lhsTile = lhs.frameTiles[i];
         const FrameTile &rhsTile = rhs.frameTiles[i];
 
         if (lhsTile.col != rhsTile.col ||
             lhsTile.row != rhsTile.row ||
             lhsTile.rect != rhsTile.rect) {
 
             return boost::none;
         }
 
         if (sampleStep > 0) {
             const int numPixels = lhsTile.rect.width() * lhsTile.rect.height();
             for (int j = 0; j < numPixels; j += sampleStep) {
                 quint8 *lhsDataPtr = lhsTile.data.data() + j * pixelSize;
                 quint8 *rhsDataPtr = rhsTile.data.data() + j * pixelSize;
 
                 if (std::memcmp(lhsDataPtr, rhsDataPtr, pixelSize) != 0) {
                     numUniquePixels++;
                 }
                 numSampledPixels++;
             }
         }
     }
 
     return numSampledPixels > 0 ? qreal(numUniquePixels) / numSampledPixels : 1.0;
 }
 
 template <template <typename U> class OpPolicy, typename T>
 bool processData(T *dst, const T *src, int numUnits)
 {
     OpPolicy<T> op;
 
     bool unitsAreSame = true;
 
     for (int j = 0; j < numUnits; j++) {
         *dst = op(*dst, *src);
 
         if (*dst != 0) {
             unitsAreSame = false;
         }
 
         src++;
         dst++;
     }
     return unitsAreSame;
 }
 
 
 template<template <typename U> class OpPolicy>
 bool KisFrameDataSerializer::processFrames(KisFrameDataSerializer::Frame &dst, const KisFrameDataSerializer::Frame &src)
 {
     bool framesAreSame = true;
 
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(estimateFrameUniqueness(src, dst, 0.0), false);
 
     for (int i = 0; i < int(src.frameTiles.size()); i++) {
         const FrameTile &srcTile = src.frameTiles[i];
         FrameTile &dstTile = dst.frameTiles[i];
 
         const int numBytes = srcTile.rect.width() * srcTile.rect.height() * src.pixelSize;
         const int numQWords = numBytes / 8;
 
         const quint64 *srcDataPtr = reinterpret_cast<const quint64*>(srcTile.data.data());
         quint64 *dstDataPtr = reinterpret_cast<quint64*>(dstTile.data.data());
 
         framesAreSame &= processData<OpPolicy>(dstDataPtr, srcDataPtr, numQWords);
 
 
         const int tailBytes = numBytes % 8;
         const quint8 *srcTailDataPtr = srcTile.data.data() + numBytes - tailBytes;
         quint8 *dstTailDataPtr = dstTile.data.data() + numBytes - tailBytes;
 
         framesAreSame &= processData<OpPolicy>(dstTailDataPtr, srcTailDataPtr, tailBytes);
     }
 
     return framesAreSame;
 }
 
 bool KisFrameDataSerializer::subtractFrames(KisFrameDataSerializer::Frame &dst, const KisFrameDataSerializer::Frame &src)
 {
     return processFrames<std::minus>(dst, src);
 }
 
 void KisFrameDataSerializer::addFrames(KisFrameDataSerializer::Frame &dst, const KisFrameDataSerializer::Frame &src)
 {
     // TODO: don't spend time on calculation of "framesAreSame" in this case
     (void) processFrames<std::plus>(dst, src);
 }
diff --git a/libs/ui/KisImportExportManager.cpp b/libs/ui/KisImportExportManager.cpp
index 09575cbc8b..61947f7cfa 100644
--- a/libs/ui/KisImportExportManager.cpp
+++ b/libs/ui/KisImportExportManager.cpp
@@ -1,629 +1,637 @@
 /*
  * Copyright (C) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "KisImportExportManager.h"
 
 #include <QFile>
 #include <QLabel>
 #include <QVBoxLayout>
 #include <QList>
 #include <QApplication>
 #include <QByteArray>
 #include <QPluginLoader>
 #include <QFileInfo>
 #include <QMessageBox>
 #include <QJsonObject>
 #include <QTextBrowser>
 #include <QCheckBox>
 #include <QSaveFile>
 #include <QGroupBox>
 #include <QFuture>
 #include <QtConcurrent>
 
 #include <klocalizedstring.h>
 #include <ksqueezedtextlabel.h>
 #include <kpluginfactory.h>
 
 #include <KoFileDialog.h>
 #include <kis_icon_utils.h>
 #include <KoDialog.h>
 #include <KoProgressUpdater.h>
 #include <KoJsonTrader.h>
 #include <KisMimeDatabase.h>
 #include <kis_config_widget.h>
 #include <kis_debug.h>
 #include <KisMimeDatabase.h>
 #include <KisPreExportChecker.h>
 #include <KisPart.h>
 #include "kis_config.h"
 #include "KisImportExportFilter.h"
 #include "KisDocument.h"
 #include <kis_image.h>
 #include <kis_paint_layer.h>
 #include "kis_painter.h"
 #include "kis_guides_config.h"
 #include "kis_grid_config.h"
 #include "kis_popup_button.h"
 #include <kis_iterator_ng.h>
 #include "kis_async_action_feedback.h"
 #include "KisReferenceImagesLayer.h"
 
 // static cache for import and export mimetypes
 QStringList KisImportExportManager::m_importMimeTypes;
 QStringList KisImportExportManager::m_exportMimeTypes;
 
 class Q_DECL_HIDDEN KisImportExportManager::Private
 {
 public:
     KoUpdaterPtr updater;
 
     QString cachedExportFilterMimeType;
     QSharedPointer<KisImportExportFilter> cachedExportFilter;
 };
 
 struct KisImportExportManager::ConversionResult {
     ConversionResult()
     {
     }
 
     ConversionResult(const QFuture<KisImportExportFilter::ConversionStatus> &futureStatus)
         : m_isAsync(true),
           m_futureStatus(futureStatus)
     {
     }
 
     ConversionResult(KisImportExportFilter::ConversionStatus status)
         : m_isAsync(false),
           m_status(status)
     {
     }
 
     bool isAsync() const {
         return m_isAsync;
     }
 
     QFuture<KisImportExportFilter::ConversionStatus> futureStatus() const {
         // if the result is not async, then it means some failure happened,
         // just return a cancelled future
         KIS_SAFE_ASSERT_RECOVER_NOOP(m_isAsync || m_status != KisImportExportFilter::OK);
 
         return m_futureStatus;
     }
 
     KisImportExportFilter::ConversionStatus status() const {
         return m_status;
     }
 
     void setStatus(KisImportExportFilter::ConversionStatus value) {
         m_status = value;
     }
 private:
     bool m_isAsync = false;
     QFuture<KisImportExportFilter::ConversionStatus> m_futureStatus;
     KisImportExportFilter::ConversionStatus m_status = KisImportExportFilter::UsageError;
 };
 
 
 KisImportExportManager::KisImportExportManager(KisDocument* document)
     : m_document(document)
     , d(new Private)
 {
 }
 
 KisImportExportManager::~KisImportExportManager()
 {
     delete d;
 }
 
 KisImportExportFilter::ConversionStatus KisImportExportManager::importDocument(const QString& location, const QString& mimeType)
 {
     ConversionResult result = convert(Import, location, location, mimeType, false, 0, false);
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!result.isAsync(), KisImportExportFilter::UsageError);
 
     return result.status();
 }
 
 KisImportExportFilter::ConversionStatus KisImportExportManager::exportDocument(const QString& location, const QString& realLocation, const QByteArray& mimeType, bool showWarnings, KisPropertiesConfigurationSP exportConfiguration)
 {
     ConversionResult result = convert(Export, location, realLocation, mimeType, showWarnings, exportConfiguration, false);
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!result.isAsync(), KisImportExportFilter::UsageError);
 
     return result.status();
 }
 
 QFuture<KisImportExportFilter::ConversionStatus> KisImportExportManager::exportDocumentAsyc(const QString &location, const QString &realLocation, const QByteArray &mimeType, KisImportExportFilter::ConversionStatus &status, bool showWarnings, KisPropertiesConfigurationSP exportConfiguration)
 {
     ConversionResult result = convert(Export, location, realLocation, mimeType, showWarnings, exportConfiguration, true);
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(result.isAsync() ||
                                          result.status() != KisImportExportFilter::OK, QFuture<KisImportExportFilter::ConversionStatus>());
 
     status = result.status();
     return result.futureStatus();
 }
 
 // The static method to figure out to which parts of the
 // graph this mimetype has a connection to.
-QStringList KisImportExportManager::mimeFilter(Direction direction)
+QStringList KisImportExportManager::supportedMimeTypes(Direction direction)
 {
     // Find the right mimetype by the extension
     QSet<QString> mimeTypes;
     //    mimeTypes << KisDocument::nativeFormatMimeType() << "application/x-krita-paintoppreset" << "image/openraster";
 
     if (direction == KisImportExportManager::Import) {
         if (m_importMimeTypes.isEmpty()) {
             QList<QPluginLoader *>list = KoJsonTrader::instance()->query("Krita/FileFilter", "");
             Q_FOREACH(QPluginLoader *loader, list) {
                 QJsonObject json = loader->metaData().value("MetaData").toObject();
                 Q_FOREACH(const QString &mimetype, json.value("X-KDE-Import").toString().split(",", QString::SkipEmptyParts)) {
                     //qDebug() << "Adding  import mimetype" << mimetype << KisMimeDatabase::descriptionForMimeType(mimetype) << "from plugin" << loader;
                     mimeTypes << mimetype;
                 }
             }
             qDeleteAll(list);
             m_importMimeTypes = mimeTypes.toList();
         }
         return m_importMimeTypes;
     }
     else if (direction == KisImportExportManager::Export) {
         if (m_exportMimeTypes.isEmpty()) {
             QList<QPluginLoader *>list = KoJsonTrader::instance()->query("Krita/FileFilter", "");
             Q_FOREACH(QPluginLoader *loader, list) {
                 QJsonObject json = loader->metaData().value("MetaData").toObject();
                 Q_FOREACH(const QString &mimetype, json.value("X-KDE-Export").toString().split(",", QString::SkipEmptyParts)) {
                     //qDebug() << "Adding  export mimetype" << mimetype << KisMimeDatabase::descriptionForMimeType(mimetype) << "from plugin" << loader;
                     mimeTypes << mimetype;
                 }
             }
             qDeleteAll(list);
             m_exportMimeTypes = mimeTypes.toList();
         }
         return m_exportMimeTypes;
     }
     return QStringList();
 }
 
 KisImportExportFilter *KisImportExportManager::filterForMimeType(const QString &mimetype, KisImportExportManager::Direction direction)
 {
     int weight = -1;
     KisImportExportFilter *filter = 0;
     QList<QPluginLoader *>list = KoJsonTrader::instance()->query("Krita/FileFilter", "");
     Q_FOREACH(QPluginLoader *loader, list) {
         QJsonObject json = loader->metaData().value("MetaData").toObject();
         QString directionKey = direction == Export ? "X-KDE-Export" : "X-KDE-Import";
         if (json.value(directionKey).toString().split(",", QString::SkipEmptyParts).contains(mimetype)) {
             KLibFactory *factory = qobject_cast<KLibFactory *>(loader->instance());
 
             if (!factory) {
                 warnUI << loader->errorString();
                 continue;
             }
 
             QObject* obj = factory->create<KisImportExportFilter>(0);
             if (!obj || !obj->inherits("KisImportExportFilter")) {
                 delete obj;
                 continue;
             }
 
             KisImportExportFilter *f = qobject_cast<KisImportExportFilter*>(obj);
             if (!f) {
                 delete obj;
                 continue;
             }
 
             int w = json.value("X-KDE-Weight").toInt();
             if (w > weight) {
                 delete filter;
                 filter = f;
                 f->setObjectName(loader->fileName());
                 weight = w;
             }
         }
     }
     qDeleteAll(list);
     if (filter) {
         filter->setMimeType(mimetype);
     }
     return filter;
 }
 
 bool KisImportExportManager::batchMode(void) const
 {
     return m_document->fileBatchMode();
 }
 
 void KisImportExportManager::setUpdater(KoUpdaterPtr updater)
 {
     d->updater = updater;
 }
 
 QString KisImportExportManager::askForAudioFileName(const QString &defaultDir, QWidget *parent)
 {
     KoFileDialog dialog(parent, KoFileDialog::ImportFiles, "ImportAudio");
 
     if (!defaultDir.isEmpty()) {
         dialog.setDefaultDir(defaultDir);
     }
 
     QStringList mimeTypes;
     mimeTypes << "audio/mpeg";
     mimeTypes << "audio/ogg";
     mimeTypes << "audio/vorbis";
     mimeTypes << "audio/vnd.wave";
     mimeTypes << "audio/flac";
 
     dialog.setMimeTypeFilters(mimeTypes);
     dialog.setCaption(i18nc("@titile:window", "Open Audio"));
 
     return dialog.filename();
 }
 
 KisImportExportManager::ConversionResult KisImportExportManager::convert(KisImportExportManager::Direction direction, const QString &location, const QString& realLocation, const QString &mimeType, bool showWarnings, KisPropertiesConfigurationSP exportConfiguration, bool isAsync)
 {
     // export configuration is supported for export only
     KIS_SAFE_ASSERT_RECOVER_NOOP(direction == Export || !bool(exportConfiguration));
 
 
     QString typeName = mimeType;
     if (typeName.isEmpty()) {
         typeName = KisMimeDatabase::mimeTypeForFile(location, direction == KisImportExportManager::Export ? false : true);
     }
 
     QSharedPointer<KisImportExportFilter> filter;
 
     /**
      * Fetching a filter from the registry is a really expensive operation,
      * because it blocks all the threads. Cache the filter if possible.
      */
     if (direction == KisImportExportManager::Export &&
             d->cachedExportFilter &&
             d->cachedExportFilterMimeType == typeName) {
 
         filter = d->cachedExportFilter;
     } else {
 
         filter = toQShared(filterForMimeType(typeName, direction));
 
         if (direction == Export) {
             d->cachedExportFilter = filter;
             d->cachedExportFilterMimeType = typeName;
         }
     }
 
     if (!filter) {
         return KisImportExportFilter::FilterCreationError;
     }
 
     filter->setFilename(location);
     filter->setRealFilename(realLocation);
     filter->setBatchMode(batchMode());
     filter->setMimeType(typeName);
 
     if (!d->updater.isNull()) {
         // WARNING: The updater is not guaranteed to be persistent! If you ever want
         // to add progress reporting to "Save also as .kra", make sure you create
         // a separate KoProgressUpdater for that!
 
         // WARNING2: the failsafe completion of the updater happens in the destructor
         // the filter.
 
         filter->setUpdater(d->updater);
     }
 
     QByteArray from, to;
     if (direction == Export) {
         from = m_document->nativeFormatMimeType();
         to = typeName.toLatin1();
     }
     else {
         from = typeName.toLatin1();
         to = m_document->nativeFormatMimeType();
     }
 
     KIS_ASSERT_RECOVER_RETURN_VALUE(
                 direction == Import || direction == Export,
                 KisImportExportFilter::BadConversionGraph);
 
 
 
     ConversionResult result = KisImportExportFilter::OK;
     if (direction == Import) {
         // async importing is not yet supported!
         KIS_SAFE_ASSERT_RECOVER_NOOP(!isAsync);
 
         if (0 && !batchMode()) {
             KisAsyncActionFeedback f(i18n("Opening document..."), 0);
             result = f.runAction(std::bind(&KisImportExportManager::doImport, this, location, filter));
         } else {
             result = doImport(location, filter);
         }
     }
     else /* if (direction == Export) */ {
         if (!exportConfiguration) {
             exportConfiguration = filter->lastSavedConfiguration(from, to);
         }
 
         if (exportConfiguration) {
             fillStaticExportConfigurationProperties(exportConfiguration);
         }
 
         bool alsoAsKra = false;
         bool askUser = askUserAboutExportConfiguration(filter, exportConfiguration,
                                                        from, to,
                                                        batchMode(), showWarnings,
                                                        &alsoAsKra);
+
+
         if (!batchMode() && !askUser) {
             return KisImportExportFilter::UserCancelled;
         }
 
         if (isAsync) {
             result = QtConcurrent::run(std::bind(&KisImportExportManager::doExport, this, location, filter, exportConfiguration, alsoAsKra));
 
             // we should explicitly report that the exporting has been initiated
             result.setStatus(KisImportExportFilter::OK);
 
         } else if (!batchMode()) {
             KisAsyncActionFeedback f(i18n("Saving document..."), 0);
             result = f.runAction(std::bind(&KisImportExportManager::doExport, this, location, filter, exportConfiguration, alsoAsKra));
         } else {
             result = doExport(location, filter, exportConfiguration, alsoAsKra);
         }
 
         if (exportConfiguration) {
             KisConfig().setExportConfiguration(typeName, exportConfiguration);
         }
     }
     return result;
 }
 
 void KisImportExportManager::fillStaticExportConfigurationProperties(KisPropertiesConfigurationSP exportConfiguration)
 {
     // Fill with some meta information about the image
     KisImageSP image = m_document->image();
     KisPaintDeviceSP dev = image->projection();
     const KoColorSpace* cs = dev->colorSpace();
     const bool isThereAlpha =
             KisPainter::checkDeviceHasTransparency(image->projection());
 
     exportConfiguration->setProperty(KisImportExportFilter::ImageContainsTransparencyTag, isThereAlpha);
     exportConfiguration->setProperty(KisImportExportFilter::ColorModelIDTag, cs->colorModelId().id());
     exportConfiguration->setProperty(KisImportExportFilter::ColorDepthIDTag, cs->colorDepthId().id());
 
     const bool sRGB =
             (cs->profile()->name().contains(QLatin1String("srgb"), Qt::CaseInsensitive) &&
              !cs->profile()->name().contains(QLatin1String("g10")));
     exportConfiguration->setProperty(KisImportExportFilter::sRGBTag, sRGB);
 }
 
-bool
-KisImportExportManager::askUserAboutExportConfiguration(
+bool KisImportExportManager::askUserAboutExportConfiguration(
         QSharedPointer<KisImportExportFilter> filter,
         KisPropertiesConfigurationSP exportConfiguration,
         const QByteArray &from,
         const QByteArray &to,
         const bool batchMode,
         const bool showWarnings,
         bool *alsoAsKra)
 {
 
+    // prevents the animation renderer from running this code
+
+
     const QString mimeUserDescription = KisMimeDatabase::descriptionForMimeType(to);
 
     QStringList warnings;
     QStringList errors;
 
     {
         KisPreExportChecker checker;
         checker.check(m_document->image(), filter->exportChecks());
 
         warnings = checker.warnings();
         errors = checker.errors();
     }
 
-    KisConfigWidget *wdg = filter->createConfigurationWidget(0, from, to);
+    KisConfigWidget *wdg = 0;
+
+    if (QThread::currentThread() == qApp->thread()) {
+        wdg = filter->createConfigurationWidget(0, from, to);
+    }
 
     // Extra checks that cannot be done by the checker, because the checker only has access to the image.
     if (!m_document->assistants().isEmpty() && to != m_document->nativeFormatMimeType()) {
         warnings.append(i18nc("image conversion warning", "The image contains <b>assistants</b>. The assistants will not be saved."));
     }
     if (m_document->referenceImagesLayer() && m_document->referenceImagesLayer()->shapeCount() > 0 && to != m_document->nativeFormatMimeType()) {
         warnings.append(i18nc("image conversion warning", "The image contains <b>reference images</b>. The reference images will not be saved."));
     }
     if (m_document->guidesConfig().hasGuides() && to != m_document->nativeFormatMimeType()) {
         warnings.append(i18nc("image conversion warning", "The image contains <b>guides</b>. The guides will not be saved."));
     }
     if (!m_document->gridConfig().isDefault() && to != m_document->nativeFormatMimeType()) {
         warnings.append(i18nc("image conversion warning", "The image contains a <b>custom grid configuration</b>. The configuration will not be saved."));
     }
 
     if (!batchMode && !errors.isEmpty()) {
         QString error =  "<html><body><p><b>"
                 + i18n("Error: cannot save this image as a %1.", mimeUserDescription)
                 + "</b> Reasons:</p>"
                 + "<p/><ul>";
         Q_FOREACH(const QString &w, errors) {
             error += "\n<li>" + w + "</li>";
         }
 
         error += "</ul>";
 
         QMessageBox::critical(KisPart::instance()->currentMainwindow(), i18nc("@title:window", "Krita: Export Error"), error);
         return false;
     }
 
     if (!batchMode && (wdg || !warnings.isEmpty())) {
 
         KoDialog dlg;
 
         dlg.setButtons(KoDialog::Ok | KoDialog::Cancel);
         dlg.setWindowTitle(mimeUserDescription);
 
         QWidget *page = new QWidget(&dlg);
         QVBoxLayout *layout = new QVBoxLayout(page);
 
         if (showWarnings && !warnings.isEmpty()) {
             QHBoxLayout *hLayout = new QHBoxLayout();
 
             QLabel *labelWarning = new QLabel();
             labelWarning->setPixmap(KisIconUtils::loadIcon("warning").pixmap(32, 32));
             hLayout->addWidget(labelWarning);
 
             KisPopupButton *bn = new KisPopupButton(0);
 
             bn->setText(i18nc("Keep the extra space at the end of the sentence, please", "Warning: saving as %1 will lose information from your image.    ", mimeUserDescription));
 
             hLayout->addWidget(bn);
 
             layout->addLayout(hLayout);
 
             QTextBrowser *browser = new QTextBrowser();
             browser->setMinimumWidth(bn->width());
             bn->setPopupWidget(browser);
 
             QString warning = "<html><body><p><b>"
                     + i18n("You will lose information when saving this image as a %1.", mimeUserDescription);
 
             if (warnings.size() == 1) {
                 warning += "</b> Reason:</p>";
             }
             else {
                 warning += "</b> Reasons:</p>";
             }
             warning += "<p/><ul>";
 
             Q_FOREACH(const QString &w, warnings) {
                 warning += "\n<li>" + w + "</li>";
             }
 
             warning += "</ul>";
             browser->setHtml(warning);
         }
 
         if (wdg) {
             QGroupBox *box = new QGroupBox(i18n("Options"));
             QVBoxLayout *boxLayout = new QVBoxLayout(box);
             wdg->setConfiguration(exportConfiguration);
             boxLayout->addWidget(wdg);
             layout->addWidget(box);
         }
 
         QCheckBox *chkAlsoAsKra = 0;
         if (showWarnings && !warnings.isEmpty()) {
             chkAlsoAsKra = new QCheckBox(i18n("Also save your image as a Krita file."));
             chkAlsoAsKra->setChecked(KisConfig().readEntry<bool>("AlsoSaveAsKra", false));
             layout->addWidget(chkAlsoAsKra);
         }
 
         dlg.setMainWidget(page);
         dlg.resize(dlg.minimumSize());
 
         if (showWarnings || wdg) {
             if (!dlg.exec()) {
                 return false;
             }
         }
 
         *alsoAsKra = false;
         if (chkAlsoAsKra) {
             KisConfig().writeEntry<bool>("AlsoSaveAsKra", chkAlsoAsKra->isChecked());
             *alsoAsKra = chkAlsoAsKra->isChecked();
         }
 
         if (wdg) {
             *exportConfiguration = *wdg->configuration();
         }
     }
 
     return true;
 }
 
 KisImportExportFilter::ConversionStatus KisImportExportManager::doImport(const QString &location, QSharedPointer<KisImportExportFilter> filter)
 {
     QFile file(location);
     if (!file.exists()) {
         return KisImportExportFilter::FileNotFound;
     }
 
     if (filter->supportsIO() && !file.open(QFile::ReadOnly)) {
         return KisImportExportFilter::FileNotFound;
     }
 
     KisImportExportFilter::ConversionStatus status =
             filter->convert(m_document, &file, KisPropertiesConfigurationSP());
 
     if (file.isOpen()) {
         file.close();
     }
 
     return status;
 }
 
 KisImportExportFilter::ConversionStatus KisImportExportManager::doExport(const QString &location, QSharedPointer<KisImportExportFilter> filter, KisPropertiesConfigurationSP exportConfiguration, bool alsoAsKra)
 {
     KisImportExportFilter::ConversionStatus status =
             doExportImpl(location, filter, exportConfiguration);
 
     if (alsoAsKra && status == KisImportExportFilter::OK) {
         QString kraLocation = location + ".kra";
         QByteArray mime = m_document->nativeFormatMimeType();
         QSharedPointer<KisImportExportFilter> filter(
                     filterForMimeType(QString::fromLatin1(mime), Export));
 
         KIS_SAFE_ASSERT_RECOVER_NOOP(filter);
 
         if (filter) {
             filter->setFilename(kraLocation);
 
             KisPropertiesConfigurationSP kraExportConfiguration =
                     filter->lastSavedConfiguration(mime, mime);
 
             status = doExportImpl(kraLocation, filter, kraExportConfiguration);
         } else {
             status = KisImportExportFilter::FilterCreationError;
         }
     }
 
     return status;
 }
 
 KisImportExportFilter::ConversionStatus KisImportExportManager::doExportImpl(const QString &location, QSharedPointer<KisImportExportFilter> filter, KisPropertiesConfigurationSP exportConfiguration)
 {
     QSaveFile file(location);
     file.setDirectWriteFallback(true);
 
     if (filter->supportsIO() && !file.open(QFile::WriteOnly)) {
         file.cancelWriting();
         return KisImportExportFilter::CreationError;
     }
 
     KisImportExportFilter::ConversionStatus status =
             filter->convert(m_document, &file, exportConfiguration);
 
     if (filter->supportsIO()) {
         if (status != KisImportExportFilter::OK) {
             file.cancelWriting();
         } else {
             if (!file.commit()) {
                 status = KisImportExportFilter::CreationError;
             }
         }
     }
     return status;
 
 }
 
 #include <KisMimeDatabase.h>
diff --git a/libs/ui/KisImportExportManager.h b/libs/ui/KisImportExportManager.h
index 93c0912bf1..775a9d34ca 100644
--- a/libs/ui/KisImportExportManager.h
+++ b/libs/ui/KisImportExportManager.h
@@ -1,152 +1,152 @@
 /*
  * Copyright (C) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_IMPORT_EXPORT_MANAGER_H
 #define KIS_IMPORT_EXPORT_MANAGER_H
 
 #include <QObject>
 #include <QMap>
 #include <QByteArray>
 #include <QUrl>
 
 #include "KisImportExportFilter.h"
 
 #include "kritaui_export.h"
 
 class KisDocument;
 class KoProgressUpdater;
 
 template <class T>
 class QFuture;
 
 /**
  *  @brief The class managing all the filters.
  *
  *  This class manages all filters for a %Calligra application. Normally
  *  you will not have to use it, since KisMainWindow takes care of loading
  *  and saving documents.
  *
  *  @ref KisFilter
  *
  *  @author Kalle Dalheimer <kalle@kde.org>
  *  @author Torben Weis <weis@kde.org>
  *  @author Werner Trobin <trobin@kde.org>
  */
 class KRITAUI_EXPORT KisImportExportManager : public QObject
 {
     Q_OBJECT
 public:
     /**
      * This enum is used to distinguish the import/export cases
      */
     enum Direction { Import = 1,  Export = 2 };
 
     /**
      * Create a filter manager for a document
      */
     explicit KisImportExportManager(KisDocument *document);
 
 public:
 
     ~KisImportExportManager() override;
 
     /**
      * Imports the specified document and returns the resultant filename
      * (most likely some file in /tmp).
      * @p path can be either a URL or a filename.
      * @p documentMimeType gives importDocument a hint about what type
      * the document may be. It can be left empty.
      *
      * @return  status signals the success/error of the conversion.
      * If the QString which is returned isEmpty() and the status is OK,
      * then we imported the file directly into the document.
      */
     KisImportExportFilter::ConversionStatus importDocument(const QString &location, const QString &mimeType);
 
     /**
      * @brief Exports the given file/document to the specified URL/mimetype.
      *
      * If @p mimeType is empty, then the closest matching Calligra part is searched
      * and when the method returns @p mimeType contains this mimetype.
      * Oh, well, export is a C++ keyword ;)
      */
     KisImportExportFilter::ConversionStatus exportDocument(const QString &location, const QString& realLocation, const QByteArray &mimeType, bool showWarnings = true, KisPropertiesConfigurationSP exportConfiguration = 0);
 
     QFuture<KisImportExportFilter::ConversionStatus> exportDocumentAsyc(const QString &location, const QString& realLocation, const QByteArray &mimeType, KisImportExportFilter::ConversionStatus &status, bool showWarnings = true, KisPropertiesConfigurationSP exportConfiguration = 0);
 
     ///@name Static API
     //@{
     /**
      * Suitable for passing to KoFileDialog::setMimeTypeFilters. The default mime
      * gets set by the "users" of this method, as we do not have enough
      * information here.
      * Optionally, @p extraNativeMimeTypes are added after the native mimetype.
      */
-    static QStringList mimeFilter(Direction direction);
+    static QStringList supportedMimeTypes(Direction direction);
 
     /**
      * @brief filterForMimeType loads the relevant import/export plugin and returns it. The caller
      * is responsible for deleting it!
      * @param mimetype the mimetype we want to import/export. If there's more than one plugin, the one
      * with the highest weight as defined in the json description will be taken
      * @param direction import or export
      * @return a pointer to the filter plugin or 0 if none could be found
      */
     static KisImportExportFilter *filterForMimeType(const QString &mimetype, Direction direction);
 
     /**
      * Get if the filter manager is batch mode (true)
      * or in interactive mode (true)
      */
     bool batchMode(void) const;
 
     void setUpdater(KoUpdaterPtr updater);
 
     static QString askForAudioFileName(const QString &defaultDir, QWidget *parent);
 
 
 private:
 
     struct ConversionResult;
     ConversionResult convert(Direction direction, const QString &location, const QString& realLocation, const QString &mimeType, bool showWarnings, KisPropertiesConfigurationSP exportConfiguration, bool isAsync);
 
 
     void fillStaticExportConfigurationProperties(KisPropertiesConfigurationSP exportConfiguration);
     bool askUserAboutExportConfiguration(QSharedPointer<KisImportExportFilter> filter, KisPropertiesConfigurationSP exportConfiguration, const QByteArray &from, const QByteArray &to, bool batchMode, const bool showWarnings, bool *alsoAsKra);
 
     KisImportExportFilter::ConversionStatus doImport(const QString &location, QSharedPointer<KisImportExportFilter> filter);
 
     KisImportExportFilter::ConversionStatus doExport(const QString &location, QSharedPointer<KisImportExportFilter> filter, KisPropertiesConfigurationSP exportConfiguration, bool alsoAsKra);
     KisImportExportFilter::ConversionStatus doExportImpl(const QString &location, QSharedPointer<KisImportExportFilter> filter, KisPropertiesConfigurationSP exportConfiguration);
 
     // Private API
     KisImportExportManager(const KisImportExportManager& rhs);
     KisImportExportManager &operator=(const KisImportExportManager& rhs);
 
     KisDocument *m_document;
 
     /// A static cache for the availability checks of filters
     static QStringList m_importMimeTypes;
     static QStringList m_exportMimeTypes;
 
     class Private;
     Private * const d;
 };
 
 #endif  // __KO_FILTER_MANAGER_H__
diff --git a/libs/ui/KisMainWindow.cpp b/libs/ui/KisMainWindow.cpp
index e12c826303..b6ea314efc 100644
--- a/libs/ui/KisMainWindow.cpp
+++ b/libs/ui/KisMainWindow.cpp
@@ -1,2591 +1,2590 @@
 /* This file is part of the KDE project
    Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
    Copyright (C) 2000-2006 David Faure <faure@kde.org>
    Copyright (C) 2007, 2009 Thomas zander <zander@kde.org>
    Copyright (C) 2010 Benjamin Port <port.benjamin@gmail.com>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #include "KisMainWindow.h"
 
 #include <KoConfig.h>
 
 // qt includes
 #include <QApplication>
 #include <QByteArray>
 #include <QCloseEvent>
 #include <QStandardPaths>
 #include <QDesktopServices>
 #include <QDesktopServices>
 #include <QDesktopWidget>
 #include <QDialog>
 #include <QDockWidget>
 #include <QIcon>
 #include <QInputDialog>
 #include <QLabel>
 #include <QLayout>
 #include <QMdiArea>
 #include <QMdiSubWindow>
 #include <QMutex>
 #include <QMutexLocker>
 #include <QPointer>
 #include <QPrintDialog>
 #include <QPrinter>
 #include <QPrintPreviewDialog>
 #include <QToolButton>
 #include <QSignalMapper>
 #include <QTabBar>
 #include <QMoveEvent>
 #include <QUrl>
 #include <QMessageBox>
 #include <QTemporaryFile>
 #include <QStatusBar>
 #include <QMenu>
 #include <QMenuBar>
 #include <KisMimeDatabase.h>
 #include <QMimeData>
 
 #include <kactioncollection.h>
 #include <QAction>
 #include <kactionmenu.h>
 #include <kis_debug.h>
 #include <kedittoolbar.h>
 #include <khelpmenu.h>
 #include <klocalizedstring.h>
 #include <kaboutdata.h>
 #include <kis_workspace_resource.h>
 #include <input/kis_input_manager.h>
 
 #ifdef HAVE_KIO
 #include <krecentdocument.h>
 #endif
 #include <krecentfilesaction.h>
 #include <KoResourcePaths.h>
 #include <ktoggleaction.h>
 #include <ktoolbar.h>
 #include <kmainwindow.h>
 #include <kxmlguiwindow.h>
 #include <kxmlguifactory.h>
 #include <kxmlguiclient.h>
 #include <kguiitem.h>
 #include <kwindowconfig.h>
 #include <kformat.h>
 
 #include "KoDockFactoryBase.h"
 #include "KoDocumentInfoDlg.h"
 #include "KoDocumentInfo.h"
 #include "KoFileDialog.h"
 #include <kis_icon.h>
 #include <KoPageLayoutDialog.h>
 #include <KoPageLayoutWidget.h>
 #include <KoToolManager.h>
 #include <KoZoomController.h>
 #include "KoToolDocker.h"
 #include <KoToolBoxFactory.h>
 #include <KoDockRegistry.h>
 #include <KoPluginLoader.h>
 #include <KoColorSpaceEngine.h>
 #include <KoUpdater.h>
 #include <KoResourceModel.h>
 
 #include <KisMimeDatabase.h>
 #include <brushengine/kis_paintop_settings.h>
 #include "dialogs/kis_about_application.h"
 #include "dialogs/kis_delayed_save_dialog.h"
 #include "dialogs/kis_dlg_preferences.h"
 #include "kis_action.h"
 #include "kis_action_manager.h"
 #include "KisApplication.h"
 #include "kis_canvas2.h"
 #include "kis_canvas_controller.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_clipboard.h"
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_custom_image_widget.h"
 #include <KisDocument.h>
 #include "kis_group_layer.h"
 #include "kis_icon_utils.h"
 #include "kis_image_from_clipboard_widget.h"
 #include "kis_image.h"
 #include <KisImportExportFilter.h>
 #include "KisImportExportManager.h"
 #include "kis_mainwindow_observer.h"
 #include "kis_memory_statistics_server.h"
 #include "kis_node.h"
 #include "KisOpenPane.h"
 #include "kis_paintop_box.h"
 #include "KisPart.h"
 #include "KisPrintJob.h"
 #include "KisResourceServerProvider.h"
 #include "kis_signal_compressor_with_param.h"
 #include "kis_statusbar.h"
 #include "KisView.h"
 #include "KisViewManager.h"
 #include "thememanager.h"
 #include "kis_animation_importer.h"
 #include "dialogs/kis_dlg_import_image_sequence.h"
 #include <KisUpdateSchedulerConfigNotifier.h>
 #include "KisWindowLayoutManager.h"
 #include <KisUndoActionsUpdateManager.h>
 
 #include <mutex>
 
 #ifdef Q_OS_WIN
   #include <QtPlatformHeaders/QWindowsWindowFunctions>
 #endif
 
 class ToolDockerFactory : public KoDockFactoryBase
 {
 public:
     ToolDockerFactory() : KoDockFactoryBase() { }
 
     QString id() const override {
         return "sharedtooldocker";
     }
 
     QDockWidget* createDockWidget() override {
         KoToolDocker* dockWidget = new KoToolDocker();
-        dockWidget->setTabEnabled(false);
         return dockWidget;
     }
 
     DockPosition defaultDockPosition() const override {
         return DockRight;
     }
 };
 
 class Q_DECL_HIDDEN KisMainWindow::Private
 {
 public:
     Private(KisMainWindow *parent, QUuid id)
         : q(parent)
         , id(id)
         , dockWidgetMenu(new KActionMenu(i18nc("@action:inmenu", "&Dockers"), parent))
         , windowMenu(new KActionMenu(i18nc("@action:inmenu", "&Window"), parent))
         , documentMenu(new KActionMenu(i18nc("@action:inmenu", "New &View"), parent))
         , workspaceMenu(new KActionMenu(i18nc("@action:inmenu", "Wor&kspace"), parent))
         , mdiArea(new QMdiArea(parent))
         , windowMapper(new QSignalMapper(parent))
         , documentMapper(new QSignalMapper(parent))
     {
         if (id.isNull()) this->id = QUuid::createUuid();
         mdiArea->setTabsMovable(true);
         mdiArea->setActivationOrder(QMdiArea::ActivationHistoryOrder);
     }
 
     ~Private() {
         qDeleteAll(toolbarList);
     }
 
     KisMainWindow *q {0};
     QUuid id;
 
     KisViewManager *viewManager {0};
 
     QPointer<KisView> activeView;
 
     QList<QAction *> toolbarList;
 
     bool firstTime {true};
     bool windowSizeDirty {false};
     bool readOnly {false};
 
     KisAction *showDocumentInfo {0};
     KisAction *saveAction {0};
     KisAction *saveActionAs {0};
 //    KisAction *printAction;
 //    KisAction *printActionPreview;
 //    KisAction *exportPdf {0};
     KisAction *importAnimation {0};
     KisAction *closeAll {0};
 //    KisAction *reloadFile;
     KisAction *importFile {0};
     KisAction *exportFile {0};
     KisAction *undo {0};
     KisAction *redo {0};
     KisAction *newWindow {0};
     KisAction *close {0};
     KisAction *mdiCascade {0};
     KisAction *mdiTile {0};
     KisAction *mdiNextWindow {0};
     KisAction *mdiPreviousWindow {0};
     KisAction *toggleDockers {0};
     KisAction *toggleDockerTitleBars {0};
     KisAction *fullScreenMode {0};
     KisAction *showSessionManager {0};
 
     KisAction *expandingSpacers[2];
 
     KActionMenu *dockWidgetMenu;
     KActionMenu *windowMenu;
     KActionMenu *documentMenu;
     KActionMenu *workspaceMenu;
 
     KHelpMenu *helpMenu  {0};
 
     KRecentFilesAction *recentFiles {0};
     KoResourceModel *workspacemodel {0};
 
     QScopedPointer<KisUndoActionsUpdateManager> undoActionsUpdateManager;
 
     QString lastExportLocation;
 
     QMap<QString, QDockWidget *> dockWidgetsMap;
     QByteArray dockerStateBeforeHiding;
     KoToolDocker *toolOptionsDocker {0};
 
     QCloseEvent *deferredClosingEvent {0};
 
     Digikam::ThemeManager *themeManager {0};
 
     QMdiArea *mdiArea;
     QMdiSubWindow *activeSubWindow  {0};
     QSignalMapper *windowMapper;
     QSignalMapper *documentMapper;
 
     QByteArray lastExportedFormat;
     QScopedPointer<KisSignalCompressorWithParam<int> > tabSwitchCompressor;
     QMutex savingEntryMutex;
 
     KConfigGroup windowStateConfig;
 
     QUuid workspaceBorrowedBy;
 
     KisActionManager * actionManager() {
         return viewManager->actionManager();
     }
 
     QTabBar* findTabBarHACK() {
         QObjectList objects = mdiArea->children();
         Q_FOREACH (QObject *object, objects) {
             QTabBar *bar = qobject_cast<QTabBar*>(object);
             if (bar) {
                 return bar;
             }
         }
         return 0;
     }
 };
 
 KisMainWindow::KisMainWindow(QUuid uuid)
     : KXmlGuiWindow()
     , d(new Private(this, uuid))
 {
     auto rserver = KisResourceServerProvider::instance()->workspaceServer();
     QSharedPointer<KoAbstractResourceServerAdapter> adapter(new KoResourceServerAdapter<KisWorkspaceResource>(rserver));
     d->workspacemodel = new KoResourceModel(adapter, this);
     connect(d->workspacemodel, &KoResourceModel::afterResourcesLayoutReset, this, [&]() { updateWindowMenu(); });
 
     KisConfig cfg;
 
     d->viewManager = new KisViewManager(this, actionCollection());
     KConfigGroup group( KSharedConfig::openConfig(), "theme");
     d->themeManager = new Digikam::ThemeManager(group.readEntry("Theme", "Krita dark"), this);
 
     d->windowStateConfig = KSharedConfig::openConfig()->group("MainWindow");
 
     setAcceptDrops(true);
     setStandardToolBarMenuEnabled(true);
     setTabPosition(Qt::AllDockWidgetAreas, QTabWidget::North);
     setDockNestingEnabled(true);
 
     qApp->setStartDragDistance(25);     // 25 px is a distance that works well for Tablet and Mouse events
 
 #ifdef Q_OS_OSX
     setUnifiedTitleAndToolBarOnMac(true);
 #endif
 
     connect(this, SIGNAL(restoringDone()), this, SLOT(forceDockTabFonts()));
     connect(this, SIGNAL(themeChanged()), d->viewManager, SLOT(updateIcons()));
     connect(KisPart::instance(), SIGNAL(documentClosed(QString)), SLOT(updateWindowMenu()));
     connect(KisPart::instance(), SIGNAL(documentOpened(QString)), SLOT(updateWindowMenu()));
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), this, SLOT(configChanged()));
 
     actionCollection()->addAssociatedWidget(this);
 
     KoPluginLoader::instance()->load("Krita/ViewPlugin", "Type == 'Service' and ([X-Krita-Version] == 28)", KoPluginLoader::PluginsConfig(), d->viewManager, false);
 
     // Load the per-application plugins (Right now, only Python) We do this only once, when the first mainwindow is being created.
     KoPluginLoader::instance()->load("Krita/ApplicationPlugin", "Type == 'Service' and ([X-Krita-Version] == 28)", KoPluginLoader::PluginsConfig(), qApp, true);
 
     KoToolBoxFactory toolBoxFactory;
     QDockWidget *toolbox = createDockWidget(&toolBoxFactory);
     toolbox->setFeatures(QDockWidget::DockWidgetMovable | QDockWidget::DockWidgetFloatable | QDockWidget::DockWidgetClosable);
 
     if (cfg.toolOptionsInDocker()) {
         ToolDockerFactory toolDockerFactory;
         d->toolOptionsDocker = qobject_cast<KoToolDocker*>(createDockWidget(&toolDockerFactory));
         d->toolOptionsDocker->toggleViewAction()->setEnabled(true);
     }
 
     QMap<QString, QAction*> dockwidgetActions;
     dockwidgetActions[toolbox->toggleViewAction()->text()] = toolbox->toggleViewAction();
     Q_FOREACH (const QString & docker, KoDockRegistry::instance()->keys()) {
         KoDockFactoryBase *factory = KoDockRegistry::instance()->value(docker);
         QDockWidget *dw = createDockWidget(factory);
         dockwidgetActions[dw->toggleViewAction()->text()] = dw->toggleViewAction();
     }
 
     if (d->toolOptionsDocker) {
         dockwidgetActions[d->toolOptionsDocker->toggleViewAction()->text()] = d->toolOptionsDocker->toggleViewAction();
     }
     connect(KoToolManager::instance(), SIGNAL(toolOptionWidgetsChanged(KoCanvasController*, QList<QPointer<QWidget> >)), this, SLOT(newOptionWidgets(KoCanvasController*, QList<QPointer<QWidget> >)));
 
     Q_FOREACH (QString title, dockwidgetActions.keys()) {
         d->dockWidgetMenu->addAction(dockwidgetActions[title]);
     }
 
 
     Q_FOREACH (QDockWidget *wdg, dockWidgets()) {
         if ((wdg->features() & QDockWidget::DockWidgetClosable) == 0) {
             wdg->setVisible(true);
         }
     }
 
     Q_FOREACH (KoCanvasObserverBase* observer, canvasObservers()) {
         observer->setObservedCanvas(0);
         KisMainwindowObserver* mainwindowObserver = dynamic_cast<KisMainwindowObserver*>(observer);
         if (mainwindowObserver) {
             mainwindowObserver->setMainWindow(d->viewManager);
         }
     }
 
     d->mdiArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     d->mdiArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     d->mdiArea->setTabPosition(QTabWidget::North);
     d->mdiArea->setTabsClosable(true);
 
     setCentralWidget(d->mdiArea);
 
     connect(d->mdiArea, SIGNAL(subWindowActivated(QMdiSubWindow*)), this, SLOT(subWindowActivated()));
     connect(d->windowMapper, SIGNAL(mapped(QWidget*)), this, SLOT(setActiveSubWindow(QWidget*)));
     connect(d->documentMapper, SIGNAL(mapped(QObject*)), this, SLOT(newView(QObject*)));
 
     createActions();
 
     setAutoSaveSettings(d->windowStateConfig, false);
 
     subWindowActivated();
     updateWindowMenu();
 
 
     if (isHelpMenuEnabled() && !d->helpMenu) {
         // workaround for KHelpMenu (or rather KAboutData::applicationData()) internally
         // not using the Q*Application metadata ATM, which results e.g. in the bugreport wizard
         // not having the app version preset
         // fixed hopefully in KF5 5.22.0, patch pending
         QGuiApplication *app = qApp;
         KAboutData aboutData(app->applicationName(), app->applicationDisplayName(), app->applicationVersion());
         aboutData.setOrganizationDomain(app->organizationDomain().toUtf8());
         d->helpMenu = new KHelpMenu(this, aboutData, false);
         // workaround-less version:
         // d->helpMenu = new KHelpMenu(this, QString()/*unused*/, false);
 
         // The difference between using KActionCollection->addAction() is that
         // these actions do not get tied to the MainWindow.  What does this all do?
         KActionCollection *actions = d->viewManager->actionCollection();
         QAction *helpContentsAction = d->helpMenu->action(KHelpMenu::menuHelpContents);
         QAction *whatsThisAction = d->helpMenu->action(KHelpMenu::menuWhatsThis);
         QAction *reportBugAction = d->helpMenu->action(KHelpMenu::menuReportBug);
         QAction *switchLanguageAction = d->helpMenu->action(KHelpMenu::menuSwitchLanguage);
         QAction *aboutAppAction = d->helpMenu->action(KHelpMenu::menuAboutApp);
         QAction *aboutKdeAction = d->helpMenu->action(KHelpMenu::menuAboutKDE);
 
         if (helpContentsAction) {
             actions->addAction(helpContentsAction->objectName(), helpContentsAction);
         }
         if (whatsThisAction) {
             actions->addAction(whatsThisAction->objectName(), whatsThisAction);
         }
         if (reportBugAction) {
             actions->addAction(reportBugAction->objectName(), reportBugAction);
         }
         if (switchLanguageAction) {
             actions->addAction(switchLanguageAction->objectName(), switchLanguageAction);
         }
         if (aboutAppAction) {
             actions->addAction(aboutAppAction->objectName(), aboutAppAction);
         }
         if (aboutKdeAction) {
             actions->addAction(aboutKdeAction->objectName(), aboutKdeAction);
         }
 
         connect(d->helpMenu, SIGNAL(showAboutApplication()), SLOT(showAboutApplication()));
     }
 
     // KDE' libs 4''s help contents action is broken outside kde, for some reason... We can handle it just as easily ourselves
     QAction *helpAction = actionCollection()->action("help_contents");
     helpAction->disconnect();
     connect(helpAction, SIGNAL(triggered()), this, SLOT(showManual()));
 
 
 #if 0
     //check for colliding shortcuts
     QSet<QKeySequence> existingShortcuts;
     Q_FOREACH (QAction* action, actionCollection()->actions()) {
         if(action->shortcut() == QKeySequence(0)) {
             continue;
         }
         dbgKrita << "shortcut " << action->text() << " " << action->shortcut();
         Q_ASSERT(!existingShortcuts.contains(action->shortcut()));
         existingShortcuts.insert(action->shortcut());
     }
 #endif
 
     configChanged();
 
     // If we have customized the toolbars, load that first
     setLocalXMLFile(KoResourcePaths::locateLocal("data", "krita4.xmlgui"));
     setXMLFile(":/kxmlgui5/krita4.xmlgui");
 
     guiFactory()->addClient(this);
 
     // Create and plug toolbar list for Settings menu
     QList<QAction *> toolbarList;
     Q_FOREACH (QWidget* it, guiFactory()->containers("ToolBar")) {
         KToolBar * toolBar = ::qobject_cast<KToolBar *>(it);
 
         if (toolBar) {
             if (toolBar->objectName() == "BrushesAndStuff") {
                 toolBar->setEnabled(false);
             }
 
             KToggleAction* act = new KToggleAction(i18n("Show %1 Toolbar", toolBar->windowTitle()), this);
             actionCollection()->addAction(toolBar->objectName().toUtf8(), act);
             act->setCheckedState(KGuiItem(i18n("Hide %1 Toolbar", toolBar->windowTitle())));
             connect(act, SIGNAL(toggled(bool)), this, SLOT(slotToolbarToggled(bool)));
             act->setChecked(!toolBar->isHidden());
             toolbarList.append(act);
         } else {
             warnUI << "Toolbar list contains a " << it->metaObject()->className() << " which is not a toolbar!";
         }
     }
     plugActionList("toolbarlist", toolbarList);
     d->toolbarList = toolbarList;
 
     applyToolBarLayout();
 
     d->viewManager->updateGUI();
     d->viewManager->updateIcons();
 
 #ifdef Q_OS_WIN
     auto w = qApp->activeWindow();
     if (w) QWindowsWindowFunctions::setHasBorderInFullScreen(w->windowHandle(), true);
 #endif
 
     QTimer::singleShot(1000, this, SLOT(checkSanity()));
 
     {
         using namespace std::placeholders; // For _1 placeholder
         std::function<void (int)> callback(
             std::bind(&KisMainWindow::switchTab, this, _1));
 
         d->tabSwitchCompressor.reset(
             new KisSignalCompressorWithParam<int>(500, callback, KisSignalCompressor::FIRST_INACTIVE));
     }
 }
 
 KisMainWindow::~KisMainWindow()
 {
 //    Q_FOREACH (QAction *ac, actionCollection()->actions()) {
 //        QAction *action = qobject_cast<QAction*>(ac);
 //        if (action) {
 //        dbgKrita << "<Action"
 //                 << "name=" << action->objectName()
 //                 << "icon=" << action->icon().name()
 //                 << "text="  << action->text().replace("&", "&amp;")
 //                 << "whatsThis="  << action->whatsThis()
 //                 << "toolTip="  << action->toolTip().replace("<html>", "").replace("</html>", "")
 //                 << "iconText="  << action->iconText().replace("&", "&amp;")
 //                 << "shortcut="  << action->shortcut(QAction::ActiveShortcut).toString()
 //                 << "defaultShortcut="  << action->shortcut(QAction::DefaultShortcut).toString()
 //                 << "isCheckable="  << QString((action->isChecked() ? "true" : "false"))
 //                 << "statusTip=" << action->statusTip()
 //                 << "/>"   ;
 //        }
 //        else {
 //            dbgKrita << "Got a QAction:" << ac->objectName();
 //        }
 
 //    }
 
     // The doc and view might still exist (this is the case when closing the window)
     KisPart::instance()->removeMainWindow(this);
 
     delete d->viewManager;
     delete d;
 
 }
 
 QUuid KisMainWindow::id() const {
     return d->id;
 }
 
 void KisMainWindow::addView(KisView *view)
 {
     if (d->activeView == view) return;
 
     if (d->activeView) {
         d->activeView->disconnect(this);
     }
 
     // register the newly created view in the input manager
     viewManager()->inputManager()->addTrackedCanvas(view->canvasBase());
 
     showView(view);
     updateCaption();
     emit restoringDone();
 
     if (d->activeView) {
         connect(d->activeView, SIGNAL(titleModified(QString,bool)), SLOT(slotDocumentTitleModified()));
         connect(d->viewManager->statusBar(), SIGNAL(memoryStatusUpdated()), this, SLOT(updateCaption()));
     }
 }
 
 void KisMainWindow::notifyChildViewDestroyed(KisView *view)
 {
     viewManager()->inputManager()->removeTrackedCanvas(view->canvasBase());
     if (view->canvasBase() == viewManager()->canvasBase()) {
         viewManager()->setCurrentView(0);
     }
 }
 
 
 void KisMainWindow::showView(KisView *imageView)
 {
     if (imageView && activeView() != imageView) {
         // XXX: find a better way to initialize this!
         imageView->setViewManager(d->viewManager);
 
         imageView->canvasBase()->setFavoriteResourceManager(d->viewManager->paintOpBox()->favoriteResourcesManager());
         imageView->slotLoadingFinished();
 
         QMdiSubWindow *subwin = d->mdiArea->addSubWindow(imageView);
         imageView->setSubWindow(subwin);
         subwin->setAttribute(Qt::WA_DeleteOnClose, true);
         connect(subwin, SIGNAL(destroyed()), SLOT(updateWindowMenu()));
 
         KisConfig cfg;
         subwin->setOption(QMdiSubWindow::RubberBandMove, cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
         subwin->setOption(QMdiSubWindow::RubberBandResize, cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
         subwin->setWindowIcon(qApp->windowIcon());
 
         /**
          * Hack alert!
          *
          * Here we explicitly request KoToolManager to emit all the tool
          * activation signals, to reinitialize the tool options docker.
          *
          * That is needed due to a design flaw we have in the
          * initialization procedure.  The tool in the KoToolManager is
          * initialized in KisView::setViewManager() calls, which
          * happens early enough. During this call the tool manager
          * requests KoCanvasControllerWidget to emit the signal to
          * update the widgets in the tool docker. *But* at that moment
          * of time the view is not yet connected to the main window,
          * because it happens in KisViewManager::setCurrentView a bit
          * later. This fact makes the widgets updating signals be lost
          * and never reach the tool docker.
          *
          * So here we just explicitly call the tool activation stub.
          */
 
         KoToolManager::instance()->initializeCurrentToolForCanvas();
 
         if (d->mdiArea->subWindowList().size() == 1) {
             imageView->showMaximized();
         }
         else {
             imageView->show();
         }
 
         // No, no, no: do not try to call this _before_ the show() has
         // been called on the view; only when that has happened is the
         // opengl context active, and very bad things happen if we tell
         // the dockers to update themselves with a view if the opengl
         // context is not active.
         setActiveView(imageView);
 
         updateWindowMenu();
         updateCaption();
     }
 }
 
 void KisMainWindow::slotPreferences()
 {
     if (KisDlgPreferences::editPreferences()) {
         KisConfigNotifier::instance()->notifyConfigChanged();
         KisConfigNotifier::instance()->notifyPixelGridModeChanged();
         KisUpdateSchedulerConfigNotifier::instance()->notifyConfigChanged();
 
         // XXX: should this be changed for the views in other windows as well?
         Q_FOREACH (QPointer<KisView> koview, KisPart::instance()->views()) {
             KisViewManager *view = qobject_cast<KisViewManager*>(koview);
             if (view) {
                 // Update the settings for all nodes -- they don't query
                 // KisConfig directly because they need the settings during
                 // compositing, and they don't connect to the config notifier
                 // because nodes are not QObjects (because only one base class
                 // can be a QObject).
                 KisNode* node = dynamic_cast<KisNode*>(view->image()->rootLayer().data());
                 node->updateSettings();
             }
 
         }
 
         d->viewManager->showHideScrollbars();
     }
 }
 
 void KisMainWindow::slotThemeChanged()
 {
     // save theme changes instantly
     KConfigGroup group( KSharedConfig::openConfig(), "theme");
     group.writeEntry("Theme", d->themeManager->currentThemeName());
 
     // reload action icons!
     Q_FOREACH (QAction *action, actionCollection()->actions()) {
         KisIconUtils::updateIcon(action);
     }
 
     emit themeChanged();
 }
 
 void KisMainWindow::updateReloadFileAction(KisDocument *doc)
 {
     Q_UNUSED(doc);
 //    d->reloadFile->setEnabled(doc && !doc->url().isEmpty());
 }
 
 void KisMainWindow::setReadWrite(bool readwrite)
 {
     d->saveAction->setEnabled(readwrite);
     d->importFile->setEnabled(readwrite);
     d->readOnly = !readwrite;
     updateCaption();
 }
 
 void KisMainWindow::addRecentURL(const QUrl &url)
 {
     // Add entry to recent documents list
     // (call coming from KisDocument because it must work with cmd line, template dlg, file/open, etc.)
     if (!url.isEmpty()) {
         bool ok = true;
         if (url.isLocalFile()) {
             QString path = url.adjusted(QUrl::StripTrailingSlash).toLocalFile();
             const QStringList tmpDirs = KoResourcePaths::resourceDirs("tmp");
             for (QStringList::ConstIterator it = tmpDirs.begin() ; ok && it != tmpDirs.end() ; ++it) {
                 if (path.contains(*it)) {
                     ok = false; // it's in the tmp resource
                 }
             }
 #ifdef HAVE_KIO
             if (ok) {
                 KRecentDocument::add(QUrl::fromLocalFile(path));
             }
 #endif
         }
 #ifdef HAVE_KIO
         else {
             KRecentDocument::add(url.adjusted(QUrl::StripTrailingSlash));
         }
 #endif
         if (ok) {
             d->recentFiles->addUrl(url);
         }
         saveRecentFiles();
 
     }
 }
 
 void KisMainWindow::saveRecentFiles()
 {
     // Save list of recent files
     KSharedConfigPtr config =  KSharedConfig::openConfig();
     d->recentFiles->saveEntries(config->group("RecentFiles"));
     config->sync();
 
     // Tell all windows to reload their list, after saving
     // Doesn't work multi-process, but it's a start
     Q_FOREACH (KisMainWindow *mw, KisPart::instance()->mainWindows()) {
         if (mw != this) {
             mw->reloadRecentFileList();
         }
     }
 }
 
 void KisMainWindow::reloadRecentFileList()
 {
     d->recentFiles->loadEntries(KSharedConfig::openConfig()->group("RecentFiles"));
 }
 
 void KisMainWindow::updateCaption()
 {
     if (!d->mdiArea->activeSubWindow()) {
         updateCaption(QString(), false);
     }
     else if (d->activeView && d->activeView->document() && d->activeView->image()){
         KisDocument *doc = d->activeView->document();
 
         QString caption(doc->caption());
         if (d->readOnly) {
             caption += " [" + i18n("Write Protected") + "] ";
         }
 
         if (doc->isRecovered()) {
             caption += " [" + i18n("Recovered") + "] ";
         }
 
 
         // new documents aren't saved yet, so we don't need to say it is modified
         // new files don't have a URL, so we are using that for the check
         if (!doc->url().isEmpty()) {
 
             if ( doc->isModified()) {
                 caption += " [" + i18n("Modified") + "] ";
             }
         }
 
         // show the file size for the document
 
 
         KisMemoryStatisticsServer::Statistics m_fileSizeStats = KisMemoryStatisticsServer::instance()->fetchMemoryStatistics(d->activeView ? d->activeView->image() : 0);
 
 
         if (m_fileSizeStats.imageSize) {
             caption += QString(" (").append( KFormat().formatByteSize(m_fileSizeStats.imageSize)).append( ")");
         }
 
 
         d->activeView->setWindowTitle(caption);
         d->activeView->setWindowModified(doc->isModified());
 
         updateCaption(caption, doc->isModified());
 
         if (!doc->url().fileName().isEmpty())
             d->saveAction->setToolTip(i18n("Save as %1", doc->url().fileName()));
         else
             d->saveAction->setToolTip(i18n("Save"));
     }
 }
 
 void KisMainWindow::updateCaption(const QString & caption, bool mod)
 {
     dbgUI << "KisMainWindow::updateCaption(" << caption << "," << mod << ")";
 #ifdef KRITA_ALPHA
     setCaption(QString("ALPHA %1: %2").arg(KRITA_ALPHA).arg(caption), mod);
     return;
 #endif
 #ifdef KRITA_BETA
     setCaption(QString("BETA %1: %2").arg(KRITA_BETA).arg(caption), mod);
     return;
 #endif
 #ifdef KRITA_RC
     setCaption(QString("RELEASE CANDIDATE %1: %2").arg(KRITA_RC).arg(caption), mod);
     return;
 #endif
 
     setCaption(caption, mod);
 }
 
 
 KisView *KisMainWindow::activeView() const
 {
     if (d->activeView) {
         return d->activeView;
     }
     return 0;
 }
 
 bool KisMainWindow::openDocument(const QUrl &url, OpenFlags flags)
 {
     if (!QFile(url.toLocalFile()).exists()) {
         if (!(flags & BatchMode)) {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("The file %1 does not exist.", url.url()));
         }
         d->recentFiles->removeUrl(url); //remove the file from the recent-opened-file-list
         saveRecentFiles();
         return false;
     }
     return openDocumentInternal(url, flags);
 }
 
 bool KisMainWindow::openDocumentInternal(const QUrl &url, OpenFlags flags)
 {
     if (!url.isLocalFile()) {
         qWarning() << "KisMainWindow::openDocumentInternal. Not a local file:" << url;
         return false;
     }
 
     KisDocument *newdoc = KisPart::instance()->createDocument();
 
     if (flags & BatchMode) {
         newdoc->setFileBatchMode(true);
     }
 
     d->firstTime = true;
     connect(newdoc, SIGNAL(completed()), this, SLOT(slotLoadCompleted()));
     connect(newdoc, SIGNAL(canceled(const QString &)), this, SLOT(slotLoadCanceled(const QString &)));
 
     KisDocument::OpenFlags openFlags = KisDocument::None;
     if (flags & RecoveryFile) {
         openFlags |= KisDocument::RecoveryFile;
     }
 
     bool openRet = !(flags & Import) ? newdoc->openUrl(url, openFlags) : newdoc->importDocument(url);
 
 
     if (!openRet) {
         delete newdoc;
         return false;
     }
 
     KisPart::instance()->addDocument(newdoc);
     updateReloadFileAction(newdoc);
 
     if (!QFileInfo(url.toLocalFile()).isWritable()) {
         setReadWrite(false);
     }
     return true;
 }
 
 void KisMainWindow::showDocument(KisDocument *document) {
     Q_FOREACH(QMdiSubWindow *subwindow, d->mdiArea->subWindowList()) {
         KisView *view = qobject_cast<KisView*>(subwindow->widget());
         KIS_SAFE_ASSERT_RECOVER_NOOP(view);
 
         if (view) {
             if (view->document() == document) {
                 setActiveSubWindow(subwindow);
                 return;
             }
         }
     }
 
     addViewAndNotifyLoadingCompleted(document);
 }
 
 KisView* KisMainWindow::addViewAndNotifyLoadingCompleted(KisDocument *document)
 {
     KisView *view = KisPart::instance()->createView(document, resourceManager(), actionCollection(), this);
     addView(view);
 
     emit guiLoadingFinished();
 
     return view;
 }
 
 QStringList KisMainWindow::showOpenFileDialog(bool isImporting)
 {
     KoFileDialog dialog(this, KoFileDialog::ImportFiles, "OpenDocument");
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
-    dialog.setMimeTypeFilters(KisImportExportManager::mimeFilter(KisImportExportManager::Import));
+    dialog.setMimeTypeFilters(KisImportExportManager::supportedMimeTypes(KisImportExportManager::Import));
     dialog.setCaption(isImporting ? i18n("Import Images") : i18n("Open Images"));
 
     return dialog.filenames();
 }
 
 // Separate from openDocument to handle async loading (remote URLs)
 void KisMainWindow::slotLoadCompleted()
 {
     KisDocument *newdoc = qobject_cast<KisDocument*>(sender());
     if (newdoc && newdoc->image()) {
         addViewAndNotifyLoadingCompleted(newdoc);
 
         disconnect(newdoc, SIGNAL(completed()), this, SLOT(slotLoadCompleted()));
         disconnect(newdoc, SIGNAL(canceled(const QString &)), this, SLOT(slotLoadCanceled(const QString &)));
 
         emit loadCompleted();
     }
 }
 
 void KisMainWindow::slotLoadCanceled(const QString & errMsg)
 {
     dbgUI << "KisMainWindow::slotLoadCanceled";
     if (!errMsg.isEmpty())   // empty when canceled by user
         QMessageBox::critical(this, i18nc("@title:window", "Krita"), errMsg);
     // ... can't delete the document, it's the one who emitted the signal...
 
     KisDocument* doc = qobject_cast<KisDocument*>(sender());
     Q_ASSERT(doc);
     disconnect(doc, SIGNAL(completed()), this, SLOT(slotLoadCompleted()));
     disconnect(doc, SIGNAL(canceled(const QString &)), this, SLOT(slotLoadCanceled(const QString &)));
 }
 
 void KisMainWindow::slotSaveCanceled(const QString &errMsg)
 {
     dbgUI << "KisMainWindow::slotSaveCanceled";
     if (!errMsg.isEmpty())   // empty when canceled by user
         QMessageBox::critical(this, i18nc("@title:window", "Krita"), errMsg);
     slotSaveCompleted();
 }
 
 void KisMainWindow::slotSaveCompleted()
 {
     dbgUI << "KisMainWindow::slotSaveCompleted";
     KisDocument* doc = qobject_cast<KisDocument*>(sender());
     Q_ASSERT(doc);
     disconnect(doc, SIGNAL(completed()), this, SLOT(slotSaveCompleted()));
     disconnect(doc, SIGNAL(canceled(const QString &)), this, SLOT(slotSaveCanceled(const QString &)));
 
     if (d->deferredClosingEvent) {
         KXmlGuiWindow::closeEvent(d->deferredClosingEvent);
     }
 }
 
 bool KisMainWindow::hackIsSaving() const
 {
     StdLockableWrapper<QMutex> wrapper(&d->savingEntryMutex);
     std::unique_lock<StdLockableWrapper<QMutex>> l(wrapper, std::try_to_lock);
     return !l.owns_lock();
 }
 
 bool KisMainWindow::installBundle(const QString &fileName) const
 {
     QFileInfo from(fileName);
     QFileInfo to(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/bundles/" + from.fileName());
     if (to.exists()) {
         QFile::remove(to.canonicalFilePath());
     }
     return QFile::copy(fileName, QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/bundles/" + from.fileName());
 }
 
 bool KisMainWindow::saveDocument(KisDocument *document, bool saveas, bool isExporting)
 {
     if (!document) {
         return true;
     }
 
     /**
      * Make sure that we cannot enter this method twice!
      *
      * The lower level functions may call processEvents() so
      * double-entry is quite possible to achieve. Here we try to lock
      * the mutex, and if it is failed, just cancel saving.
      */
     StdLockableWrapper<QMutex> wrapper(&d->savingEntryMutex);
     std::unique_lock<StdLockableWrapper<QMutex>> l(wrapper, std::try_to_lock);
     if (!l.owns_lock()) return false;
 
     // no busy wait for saving because it is dangerous!
     KisDelayedSaveDialog dlg(document->image(), KisDelayedSaveDialog::SaveDialog, 0, this);
     dlg.blockIfImageIsBusy();
 
     if (dlg.result() == KisDelayedSaveDialog::Rejected) {
         return false;
     }
     else if (dlg.result() == KisDelayedSaveDialog::Ignored) {
         QMessageBox::critical(0,
                               i18nc("@title:window", "Krita"),
                               i18n("You are saving a file while the image is "
                                    "still rendering. The saved file may be "
                                    "incomplete or corrupted.\n\n"
                                    "Please select a location where the original "
                                    "file will not be overridden!"));
 
 
         saveas = true;
     }
 
     if (document->isRecovered()) {
         saveas = true;
     }
 
     bool reset_url;
 
     if (document->url().isEmpty()) {
         reset_url = true;
         saveas = true;
     }
     else {
         reset_url = false;
     }
 
     connect(document, SIGNAL(completed()), this, SLOT(slotSaveCompleted()));
     connect(document, SIGNAL(canceled(const QString &)), this, SLOT(slotSaveCanceled(const QString &)));
 
     QUrl oldURL = document->url();
     QString oldFile = document->localFilePath();
 
     QByteArray nativeFormat = document->nativeFormatMimeType();
     QByteArray oldMimeFormat = document->mimeType();
 
     QUrl suggestedURL = document->url();
 
-    QStringList mimeFilter = KisImportExportManager::mimeFilter(KisImportExportManager::Export);
+    QStringList mimeFilter = KisImportExportManager::supportedMimeTypes(KisImportExportManager::Export);
 
-    mimeFilter = KisImportExportManager::mimeFilter(KisImportExportManager::Export);
+    mimeFilter = KisImportExportManager::supportedMimeTypes(KisImportExportManager::Export);
     if (!mimeFilter.contains(oldMimeFormat)) {
         dbgUI << "KisMainWindow::saveDocument no export filter for" << oldMimeFormat;
 
         // --- don't setOutputMimeType in case the user cancels the Save As
         // dialog and then tries to just plain Save ---
 
         // suggest a different filename extension (yes, we fortunately don't all live in a world of magic :))
         QString suggestedFilename = QFileInfo(suggestedURL.toLocalFile()).baseName();
 
         if (!suggestedFilename.isEmpty()) {  // ".kra" looks strange for a name
             suggestedFilename = suggestedFilename + "." + KisMimeDatabase::suffixesForMimeType(KIS_MIME_TYPE).first();
             suggestedURL = suggestedURL.adjusted(QUrl::RemoveFilename);
             suggestedURL.setPath(suggestedURL.path() + suggestedFilename);
         }
 
         // force the user to choose outputMimeType
         saveas = true;
     }
 
     bool ret = false;
 
     if (document->url().isEmpty() || isExporting || saveas) {
         // if you're just File/Save As'ing to change filter options you
         // don't want to be reminded about overwriting files etc.
         bool justChangingFilterOptions = false;
 
         KoFileDialog dialog(this, KoFileDialog::SaveFile, "SaveAs");
         dialog.setCaption(isExporting ? i18n("Exporting") : i18n("Saving As"));
 
         //qDebug() << ">>>>>" << isExporting << d->lastExportLocation << d->lastExportedFormat << QString::fromLatin1(document->mimeType());
 
         if (isExporting && !d->lastExportLocation.isEmpty()) {
 
             // Use the location where we last exported to, if it's set, as the opening location for the file dialog
             QString proposedPath = QFileInfo(d->lastExportLocation).absolutePath();
             // If the document doesn't have a filename yet, use the title
             QString proposedFileName = suggestedURL.isEmpty() ? document->documentInfo()->aboutInfo("title") :  QFileInfo(suggestedURL.toLocalFile()).baseName();
             // Use the last mimetype we exported to by default
             QString proposedMimeType =  d->lastExportedFormat.isEmpty() ? "" : d->lastExportedFormat;
             QString proposedExtension = KisMimeDatabase::suffixesForMimeType(proposedMimeType).first().remove("*,");
 
             // Set the default dir: this overrides the one loaded from the config file, since we're exporting and the lastExportLocation is not empty
             dialog.setDefaultDir(proposedPath + "/" + proposedFileName + "." + proposedExtension, true);
             dialog.setMimeTypeFilters(mimeFilter, proposedMimeType);
         }
         else {
             // Get the last used location for saving
             KConfigGroup group =  KSharedConfig::openConfig()->group("File Dialogs");
             QString proposedPath = group.readEntry("SaveAs", "");
             // if that is empty, get the last used location for loading
             if (proposedPath.isEmpty()) {
                 proposedPath = group.readEntry("OpenDocument", "");
             }
             // If that is empty, too, use the Pictures location.
             if (proposedPath.isEmpty()) {
                 proposedPath = QStandardPaths::writableLocation(QStandardPaths::PicturesLocation);
             }
             // But only use that if the suggestedUrl, that is, the document's own url is empty, otherwise
             // open the location where the document currently is.
             dialog.setDefaultDir(suggestedURL.isEmpty() ? proposedPath : suggestedURL.toLocalFile(), true);
 
             // If exporting, default to all supported file types if user is exporting
             QByteArray default_mime_type = "";
             if (!isExporting) {
                 // otherwise use the document's mimetype, or if that is empty, kra, which is the savest.
                 default_mime_type = document->mimeType().isEmpty() ? nativeFormat : document->mimeType();
             }
             dialog.setMimeTypeFilters(mimeFilter, QString::fromLatin1(default_mime_type));
         }
 
         QUrl newURL = QUrl::fromUserInput(dialog.filename());
 
         if (newURL.isLocalFile()) {
             QString fn = newURL.toLocalFile();
             if (QFileInfo(fn).completeSuffix().isEmpty()) {
                 fn.append(KisMimeDatabase::suffixesForMimeType(nativeFormat).first());
                 newURL = QUrl::fromLocalFile(fn);
             }
         }
 
         if (document->documentInfo()->aboutInfo("title") == i18n("Unnamed")) {
             QString fn = newURL.toLocalFile();
             QFileInfo info(fn);
             document->documentInfo()->setAboutInfo("title", info.baseName());
         }
 
         QByteArray outputFormat = nativeFormat;
 
         QString outputFormatString = KisMimeDatabase::mimeTypeForFile(newURL.toLocalFile(), false);
         outputFormat = outputFormatString.toLatin1();
 
 
         if (!isExporting) {
             justChangingFilterOptions = (newURL == document->url()) && (outputFormat == document->mimeType());
         }
         else {
             QString path = QFileInfo(d->lastExportLocation).absolutePath();
             QString filename = QFileInfo(document->url().toLocalFile()).baseName();
             justChangingFilterOptions = (QFileInfo(newURL.toLocalFile()).absolutePath() == path)
                     && (QFileInfo(newURL.toLocalFile()).baseName() == filename)
                     && (outputFormat == d->lastExportedFormat);
         }
 
         bool bOk = true;
         if (newURL.isEmpty()) {
             bOk = false;
         }
 
         if (bOk) {
             bool wantToSave = true;
 
             // don't change this line unless you know what you're doing :)
             if (!justChangingFilterOptions) {
                 if (!document->isNativeFormat(outputFormat))
                     wantToSave = true;
             }
 
             if (wantToSave) {
                 if (!isExporting) {  // Save As
                     ret = document->saveAs(newURL, outputFormat, true);
                     if (ret) {
                         dbgUI << "Successful Save As!";
                         KisPart::instance()->addRecentURLToAllMainWindows(newURL);
                         setReadWrite(true);
                     } else {
                         dbgUI << "Failed Save As!";
                         document->setUrl(oldURL);
                         document->setLocalFilePath(oldFile);
                     }
                 }
                 else { // Export
                     ret = document->exportDocument(newURL, outputFormat);
 
                     if (ret) {
                         d->lastExportLocation = newURL.toLocalFile();
                         d->lastExportedFormat = outputFormat;
                     }
                 }
 
             }   // if (wantToSave)  {
             else
                 ret = false;
         }   // if (bOk) {
         else
             ret = false;
     } else { // saving
         // We cannot "export" into the currently
         // opened document. We are not Gimp.
         KIS_ASSERT_RECOVER_NOOP(!isExporting);
 
         // be sure document has the correct outputMimeType!
         if (document->isModified()) {
             ret = document->save(true, 0);
         }
 
         if (!ret) {
             dbgUI << "Failed Save!";
             document->setUrl(oldURL);
             document->setLocalFilePath(oldFile);
         }
     }
 
     if (ret && !isExporting) {
         document->setRecovered(false);
     }
 
     if (!ret && reset_url)
         document->resetURL(); //clean the suggested filename as the save dialog was rejected
 
     updateReloadFileAction(document);
     updateCaption();
 
     return ret;
 }
 
 void KisMainWindow::undo()
 {
     if (activeView()) {
         activeView()->document()->undoStack()->undo();
     }
 }
 
 void KisMainWindow::redo()
 {
     if (activeView()) {
         activeView()->document()->undoStack()->redo();
     }
 }
 
 void KisMainWindow::closeEvent(QCloseEvent *e)
 {
     if (!KisPart::instance()->closingSession()) {
         QAction *action= d->viewManager->actionCollection()->action("view_show_canvas_only");
         if ((action) && (action->isChecked())) {
             action->setChecked(false);
         }
 
         // Save session when last window is closed
         if (KisPart::instance()->mainwindowCount() == 1) {
             bool closeAllowed = KisPart::instance()->closeSession();
 
             if (!closeAllowed) {
                 e->setAccepted(false);
                 return;
             }
         }
     }
 
     d->mdiArea->closeAllSubWindows();
 
     QList<QMdiSubWindow*> childrenList = d->mdiArea->subWindowList();
 
     if (childrenList.isEmpty()) {
         d->deferredClosingEvent = e;
         saveWindowState(true);
     } else {
         e->setAccepted(false);
     }
 }
 
 void KisMainWindow::saveWindowSettings()
 {
     KSharedConfigPtr config =  KSharedConfig::openConfig();
 
     if (d->windowSizeDirty ) {
         dbgUI << "KisMainWindow::saveWindowSettings";
         KConfigGroup group = d->windowStateConfig;
         KWindowConfig::saveWindowSize(windowHandle(), group);
         config->sync();
         d->windowSizeDirty = false;
     }
 
     if (!d->activeView || d->activeView->document()) {
 
         // Save toolbar position into the config file of the app, under the doc's component name
         KConfigGroup group = d->windowStateConfig;
         saveMainWindowSettings(group);
 
         // Save collapsible state of dock widgets
         for (QMap<QString, QDockWidget*>::const_iterator i = d->dockWidgetsMap.constBegin();
              i != d->dockWidgetsMap.constEnd(); ++i) {
             if (i.value()->widget()) {
                 KConfigGroup dockGroup = group.group(QString("DockWidget ") + i.key());
                 dockGroup.writeEntry("Collapsed", i.value()->widget()->isHidden());
                 dockGroup.writeEntry("Locked", i.value()->property("Locked").toBool());
                 dockGroup.writeEntry("DockArea", (int) dockWidgetArea(i.value()));
                 dockGroup.writeEntry("xPosition", (int) i.value()->widget()->x());
                 dockGroup.writeEntry("yPosition", (int) i.value()->widget()->y());
 
                 dockGroup.writeEntry("width", (int) i.value()->widget()->width());
                 dockGroup.writeEntry("height", (int) i.value()->widget()->height());
             }
         }
 
     }
 
      KSharedConfig::openConfig()->sync();
     resetAutoSaveSettings(); // Don't let KMainWindow override the good stuff we wrote down
 
 }
 
 void KisMainWindow::resizeEvent(QResizeEvent * e)
 {
     d->windowSizeDirty = true;
     KXmlGuiWindow::resizeEvent(e);
 }
 
 void KisMainWindow::setActiveView(KisView* view)
 {
     d->activeView = view;
     updateCaption();
 
     if (d->undoActionsUpdateManager) {
         d->undoActionsUpdateManager->setCurrentDocument(view ? view->document() : 0);
     }
 
     d->viewManager->setCurrentView(view);
 
     KisWindowLayoutManager::instance()->activeDocumentChanged(view->document());
 }
 
 void KisMainWindow::dragEnterEvent(QDragEnterEvent *event)
 {
     if (event->mimeData()->hasUrls() ||
         event->mimeData()->hasFormat("application/x-krita-node") ||
         event->mimeData()->hasFormat("application/x-qt-image")) {
 
         event->accept();
     }
 }
 
 void KisMainWindow::dropEvent(QDropEvent *event)
 {
     if (event->mimeData()->hasUrls() && event->mimeData()->urls().size() > 0) {
         Q_FOREACH (const QUrl &url, event->mimeData()->urls()) {
             if (url.toLocalFile().endsWith(".bundle")) {
                 bool r = installBundle(url.toLocalFile());
                 qDebug() << "\t" << r;
             }
             else {
                 openDocument(url, None);
             }
         }
     }
 }
 
 void KisMainWindow::dragMoveEvent(QDragMoveEvent * event)
 {
     QTabBar *tabBar = d->findTabBarHACK();
 
     if (!tabBar && d->mdiArea->viewMode() == QMdiArea::TabbedView) {
         qWarning() << "WARNING!!! Cannot find QTabBar in the main window! Looks like Qt has changed behavior. Drag & Drop between multiple tabs might not work properly (tabs will not switch automatically)!";
     }
 
     if (tabBar && tabBar->isVisible()) {
         QPoint pos = tabBar->mapFromGlobal(mapToGlobal(event->pos()));
         if (tabBar->rect().contains(pos)) {
             const int tabIndex = tabBar->tabAt(pos);
 
             if (tabIndex >= 0 && tabBar->currentIndex() != tabIndex) {
                 d->tabSwitchCompressor->start(tabIndex);
             }
         } else if (d->tabSwitchCompressor->isActive()) {
             d->tabSwitchCompressor->stop();
         }
     }
 }
 
 void KisMainWindow::dragLeaveEvent(QDragLeaveEvent * /*event*/)
 {
     if (d->tabSwitchCompressor->isActive()) {
         d->tabSwitchCompressor->stop();
     }
 }
 
 void KisMainWindow::mouseReleaseEvent(QMouseEvent *event)
 {
     /**
      * This ensures people who do not understand that you
      * need to make a canvas first, will find the new image
      * dialog on click.
      */
     if (centralWidget()->geometry().contains(event->pos())
             && KisPart::instance()->documents().size()==0 && event->button() == Qt::LeftButton) {
         this->slotFileNew();
         event->accept();
     } else {
         event->ignore();
     }
 }
 
 void KisMainWindow::switchTab(int index)
 {
     QTabBar *tabBar = d->findTabBarHACK();
     if (!tabBar) return;
 
     tabBar->setCurrentIndex(index);
 }
 
 void KisMainWindow::slotFileNew()
 {
-    const QStringList mimeFilter = KisImportExportManager::mimeFilter(KisImportExportManager::Import);
+    const QStringList mimeFilter = KisImportExportManager::supportedMimeTypes(KisImportExportManager::Import);
 
     KisOpenPane *startupWidget = new KisOpenPane(this, mimeFilter, QStringLiteral("templates/"));
     startupWidget->setWindowModality(Qt::WindowModal);
     startupWidget->setWindowTitle(i18n("Create new document"));
 
 
     KisConfig cfg;
 
     int w = cfg.defImageWidth();
     int h = cfg.defImageHeight();
     const double resolution = cfg.defImageResolution();
     const QString colorModel = cfg.defColorModel();
     const QString colorDepth = cfg.defaultColorDepth();
     const QString colorProfile = cfg.defColorProfile();
 
 
     CustomDocumentWidgetItem item;
     item.widget = new KisCustomImageWidget(startupWidget,
                                            w,
                                            h,
                                            resolution,
                                            colorModel,
                                            colorDepth,
                                            colorProfile,
                                            i18n("Unnamed"));
 
     item.icon = "document-new";
 
     startupWidget->addCustomDocumentWidget(item.widget, item.title, item.icon);
 
     QSize sz = KisClipboard::instance()->clipSize();
     if (sz.isValid() && sz.width() != 0 && sz.height() != 0) {
         w = sz.width();
         h = sz.height();
     }
 
     item.widget = new KisImageFromClipboard(startupWidget,
                                             w,
                                             h,
                                             resolution,
                                             colorModel,
                                             colorDepth,
                                             colorProfile,
                                             i18n("Unnamed"));
 
     item.title = i18n("Create from Clipboard");
     item.icon = "tab-new";
 
     startupWidget->addCustomDocumentWidget(item.widget, item.title, item.icon);
 
     // calls deleteLater
     connect(startupWidget, SIGNAL(documentSelected(KisDocument*)), KisPart::instance(), SLOT(startCustomDocument(KisDocument*)));
     // calls deleteLater
     connect(startupWidget, SIGNAL(openTemplate(const QUrl&)), KisPart::instance(), SLOT(openTemplate(const QUrl&)));
 
     startupWidget->exec();
 
     // Cancel calls deleteLater...
 
 }
 
 void KisMainWindow::slotImportFile()
 {
     dbgUI << "slotImportFile()";
     slotFileOpen(true);
 }
 
 
 void KisMainWindow::slotFileOpen(bool isImporting)
 {
     QStringList urls = showOpenFileDialog(isImporting);
 
     if (urls.isEmpty())
         return;
 
     Q_FOREACH (const QString& url, urls) {
 
         if (!url.isEmpty()) {
             OpenFlags flags = isImporting ? Import : None;
             bool res = openDocument(QUrl::fromLocalFile(url), flags);
             if (!res) {
                 warnKrita << "Loading" << url << "failed";
             }
         }
     }
 }
 
 void KisMainWindow::slotFileOpenRecent(const QUrl &url)
 {
     (void) openDocument(QUrl::fromLocalFile(url.toLocalFile()), None);
 }
 
 void KisMainWindow::slotFileSave()
 {
     if (saveDocument(d->activeView->document(), false, false)) {
         emit documentSaved();
     }
 }
 
 void KisMainWindow::slotFileSaveAs()
 {
     if (saveDocument(d->activeView->document(), true, false)) {
         emit documentSaved();
     }
 }
 
 void KisMainWindow::slotExportFile()
 {
     if (saveDocument(d->activeView->document(), true, true)) {
         emit documentSaved();
     }
 }
 
 void KisMainWindow::slotShowSessionManager() {
     KisPart::instance()->showSessionManager();
 }
 
 KoCanvasResourceManager *KisMainWindow::resourceManager() const
 {
     return d->viewManager->resourceProvider()->resourceManager();
 }
 
 int KisMainWindow::viewCount() const
 {
     return d->mdiArea->subWindowList().size();
 }
 
 const KConfigGroup &KisMainWindow::windowStateConfig() const
 {
     return d->windowStateConfig;
 }
 
 void KisMainWindow::saveWindowState(bool restoreNormalState)
 {
     if (restoreNormalState) {
         QAction *showCanvasOnly = d->viewManager->actionCollection()->action("view_show_canvas_only");
 
         if (showCanvasOnly && showCanvasOnly->isChecked()) {
             showCanvasOnly->setChecked(false);
         }
 
         d->windowStateConfig.writeEntry("ko_geometry", saveGeometry().toBase64());
         d->windowStateConfig.writeEntry("State", saveState().toBase64());
 
         if (!d->dockerStateBeforeHiding.isEmpty()) {
             restoreState(d->dockerStateBeforeHiding);
         }
 
         statusBar()->setVisible(true);
         menuBar()->setVisible(true);
 
         saveWindowSettings();
 
     } else {
         saveMainWindowSettings(d->windowStateConfig);
     }
 
 }
 
 bool KisMainWindow::restoreWorkspaceState(const QByteArray &state)
 {
     QByteArray oldState = saveState();
 
     // needed because otherwise the layout isn't correctly restored in some situations
     Q_FOREACH (QDockWidget *dock, dockWidgets()) {
         dock->toggleViewAction()->setEnabled(true);
         dock->hide();
     }
 
     bool success = KXmlGuiWindow::restoreState(state);
 
     if (!success) {
         KXmlGuiWindow::restoreState(oldState);
         return false;
     }
 
     return success;
 }
 
 bool KisMainWindow::restoreWorkspace(KisWorkspaceResource *workspace)
 {
     bool success = restoreWorkspaceState(workspace->dockerState());
 
     if (activeKisView()) {
         activeKisView()->resourceProvider()->notifyLoadingWorkspace(workspace);
     }
 
     return success;
 }
 
 QByteArray KisMainWindow::borrowWorkspace(KisMainWindow *other)
 {
     QByteArray currentWorkspace = saveState();
 
     if (!d->workspaceBorrowedBy.isNull()) {
         if (other->id() == d->workspaceBorrowedBy) {
             // We're swapping our original workspace back
             d->workspaceBorrowedBy = QUuid();
             return currentWorkspace;
         } else {
             // Get our original workspace back before swapping with a third window
             KisMainWindow *borrower = KisPart::instance()->windowById(d->workspaceBorrowedBy);
             if (borrower) {
                 QByteArray originalLayout = borrower->borrowWorkspace(this);
                 borrower->restoreWorkspaceState(currentWorkspace);
 
                 d->workspaceBorrowedBy = other->id();
                 return originalLayout;
             }
         }
     }
 
     d->workspaceBorrowedBy = other->id();
     return currentWorkspace;
 }
 
 void KisMainWindow::swapWorkspaces(KisMainWindow *a, KisMainWindow *b)
 {
     QByteArray workspaceA = a->borrowWorkspace(b);
     QByteArray workspaceB = b->borrowWorkspace(a);
 
     a->restoreWorkspaceState(workspaceB);
     b->restoreWorkspaceState(workspaceA);
 }
 
 KisViewManager *KisMainWindow::viewManager() const
 {
     return d->viewManager;
 }
 
 void KisMainWindow::slotDocumentInfo()
 {
     if (!d->activeView->document())
         return;
 
     KoDocumentInfo *docInfo = d->activeView->document()->documentInfo();
 
     if (!docInfo)
         return;
 
     KoDocumentInfoDlg *dlg = d->activeView->document()->createDocumentInfoDialog(this, docInfo);
 
     if (dlg->exec()) {
         if (dlg->isDocumentSaved()) {
             d->activeView->document()->setModified(false);
         } else {
             d->activeView->document()->setModified(true);
         }
         d->activeView->document()->setTitleModified();
     }
 
     delete dlg;
 }
 
 bool KisMainWindow::slotFileCloseAll()
 {
     Q_FOREACH (QMdiSubWindow *subwin, d->mdiArea->subWindowList()) {
         if (subwin) {
             if(!subwin->close())
                 return false;
         }
     }
 
     updateCaption();
     return true;
 }
 
 void KisMainWindow::slotFileQuit()
 {
     KisPart::instance()->closeSession();
 }
 
 void KisMainWindow::slotFilePrint()
 {
     if (!activeView())
         return;
     KisPrintJob *printJob = activeView()->createPrintJob();
     if (printJob == 0)
         return;
     applyDefaultSettings(printJob->printer());
     QPrintDialog *printDialog = activeView()->createPrintDialog( printJob, this );
     if (printDialog && printDialog->exec() == QDialog::Accepted) {
         printJob->printer().setPageMargins(0.0, 0.0, 0.0, 0.0, QPrinter::Point);
         printJob->printer().setPaperSize(QSizeF(activeView()->image()->width() / (72.0 * activeView()->image()->xRes()),
                                                 activeView()->image()->height()/ (72.0 * activeView()->image()->yRes())),
                                          QPrinter::Inch);
         printJob->startPrinting(KisPrintJob::DeleteWhenDone);
     }
     else {
         delete printJob;
     }
     delete printDialog;
 }
 
 void KisMainWindow::slotFilePrintPreview()
 {
     if (!activeView())
         return;
     KisPrintJob *printJob = activeView()->createPrintJob();
     if (printJob == 0)
         return;
 
     /* Sets the startPrinting() slot to be blocking.
      The Qt print-preview dialog requires the printing to be completely blocking
      and only return when the full document has been printed.
      By default the KisPrintingDialog is non-blocking and
      multithreading, setting blocking to true will allow it to be used in the preview dialog */
     printJob->setProperty("blocking", true);
     QPrintPreviewDialog *preview = new QPrintPreviewDialog(&printJob->printer(), this);
     printJob->setParent(preview); // will take care of deleting the job
     connect(preview, SIGNAL(paintRequested(QPrinter*)), printJob, SLOT(startPrinting()));
     preview->exec();
     delete preview;
 }
 
 KisPrintJob* KisMainWindow::exportToPdf(QString pdfFileName)
 {
     if (!activeView())
         return 0;
 
     if (!activeView()->document())
         return 0;
 
     KoPageLayout pageLayout;
     pageLayout.width = 0;
     pageLayout.height = 0;
     pageLayout.topMargin = 0;
     pageLayout.bottomMargin = 0;
     pageLayout.leftMargin = 0;
     pageLayout.rightMargin = 0;
 
     if (pdfFileName.isEmpty()) {
         KConfigGroup group =  KSharedConfig::openConfig()->group("File Dialogs");
         QString defaultDir = group.readEntry("SavePdfDialog");
         if (defaultDir.isEmpty())
             defaultDir = QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation);
         QUrl startUrl = QUrl::fromLocalFile(defaultDir);
         KisDocument* pDoc = d->activeView->document();
         /** if document has a file name, take file name and replace extension with .pdf */
         if (pDoc && pDoc->url().isValid()) {
             startUrl = pDoc->url();
             QString fileName = startUrl.toLocalFile();
             fileName = fileName.replace( QRegExp( "\\.\\w{2,5}$", Qt::CaseInsensitive ), ".pdf" );
             startUrl = startUrl.adjusted(QUrl::RemoveFilename);
             startUrl.setPath(startUrl.path() +  fileName );
         }
 
         QPointer<KoPageLayoutDialog> layoutDlg(new KoPageLayoutDialog(this, pageLayout));
         layoutDlg->setWindowModality(Qt::WindowModal);
         if (layoutDlg->exec() != QDialog::Accepted || !layoutDlg) {
             delete layoutDlg;
             return 0;
         }
         pageLayout = layoutDlg->pageLayout();
         delete layoutDlg;
 
         KoFileDialog dialog(this, KoFileDialog::SaveFile, "OpenDocument");
         dialog.setCaption(i18n("Export as PDF"));
         dialog.setDefaultDir(startUrl.toLocalFile());
         dialog.setMimeTypeFilters(QStringList() << "application/pdf");
         QUrl url = QUrl::fromUserInput(dialog.filename());
 
         pdfFileName = url.toLocalFile();
         if (pdfFileName.isEmpty())
             return 0;
     }
 
     KisPrintJob *printJob = activeView()->createPrintJob();
     if (printJob == 0)
         return 0;
     if (isHidden()) {
         printJob->setProperty("noprogressdialog", true);
     }
 
     applyDefaultSettings(printJob->printer());
     // TODO for remote files we have to first save locally and then upload.
     printJob->printer().setOutputFileName(pdfFileName);
     printJob->printer().setDocName(pdfFileName);
     printJob->printer().setColorMode(QPrinter::Color);
 
     if (pageLayout.format == KoPageFormat::CustomSize) {
         printJob->printer().setPaperSize(QSizeF(pageLayout.width, pageLayout.height), QPrinter::Millimeter);
     } else {
         printJob->printer().setPaperSize(KoPageFormat::printerPageSize(pageLayout.format));
     }
 
     printJob->printer().setPageMargins(pageLayout.leftMargin, pageLayout.topMargin, pageLayout.rightMargin, pageLayout.bottomMargin, QPrinter::Millimeter);
 
     switch (pageLayout.orientation) {
     case KoPageFormat::Portrait:
         printJob->printer().setOrientation(QPrinter::Portrait);
         break;
     case KoPageFormat::Landscape:
         printJob->printer().setOrientation(QPrinter::Landscape);
         break;
     }
 
     //before printing check if the printer can handle printing
     if (!printJob->canPrint()) {
         QMessageBox::critical(this, i18nc("@title:window", "Krita"), i18n("Cannot export to the specified file"));
     }
 
     printJob->startPrinting(KisPrintJob::DeleteWhenDone);
     return printJob;
 }
 
 void KisMainWindow::importAnimation()
 {
     if (!activeView()) return;
 
     KisDocument *document = activeView()->document();
     if (!document) return;
 
     KisDlgImportImageSequence dlg(this, document);
 
     if (dlg.exec() == QDialog::Accepted) {
         QStringList files = dlg.files();
         int firstFrame = dlg.firstFrame();
         int step = dlg.step();
 
         KoUpdaterPtr updater =
             !document->fileBatchMode() ? viewManager()->createUnthreadedUpdater(i18n("Import frames")) : 0;
         KisAnimationImporter importer(document->image(), updater);
         KisImportExportFilter::ConversionStatus status = importer.import(files, firstFrame, step);
 
         if (status != KisImportExportFilter::OK && status != KisImportExportFilter::InternalError) {
             QString msg = KisImportExportFilter::conversionStatusString(status);
 
             if (!msg.isEmpty())
                 QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not finish import animation:\n%1", msg));
         }
         activeView()->canvasBase()->refetchDataFromImage();
     }
 }
 
 void KisMainWindow::slotConfigureToolbars()
 {
     saveWindowState();
     KEditToolBar edit(factory(), this);
     connect(&edit, SIGNAL(newToolBarConfig()), this, SLOT(slotNewToolbarConfig()));
     (void) edit.exec();
     applyToolBarLayout();
 }
 
 void KisMainWindow::slotNewToolbarConfig()
 {
     applyMainWindowSettings(d->windowStateConfig);
 
     KXMLGUIFactory *factory = guiFactory();
     Q_UNUSED(factory);
 
     // Check if there's an active view
     if (!d->activeView)
         return;
 
     plugActionList("toolbarlist", d->toolbarList);
     applyToolBarLayout();
 }
 
 void KisMainWindow::slotToolbarToggled(bool toggle)
 {
     //dbgUI <<"KisMainWindow::slotToolbarToggled" << sender()->name() <<" toggle=" << true;
     // The action (sender) and the toolbar have the same name
     KToolBar * bar = toolBar(sender()->objectName());
     if (bar) {
         if (toggle) {
             bar->show();
         }
         else {
             bar->hide();
         }
 
         if (d->activeView && d->activeView->document()) {
             saveWindowState();
         }
     } else
         warnUI << "slotToolbarToggled : Toolbar " << sender()->objectName() << " not found!";
 }
 
 void KisMainWindow::viewFullscreen(bool fullScreen)
 {
     KisConfig cfg;
     cfg.setFullscreenMode(fullScreen);
 
     if (fullScreen) {
         setWindowState(windowState() | Qt::WindowFullScreen);   // set
     } else {
         setWindowState(windowState() & ~Qt::WindowFullScreen);   // reset
     }
 }
 
 void KisMainWindow::setMaxRecentItems(uint _number)
 {
     d->recentFiles->setMaxItems(_number);
 }
 
 void KisMainWindow::slotReloadFile()
 {
     KisDocument* document = d->activeView->document();
     if (!document || document->url().isEmpty())
         return;
 
     if (document->isModified()) {
         bool ok = QMessageBox::question(this,
                                         i18nc("@title:window", "Krita"),
                                         i18n("You will lose all changes made since your last save\n"
                                              "Do you want to continue?"),
                                         QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes) == QMessageBox::Yes;
         if (!ok)
             return;
     }
 
     QUrl url = document->url();
 
     saveWindowSettings();
     if (!document->reload()) {
         QMessageBox::critical(this, i18nc("@title:window", "Krita"), i18n("Error: Could not reload this document"));
     }
 
     return;
 
 }
 
 QDockWidget* KisMainWindow::createDockWidget(KoDockFactoryBase* factory)
 {
     QDockWidget* dockWidget = 0;
 
     if (!d->dockWidgetsMap.contains(factory->id())) {
         dockWidget = factory->createDockWidget();
 
         // It is quite possible that a dock factory cannot create the dock; don't
         // do anything in that case.
         if (!dockWidget) {
             warnKrita << "Could not create docker for" << factory->id();
             return 0;
         }
 
         dockWidget->setFont(KoDockRegistry::dockFont());
         dockWidget->setObjectName(factory->id());
         dockWidget->setParent(this);
 
         if (dockWidget->widget() && dockWidget->widget()->layout())
             dockWidget->widget()->layout()->setContentsMargins(1, 1, 1, 1);
 
         Qt::DockWidgetArea side = Qt::RightDockWidgetArea;
         bool visible = true;
 
         switch (factory->defaultDockPosition()) {
         case KoDockFactoryBase::DockTornOff:
             dockWidget->setFloating(true); // position nicely?
             break;
         case KoDockFactoryBase::DockTop:
             side = Qt::TopDockWidgetArea; break;
         case KoDockFactoryBase::DockLeft:
             side = Qt::LeftDockWidgetArea; break;
         case KoDockFactoryBase::DockBottom:
             side = Qt::BottomDockWidgetArea; break;
         case KoDockFactoryBase::DockRight:
             side = Qt::RightDockWidgetArea; break;
         case KoDockFactoryBase::DockMinimized:
         default:
             side = Qt::RightDockWidgetArea;
             visible = false;
         }
 
         KConfigGroup group = d->windowStateConfig.group("DockWidget " + factory->id());
         side = static_cast<Qt::DockWidgetArea>(group.readEntry("DockArea", static_cast<int>(side)));
         if (side == Qt::NoDockWidgetArea) side = Qt::RightDockWidgetArea;
 
         addDockWidget(side, dockWidget);
         if (!visible) {
             dockWidget->hide();
         }
 
         d->dockWidgetsMap.insert(factory->id(), dockWidget);
     }
     else {
         dockWidget = d->dockWidgetsMap[factory->id()];
     }
 
 #ifdef Q_OS_OSX
     dockWidget->setAttribute(Qt::WA_MacSmallSize, true);
 #endif
     dockWidget->setFont(KoDockRegistry::dockFont());
 
     connect(dockWidget, SIGNAL(dockLocationChanged(Qt::DockWidgetArea)), this, SLOT(forceDockTabFonts()));
 
     return dockWidget;
 }
 
 void KisMainWindow::forceDockTabFonts()
 {
     Q_FOREACH (QObject *child, children()) {
         if (child->inherits("QTabBar")) {
             ((QTabBar *)child)->setFont(KoDockRegistry::dockFont());
         }
     }
 }
 
 QList<QDockWidget*> KisMainWindow::dockWidgets() const
 {
     return d->dockWidgetsMap.values();
 }
 
 QDockWidget* KisMainWindow::dockWidget(const QString &id)
 {
     if (!d->dockWidgetsMap.contains(id)) return 0;
     return d->dockWidgetsMap[id];
 }
 
 QList<KoCanvasObserverBase*> KisMainWindow::canvasObservers() const
 {
     QList<KoCanvasObserverBase*> observers;
 
     Q_FOREACH (QDockWidget *docker, dockWidgets()) {
         KoCanvasObserverBase *observer = dynamic_cast<KoCanvasObserverBase*>(docker);
         if (observer) {
             observers << observer;
         }
         else {
             warnKrita << docker << "is not a canvas observer";
         }
     }
     return observers;
 }
 
 
 void KisMainWindow::toggleDockersVisibility(bool visible)
 {
     if (!visible) {
         d->dockerStateBeforeHiding = saveState();
 
         Q_FOREACH (QObject* widget, children()) {
             if (widget->inherits("QDockWidget")) {
                 QDockWidget* dw = static_cast<QDockWidget*>(widget);
                 if (dw->isVisible()) {
                     dw->hide();
                 }
             }
         }
     }
     else {
         restoreState(d->dockerStateBeforeHiding);
     }
 }
 
 void KisMainWindow::slotDocumentTitleModified()
 {
     updateCaption();
     updateReloadFileAction(d->activeView ? d->activeView->document() : 0);
 }
 
 
 void KisMainWindow::subWindowActivated()
 {
     bool enabled = (activeKisView() != 0);
 
     d->mdiCascade->setEnabled(enabled);
     d->mdiNextWindow->setEnabled(enabled);
     d->mdiPreviousWindow->setEnabled(enabled);
     d->mdiTile->setEnabled(enabled);
     d->close->setEnabled(enabled);
     d->closeAll->setEnabled(enabled);
 
     setActiveSubWindow(d->mdiArea->activeSubWindow());
     Q_FOREACH (QToolBar *tb, toolBars()) {
         if (tb->objectName() == "BrushesAndStuff") {
             tb->setEnabled(enabled);
         }
     }
 
     updateCaption();
     d->actionManager()->updateGUI();
 }
 
 void KisMainWindow::windowFocused()
 {
     auto *kisPart = KisPart::instance();
     auto *layoutManager = KisWindowLayoutManager::instance();
     if (!layoutManager->primaryWorkspaceFollowsFocus()) return;
 
     QUuid primary = layoutManager->primaryWindowId();
     if (primary.isNull()) return;
 
     if (d->id == primary) {
         if (!d->workspaceBorrowedBy.isNull()) {
             KisMainWindow *borrower = kisPart->windowById(d->workspaceBorrowedBy);
             if (!borrower) return;
             swapWorkspaces(this, borrower);
         }
     } else {
         if (d->workspaceBorrowedBy == primary) return;
 
         KisMainWindow *primaryWindow = kisPart->windowById(primary);
         if (!primaryWindow) return;
         swapWorkspaces(this, primaryWindow);
     }
 }
 
 void KisMainWindow::updateWindowMenu()
 {
     QMenu *menu = d->windowMenu->menu();
     menu->clear();
 
     menu->addAction(d->newWindow);
     menu->addAction(d->documentMenu);
 
     QMenu *docMenu = d->documentMenu->menu();
     docMenu->clear();
 
     Q_FOREACH (QPointer<KisDocument> doc, KisPart::instance()->documents()) {
         if (doc) {
             QString title = doc->url().toDisplayString();
             if (title.isEmpty() && doc->image()) {
                 title = doc->image()->objectName();
             }
             QAction *action = docMenu->addAction(title);
             action->setIcon(qApp->windowIcon());
             connect(action, SIGNAL(triggered()), d->documentMapper, SLOT(map()));
             d->documentMapper->setMapping(action, doc);
         }
     }
 
     menu->addAction(d->workspaceMenu);
     QMenu *workspaceMenu = d->workspaceMenu->menu();
     workspaceMenu->clear();
 
     auto workspaces = KisResourceServerProvider::instance()->workspaceServer()->resources();
     auto m_this = this;
     for (auto &w : workspaces) {
         auto action = workspaceMenu->addAction(w->name());
         connect(action, &QAction::triggered, this, [=]() {
             m_this->restoreWorkspace(w);
         });
     }
     workspaceMenu->addSeparator();
     connect(workspaceMenu->addAction(i18nc("@action:inmenu", "&Import Workspace...")),
             &QAction::triggered,
             this,
             [&]() {
         QString extensions = d->workspacemodel->extensions();
         QStringList mimeTypes;
         for(const QString &suffix : extensions.split(":")) {
             mimeTypes << KisMimeDatabase::mimeTypeForSuffix(suffix);
         }
 
         KoFileDialog dialog(0, KoFileDialog::OpenFile, "OpenDocument");
         dialog.setMimeTypeFilters(mimeTypes);
         dialog.setCaption(i18nc("@title:window", "Choose File to Add"));
         QString filename = dialog.filename();
 
         d->workspacemodel->importResourceFile(filename);
     });
 
     connect(workspaceMenu->addAction(i18nc("@action:inmenu", "&New Workspace...")),
             &QAction::triggered,
             [=]() {
         QString name = QInputDialog::getText(this, i18nc("@title:window", "New Workspace..."),
                                              i18nc("@label:textbox", "Name:"));
         if (name.isEmpty()) return;
         auto rserver = KisResourceServerProvider::instance()->workspaceServer();
 
         KisWorkspaceResource* workspace = new KisWorkspaceResource("");
         workspace->setDockerState(m_this->saveState());
         d->viewManager->resourceProvider()->notifySavingWorkspace(workspace);
         workspace->setValid(true);
         QString saveLocation = rserver->saveLocation();
 
         bool newName = false;
         if(name.isEmpty()) {
             newName = true;
             name = i18n("Workspace");
         }
         QFileInfo fileInfo(saveLocation + name + workspace->defaultFileExtension());
 
         int i = 1;
         while (fileInfo.exists()) {
             fileInfo.setFile(saveLocation + name + QString("%1").arg(i) + workspace->defaultFileExtension());
             i++;
         }
         workspace->setFilename(fileInfo.filePath());
         if(newName) {
             name = i18n("Workspace %1", i);
         }
         workspace->setName(name);
         rserver->addResource(workspace);
     });
 
     // TODO: What to do about delete?
 //    workspaceMenu->addAction(i18nc("@action:inmenu", "&Delete Workspace..."));
 
     menu->addSeparator();
     menu->addAction(d->close);
     menu->addAction(d->closeAll);
     if (d->mdiArea->viewMode() == QMdiArea::SubWindowView) {
         menu->addSeparator();
         menu->addAction(d->mdiTile);
         menu->addAction(d->mdiCascade);
     }
     menu->addSeparator();
     menu->addAction(d->mdiNextWindow);
     menu->addAction(d->mdiPreviousWindow);
     menu->addSeparator();
 
     QList<QMdiSubWindow *> windows = d->mdiArea->subWindowList();
     for (int i = 0; i < windows.size(); ++i) {
         QPointer<KisView>child = qobject_cast<KisView*>(windows.at(i)->widget());
         if (child && child->document()) {
             QString text;
             if (i < 9) {
                 text = i18n("&%1 %2", i + 1, child->document()->url().toDisplayString());
             }
             else {
                 text = i18n("%1 %2", i + 1, child->document()->url().toDisplayString());
             }
 
             QAction *action  = menu->addAction(text);
             action->setIcon(qApp->windowIcon());
             action->setCheckable(true);
             action->setChecked(child == activeKisView());
             connect(action, SIGNAL(triggered()), d->windowMapper, SLOT(map()));
             d->windowMapper->setMapping(action, windows.at(i));
         }
     }
 
     updateCaption();
 }
 
 void KisMainWindow::setActiveSubWindow(QWidget *window)
 {
     if (!window) return;
     QMdiSubWindow *subwin = qobject_cast<QMdiSubWindow *>(window);
     //dbgKrita << "setActiveSubWindow();" << subwin << d->activeSubWindow;
 
     if (subwin && subwin != d->activeSubWindow) {
         KisView *view = qobject_cast<KisView *>(subwin->widget());
         //dbgKrita << "\t" << view << activeView();
         if (view && view != activeView()) {
              d->mdiArea->setActiveSubWindow(subwin);
             setActiveView(view);
         }
         d->activeSubWindow = subwin;
     }
     updateWindowMenu();
     d->actionManager()->updateGUI();
 }
 
 void KisMainWindow::configChanged()
 {
     KisConfig cfg;
     QMdiArea::ViewMode viewMode = (QMdiArea::ViewMode)cfg.readEntry<int>("mdi_viewmode", (int)QMdiArea::TabbedView);
     d->mdiArea->setViewMode(viewMode);
     Q_FOREACH (QMdiSubWindow *subwin, d->mdiArea->subWindowList()) {
         subwin->setOption(QMdiSubWindow::RubberBandMove, cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
         subwin->setOption(QMdiSubWindow::RubberBandResize, cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
 
         /**
          * Dirty workaround for a bug in Qt (checked on Qt 5.6.1):
          *
          * If you make a window "Show on top" and then switch to the tabbed mode
          * the window will contiue to be painted in its initial "mid-screen"
          * position. It will persist here until you explicitly switch to its tab.
          */
         if (viewMode == QMdiArea::TabbedView) {
             Qt::WindowFlags oldFlags = subwin->windowFlags();
             Qt::WindowFlags flags = oldFlags;
 
             flags &= ~Qt::WindowStaysOnTopHint;
             flags &= ~Qt::WindowStaysOnBottomHint;
 
             if (flags != oldFlags) {
                 subwin->setWindowFlags(flags);
                 subwin->showMaximized();
             }
         }
 
     }
 
     KConfigGroup group( KSharedConfig::openConfig(), "theme");
     d->themeManager->setCurrentTheme(group.readEntry("Theme", "Krita dark"));
     d->actionManager()->updateGUI();
 
     QBrush brush(cfg.getMDIBackgroundColor());
     d->mdiArea->setBackground(brush);
 
     QString backgroundImage = cfg.getMDIBackgroundImage();
     if (backgroundImage != "") {
         QImage image(backgroundImage);
         QBrush brush(image);
         d->mdiArea->setBackground(brush);
     }
 
     d->mdiArea->update();
 }
 
 KisView* KisMainWindow::newView(QObject *document)
 {
     KisDocument *doc = qobject_cast<KisDocument*>(document);
     KisView *view = addViewAndNotifyLoadingCompleted(doc);
     d->actionManager()->updateGUI();
 
     return view;
 }
 
 void KisMainWindow::newWindow()
 {
     KisMainWindow *mainWindow = KisPart::instance()->createMainWindow();
     mainWindow->initializeGeometry();
     mainWindow->show();
 }
 
 void KisMainWindow::closeCurrentWindow()
 {
     d->mdiArea->currentSubWindow()->close();
     d->actionManager()->updateGUI();
 }
 
 void KisMainWindow::checkSanity()
 {
     // print error if the lcms engine is not available
     if (!KoColorSpaceEngineRegistry::instance()->contains("icc")) {
         // need to wait 1 event since exiting here would not work.
         m_errorMessage = i18n("The Krita LittleCMS color management plugin is not installed. Krita will quit now.");
         m_dieOnError = true;
         QTimer::singleShot(0, this, SLOT(showErrorAndDie()));
         return;
     }
 
     KisPaintOpPresetResourceServer * rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
     if (rserver->resources().isEmpty()) {
         m_errorMessage = i18n("Krita cannot find any brush presets! Krita will quit now.");
         m_dieOnError = true;
         QTimer::singleShot(0, this, SLOT(showErrorAndDie()));
         return;
     }
 }
 
 void KisMainWindow::showErrorAndDie()
 {
     QMessageBox::critical(0, i18nc("@title:window", "Installation error"), m_errorMessage);
     if (m_dieOnError) {
         exit(10);
     }
 }
 
 void KisMainWindow::showAboutApplication()
 {
     KisAboutApplication dlg(this);
     dlg.exec();
 }
 
 QPointer<KisView> KisMainWindow::activeKisView()
 {
     if (!d->mdiArea) return 0;
     QMdiSubWindow *activeSubWindow = d->mdiArea->activeSubWindow();
     //dbgKrita << "activeKisView" << activeSubWindow;
     if (!activeSubWindow) return 0;
     return qobject_cast<KisView*>(activeSubWindow->widget());
 }
 
 void KisMainWindow::newOptionWidgets(KoCanvasController *controller, const QList<QPointer<QWidget> > &optionWidgetList)
 {
     KIS_ASSERT_RECOVER_NOOP(controller == KoToolManager::instance()->activeCanvasController());
     bool isOurOwnView = false;
 
     Q_FOREACH (QPointer<KisView> view, KisPart::instance()->views()) {
         if (view && view->canvasController() == controller) {
             isOurOwnView = view->mainWindow() == this;
         }
     }
 
     if (!isOurOwnView) return;
 
     Q_FOREACH (QWidget *w, optionWidgetList) {
 #ifdef Q_OS_OSX
         w->setAttribute(Qt::WA_MacSmallSize, true);
 #endif
         w->setFont(KoDockRegistry::dockFont());
     }
 
     if (d->toolOptionsDocker) {
         d->toolOptionsDocker->setOptionWidgets(optionWidgetList);
     }
     else {
         d->viewManager->paintOpBox()->newOptionWidgets(optionWidgetList);
     }
 }
 
 void KisMainWindow::applyDefaultSettings(QPrinter &printer) {
 
     if (!d->activeView) return;
 
     QString title = d->activeView->document()->documentInfo()->aboutInfo("title");
     if (title.isEmpty()) {
         QFileInfo info(d->activeView->document()->url().fileName());
         title = info.baseName();
     }
 
     if (title.isEmpty()) {
         // #139905
         title = i18n("%1 unsaved document (%2)", qApp->applicationDisplayName(),
                      QLocale().toString(QDate::currentDate(), QLocale::ShortFormat));
     }
     printer.setDocName(title);
 }
 
 void KisMainWindow::createActions()
 {
     KisActionManager *actionManager = d->actionManager();
     KisConfig cfg;
 
     actionManager->createStandardAction(KStandardAction::New, this, SLOT(slotFileNew()));
     actionManager->createStandardAction(KStandardAction::Open, this, SLOT(slotFileOpen()));
     actionManager->createStandardAction(KStandardAction::Quit, this, SLOT(slotFileQuit()));
     actionManager->createStandardAction(KStandardAction::ConfigureToolbars, this, SLOT(slotConfigureToolbars()));
     d->fullScreenMode = actionManager->createStandardAction(KStandardAction::FullScreen, this, SLOT(viewFullscreen(bool)));
 
     d->recentFiles = KStandardAction::openRecent(this, SLOT(slotFileOpenRecent(QUrl)), actionCollection());
     connect(d->recentFiles, SIGNAL(recentListCleared()), this, SLOT(saveRecentFiles()));
     KSharedConfigPtr configPtr =  KSharedConfig::openConfig();
     d->recentFiles->loadEntries(configPtr->group("RecentFiles"));
 
     d->saveAction = actionManager->createStandardAction(KStandardAction::Save, this, SLOT(slotFileSave()));
     d->saveAction->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
     d->saveActionAs = actionManager->createStandardAction(KStandardAction::SaveAs, this, SLOT(slotFileSaveAs()));
     d->saveActionAs->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
 //    d->printAction = actionManager->createStandardAction(KStandardAction::Print, this, SLOT(slotFilePrint()));
 //    d->printAction->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
 //    d->printActionPreview = actionManager->createStandardAction(KStandardAction::PrintPreview, this, SLOT(slotFilePrintPreview()));
 //    d->printActionPreview->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
     d->undo = actionManager->createStandardAction(KStandardAction::Undo, this, SLOT(undo()));
     d->undo->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
     d->redo = actionManager->createStandardAction(KStandardAction::Redo, this, SLOT(redo()));
     d->redo->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
     d->undoActionsUpdateManager.reset(new KisUndoActionsUpdateManager(d->undo, d->redo));
     d->undoActionsUpdateManager->setCurrentDocument(d->activeView ? d->activeView->document() : 0);
 
 //    d->exportPdf  = actionManager->createAction("file_export_pdf");
 //    connect(d->exportPdf, SIGNAL(triggered()), this, SLOT(exportToPdf()));
 
     d->importAnimation  = actionManager->createAction("file_import_animation");
     connect(d->importAnimation, SIGNAL(triggered()), this, SLOT(importAnimation()));
 
     d->closeAll = actionManager->createAction("file_close_all");
     connect(d->closeAll, SIGNAL(triggered()), this, SLOT(slotFileCloseAll()));
 
 //    d->reloadFile  = actionManager->createAction("file_reload_file");
 //    d->reloadFile->setActivationFlags(KisAction::CURRENT_IMAGE_MODIFIED);
 //    connect(d->reloadFile, SIGNAL(triggered(bool)), this, SLOT(slotReloadFile()));
 
     d->importFile  = actionManager->createAction("file_import_file");
     connect(d->importFile, SIGNAL(triggered(bool)), this, SLOT(slotImportFile()));
 
     d->exportFile  = actionManager->createAction("file_export_file");
     connect(d->exportFile, SIGNAL(triggered(bool)), this, SLOT(slotExportFile()));
 
     /* The following entry opens the document information dialog.  Since the action is named so it
         intends to show data this entry should not have a trailing ellipses (...).  */
     d->showDocumentInfo  = actionManager->createAction("file_documentinfo");
     connect(d->showDocumentInfo, SIGNAL(triggered(bool)), this, SLOT(slotDocumentInfo()));
 
 
     d->themeManager->setThemeMenuAction(new KActionMenu(i18nc("@action:inmenu", "&Themes"), this));
     d->themeManager->registerThemeActions(actionCollection());
     connect(d->themeManager, SIGNAL(signalThemeChanged()), this, SLOT(slotThemeChanged()));
 
     d->toggleDockers = actionManager->createAction("view_toggledockers");
     cfg.showDockers(true);
     d->toggleDockers->setChecked(true);
     connect(d->toggleDockers, SIGNAL(toggled(bool)), SLOT(toggleDockersVisibility(bool)));
 
     actionCollection()->addAction("settings_dockers_menu", d->dockWidgetMenu);
     actionCollection()->addAction("window", d->windowMenu);
 
     d->mdiCascade = actionManager->createAction("windows_cascade");
     connect(d->mdiCascade, SIGNAL(triggered()), d->mdiArea, SLOT(cascadeSubWindows()));
 
     d->mdiTile = actionManager->createAction("windows_tile");
     connect(d->mdiTile, SIGNAL(triggered()), d->mdiArea, SLOT(tileSubWindows()));
 
     d->mdiNextWindow = actionManager->createAction("windows_next");
     connect(d->mdiNextWindow, SIGNAL(triggered()), d->mdiArea, SLOT(activateNextSubWindow()));
 
     d->mdiPreviousWindow = actionManager->createAction("windows_previous");
     connect(d->mdiPreviousWindow, SIGNAL(triggered()), d->mdiArea, SLOT(activatePreviousSubWindow()));
 
     d->newWindow = actionManager->createAction("view_newwindow");
     connect(d->newWindow, SIGNAL(triggered(bool)), this, SLOT(newWindow()));
 
     d->close = actionManager->createAction("file_close");
     connect(d->close, SIGNAL(triggered()), SLOT(closeCurrentWindow()));
 
     d->showSessionManager = actionManager->createAction("file_sessions");
     connect(d->showSessionManager, SIGNAL(triggered(bool)), this, SLOT(slotShowSessionManager()));
 
     actionManager->createStandardAction(KStandardAction::Preferences, this, SLOT(slotPreferences()));
 
     for (int i = 0; i < 2; i++) {
         d->expandingSpacers[i] = new KisAction(i18n("Expanding Spacer"));
         d->expandingSpacers[i]->setDefaultWidget(new QWidget(this));
         d->expandingSpacers[i]->defaultWidget()->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
         actionManager->addAction(QString("expanding_spacer_%1").arg(i), d->expandingSpacers[i]);
     }
 }
 
 void KisMainWindow::applyToolBarLayout()
 {
     const bool isPlastiqueStyle = style()->objectName() == "plastique";
 
     Q_FOREACH (KToolBar *toolBar, toolBars()) {
         toolBar->layout()->setSpacing(4);
         if (isPlastiqueStyle) {
             toolBar->setContentsMargins(0, 0, 0, 2);
         }
         //Hide text for buttons with an icon in the toolbar
         Q_FOREACH (QAction *ac, toolBar->actions()){
             if (ac->icon().pixmap(QSize(1,1)).isNull() == false){
                 ac->setPriority(QAction::LowPriority);
             }else {
                 ac->setIcon(QIcon());
             }
         }
     }
 }
 
 void KisMainWindow::initializeGeometry()
 {
     // if the user didn's specify the geometry on the command line (does anyone do that still?),
     // we first figure out some good default size and restore the x,y position. See bug 285804Z.
     KConfigGroup cfg = d->windowStateConfig;
     QByteArray geom = QByteArray::fromBase64(cfg.readEntry("ko_geometry", QByteArray()));
     if (!restoreGeometry(geom)) {
         const int scnum = QApplication::desktop()->screenNumber(parentWidget());
         QRect desk = QApplication::desktop()->availableGeometry(scnum);
         // if the desktop is virtual then use virtual screen size
         if (QApplication::desktop()->isVirtualDesktop()) {
             desk = QApplication::desktop()->availableGeometry(QApplication::desktop()->screen(scnum));
         }
 
         quint32 x = desk.x();
         quint32 y = desk.y();
         quint32 w = 0;
         quint32 h = 0;
 
         // Default size -- maximize on small screens, something useful on big screens
         const int deskWidth = desk.width();
         if (deskWidth > 1024) {
             // a nice width, and slightly less than total available
             // height to componensate for the window decs
             w = (deskWidth / 3) * 2;
             h = (desk.height() / 3) * 2;
         }
         else {
             w = desk.width();
             h = desk.height();
         }
 
         x += (desk.width() - w) / 2;
         y += (desk.height() - h) / 2;
 
         move(x,y);
         setGeometry(geometry().x(), geometry().y(), w, h);
     }
     d->fullScreenMode->setChecked(isFullScreen());
 }
 
 void KisMainWindow::showManual()
 {
     QDesktopServices::openUrl(QUrl("https://docs.krita.org"));
 }
 
 void KisMainWindow::moveEvent(QMoveEvent *e)
 {
     /**
      * For checking if the display number has changed or not we should always use
      * positional overload, not using QWidget overload. Otherwise we might get
      * inconsistency, because screenNumber(widget) can return -1, but screenNumber(pos)
      * will always return the nearest screen.
      */
 
     const int oldScreen = qApp->desktop()->screenNumber(e->oldPos());
     const int newScreen = qApp->desktop()->screenNumber(e->pos());
 
     if (oldScreen != newScreen) {
         KisConfigNotifier::instance()->notifyConfigChanged();
     }
 }
 
 
 
 #include <moc_KisMainWindow.cpp>
diff --git a/libs/ui/KisReferenceImagesDecoration.cpp b/libs/ui/KisReferenceImagesDecoration.cpp
index 23a96fce08..a9c6899217 100644
--- a/libs/ui/KisReferenceImagesDecoration.cpp
+++ b/libs/ui/KisReferenceImagesDecoration.cpp
@@ -1,145 +1,164 @@
 /*
  * Copyright (C) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "KisReferenceImagesDecoration.h"
 
 #include "KoShapeManager.h"
 
 #include "kis_algebra_2d.h"
 #include "KisDocument.h"
 #include "KisReferenceImagesLayer.h"
 
 struct KisReferenceImagesDecoration::Private {
     struct Buffer
     {
         /// Top left corner of the buffer relative to the viewport
         QPointF position;
         QImage image;
 
         QRectF bounds() const
         {
             return QRectF(position, image.size());
         }
     };
 
     KisReferenceImagesDecoration *q;
 
     KisWeakSharedPtr<KisReferenceImagesLayer> layer;
     Buffer buffer;
     QTransform previousTransform;
 
     explicit Private(KisReferenceImagesDecoration *q)
         : q(q)
     {}
 
     void updateBufferByImageCoordinates(const QRectF &dirtyImageRect)
     {
         QRectF dirtyWidgetRect = q->view()->viewConverter()->imageToWidget(dirtyImageRect);
         updateBuffer(dirtyWidgetRect, dirtyImageRect);
     }
 
     void updateBufferByWidgetCoordinates(const QRectF &dirtyWidgetRect)
     {
         QRectF dirtyImageRect = q->view()->viewConverter()->widgetToImage(dirtyWidgetRect);
         updateBuffer(dirtyWidgetRect, dirtyImageRect);
     }
 
 private:
     void updateBuffer(QRectF widgetRect, QRectF imageRect)
     {
         KisCoordinatesConverter *viewConverter = q->view()->viewConverter();
         QTransform transform = viewConverter->imageToWidgetTransform();
 
         if (buffer.image.isNull() || !buffer.bounds().contains(widgetRect)) {
             const QRectF boundingImageRect = layer->boundingImageRect();
             const QRectF boundingWidgetRect = q->view()->viewConverter()->imageToWidget(boundingImageRect);
             widgetRect = boundingWidgetRect.intersected(q->view()->rect());
 
+            if (widgetRect.isNull()) return;
+
             buffer.position = widgetRect.topLeft();
             buffer.image = QImage(widgetRect.size().toSize(), QImage::Format_ARGB32);
             buffer.image.fill(Qt::transparent);
 
             imageRect = q->view()->viewConverter()->widgetToImage(widgetRect);
         }
 
         QPainter gc(&buffer.image);
 
         gc.translate(-buffer.position);
         gc.setTransform(transform, true);
 
         gc.save();
         gc.setCompositionMode(QPainter::CompositionMode_Source);
         gc.fillRect(imageRect, Qt::transparent);
         gc.restore();
 
         gc.setClipRect(imageRect);
         layer->paintReferences(gc);
     }
 };
 
-KisReferenceImagesDecoration::KisReferenceImagesDecoration(QPointer<KisView> parent)
+KisReferenceImagesDecoration::KisReferenceImagesDecoration(QPointer<KisView> parent, KisDocument *document)
     : KisCanvasDecoration("referenceImagesDecoration", parent)
     , d(new Private(this))
-{}
+{
+    connect(document->image().data(), SIGNAL(sigNodeAddedAsync(KisNodeSP)), this, SLOT(slotNodeAdded(KisNodeSP)));
+
+    auto referenceImageLayer = document->referenceImagesLayer();
+    if (referenceImageLayer) {
+        setReferenceImageLayer(referenceImageLayer);
+    }
+}
 
 KisReferenceImagesDecoration::~KisReferenceImagesDecoration()
 {}
 
 void KisReferenceImagesDecoration::addReferenceImage(KisReferenceImage *referenceImage)
 {
-    KisSharedPtr<KisReferenceImagesLayer> layer = view()->document()->getOrCreateReferenceImagesLayer();
-    KIS_SAFE_ASSERT_RECOVER_RETURN(layer);
-
-    KUndo2Command *cmd = layer->addReferenceImage(referenceImage);
-    view()->document()->addCommand(cmd);
+    KisDocument *document = view()->document();
+    KUndo2Command *cmd = KisReferenceImagesLayer::addReferenceImages(document, {referenceImage});
+    document->addCommand(cmd);
 }
 
 bool KisReferenceImagesDecoration::documentHasReferenceImages() const
 {
     return view()->document()->referenceImagesLayer() != nullptr;
 }
 
 void KisReferenceImagesDecoration::drawDecoration(QPainter &gc, const QRectF &updateRect, const KisCoordinatesConverter */*converter*/, KisCanvas2 */*canvas*/)
 {
     KisSharedPtr<KisReferenceImagesLayer> layer = d->layer.toStrongRef();
-    if (layer.isNull()) {
-        layer = d->layer = view()->document()->referenceImagesLayer();
-        if (layer.isNull()) return;
-
-        connect(layer.data(), SIGNAL(sigUpdateCanvas(const QRectF&)), this, SLOT(slotReferenceImagesChanged(const QRectF&)));
 
-        d->updateBufferByWidgetCoordinates(updateRect);
-    } else {
+    if (!layer.isNull()) {
         QTransform transform = view()->viewConverter()->imageToWidgetTransform();
         if (!KisAlgebra2D::fuzzyMatrixCompare(transform, d->previousTransform, 1e-4)) {
             d->previousTransform = transform;
             d->updateBufferByWidgetCoordinates(QRectF(0, 0, view()->width(), view()->height()));
         }
+
+        gc.drawImage(d->buffer.position, d->buffer.image);
     }
+}
+
+void KisReferenceImagesDecoration::slotNodeAdded(KisNodeSP node)
+{
+    auto *referenceImagesLayer = dynamic_cast<KisReferenceImagesLayer*>(node.data());
 
-    gc.drawImage(d->buffer.position, d->buffer.image);
+    if (referenceImagesLayer) {
+        setReferenceImageLayer(referenceImagesLayer);
+    }
 }
 
 void KisReferenceImagesDecoration::slotReferenceImagesChanged(const QRectF &dirtyRect)
 {
     d->updateBufferByImageCoordinates(dirtyRect);
 
     QRectF documentRect = view()->viewConverter()->imageToDocument(dirtyRect);
     view()->canvasBase()->updateCanvas(documentRect);
 }
+
+void KisReferenceImagesDecoration::setReferenceImageLayer(KisSharedPtr<KisReferenceImagesLayer> layer)
+{
+    d->layer = layer;
+    connect(
+            layer.data(), SIGNAL(sigUpdateCanvas(const QRectF&)),
+            this, SLOT(slotReferenceImagesChanged(const QRectF&))
+    );
+}
diff --git a/libs/ui/KisReferenceImagesDecoration.h b/libs/ui/KisReferenceImagesDecoration.h
index bee00dfcab..021177fe80 100644
--- a/libs/ui/KisReferenceImagesDecoration.h
+++ b/libs/ui/KisReferenceImagesDecoration.h
@@ -1,62 +1,66 @@
 /*
  * Copyright (C) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #ifndef KISREFERENCEIMAGESDECORATION_H
 #define KISREFERENCEIMAGESDECORATION_H
 
 #include <QObject>
 #include <QPainter>
 #include <QRectF>
 #include <kis_shared_ptr.h>
 
 class KisReferenceImagesDecoration;
+class KisReferenceImagesLayer;
 typedef KisSharedPtr<KisReferenceImagesDecoration> KisReferenceImagesDecorationSP;
 
 #include <kis_coordinates_converter.h>
 #include <kis_canvas_decoration.h>
 #include <kis_canvas2.h>
 #include <kis_types.h>
 
 /**
  * @brief The KisReferenceImagesDecoration class draws the reference images on the canvas.
  * The document stores the list of reference images.
  */
 class KisReferenceImagesDecoration : public KisCanvasDecoration
 {
     Q_OBJECT
 public:
-    KisReferenceImagesDecoration(QPointer<KisView> parent);
+    KisReferenceImagesDecoration(QPointer<KisView> parent, KisDocument *document);
     ~KisReferenceImagesDecoration() override;
 
     void addReferenceImage(KisReferenceImage *referenceImage);
 
     bool documentHasReferenceImages() const;
 
 private Q_SLOTS:
+    void slotNodeAdded(KisNodeSP);
     void slotReferenceImagesChanged(const QRectF &dirtyRect);
 
 protected:
     void drawDecoration(QPainter& gc, const QRectF& updateRect, const KisCoordinatesConverter *converter, KisCanvas2* canvas) override;
 
 private:
     struct Private;
     const QScopedPointer<Private> d;
+
+    void setReferenceImageLayer(KisSharedPtr<KisReferenceImagesLayer> layer);
 };
 
 #endif // KISREFERENCEIMAGESDECORATION_H
diff --git a/libs/ui/KisView.cpp b/libs/ui/KisView.cpp
index 699268e415..b52aa6c36c 100644
--- a/libs/ui/KisView.cpp
+++ b/libs/ui/KisView.cpp
@@ -1,1013 +1,1013 @@
 /*
  * Copyright (C) 2014 Boudewijn Rempt <boud@valdyas.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "KisView.h"
 
 #include "KisView_p.h"
 
 #include <KoDockFactoryBase.h>
 #include <KoDockRegistry.h>
 #include <KoDocumentInfo.h>
 #include "KoDocumentInfo.h"
 #include "KoPageLayout.h"
 #include <KoToolManager.h>
 
 #include <kis_icon.h>
 
 #include <kactioncollection.h>
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 #include <kselectaction.h>
 #include <kconfiggroup.h>
 #include <kactioncollection.h>
 
 #include <QMenu>
 #include <QMessageBox>
 #include <QUrl>
 #include <QTemporaryFile>
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QDockWidget>
 #include <QDragEnterEvent>
 #include <QDropEvent>
 #include <QImage>
 #include <QList>
 #include <QPrintDialog>
 #include <QToolBar>
 #include <QUrl>
 #include <QStatusBar>
 #include <QMoveEvent>
 #include <QTemporaryFile>
 #include <QMdiSubWindow>
 
 #include <kis_image.h>
 #include <kis_node.h>
 
 #include <kis_group_layer.h>
 #include <kis_layer.h>
 #include <kis_mask.h>
 #include <kis_selection.h>
 
 #include "kis_canvas2.h"
 #include "kis_canvas_controller.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_config.h"
 #include "KisDocument.h"
 #include "kis_image_manager.h"
 #include "KisMainWindow.h"
 #include "kis_mimedata.h"
 #include "kis_mirror_axis.h"
 #include "kis_node_commands_adapter.h"
 #include "kis_node_manager.h"
 #include "KisPart.h"
 #include "KisPrintJob.h"
 #include "kis_shape_controller.h"
 #include "kis_tool_freehand.h"
 #include "KisViewManager.h"
 #include "kis_zoom_manager.h"
 #include "kis_statusbar.h"
 #include "kis_painting_assistants_decoration.h"
 #include "KisReferenceImagesDecoration.h"
 #include "kis_progress_widget.h"
 #include "kis_signal_compressor.h"
 #include "kis_filter_manager.h"
 #include "kis_file_layer.h"
 #include "krita_utils.h"
 #include "input/kis_input_manager.h"
 #include "KisRemoteFileFetcher.h"
 
 //static
 QString KisView::newObjectName()
 {
     static int s_viewIFNumber = 0;
     QString name; name.setNum(s_viewIFNumber++); name.prepend("view_");
     return name;
 }
 
 bool KisView::s_firstView = true;
 
 class Q_DECL_HIDDEN KisView::Private
 {
 public:
     Private(KisView *_q,
             KisDocument *document,
             KoCanvasResourceManager *resourceManager,
             KActionCollection *actionCollection)
         : actionCollection(actionCollection)
         , viewConverter()
         , canvasController(_q, actionCollection)
         , canvas(&viewConverter, resourceManager, _q, document->shapeController())
         , zoomManager(_q, &this->viewConverter, &this->canvasController)
         , paintingAssistantsDecoration(new KisPaintingAssistantsDecoration(_q))
-        , referenceImagesDecoration(new KisReferenceImagesDecoration(_q))
+        , referenceImagesDecoration(new KisReferenceImagesDecoration(_q, document))
         , floatingMessageCompressor(100, KisSignalCompressor::POSTPONE)
     {
     }
 
     bool inOperation; //in the middle of an operation (no screen refreshing)?
 
     QPointer<KisDocument> document; // our KisDocument
     QWidget *tempActiveWidget = 0;
 
     /**
      * Signals the document has been deleted. Can't use document==0 since this
      * only happens in ~QObject, and views get deleted by ~KisDocument.
      * XXX: either provide a better justification to do things this way, or
      * rework the mechanism.
      */
     bool documentDeleted = false;
 
     KActionCollection* actionCollection;
     KisCoordinatesConverter viewConverter;
     KisCanvasController canvasController;
     KisCanvas2 canvas;
     KisZoomManager zoomManager;
     KisViewManager *viewManager = 0;
     KisNodeSP currentNode;
     KisPaintingAssistantsDecorationSP paintingAssistantsDecoration;
     KisReferenceImagesDecorationSP referenceImagesDecoration;
     bool isCurrent = false;
     bool showFloatingMessage = false;
     QPointer<KisFloatingMessage> savedFloatingMessage;
     KisSignalCompressor floatingMessageCompressor;
     QMdiSubWindow *subWindow{nullptr};
 
     bool softProofing = false;
     bool gamutCheck = false;
 
     // Hmm sorry for polluting the private class with such a big inner class.
     // At the beginning it was a little struct :)
     class StatusBarItem
     {
     public:
 
         StatusBarItem(QWidget * widget, int stretch, bool permanent)
             : m_widget(widget),
               m_stretch(stretch),
               m_permanent(permanent),
               m_connected(false),
               m_hidden(false) {}
 
         bool operator==(const StatusBarItem& rhs) {
             return m_widget == rhs.m_widget;
         }
 
         bool operator!=(const StatusBarItem& rhs) {
             return m_widget != rhs.m_widget;
         }
 
         QWidget * widget() const {
             return m_widget;
         }
 
         void ensureItemShown(QStatusBar * sb) {
             Q_ASSERT(m_widget);
             if (!m_connected) {
                 if (m_permanent)
                     sb->addPermanentWidget(m_widget, m_stretch);
                 else
                     sb->addWidget(m_widget, m_stretch);
 
                 if(!m_hidden)
                     m_widget->show();
 
                 m_connected = true;
             }
         }
         void ensureItemHidden(QStatusBar * sb) {
             if (m_connected) {
                 m_hidden = m_widget->isHidden();
                 sb->removeWidget(m_widget);
                 m_widget->hide();
                 m_connected = false;
             }
         }
     private:
         QWidget * m_widget = 0;
         int m_stretch;
         bool m_permanent;
         bool m_connected = false;
         bool m_hidden = false;
 
     };
 
 };
 
 KisView::KisView(KisDocument *document, KoCanvasResourceManager *resourceManager, KActionCollection *actionCollection, QWidget *parent)
     : QWidget(parent)
     , d(new Private(this, document, resourceManager, actionCollection))
 {
     Q_ASSERT(document);
     connect(document, SIGNAL(titleModified(QString,bool)), this, SIGNAL(titleModified(QString,bool)));
     setObjectName(newObjectName());
 
     d->document = document;
 
     setFocusPolicy(Qt::StrongFocus);
 
     QStatusBar * sb = statusBar();
     if (sb) { // No statusbar in e.g. konqueror
         connect(d->document, SIGNAL(statusBarMessage(const QString&, int)),
                 this, SLOT(slotSavingStatusMessage(const QString&, int)));
         connect(d->document, SIGNAL(clearStatusBarMessage()),
                 this, SLOT(slotClearStatusText()));
     }
 
     d->canvas.setup();
 
     KisConfig cfg;
 
     d->canvasController.setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
     d->canvasController.setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
     d->canvasController.setVastScrolling(cfg.vastScrolling());
     d->canvasController.setCanvas(&d->canvas);
 
     d->zoomManager.setup(d->actionCollection);
 
 
     connect(&d->canvasController, SIGNAL(documentSizeChanged()), &d->zoomManager, SLOT(slotScrollAreaSizeChanged()));
     setAcceptDrops(true);
 
     connect(d->document, SIGNAL(sigLoadingFinished()), this, SLOT(slotLoadingFinished()));
     connect(d->document, SIGNAL(sigSavingFinished()), this, SLOT(slotSavingFinished()));
 
     d->canvas.addDecoration(d->paintingAssistantsDecoration);
     d->paintingAssistantsDecoration->setVisible(true);
 
     d->canvas.addDecoration(d->referenceImagesDecoration);
     d->referenceImagesDecoration->setVisible(true);
 
     d->showFloatingMessage = cfg.showCanvasMessages();
 }
 
 KisView::~KisView()
 {
     if (d->viewManager) {
         if (d->viewManager->filterManager()->isStrokeRunning()) {
             d->viewManager->filterManager()->cancel();
         }
 
         d->viewManager->mainWindow()->notifyChildViewDestroyed(this);
     }
 
     KoToolManager::instance()->removeCanvasController(&d->canvasController);
     d->canvasController.setCanvas(0);
 
     KisPart::instance()->removeView(this);
     delete d;
 }
 
 void KisView::notifyCurrentStateChanged(bool isCurrent)
 {
     d->isCurrent = isCurrent;
 
     if (!d->isCurrent && d->savedFloatingMessage) {
         d->savedFloatingMessage->removeMessage();
     }
 
     KisInputManager *inputManager = globalInputManager();
     if (d->isCurrent) {
         inputManager->attachPriorityEventFilter(&d->canvasController);
     } else {
         inputManager->detachPriorityEventFilter(&d->canvasController);
     }
 }
 
 void KisView::setShowFloatingMessage(bool show)
 {
     d->showFloatingMessage = show;
 }
 
 void KisView::showFloatingMessageImpl(const QString &message, const QIcon& icon, int timeout, KisFloatingMessage::Priority priority, int alignment)
 {
     if (!d->viewManager) return;
 
     if(d->isCurrent && d->showFloatingMessage && d->viewManager->qtMainWindow()) {
         if (d->savedFloatingMessage) {
             d->savedFloatingMessage->tryOverrideMessage(message, icon, timeout, priority, alignment);
         } else {
             d->savedFloatingMessage = new KisFloatingMessage(message, this->canvasBase()->canvasWidget(), false, timeout, priority, alignment);
             d->savedFloatingMessage->setShowOverParent(true);
             d->savedFloatingMessage->setIcon(icon);
 
             connect(&d->floatingMessageCompressor, SIGNAL(timeout()), d->savedFloatingMessage, SLOT(showMessage()));
             d->floatingMessageCompressor.start();
         }
     }
 }
 
 bool KisView::canvasIsMirrored() const
 {
     return d->canvas.xAxisMirrored() || d->canvas.yAxisMirrored();
 }
 
 void KisView::setViewManager(KisViewManager *view)
 {
     d->viewManager = view;
 
     KoToolManager::instance()->addController(&d->canvasController);
     KoToolManager::instance()->registerToolActions(d->actionCollection, &d->canvasController);
     dynamic_cast<KisShapeController*>(d->document->shapeController())->setInitialShapeForCanvas(&d->canvas);
 
     if (resourceProvider()) {
         resourceProvider()->slotImageSizeChanged();
     }
 
     if (d->viewManager && d->viewManager->nodeManager()) {
         d->viewManager->nodeManager()->nodesUpdated();
     }
 
     connect(image(), SIGNAL(sigSizeChanged(const QPointF&, const QPointF&)), this, SLOT(slotImageSizeChanged(const QPointF&, const QPointF&)));
     connect(image(), SIGNAL(sigResolutionChanged(double,double)), this, SLOT(slotImageResolutionChanged()));
 
     // executed in a context of an image thread
     connect(image(), SIGNAL(sigNodeAddedAsync(KisNodeSP)),
             SLOT(slotImageNodeAdded(KisNodeSP)),
             Qt::DirectConnection);
 
     // executed in a context of the gui thread
     connect(this, SIGNAL(sigContinueAddNode(KisNodeSP)),
             SLOT(slotContinueAddNode(KisNodeSP)),
             Qt::AutoConnection);
 
     // executed in a context of an image thread
     connect(image(), SIGNAL(sigRemoveNodeAsync(KisNodeSP)),
             SLOT(slotImageNodeRemoved(KisNodeSP)),
             Qt::DirectConnection);
 
     // executed in a context of the gui thread
     connect(this, SIGNAL(sigContinueRemoveNode(KisNodeSP)),
             SLOT(slotContinueRemoveNode(KisNodeSP)),
             Qt::AutoConnection);
 
     d->viewManager->updateGUI();
 
     KoToolManager::instance()->switchToolRequested("KritaShape/KisToolBrush");
 }
 
 KisViewManager* KisView::viewManager() const
 {
     return d->viewManager;
 }
 
 void KisView::slotImageNodeAdded(KisNodeSP node)
 {
     emit sigContinueAddNode(node);
 }
 
 void KisView::slotContinueAddNode(KisNodeSP newActiveNode)
 {
     /**
      * When deleting the last layer, root node got selected. We should
      * fix it when the first layer is added back.
      *
      * Here we basically reimplement what Qt's view/model do. But
      * since they are not connected, we should do it manually.
      */
 
     if (!d->isCurrent &&
             (!d->currentNode || !d->currentNode->parent())) {
 
         d->currentNode = newActiveNode;
     }
 }
 
 
 void KisView::slotImageNodeRemoved(KisNodeSP node)
 {
     emit sigContinueRemoveNode(KritaUtils::nearestNodeAfterRemoval(node));
 }
 
 void KisView::slotContinueRemoveNode(KisNodeSP newActiveNode)
 {
     if (!d->isCurrent) {
         d->currentNode = newActiveNode;
     }
 }
 
 KoZoomController *KisView::zoomController() const
 {
     return d->zoomManager.zoomController();
 }
 
 KisZoomManager *KisView::zoomManager() const
 {
     return &d->zoomManager;
 }
 
 KisCanvasController *KisView::canvasController() const
 {
     return &d->canvasController;
 }
 
 KisCanvasResourceProvider *KisView::resourceProvider() const
 {
     if (d->viewManager) {
         return d->viewManager->resourceProvider();
     }
     return 0;
 }
 
 KisInputManager* KisView::globalInputManager() const
 {
     return d->viewManager ? d->viewManager->inputManager() : 0;
 }
 
 KisCanvas2 *KisView::canvasBase() const
 {
     return &d->canvas;
 }
 
 KisImageWSP KisView::image() const
 {
     if (d->document) {
         return d->document->image();
     }
     return 0;
 }
 
 KisCoordinatesConverter *KisView::viewConverter() const
 {
     return &d->viewConverter;
 }
 
 void KisView::dragEnterEvent(QDragEnterEvent *event)
 {
     if (event->mimeData()->hasImage()
             || event->mimeData()->hasUrls()
             || event->mimeData()->hasFormat("application/x-krita-node")) {
         event->accept();
 
         // activate view if it should accept the drop
         this->setFocus();
     } else {
         event->ignore();
     }
 }
 
 void KisView::dropEvent(QDropEvent *event)
 {
     KisImageWSP kisimage = image();
     Q_ASSERT(kisimage);
 
     QPoint cursorPos = canvasBase()->coordinatesConverter()->widgetToImage(event->pos()).toPoint();
     QRect imageBounds = kisimage->bounds();
     QPoint pasteCenter;
     bool forceRecenter;
 
     if (event->keyboardModifiers() & Qt::ShiftModifier &&
             imageBounds.contains(cursorPos)) {
 
         pasteCenter = cursorPos;
         forceRecenter = true;
     } else {
         pasteCenter = imageBounds.center();
         forceRecenter = false;
     }
     if (event->mimeData()->hasFormat("application/x-krita-node") ||
             event->mimeData()->hasImage())
     {
         KisShapeController *kritaShapeController =
                 dynamic_cast<KisShapeController*>(d->document->shapeController());
 
         QList<KisNodeSP> nodes =
                 KisMimeData::loadNodes(event->mimeData(), imageBounds,
                                        pasteCenter, forceRecenter,
                                        kisimage, kritaShapeController);
 
         Q_FOREACH (KisNodeSP node, nodes) {
             if (node) {
                 KisNodeCommandsAdapter adapter(viewManager());
                 if (!viewManager()->nodeManager()->activeLayer()) {
                     adapter.addNode(node, kisimage->rootLayer() , 0);
                 } else {
                     adapter.addNode(node,
                                     viewManager()->nodeManager()->activeLayer()->parent(),
                                     viewManager()->nodeManager()->activeLayer());
                 }
             }
         }
     }
     else if (event->mimeData()->hasUrls()) {
 
         QList<QUrl> urls = event->mimeData()->urls();
         if (urls.length() > 0) {
 
             QMenu popup;
             popup.setObjectName("drop_popup");
 
             QAction *insertAsNewLayer = new QAction(i18n("Insert as New Layer"), &popup);
             QAction *insertManyLayers = new QAction(i18n("Insert Many Layers"), &popup);
 
             QAction *insertAsNewFileLayer = new QAction(i18n("Insert as New File Layer"), &popup);
             QAction *insertManyFileLayers = new QAction(i18n("Insert Many File Layers"), &popup);
 
             QAction *openInNewDocument = new QAction(i18n("Open in New Document"), &popup);
             QAction *openManyDocuments = new QAction(i18n("Open Many Documents"), &popup);
 
             QAction *insertAsReferenceImage = new QAction(i18n("Insert as Reference Image"), &popup);
             QAction *insertAsReferenceImages = new QAction(i18n("Insert as Reference Images"), &popup);
 
             QAction *cancel = new QAction(i18n("Cancel"), &popup);
 
             popup.addAction(insertAsNewLayer);
             popup.addAction(insertAsNewFileLayer);
             popup.addAction(openInNewDocument);
             popup.addAction(insertAsReferenceImage);
 
             popup.addAction(insertManyLayers);
             popup.addAction(insertManyFileLayers);
             popup.addAction(openManyDocuments);
             popup.addAction(insertAsReferenceImages);
 
             insertAsNewLayer->setEnabled(image() && urls.count() == 1);
             insertAsNewFileLayer->setEnabled(image() && urls.count() == 1);
             openInNewDocument->setEnabled(urls.count() == 1);
             insertAsReferenceImage->setEnabled(image() && urls.count() == 1);
 
             insertManyLayers->setEnabled(image() && urls.count() > 1);
             insertManyFileLayers->setEnabled(image() && urls.count() > 1);
             openManyDocuments->setEnabled(urls.count() > 1);
             insertAsReferenceImages->setEnabled(image() && urls.count() > 1);
 
             popup.addSeparator();
             popup.addAction(cancel);
 
             QAction *action = popup.exec(QCursor::pos());
             if (action != 0 && action != cancel) {
                 QTemporaryFile *tmp = 0;
                 for (QUrl url : urls) {
 
                     if (!url.isLocalFile()) {
                         // download the file and substitute the url
                         KisRemoteFileFetcher fetcher;
                         tmp = new QTemporaryFile();
                         tmp->setAutoRemove(true);
                         if (!fetcher.fetchFile(url, tmp)) {
                             qDebug() << "Fetching" << url << "failed";
                             continue;
                         }
                         url = url.fromLocalFile(tmp->fileName());
                     }
                     if (url.isLocalFile()) {
                         if (action == insertAsNewLayer || action == insertManyLayers) {
                             d->viewManager->imageManager()->importImage(url);
                             activateWindow();
                         }
                         else if (action == insertAsNewFileLayer || action == insertManyFileLayers) {
                             KisNodeCommandsAdapter adapter(viewManager());
                             KisFileLayer *fileLayer = new KisFileLayer(image(), "", url.toLocalFile(),
                                                                        KisFileLayer::None, image()->nextLayerName(), OPACITY_OPAQUE_U8);
                             adapter.addNode(fileLayer, viewManager()->activeNode()->parent(), viewManager()->activeNode());
                         }
                         else if (action == openInNewDocument || action == openManyDocuments) {
                             if (mainWindow()) {
                                 mainWindow()->openDocument(url, KisMainWindow::None);
                             }
                         }
                         else if (action == insertAsReferenceImage || action == insertAsReferenceImages) {
                             auto *reference = KisReferenceImage::fromFile(url.toLocalFile(), d->viewConverter);
                             reference->setPosition(d->viewConverter.imageToDocument(cursorPos));
                             d->referenceImagesDecoration->addReferenceImage(reference);
 
                             KoToolManager::instance()->switchToolRequested("ToolReferenceImages");
                         }
 
                     }
                     delete tmp;
                     tmp = 0;
                 }
             }
         }
     }
 
 }
 
 KisDocument *KisView::document() const
 {
     return d->document;
 }
 
 void KisView::setDocument(KisDocument *document)
 {
     d->document->disconnect(this);
     d->document = document;
     QStatusBar *sb = statusBar();
     if (sb) { // No statusbar in e.g. konqueror
         connect(d->document, SIGNAL(statusBarMessage(const QString&, int)),
                 this, SLOT(slotSavingStatusMessage(const QString&, int)));
         connect(d->document, SIGNAL(clearStatusBarMessage()),
                 this, SLOT(slotClearStatusText()));
     }
 }
 
 void KisView::setDocumentDeleted()
 {
     d->documentDeleted = true;
 }
 
 QPrintDialog *KisView::createPrintDialog(KisPrintJob *printJob, QWidget *parent)
 {
     Q_UNUSED(parent);
     QPrintDialog *printDialog = new QPrintDialog(&printJob->printer(), this);
     printDialog->setMinMax(printJob->printer().fromPage(), printJob->printer().toPage());
     printDialog->setEnabledOptions(printJob->printDialogOptions());
     return printDialog;
 }
 
 
 KisMainWindow * KisView::mainWindow() const
 {
     return dynamic_cast<KisMainWindow *>(window());
 }
 
 void KisView::setSubWindow(QMdiSubWindow *subWindow)
 {
     d->subWindow = subWindow;
 }
 
 QStatusBar * KisView::statusBar() const
 {
     KisMainWindow *mw = mainWindow();
     return mw ? mw->statusBar() : 0;
 }
 
 void KisView::slotSavingStatusMessage(const QString &text, int timeout, bool isAutoSaving)
 {
     QStatusBar *sb = statusBar();
     if (sb) {
         sb->showMessage(text, timeout);
     }
 
     KisConfig cfg;
 
     if (!sb || sb->isHidden() ||
         (!isAutoSaving && cfg.forceShowSaveMessages()) ||
         (cfg.forceShowAutosaveMessages() && isAutoSaving)) {
 
         viewManager()->showFloatingMessage(text, QIcon());
     }
 }
 
 void KisView::slotClearStatusText()
 {
     QStatusBar *sb = statusBar();
     if (sb) {
         sb->clearMessage();
     }
 }
 
 QList<QAction*> KisView::createChangeUnitActions(bool addPixelUnit)
 {
     UnitActionGroup* unitActions = new UnitActionGroup(d->document, addPixelUnit, this);
     return unitActions->actions();
 }
 
 void KisView::closeEvent(QCloseEvent *event)
 {
     // Check whether we're the last (user visible) view
     int viewCount = KisPart::instance()->viewCount(document());
     if (viewCount > 1 || !isVisible()) {
         // there are others still, so don't bother the user
         event->accept();
         return;
     }
 
     if (queryClose()) {
         d->viewManager->statusBar()->setView(0);
         event->accept();
         return;
     }
 
     event->ignore();
 
 }
 
 bool KisView::queryClose()
 {
     if (!document())
         return true;
 
     document()->waitForSavingToComplete();
 
     if (document()->isModified()) {
         QString name;
         if (document()->documentInfo()) {
             name = document()->documentInfo()->aboutInfo("title");
         }
         if (name.isEmpty())
             name = document()->url().fileName();
 
         if (name.isEmpty())
             name = i18n("Untitled");
 
         int res = QMessageBox::warning(this,
                                        i18nc("@title:window", "Krita"),
                                        i18n("<p>The document <b>'%1'</b> has been modified.</p><p>Do you want to save it?</p>", name),
                                        QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel, QMessageBox::Yes);
 
         switch (res) {
         case QMessageBox::Yes : {
             bool isNative = (document()->mimeType() == document()->nativeFormatMimeType());
             if (!viewManager()->mainWindow()->saveDocument(document(), !isNative, false))
                 return false;
             break;
         }
         case QMessageBox::No : {
             KisImageSP image = document()->image();
             image->requestStrokeCancellation();
             viewManager()->blockUntilOperationsFinishedForced(image);
 
             document()->removeAutoSaveFiles();
             document()->setModified(false);   // Now when queryClose() is called by closeEvent it won't do anything.
             break;
         }
         default : // case QMessageBox::Cancel :
             return false;
         }
     }
 
     return true;
 
 }
 
 void KisView::resetImageSizeAndScroll(bool changeCentering,
                                       const QPointF &oldImageStillPoint,
                                       const QPointF &newImageStillPoint)
 {
     const KisCoordinatesConverter *converter = d->canvas.coordinatesConverter();
 
     QPointF oldPreferredCenter = d->canvasController.preferredCenter();
 
     /**
      * Calculating the still point in old coordinates depending on the
      * parameters given
      */
 
     QPointF oldStillPoint;
 
     if (changeCentering) {
         oldStillPoint =
                 converter->imageToWidget(oldImageStillPoint) +
                 converter->documentOffset();
     } else {
         QSize oldDocumentSize = d->canvasController.documentSize();
         oldStillPoint = QPointF(0.5 * oldDocumentSize.width(), 0.5 * oldDocumentSize.height());
     }
 
     /**
      * Updating the document size
      */
 
     QSizeF size(image()->width() / image()->xRes(), image()->height() / image()->yRes());
     KoZoomController *zc = d->zoomManager.zoomController();
     zc->setZoom(KoZoomMode::ZOOM_CONSTANT, zc->zoomAction()->effectiveZoom());
     zc->setPageSize(size);
     zc->setDocumentSize(size, true);
 
     /**
      * Calculating the still point in new coordinates depending on the
      * parameters given
      */
 
     QPointF newStillPoint;
 
     if (changeCentering) {
         newStillPoint =
                 converter->imageToWidget(newImageStillPoint) +
                 converter->documentOffset();
     } else {
         QSize newDocumentSize = d->canvasController.documentSize();
         newStillPoint = QPointF(0.5 * newDocumentSize.width(), 0.5 * newDocumentSize.height());
     }
 
     d->canvasController.setPreferredCenter(oldPreferredCenter - oldStillPoint + newStillPoint);
 }
 
 void KisView::syncLastActiveNodeToDocument()
 {
     KisDocument *doc = document();
     if (doc) {
         doc->setPreActivatedNode(d->currentNode);
     }
 }
 
 void KisView::saveViewState(KisPropertiesConfiguration &config) const
 {
     config.setProperty("file", d->document->url());
     config.setProperty("window", mainWindow()->windowStateConfig().name());
 
     if (d->subWindow) {
         config.setProperty("geometry", d->subWindow->saveGeometry().toBase64());
     }
 
     config.setProperty("zoomMode", (int)zoomController()->zoomMode());
     config.setProperty("zoom", d->canvas.coordinatesConverter()->zoom());
 
     d->canvasController.saveCanvasState(config);
 }
 
 void KisView::restoreViewState(const KisPropertiesConfiguration &config)
 {
     if (d->subWindow) {
         QByteArray geometry = QByteArray::fromBase64(config.getString("geometry", "").toLatin1());
         d->subWindow->restoreGeometry(QByteArray::fromBase64(geometry));
     }
 
     qreal zoom = config.getFloat("zoom", 1.0f);
     int zoomMode = config.getInt("zoomMode", (int)KoZoomMode::ZOOM_PAGE);
     d->zoomManager.zoomController()->setZoom((KoZoomMode::Mode)zoomMode, zoom);
     d->canvasController.restoreCanvasState(config);
 }
 
 void KisView::setCurrentNode(KisNodeSP node)
 {
     d->currentNode = node;
     d->canvas.slotTrySwitchShapeManager();
 
     syncLastActiveNodeToDocument();
 }
 
 KisNodeSP KisView::currentNode() const
 {
     return d->currentNode;
 }
 
 KisLayerSP KisView::currentLayer() const
 {
     KisNodeSP node;
     KisMaskSP mask = currentMask();
     if (mask) {
         node = mask->parent();
     }
     else {
         node = d->currentNode;
     }
     return qobject_cast<KisLayer*>(node.data());
 }
 
 KisMaskSP KisView::currentMask() const
 {
     return dynamic_cast<KisMask*>(d->currentNode.data());
 }
 
 KisSelectionSP KisView::selection()
 {
     KisLayerSP layer = currentLayer();
     if (layer)
         return layer->selection(); // falls through to the global
     // selection, or 0 in the end
     if (image()) {
         return image()->globalSelection();
     }
     return 0;
 }
 
 void KisView::slotSoftProofing(bool softProofing)
 {
     d->softProofing = softProofing;
     QString message;
     if (canvasBase()->image()->colorSpace()->colorDepthId().id().contains("F"))
     {
         message = i18n("Soft Proofing doesn't work in floating point.");
         viewManager()->showFloatingMessage(message,QIcon());
         return;
     }
     if (softProofing){
         message = i18n("Soft Proofing turned on.");
     } else {
         message = i18n("Soft Proofing turned off.");
     }
     viewManager()->showFloatingMessage(message,QIcon());
     canvasBase()->slotSoftProofing(softProofing);
 }
 
 void KisView::slotGamutCheck(bool gamutCheck)
 {
     d->gamutCheck = gamutCheck;
     QString message;
     if (canvasBase()->image()->colorSpace()->colorDepthId().id().contains("F"))
     {
         message = i18n("Gamut Warnings don't work in floating point.");
         viewManager()->showFloatingMessage(message,QIcon());
         return;
     }
 
     if (gamutCheck){
         message = i18n("Gamut Warnings turned on.");
         if (!d->softProofing){
             message += "\n "+i18n("But Soft Proofing is still off.");
         }
     } else {
         message = i18n("Gamut Warnings turned off.");
     }
     viewManager()->showFloatingMessage(message,QIcon());
     canvasBase()->slotGamutCheck(gamutCheck);
 }
 
 bool KisView::softProofing()
 {
     return d->softProofing;
 }
 
 bool KisView::gamutCheck()
 {
     return d->gamutCheck;
 }
 
 void KisView::slotLoadingFinished()
 {
     if (!document()) return;
 
     /**
      * Cold-start of image size/resolution signals
      */
     slotImageResolutionChanged();
 
     if (image()->locked()) {
         // If this is the first view on the image, the image will have been locked
         // so unlock it.
         image()->blockSignals(false);
         image()->unlock();
     }
 
     canvasBase()->initializeImage();
 
     /**
      * Dirty hack alert
      */
     d->zoomManager.zoomController()->setAspectMode(true);
 
     if (viewConverter()) {
         viewConverter()->setZoomMode(KoZoomMode::ZOOM_PAGE);
     }
     connect(image(), SIGNAL(sigColorSpaceChanged(const KoColorSpace*)), this, SIGNAL(sigColorSpaceChanged(const KoColorSpace*)));
     connect(image(), SIGNAL(sigProfileChanged(const KoColorProfile*)), this, SIGNAL(sigProfileChanged(const KoColorProfile*)));
     connect(image(), SIGNAL(sigSizeChanged(QPointF,QPointF)), this, SIGNAL(sigSizeChanged(QPointF,QPointF)));
 
     KisNodeSP activeNode = document()->preActivatedNode();
 
     if (!activeNode) {
         activeNode = image()->rootLayer()->lastChild();
     }
 
     while (activeNode && !activeNode->inherits("KisLayer")) {
         activeNode = activeNode->prevSibling();
     }
 
     setCurrentNode(activeNode);
     zoomManager()->updateImageBoundsSnapping();
 }
 
 void KisView::slotSavingFinished()
 {
     if (d->viewManager && d->viewManager->mainWindow()) {
         d->viewManager->mainWindow()->updateCaption();
     }
 }
 
 KisPrintJob * KisView::createPrintJob()
 {
     return new KisPrintJob(image());
 }
 
 void KisView::slotImageResolutionChanged()
 {
     resetImageSizeAndScroll(false);
     zoomManager()->updateImageBoundsSnapping();
     zoomManager()->updateGUI();
 
     // update KoUnit value for the document
     if (resourceProvider()) {
         resourceProvider()->resourceManager()->
                 setResource(KoCanvasResourceManager::Unit, d->canvas.unit());
     }
 }
 
 void KisView::slotImageSizeChanged(const QPointF &oldStillPoint, const QPointF &newStillPoint)
 {
     resetImageSizeAndScroll(true, oldStillPoint, newStillPoint);
     zoomManager()->updateImageBoundsSnapping();
     zoomManager()->updateGUI();
 }
 
 void KisView::closeView()
 {
     d->subWindow->close();
 }
diff --git a/libs/ui/canvas/kis_display_color_converter.cpp b/libs/ui/canvas/kis_display_color_converter.cpp
index ba1ec8aef1..3c4824c01f 100644
--- a/libs/ui/canvas/kis_display_color_converter.cpp
+++ b/libs/ui/canvas/kis_display_color_converter.cpp
@@ -1,641 +1,645 @@
 /*
  *  Copyright (c) 2014 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_display_color_converter.h"
 
 #include <QGlobalStatic>
 #include <QPointer>
 
 #include <KoColor.h>
 #include <KoColorDisplayRendererInterface.h>
 #include <KoColorSpaceMaths.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorModelStandardIds.h>
 #include <KoColorConversions.h>
 
 #include <KoCanvasResourceManager.h>
 #include "kis_config_notifier.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_canvas2.h"
 #include "KisViewManager.h"
 #include "kis_image.h"
 #include "kis_node.h"
 
 #include "kundo2command.h"
 #include "kis_config.h"
 #include "kis_paint_device.h"
 #include "kis_iterator_ng.h"
 
 Q_GLOBAL_STATIC(KisDisplayColorConverter, s_instance)
 
 
 struct KisDisplayColorConverter::Private
 {
     Private(KisDisplayColorConverter *_q, KoCanvasResourceManager *_resourceManager)
         : q(_q),
           resourceManager(_resourceManager),
           nodeColorSpace(0),
           paintingColorSpace(0),
           monitorColorSpace(0),
           monitorProfile(0),
           renderingIntent(KoColorConversionTransformation::internalRenderingIntent()),
           conversionFlags(KoColorConversionTransformation::internalConversionFlags()),
           displayFilter(0),
           intermediateColorSpace(0),
           displayRenderer(new DisplayRenderer(_q, _resourceManager))
     {
     }
 
     KisDisplayColorConverter *const q;
 
     KoCanvasResourceManager *resourceManager;
 
     const KoColorSpace *nodeColorSpace;
     const KoColorSpace *paintingColorSpace;
     const KoColorSpace *monitorColorSpace;
 
     const KoColorProfile *monitorProfile;
 
     KoColorConversionTransformation::Intent renderingIntent;
     KoColorConversionTransformation::ConversionFlags conversionFlags;
 
     QSharedPointer<KisDisplayFilter> displayFilter;
     const KoColorSpace *intermediateColorSpace;
 
     KoColor intermediateFgColor;
     KisNodeSP connectedNode;
 
     inline KoColor approximateFromQColor(const QColor &qcolor);
     inline QColor approximateToQColor(const KoColor &color);
 
     void slotCanvasResourceChanged(int key, const QVariant &v);
     void slotUpdateCurrentNodeColorSpace();
     void selectPaintingColorSpace();
 
     void updateIntermediateFgColor(const KoColor &color);
     void setCurrentNode(KisNodeSP node);
     bool useOcio() const;
 
     bool finalIsRgba(const KoColorSpace *cs) const;
 
     template <bool flipToBgra>
     QColor floatArrayToQColor(const float *p);
 
     template <bool flipToBgra>
     QImage convertToQImageDirect(KisPaintDeviceSP device);
 
     class DisplayRenderer : public KoColorDisplayRendererInterface {
     public:
         DisplayRenderer(KisDisplayColorConverter *displayColorConverter, KoCanvasResourceManager *resourceManager)
             : m_displayColorConverter(displayColorConverter),
               m_resourceManager(resourceManager)
         {
             displayColorConverter->connect(displayColorConverter, SIGNAL(displayConfigurationChanged()),
                             this, SIGNAL(displayConfigurationChanged()));
         }
 
         QImage convertToQImage(const KoColorSpace *srcColorSpace, const quint8 *data, qint32 width, qint32 height) const override {
             KisPaintDeviceSP dev = new KisPaintDevice(srcColorSpace);
             dev->writeBytes(data, 0, 0, width, height);
             return m_displayColorConverter->toQImage(dev);
         }
 
         QColor toQColor(const KoColor &c) const override {
             return m_displayColorConverter->toQColor(c);
         }
 
         KoColor approximateFromRenderedQColor(const QColor &c) const override {
             return m_displayColorConverter->approximateFromRenderedQColor(c);
         }
 
         KoColor fromHsv(int h, int s, int v, int a) const override {
             return m_displayColorConverter->fromHsv(h, s, v, a);
         }
 
         void getHsv(const KoColor &srcColor, int *h, int *s, int *v, int *a) const override {
             m_displayColorConverter->getHsv(srcColor, h, s, v, a);
         }
 
         qreal minVisibleFloatValue(const KoChannelInfo *chaninfo) const override {
             return chaninfo->getUIMin();
         }
 
         qreal maxVisibleFloatValue(const KoChannelInfo *chaninfo) const override {
             qreal maxValue = chaninfo->getUIMax();
 
             if (m_resourceManager) {
                 qreal exposure = m_resourceManager->resource(KisCanvasResourceProvider::HdrExposure).value<qreal>();
                 // not sure if *= is what we want
                 maxValue *= std::pow(2.0, -exposure);
             }
 
             return maxValue;
         }
 
         const KoColorSpace* getPaintingColorSpace() const override {
             return m_displayColorConverter->paintingColorSpace();
         }
 
     private:
         KisDisplayColorConverter *m_displayColorConverter;
         QPointer<KoCanvasResourceManager> m_resourceManager;
     };
 
     QScopedPointer<KoColorDisplayRendererInterface> displayRenderer;
 };
 
 KisDisplayColorConverter::KisDisplayColorConverter(KoCanvasResourceManager *resourceManager, QObject *parent)
     : QObject(parent),
       m_d(new Private(this, resourceManager))
 {
 
     connect(m_d->resourceManager, SIGNAL(canvasResourceChanged(int, const QVariant&)),
             SLOT(slotCanvasResourceChanged(int, const QVariant&)));
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()),
             SLOT(selectPaintingColorSpace()));
 
 
     m_d->setCurrentNode(0);
     setMonitorProfile(0);
     setDisplayFilter(QSharedPointer<KisDisplayFilter>(0));
 }
 
 KisDisplayColorConverter::KisDisplayColorConverter()
     : m_d(new Private(this, 0))
 {
     setDisplayFilter(QSharedPointer<KisDisplayFilter>(0));
 
     m_d->paintingColorSpace = KoColorSpaceRegistry::instance()->rgb8();
 
     m_d->setCurrentNode(0);
     setMonitorProfile(0);
 
 }
 
 KisDisplayColorConverter::~KisDisplayColorConverter()
 {
 }
 
 KisDisplayColorConverter* KisDisplayColorConverter::dumbConverterInstance()
 {
     return s_instance;
 }
 
 KoColorDisplayRendererInterface* KisDisplayColorConverter::displayRendererInterface() const
 {
     return m_d->displayRenderer.data();
 }
 
 bool KisDisplayColorConverter::Private::useOcio() const
 {
     return displayFilter && paintingColorSpace->colorModelId() == RGBAColorModelID;
 }
 
 void KisDisplayColorConverter::Private::updateIntermediateFgColor(const KoColor &srcColor)
 {
     KIS_ASSERT_RECOVER_RETURN(displayFilter);
 
     KoColor color = srcColor;
     color.convertTo(intermediateColorSpace);
     displayFilter->approximateForwardTransformation(color.data(), 1);
     intermediateFgColor = color;
 }
 
 void KisDisplayColorConverter::Private::slotCanvasResourceChanged(int key, const QVariant &v)
 {
     if (key == KisCanvasResourceProvider::CurrentKritaNode) {
         KisNodeSP currentNode = v.value<KisNodeWSP>();
         setCurrentNode(currentNode);
     } else if (useOcio() && key == KoCanvasResourceManager::ForegroundColor) {
         updateIntermediateFgColor(v.value<KoColor>());
     }
 }
 
 void KisDisplayColorConverter::Private::slotUpdateCurrentNodeColorSpace()
 {
     setCurrentNode(connectedNode);
 }
 
 inline KisPaintDeviceSP findValidDevice(KisNodeSP node) {
     return node->paintDevice() ? node->paintDevice() : node->original();
 }
 
 void KisDisplayColorConverter::Private::setCurrentNode(KisNodeSP node)
 {
     if (connectedNode) {
         KisPaintDeviceSP device = findValidDevice(connectedNode);
 
         if (device) {
             q->disconnect(device, 0);
         }
     }
 
+    nodeColorSpace = 0;
+
     if (node) {
         KisPaintDeviceSP device = findValidDevice(node);
 
         nodeColorSpace = device ?
             device->compositionSourceColorSpace() :
             node->colorSpace();
 
-        KIS_ASSERT_RECOVER_NOOP(nodeColorSpace);
+        KIS_SAFE_ASSERT_RECOVER_NOOP(nodeColorSpace);
 
         if (device) {
             q->connect(device, SIGNAL(profileChanged(const KoColorProfile*)),
                        SLOT(slotUpdateCurrentNodeColorSpace()), Qt::UniqueConnection);
             q->connect(device, SIGNAL(colorSpaceChanged(const KoColorSpace*)),
                        SLOT(slotUpdateCurrentNodeColorSpace()), Qt::UniqueConnection);
         }
 
-    } else {
+    }
+
+    if (!nodeColorSpace) {
         nodeColorSpace = KoColorSpaceRegistry::instance()->rgb8();
     }
 
     connectedNode = node;
     selectPaintingColorSpace();
 }
 
 void KisDisplayColorConverter::Private::selectPaintingColorSpace()
 {
     KisConfig cfg;
     paintingColorSpace = cfg.customColorSelectorColorSpace();
 
     if (!paintingColorSpace || displayFilter) {
         paintingColorSpace = nodeColorSpace;
     }
 
     emit q->displayConfigurationChanged();
 }
 
 const KoColorSpace* KisDisplayColorConverter::paintingColorSpace() const
 {
     KIS_ASSERT_RECOVER(m_d->paintingColorSpace) {
         return KoColorSpaceRegistry::instance()->rgb8();
     }
 
     return m_d->paintingColorSpace;
 }
 
 void KisDisplayColorConverter::setMonitorProfile(const KoColorProfile *monitorProfile)
 {
     m_d->monitorColorSpace = KoColorSpaceRegistry::instance()->rgb8(monitorProfile);
     m_d->monitorProfile = monitorProfile;
 
     m_d->renderingIntent = renderingIntent();
     m_d->conversionFlags = conversionFlags();
 
     emit displayConfigurationChanged();
 }
 
 void KisDisplayColorConverter::setDisplayFilter(QSharedPointer<KisDisplayFilter> displayFilter)
 {
     if (m_d->displayFilter && displayFilter &&
         displayFilter->lockCurrentColorVisualRepresentation()) {
 
         KoColor color(m_d->intermediateFgColor);
         displayFilter->approximateInverseTransformation(color.data(), 1);
         color.convertTo(m_d->paintingColorSpace);
         m_d->resourceManager->setForegroundColor(color);
     }
 
     m_d->displayFilter = displayFilter;
     m_d->intermediateColorSpace = 0;
 
     if (m_d->displayFilter) {
         // choosing default profile, which is scRGB
         const KoColorProfile *intermediateProfile = 0;
         m_d->intermediateColorSpace =
             KoColorSpaceRegistry::instance()->
             colorSpace(RGBAColorModelID.id(), Float32BitsColorDepthID.id(), intermediateProfile);
 
         KIS_ASSERT_RECOVER(m_d->intermediateColorSpace) {
             m_d->intermediateColorSpace = m_d->monitorColorSpace;
         }
 
         m_d->updateIntermediateFgColor(
             m_d->resourceManager->foregroundColor());
     }
 
 
     { // sanity check
         KisConfig cfg;
         //KIS_ASSERT_RECOVER_NOOP(cfg.useOcio() == (bool) m_d->displayFilter);
     }
 
     m_d->selectPaintingColorSpace();
 }
 
 
 KoColorConversionTransformation::Intent
 KisDisplayColorConverter::renderingIntent()
 {
     KisConfig cfg;
     return (KoColorConversionTransformation::Intent)cfg.monitorRenderIntent();
 }
 
 KoColorConversionTransformation::ConversionFlags
 KisDisplayColorConverter::conversionFlags()
 {
     KoColorConversionTransformation::ConversionFlags conversionFlags =
         KoColorConversionTransformation::HighQuality;
 
     KisConfig cfg;
 
     if (cfg.useBlackPointCompensation()) conversionFlags |= KoColorConversionTransformation::BlackpointCompensation;
     if (!cfg.allowLCMSOptimization()) conversionFlags |= KoColorConversionTransformation::NoOptimization;
 
     return conversionFlags;
 }
 
 QSharedPointer<KisDisplayFilter> KisDisplayColorConverter::displayFilter() const
 {
     return m_d->displayFilter;
 }
 
 const KoColorProfile* KisDisplayColorConverter::monitorProfile() const
 {
     return m_d->monitorProfile;
 }
 
 bool KisDisplayColorConverter::Private::finalIsRgba(const KoColorSpace *cs) const
 {
     /**
      * In Krita RGB color spaces differ: 8/16bit are BGRA, 16f/32f-bit RGBA
      */
     KoID colorDepthId = cs->colorDepthId();
     return colorDepthId == Float16BitsColorDepthID ||
         colorDepthId == Float32BitsColorDepthID;
 }
 
 template <bool flipToBgra>
 QColor KisDisplayColorConverter::Private::floatArrayToQColor(const float *p) {
     if (flipToBgra) {
         return QColor(KoColorSpaceMaths<float, quint8>::scaleToA(p[0]),
                       KoColorSpaceMaths<float, quint8>::scaleToA(p[1]),
                       KoColorSpaceMaths<float, quint8>::scaleToA(p[2]),
                       KoColorSpaceMaths<float, quint8>::scaleToA(p[3]));
     } else {
         return QColor(KoColorSpaceMaths<float, quint8>::scaleToA(p[2]),
                       KoColorSpaceMaths<float, quint8>::scaleToA(p[1]),
                       KoColorSpaceMaths<float, quint8>::scaleToA(p[0]),
                       KoColorSpaceMaths<float, quint8>::scaleToA(p[3]));
     }
 }
 
 QColor KisDisplayColorConverter::toQColor(const KoColor &srcColor) const
 {
     KoColor c(srcColor);
     c.convertTo(m_d->paintingColorSpace);
 
     if (!m_d->useOcio()) {
         // we expect the display profile is rgb8, which is BGRA here
         KIS_ASSERT_RECOVER(m_d->monitorColorSpace->pixelSize() == 4) { return Qt::red; };
 
         c.convertTo(m_d->monitorColorSpace, m_d->renderingIntent, m_d->conversionFlags);
 
         const quint8 *p = c.data();
         return QColor(p[2], p[1], p[0], p[3]);
     } else {
         const KoColorSpace *srcCS = c.colorSpace();
 
         if (m_d->displayFilter->useInternalColorManagement()) {
             srcCS = KoColorSpaceRegistry::instance()->colorSpace(
                 RGBAColorModelID.id(),
                 Float32BitsColorDepthID.id(),
                 m_d->monitorProfile);
             c.convertTo(srcCS, m_d->renderingIntent, m_d->conversionFlags);
         }
 
         int numChannels = srcCS->channelCount();
         QVector<float> normalizedChannels(numChannels);
         srcCS->normalisedChannelsValue(c.data(), normalizedChannels);
         m_d->displayFilter->filter((quint8*)normalizedChannels.data(), 1);
 
         const float *p = (const float *)normalizedChannels.constData();
 
         return m_d->finalIsRgba(srcCS) ?
             m_d->floatArrayToQColor<true>(p) :
             m_d->floatArrayToQColor<false>(p);
     }
 }
 
 KoColor KisDisplayColorConverter::approximateFromRenderedQColor(const QColor &c) const
 {
     return m_d->approximateFromQColor(c);
 }
 
 template <bool flipToBgra>
 QImage
 KisDisplayColorConverter::Private::convertToQImageDirect(KisPaintDeviceSP device)
 {
     QRect bounds = device->exactBounds();
     if (bounds.isEmpty()) return QImage();
 
     QImage image(bounds.size(), QImage::Format_ARGB32);
 
     KisSequentialConstIterator it(device, bounds);
     quint8 *dstPtr = image.bits();
 
     const KoColorSpace *cs = device->colorSpace();
     int numChannels = cs->channelCount();
     QVector<float> normalizedChannels(numChannels);
 
     while (it.nextPixel()) {
         cs->normalisedChannelsValue(it.rawDataConst(), normalizedChannels);
         displayFilter->filter((quint8*)normalizedChannels.data(), 1);
 
         const float *p = normalizedChannels.constData();
 
         if (flipToBgra) {
             dstPtr[0] = KoColorSpaceMaths<float, quint8>::scaleToA(p[2]);
             dstPtr[1] = KoColorSpaceMaths<float, quint8>::scaleToA(p[1]);
             dstPtr[2] = KoColorSpaceMaths<float, quint8>::scaleToA(p[0]);
             dstPtr[3] = KoColorSpaceMaths<float, quint8>::scaleToA(p[3]);
         } else {
             dstPtr[0] = KoColorSpaceMaths<float, quint8>::scaleToA(p[0]);
             dstPtr[1] = KoColorSpaceMaths<float, quint8>::scaleToA(p[1]);
             dstPtr[2] = KoColorSpaceMaths<float, quint8>::scaleToA(p[2]);
             dstPtr[3] = KoColorSpaceMaths<float, quint8>::scaleToA(p[3]);
         }
 
         dstPtr += 4;
     }
 
     return image;
 }
 
 QImage KisDisplayColorConverter::toQImage(KisPaintDeviceSP srcDevice) const
 {
     KisPaintDeviceSP device = srcDevice;
     if (*device->colorSpace() != *m_d->paintingColorSpace) {
         device = new KisPaintDevice(*srcDevice);
 
         KUndo2Command *cmd = device->convertTo(m_d->paintingColorSpace);
         delete cmd;
     }
 
     if (!m_d->useOcio()) {
         return device->convertToQImage(m_d->monitorProfile, m_d->renderingIntent, m_d->conversionFlags);
     } else {
         if (m_d->displayFilter->useInternalColorManagement()) {
             if (device == srcDevice) {
                 device = new KisPaintDevice(*srcDevice);
             }
 
             const KoColorSpace *srcCS =
                 KoColorSpaceRegistry::instance()->colorSpace(
                     RGBAColorModelID.id(),
                     Float32BitsColorDepthID.id(),
                     m_d->monitorProfile);
 
             KUndo2Command *cmd = device->convertTo(srcCS, m_d->renderingIntent, m_d->conversionFlags);
             delete cmd;
         }
 
         return m_d->finalIsRgba(device->colorSpace()) ?
             m_d->convertToQImageDirect<true>(device) :
             m_d->convertToQImageDirect<false>(device);
     }
 
     return QImage();
 }
 
 KoColor KisDisplayColorConverter::Private::approximateFromQColor(const QColor &qcolor)
 {
     if (!useOcio()) {
         return KoColor(qcolor, paintingColorSpace);
     } else {
         KoColor color(qcolor, intermediateColorSpace);
         displayFilter->approximateInverseTransformation(color.data(), 1);
         color.convertTo(paintingColorSpace);
         return color;
     }
 
     qFatal("Must not be reachable");
     return KoColor();
 }
 
 QColor KisDisplayColorConverter::Private::approximateToQColor(const KoColor &srcColor)
 {
     KoColor color(srcColor);
 
     if (useOcio()) {
         color.convertTo(intermediateColorSpace);
         displayFilter->approximateForwardTransformation(color.data(), 1);
     }
 
     return color.toQColor();
 }
 
 
 KoColor KisDisplayColorConverter::fromHsv(int h, int s, int v, int a) const
 {
     // generate HSV from sRGB!
     QColor qcolor(QColor::fromHsv(h, s, v, a));
     return m_d->approximateFromQColor(qcolor);
 }
 
 void KisDisplayColorConverter::getHsv(const KoColor &srcColor, int *h, int *s, int *v, int *a) const
 {
     // we are going through sRGB here!
     QColor color = m_d->approximateToQColor(srcColor);
     color.getHsv(h, s, v, a);
 }
 
 KoColor KisDisplayColorConverter::fromHsvF(qreal h, qreal s, qreal v, qreal a)
 {
     // generate HSV from sRGB!
     QColor qcolor(QColor::fromHsvF(h, s, v, a));
     return m_d->approximateFromQColor(qcolor);
 }
 
 void KisDisplayColorConverter::getHsvF(const KoColor &srcColor, qreal *h, qreal *s, qreal *v, qreal *a)
 {
     // we are going through sRGB here!
     QColor color = m_d->approximateToQColor(srcColor);
     color.getHsvF(h, s, v, a);
 }
 
 KoColor KisDisplayColorConverter::fromHslF(qreal h, qreal s, qreal l, qreal a)
 {
     // generate HSL from sRGB!
     QColor qcolor(QColor::fromHslF(h, s, l, a));
     if (!qcolor.isValid()) {
         warnKrita << "Could not construct valid color from h" << h << "s" << s << "l" << l << "a" << a;
         qcolor = Qt::black;
     }
     return m_d->approximateFromQColor(qcolor);
 
 }
 
 void KisDisplayColorConverter::getHslF(const KoColor &srcColor, qreal *h, qreal *s, qreal *l, qreal *a)
 {
     // we are going through sRGB here!
     QColor color = m_d->approximateToQColor(srcColor);
     color.getHslF(h, s, l, a);
 }
 
 KoColor KisDisplayColorConverter::fromHsiF(qreal h, qreal s, qreal i)
 {
     // generate HSI from sRGB!
     qreal r=0.0;
     qreal g=0.0;
     qreal b=0.0;
     qreal a=1.0;
     HSIToRGB(h, s, i, &r, &g, &b);
     QColor qcolor;
     qcolor.setRgbF(qBound(0.0,r,1.0), qBound(0.0,g,1.0), qBound(0.0,b,1.0), a);
     return m_d->approximateFromQColor(qcolor);
 }
 
 void KisDisplayColorConverter::getHsiF(const KoColor &srcColor, qreal *h, qreal *s, qreal *i)
 {
     // we are going through sRGB here!
     QColor color = m_d->approximateToQColor(srcColor);
     qreal r=color.redF();
     qreal g=color.greenF();
     qreal b=color.blueF();
     RGBToHSI(r, g, b, h, s, i);
 }
 
 KoColor KisDisplayColorConverter::fromHsyF(qreal h, qreal s, qreal y, qreal R, qreal G, qreal B, qreal gamma)
 {
     // generate HSL from sRGB!
     QVector <qreal> channelValues(3);
     y = pow(y, gamma);
     HSYToRGB(h, s, y, &channelValues[0], &channelValues[1], &channelValues[2], R, G, B);
     KoColorSpaceRegistry::instance()->rgb8()->profile()->delinearizeFloatValueFast(channelValues);
     QColor qcolor;
     qcolor.setRgbF(qBound(0.0,channelValues[0],1.0), qBound(0.0,channelValues[1],1.0), qBound(0.0,channelValues[2],1.0), 1.0);
     return m_d->approximateFromQColor(qcolor);
 }
 
 void KisDisplayColorConverter::getHsyF(const KoColor &srcColor, qreal *h, qreal *s, qreal *y, qreal R, qreal G, qreal B, qreal gamma)
 {
     // we are going through sRGB here!
     QColor color = m_d->approximateToQColor(srcColor);
     QVector <qreal> channelValues(3);
     channelValues[0]=color.redF();
     channelValues[1]=color.greenF();
     channelValues[2]=color.blueF();
     //TODO: if we're going to have KoColor here, remember to check whether the TRC of the profile exists...
     KoColorSpaceRegistry::instance()->rgb8()->profile()->linearizeFloatValueFast(channelValues);
     RGBToHSY(channelValues[0], channelValues[1], channelValues[2], h, s, y, R, G, B);
     *y = pow(*y, 1/gamma);
 }
 
 #include "moc_kis_display_color_converter.cpp"
diff --git a/libs/ui/dialogs/kis_dlg_file_layer.cpp b/libs/ui/dialogs/kis_dlg_file_layer.cpp
index 9935d70ef4..a0be8a89cb 100644
--- a/libs/ui/dialogs/kis_dlg_file_layer.cpp
+++ b/libs/ui/dialogs/kis_dlg_file_layer.cpp
@@ -1,120 +1,120 @@
 /* This file is part of the KDE project
  * Copyright (C) Boudewijn Rempt <boud@valdyas.org>, (C) 2013
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "kis_dlg_file_layer.h"
 
 #include <QLineEdit>
 #include <QCheckBox>
 #include <QStandardPaths>
 
 #include <klocalizedstring.h>
 
 #include <KoFileDialog.h>
 #include <KisApplication.h>
 #include <KisImportExportManager.h>
 #include <kis_file_name_requester.h>
 #include <kis_config_widget.h>
 #include <kis_paint_device.h>
 #include <kis_transaction.h>
 #include <kis_node.h>
 #include <kis_file_layer.h>
 
 KisDlgFileLayer::KisDlgFileLayer(const QString &basePath, const QString & name, QWidget * parent)
     : KoDialog(parent)
     , m_basePath(basePath)
 {
     setButtons(Ok | Cancel);
     setDefaultButton(Ok);
     QWidget * page = new QWidget(this);
     dlgWidget.setupUi(page);
-    QStringList mimes = KisImportExportManager::mimeFilter(KisImportExportManager::Import);
+    QStringList mimes = KisImportExportManager::supportedMimeTypes(KisImportExportManager::Import);
     // Nesting .kra files is not supported, so do not offer that option. See https://bugs.kde.org/show_bug.cgi?id=386515
     mimes.removeAll("application/x-krita");
     dlgWidget.wdgUrlRequester->setMimeTypeFilters(mimes);
     setMainWidget(page);
 
     //dlgWidget.wdgUrlRequester->setBasePath(m_basePath);
     dlgWidget.wdgUrlRequester->setStartDir(m_basePath);
 
     dlgWidget.txtLayerName->setText(name);
 
     connect(dlgWidget.wdgUrlRequester, SIGNAL(textChanged(const QString &)),
             SLOT(slotNameChanged(const QString &)));
 
     enableButtonOk(false);
 }
 
 void KisDlgFileLayer::slotNameChanged(const QString & text)
 {
     enableButtonOk(!text.isEmpty());
 }
 
 QString KisDlgFileLayer::layerName() const
 {
     return dlgWidget.txtLayerName->text();
 }
 
 KisFileLayer::ScalingMethod KisDlgFileLayer::scaleToImageResolution() const
 {
     if (dlgWidget.radioDontScale->isChecked()) {
         return KisFileLayer::None;
     }
     else if (dlgWidget.radioScaleToImageSize->isChecked()) {
         return KisFileLayer::ToImageSize;
     }
     else {
         return KisFileLayer::ToImagePPI;
     }
 }
 
 void KisDlgFileLayer::setFileName(QString fileName)
 {
     dlgWidget.wdgUrlRequester->setFileName(fileName);
 }
 
 void KisDlgFileLayer::setScalingMethod(KisFileLayer::ScalingMethod method)
 {
     dlgWidget.radioDontScale->setChecked(false);
     dlgWidget.radioScaleToImageSize->setChecked(false);
     dlgWidget.radioScalePPI->setChecked(false);
     if (method == KisFileLayer::None) {
         dlgWidget.radioDontScale->setChecked(true);
     } else if (method == KisFileLayer::ToImageSize) {
         dlgWidget.radioScaleToImageSize->setChecked(true);
     } else {
         dlgWidget.radioScalePPI->setChecked(true);
     }
 }
 
 QString KisDlgFileLayer::fileName() const
 {
     QString path = dlgWidget.wdgUrlRequester->fileName();
     QFileInfo fi(path);
     if (fi.isSymLink()) {
         path = fi.symLinkTarget();
         fi = QFileInfo(path);
     }
     if (!m_basePath.isEmpty() && fi.isAbsolute()) {
         QDir directory(m_basePath);
         path = directory.relativeFilePath(path);
     }
 
     return path;
 }
 
diff --git a/libs/ui/dialogs/kis_dlg_import_image_sequence.cpp b/libs/ui/dialogs/kis_dlg_import_image_sequence.cpp
index 5fa8ae5db9..696b025fa4 100644
--- a/libs/ui/dialogs/kis_dlg_import_image_sequence.cpp
+++ b/libs/ui/dialogs/kis_dlg_import_image_sequence.cpp
@@ -1,163 +1,163 @@
 /*
  *  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_dlg_import_image_sequence.h"
 
 #include "KisDocument.h"
 #include "KisMainWindow.h"
 #include "kis_image.h"
 #include "kis_image_animation_interface.h"
 #include "KisImportExportManager.h"
 #include "KoFileDialog.h"
 #include <QStandardPaths>
 
 
 class KisDlgImportImageSequence::ListItem : QListWidgetItem {
 
 public:
     ListItem(const QString &text, QListWidget *view, QCollator *collator)
         : QListWidgetItem(text, view),
        collator(collator)
     {}
 
     bool operator <(const QListWidgetItem &other) const override
     {
         int cmp = collator->compare(this->text(), other.text());
         return cmp < 0;
     }
 
 private:
     QCollator *collator;
 };
 
 KisDlgImportImageSequence::KisDlgImportImageSequence(KisMainWindow *mainWindow, KisDocument *document) :
     KoDialog(mainWindow),
     m_mainWindow(mainWindow),
     m_document(document)
 {
     setButtons(Ok | Cancel);
     setDefaultButton(Ok);
 
     QWidget * page = new QWidget(this);
     m_ui.setupUi(page);
     setMainWidget(page);
 
     enableButtonOk(false);
 
     m_ui.cmbOrder->addItem(i18n("Ascending"), Ascending);
     m_ui.cmbOrder->addItem(i18n("Descending"), Descending);
     m_ui.cmbOrder->setCurrentIndex(0);
 
     m_ui.cmbSortMode->addItem(i18n("Alphabetical"), Natural);
     m_ui.cmbSortMode->addItem(i18n("Numerical"), Numerical);
     m_ui.cmbSortMode->setCurrentIndex(1);
 
     m_ui.lstFiles->setSelectionMode(QAbstractItemView::ExtendedSelection);
 
     connect(m_ui.btnAddImages, &QAbstractButton::clicked, this, &KisDlgImportImageSequence::slotAddFiles);
     connect(m_ui.btnRemove, &QAbstractButton::clicked, this, &KisDlgImportImageSequence::slotRemoveFiles);
     connect(m_ui.spinStep, SIGNAL(valueChanged(int)), this, SLOT(slotSkipChanged(int)));
     connect(m_ui.cmbOrder, SIGNAL(currentIndexChanged(int)), this, SLOT(slotOrderOptionsChanged(int)));
     connect(m_ui.cmbSortMode, SIGNAL(currentIndexChanged(int)), this, SLOT(slotOrderOptionsChanged(int)));
 
     // cold initialization of the controls
     slotSkipChanged(m_ui.spinStep->value());
     slotOrderOptionsChanged(m_ui.cmbOrder->currentIndex());
     slotOrderOptionsChanged(m_ui.cmbSortMode->currentIndex());
 }
 
 QStringList KisDlgImportImageSequence::files()
 {
     QStringList list;
 
     for (int i=0; i < m_ui.lstFiles->count(); i++) {
         list.append(m_ui.lstFiles->item(i)->text());
     }
 
     return list;
 }
 
 int KisDlgImportImageSequence::firstFrame()
 {
     return m_ui.spinFirstFrame->value();
 }
 
 int KisDlgImportImageSequence::step()
 {
     return m_ui.spinStep->value();
 }
 
 void KisDlgImportImageSequence::slotAddFiles()
 {
     QStringList urls = showOpenFileDialog();
 
     if (!urls.isEmpty()) {
         Q_FOREACH(QString url, urls) {
             new ListItem(url, m_ui.lstFiles, &m_collator);
         }
 
         sortFileList();
     }
 
     enableButtonOk(m_ui.lstFiles->count() > 0);
 }
 
 QStringList KisDlgImportImageSequence::showOpenFileDialog()
 {
     KoFileDialog dialog(this, KoFileDialog::ImportFiles, "OpenDocument");
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
-    dialog.setMimeTypeFilters(KisImportExportManager::mimeFilter(KisImportExportManager::Import));
+    dialog.setMimeTypeFilters(KisImportExportManager::supportedMimeTypes(KisImportExportManager::Import));
     dialog.setCaption(i18n("Import Images"));
 
     return dialog.filenames();
 }
 
 
 
 void KisDlgImportImageSequence::slotRemoveFiles()
 {
     QList<QListWidgetItem*> selected = m_ui.lstFiles->selectedItems();
 
     Q_FOREACH(QListWidgetItem *item, selected) {
         delete item;
     }
 
     enableButtonOk(m_ui.lstFiles->count() > 0);
 }
 
 void KisDlgImportImageSequence::slotSkipChanged(int)
 {
     int documentFps = m_document->image()->animationInterface()->framerate();
     float sourceFps = 1.0f * documentFps / m_ui.spinStep->value();
 
     m_ui.lblFramerate->setText(i18n("Source fps: %1", sourceFps));
 }
 
 void KisDlgImportImageSequence::slotOrderOptionsChanged(int)
 {
     sortFileList();
 }
 
 void KisDlgImportImageSequence::sortFileList()
 {
     int order = m_ui.cmbOrder->currentData().toInt();
     bool numeric = m_ui.cmbSortMode->currentData().toInt() == Numerical;
 
     m_collator.setNumericMode(numeric);
     m_ui.lstFiles->sortItems((order == Ascending) ? Qt::AscendingOrder : Qt::DescendingOrder);
 }
diff --git a/libs/ui/dialogs/kis_dlg_layer_style.cpp b/libs/ui/dialogs/kis_dlg_layer_style.cpp
index 3e94ed1088..57fa9de80e 100644
--- a/libs/ui/dialogs/kis_dlg_layer_style.cpp
+++ b/libs/ui/dialogs/kis_dlg_layer_style.cpp
@@ -1,1451 +1,1452 @@
 /*
  *  Copyright (c) 2014 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "kis_dlg_layer_style.h"
 
 #include <QWidget>
 #include <QStackedWidget>
 #include <QTreeWidget>
 #include <QListWidget>
 #include <QListWidgetItem>
 #include <QComboBox>
 #include <QDial>
 #include <QCheckBox>
 #include <QSpinBox>
 #include <QUuid>
 #include <QInputDialog>
 
 
 #include <KoColorPopupButton.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoResourceServerProvider.h>
 
 #include "kis_config.h"
 #include "kis_cmb_contour.h"
 #include "kis_cmb_gradient.h"
 #include "KisResourceServerProvider.h"
 #include "kis_psd_layer_style_resource.h"
 #include "kis_psd_layer_style.h"
 
 #include "kis_signals_blocker.h"
 #include "kis_signal_compressor.h"
 #include "kis_canvas_resource_provider.h"
 
 #include <KoFileDialog.h>
 
 
 
 KoAbstractGradient* fetchGradientLazy(KoAbstractGradient *gradient,
                                       KisCanvasResourceProvider *resourceProvider)
 {
     if (!gradient) {
         gradient = resourceProvider->currentGradient();
     }
     return gradient;
 }
 
 KisDlgLayerStyle::KisDlgLayerStyle(KisPSDLayerStyleSP layerStyle, KisCanvasResourceProvider *resourceProvider, QWidget *parent)
     : KoDialog(parent)
     , m_layerStyle(layerStyle)
     , m_initialLayerStyle(layerStyle->clone())
     , m_isSwitchingPredefinedStyle(false)
     , m_sanityLayerStyleDirty(false)
 {
     setCaption(i18n("Layer Styles"));
     setButtons(Ok | Cancel);
     setDefaultButton(Ok);
 
     m_configChangedCompressor =
         new KisSignalCompressor(1000, KisSignalCompressor::POSTPONE, this);
     connect(m_configChangedCompressor, SIGNAL(timeout()), SIGNAL(configChanged()));
 
     QWidget *page = new QWidget(this);
     wdgLayerStyles.setupUi(page);
     setMainWidget(page);
+    wdgLayerStyles.chkPreview->setVisible(false);
 
     connect(wdgLayerStyles.lstStyleSelector, SIGNAL(itemChanged(QListWidgetItem*)), SLOT(notifyGuiConfigChanged()));
 
     m_stylesSelector = new StylesSelector(this);
     connect(m_stylesSelector, SIGNAL(styleSelected(KisPSDLayerStyleSP)), SLOT(notifyPredefinedStyleSelected(KisPSDLayerStyleSP)));
     wdgLayerStyles.stylesStack->addWidget(m_stylesSelector);
 
     m_blendingOptions = new BlendingOptions(this);
     wdgLayerStyles.stylesStack->addWidget(m_blendingOptions);
 
     m_dropShadow = new DropShadow(DropShadow::DropShadowMode, this);
     wdgLayerStyles.stylesStack->addWidget(m_dropShadow);
     connect(m_dropShadow, SIGNAL(configChanged()), SLOT(notifyGuiConfigChanged()));
 
     m_innerShadow = new DropShadow(DropShadow::InnerShadowMode, this);
     wdgLayerStyles.stylesStack->addWidget(m_innerShadow);
     connect(m_innerShadow, SIGNAL(configChanged()), SLOT(notifyGuiConfigChanged()));
 
     m_outerGlow = new InnerGlow(InnerGlow::OuterGlowMode, resourceProvider, this);
     wdgLayerStyles.stylesStack->addWidget(m_outerGlow);
     connect(m_outerGlow, SIGNAL(configChanged()), SLOT(notifyGuiConfigChanged()));
 
     m_innerGlow = new InnerGlow(InnerGlow::InnerGlowMode, resourceProvider, this);
     wdgLayerStyles.stylesStack->addWidget(m_innerGlow);
     connect(m_innerGlow, SIGNAL(configChanged()), SLOT(notifyGuiConfigChanged()));
 
     m_contour = new Contour(this);
     m_texture = new Texture(this);
     m_bevelAndEmboss = new BevelAndEmboss(m_contour, m_texture, this);
 
     wdgLayerStyles.stylesStack->addWidget(m_bevelAndEmboss);
     wdgLayerStyles.stylesStack->addWidget(m_contour);
     wdgLayerStyles.stylesStack->addWidget(m_texture);
 
     connect(m_bevelAndEmboss, SIGNAL(configChanged()), SLOT(notifyGuiConfigChanged()));
 
     m_satin = new Satin(this);
     wdgLayerStyles.stylesStack->addWidget(m_satin);
     connect(m_satin, SIGNAL(configChanged()), SLOT(notifyGuiConfigChanged()));
 
     m_colorOverlay = new ColorOverlay(this);
     wdgLayerStyles.stylesStack->addWidget(m_colorOverlay);
     connect(m_colorOverlay, SIGNAL(configChanged()), SLOT(notifyGuiConfigChanged()));
 
     m_gradientOverlay = new GradientOverlay(resourceProvider, this);
     wdgLayerStyles.stylesStack->addWidget(m_gradientOverlay);
     connect(m_gradientOverlay, SIGNAL(configChanged()), SLOT(notifyGuiConfigChanged()));
 
     m_patternOverlay = new PatternOverlay(this);
     wdgLayerStyles.stylesStack->addWidget(m_patternOverlay);
     connect(m_patternOverlay, SIGNAL(configChanged()), SLOT(notifyGuiConfigChanged()));
 
     m_stroke = new Stroke(resourceProvider, this);
     wdgLayerStyles.stylesStack->addWidget(m_stroke);
     connect(m_stroke, SIGNAL(configChanged()), SLOT(notifyGuiConfigChanged()));
 
     KisConfig cfg;
     wdgLayerStyles.stylesStack->setCurrentIndex(cfg.readEntry("KisDlgLayerStyle::current", 1));
     wdgLayerStyles.lstStyleSelector->setCurrentRow(cfg.readEntry("KisDlgLayerStyle::current", 1));
 
     connect(wdgLayerStyles.lstStyleSelector,
             SIGNAL(currentItemChanged(QListWidgetItem*,QListWidgetItem*)),
              this, SLOT(changePage(QListWidgetItem*,QListWidgetItem*)));
 
     notifyPredefinedStyleSelected(layerStyle);
 
     connect(m_dropShadow, SIGNAL(globalAngleChanged(int)), SLOT(syncGlobalAngle(int)));
     connect(m_innerShadow, SIGNAL(globalAngleChanged(int)), SLOT(syncGlobalAngle(int)));
     connect(m_bevelAndEmboss, SIGNAL(globalAngleChanged(int)), SLOT(syncGlobalAngle(int)));
 
 
     connect(wdgLayerStyles.btnNewStyle, SIGNAL(clicked()), SLOT(slotNewStyle()));
     connect(wdgLayerStyles.btnLoadStyle, SIGNAL(clicked()), SLOT(slotLoadStyle()));
     connect(wdgLayerStyles.btnSaveStyle, SIGNAL(clicked()), SLOT(slotSaveStyle()));
 
     connect(wdgLayerStyles.chkMasterFxSwitch, SIGNAL(toggled(bool)), SLOT(slotMasterFxSwitchChanged(bool)));
 
     connect(this, SIGNAL(accepted()), SLOT(slotNotifyOnAccept()));
     connect(this, SIGNAL(rejected()), SLOT(slotNotifyOnReject()));
 }
 
 KisDlgLayerStyle::~KisDlgLayerStyle()
 {
 }
 
 void KisDlgLayerStyle::slotMasterFxSwitchChanged(bool value)
 {
     wdgLayerStyles.lstStyleSelector->setEnabled(value);
     wdgLayerStyles.stylesStack->setEnabled(value);
     wdgLayerStyles.btnNewStyle->setEnabled(value);
     wdgLayerStyles.btnLoadStyle->setEnabled(value);
     wdgLayerStyles.btnSaveStyle->setEnabled(value);
     notifyGuiConfigChanged();
 }
 
 void KisDlgLayerStyle::notifyGuiConfigChanged()
 {
     if (m_isSwitchingPredefinedStyle) return;
 
     m_configChangedCompressor->start();
     m_layerStyle->setUuid(QUuid::createUuid());
     m_sanityLayerStyleDirty = true;
 
     m_stylesSelector->notifyExternalStyleChanged(m_layerStyle->name(), m_layerStyle->uuid());
 }
 
 void KisDlgLayerStyle::notifyPredefinedStyleSelected(KisPSDLayerStyleSP style)
 {
     m_isSwitchingPredefinedStyle = true;
     setStyle(style);
     m_isSwitchingPredefinedStyle = false;
     m_configChangedCompressor->start();
 }
 
 
 void KisDlgLayerStyle::slotNotifyOnAccept()
 {
     if (m_configChangedCompressor->isActive()) {
         m_configChangedCompressor->stop();
         emit configChanged();
     }
 }
 
 void KisDlgLayerStyle::slotNotifyOnReject()
 {
     notifyPredefinedStyleSelected(m_initialLayerStyle);
 
     m_configChangedCompressor->stop();
     emit configChanged();
 }
 
 bool checkCustomNameAvailable(const QString &name)
 {
     const QString customName = "CustomStyles.asl";
 
     KoResourceServer<KisPSDLayerStyleCollectionResource> *server = KisResourceServerProvider::instance()->layerStyleCollectionServer();
 
     KoResource *resource = server->resourceByName(customName);
     if (!resource) return true;
 
     KisPSDLayerStyleCollectionResource *collection = dynamic_cast<KisPSDLayerStyleCollectionResource*>(resource);
 
     Q_FOREACH (KisPSDLayerStyleSP style, collection->layerStyles()) {
         if (style->name() == name) {
             return false;
         }
     }
 
     return true;
 }
 
 QString selectAvailableStyleName(const QString &name)
 {
     QString finalName = name;
     if (checkCustomNameAvailable(finalName)) {
         return finalName;
     }
 
     int i = 0;
 
     do {
         finalName = QString("%1%2").arg(name).arg(i++);
     } while (!checkCustomNameAvailable(finalName));
 
     return finalName;
 }
 
 void KisDlgLayerStyle::slotNewStyle()
 {
     QString styleName =
         QInputDialog::getText(this,
                               i18nc("@title:window", "Enter new style name"),
                               i18nc("@label:textbox", "Name:"),
                               QLineEdit::Normal, i18nc("Default name for a new style", "New Style"));
 
     KisPSDLayerStyleSP style = this->style();
     style->setName(selectAvailableStyleName(styleName));
 
     m_stylesSelector->addNewStyle(style->clone());
 }
 
 void KisDlgLayerStyle::slotLoadStyle()
 {
     QString filename; // default value?
 
     KoFileDialog dialog(this, KoFileDialog::OpenFile, "layerstyle");
     dialog.setCaption(i18n("Select ASL file"));
     dialog.setMimeTypeFilters(QStringList() << "application/x-photoshop-style-library", "application/x-photoshop-style-library");
     filename = dialog.filename();
 
     m_stylesSelector->loadCollection(filename);
     wdgLayerStyles.lstStyleSelector->setCurrentRow(0);
 }
 
 void KisDlgLayerStyle::slotSaveStyle()
 {
     QString filename; // default value?
 
     KoFileDialog dialog(this, KoFileDialog::SaveFile, "layerstyle");
     dialog.setCaption(i18n("Select ASL file"));
     dialog.setMimeTypeFilters(QStringList() << "application/x-photoshop-style-library", "application/x-photoshop-style-library");
     filename = dialog.filename();
 
     QScopedPointer<KisPSDLayerStyleCollectionResource> collection(
         new KisPSDLayerStyleCollectionResource(filename));
 
     KisPSDLayerStyleSP newStyle = style()->clone();
     newStyle->setName(QFileInfo(filename).baseName());
 
     KisPSDLayerStyleCollectionResource::StylesVector vector = collection->layerStyles();
     vector << newStyle;
     collection->setLayerStyles(vector);
     collection->save();
 }
 
 void KisDlgLayerStyle::changePage(QListWidgetItem *current, QListWidgetItem *previous)
 {
     if (!current) {
         current = previous;
     }
     wdgLayerStyles.stylesStack->setCurrentIndex(wdgLayerStyles.lstStyleSelector->row(current));
 }
 
 void KisDlgLayerStyle::setStyle(KisPSDLayerStyleSP style)
 {
     // we may self-assign style is some cases
     if (style != m_layerStyle) {
         *m_layerStyle = *style;
     }
     m_sanityLayerStyleDirty = false;
 
     {
         KisSignalsBlocker b(m_stylesSelector);
         m_stylesSelector->notifyExternalStyleChanged(m_layerStyle->name(), m_layerStyle->uuid());
     }
 
     QListWidgetItem *item;
     item = wdgLayerStyles.lstStyleSelector->item(2);
     item->setCheckState(m_layerStyle->dropShadow()->effectEnabled() ? Qt::Checked : Qt::Unchecked);
 
     item = wdgLayerStyles.lstStyleSelector->item(3);
     item->setCheckState(m_layerStyle->innerShadow()->effectEnabled() ? Qt::Checked : Qt::Unchecked);
 
     item = wdgLayerStyles.lstStyleSelector->item(4);
     item->setCheckState(m_layerStyle->outerGlow()->effectEnabled() ? Qt::Checked : Qt::Unchecked);
 
     item = wdgLayerStyles.lstStyleSelector->item(5);
     item->setCheckState(m_layerStyle->innerGlow()->effectEnabled() ? Qt::Checked : Qt::Unchecked);
 
     item = wdgLayerStyles.lstStyleSelector->item(6);
     item->setCheckState(m_layerStyle->bevelAndEmboss()->effectEnabled() ? Qt::Checked : Qt::Unchecked);
 
     item = wdgLayerStyles.lstStyleSelector->item(7);
     item->setCheckState(m_layerStyle->bevelAndEmboss()->contourEnabled() ? Qt::Checked : Qt::Unchecked);
 
     item = wdgLayerStyles.lstStyleSelector->item(8);
     item->setCheckState(m_layerStyle->bevelAndEmboss()->textureEnabled() ? Qt::Checked : Qt::Unchecked);
 
     item = wdgLayerStyles.lstStyleSelector->item(9);
     item->setCheckState(m_layerStyle->satin()->effectEnabled() ? Qt::Checked : Qt::Unchecked);
 
     item = wdgLayerStyles.lstStyleSelector->item(10);
     item->setCheckState(m_layerStyle->colorOverlay()->effectEnabled() ? Qt::Checked : Qt::Unchecked);
 
     item = wdgLayerStyles.lstStyleSelector->item(11);
     item->setCheckState(m_layerStyle->gradientOverlay()->effectEnabled() ? Qt::Checked : Qt::Unchecked);
 
     item = wdgLayerStyles.lstStyleSelector->item(12);
     item->setCheckState(m_layerStyle->patternOverlay()->effectEnabled() ? Qt::Checked : Qt::Unchecked);
 
     item = wdgLayerStyles.lstStyleSelector->item(13);
     item->setCheckState(m_layerStyle->stroke()->effectEnabled() ? Qt::Checked : Qt::Unchecked);
 
     m_dropShadow->setShadow(m_layerStyle->dropShadow());
     m_innerShadow->setShadow(m_layerStyle->innerShadow());
     m_outerGlow->setConfig(m_layerStyle->outerGlow());
     m_innerGlow->setConfig(m_layerStyle->innerGlow());
     m_bevelAndEmboss->setBevelAndEmboss(m_layerStyle->bevelAndEmboss());
     m_satin->setSatin(m_layerStyle->satin());
     m_colorOverlay->setColorOverlay(m_layerStyle->colorOverlay());
     m_gradientOverlay->setGradientOverlay(m_layerStyle->gradientOverlay());
     m_patternOverlay->setPatternOverlay(m_layerStyle->patternOverlay());
     m_stroke->setStroke(m_layerStyle->stroke());
 
     wdgLayerStyles.chkMasterFxSwitch->setChecked(m_layerStyle->isEnabled());
     slotMasterFxSwitchChanged(m_layerStyle->isEnabled());
 }
 
 KisPSDLayerStyleSP KisDlgLayerStyle::style() const
 {
     m_layerStyle->setEnabled(wdgLayerStyles.chkMasterFxSwitch->isChecked());
 
     m_layerStyle->dropShadow()->setEffectEnabled(wdgLayerStyles.lstStyleSelector->item(2)->checkState() == Qt::Checked);
     m_layerStyle->innerShadow()->setEffectEnabled(wdgLayerStyles.lstStyleSelector->item(3)->checkState() == Qt::Checked);
     m_layerStyle->outerGlow()->setEffectEnabled(wdgLayerStyles.lstStyleSelector->item(4)->checkState() == Qt::Checked);
     m_layerStyle->innerGlow()->setEffectEnabled(wdgLayerStyles.lstStyleSelector->item(5)->checkState() == Qt::Checked);
     m_layerStyle->bevelAndEmboss()->setEffectEnabled(wdgLayerStyles.lstStyleSelector->item(6)->checkState() == Qt::Checked);
     m_layerStyle->bevelAndEmboss()->setContourEnabled(wdgLayerStyles.lstStyleSelector->item(7)->checkState() == Qt::Checked);
     m_layerStyle->bevelAndEmboss()->setTextureEnabled(wdgLayerStyles.lstStyleSelector->item(8)->checkState() == Qt::Checked);
     m_layerStyle->satin()->setEffectEnabled(wdgLayerStyles.lstStyleSelector->item(9)->checkState() == Qt::Checked);
     m_layerStyle->colorOverlay()->setEffectEnabled(wdgLayerStyles.lstStyleSelector->item(10)->checkState() == Qt::Checked);
     m_layerStyle->gradientOverlay()->setEffectEnabled(wdgLayerStyles.lstStyleSelector->item(11)->checkState() == Qt::Checked);
     m_layerStyle->patternOverlay()->setEffectEnabled(wdgLayerStyles.lstStyleSelector->item(12)->checkState() == Qt::Checked);
     m_layerStyle->stroke()->setEffectEnabled(wdgLayerStyles.lstStyleSelector->item(13)->checkState() == Qt::Checked);
 
 
     m_dropShadow->fetchShadow(m_layerStyle->dropShadow());
     m_innerShadow->fetchShadow(m_layerStyle->innerShadow());
     m_outerGlow->fetchConfig(m_layerStyle->outerGlow());
     m_innerGlow->fetchConfig(m_layerStyle->innerGlow());
     m_bevelAndEmboss->fetchBevelAndEmboss(m_layerStyle->bevelAndEmboss());
     m_satin->fetchSatin(m_layerStyle->satin());
     m_colorOverlay->fetchColorOverlay(m_layerStyle->colorOverlay());
     m_gradientOverlay->fetchGradientOverlay(m_layerStyle->gradientOverlay());
     m_patternOverlay->fetchPatternOverlay(m_layerStyle->patternOverlay());
     m_stroke->fetchStroke(m_layerStyle->stroke());
 
     m_sanityLayerStyleDirty = false;
     m_stylesSelector->notifyExternalStyleChanged(m_layerStyle->name(), m_layerStyle->uuid());
 
     return m_layerStyle;
 }
 
 void KisDlgLayerStyle::syncGlobalAngle(int angle)
 {
     KisPSDLayerStyleSP style = this->style();
 
     if (style->dropShadow()->useGlobalLight()) {
         style->dropShadow()->setAngle(angle);
     }
     if (style->innerShadow()->useGlobalLight()) {
         style->innerShadow()->setAngle(angle);
     }
     if (style->bevelAndEmboss()->useGlobalLight()) {
         style->bevelAndEmboss()->setAngle(angle);
     }
 
     setStyle(style);
 }
 
 /********************************************************************/
 /***** Styles Selector **********************************************/
 /********************************************************************/
 
 class StyleItem : public QListWidgetItem {
 public:
     StyleItem(KisPSDLayerStyleSP style)
         : QListWidgetItem(style->name())
         , m_style(style)
     {
     }
 
 public:
     KisPSDLayerStyleSP m_style;
 };
 
 
 StylesSelector::StylesSelector(QWidget *parent)
     : QWidget(parent)
 {
     ui.setupUi(this);
 
     connect(ui.cmbStyleCollections, SIGNAL(activated(QString)), this, SLOT(loadStyles(QString)));
     connect(ui.listStyles, SIGNAL(currentItemChanged(QListWidgetItem*,QListWidgetItem*)), this, SLOT(selectStyle(QListWidgetItem*,QListWidgetItem*)));
 
     refillCollections();
 
     if (ui.cmbStyleCollections->count()) {
         ui.cmbStyleCollections->setCurrentIndex(0);
         loadStyles(ui.cmbStyleCollections->currentText());
     }
 }
 
 void StylesSelector::refillCollections()
 {
     QString previousCollection = ui.cmbStyleCollections->currentText();
 
     ui.cmbStyleCollections->clear();
     Q_FOREACH (KoResource *res, KisResourceServerProvider::instance()->layerStyleCollectionServer()->resources()) {
         ui.cmbStyleCollections->addItem(res->name());
     }
 
     if (!previousCollection.isEmpty()) {
         KisSignalsBlocker blocker(this);
 
         int index = ui.cmbStyleCollections->findText(previousCollection);
         ui.cmbStyleCollections->setCurrentIndex(index);
     }
 }
 
 void StylesSelector::notifyExternalStyleChanged(const QString &name, const QUuid &uuid)
 {
     int currentIndex = -1;
 
     for (int i = 0; i < ui.listStyles->count(); i++ ) {
         StyleItem *item = dynamic_cast<StyleItem*>(ui.listStyles->item(i));
 
         QString itemName = item->m_style->name();
 
         if (itemName == name) {
             bool isDirty = item->m_style->uuid() != uuid;
 
             if (isDirty) {
                 itemName += "*";
             }
 
             currentIndex = i;
         }
 
         item->setText(itemName);
     }
 
     ui.listStyles->setCurrentRow(currentIndex);
 }
 
 void StylesSelector::loadStyles(const QString &name)
 {
     ui.listStyles->clear();
     KoResource *res = KisResourceServerProvider::instance()->layerStyleCollectionServer()->resourceByName(name);
     KisPSDLayerStyleCollectionResource *collection = dynamic_cast<KisPSDLayerStyleCollectionResource*>(res);
     if (collection) {
         Q_FOREACH (KisPSDLayerStyleSP style, collection->layerStyles()) {
             // XXX: also use the preview image, when we have one
             ui.listStyles->addItem(new StyleItem(style));
         }
     }
 }
 
 void StylesSelector::selectStyle(QListWidgetItem *current, QListWidgetItem* /*previous*/)
 {
     StyleItem *item = dynamic_cast<StyleItem*>(current);
     if (item) {
         emit styleSelected(item->m_style);
     }
 }
 
 void StylesSelector::loadCollection(const QString &fileName)
 {
     if (!QFileInfo(fileName).exists()) {
         warnKrita << "Loaded style collection doesn't exist!";
         return;
     }
 
     KisPSDLayerStyleCollectionResource *collection =
         new KisPSDLayerStyleCollectionResource(fileName);
 
     collection->load();
 
     KoResourceServer<KisPSDLayerStyleCollectionResource> *server = KisResourceServerProvider::instance()->layerStyleCollectionServer();
     collection->setFilename(server->saveLocation() + QDir::separator() + collection->name());
     server->addResource(collection);
 
     refillCollections();
 
     int index = ui.cmbStyleCollections->findText(collection->name());
     ui.cmbStyleCollections->setCurrentIndex(index);
     loadStyles(collection->name());
 }
 
 void StylesSelector::addNewStyle(KisPSDLayerStyleSP style)
 {
     KoResourceServer<KisPSDLayerStyleCollectionResource> *server = KisResourceServerProvider::instance()->layerStyleCollectionServer();
 
     // NOTE: not translatable, since it is a key!
     const QString customName = "CustomStyles.asl";
     const QString saveLocation = server->saveLocation();
     const QString fullFilename = saveLocation + customName;
 
     KoResource *resource = server->resourceByName(customName);
     KisPSDLayerStyleCollectionResource *collection = 0;
 
     if (!resource) {
         collection = new KisPSDLayerStyleCollectionResource("");
         collection->setName(customName);
         collection->setFilename(fullFilename);
 
         KisPSDLayerStyleCollectionResource::StylesVector vector;
         vector << style;
         collection->setLayerStyles(vector);
 
         server->addResource(collection);
     } else {
         collection = dynamic_cast<KisPSDLayerStyleCollectionResource*>(resource);
 
         KisPSDLayerStyleCollectionResource::StylesVector vector;
         vector = collection->layerStyles();
         vector << style;
         collection->setLayerStyles(vector);
         collection->save();
     }
 
     refillCollections();
 
     // select in gui
 
     int index = ui.cmbStyleCollections->findText(customName);
     KIS_ASSERT_RECOVER_RETURN(index >= 0);
     ui.cmbStyleCollections->setCurrentIndex(index);
 
     loadStyles(customName);
 
     notifyExternalStyleChanged(style->name(), style->uuid());
 }
 
 /********************************************************************/
 /***** Bevel and Emboss *********************************************/
 /********************************************************************/
 
 BevelAndEmboss::BevelAndEmboss(Contour *contour, Texture *texture, QWidget *parent)
     : QWidget(parent)
     , m_contour(contour)
     , m_texture(texture)
 {
     ui.setupUi(this);
 
     // Structure
     ui.intDepth->setRange(0, 100);
     ui.intDepth->setSuffix(i18n(" %"));
 
     ui.intSize->setRange(0, 250);
     ui.intSize->setSuffix(i18n(" px"));
 
     ui.intSoften->setRange(0, 18);
     ui.intSoften->setSuffix(i18n(" px"));
 
     connect(ui.cmbStyle, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.cmbTechnique, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.intDepth, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.cmbDirection, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.intSize, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intSoften, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     // Shading
     ui.intOpacity->setRange(0, 100);
     ui.intOpacity->setSuffix(i18n(" %"));
 
     ui.intOpacity2->setRange(0, 100);
     ui.intOpacity2->setSuffix(i18n(" %"));
 
     connect(ui.dialAngle, SIGNAL(valueChanged(int)), SLOT(slotDialAngleChanged(int)));
     connect(ui.intAngle, SIGNAL(valueChanged(int)), SLOT(slotIntAngleChanged(int)));
     connect(ui.chkUseGlobalLight, SIGNAL(toggled(bool)), SLOT(slotGlobalLightToggled()));
 
     connect(ui.dialAngle, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intAngle, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.chkUseGlobalLight, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.intAltitude, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.cmbContour, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.chkAntiAliased, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.cmbHighlightMode, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.bnHighlightColor, SIGNAL(changed(KoColor)), SIGNAL(configChanged()));
     connect(ui.intOpacity, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.cmbShadowMode, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.bnShadowColor, SIGNAL(changed(KoColor)), SIGNAL(configChanged()));
     connect(ui.intOpacity2, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     // Contour
     m_contour->ui.intRange->setRange(1, 100);
     m_contour->ui.intRange->setSuffix(i18n(" %"));
 
     connect(m_contour->ui.cmbContour, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(m_contour->ui.chkAntiAliased, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(m_contour->ui.intRange, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     // Texture
     m_texture->ui.intScale->setRange(0, 100);
     m_texture->ui.intScale->setSuffix(i18n(" %"));
 
     m_texture->ui.intDepth->setRange(-1000, 1000);
     m_texture->ui.intDepth->setSuffix(i18n(" %"));
 
     connect(m_texture->ui.patternChooser, SIGNAL(resourceSelected(KoResource*)), SIGNAL(configChanged()));
     connect(m_texture->ui.intScale, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(m_texture->ui.intDepth, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(m_texture->ui.chkInvert, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(m_texture->ui.chkLinkWithLayer, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
 }
 
 void BevelAndEmboss::setBevelAndEmboss(const psd_layer_effects_bevel_emboss *bevelAndEmboss)
 {
     ui.cmbStyle->setCurrentIndex((int)bevelAndEmboss->style());
     ui.cmbTechnique->setCurrentIndex((int)bevelAndEmboss->technique());
     ui.intDepth->setValue(bevelAndEmboss->depth());
     ui.cmbDirection->setCurrentIndex((int)bevelAndEmboss->direction());
     ui.intSize->setValue(bevelAndEmboss->size());
     ui.intSoften->setValue(bevelAndEmboss->soften());
 
     ui.dialAngle->setValue(bevelAndEmboss->angle());
     ui.intAngle->setValue(bevelAndEmboss->angle());
     ui.chkUseGlobalLight->setChecked(bevelAndEmboss->useGlobalLight());
     ui.intAltitude->setValue(bevelAndEmboss->altitude());
     // FIXME: curve editing
     // ui.cmbContour;
     ui.chkAntiAliased->setChecked(bevelAndEmboss->glossAntiAliased());
     ui.cmbHighlightMode->selectCompositeOp(KoID(bevelAndEmboss->highlightBlendMode()));
     KoColor highlightshadow(KoColorSpaceRegistry::instance()->rgb8());
     highlightshadow.fromQColor(bevelAndEmboss->highlightColor());
     ui.bnHighlightColor->setColor(highlightshadow);
     ui.intOpacity->setValue(bevelAndEmboss->highlightOpacity());
     ui.cmbShadowMode->selectCompositeOp(KoID(bevelAndEmboss->shadowBlendMode()));
     highlightshadow.fromQColor(bevelAndEmboss->shadowColor());
     ui.bnShadowColor->setColor(highlightshadow);
     ui.intOpacity2->setValue(bevelAndEmboss->shadowOpacity());
 
     // FIXME: curve editing
     // m_contour->ui.cmbContour;
     m_contour->ui.chkAntiAliased->setChecked(bevelAndEmboss->antiAliased());
     m_contour->ui.intRange->setValue(bevelAndEmboss->contourRange());
 
     m_texture->ui.patternChooser->setCurrentPattern(bevelAndEmboss->texturePattern());
     m_texture->ui.intScale->setValue(bevelAndEmboss->textureScale());
     m_texture->ui.intDepth->setValue(bevelAndEmboss->textureDepth());
     m_texture->ui.chkInvert->setChecked(bevelAndEmboss->textureInvert());
     m_texture->ui.chkLinkWithLayer->setChecked(bevelAndEmboss->textureAlignWithLayer());
 }
 
 void BevelAndEmboss::fetchBevelAndEmboss(psd_layer_effects_bevel_emboss *bevelAndEmboss) const
 {
     bevelAndEmboss->setStyle((psd_bevel_style)ui.cmbStyle->currentIndex());
     bevelAndEmboss->setTechnique((psd_technique_type)ui.cmbTechnique->currentIndex());
     bevelAndEmboss->setDepth(ui.intDepth->value());
     bevelAndEmboss->setDirection((psd_direction)ui.cmbDirection->currentIndex());
     bevelAndEmboss->setSize(ui.intSize->value());
     bevelAndEmboss->setSoften(ui.intSoften->value());
 
     bevelAndEmboss->setAngle(ui.dialAngle->value());
     bevelAndEmboss->setUseGlobalLight(ui.chkUseGlobalLight->isChecked());
     bevelAndEmboss->setAltitude(ui.intAltitude->value());
     bevelAndEmboss->setGlossAntiAliased(ui.chkAntiAliased->isChecked());
     bevelAndEmboss->setHighlightBlendMode(ui.cmbHighlightMode->selectedCompositeOp().id());
     bevelAndEmboss->setHighlightColor(ui.bnHighlightColor->color().toQColor());
     bevelAndEmboss->setHighlightOpacity(ui.intOpacity->value());
     bevelAndEmboss->setShadowBlendMode(ui.cmbShadowMode->selectedCompositeOp().id());
     bevelAndEmboss->setShadowColor(ui.bnShadowColor->color().toQColor());
     bevelAndEmboss->setShadowOpacity(ui.intOpacity2->value());
 
     // FIXME: curve editing
     bevelAndEmboss->setAntiAliased(m_contour->ui.chkAntiAliased->isChecked());
     bevelAndEmboss->setContourRange(m_contour->ui.intRange->value());
 
     bevelAndEmboss->setTexturePattern(static_cast<KoPattern*>(m_texture->ui.patternChooser->currentResource()));
     bevelAndEmboss->setTextureScale(m_texture->ui.intScale->value());
     bevelAndEmboss->setTextureDepth(m_texture->ui.intDepth->value());
     bevelAndEmboss->setTextureInvert(m_texture->ui.chkInvert->isChecked());
     bevelAndEmboss->setTextureAlignWithLayer(m_texture->ui.chkLinkWithLayer->isChecked());
 }
 
 void BevelAndEmboss::slotDialAngleChanged(int value)
 {
     KisSignalsBlocker b(ui.intAngle);
     ui.intAngle->setValue(value);
 
     if (ui.chkUseGlobalLight->isChecked()) {
         emit globalAngleChanged(value);
     }
 }
 
 void BevelAndEmboss::slotIntAngleChanged(int value)
 {
     KisSignalsBlocker b(ui.dialAngle);
     ui.dialAngle->setValue(value);
 
     if (ui.chkUseGlobalLight->isChecked()) {
         emit globalAngleChanged(value);
     }
 }
 
 void BevelAndEmboss::slotGlobalLightToggled()
 {
     if (ui.chkUseGlobalLight->isChecked()) {
         emit globalAngleChanged(ui.intAngle->value());
     }
 }
 
 /********************************************************************/
 /***** Texture          *********************************************/
 /********************************************************************/
 
 Texture::Texture(QWidget *parent)
     : QWidget(parent)
 {
     ui.setupUi(this);
 }
 
 /********************************************************************/
 /***** Contour          *********************************************/
 /********************************************************************/
 
 Contour::Contour(QWidget *parent)
     : QWidget(parent)
 {
     ui.setupUi(this);
 }
 
 
 /********************************************************************/
 /***** Blending Options *********************************************/
 /********************************************************************/
 
 BlendingOptions::BlendingOptions(QWidget *parent)
     : QWidget(parent)
 {
     ui.setupUi(this);
 
     // FIXME: Blend options are not implemented yet
     ui.grpBlendingOptions->setTitle(QString("%1 (%2)").arg(ui.grpBlendingOptions->title()).arg(i18n("Not Implemented Yet")));
     ui.grpBlendingOptions->setEnabled(false);
 
 }
 
 
 /********************************************************************/
 /***** Color Overlay    *********************************************/
 /********************************************************************/
 
 
 ColorOverlay::ColorOverlay(QWidget *parent)
     : QWidget(parent)
 {
     ui.setupUi(this);
 
     ui.intOpacity->setRange(0, 100);
     ui.intOpacity->setSuffix(i18n(" %"));
 
     connect(ui.cmbCompositeOp, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.intOpacity, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.bnColor, SIGNAL(changed(KoColor)), SIGNAL(configChanged()));
 }
 
 void ColorOverlay::setColorOverlay(const psd_layer_effects_color_overlay *colorOverlay)
 {
     ui.cmbCompositeOp->selectCompositeOp(KoID(colorOverlay->blendMode()));
     ui.intOpacity->setValue(colorOverlay->opacity());
     KoColor color(KoColorSpaceRegistry::instance()->rgb8());
     color.fromQColor(colorOverlay->color());
     ui.bnColor->setColor(color);
 }
 
 void ColorOverlay::fetchColorOverlay(psd_layer_effects_color_overlay *colorOverlay) const
 {
     colorOverlay->setBlendMode(ui.cmbCompositeOp->selectedCompositeOp().id());
     colorOverlay->setOpacity(ui.intOpacity->value());
     colorOverlay->setColor(ui.bnColor->color().toQColor());
 }
 
 
 /********************************************************************/
 /***** Drop Shadow **************************************************/
 /********************************************************************/
 
 DropShadow::DropShadow(Mode mode, QWidget *parent)
     : QWidget(parent),
       m_mode(mode)
 {
     ui.setupUi(this);
 
     ui.intOpacity->setRange(0, 100);
     ui.intOpacity->setSuffix(i18n(" %"));
 
     ui.intDistance->setRange(0, 500);
     ui.intDistance->setSuffix(i18n(" px"));
     ui.intDistance->setExponentRatio(3.0);
 
     ui.intSpread->setRange(0, 100);
     ui.intSpread->setSuffix(i18n(" %"));
 
     ui.intSize->setRange(0, 250);
     ui.intSize->setSuffix(i18n(" px"));
 
     ui.intNoise->setRange(0, 100);
     ui.intNoise->setSuffix(i18n(" %"));
 
     connect(ui.dialAngle, SIGNAL(valueChanged(int)), SLOT(slotDialAngleChanged(int)));
     connect(ui.intAngle, SIGNAL(valueChanged(int)), SLOT(slotIntAngleChanged(int)));
     connect(ui.chkUseGlobalLight, SIGNAL(toggled(bool)), SLOT(slotGlobalLightToggled()));
 
     // connect everything to configChanged() signal
     connect(ui.cmbCompositeOp, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.intOpacity, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.bnColor, SIGNAL(changed(KoColor)), SIGNAL(configChanged()));
 
     connect(ui.dialAngle, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intAngle, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.chkUseGlobalLight, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
 
     connect(ui.intDistance, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intSpread, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intSize, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     connect(ui.cmbContour, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.chkAntiAliased, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.intNoise, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     connect(ui.chkLayerKnocksOutDropShadow, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
 
     if (m_mode == InnerShadowMode) {
         ui.chkLayerKnocksOutDropShadow->setVisible(false);
         ui.grpMain->setTitle(i18n("Inner Shadow"));
         ui.lblSpread->setText(i18n("Choke:"));
     }
 }
 
 void DropShadow::slotDialAngleChanged(int value)
 {
     KisSignalsBlocker b(ui.intAngle);
     ui.intAngle->setValue(value);
 
     if (ui.chkUseGlobalLight->isChecked()) {
         emit globalAngleChanged(value);
     }
 }
 
 void DropShadow::slotIntAngleChanged(int value)
 {
     KisSignalsBlocker b(ui.dialAngle);
     ui.dialAngle->setValue(value);
 
     if (ui.chkUseGlobalLight->isChecked()) {
         emit globalAngleChanged(value);
     }
 }
 
 void DropShadow::slotGlobalLightToggled()
 {
     if (ui.chkUseGlobalLight->isChecked()) {
         emit globalAngleChanged(ui.intAngle->value());
     }
 }
 
 void DropShadow::setShadow(const psd_layer_effects_shadow_common *shadow)
 {
     ui.cmbCompositeOp->selectCompositeOp(KoID(shadow->blendMode()));
     ui.intOpacity->setValue(shadow->opacity());
     KoColor color(KoColorSpaceRegistry::instance()->rgb8());
     color.fromQColor(shadow->color());
     ui.bnColor->setColor(color);
 
     ui.dialAngle->setValue(shadow->angle());
     ui.intAngle->setValue(shadow->angle());
     ui.chkUseGlobalLight->setChecked(shadow->useGlobalLight());
 
     ui.intDistance->setValue(shadow->distance());
     ui.intSpread->setValue(shadow->spread());
     ui.intSize->setValue(shadow->size());
 
     // FIXME: curve editing
     // ui.cmbContour;
     ui.chkAntiAliased->setChecked(shadow->antiAliased());
 
     ui.intNoise->setValue(shadow->noise());
 
     if (m_mode == DropShadowMode) {
         const psd_layer_effects_drop_shadow *realDropShadow = dynamic_cast<const psd_layer_effects_drop_shadow*>(shadow);
         KIS_ASSERT_RECOVER_NOOP(realDropShadow);
 
         ui.chkLayerKnocksOutDropShadow->setChecked(shadow->knocksOut());
     }
 }
 
 void DropShadow::fetchShadow(psd_layer_effects_shadow_common *shadow) const
 {
     shadow->setBlendMode(ui.cmbCompositeOp->selectedCompositeOp().id());
     shadow->setOpacity(ui.intOpacity->value());
     shadow->setColor(ui.bnColor->color().toQColor());
 
     shadow->setAngle(ui.dialAngle->value());
     shadow->setUseGlobalLight(ui.chkUseGlobalLight->isChecked());
 
     shadow->setDistance(ui.intDistance->value());
     shadow->setSpread(ui.intSpread->value());
     shadow->setSize(ui.intSize->value());
 
     // FIXME: curve editing
     // ui.cmbContour;
     shadow->setAntiAliased(ui.chkAntiAliased->isChecked());
     shadow->setNoise(ui.intNoise->value());
 
     if (m_mode == DropShadowMode) {
         psd_layer_effects_drop_shadow *realDropShadow = dynamic_cast<psd_layer_effects_drop_shadow*>(shadow);
         KIS_ASSERT_RECOVER_NOOP(realDropShadow);
 
         realDropShadow->setKnocksOut(ui.chkLayerKnocksOutDropShadow->isChecked());
     }
 }
 
 class GradientPointerConverter
 {
 public:
     static KoAbstractGradientSP resourceToStyle(KoAbstractGradient *gradient) {
         return gradient ? KoAbstractGradientSP(gradient->clone()) : KoAbstractGradientSP();
     }
 
     static KoAbstractGradient* styleToResource(KoAbstractGradientSP gradient) {
         if (!gradient) return 0;
 
         KoResourceServer<KoAbstractGradient> *server = KoResourceServerProvider::instance()->gradientServer();
         KoAbstractGradient *resource = server->resourceByMD5(gradient->md5());
 
         if (!resource) {
             KoAbstractGradient *clone = gradient->clone();
             clone->setName(findAvailableName(gradient->name()));
             server->addResource(clone, false);
             resource = clone;
         }
 
         return resource;
     }
 
 private:
     static QString findAvailableName(const QString &name) {
         KoResourceServer<KoAbstractGradient> *server = KoResourceServerProvider::instance()->gradientServer();
         QString newName = name;
         int i = 0;
 
         while (server->resourceByName(newName)) {
             newName = QString("%1%2").arg(name).arg(i++);
         }
 
         return newName;
     }
 };
 
 /********************************************************************/
 /***** Gradient Overlay *********************************************/
 /********************************************************************/
 
 GradientOverlay::GradientOverlay(KisCanvasResourceProvider *resourceProvider, QWidget *parent)
     : QWidget(parent),
       m_resourceProvider(resourceProvider)
 {
     ui.setupUi(this);
 
     ui.intOpacity->setRange(0, 100);
     ui.intOpacity->setSuffix(i18n(" %"));
 
     ui.intScale->setRange(0, 100);
     ui.intScale->setSuffix(i18n(" %"));
 
     connect(ui.dialAngle, SIGNAL(valueChanged(int)), SLOT(slotDialAngleChanged(int)));
     connect(ui.intAngle, SIGNAL(valueChanged(int)), SLOT(slotIntAngleChanged(int)));
 
     connect(ui.cmbCompositeOp, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.intOpacity, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.cmbGradient, SIGNAL(gradientChanged(KoAbstractGradient*)), SIGNAL(configChanged()));
     connect(ui.chkReverse, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.cmbStyle, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.chkAlignWithLayer, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.dialAngle, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intAngle, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intScale, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 }
 
 void GradientOverlay::setGradientOverlay(const psd_layer_effects_gradient_overlay *config)
 {
     ui.cmbCompositeOp->selectCompositeOp(KoID(config->blendMode()));
     ui.intOpacity->setValue(config->opacity());
 
     KoAbstractGradient *gradient = fetchGradientLazy(
         GradientPointerConverter::styleToResource(config->gradient()), m_resourceProvider);
 
     if (gradient) {
         ui.cmbGradient->setGradient(gradient);
     }
 
     ui.chkReverse->setChecked(config->reverse());
     ui.cmbStyle->setCurrentIndex((int)config->style());
     ui.chkAlignWithLayer->setCheckable(config->alignWithLayer());
     ui.dialAngle->setValue(config->angle());
     ui.intAngle->setValue(config->angle());
     ui.intScale->setValue(config->scale());
 }
 
 void GradientOverlay::fetchGradientOverlay(psd_layer_effects_gradient_overlay *config) const
 {
     config->setBlendMode(ui.cmbCompositeOp->selectedCompositeOp().id());
     config->setOpacity(ui.intOpacity->value());
     config->setGradient(GradientPointerConverter::resourceToStyle(ui.cmbGradient->gradient()));
     config->setReverse(ui.chkReverse->isChecked());
     config->setStyle((psd_gradient_style)ui.cmbStyle->currentIndex());
     config->setAlignWithLayer(ui.chkAlignWithLayer->isChecked());
     config->setAngle(ui.dialAngle->value());
     config->setScale(ui.intScale->value());
 }
 
 void GradientOverlay::slotDialAngleChanged(int value)
 {
     KisSignalsBlocker b(ui.intAngle);
     ui.intAngle->setValue(value);
 }
 
 void GradientOverlay::slotIntAngleChanged(int value)
 {
     KisSignalsBlocker b(ui.dialAngle);
     ui.dialAngle->setValue(value);
 }
 
 /********************************************************************/
 /***** Innner Glow      *********************************************/
 /********************************************************************/
 
 InnerGlow::InnerGlow(Mode mode, KisCanvasResourceProvider *resourceProvider, QWidget *parent)
     : QWidget(parent),
       m_mode(mode),
       m_resourceProvider(resourceProvider)
 {
     ui.setupUi(this);
 
     ui.intOpacity->setRange(0, 100);
     ui.intOpacity->setSuffix(i18n(" %"));
 
     ui.intNoise->setRange(0, 100);
     ui.intNoise->setSuffix(i18n(" %"));
 
     ui.intChoke->setRange(0, 100);
     ui.intChoke->setSuffix(i18n(" %"));
 
     ui.intSize->setRange(0, 250);
     ui.intSize->setSuffix(i18n(" px"));
 
     ui.intRange->setRange(1, 100);
     ui.intRange->setSuffix(i18n(" %"));
 
     ui.intJitter->setRange(0, 100);
     ui.intJitter->setSuffix(i18n(" %"));
 
     connect(ui.cmbCompositeOp, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.intOpacity, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intNoise, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     connect(ui.radioColor, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.bnColor, SIGNAL(changed(KoColor)), SIGNAL(configChanged()));
     connect(ui.radioGradient, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.cmbGradient, SIGNAL(gradientChanged(KoAbstractGradient*)), SIGNAL(configChanged()));
 
     connect(ui.cmbTechnique, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.cmbSource, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.intChoke, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intSize, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     connect(ui.cmbContour, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.chkAntiAliased, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.intRange, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intJitter, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     if (m_mode == OuterGlowMode) {
         ui.cmbSource->hide();
         ui.lblSource->hide();
         ui.lblChoke->setText(i18nc("layer styles parameter", "Spread:"));
     }
 
 }
 
 void InnerGlow::setConfig(const psd_layer_effects_glow_common *config)
 {
     ui.cmbCompositeOp->selectCompositeOp(KoID(config->blendMode()));
     ui.intOpacity->setValue(config->opacity());
     ui.intNoise->setValue(config->noise());
 
     ui.radioColor->setChecked(config->fillType() == psd_fill_solid_color);
     KoColor color(KoColorSpaceRegistry::instance()->rgb8());
     color.fromQColor(config->color());
     ui.bnColor->setColor(color);
     ui.radioGradient->setChecked(config->fillType() == psd_fill_gradient);
 
     KoAbstractGradient *gradient = fetchGradientLazy(
         GradientPointerConverter::styleToResource(config->gradient()), m_resourceProvider);
 
     if (gradient) {
         ui.cmbGradient->setGradient(gradient);
     }
 
     ui.cmbTechnique->setCurrentIndex((int)config->technique());
     ui.intChoke->setValue(config->spread());
     ui.intSize->setValue(config->size());
 
     if (m_mode == InnerGlowMode) {
         const psd_layer_effects_inner_glow *iglow =
             dynamic_cast<const psd_layer_effects_inner_glow *>(config);
         KIS_ASSERT_RECOVER_RETURN(iglow);
 
         ui.cmbSource->setCurrentIndex(iglow->source() == psd_glow_edge);
     }
 
     // FIXME: Curve editing
     //ui.cmbContour;
 
     ui.chkAntiAliased->setChecked(config->antiAliased());
     ui.intRange->setValue(config->range());
     ui.intJitter->setValue(config->jitter());
 }
 
 void InnerGlow::fetchConfig(psd_layer_effects_glow_common *config) const
 {
     config->setBlendMode(ui.cmbCompositeOp->selectedCompositeOp().id());
     config->setOpacity(ui.intOpacity->value());
     config->setNoise(ui.intNoise->value());
 
     if (ui.radioColor->isChecked()) {
         config->setFillType(psd_fill_solid_color);
     }
     else {
         config->setFillType(psd_fill_gradient);
     }
 
     config->setColor(ui.bnColor->color().toQColor());
     config->setGradient(GradientPointerConverter::resourceToStyle(ui.cmbGradient->gradient()));
     config->setTechnique((psd_technique_type)ui.cmbTechnique->currentIndex());
     config->setSpread(ui.intChoke->value());
     config->setSize(ui.intSize->value());
 
     if (m_mode == InnerGlowMode) {
         psd_layer_effects_inner_glow *iglow =
             dynamic_cast<psd_layer_effects_inner_glow *>(config);
         KIS_ASSERT_RECOVER_RETURN(iglow);
 
         iglow->setSource((psd_glow_source)ui.cmbSource->currentIndex());
     }
 
     // FIXME: Curve editing
     //ui.cmbContour;
 
     config->setAntiAliased(ui.chkAntiAliased->isChecked());
     config->setRange(ui.intRange->value());
     config->setJitter(ui.intJitter->value());
 }
 
 
 /********************************************************************/
 /***** Pattern Overlay  *********************************************/
 /********************************************************************/
 
 
 PatternOverlay::PatternOverlay(QWidget *parent)
     : QWidget(parent)
 {
     ui.setupUi(this);
 
     ui.intOpacity->setRange(0, 100);
     ui.intOpacity->setSuffix(i18n(" %"));
 
     ui.intScale->setRange(0, 100);
     ui.intScale->setSuffix(i18n(" %"));
 
     connect(ui.cmbCompositeOp, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.intOpacity, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.patternChooser, SIGNAL(resourceSelected(KoResource*)), SIGNAL(configChanged()));
     connect(ui.chkLinkWithLayer, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.intScale, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 }
 
 void PatternOverlay::setPatternOverlay(const psd_layer_effects_pattern_overlay *pattern)
 {
     ui.cmbCompositeOp->selectCompositeOp(KoID(pattern->blendMode()));
     ui.intOpacity->setValue(pattern->opacity());
     ui.patternChooser->setCurrentPattern(pattern->pattern());
     ui.chkLinkWithLayer->setChecked(pattern->alignWithLayer());
     ui.intScale->setValue(pattern->scale());
 }
 
 void PatternOverlay::fetchPatternOverlay(psd_layer_effects_pattern_overlay *pattern) const
 {
     pattern->setBlendMode(ui.cmbCompositeOp->selectedCompositeOp().id());
     pattern->setOpacity(ui.intOpacity->value());
     pattern->setPattern(static_cast<KoPattern*>(ui.patternChooser->currentResource()));
     pattern->setAlignWithLayer(ui.chkLinkWithLayer->isChecked());
     pattern->setScale(ui.intScale->value());
 }
 
 /********************************************************************/
 /***** Satin            *********************************************/
 /********************************************************************/
 
 
 Satin::Satin(QWidget *parent)
     : QWidget(parent)
 {
     ui.setupUi(this);
 
     ui.intOpacity->setRange(0, 100);
     ui.intOpacity->setSuffix(i18n(" %"));
 
     ui.intDistance->setRange(0, 250);
     ui.intDistance->setSuffix(i18n(" px"));
 
     ui.intSize->setRange(0, 250);
     ui.intSize->setSuffix(i18n(" px"));
 
     connect(ui.dialAngle, SIGNAL(valueChanged(int)), SLOT(slotDialAngleChanged(int)));
     connect(ui.intAngle, SIGNAL(valueChanged(int)), SLOT(slotIntAngleChanged(int)));
 
     connect(ui.cmbCompositeOp, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.bnColor, SIGNAL(changed(KoColor)), SIGNAL(configChanged()));
     connect(ui.intOpacity, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     connect(ui.dialAngle, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intAngle, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intDistance, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.intSize, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     connect(ui.cmbContour, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.chkAntiAliased, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.chkInvert, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
 
 }
 
 void Satin::slotDialAngleChanged(int value)
 {
     KisSignalsBlocker b(ui.intAngle);
     ui.intAngle->setValue(value);
 }
 
 void Satin::slotIntAngleChanged(int value)
 {
     KisSignalsBlocker b(ui.dialAngle);
     ui.dialAngle->setValue(value);
 }
 
 void Satin::setSatin(const psd_layer_effects_satin *satin)
 {
     ui.cmbCompositeOp->selectCompositeOp(KoID(satin->blendMode()));
     KoColor color(KoColorSpaceRegistry::instance()->rgb8());
     color.fromQColor(satin->color());
     ui.bnColor->setColor(color);
     ui.intOpacity->setValue(satin->opacity());
 
     ui.dialAngle->setValue(satin->angle());
     ui.intAngle->setValue(satin->angle());
 
     ui.intDistance->setValue(satin->distance());
     ui.intSize->setValue(satin->size());
 
     // FIXME: Curve editing
     //ui.cmbContour;
 
     ui.chkAntiAliased->setChecked(satin->antiAliased());
     ui.chkInvert->setChecked(satin->invert());
 
 }
 
 void Satin::fetchSatin(psd_layer_effects_satin *satin) const
 {
     satin->setBlendMode(ui.cmbCompositeOp->selectedCompositeOp().id());
     satin->setOpacity(ui.intOpacity->value());
     satin->setColor(ui.bnColor->color().toQColor());
 
     satin->setAngle(ui.dialAngle->value());
 
     satin->setDistance(ui.intDistance->value());
     satin->setSize(ui.intSize->value());
 
     // FIXME: curve editing
     // ui.cmbContour;
     satin->setAntiAliased(ui.chkAntiAliased->isChecked());
     satin->setInvert(ui.chkInvert->isChecked());
 }
 
 /********************************************************************/
 /***** Stroke           *********************************************/
 /********************************************************************/
 
 Stroke::Stroke(KisCanvasResourceProvider *resourceProvider, QWidget *parent)
     : QWidget(parent),
       m_resourceProvider(resourceProvider)
 {
     ui.setupUi(this);
 
     ui.intSize->setRange(0, 250);
     ui.intSize->setSuffix(i18n(" px"));
 
     ui.intOpacity->setRange(0, 100);
     ui.intOpacity->setSuffix(i18n(" %"));
 
     ui.intScale->setRange(0, 100);
     ui.intScale->setSuffix(i18n(" %"));
 
     ui.intScale_2->setRange(0, 100);
     ui.intScale_2->setSuffix(i18n(" %"));
 
     connect(ui.cmbFillType, SIGNAL(currentIndexChanged(int)), ui.fillStack, SLOT(setCurrentIndex(int)));
 
     connect(ui.intSize, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
     connect(ui.cmbPosition, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.cmbCompositeOp, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.intOpacity, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     connect(ui.cmbFillType, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
 
     connect(ui.bnColor, SIGNAL(changed(KoColor)), SIGNAL(configChanged()));
 
     connect(ui.cmbGradient, SIGNAL(gradientChanged(KoAbstractGradient*)), SIGNAL(configChanged()));
     connect(ui.chkReverse, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.cmbStyle, SIGNAL(currentIndexChanged(int)), SIGNAL(configChanged()));
     connect(ui.chkAlignWithLayer, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.dialAngle, SIGNAL(valueChanged(int)), SLOT(slotDialAngleChanged(int)));
     connect(ui.intAngle, SIGNAL(valueChanged(int)), SLOT(slotIntAngleChanged(int)));
     connect(ui.intScale, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     connect(ui.patternChooser, SIGNAL(resourceSelected(KoResource*)), SIGNAL(configChanged()));
     connect(ui.chkLinkWithLayer, SIGNAL(toggled(bool)), SIGNAL(configChanged()));
     connect(ui.intScale_2, SIGNAL(valueChanged(int)), SIGNAL(configChanged()));
 
     // cold initialization
     ui.fillStack->setCurrentIndex(ui.cmbFillType->currentIndex());
 }
 
 void Stroke::slotDialAngleChanged(int value)
 {
     KisSignalsBlocker b(ui.intAngle);
     ui.intAngle->setValue(value);
 }
 
 void Stroke::slotIntAngleChanged(int value)
 {
     KisSignalsBlocker b(ui.dialAngle);
     ui.dialAngle->setValue(value);
 }
 
 
 void Stroke::setStroke(const psd_layer_effects_stroke *stroke)
 {
 
     ui.intSize->setValue(stroke->size());
     ui.cmbPosition->setCurrentIndex((int)stroke->position());
     ui.cmbCompositeOp->selectCompositeOp(KoID(stroke->blendMode()));
     ui.intOpacity->setValue(stroke->opacity());
 
     ui.cmbFillType->setCurrentIndex((int)stroke->fillType());
     KoColor color(KoColorSpaceRegistry::instance()->rgb8());
     color.fromQColor(stroke->color());
     ui.bnColor->setColor(color);
 
     KoAbstractGradient *gradient =
         fetchGradientLazy(GradientPointerConverter::styleToResource(stroke->gradient()), m_resourceProvider);
 
     if (gradient) {
         ui.cmbGradient->setGradient(gradient);
     }
 
     ui.chkReverse->setChecked(stroke->antiAliased());
     ui.cmbStyle->setCurrentIndex((int)stroke->style());
     ui.chkAlignWithLayer->setCheckable(stroke->alignWithLayer());
     ui.dialAngle->setValue(stroke->angle());
     ui.intAngle->setValue(stroke->angle());
     ui.intScale->setValue(stroke->scale());
 
     ui.patternChooser->setCurrentPattern(stroke->pattern());
     ui.chkLinkWithLayer->setChecked(stroke->alignWithLayer());
     ui.intScale_2->setValue(stroke->scale());
 
 }
 
 void Stroke::fetchStroke(psd_layer_effects_stroke *stroke) const
 {
     stroke->setSize(ui.intSize->value());
     stroke->setPosition((psd_stroke_position)ui.cmbPosition->currentIndex());
     stroke->setBlendMode(ui.cmbCompositeOp->selectedCompositeOp().id());
     stroke->setOpacity(ui.intOpacity->value());
 
     stroke->setFillType((psd_fill_type)ui.cmbFillType->currentIndex());
 
     stroke->setColor(ui.bnColor->color().toQColor());
 
     stroke->setGradient(GradientPointerConverter::resourceToStyle(ui.cmbGradient->gradient()));
     stroke->setReverse(ui.chkReverse->isChecked());
     stroke->setStyle((psd_gradient_style)ui.cmbStyle->currentIndex());
     stroke->setAlignWithLayer(ui.chkAlignWithLayer->isChecked());
     stroke->setAngle(ui.dialAngle->value());
     stroke->setScale(ui.intScale->value());
 
     stroke->setPattern(static_cast<KoPattern*>(ui.patternChooser->currentResource()));
     stroke->setAlignWithLayer(ui.chkLinkWithLayer->isChecked());
     stroke->setScale(ui.intScale->value());
 }
diff --git a/libs/ui/flake/KisReferenceImagesLayer.cpp b/libs/ui/flake/KisReferenceImagesLayer.cpp
index 73ce5e9cc1..121bd207fa 100644
--- a/libs/ui/flake/KisReferenceImagesLayer.cpp
+++ b/libs/ui/flake/KisReferenceImagesLayer.cpp
@@ -1,147 +1,205 @@
 /*
  * Copyright (C) 2017 Jouni Pentikäinen <joupent@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include <KoShapeCreateCommand.h>
+#include <KoShapeDeleteCommand.h>
 #include <kis_node_visitor.h>
 #include <kis_processing_visitor.h>
 #include <kis_shape_layer_canvas.h>
 
 #include "KisReferenceImagesLayer.h"
 #include "KisReferenceImage.h"
+#include "KisDocument.h"
 
-struct AddReferenceImageCommand : KoShapeCreateCommand
+struct AddReferenceImagesCommand : KoShapeCreateCommand
 {
-    AddReferenceImageCommand(KisReferenceImagesLayer *layer, KisReferenceImage* referenceImage)
-        : KoShapeCreateCommand(layer->shapeController(), {referenceImage}, layer, nullptr, kundo2_i18n("Add reference image"))
+    AddReferenceImagesCommand(KisDocument *document, KisSharedPtr<KisReferenceImagesLayer> layer, const QList<KoShape*> referenceImages)
+        : KoShapeCreateCommand(layer->shapeController(), referenceImages, layer.data(), nullptr, kundo2_i18n("Add reference image"))
+        , m_document(document)
         , m_layer(layer)
     {}
 
     void redo() override {
+        auto layer = m_document->referenceImagesLayer();
+        KIS_SAFE_ASSERT_RECOVER_NOOP(!layer || layer == m_layer)
+
+        if (!layer) {
+            m_document->setReferenceImagesLayer(m_layer, true);
+        }
+
         KoShapeCreateCommand::redo();
     }
 
     void undo() override {
         KoShapeCreateCommand::undo();
+
+        if (m_layer->shapeCount() == 0) {
+            m_document->setReferenceImagesLayer(nullptr, true);
+        }
     }
 
 private:
-    KisReferenceImagesLayer *m_layer;
+    KisDocument *m_document;
+    KisSharedPtr<KisReferenceImagesLayer> m_layer;
+};
+
+struct RemoveReferenceImagesCommand : KoShapeDeleteCommand
+{
+    RemoveReferenceImagesCommand(KisDocument *document, KisSharedPtr<KisReferenceImagesLayer> layer, QList<KoShape *> referenceImages)
+        : KoShapeDeleteCommand(layer->shapeController(), referenceImages)
+        , m_document(document)
+        , m_layer(layer)
+    {}
+
+
+    void redo() override {
+        KoShapeDeleteCommand::redo();
+
+        if (m_layer->shapeCount() == 0) {
+            m_document->setReferenceImagesLayer(nullptr, true);
+        }
+    }
+
+    void undo() override {
+        auto layer = m_document->referenceImagesLayer();
+        KIS_SAFE_ASSERT_RECOVER_NOOP(!layer || layer == m_layer)
+
+        if (!layer) {
+            m_document->setReferenceImagesLayer(m_layer, true);
+        }
+
+        KoShapeDeleteCommand::undo();
+    }
+
+private:
+    KisDocument *m_document;
+    KisSharedPtr<KisReferenceImagesLayer> m_layer;
 };
 
 class ReferenceImagesCanvas : public KisShapeLayerCanvasBase
 {
 public:
     ReferenceImagesCanvas(KisReferenceImagesLayer *parent, KisImageWSP image)
         : KisShapeLayerCanvasBase(parent, image)
         , m_layer(parent)
     {}
 
     void updateCanvas(const QRectF &rect) override
     {
         if (!m_layer->image() || m_isDestroying) {
             return;
         }
 
         QRectF r = m_viewConverter->documentToView(rect);
         m_layer->signalUpdate(r);
     }
 
     void forceRepaint() override
     {
         m_layer->signalUpdate(m_layer->boundingImageRect());
     }
 
     void rerenderAfterBeingInvisible() override {}
     void resetCache() override {}
     void setImage(KisImageWSP /*image*/) override {}
 
 private:
     KisReferenceImagesLayer *m_layer;
 };
 
 KisReferenceImagesLayer::KisReferenceImagesLayer(KoShapeBasedDocumentBase* shapeController, KisImageWSP image)
     : KisShapeLayer(shapeController, image, i18n("Reference images"), OPACITY_OPAQUE_U8, new ReferenceImagesCanvas(this, image))
 {}
 
 KisReferenceImagesLayer::KisReferenceImagesLayer(const KisReferenceImagesLayer &rhs)
     : KisShapeLayer(rhs, rhs.shapeController(), new ReferenceImagesCanvas(this, rhs.image()))
 {}
 
-KUndo2Command * KisReferenceImagesLayer::addReferenceImage(KisReferenceImage *referenceImage)
+KUndo2Command * KisReferenceImagesLayer::addReferenceImages(KisDocument *document, const QList<KoShape*> referenceImages)
+{
+    KisSharedPtr<KisReferenceImagesLayer> layer = document->referenceImagesLayer();
+    if (!layer) {
+        layer = new KisReferenceImagesLayer(document->shapeController(), document->image());
+    }
+
+    return new AddReferenceImagesCommand(document, layer, referenceImages);
+}
+
+KUndo2Command * KisReferenceImagesLayer::removeReferenceImages(KisDocument *document, QList<KoShape*> referenceImages)
 {
-    return new AddReferenceImageCommand(this, referenceImage);
+    return new RemoveReferenceImagesCommand(document, this, referenceImages);
 }
 
 QVector<KisReferenceImage*> KisReferenceImagesLayer::referenceImages() const
 {
     QVector<KisReferenceImage*> references;
 
     Q_FOREACH(auto shape, shapes()) {
         KisReferenceImage *referenceImage = dynamic_cast<KisReferenceImage*>(shape);
         if (referenceImage) {
             references.append(referenceImage);
         }
     }
     return references;
 }
 
 void KisReferenceImagesLayer::paintReferences(QPainter &painter) {
     shapeManager()->paint(painter, *converter(), false);
 }
 
 bool KisReferenceImagesLayer::allowAsChild(KisNodeSP) const
 {
     return false;
 }
 
 bool KisReferenceImagesLayer::accept(KisNodeVisitor &visitor)
 {
     return visitor.visit(this);
 }
 
 void KisReferenceImagesLayer::accept(KisProcessingVisitor &visitor, KisUndoAdapter *undoAdapter)
 {
     visitor.visit(this, undoAdapter);
 }
 
 void KisReferenceImagesLayer::signalUpdate(const QRectF &rect)
 {
     emit sigUpdateCanvas(rect);
 }
 
 QRectF KisReferenceImagesLayer::boundingImageRect() const
 {
     return converter()->documentToView(boundingRect());
 }
 
 QColor KisReferenceImagesLayer::getPixel(QPointF position) const
 {
     const QPointF docPoint = converter()->viewToDocument(position);
 
     KoShape *shape = shapeManager()->shapeAt(docPoint);
 
     if (shape) {
         auto *reference = dynamic_cast<KisReferenceImage*>(shape);
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(reference, QColor());
 
         return reference->getPixel(docPoint);
     }
 
     return QColor();
 }
diff --git a/libs/ui/flake/KisReferenceImagesLayer.h b/libs/ui/flake/KisReferenceImagesLayer.h
index 4eb89b1de8..731743b6ff 100644
--- a/libs/ui/flake/KisReferenceImagesLayer.h
+++ b/libs/ui/flake/KisReferenceImagesLayer.h
@@ -1,66 +1,68 @@
 /*
  * Copyright (C) 2017 Jouni Pentikäinen <joupent@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #ifndef KRITA_KISREFERENCEIMAGESLAYER_H
 #define KRITA_KISREFERENCEIMAGESLAYER_H
 
 #include "kis_shape_layer.h"
 
 #include <kis_types.h>
 
 class KRITAUI_EXPORT KisReferenceImagesLayer : public KisShapeLayer
 {
     Q_OBJECT
 
 public:
     KisReferenceImagesLayer(KoShapeBasedDocumentBase* shapeController, KisImageWSP image);
     KisReferenceImagesLayer(const KisReferenceImagesLayer &rhs);
 
-    KUndo2Command * addReferenceImage(KisReferenceImage *referenceImage);
+    static KUndo2Command * addReferenceImages(KisDocument *document, QList<KoShape*> referenceImages);
+    KUndo2Command * removeReferenceImages(KisDocument *document, QList<KoShape*> referenceImages);
     QVector<KisReferenceImage*> referenceImages() const;
 
     QRectF boundingImageRect() const;
     QColor getPixel(QPointF position) const;
 
     void paintReferences(QPainter &painter);
 
     bool allowAsChild(KisNodeSP) const override;
 
     bool accept(KisNodeVisitor&) override;
     void accept(KisProcessingVisitor &visitor, KisUndoAdapter *undoAdapter) override;
 
     KisNodeSP clone() const override {
         return new KisReferenceImagesLayer(*this);
     }
 
 Q_SIGNALS:
     /**
      * The content of the layer has changed, and the canvas decoration
      * needs to update.
      */
     void sigUpdateCanvas(const QRectF &rect);
 
 private:
     void signalUpdate(const QRectF &rect);
-    friend struct AddReferenceImageCommand;
-    friend struct ReferenceImagesCanvas;
+    friend struct AddReferenceImagesCommand;
+    friend struct RemoveReferenceImagesCommand;
+    friend class ReferenceImagesCanvas;
 };
 
 
 #endif //KRITA_KISREFERENCEIMAGESLAYER_H
diff --git a/libs/ui/flake/kis_dummies_facade_base.cpp b/libs/ui/flake/kis_dummies_facade_base.cpp
index 224de41ab3..2dac16c9e7 100644
--- a/libs/ui/flake/kis_dummies_facade_base.cpp
+++ b/libs/ui/flake/kis_dummies_facade_base.cpp
@@ -1,156 +1,158 @@
 /*
  *  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_dummies_facade_base.h"
 
 #include "kis_image.h"
 #include "kis_node_dummies_graph.h"
 
 
 struct KisDummiesFacadeBase::Private
 {
 public:
     KisImageWSP image;
     KisNodeSP savedRootNode;
 };
 
 
 KisDummiesFacadeBase::KisDummiesFacadeBase(QObject *parent)
     : QObject(parent),
       m_d(new Private())
 {
     connect(this, SIGNAL(sigContinueAddNode(KisNodeSP,KisNodeSP,KisNodeSP)),
             SLOT(slotContinueAddNode(KisNodeSP,KisNodeSP,KisNodeSP)));
     connect(this, SIGNAL(sigContinueRemoveNode(KisNodeSP)),
             SLOT(slotContinueRemoveNode(KisNodeSP)));
 }
 
 KisDummiesFacadeBase::~KisDummiesFacadeBase()
 {
     delete m_d;
 }
 
 void KisDummiesFacadeBase::setImage(KisImageWSP image)
 {
     if (m_d->image) {
         emit sigActivateNode(0);
         m_d->image->disconnect(this);
 
         KisNodeDummy *rootDummy = this->rootDummy();
         if(rootDummy) {
             slotRemoveNode(rootDummy->node());
         }
     }
 
     m_d->image = image;
 
     if (image) {
         slotNodeAdded(image->root());
 
         connect(image, SIGNAL(sigNodeAddedAsync(KisNodeSP)),
                 SLOT(slotNodeAdded(KisNodeSP)), Qt::DirectConnection);
         connect(image, SIGNAL(sigRemoveNodeAsync(KisNodeSP)),
                 SLOT(slotRemoveNode(KisNodeSP)), Qt::DirectConnection);
         connect(image, SIGNAL(sigLayersChangedAsync()),
                 SLOT(slotLayersChanged()), Qt::DirectConnection);
 
         connect(image, SIGNAL(sigNodeChanged(KisNodeSP)),
                 SLOT(slotNodeChanged(KisNodeSP)));
 
         connect(image, SIGNAL(sigNodeAddedAsync(KisNodeSP)),
                 SLOT(slotNodeActivationRequested(KisNodeSP)), Qt::AutoConnection);
         emit sigActivateNode(findFirstLayer(image->root()));
     }
 }
 
 KisImageWSP KisDummiesFacadeBase::image() const
 {
     return m_d->image;
 }
 
 KisNodeSP KisDummiesFacadeBase::findFirstLayer(KisNodeSP root)
 {
     KisNodeSP child = root->firstChild();
     while(child && !child->inherits("KisLayer")) {
         child = child->nextSibling();
     }
     return child;
 }
 
 void KisDummiesFacadeBase::slotNodeChanged(KisNodeSP node)
 {
     emit sigDummyChanged(dummyForNode(node));
 }
 
 void KisDummiesFacadeBase::slotLayersChanged()
 {
     setImage(m_d->image);
 }
 
 void KisDummiesFacadeBase::slotNodeActivationRequested(KisNodeSP node)
 {
+    if (!node->graphListener()) return;
+
     if (!node->inherits("KisSelectionMask") && !node->inherits("KisReferenceImagesLayer")) {
         emit sigActivateNode(node);
     }
 }
 
 void KisDummiesFacadeBase::slotNodeAdded(KisNodeSP node)
 {
     emit sigContinueAddNode(node, node->parent(), node->prevSibling());
 
     KisNodeSP childNode = node->firstChild();
     while (childNode) {
         slotNodeAdded(childNode);
         childNode = childNode->nextSibling();
     }
 }
 
 void KisDummiesFacadeBase::slotRemoveNode(KisNodeSP node)
 {
     KisNodeSP childNode = node->lastChild();
     while (childNode) {
         slotRemoveNode(childNode);
         childNode = childNode->prevSibling();
     }
 
     emit sigContinueRemoveNode(node);
 }
 
 void KisDummiesFacadeBase::slotContinueAddNode(KisNodeSP node, KisNodeSP parent, KisNodeSP aboveThis)
 {
     KisNodeDummy *parentDummy = parent ? dummyForNode(parent) : 0;
     KisNodeDummy *aboveThisDummy = aboveThis ? dummyForNode(aboveThis) : 0;
     // Add one because this node does not exist yet
     int index = parentDummy && aboveThisDummy ?
         parentDummy->indexOf(aboveThisDummy) + 1 : 0;
     emit sigBeginInsertDummy(parentDummy, index, node->metaObject()->className());
 
     addNodeImpl(node, parent, aboveThis);
 
     emit sigEndInsertDummy(dummyForNode(node));
 }
 
 void KisDummiesFacadeBase::slotContinueRemoveNode(KisNodeSP node)
 {
     KisNodeDummy *dummy = dummyForNode(node);
     emit sigBeginRemoveDummy(dummy);
 
     removeNodeImpl(node);
 
     emit sigEndRemoveDummy();
 }
diff --git a/libs/ui/input/kis_input_profile_manager.cpp b/libs/ui/input/kis_input_profile_manager.cpp
index a8da62c9b4..42c99b3eb4 100644
--- a/libs/ui/input/kis_input_profile_manager.cpp
+++ b/libs/ui/input/kis_input_profile_manager.cpp
@@ -1,377 +1,377 @@
 /*
  * This file is part of the KDE project
  * Copyright (C) 2013 Arjen Hiemstra <ahiemstra@heimr.nl>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_input_profile_manager.h"
 #include "kis_input_profile.h"
 
 #include <QMap>
 #include <QStringList>
 #include <QDir>
 #include <QGlobalStatic>
 
 #include <KoResourcePaths.h>
 #include <kconfig.h>
 #include <kconfiggroup.h>
 
 #include "kis_config.h"
 #include "kis_alternate_invocation_action.h"
 #include "kis_change_primary_setting_action.h"
 #include "kis_pan_action.h"
 #include "kis_rotate_canvas_action.h"
 #include "kis_show_palette_action.h"
 #include "kis_tool_invocation_action.h"
 #include "kis_zoom_action.h"
 #include "kis_shortcut_configuration.h"
 #include "kis_select_layer_action.h"
 #include "kis_gamma_exposure_action.h"
 #include "kis_change_frame_action.h"
 
 #define PROFILE_VERSION 3
 
 
 class Q_DECL_HIDDEN KisInputProfileManager::Private
 {
 public:
     Private() : currentProfile(0) { }
 
     void createActions();
     QString profileFileName(const QString &profileName);
 
     KisInputProfile *currentProfile;
 
     QMap<QString, KisInputProfile *> profiles;
 
     QList<KisAbstractInputAction *> actions;
 };
 
 Q_GLOBAL_STATIC(KisInputProfileManager, inputProfileManager)
 
 KisInputProfileManager *KisInputProfileManager::instance()
 {
     return inputProfileManager;
 }
 
 QList< KisInputProfile * > KisInputProfileManager::profiles() const
 {
     return d->profiles.values();
 }
 
 QStringList KisInputProfileManager::profileNames() const
 {
     return d->profiles.keys();
 }
 
 KisInputProfile *KisInputProfileManager::profile(const QString &name) const
 {
     if (d->profiles.contains(name)) {
         return d->profiles.value(name);
     }
 
     return 0;
 }
 
 KisInputProfile *KisInputProfileManager::currentProfile() const
 {
     return d->currentProfile;
 }
 
 void KisInputProfileManager::setCurrentProfile(KisInputProfile *profile)
 {
     if (profile && profile != d->currentProfile) {
         d->currentProfile = profile;
         emit currentProfileChanged();
     }
 }
 
 KisInputProfile *KisInputProfileManager::addProfile(const QString &name)
 {
     if (d->profiles.contains(name)) {
         return d->profiles.value(name);
     }
 
     KisInputProfile *profile = new KisInputProfile(this);
     profile->setName(name);
     d->profiles.insert(name, profile);
 
     emit profilesChanged();
 
     return profile;
 }
 
 void KisInputProfileManager::removeProfile(const QString &name)
 {
     if (d->profiles.contains(name)) {
         QString currentProfileName = d->currentProfile->name();
 
         delete d->profiles.value(name);
         d->profiles.remove(name);
 
         //Delete the settings file for the removed profile, if it exists
         QDir userDir(KoResourcePaths::saveLocation("data", "input/"));
 
         if (userDir.exists(d->profileFileName(name))) {
             userDir.remove(d->profileFileName(name));
         }
 
         if (currentProfileName == name) {
             d->currentProfile = d->profiles.begin().value();
             emit currentProfileChanged();
         }
 
         emit profilesChanged();
     }
 }
 
 bool KisInputProfileManager::renameProfile(const QString &oldName, const QString &newName)
 {
     if (!d->profiles.contains(oldName)) {
         return false;
     }
 
     KisInputProfile *profile = d->profiles.value(oldName);
     d->profiles.remove(oldName);
     profile->setName(newName);
     d->profiles.insert(newName, profile);
 
     emit profilesChanged();
 
     return true;
 }
 
 void KisInputProfileManager::duplicateProfile(const QString &name, const QString &newName)
 {
     if (!d->profiles.contains(name) || d->profiles.contains(newName)) {
         return;
     }
 
     KisInputProfile *newProfile = new KisInputProfile(this);
     newProfile->setName(newName);
     d->profiles.insert(newName, newProfile);
 
     KisInputProfile *profile = d->profiles.value(name);
     QList<KisShortcutConfiguration *> shortcuts = profile->allShortcuts();
     Q_FOREACH(KisShortcutConfiguration * shortcut, shortcuts) {
         newProfile->addShortcut(new KisShortcutConfiguration(*shortcut));
     }
 
     emit profilesChanged();
 }
 
 QList< KisAbstractInputAction * > KisInputProfileManager::actions()
 {
     return d->actions;
 }
 
 
 struct ProfileEntry {
     QString name;
     QString fullpath;
     int version;
 };
 
 void KisInputProfileManager::loadProfiles()
 {
     //Remove any profiles that already exist
     d->currentProfile = 0;
     qDeleteAll(d->profiles);
     d->profiles.clear();
 
     //Look up all profiles (this includes those installed to $prefix as well as the user's local data dir)
     QStringList profiles = KoResourcePaths::findAllResources("data", "input/*", KoResourcePaths::Recursive);
 
     dbgKrita << "profiles" << profiles;
 
     QMap<QString, QList<ProfileEntry> > profileEntries;
 
     // Get only valid entries...
     Q_FOREACH(const QString & p, profiles) {
 
         ProfileEntry entry;
         entry.fullpath = p;
 
         KConfig config(p, KConfig::SimpleConfig);
         if (!config.hasGroup("General") || !config.group("General").hasKey("name") || !config.group("General").hasKey("version")) {
             //Skip if we don't have the proper settings.
             continue;
         }
 
         // Only entries of exactly the right version can be considered
         entry.version = config.group("General").readEntry("version", 0);
         if (entry.version != PROFILE_VERSION) {
             continue;
         }
 
         entry.name = config.group("General").readEntry("name");
         if (!profileEntries.contains(entry.name)) {
             profileEntries[entry.name] = QList<ProfileEntry>();
         }
 
         if (p.contains(".kde") || p.contains(".krita")) {
             // It's the user define one, drop the others
             profileEntries[entry.name].clear();
             profileEntries[entry.name].append(entry);
             break;
         }
         else {
             profileEntries[entry.name].append(entry);
         }
     }
 
     QStringList profilePaths;
 
     Q_FOREACH(const QString & profileName, profileEntries.keys()) {
 
         if (profileEntries[profileName].isEmpty()) {
             continue;
         }
 
         // we have one or more entries for this profile name. We'll take the first,
         // because that's the most local one.
         ProfileEntry entry = profileEntries[profileName].first();
 
         QString path(QFileInfo(entry.fullpath).dir().absolutePath());
         if (!profilePaths.contains(path)) {
             profilePaths.append(path);
         }
 
         KConfig config(entry.fullpath, KConfig::SimpleConfig);
 
         KisInputProfile *newProfile = addProfile(entry.name);
         Q_FOREACH(KisAbstractInputAction * action, d->actions) {
             if (!config.hasGroup(action->id())) {
                 continue;
             }
 
             KConfigGroup grp = config.group(action->id());
             //Read the settings for the action and create the appropriate shortcuts.
             Q_FOREACH(const QString & entry, grp.entryMap()) {
                 KisShortcutConfiguration *shortcut = new KisShortcutConfiguration;
                 shortcut->setAction(action);
 
                 if (shortcut->unserialize(entry)) {
                     newProfile->addShortcut(shortcut);
                 }
                 else {
                     delete shortcut;
                 }
             }
         }
     }
 
-    QString profilePathsStr(profilePaths.join("' AND '"));
-    qDebug() << "input profiles were read from '" << qUtf8Printable(profilePathsStr) << "'.";
+//    QString profilePathsStr(profilePaths.join("' AND '"));
+//    qDebug() << "input profiles were read from '" << qUtf8Printable(profilePathsStr) << "'.";
 
     KisConfig cfg;
     QString currentProfile = cfg.currentInputProfile();
     if (d->profiles.size() > 0) {
         if (currentProfile.isEmpty() || !d->profiles.contains(currentProfile)) {
             d->currentProfile = d->profiles.begin().value();
         }
         else {
             d->currentProfile = d->profiles.value(currentProfile);
         }
     }
     if (d->currentProfile) {
         emit currentProfileChanged();
     }
 }
 
 void KisInputProfileManager::saveProfiles()
 {
     QString storagePath = KoResourcePaths::saveLocation("data", "input/", true);
     Q_FOREACH(KisInputProfile * p, d->profiles) {
         QString fileName = d->profileFileName(p->name());
 
         KConfig config(storagePath + fileName, KConfig::SimpleConfig);
 
         config.group("General").writeEntry("name", p->name());
         config.group("General").writeEntry("version", PROFILE_VERSION);
 
         Q_FOREACH(KisAbstractInputAction * action, d->actions) {
             KConfigGroup grp = config.group(action->id());
             grp.deleteGroup(); //Clear the group of any existing shortcuts.
 
             int index = 0;
             QList<KisShortcutConfiguration *> shortcuts = p->shortcutsForAction(action);
             Q_FOREACH(KisShortcutConfiguration * shortcut, shortcuts) {
                 grp.writeEntry(QString("%1").arg(index++), shortcut->serialize());
             }
         }
 
         config.sync();
     }
 
     KisConfig config;
     config.setCurrentInputProfile(d->currentProfile->name());
 
     //Force a reload of the current profile in input manager and whatever else uses the profile.
     emit currentProfileChanged();
 }
 
 void KisInputProfileManager::resetAll()
 {
     QString kdeHome = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
     QStringList profiles = KoResourcePaths::findAllResources("data", "input/*", KoResourcePaths::Recursive);
 
     Q_FOREACH (const QString &profile, profiles) {
         if(profile.contains(kdeHome)) {
             //This is a local file, remove it.
             QFile::remove(profile);
         }
     }
 
     //Load the profiles again, this should now only load those shipped with Krita.
     loadProfiles();
 
     emit profilesChanged();
 }
 
 KisInputProfileManager::KisInputProfileManager(QObject *parent)
     : QObject(parent), d(new Private())
 {
     d->createActions();
 }
 
 KisInputProfileManager::~KisInputProfileManager()
 {
     qDeleteAll(d->profiles);
     qDeleteAll(d->actions);
     delete d;
 }
 
 void KisInputProfileManager::Private::createActions()
 {
     //TODO: Make this plugin based
     //Note that the ordering here determines how things show up in the UI
     actions.append(new KisToolInvocationAction());
     actions.append(new KisAlternateInvocationAction());
     actions.append(new KisChangePrimarySettingAction());
     actions.append(new KisPanAction());
     actions.append(new KisRotateCanvasAction());
     actions.append(new KisZoomAction());
     actions.append(new KisShowPaletteAction());
     actions.append(new KisSelectLayerAction());
     actions.append(new KisGammaExposureAction());
     actions.append(new KisChangeFrameAction());
 }
 
 QString KisInputProfileManager::Private::profileFileName(const QString &profileName)
 {
     return profileName.toLower().remove(QRegExp("[^a-z0-9]")).append(".profile");
 }
diff --git a/libs/ui/kis_animation_frame_cache.cpp b/libs/ui/kis_animation_frame_cache.cpp
index 68860a5136..495e126012 100644
--- a/libs/ui/kis_animation_frame_cache.cpp
+++ b/libs/ui/kis_animation_frame_cache.cpp
@@ -1,412 +1,414 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_animation_frame_cache.h"
 
 #include <QMap>
 
 #include "kis_debug.h"
 
 #include "kis_image.h"
 #include "kis_image_animation_interface.h"
 #include "kis_time_range.h"
 #include "KisPart.h"
 #include "kis_animation_cache_populator.h"
 
 #include <KisAbstractFrameCacheSwapper.h>
 #include "KisFrameCacheSwapper.h"
 #include "KisInMemoryFrameCacheSwapper.h"
 
 #include "kis_image_config.h"
 #include "kis_config_notifier.h"
 
 #include "opengl/kis_opengl_image_textures.h"
 
 #include <kis_algebra_2d.h>
 #include <cmath>
 
 
 struct KisAnimationFrameCache::Private
 {
     Private(KisOpenGLImageTexturesSP _textures)
         : textures(_textures)
     {
         image = textures->image();
     }
 
     ~Private()
     {
     }
 
     KisOpenGLImageTexturesSP textures;
     KisImageWSP image;
 
     QScopedPointer<KisAbstractFrameCacheSwapper> swapper;
     int frameSizeLimit = 777;
 
     KisOpenGLUpdateInfoSP fetchFrameDataImpl(KisImageSP image, const QRect &requestedRect, int lod);
 
     struct Frame
     {
         KisOpenGLUpdateInfoSP openGlFrame;
         int length;
 
         Frame(KisOpenGLUpdateInfoSP info, int length)
             : openGlFrame(info), length(length)
         {}
     };
 
     QMap<int, int> newFrames;
 
     int getFrameIdAtTime(int time) const
     {
         if (newFrames.isEmpty()) return -1;
 
         auto it = newFrames.upperBound(time);
 
         if (it != newFrames.constBegin()) it--;
 
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(it != newFrames.constEnd(), 0);
         const int start = it.key();
         const int length = it.value();
 
         bool foundFrameValid = false;
 
         if (length == -1) {
             if (start <= time) {
                 foundFrameValid = true;
             }
         } else {
             int end = start + length - 1;
             if (start <= time && time <= end) {
                 foundFrameValid = true;
             }
         }
 
         return foundFrameValid ? start : -1;
     }
 
     bool hasFrame(int time) const {
         return getFrameIdAtTime(time) >= 0;
     }
 
     KisOpenGLUpdateInfoSP getFrame(int time)
     {
         const int frameId = getFrameIdAtTime(time);
         return frameId >= 0 ? swapper->loadFrame(frameId) : 0;
     }
 
     void addFrame(KisOpenGLUpdateInfoSP info, const KisTimeRange& range)
     {
         invalidate(range);
 
         const int length = range.isInfinite() ? -1 : range.end() - range.start() + 1;
         newFrames.insert(range.start(), length);
         swapper->saveFrame(range.start(), info, image->bounds());
     }
 
     /**
      * Invalidate any cached frames within the given time range.
      * @param range
      * @return true if frames were invalidated, false if nothing was changed
      */
     bool invalidate(const KisTimeRange& range)
     {
         if (newFrames.isEmpty()) return false;
 
         bool cacheChanged = false;
 
         auto it = newFrames.lowerBound(range.start());
         if (it.key() != range.start() && it != newFrames.begin()) it--;
 
         while (it != newFrames.end()) {
             const int start = it.key();
             const int length = it.value();
             const bool frameIsInfinite = (length == -1);
             const int end = start + length - 1;
 
             if (start >= range.start()) {
                 if (!range.isInfinite() && start > range.end()) {
                     break;
                 }
 
                 if (!range.isInfinite() && (frameIsInfinite || end > range.end())) {
                     // Reinsert with a later start
                     int newStart = range.end() + 1;
                     int newLength = frameIsInfinite ? -1 : (end - newStart + 1);
 
                     newFrames.insert(newStart, newLength);
                     swapper->moveFrame(start, newStart);
                 } else {
                     swapper->forgetFrame(start);
                 }
 
                 it = newFrames.erase(it);
 
                 cacheChanged = true;
                 continue;
 
             } else if (frameIsInfinite || end >= range.start()) {
                 const int newEnd = range.start() - 1;
                 *it = newEnd - start + 1;
 
                 cacheChanged = true;
             }
 
             it++;
         }
 
         return cacheChanged;
     }
 
     int effectiveLevelOfDetail(const QRect &rc) const {
         if (!frameSizeLimit) return 0;
 
         const int maxDimension = KisAlgebra2D::maxDimension(rc);
 
         const qreal minLod = -std::log2(qreal(frameSizeLimit) / maxDimension);
         const int lodLimit = qMax(0, qCeil(minLod));
         return lodLimit;
     }
 
 
     // TODO: verify that we don't have any leak here!
     typedef QMap<KisOpenGLImageTexturesSP, KisAnimationFrameCache*> CachesMap;
     static CachesMap caches;
 };
 
 KisAnimationFrameCache::Private::CachesMap KisAnimationFrameCache::Private::caches;
 
 KisAnimationFrameCacheSP KisAnimationFrameCache::getFrameCache(KisOpenGLImageTexturesSP textures)
 {
     KisAnimationFrameCache *cache;
 
     Private::CachesMap::iterator it = Private::caches.find(textures);
     if (it == Private::caches.end()) {
         cache = new KisAnimationFrameCache(textures);
         Private::caches.insert(textures, cache);
     } else {
         cache = it.value();
     }
 
     return cache;
 }
 
 const QList<KisAnimationFrameCache *> KisAnimationFrameCache::caches()
 {
     return Private::caches.values();
 }
 
 KisAnimationFrameCache::KisAnimationFrameCache(KisOpenGLImageTexturesSP textures)
     : m_d(new Private(textures))
 {
     // create swapping backend
     slotConfigChanged();
 
     connect(m_d->image->animationInterface(), SIGNAL(sigFramesChanged(KisTimeRange,QRect)), this, SLOT(framesChanged(KisTimeRange,QRect)));
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
 }
 
 KisAnimationFrameCache::~KisAnimationFrameCache()
 {
     Private::caches.remove(m_d->textures);
 }
 
 bool KisAnimationFrameCache::uploadFrame(int time)
 {
     KisOpenGLUpdateInfoSP info = m_d->getFrame(time);
 
     if (!info) {
         // Do nothing!
         //
         // Previously we were trying to start cache regeneration in this point,
         // but it caused even bigger slowdowns when scrubbing
     } else {
         m_d->textures->recalculateCache(info);
     }
 
     return bool(info);
 }
 
 bool KisAnimationFrameCache::shouldUploadNewFrame(int newTime, int oldTime) const
 {
     if (oldTime < 0) return true;
 
     const int oldKeyframeStart = m_d->getFrameIdAtTime(oldTime);
     if (oldKeyframeStart < 0) return true;
 
     const int oldKeyFrameLength = m_d->newFrames[oldKeyframeStart];
     return !(newTime >= oldKeyframeStart && (newTime < oldKeyframeStart + oldKeyFrameLength || oldKeyFrameLength == -1));
 }
 
 KisAnimationFrameCache::CacheStatus KisAnimationFrameCache::frameStatus(int time) const
 {
     return m_d->hasFrame(time) ? Cached : Uncached;
 }
 
 KisImageWSP KisAnimationFrameCache::image()
 {
     return m_d->image;
 }
 
 void KisAnimationFrameCache::framesChanged(const KisTimeRange &range, const QRect &rect)
 {
     Q_UNUSED(rect);
 
     if (!range.isValid()) return;
 
     bool cacheChanged = m_d->invalidate(range);
 
     if (cacheChanged) {
         emit changed();
     }
 }
 
 void KisAnimationFrameCache::slotConfigChanged()
 {
     m_d->newFrames.clear();
 
     KisImageConfig cfg;
 
     if (cfg.useOnDiskAnimationCacheSwapping()) {
         m_d->swapper.reset(new KisFrameCacheSwapper(m_d->textures->updateInfoBuilder(), cfg.swapDir()));
     } else {
         m_d->swapper.reset(new KisInMemoryFrameCacheSwapper());
     }
 
     m_d->frameSizeLimit = cfg.useAnimationCacheFrameSizeLimit() ? cfg.animationCacheFrameSizeLimit() : 0;
     emit changed();
 }
 
 KisOpenGLUpdateInfoSP KisAnimationFrameCache::Private::fetchFrameDataImpl(KisImageSP image, const QRect &requestedRect, int lod)
 {
     if (lod > 0) {
         KisPaintDeviceSP tempDevice = new KisPaintDevice(image->projection()->colorSpace());
         tempDevice->prepareClone(image->projection());
         image->projection()->generateLodCloneDevice(tempDevice, image->projection()->extent(), lod);
 
         const QRect fetchRect = KisLodTransform::alignedRect(requestedRect, lod);
         return textures->updateInfoBuilder().buildUpdateInfo(fetchRect, tempDevice, image->bounds(), lod, true);
     } else {
         return textures->updateCache(requestedRect, image);
     }
 }
 
 KisOpenGLUpdateInfoSP KisAnimationFrameCache::fetchFrameData(int time, KisImageSP image, const QRegion &requestedRegion) const
 {
     if (time != image->animationInterface()->currentTime()) {
         qWarning() << "WARNING: KisAnimationFrameCache::frameReady image's time doesn't coincide with the requested time!";
         qWarning() << "    "  << ppVar(image->animationInterface()->currentTime()) << ppVar(time);
     }
 
     // the frames are always generated at full scale
     KIS_SAFE_ASSERT_RECOVER_NOOP(image->currentLevelOfDetail() == 0);
 
     const int lod = m_d->effectiveLevelOfDetail(requestedRegion.boundingRect());
 
     KisOpenGLUpdateInfoSP totalInfo;
 
     Q_FOREACH (const QRect &rc, requestedRegion.rects()) {
         KisOpenGLUpdateInfoSP info = m_d->fetchFrameDataImpl(image, rc, lod);
         if (!totalInfo) {
             totalInfo = info;
         } else {
             const bool result = totalInfo->tryMergeWith(*info);
             KIS_SAFE_ASSERT_RECOVER_NOOP(result);
         }
     }
 
     return totalInfo;
 }
 
 void KisAnimationFrameCache::addConvertedFrameData(KisOpenGLUpdateInfoSP info, int time)
 {
     KisTimeRange identicalRange = KisTimeRange::infinite(0);
     KisTimeRange::calculateTimeRangeRecursive(m_d->image->root(), time, identicalRange, true);
 
     m_d->addFrame(info, identicalRange);
 
     emit changed();
 }
 
 void KisAnimationFrameCache::dropLowQualityFrames(const KisTimeRange &range, const QRect &regionOfInterest, const QRect &minimalRect)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(!range.isInfinite());
     if (m_d->newFrames.isEmpty()) return;
 
     auto it = m_d->newFrames.upperBound(range.start());
 
+    // the vector is guaranteed to be non-empty,
+    // so decrementing iterator is safe
     if (it != m_d->newFrames.begin()) it--;
 
-    while (it.key() <= range.end()) {
+    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_image_manager.cc b/libs/ui/kis_image_manager.cc
index 7ae7c670a0..25bea29b9a 100644
--- a/libs/ui/kis_image_manager.cc
+++ b/libs/ui/kis_image_manager.cc
@@ -1,211 +1,211 @@
 /* This file is part of the KDE project
  * Copyright (C) Boudewijn Rempt <boud@valdyas.org>, (C) 2006
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_image_manager.h"
 
 #include <QString>
 #include <QStandardPaths>
 
 #include <QAction>
 #include <QUrl>
 #include <QColorDialog>
 
 #include <klocalizedstring.h>
 
 #include <KoColor.h>
 #include <KoFileDialog.h>
 
 #include <kis_types.h>
 #include <kis_image.h>
 #include <kis_icon.h>
 #include <KisImportExportManager.h>
 #include "kis_import_catcher.h"
 #include "KisViewManager.h"
 #include "KisDocument.h"
 #include "dialogs/kis_dlg_image_properties.h"
 #include "commands/kis_image_commands.h"
 #include "kis_action.h"
 #include "kis_action_manager.h"
 #include "kis_layer_utils.h"
 
 #include "kis_signal_compressor_with_param.h"
 
 
 KisImageManager::KisImageManager(KisViewManager * view)
         : m_view(view)
 {
 }
 
 void KisImageManager::setView(QPointer<KisView>imageView)
 {
     Q_UNUSED(imageView);
 }
 
 void KisImageManager::setup(KisActionManager *actionManager)
 {
 
     KisAction *action  = actionManager->createAction("import_layer_from_file");
     connect(action, SIGNAL(triggered()), this, SLOT(slotImportLayerFromFile()));
 
     action  = actionManager->createAction("image_properties");
     connect(action, SIGNAL(triggered()), this, SLOT(slotImageProperties()));
 
     action  = actionManager->createAction("import_layer_as_paint_layer");
     connect(action, SIGNAL(triggered()), this, SLOT(slotImportLayerFromFile()));
 
     action  = actionManager->createAction("import_layer_as_transparency_mask");
     connect(action, SIGNAL(triggered()), this, SLOT(slotImportLayerAsTransparencyMask()));
 
     action  = actionManager->createAction("import_layer_as_filter_mask");
     connect(action, SIGNAL(triggered()), this, SLOT(slotImportLayerAsFilterMask()));
 
     action  = actionManager->createAction("import_layer_as_selection_mask");
     connect(action, SIGNAL(triggered()), this, SLOT(slotImportLayerAsSelectionMask()));
 
     action = actionManager->createAction("image_color");
     connect(action, SIGNAL(triggered()), this, SLOT(slotImageColor()));
 }
 
 void KisImageManager::slotImportLayerFromFile()
 {
     importImage(QUrl(), "KisPaintLayer");
 }
 
 void KisImageManager::slotImportLayerAsTransparencyMask()
 {
     importImage(QUrl(), "KisTransparencyMask");
 }
 
 void KisImageManager::slotImportLayerAsFilterMask()
 {
     importImage(QUrl(), "KisFilterMask");
 }
 
 void KisImageManager::slotImportLayerAsSelectionMask()
 {
     importImage(QUrl(), "KisSelectionMask");
 }
 
 
 qint32 KisImageManager::importImage(const QUrl &urlArg, const QString &layerType)
 {
     KisImageWSP currentImage = m_view->image();
 
     if (!currentImage) {
         return 0;
     }
 
     QList<QUrl> urls;
     qint32 rc = 0;
 
     if (urlArg.isEmpty()) {
         KoFileDialog dialog(m_view->mainWindow(), KoFileDialog::OpenFiles, "OpenDocument");
         dialog.setCaption(i18n("Import Image"));
         dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
-        dialog.setMimeTypeFilters(KisImportExportManager::mimeFilter(KisImportExportManager::Import));
+        dialog.setMimeTypeFilters(KisImportExportManager::supportedMimeTypes(KisImportExportManager::Import));
         QStringList fileNames = dialog.filenames();
         Q_FOREACH (const QString &fileName, fileNames) {
             urls << QUrl::fromLocalFile(fileName);
         }
 
     } else {
         urls.push_back(urlArg);
     }
 
     if (urls.empty())
         return 0;
 
     for (QList<QUrl>::iterator it = urls.begin(); it != urls.end(); ++it) {
         new KisImportCatcher(*it, m_view, layerType);
     }
 
     m_view->canvas()->update();
 
     return rc;
 }
 
 void KisImageManager::resizeCurrentImage(qint32 w, qint32 h, qint32 xOffset, qint32 yOffset)
 {
     if (!m_view->image()) return;
 
     m_view->image()->resizeImage(QRect(-xOffset, -yOffset, w, h));
 }
 
 void KisImageManager::scaleCurrentImage(const QSize &size, qreal xres, qreal yres, KisFilterStrategy *filterStrategy)
 {
     if (!m_view->image()) return;
     m_view->image()->scaleImage(size, xres, yres, filterStrategy);
 }
 
 void KisImageManager::rotateCurrentImage(double radians)
 {
     if (!m_view->image()) return;
     m_view->image()->rotateImage(radians);
 }
 
 void KisImageManager::shearCurrentImage(double angleX, double angleY)
 {
     if (!m_view->image()) return;
     m_view->image()->shear(angleX, angleY);
 }
 
 
 void KisImageManager::slotImageProperties()
 {
     KisImageWSP image = m_view->image();
     if (!image) return;
 
     QPointer<KisDlgImageProperties> dlg = new KisDlgImageProperties(image, m_view->mainWindow());
     if (dlg->exec() == QDialog::Accepted) {
         image->convertProjectionColorSpace(dlg->colorSpace());
     }
     delete dlg;
 }
 
 void updateImageBackgroundColor(KisImageSP image, const QColorDialog *dlg)
 {
     QColor newColor = dlg->currentColor();
     KoColor bg = image->defaultProjectionColor();
     bg.fromQColor(newColor);
 
     KisLayerUtils::changeImageDefaultProjectionColor(image, bg);
 }
 
 void KisImageManager::slotImageColor()
 {
     KisImageWSP image = m_view->image();
     if (!image) return;
 
     QColorDialog dlg;
     dlg.setOption(QColorDialog::ShowAlphaChannel, true);
 
     KoColor bg = image->defaultProjectionColor();
     dlg.setCurrentColor(bg.toQColor());
 
     KisSignalCompressor compressor(200, KisSignalCompressor::FIRST_INACTIVE);
 
     std::function<void ()> updateCall(std::bind(updateImageBackgroundColor, image, &dlg));
     SignalToFunctionProxy proxy(updateCall);
 
     connect(&dlg, SIGNAL(currentColorChanged(QColor)), &compressor, SLOT(start()));
     connect(&compressor, SIGNAL(timeout()), &proxy, SLOT(start()));
 
     dlg.exec();
 }
 
 
diff --git a/libs/ui/kis_layer_manager.cc b/libs/ui/kis_layer_manager.cc
index 5dda333800..2c7ad7af0b 100644
--- a/libs/ui/kis_layer_manager.cc
+++ b/libs/ui/kis_layer_manager.cc
@@ -1,955 +1,955 @@
 /*
  *  Copyright (C) 2006 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_layer_manager.h"
 
 #include <QRect>
 #include <QApplication>
 #include <QCursor>
 #include <QString>
 #include <QDialog>
 #include <QVBoxLayout>
 #include <QFileInfo>
 #include <QStandardPaths>
 
 #include <kactioncollection.h>
 #include <klocalizedstring.h>
 #include <QMessageBox>
 #include <QUrl>
 
 #include <kis_file_name_requester.h>
 #include <kis_icon.h>
 #include <KisImportExportManager.h>
 #include <KisDocument.h>
 #include <KoColorSpace.h>
 #include <KoCompositeOpRegistry.h>
 #include <KoPointerEvent.h>
 #include <KoColorProfile.h>
 #include <KoSelection.h>
 #include <KisPart.h>
 #include <KisMainWindow.h>
 
 #include <filter/kis_filter_configuration.h>
 #include <filter/kis_filter.h>
 #include <kis_filter_strategy.h>
 #include <generator/kis_generator_layer.h>
 #include <kis_file_layer.h>
 #include <kis_adjustment_layer.h>
 #include <kis_mask.h>
 #include <kis_clone_layer.h>
 #include <kis_group_layer.h>
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <kis_paint_device.h>
 #include <kis_selection.h>
 #include <flake/kis_shape_layer.h>
 #include <kis_undo_adapter.h>
 #include <kis_painter.h>
 #include <metadata/kis_meta_data_store.h>
 #include <metadata/kis_meta_data_merge_strategy_registry.h>
 #include <kis_psd_layer_style.h>
 #include <KisMimeDatabase.h>
 
 #include "KisImportExportManager.h"
 #include "kis_config.h"
 #include "kis_cursor.h"
 #include "dialogs/kis_dlg_adj_layer_props.h"
 #include "dialogs/kis_dlg_adjustment_layer.h"
 #include "dialogs/kis_dlg_layer_properties.h"
 #include "dialogs/kis_dlg_generator_layer.h"
 #include "dialogs/kis_dlg_file_layer.h"
 #include "dialogs/kis_dlg_layer_style.h"
 #include "KisDocument.h"
 #include "kis_filter_manager.h"
 #include "kis_node_visitor.h"
 #include "kis_paint_layer.h"
 #include "commands/kis_image_commands.h"
 #include "commands/kis_node_commands.h"
 #include "kis_change_file_layer_command.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_selection_manager.h"
 #include "kis_statusbar.h"
 #include "KisViewManager.h"
 #include "kis_zoom_manager.h"
 #include "canvas/kis_canvas2.h"
 #include "widgets/kis_meta_data_merge_strategy_chooser_widget.h"
 #include "widgets/kis_wdg_generator.h"
 #include "kis_progress_widget.h"
 #include "kis_node_commands_adapter.h"
 #include "kis_node_manager.h"
 #include "kis_action.h"
 #include "kis_action_manager.h"
 #include "KisPart.h"
 #include "kis_raster_keyframe_channel.h"
 
 #include "kis_signal_compressor_with_param.h"
 #include "kis_abstract_projection_plane.h"
 #include "commands_new/kis_set_layer_style_command.h"
 #include "kis_post_execution_undo_adapter.h"
 #include "kis_selection_mask.h"
 #include "kis_layer_utils.h"
 #include "lazybrush/kis_colorize_mask.h"
 
 #include "KisSaveGroupVisitor.h"
 
 KisLayerManager::KisLayerManager(KisViewManager * view)
     : m_view(view)
     , m_imageView(0)
     , m_imageFlatten(0)
     , m_imageMergeLayer(0)
     , m_groupLayersSave(0)
     , m_imageResizeToLayer(0)
     , m_flattenLayer(0)
     , m_rasterizeLayer(0)
     , m_commandsAdapter(new KisNodeCommandsAdapter(m_view))
     , m_layerStyle(0)
 {
 }
 
 KisLayerManager::~KisLayerManager()
 {
     delete m_commandsAdapter;
 }
 
 void KisLayerManager::setView(QPointer<KisView>view)
 {
     m_imageView = view;
 }
 
 KisLayerSP KisLayerManager::activeLayer()
 {
     if (m_imageView) {
         return m_imageView->currentLayer();
     }
     return 0;
 }
 
 KisPaintDeviceSP KisLayerManager::activeDevice()
 {
     if (activeLayer()) {
         return activeLayer()->paintDevice();
     }
     return 0;
 }
 
 void KisLayerManager::activateLayer(KisLayerSP layer)
 {
     if (m_imageView) {
         emit sigLayerActivated(layer);
         layersUpdated();
         if (layer) {
             m_view->resourceProvider()->slotNodeActivated(layer.data());
         }
     }
 }
 
 
 void KisLayerManager::setup(KisActionManager* actionManager)
 {
     m_imageFlatten = actionManager->createAction("flatten_image");
     connect(m_imageFlatten, SIGNAL(triggered()), this, SLOT(flattenImage()));
 
     m_imageMergeLayer = actionManager->createAction("merge_layer");
     connect(m_imageMergeLayer, SIGNAL(triggered()), this, SLOT(mergeLayer()));
 
     m_flattenLayer = actionManager->createAction("flatten_layer");
     connect(m_flattenLayer, SIGNAL(triggered()), this, SLOT(flattenLayer()));
 
     m_rasterizeLayer = actionManager->createAction("rasterize_layer");
     connect(m_rasterizeLayer, SIGNAL(triggered()), this, SLOT(rasterizeLayer()));
 
     m_groupLayersSave = actionManager->createAction("save_groups_as_images");
     connect(m_groupLayersSave, SIGNAL(triggered()), this, SLOT(saveGroupLayers()));
 
     m_convertGroupAnimated = actionManager->createAction("convert_group_to_animated");
     connect(m_convertGroupAnimated, SIGNAL(triggered()), this, SLOT(convertGroupToAnimated()));
 
     m_imageResizeToLayer = actionManager->createAction("resizeimagetolayer");
     connect(m_imageResizeToLayer, SIGNAL(triggered()), this, SLOT(imageResizeToActiveLayer()));
 
     KisAction *action = actionManager->createAction("trim_to_image");
     connect(action, SIGNAL(triggered()), this, SLOT(trimToImage()));
 
     m_layerStyle  = actionManager->createAction("layer_style");
     connect(m_layerStyle, SIGNAL(triggered()), this, SLOT(layerStyle()));
 
 }
 
 void KisLayerManager::updateGUI()
 {
     KisImageSP image = m_view->image();
     KisLayerSP layer = activeLayer();
 
     const bool isGroupLayer = layer && layer->inherits("KisGroupLayer");
 
     m_imageMergeLayer->setText(
         isGroupLayer ?
             i18nc("@action:inmenu", "Merge Group") :
             i18nc("@action:inmenu", "Merge with Layer Below"));
     m_flattenLayer->setVisible(!isGroupLayer);
 
     if (m_view->statusBar())
         m_view->statusBar()->setProfile(image);
 }
 
 void KisLayerManager::imageResizeToActiveLayer()
 {
     KisLayerSP layer;
     KisImageWSP image = m_view->image();
 
     if (image && (layer = activeLayer())) {
         QRect cropRect = layer->projection()->nonDefaultPixelArea();
         if (!cropRect.isEmpty()) {
             image->cropImage(cropRect);
         } else {
             m_view->showFloatingMessage(
                 i18nc("floating message in layer manager",
                       "Layer is empty "),
                 QIcon(), 2000, KisFloatingMessage::Low);
         }
     }
 }
 
 void KisLayerManager::trimToImage()
 {
     KisImageWSP image = m_view->image();
     if (image) {
         image->cropImage(image->bounds());
     }
 }
 
 void KisLayerManager::layerProperties()
 {
     if (!m_view) return;
     if (!m_view->document()) return;
 
     KisLayerSP layer = activeLayer();
     if (!layer) return;
 
     QList<KisNodeSP> selectedNodes = m_view->nodeManager()->selectedNodes();
     const bool multipleLayersSelected = selectedNodes.size() > 1;
 
     KisAdjustmentLayerSP alayer = KisAdjustmentLayerSP(dynamic_cast<KisAdjustmentLayer*>(layer.data()));
     KisGeneratorLayerSP glayer = KisGeneratorLayerSP(dynamic_cast<KisGeneratorLayer*>(layer.data()));
     KisFileLayerSP flayer = KisFileLayerSP(dynamic_cast<KisFileLayer*>(layer.data()));
 
     if (alayer && !multipleLayersSelected) {
 
         KisPaintDeviceSP dev = alayer->projection();
 
         KisDlgAdjLayerProps dlg(alayer, alayer.data(), dev, m_view, alayer->filter().data(), alayer->name(), i18n("Filter Layer Properties"), m_view->mainWindow(), "dlgadjlayerprops");
         dlg.resize(dlg.minimumSizeHint());
 
 
         KisFilterConfigurationSP configBefore(alayer->filter());
         KIS_ASSERT_RECOVER_RETURN(configBefore);
         QString xmlBefore = configBefore->toXML();
 
 
         if (dlg.exec() == QDialog::Accepted) {
 
             alayer->setName(dlg.layerName());
 
             KisFilterConfigurationSP configAfter(dlg.filterConfiguration());
             Q_ASSERT(configAfter);
             QString xmlAfter = configAfter->toXML();
 
             if(xmlBefore != xmlAfter) {
                 KisChangeFilterCmd *cmd
                    = new KisChangeFilterCmd(alayer,
                                              configBefore->name(),
                                              xmlBefore,
                                              configAfter->name(),
                                              xmlAfter,
                                              false);
                 // FIXME: check whether is needed
                 cmd->redo();
                 m_view->undoAdapter()->addCommand(cmd);
                 m_view->document()->setModified(true);
             }
         }
         else {
             KisFilterConfigurationSP configAfter(dlg.filterConfiguration());
             Q_ASSERT(configAfter);
             QString xmlAfter = configAfter->toXML();
 
             if(xmlBefore != xmlAfter) {
                 alayer->setFilter(KisFilterRegistry::instance()->cloneConfiguration(configBefore.data()));
                 alayer->setDirty();
             }
         }
     }
     else if (glayer && !multipleLayersSelected) {
 
         KisDlgGeneratorLayer dlg(glayer->name(), m_view, m_view->mainWindow());
         dlg.setCaption(i18n("Fill Layer Properties"));
 
         KisFilterConfigurationSP configBefore(glayer->filter());
         Q_ASSERT(configBefore);
         QString xmlBefore = configBefore->toXML();
 
         dlg.setConfiguration(configBefore.data());
         dlg.resize(dlg.minimumSizeHint());
 
         if (dlg.exec() == QDialog::Accepted) {
 
             glayer->setName(dlg.layerName());
 
             KisFilterConfigurationSP configAfter(dlg.configuration());
             Q_ASSERT(configAfter);
             QString xmlAfter = configAfter->toXML();
 
             if(xmlBefore != xmlAfter) {
                 KisChangeFilterCmd *cmd
                         = new KisChangeFilterCmd(glayer,
                                                  configBefore->name(),
                                                  xmlBefore,
                                                  configAfter->name(),
                                                  xmlAfter,
                                                  true);
                 // FIXME: check whether is needed
                 cmd->redo();
                 m_view->undoAdapter()->addCommand(cmd);
                 m_view->document()->setModified(true);
             }
 
         }
     }  else if (flayer && !multipleLayersSelected){
         QString basePath = QFileInfo(m_view->document()->url().toLocalFile()).absolutePath();
         QString fileNameOld = flayer->fileName();
         KisFileLayer::ScalingMethod scalingMethodOld = flayer->scalingMethod();
         KisDlgFileLayer dlg(basePath, flayer->name(), m_view->mainWindow());
         dlg.setCaption(i18n("File Layer Properties"));
         dlg.setFileName(fileNameOld);
         dlg.setScalingMethod(scalingMethodOld);
 
         if (dlg.exec() == QDialog::Accepted) {
             const QString fileNameNew = dlg.fileName();
             KisFileLayer::ScalingMethod scalingMethodNew = dlg.scaleToImageResolution();
 
             if(fileNameNew.isEmpty()){
                 QMessageBox::critical(m_view->mainWindow(), i18nc("@title:window", "Krita"), i18n("No file name specified"));
                 return;
             }
             flayer->setName(dlg.layerName());
 
             if (fileNameOld!= fileNameNew || scalingMethodOld != scalingMethodNew) {
                 KisChangeFileLayerCmd *cmd
                         = new KisChangeFileLayerCmd(flayer,
                                                 basePath,
                                                 fileNameOld,
                                                 scalingMethodOld,
                                                 basePath,
                                                 fileNameNew,
                                                 scalingMethodNew);
                 m_view->undoAdapter()->addCommand(cmd);
             }
         }
     } else { // If layer == normal painting layer, vector layer, or group layer
         QList<KisNodeSP> selectedNodes = m_view->nodeManager()->selectedNodes();
 
         KisDlgLayerProperties *dialog = new KisDlgLayerProperties(selectedNodes, m_view);
         dialog->resize(dialog->minimumSizeHint());
         dialog->setAttribute(Qt::WA_DeleteOnClose);
         Qt::WindowFlags flags = dialog->windowFlags();
         dialog->setWindowFlags(flags | Qt::WindowStaysOnTopHint | Qt::Dialog);
         dialog->show();
 
     }
 }
 
 void KisLayerManager::convertNodeToPaintLayer(KisNodeSP source)
 {
     KisImageWSP image = m_view->image();
     if (!image) return;
 
 
     KisLayer *srcLayer = qobject_cast<KisLayer*>(source.data());
     if (srcLayer && (srcLayer->inherits("KisGroupLayer") || srcLayer->layerStyle() || srcLayer->childCount() > 0)) {
         image->flattenLayer(srcLayer);
         return;
     }
 
 
     KisPaintDeviceSP srcDevice =
         source->paintDevice() ? source->projection() : source->original();
 
     bool putBehind = false;
     QString newCompositeOp = source->compositeOpId();
     KisColorizeMask *colorizeMask = dynamic_cast<KisColorizeMask*>(source.data());
     if (colorizeMask) {
         srcDevice = colorizeMask->coloringProjection();
         putBehind = colorizeMask->compositeOpId() == COMPOSITE_BEHIND;
         if (putBehind) {
             newCompositeOp = COMPOSITE_OVER;
         }
     }
 
     if (!srcDevice) return;
 
     KisPaintDeviceSP clone;
 
     if (*srcDevice->colorSpace() !=
         *srcDevice->compositionSourceColorSpace()) {
 
         clone = new KisPaintDevice(srcDevice->compositionSourceColorSpace());
 
         QRect rc(srcDevice->extent());
         KisPainter::copyAreaOptimized(rc.topLeft(), srcDevice, clone, rc);
 
     } else {
         clone = new KisPaintDevice(*srcDevice);
     }
 
     KisLayerSP layer = new KisPaintLayer(image,
                                          source->name(),
                                          source->opacity(),
                                          clone);
     layer->setCompositeOpId(newCompositeOp);
 
     KisNodeSP parent = source->parent();
     KisNodeSP above = source;
 
     while (parent && !parent->allowAsChild(layer)) {
         above = above->parent();
         parent = above ? above->parent() : 0;
     }
 
     if (putBehind && above == source->parent()) {
         above = above->prevSibling();
     }
 
     m_commandsAdapter->beginMacro(kundo2_i18n("Convert to a Paint Layer"));
     m_commandsAdapter->addNode(layer, parent, above);
     m_commandsAdapter->removeNode(source);
     m_commandsAdapter->endMacro();
 
 }
 
 void KisLayerManager::convertGroupToAnimated()
 {
     KisGroupLayerSP group = dynamic_cast<KisGroupLayer*>(activeLayer().data());
     if (group.isNull()) return;
 
     KisPaintLayerSP animatedLayer = new KisPaintLayer(m_view->image(), group->name(), OPACITY_OPAQUE_U8);
     animatedLayer->enableAnimation();
     KisRasterKeyframeChannel *contentChannel = dynamic_cast<KisRasterKeyframeChannel*>(
             animatedLayer->getKeyframeChannel(KisKeyframeChannel::Content.id(), true));
     KIS_ASSERT_RECOVER_RETURN(contentChannel);
 
     KisNodeSP child = group->firstChild();
     int time = 0;
     while (child) {
         contentChannel->importFrame(time, child->projection(), NULL);
         time++;
 
         child = child->nextSibling();
     }
 
     m_commandsAdapter->beginMacro(kundo2_i18n("Convert to an animated layer"));
     m_commandsAdapter->addNode(animatedLayer, group->parent(), group);
     m_commandsAdapter->removeNode(group);
     m_commandsAdapter->endMacro();
 }
 
 void KisLayerManager::convertLayerToFileLayer(KisNodeSP source)
 {
     KisImageSP image = m_view->image();
     if (!image) return;
 
-    QStringList listMimeFilter = KisImportExportManager::mimeFilter(KisImportExportManager::Export);
+    QStringList listMimeFilter = KisImportExportManager::supportedMimeTypes(KisImportExportManager::Export);
 
     KoDialog dlg;
     QWidget *page = new QWidget(&dlg);
     dlg.setMainWidget(page);
     QBoxLayout *layout = new QVBoxLayout(page);
     dlg.setWindowTitle(i18n("Save layers to..."));
     QLabel *lbl = new QLabel(i18n("Choose the location where the layer will be saved to. The new file layer will then reference this location."));
     lbl->setWordWrap(true);
     layout->addWidget(lbl);
     KisFileNameRequester *urlRequester = new KisFileNameRequester(page);
     urlRequester->setMode(KoFileDialog::SaveFile);
     urlRequester->setMimeTypeFilters(listMimeFilter);
     urlRequester->setFileName(m_view->document()->url().toLocalFile());
     if (m_view->document()->url().isLocalFile()) {
         QFileInfo location = QFileInfo(m_view->document()->url().toLocalFile()).baseName();
         location.setFile(location.dir(), location.baseName()+"_"+ source->name()+".kra");
         urlRequester->setFileName(location.absoluteFilePath());
     } else {
         const QFileInfo location = QFileInfo(QStandardPaths::writableLocation(QStandardPaths::HomeLocation));
         const QString proposedFileName = QDir(location.absoluteFilePath()).absoluteFilePath(source->name() + ".kra");
         urlRequester->setFileName(proposedFileName);
     }
 
     layout->addWidget(urlRequester);
     if (!dlg.exec()) return;
 
     QString path = urlRequester->fileName();
 
     if (path.isEmpty()) return;
 
     QFileInfo f(path);
 
     QString mimeType= KisMimeDatabase::mimeTypeForFile(f.fileName());
     if (mimeType.isEmpty()) {
         mimeType = "image/png";
     }
     QScopedPointer<KisDocument> doc(KisPart::instance()->createDocument());
 
     QRect bounds = source->exactBounds();
 
     KisImageSP dst = new KisImage(doc->createUndoStore(),
                                   image->width(),
                                   image->height(),
                                   image->projection()->compositionSourceColorSpace(),
                                   source->name());
     dst->setResolution(image->xRes(), image->yRes());
     doc->setFileBatchMode(false);
     doc->setCurrentImage(dst);
     KisNodeSP node = source->clone();
     dst->addNode(node);
     dst->initialRefreshGraph();
     dst->cropImage(bounds);
     dst->waitForDone();
 
     bool r = doc->exportDocumentSync(QUrl::fromLocalFile(path), mimeType.toLatin1());
     if (!r) {
         qDebug()<< "Path:"<<path;
         qWarning() << doc->errorMessage();
     } else {
         QString basePath = QFileInfo(m_view->document()->url().toLocalFile()).absolutePath();
         QString relativePath = QDir(basePath).relativeFilePath(path);
         KisFileLayer *fileLayer = new KisFileLayer(image, basePath, relativePath, KisFileLayer::None, source->name(), OPACITY_OPAQUE_U8);
         fileLayer->setX(bounds.x());
         fileLayer->setY(bounds.y());
         KisNodeSP dstParent = source->parent();
         KisNodeSP dstAboveThis = source->prevSibling();
         m_commandsAdapter->beginMacro(kundo2_i18n("Convert to a file layer"));
         m_commandsAdapter->removeNode(source);
         m_commandsAdapter->addNode(fileLayer, dstParent, dstAboveThis);
         m_commandsAdapter->endMacro();
     }
     doc->closeUrl(false);
 }
 
 void KisLayerManager::adjustLayerPosition(KisNodeSP node, KisNodeSP activeNode, KisNodeSP &parent, KisNodeSP &above)
 {
     Q_ASSERT(activeNode);
 
     parent = activeNode;
     above = parent->lastChild();
 
     while (parent &&
            (!parent->allowAsChild(node) || parent->userLocked())) {
 
         above = parent;
         parent = parent->parent();
     }
 
     if (!parent) {
         warnKrita << "KisLayerManager::adjustLayerPosition:"
                    << "No node accepted newly created node";
 
         parent = m_view->image()->root();
         above = parent->lastChild();
     }
 }
 
 void KisLayerManager::addLayerCommon(KisNodeSP activeNode, KisLayerSP layer, bool updateImage)
 {
     KisNodeSP parent;
     KisNodeSP above;
     adjustLayerPosition(layer, activeNode, parent, above);
 
 
     KisGroupLayer *group = dynamic_cast<KisGroupLayer*>(parent.data());
     const bool parentForceUpdate = group && !group->projectionIsValid();
     updateImage |= parentForceUpdate;
 
     m_commandsAdapter->addNode(layer, parent, above, updateImage, updateImage);
 }
 
 KisLayerSP KisLayerManager::addLayer(KisNodeSP activeNode)
 {
     KisLayerSP layer = KisLayerUtils::constructDefaultLayer(m_view->image());
     addLayerCommon(activeNode, layer, false);
 
     return layer;
 }
 
 void KisLayerManager::addGroupLayer(KisNodeSP activeNode)
 {
     KisImageWSP image = m_view->image();
     addLayerCommon(activeNode,
                    new KisGroupLayer(image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8), false);
 }
 
 void KisLayerManager::addCloneLayer(KisNodeSP activeNode)
 {
     KisImageWSP image = m_view->image();
     addLayerCommon(activeNode,
                    new KisCloneLayer(activeLayer(), image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8));
 }
 
 void KisLayerManager::addShapeLayer(KisNodeSP activeNode)
 {
     if (!m_view) return;
     if (!m_view->document()) return;
 
     KisImageWSP image = m_view->image();
     KisShapeLayerSP layer = new KisShapeLayer(m_view->document()->shapeController(), image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8);
 
     addLayerCommon(activeNode, layer, false);
 }
 
 void KisLayerManager::addAdjustmentLayer(KisNodeSP activeNode)
 {
     KisImageWSP image = m_view->image();
 
     KisSelectionSP selection = m_view->selection();
     KisAdjustmentLayerSP adjl = addAdjustmentLayer(activeNode, QString(), 0, selection);
     image->refreshGraph();
 
     KisPaintDeviceSP previewDevice = new KisPaintDevice(*adjl->original());
 
     KisDlgAdjustmentLayer dlg(adjl, adjl.data(), previewDevice, image->nextLayerName(), i18n("New Filter Layer"), m_view);
     dlg.resize(dlg.minimumSizeHint());
 
     // ensure that the device may be free'd by the dialog
     // when it is not needed anymore
     previewDevice = 0;
 
     if (dlg.exec() != QDialog::Accepted || adjl->filter().isNull()) {
         // XXX: add messagebox warning if there's no filter set!
         m_commandsAdapter->undoLastCommand();
     } else {
         adjl->setName(dlg.layerName());
     }
 
 }
 
 KisAdjustmentLayerSP KisLayerManager::addAdjustmentLayer(KisNodeSP activeNode, const QString & name,
                                                          KisFilterConfigurationSP  filter, KisSelectionSP selection)
 {
     KisImageWSP image = m_view->image();
     KisAdjustmentLayerSP layer = new KisAdjustmentLayer(image, name, filter, selection);
     addLayerCommon(activeNode, layer);
 
     return layer;
 }
 
 void KisLayerManager::addGeneratorLayer(KisNodeSP activeNode)
 {
     KisImageWSP image = m_view->image();
 
     KisDlgGeneratorLayer dlg(image->nextLayerName(), m_view, m_view->mainWindow());
     dlg.resize(dlg.minimumSizeHint());
 
     if (dlg.exec() == QDialog::Accepted) {
         KisSelectionSP selection = m_view->selection();
         KisFilterConfigurationSP  generator = dlg.configuration();
         QString name = dlg.layerName();
 
         addLayerCommon(activeNode,
             new KisGeneratorLayer(image, name, generator, selection));
     }
 
 }
 
 void KisLayerManager::flattenImage()
 {
     KisImageSP image = m_view->image();
 
     if (!m_view->blockUntilOperationsFinished(image)) return;
 
     if (image) {
         bool doIt = true;
 
         if (image->nHiddenLayers() > 0) {
             int answer = QMessageBox::warning(m_view->mainWindow(),
                                               i18nc("@title:window", "Flatten Image"),
                                               i18n("The image contains hidden layers that will be lost. Do you want to flatten the image?"),
                                               QMessageBox::Yes | QMessageBox::No,
                                               QMessageBox::No);
 
             if (answer != QMessageBox::Yes) {
                 doIt = false;
             }
         }
 
         if (doIt) {
             image->flatten();
         }
     }
 }
 
 inline bool isSelectionMask(KisNodeSP node) {
     return dynamic_cast<KisSelectionMask*>(node.data());
 }
 
 bool tryMergeSelectionMasks(KisNodeSP currentNode, KisImageSP image)
 {
     bool result = false;
 
     KisNodeSP prevNode = currentNode->prevSibling();
     if (isSelectionMask(currentNode) &&
         prevNode && isSelectionMask(prevNode)) {
 
         QList<KisNodeSP> mergedNodes;
         mergedNodes.append(currentNode);
         mergedNodes.append(prevNode);
 
         image->mergeMultipleLayers(mergedNodes, currentNode);
 
         result = true;
     }
 
     return result;
 }
 
 bool tryFlattenGroupLayer(KisNodeSP currentNode, KisImageSP image)
 {
     bool result = false;
 
     if (currentNode->inherits("KisGroupLayer")) {
         KisGroupLayer *layer = qobject_cast<KisGroupLayer*>(currentNode.data());
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(layer, false);
 
         image->flattenLayer(layer);
         result = true;
     }
 
     return result;
 }
 
 void KisLayerManager::mergeLayer()
 {
     KisImageSP image = m_view->image();
     if (!image) return;
 
     KisLayerSP layer = activeLayer();
     if (!layer) return;
 
     if (!m_view->blockUntilOperationsFinished(image)) return;
 
     QList<KisNodeSP> selectedNodes = m_view->nodeManager()->selectedNodes();
       if (selectedNodes.size() > 1) {
         image->mergeMultipleLayers(selectedNodes, m_view->activeNode());
     }
 
       else if (tryMergeSelectionMasks(m_view->activeNode(), image)) {
         // already done!
     } else if (tryFlattenGroupLayer(m_view->activeNode(), image)) {
         // already done!
     } else {
 
         if (!layer->prevSibling()) return;
         KisLayer *prevLayer = qobject_cast<KisLayer*>(layer->prevSibling().data());
         if (!prevLayer) return;
         if (prevLayer->userLocked()) {
             m_view->showFloatingMessage(
                 i18nc("floating message in layer manager",
                       "Layer is locked "),
                 QIcon(), 2000, KisFloatingMessage::Low);
         }
 
         else if (layer->metaData()->isEmpty() && prevLayer->metaData()->isEmpty()) {
             image->mergeDown(layer, KisMetaData::MergeStrategyRegistry::instance()->get("Drop"));
         }
         else {
             const KisMetaData::MergeStrategy* strategy = KisMetaDataMergeStrategyChooserWidget::showDialog(m_view->mainWindow());
             if (!strategy) return;
             image->mergeDown(layer, strategy);
         }
     }
 
     m_view->updateGUI();
 }
 
 void KisLayerManager::flattenLayer()
 {
     KisImageSP image = m_view->image();
     if (!image) return;
 
     KisLayerSP layer = activeLayer();
     if (!layer) return;
 
     if (!m_view->blockUntilOperationsFinished(image)) return;
 
     convertNodeToPaintLayer(layer);
     m_view->updateGUI();
 }
 
 void KisLayerManager::rasterizeLayer()
 {
     KisImageSP image = m_view->image();
     if (!image) return;
 
     KisLayerSP layer = activeLayer();
     if (!layer) return;
 
     if (!m_view->blockUntilOperationsFinished(image)) return;
 
     KisPaintLayerSP paintLayer = new KisPaintLayer(image, layer->name(), layer->opacity());
     KisPainter gc(paintLayer->paintDevice());
     QRect rc = layer->projection()->exactBounds();
     gc.bitBlt(rc.topLeft(), layer->projection(), rc);
 
     m_commandsAdapter->beginMacro(kundo2_i18n("Rasterize Layer"));
     m_commandsAdapter->addNode(paintLayer.data(), layer->parent().data(), layer.data());
 
     int childCount = layer->childCount();
     for (int i = 0; i < childCount; i++) {
         m_commandsAdapter->moveNode(layer->firstChild(), paintLayer, paintLayer->lastChild());
     }
     m_commandsAdapter->removeNode(layer);
     m_commandsAdapter->endMacro();
     updateGUI();
 }
 
 
 void KisLayerManager::layersUpdated()
 {
     KisLayerSP layer = activeLayer();
     if (!layer) return;
 
     m_view->updateGUI();
 }
 
 void KisLayerManager::saveGroupLayers()
 {
-    QStringList listMimeFilter = KisImportExportManager::mimeFilter(KisImportExportManager::Export);
+    QStringList listMimeFilter = KisImportExportManager::supportedMimeTypes(KisImportExportManager::Export);
 
     KoDialog dlg;
     QWidget *page = new QWidget(&dlg);
     dlg.setMainWidget(page);
     QBoxLayout *layout = new QVBoxLayout(page);
 
     KisFileNameRequester *urlRequester = new KisFileNameRequester(page);
     urlRequester->setMode(KoFileDialog::SaveFile);
     if (m_view->document()->url().isLocalFile()) {
         urlRequester->setStartDir(QFileInfo(m_view->document()->url().toLocalFile()).absolutePath());
     }
     urlRequester->setMimeTypeFilters(listMimeFilter);
     urlRequester->setFileName(m_view->document()->url().toLocalFile());
     layout->addWidget(urlRequester);
 
     QCheckBox *chkInvisible = new QCheckBox(i18n("Convert Invisible Groups"), page);
     chkInvisible->setChecked(false);
     layout->addWidget(chkInvisible);
     QCheckBox *chkDepth = new QCheckBox(i18n("Export Only Toplevel Groups"), page);
     chkDepth->setChecked(true);
     layout->addWidget(chkDepth);
 
     if (!dlg.exec()) return;
 
     QString path = urlRequester->fileName();
 
     if (path.isEmpty()) return;
 
     QFileInfo f(path);
 
     QString mimeType= KisMimeDatabase::mimeTypeForFile(f.fileName(), false);
     if (mimeType.isEmpty()) {
         mimeType = "image/png";
     }
     QString extension = KisMimeDatabase::suffixesForMimeType(mimeType).first();
     QString basename = f.baseName();
 
     KisImageSP image = m_view->image();
     if (!image) return;
 
     KisSaveGroupVisitor v(image, chkInvisible->isChecked(), chkDepth->isChecked(), f.absolutePath(), basename, extension, mimeType);
     image->rootLayer()->accept(v);
 
 }
 
 bool KisLayerManager::activeLayerHasSelection()
 {
     return (activeLayer()->selection() != 0);
 }
 
 void KisLayerManager::addFileLayer(KisNodeSP activeNode)
 {
 
     QString basePath;
     QUrl url = m_view->document()->url();
     if (url.isLocalFile()) {
         basePath = QFileInfo(url.toLocalFile()).absolutePath();
     }
     KisImageWSP image = m_view->image();
 
     KisDlgFileLayer dlg(basePath, image->nextLayerName(), m_view->mainWindow());
     dlg.resize(dlg.minimumSizeHint());
 
     if (dlg.exec() == QDialog::Accepted) {
         QString name = dlg.layerName();
         QString fileName = dlg.fileName();
 
         if(fileName.isEmpty()){
             QMessageBox::critical(m_view->mainWindow(), i18nc("@title:window", "Krita"), i18n("No file name specified"));
             return;
         }
 
         KisFileLayer::ScalingMethod scalingMethod = dlg.scaleToImageResolution();
 
         addLayerCommon(activeNode,
                        new KisFileLayer(image, basePath, fileName, scalingMethod, name, OPACITY_OPAQUE_U8));
     }
 
 }
 
 void updateLayerStyles(KisLayerSP layer, KisDlgLayerStyle *dlg)
 {
     KisSetLayerStyleCommand::updateLayerStyle(layer, dlg->style()->clone());
 }
 
 void KisLayerManager::layerStyle()
 {
     KisImageWSP image = m_view->image();
     if (!image) return;
 
     KisLayerSP layer = activeLayer();
     if (!layer) return;
 
     if (!m_view->blockUntilOperationsFinished(image)) return;
 
     KisPSDLayerStyleSP oldStyle;
     if (layer->layerStyle()) {
         oldStyle = layer->layerStyle()->clone();
     }
     else {
         oldStyle = toQShared(new KisPSDLayerStyle());
     }
 
     KisDlgLayerStyle dlg(oldStyle->clone(), m_view->resourceProvider());
 
     std::function<void ()> updateCall(std::bind(updateLayerStyles, layer, &dlg));
     SignalToFunctionProxy proxy(updateCall);
     connect(&dlg, SIGNAL(configChanged()), &proxy, SLOT(start()));
 
     if (dlg.exec() == QDialog::Accepted) {
         KisPSDLayerStyleSP newStyle = dlg.style();
 
         KUndo2CommandSP command = toQShared(
             new KisSetLayerStyleCommand(layer, oldStyle, newStyle));
 
         image->postExecutionUndoAdapter()->addCommand(command);
     }
 }
 
diff --git a/libs/ui/kis_node_manager.cpp b/libs/ui/kis_node_manager.cpp
index 474fc14886..9a55a667ba 100644
--- a/libs/ui/kis_node_manager.cpp
+++ b/libs/ui/kis_node_manager.cpp
@@ -1,1493 +1,1502 @@
 /*
  *  Copyright (C) 2007 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_node_manager.h"
 
 #include <QStandardPaths>
 #include <QMessageBox>
 #include <QSignalMapper>
 #include <QApplication>
 
 #include <kactioncollection.h>
 
 #include <QKeySequence>
 
 #include <kis_icon.h>
 #include <KoSelection.h>
 #include <KoShapeManager.h>
 #include <KoShape.h>
 #include <KoShapeLayer.h>
 #include <KisImportExportManager.h>
 #include <KoFileDialog.h>
 #include <KoToolManager.h>
 #include <KoProperties.h>
 
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorModelStandardIds.h>
 
 #include <kis_types.h>
 #include <kis_node.h>
 #include <kis_selection.h>
 #include <kis_selection_mask.h>
 #include <kis_layer.h>
 #include <kis_mask.h>
 #include <kis_image.h>
 #include <kis_painter.h>
 #include <kis_paint_layer.h>
 #include <KisMimeDatabase.h>
 #include <KisReferenceImagesLayer.h>
 
 #include "KisPart.h"
 #include "canvas/kis_canvas2.h"
 #include "kis_shape_controller.h"
 #include "kis_canvas_resource_provider.h"
 #include "KisViewManager.h"
 #include "KisDocument.h"
 #include "kis_mask_manager.h"
 #include "kis_group_layer.h"
 #include "kis_layer_manager.h"
 #include "kis_selection_manager.h"
 #include "kis_node_commands_adapter.h"
 #include "kis_action.h"
 #include "kis_action_manager.h"
 #include "kis_processing_applicator.h"
 #include "kis_sequential_iterator.h"
 #include "kis_transaction.h"
 #include "kis_node_selection_adapter.h"
 #include "kis_node_insertion_adapter.h"
 #include "kis_node_juggler_compressed.h"
 #include "kis_clipboard.h"
 #include "kis_node_dummies_graph.h"
 #include "kis_mimedata.h"
 #include "kis_layer_utils.h"
 #include "krita_utils.h"
 #include "kis_shape_layer.h"
 
 #include "processing/kis_mirror_processing_visitor.h"
 #include "KisView.h"
 
 #include <kis_signals_blocker.h>
 
 struct KisNodeManager::Private {
 
     Private(KisNodeManager *_q, KisViewManager *v)
         : q(_q)
         , view(v)
         , imageView(0)
         , layerManager(v)
         , maskManager(v)
         , commandsAdapter(v)
         , nodeSelectionAdapter(new KisNodeSelectionAdapter(q))
         , nodeInsertionAdapter(new KisNodeInsertionAdapter(q))
     {
     }
 
     KisNodeManager * q;
     KisViewManager * view;
     QPointer<KisView>imageView;
     KisLayerManager layerManager;
     KisMaskManager maskManager;
     KisNodeCommandsAdapter commandsAdapter;
     QScopedPointer<KisNodeSelectionAdapter> nodeSelectionAdapter;
     QScopedPointer<KisNodeInsertionAdapter> nodeInsertionAdapter;
 
     KisAction *showInTimeline;
 
     KisNodeList selectedNodes;
     QPointer<KisNodeJugglerCompressed> nodeJuggler;
 
     KisNodeWSP previouslyActiveNode;
 
     bool activateNodeImpl(KisNodeSP node);
 
     QSignalMapper nodeCreationSignalMapper;
     QSignalMapper nodeConversionSignalMapper;
 
     void saveDeviceAsImage(KisPaintDeviceSP device,
                            const QString &defaultName,
                            const QRect &bounds,
                            qreal xRes,
                            qreal yRes,
                            quint8 opacity);
 
     void mergeTransparencyMaskAsAlpha(bool writeToLayers);
     KisNodeJugglerCompressed* lazyGetJuggler(const KUndo2MagicString &actionName);
 };
 
 bool KisNodeManager::Private::activateNodeImpl(KisNodeSP node)
 {
     Q_ASSERT(view);
     Q_ASSERT(view->canvasBase());
     Q_ASSERT(view->canvasBase()->globalShapeManager());
     Q_ASSERT(imageView);
     if (node && node == q->activeNode()) {
         return false;
     }
 
     // Set the selection on the shape manager to the active layer
     // and set call KoSelection::setActiveLayer( KoShapeLayer* layer )
     // with the parent of the active layer.
     KoSelection *selection = view->canvasBase()->globalShapeManager()->selection();
     Q_ASSERT(selection);
     selection->deselectAll();
 
     if (!node) {
         selection->setActiveLayer(0);
         imageView->setCurrentNode(0);
         maskManager.activateMask(0);
         layerManager.activateLayer(0);
         previouslyActiveNode = q->activeNode();
     } else {
 
         previouslyActiveNode = q->activeNode();
 
         KoShape * shape = view->document()->shapeForNode(node);
 
         //if (!shape) return false;
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(shape, false);
 
         selection->select(shape);
         KoShapeLayer * shapeLayer = dynamic_cast<KoShapeLayer*>(shape);
 
         //if (!shapeLayer) return false;
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(shapeLayer, false);
 
 //         shapeLayer->setGeometryProtected(node->userLocked());
 //         shapeLayer->setVisible(node->visible());
         selection->setActiveLayer(shapeLayer);
 
         imageView->setCurrentNode(node);
         if (KisLayerSP layer = qobject_cast<KisLayer*>(node.data())) {
             maskManager.activateMask(0);
             layerManager.activateLayer(layer);
         } else if (KisMaskSP mask = dynamic_cast<KisMask*>(node.data())) {
             maskManager.activateMask(mask);
             // XXX_NODE: for now, masks cannot be nested.
             layerManager.activateLayer(static_cast<KisLayer*>(node->parent().data()));
         }
 
     }
     return true;
 }
 
 KisNodeManager::KisNodeManager(KisViewManager *view)
     : m_d(new Private(this, view))
 {
 
     connect(&m_d->layerManager, SIGNAL(sigLayerActivated(KisLayerSP)), SIGNAL(sigLayerActivated(KisLayerSP)));
 }
 
 KisNodeManager::~KisNodeManager()
 {
     delete m_d;
 }
 
 void KisNodeManager::setView(QPointer<KisView>imageView)
 {
     m_d->maskManager.setView(imageView);
     m_d->layerManager.setView(imageView);
 
     if (m_d->imageView) {
         KisShapeController *shapeController = dynamic_cast<KisShapeController*>(m_d->imageView->document()->shapeController());
         Q_ASSERT(shapeController);
         shapeController->disconnect(SIGNAL(sigActivateNode(KisNodeSP)), this);
         m_d->imageView->image()->disconnect(this);
     }
 
     m_d->imageView = imageView;
 
     if (m_d->imageView) {
         KisShapeController *shapeController = dynamic_cast<KisShapeController*>(m_d->imageView->document()->shapeController());
         Q_ASSERT(shapeController);
         connect(shapeController, SIGNAL(sigActivateNode(KisNodeSP)), SLOT(slotNonUiActivatedNode(KisNodeSP)));
         connect(m_d->imageView->image(), SIGNAL(sigIsolatedModeChanged()),this, SLOT(slotUpdateIsolateModeAction()));
         connect(m_d->imageView->image(), SIGNAL(sigRequestNodeReselection(KisNodeSP, const KisNodeList&)),this, SLOT(slotImageRequestNodeReselection(KisNodeSP, const KisNodeList&)));
         m_d->imageView->resourceProvider()->slotNodeActivated(m_d->imageView->currentNode());
     }
 
 }
 
 #define NEW_LAYER_ACTION(id, layerType)                                 \
     {                                                                   \
         action = actionManager->createAction(id);                       \
         m_d->nodeCreationSignalMapper.setMapping(action, layerType);    \
         connect(action, SIGNAL(triggered()),                            \
                 &m_d->nodeCreationSignalMapper, SLOT(map()));           \
     }
 
 #define CONVERT_NODE_ACTION_2(id, layerType, exclude)                   \
     {                                                                   \
         action = actionManager->createAction(id);                       \
         action->setExcludedNodeTypes(QStringList(exclude));             \
         actionManager->addAction(id, action);                           \
         m_d->nodeConversionSignalMapper.setMapping(action, layerType);  \
         connect(action, SIGNAL(triggered()),                            \
                 &m_d->nodeConversionSignalMapper, SLOT(map()));         \
     }
 
 #define CONVERT_NODE_ACTION(id, layerType)              \
     CONVERT_NODE_ACTION_2(id, layerType, layerType)
 
 void KisNodeManager::setup(KActionCollection * actionCollection, KisActionManager* actionManager)
 {
     m_d->layerManager.setup(actionManager);
     m_d->maskManager.setup(actionCollection, actionManager);
 
     KisAction * action  = actionManager->createAction("mirrorNodeX");
     connect(action, SIGNAL(triggered()), this, SLOT(mirrorNodeX()));
 
     action  = actionManager->createAction("mirrorNodeY");
     connect(action, SIGNAL(triggered()), this, SLOT(mirrorNodeY()));
 
     action = actionManager->createAction("activateNextLayer");
     connect(action, SIGNAL(triggered()), this, SLOT(activateNextNode()));
 
     action = actionManager->createAction("activatePreviousLayer");
     connect(action, SIGNAL(triggered()), this, SLOT(activatePreviousNode()));
 
     action = actionManager->createAction("switchToPreviouslyActiveNode");
     connect(action, SIGNAL(triggered()), this, SLOT(switchToPreviouslyActiveNode()));
 
     action  = actionManager->createAction("save_node_as_image");
     connect(action, SIGNAL(triggered()), this, SLOT(saveNodeAsImage()));
 
     action  = actionManager->createAction("save_vector_node_to_svg");
     connect(action, SIGNAL(triggered()), this, SLOT(saveVectorLayerAsImage()));
     action->setActivationFlags(KisAction::ACTIVE_SHAPE_LAYER);
 
     action = actionManager->createAction("duplicatelayer");
     connect(action, SIGNAL(triggered()), this, SLOT(duplicateActiveNode()));
 
     action = actionManager->createAction("copy_layer_clipboard");
     connect(action, SIGNAL(triggered()), this, SLOT(copyLayersToClipboard()));
 
     action = actionManager->createAction("cut_layer_clipboard");
     connect(action, SIGNAL(triggered()), this, SLOT(cutLayersToClipboard()));
 
     action = actionManager->createAction("paste_layer_from_clipboard");
     connect(action, SIGNAL(triggered()), this, SLOT(pasteLayersFromClipboard()));
 
     action = actionManager->createAction("create_quick_group");
     connect(action, SIGNAL(triggered()), this, SLOT(createQuickGroup()));
 
     action = actionManager->createAction("create_quick_clipping_group");
     connect(action, SIGNAL(triggered()), this, SLOT(createQuickClippingGroup()));
 
     action = actionManager->createAction("quick_ungroup");
     connect(action, SIGNAL(triggered()), this, SLOT(quickUngroup()));
 
     action = actionManager->createAction("select_all_layers");
     connect(action, SIGNAL(triggered()), this, SLOT(selectAllNodes()));
 
     action = actionManager->createAction("select_visible_layers");
     connect(action, SIGNAL(triggered()), this, SLOT(selectVisibleNodes()));
 
     action = actionManager->createAction("select_locked_layers");
     connect(action, SIGNAL(triggered()), this, SLOT(selectLockedNodes()));
 
     action = actionManager->createAction("select_invisible_layers");
     connect(action, SIGNAL(triggered()), this, SLOT(selectInvisibleNodes()));
 
     action = actionManager->createAction("select_unlocked_layers");
     connect(action, SIGNAL(triggered()), this, SLOT(selectUnlockedNodes()));
 
     action = actionManager->createAction("new_from_visible");
     connect(action, SIGNAL(triggered()), this, SLOT(createFromVisible()));
 
     action = actionManager->createAction("show_in_timeline");
     action->setCheckable(true);
     connect(action, SIGNAL(toggled(bool)), this, SLOT(slotShowHideTimeline(bool)));
     m_d->showInTimeline = action;
 
     NEW_LAYER_ACTION("add_new_paint_layer", "KisPaintLayer");
 
     NEW_LAYER_ACTION("add_new_group_layer", "KisGroupLayer");
 
     NEW_LAYER_ACTION("add_new_clone_layer", "KisCloneLayer");
 
     NEW_LAYER_ACTION("add_new_shape_layer", "KisShapeLayer");
 
     NEW_LAYER_ACTION("add_new_adjustment_layer", "KisAdjustmentLayer");
 
     NEW_LAYER_ACTION("add_new_fill_layer", "KisGeneratorLayer");
 
     NEW_LAYER_ACTION("add_new_file_layer", "KisFileLayer");
 
     NEW_LAYER_ACTION("add_new_transparency_mask", "KisTransparencyMask");
 
     NEW_LAYER_ACTION("add_new_filter_mask", "KisFilterMask");
 
     NEW_LAYER_ACTION("add_new_colorize_mask", "KisColorizeMask");
 
     NEW_LAYER_ACTION("add_new_transform_mask", "KisTransformMask");
 
     NEW_LAYER_ACTION("add_new_selection_mask", "KisSelectionMask");
 
     connect(&m_d->nodeCreationSignalMapper, SIGNAL(mapped(const QString &)),
             this, SLOT(createNode(const QString &)));
 
     CONVERT_NODE_ACTION("convert_to_paint_layer", "KisPaintLayer");
 
     CONVERT_NODE_ACTION_2("convert_to_selection_mask", "KisSelectionMask", QStringList() << "KisSelectionMask" << "KisColorizeMask");
 
     CONVERT_NODE_ACTION_2("convert_to_filter_mask", "KisFilterMask", QStringList() << "KisFilterMask" << "KisColorizeMask");
 
     CONVERT_NODE_ACTION_2("convert_to_transparency_mask", "KisTransparencyMask", QStringList() << "KisTransparencyMask" << "KisColorizeMask");
 
     CONVERT_NODE_ACTION("convert_to_animated", "animated");
 
     CONVERT_NODE_ACTION_2("convert_layer_to_file_layer", "KisFileLayer", QStringList()<< "KisFileLayer" << "KisCloneLayer");
 
     connect(&m_d->nodeConversionSignalMapper, SIGNAL(mapped(const QString &)),
             this, SLOT(convertNode(const QString &)));
 
     action = actionManager->createAction("isolate_layer");
     connect(action, SIGNAL(triggered(bool)), this, SLOT(toggleIsolateMode(bool)));
 
     action = actionManager->createAction("toggle_layer_visibility");
     connect(action, SIGNAL(triggered()), this, SLOT(toggleVisibility()));
 
     action = actionManager->createAction("toggle_layer_lock");
     connect(action, SIGNAL(triggered()), this, SLOT(toggleLock()));
 
     action = actionManager->createAction("toggle_layer_inherit_alpha");
     connect(action, SIGNAL(triggered()), this, SLOT(toggleInheritAlpha()));
 
     action = actionManager->createAction("toggle_layer_alpha_lock");
     connect(action, SIGNAL(triggered()), this, SLOT(toggleAlphaLock()));
 
     action  = actionManager->createAction("split_alpha_into_mask");
     connect(action, SIGNAL(triggered()), this, SLOT(slotSplitAlphaIntoMask()));
 
     action  = actionManager->createAction("split_alpha_write");
     connect(action, SIGNAL(triggered()), this, SLOT(slotSplitAlphaWrite()));
 
     // HINT: we can save even when the nodes are not editable
     action  = actionManager->createAction("split_alpha_save_merged");
     connect(action, SIGNAL(triggered()), this, SLOT(slotSplitAlphaSaveMerged()));
 
     connect(this, SIGNAL(sigNodeActivated(KisNodeSP)), SLOT(slotUpdateIsolateModeAction()));
     connect(this, SIGNAL(sigNodeActivated(KisNodeSP)), SLOT(slotTryFinishIsolatedMode()));
 }
 
 void KisNodeManager::updateGUI()
 {
     // enable/disable all relevant actions
     m_d->layerManager.updateGUI();
     m_d->maskManager.updateGUI();
 }
 
 KisNodeSP KisNodeManager::activeNode()
 {
     if (m_d->imageView) {
         return m_d->imageView->currentNode();
     }
     return 0;
 }
 
 KisLayerSP KisNodeManager::activeLayer()
 {
     return m_d->layerManager.activeLayer();
 }
 
 const KoColorSpace* KisNodeManager::activeColorSpace()
 {
     if (m_d->maskManager.activeDevice()) {
         return m_d->maskManager.activeDevice()->colorSpace();
     } else {
         Q_ASSERT(m_d->layerManager.activeLayer());
         if (m_d->layerManager.activeLayer()->parentLayer())
             return m_d->layerManager.activeLayer()->parentLayer()->colorSpace();
         else
             return m_d->view->image()->colorSpace();
     }
 }
 
 void KisNodeManager::moveNodeAt(KisNodeSP node, KisNodeSP parent, int index)
 {
     if (parent->allowAsChild(node)) {
         if (node->inherits("KisSelectionMask") && parent->inherits("KisLayer")) {
             KisSelectionMask *m = dynamic_cast<KisSelectionMask*>(node.data());
             KisLayer *l = qobject_cast<KisLayer*>(parent.data());
             if (m && m->active() && l && l->selectionMask()) {
                 l->selectionMask()->setActive(false);
             }
         }
         m_d->commandsAdapter.moveNode(node, parent, index);
     }
 }
 
 void KisNodeManager::moveNodesDirect(KisNodeList nodes, KisNodeSP parent, KisNodeSP aboveThis)
 {
     KUndo2MagicString actionName = kundo2_i18n("Move Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->moveNode(nodes, parent, aboveThis);
 }
 
 void KisNodeManager::copyNodesDirect(KisNodeList nodes, KisNodeSP parent, KisNodeSP aboveThis)
 {
     KUndo2MagicString actionName = kundo2_i18n("Copy Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->copyNode(nodes, parent, aboveThis);
 }
 
 void KisNodeManager::addNodesDirect(KisNodeList nodes, KisNodeSP parent, KisNodeSP aboveThis)
 {
     KUndo2MagicString actionName = kundo2_i18n("Add Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->addNode(nodes, parent, aboveThis);
 }
 
 void KisNodeManager::toggleIsolateActiveNode()
 {
     KisImageWSP image = m_d->view->image();
     KisNodeSP activeNode = this->activeNode();
     KIS_ASSERT_RECOVER_RETURN(activeNode);
 
     if (activeNode == image->isolatedModeRoot()) {
         toggleIsolateMode(false);
     } else {
         toggleIsolateMode(true);
     }
 }
 
 void KisNodeManager::toggleIsolateMode(bool checked)
 {
     KisImageWSP image = m_d->view->image();
 
     if (checked) {
         KisNodeSP activeNode = this->activeNode();
         // Transform and colorize masks don't have pixel data...
         if (activeNode->inherits("KisTransformMask") ||
             activeNode->inherits("KisColorizeMask")) return;
 
         KIS_ASSERT_RECOVER_RETURN(activeNode);
         if (!image->startIsolatedMode(activeNode)) {
             KisAction *action = m_d->view->actionManager()->actionByName("isolate_layer");
             action->setChecked(false);
         }
     } else {
         image->stopIsolatedMode();
     }
 }
 
 void KisNodeManager::slotUpdateIsolateModeAction()
 {
     KisAction *action = m_d->view->actionManager()->actionByName("isolate_layer");
     Q_ASSERT(action);
 
     KisNodeSP activeNode = this->activeNode();
     KisNodeSP isolatedRootNode = m_d->view->image()->isolatedModeRoot();
 
     action->setChecked(isolatedRootNode && isolatedRootNode == activeNode);
 }
 
 void KisNodeManager::slotTryFinishIsolatedMode()
 {
     KisNodeSP isolatedRootNode = m_d->view->image()->isolatedModeRoot();
     if (!isolatedRootNode) return;
 
     this->toggleIsolateMode(true);
 }
 
 void KisNodeManager::createNode(const QString & nodeType, bool quiet, KisPaintDeviceSP copyFrom)
 {
     if (!m_d->view->blockUntilOperationsFinished(m_d->view->image())) {
         return;
     }
 
     KisNodeSP activeNode = this->activeNode();
     if (!activeNode) {
         activeNode = m_d->view->image()->root();
     }
 
     KIS_ASSERT_RECOVER_RETURN(activeNode);
 
     // XXX: make factories for this kind of stuff,
     //      with a registry
 
     if (nodeType == "KisPaintLayer") {
         m_d->layerManager.addLayer(activeNode);
     } else if (nodeType == "KisGroupLayer") {
         m_d->layerManager.addGroupLayer(activeNode);
     } else if (nodeType == "KisAdjustmentLayer") {
         m_d->layerManager.addAdjustmentLayer(activeNode);
     } else if (nodeType == "KisGeneratorLayer") {
         m_d->layerManager.addGeneratorLayer(activeNode);
     } else if (nodeType == "KisShapeLayer") {
         m_d->layerManager.addShapeLayer(activeNode);
     } else if (nodeType == "KisCloneLayer") {
         m_d->layerManager.addCloneLayer(activeNode);
     } else if (nodeType == "KisTransparencyMask") {
         m_d->maskManager.createTransparencyMask(activeNode, copyFrom, false);
     } else if (nodeType == "KisFilterMask") {
         m_d->maskManager.createFilterMask(activeNode, copyFrom, quiet, false);
     } else if (nodeType == "KisColorizeMask") {
         m_d->maskManager.createColorizeMask(activeNode);
     } else if (nodeType == "KisTransformMask") {
         m_d->maskManager.createTransformMask(activeNode);
     } else if (nodeType == "KisSelectionMask") {
         m_d->maskManager.createSelectionMask(activeNode, copyFrom, false);
     } else if (nodeType == "KisFileLayer") {
         m_d->layerManager.addFileLayer(activeNode);
     }
 }
 
 void KisNodeManager::createFromVisible()
 {
     KisLayerUtils::newLayerFromVisible(m_d->view->image(), m_d->view->image()->root()->lastChild());
 }
 
 void KisNodeManager::slotShowHideTimeline(bool value)
 {
     Q_FOREACH (KisNodeSP node, selectedNodes()) {
         node->setUseInTimeline(value);
     }
 }
 
 KisLayerSP KisNodeManager::createPaintLayer()
 {
     KisNodeSP activeNode = this->activeNode();
     if (!activeNode) {
         activeNode = m_d->view->image()->root();
     }
 
     return m_d->layerManager.addLayer(activeNode);
 }
 
 void KisNodeManager::convertNode(const QString &nodeType)
 {
     KisNodeSP activeNode = this->activeNode();
     if (!activeNode) return;
 
     if (nodeType == "KisPaintLayer") {
         m_d->layerManager.convertNodeToPaintLayer(activeNode);
     } else if (nodeType == "KisSelectionMask" ||
                nodeType == "KisFilterMask" ||
                nodeType == "KisTransparencyMask") {
 
         KisPaintDeviceSP copyFrom = activeNode->paintDevice() ?
             activeNode->paintDevice() : activeNode->projection();
 
         m_d->commandsAdapter.beginMacro(kundo2_i18n("Convert to a Selection Mask"));
 
         if (nodeType == "KisSelectionMask") {
             m_d->maskManager.createSelectionMask(activeNode, copyFrom, true);
         } else if (nodeType == "KisFilterMask") {
             m_d->maskManager.createFilterMask(activeNode, copyFrom, false, true);
         } else if (nodeType == "KisTransparencyMask") {
             m_d->maskManager.createTransparencyMask(activeNode, copyFrom, true);
         }
 
         m_d->commandsAdapter.removeNode(activeNode);
         m_d->commandsAdapter.endMacro();
     } else if (nodeType == "KisFileLayer") {
             m_d->layerManager.convertLayerToFileLayer(activeNode);
     } else {
         warnKrita << "Unsupported node conversion type:" << nodeType;
     }
 }
 
 void KisNodeManager::slotSomethingActivatedNodeImpl(KisNodeSP node)
 {
     KIS_ASSERT_RECOVER_RETURN(node != activeNode());
     if (m_d->activateNodeImpl(node)) {
         emit sigUiNeedChangeActiveNode(node);
         emit sigNodeActivated(node);
         nodesUpdated();
         if (node) {
             bool toggled =  m_d->view->actionCollection()->action("view_show_canvas_only")->isChecked();
             if (toggled) {
                 m_d->view->showFloatingMessage( activeLayer()->name(), QIcon(), 1600, KisFloatingMessage::Medium, Qt::TextSingleLine);
             }
         }
     }
 }
 
 void KisNodeManager::slotNonUiActivatedNode(KisNodeSP node)
 {
     if (node == activeNode()) return;
+
+    // the node must still be in the graph, some asynchronous
+    // signals may easily break this requirement
+    KIS_SAFE_ASSERT_RECOVER_RETURN(node->graphListener());
+
     slotSomethingActivatedNodeImpl(node);
 
     if (node) {
         bool toggled =  m_d->view->actionCollection()->action("view_show_canvas_only")->isChecked();
         if (toggled) {
             m_d->view->showFloatingMessage( activeLayer()->name(), QIcon(), 1600, KisFloatingMessage::Medium, Qt::TextSingleLine);
         }
     }
 }
 
 void KisNodeManager::slotUiActivatedNode(KisNodeSP node)
 {
     if (node == activeNode()) return;
 
+    // the node must still be in the graph, some asynchronous
+    // signals may easily break this requirement
+    KIS_SAFE_ASSERT_RECOVER_RETURN(node->graphListener());
+
     slotSomethingActivatedNodeImpl(node);
 
     if (node) {
         QStringList vectorTools = QStringList()
                 << "InteractionTool"
                 << "KarbonPatternTool"
                 << "KarbonGradientTool"
                 << "KarbonCalligraphyTool"
                 << "CreateShapesTool"
                 << "PathTool";
 
         QStringList pixelTools = QStringList()
                 << "KritaShape/KisToolBrush"
                 << "KritaShape/KisToolDyna"
                 << "KritaShape/KisToolMultiBrush"
                 << "KritaFill/KisToolFill"
                 << "KritaFill/KisToolGradient";
 
         if (node->inherits("KisShapeLayer")) {
             if (pixelTools.contains(KoToolManager::instance()->activeToolId())) {
                 KoToolManager::instance()->switchToolRequested("InteractionTool");
             }
         }
         else {
             if (vectorTools.contains(KoToolManager::instance()->activeToolId())) {
                 KoToolManager::instance()->switchToolRequested("KritaShape/KisToolBrush");
             }
         }
     }
 }
 
 void KisNodeManager::nodesUpdated()
 {
     KisNodeSP node = activeNode();
     if (!node) return;
 
     m_d->layerManager.layersUpdated();
     m_d->maskManager.masksUpdated();
 
     m_d->view->updateGUI();
     m_d->view->selectionManager()->selectionChanged();
 
     {
         KisSignalsBlocker b(m_d->showInTimeline);
         m_d->showInTimeline->setChecked(node->useInTimeline());
     }
 }
 
 KisPaintDeviceSP KisNodeManager::activePaintDevice()
 {
     return m_d->maskManager.activeMask() ?
         m_d->maskManager.activeDevice() :
         m_d->layerManager.activeDevice();
 }
 
 void KisNodeManager::nodeProperties(KisNodeSP node)
 {
     if ((selectedNodes().size() > 1 && node->inherits("KisLayer")) || node->inherits("KisLayer")) {
         m_d->layerManager.layerProperties();
     }
     else if (node->inherits("KisMask")) {
         m_d->maskManager.maskProperties();
     }
 }
 
 qint32 KisNodeManager::convertOpacityToInt(qreal opacity)
 {
     /**
      * Scales opacity from the range 0...100
      * to the integer range 0...255
      */
 
     return qMin(255, int(opacity * 2.55 + 0.5));
 }
 
 void KisNodeManager::setNodeOpacity(KisNodeSP node, qint32 opacity,
                                     bool finalChange)
 {
     if (!node) return;
     if (node->opacity() == opacity) return;
 
     if (!finalChange) {
         node->setOpacity(opacity);
         node->setDirty();
     } else {
         m_d->commandsAdapter.setOpacity(node, opacity);
     }
 }
 
 void KisNodeManager::setNodeCompositeOp(KisNodeSP node,
                                         const KoCompositeOp* compositeOp)
 {
     if (!node) return;
     if (node->compositeOp() == compositeOp) return;
 
     m_d->commandsAdapter.setCompositeOp(node, compositeOp);
 }
 
 void KisNodeManager::slotImageRequestNodeReselection(KisNodeSP activeNode, const KisNodeList &selectedNodes)
 {
     if (activeNode) {
         slotNonUiActivatedNode(activeNode);
     }
     if (!selectedNodes.isEmpty()) {
         slotSetSelectedNodes(selectedNodes);
     }
 }
 
 void KisNodeManager::slotSetSelectedNodes(const KisNodeList &nodes)
 {
     m_d->selectedNodes = nodes;
     emit sigUiNeedChangeSelectedNodes(nodes);
 }
 
 KisNodeList KisNodeManager::selectedNodes()
 {
     return m_d->selectedNodes;
 }
 
 KisNodeSelectionAdapter* KisNodeManager::nodeSelectionAdapter() const
 {
     return m_d->nodeSelectionAdapter.data();
 }
 
 KisNodeInsertionAdapter* KisNodeManager::nodeInsertionAdapter() const
 {
     return m_d->nodeInsertionAdapter.data();
 }
 
 bool KisNodeManager::isNodeHidden(KisNodeSP node, bool isGlobalSelectionHidden)
 {
     if (dynamic_cast<KisReferenceImagesLayer *>(node.data())) {
         return true;
     }
 
     if (isGlobalSelectionHidden && dynamic_cast<KisSelectionMask *>(node.data()) &&
         (!node->parent() || !node->parent()->parent())) {
         return true;
     }
 
     return false;
 }
 
 void KisNodeManager::nodeOpacityChanged(qreal opacity, bool finalChange)
 {
     KisNodeSP node = activeNode();
 
     setNodeOpacity(node, convertOpacityToInt(opacity), finalChange);
 }
 
 void KisNodeManager::nodeCompositeOpChanged(const KoCompositeOp* op)
 {
     KisNodeSP node = activeNode();
 
     setNodeCompositeOp(node, op);
 }
 
 void KisNodeManager::duplicateActiveNode()
 {
     KUndo2MagicString actionName = kundo2_i18n("Duplicate Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->duplicateNode(selectedNodes());
 }
 
 KisNodeJugglerCompressed* KisNodeManager::Private::lazyGetJuggler(const KUndo2MagicString &actionName)
 {
     KisImageWSP image = view->image();
 
     if (!nodeJuggler ||
         (nodeJuggler &&
          (nodeJuggler->isEnded() ||
           !nodeJuggler->canMergeAction(actionName)))) {
 
         nodeJuggler = new KisNodeJugglerCompressed(actionName, image, q, 750);
         nodeJuggler->setAutoDelete(true);
     }
 
     return nodeJuggler;
 }
 
 void KisNodeManager::raiseNode()
 {
     KUndo2MagicString actionName = kundo2_i18n("Raise Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->raiseNode(selectedNodes());
 }
 
 void KisNodeManager::lowerNode()
 {
     KUndo2MagicString actionName = kundo2_i18n("Lower Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->lowerNode(selectedNodes());
 }
 
 void KisNodeManager::removeSingleNode(KisNodeSP node)
 {
     if (!node || !node->parent()) {
         return;
     }
 
     KisNodeList nodes;
     nodes << node;
     removeSelectedNodes(nodes);
 }
 
 void KisNodeManager::removeSelectedNodes(KisNodeList nodes)
 {
     KUndo2MagicString actionName = kundo2_i18n("Remove Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->removeNode(nodes);
 }
 
 void KisNodeManager::removeNode()
 {
     removeSelectedNodes(selectedNodes());
 }
 
 void KisNodeManager::mirrorNodeX()
 {
     KisNodeSP node = activeNode();
 
     KUndo2MagicString commandName;
     if (node->inherits("KisLayer")) {
         commandName = kundo2_i18n("Mirror Layer X");
     } else if (node->inherits("KisMask")) {
         commandName = kundo2_i18n("Mirror Mask X");
     }
     mirrorNode(node, commandName, Qt::Horizontal);
 }
 
 void KisNodeManager::mirrorNodeY()
 {
     KisNodeSP node = activeNode();
 
     KUndo2MagicString commandName;
     if (node->inherits("KisLayer")) {
         commandName = kundo2_i18n("Mirror Layer Y");
     } else if (node->inherits("KisMask")) {
         commandName = kundo2_i18n("Mirror Mask Y");
     }
     mirrorNode(node, commandName, Qt::Vertical);
 }
 
 void KisNodeManager::activateNextNode()
 {
     KisNodeSP activeNode = this->activeNode();
     if (!activeNode) return;
 
     KisNodeSP node = activeNode->nextSibling();
 
     while (node && node->childCount() > 0) {
            node = node->firstChild();
     }
 
     if (!node && activeNode->parent() && activeNode->parent()->parent()) {
         node = activeNode->parent();
     }
 
     while(node && isNodeHidden(node, true)) {
         node = node->nextSibling();
     }
 
     if (node) {
         slotNonUiActivatedNode(node);
     }
 }
 
 void KisNodeManager::activatePreviousNode()
 {
     KisNodeSP activeNode = this->activeNode();
     if (!activeNode) return;
 
     KisNodeSP node;
 
     if (activeNode->childCount() > 0) {
         node = activeNode->lastChild();
     }
     else {
         node = activeNode->prevSibling();
     }
 
     while (!node && activeNode->parent()) {
         node = activeNode->parent()->prevSibling();
         activeNode = activeNode->parent();
     }
 
     while(node && isNodeHidden(node, true)) {
         node = node->prevSibling();
     }
 
     if (node) {
         slotNonUiActivatedNode(node);
     }
 }
 
 void KisNodeManager::switchToPreviouslyActiveNode()
 {
     if (m_d->previouslyActiveNode && m_d->previouslyActiveNode->parent()) {
         slotNonUiActivatedNode(m_d->previouslyActiveNode);
     }
 }
 
 void KisNodeManager::rotate(double radians)
 {
     if(!m_d->view->image()) return;
 
     KisNodeSP node = activeNode();
     if (!node) return;
 
     if (!m_d->view->blockUntilOperationsFinished(m_d->view->image())) return;
 
     m_d->view->image()->rotateNode(node, radians);
 }
 
 void KisNodeManager::rotate180()
 {
     rotate(M_PI);
 }
 
 void KisNodeManager::rotateLeft90()
 {
    rotate(-M_PI / 2);
 }
 
 void KisNodeManager::rotateRight90()
 {
     rotate(M_PI / 2);
 }
 
 void KisNodeManager::shear(double angleX, double angleY)
 {
     if (!m_d->view->image()) return;
 
     KisNodeSP node = activeNode();
     if (!node) return;
 
     if(!m_d->view->blockUntilOperationsFinished(m_d->view->image())) return;
 
     m_d->view->image()->shearNode(node, angleX, angleY);
 }
 
 void KisNodeManager::scale(double sx, double sy, KisFilterStrategy *filterStrategy)
 {
     KisNodeSP node = activeNode();
     KIS_ASSERT_RECOVER_RETURN(node);
 
     m_d->view->image()->scaleNode(node, sx, sy, filterStrategy);
 
     nodesUpdated();
 }
 
 void KisNodeManager::mirrorNode(KisNodeSP node, const KUndo2MagicString& actionName, Qt::Orientation orientation)
 {
     KisImageSignalVector emitSignals;
     emitSignals << ModifiedSignal;
 
     KisProcessingApplicator applicator(m_d->view->image(), node,
                                        KisProcessingApplicator::RECURSIVE,
                                        emitSignals, actionName);
 
     KisProcessingVisitorSP visitor =
         new KisMirrorProcessingVisitor(m_d->view->image()->bounds(), orientation);
 
     applicator.applyVisitor(visitor, KisStrokeJobData::CONCURRENT);
     applicator.end();
 
     nodesUpdated();
 }
 
 void KisNodeManager::Private::saveDeviceAsImage(KisPaintDeviceSP device,
                                                 const QString &defaultName,
                                                 const QRect &bounds,
                                                 qreal xRes,
                                                 qreal yRes,
                                                 quint8 opacity)
 {
     KoFileDialog dialog(view->mainWindow(), KoFileDialog::SaveFile, "savenodeasimage");
     dialog.setCaption(i18n("Export \"%1\"", defaultName));
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
-    dialog.setMimeTypeFilters(KisImportExportManager::mimeFilter(KisImportExportManager::Export));
+    dialog.setMimeTypeFilters(KisImportExportManager::supportedMimeTypes(KisImportExportManager::Export));
     QString filename = dialog.filename();
 
     if (filename.isEmpty()) return;
 
     QUrl url = QUrl::fromLocalFile(filename);
 
     if (url.isEmpty()) return;
 
     QString mimefilter = KisMimeDatabase::mimeTypeForFile(filename, false);
 
     QScopedPointer<KisDocument> doc(KisPart::instance()->createDocument());
 
     KisImageSP dst = new KisImage(doc->createUndoStore(),
                                   bounds.width(),
                                   bounds.height(),
                                   device->compositionSourceColorSpace(),
                                   defaultName);
     dst->setResolution(xRes, yRes);
     doc->setCurrentImage(dst);
     KisPaintLayer* paintLayer = new KisPaintLayer(dst, "paint device", opacity);
     paintLayer->paintDevice()->makeCloneFrom(device, bounds);
     dst->addNode(paintLayer, dst->rootLayer(), KisLayerSP(0));
 
     dst->initialRefreshGraph();
 
     doc->exportDocumentSync(url, mimefilter.toLatin1());
 }
 
 void KisNodeManager::saveNodeAsImage()
 {
     KisNodeSP node = activeNode();
 
     if (!node) {
         warnKrita << "BUG: Save Node As Image was called without any node selected";
         return;
     }
 
     KisImageWSP image = m_d->view->image();
     QRect saveRect = image->bounds() | node->exactBounds();
 
     KisPaintDeviceSP device = node->paintDevice();
     if (!device) {
         device = node->projection();
     }
 
     m_d->saveDeviceAsImage(device, node->name(),
                            saveRect,
                            image->xRes(), image->yRes(),
                            node->opacity());
 }
 
 #include "SvgWriter.h"
 
 void KisNodeManager::saveVectorLayerAsImage()
 {
     KisShapeLayerSP shapeLayer = qobject_cast<KisShapeLayer*>(activeNode().data());
     if (!shapeLayer) {
         return;
     }
 
     KoFileDialog dialog(m_d->view->mainWindow(), KoFileDialog::SaveFile, "savenodeasimage");
     dialog.setCaption(i18nc("@title:window", "Export to SVG"));
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
     dialog.setMimeTypeFilters(QStringList() << "image/svg+xml", "image/svg+xml");
     QString filename = dialog.filename();
 
     if (filename.isEmpty()) return;
 
     QUrl url = QUrl::fromLocalFile(filename);
 
     if (url.isEmpty()) return;
 
     const QSizeF sizeInPx = m_d->view->image()->bounds().size();
     const QSizeF sizeInPt(sizeInPx.width() / m_d->view->image()->xRes(),
                           sizeInPx.height() / m_d->view->image()->yRes());
 
     QList<KoShape*> shapes = shapeLayer->shapes();
     std::sort(shapes.begin(), shapes.end(), KoShape::compareShapeZIndex);
 
     SvgWriter writer(shapes);
     if (!writer.save(filename, sizeInPt, true)) {
         QMessageBox::warning(qApp->activeWindow(), i18nc("@title:window", "Krita"), i18n("Could not save to svg: %1").arg(filename));
     }
 }
 
 void KisNodeManager::slotSplitAlphaIntoMask()
 {
     KisNodeSP node = activeNode();
 
     // guaranteed by KisActionManager
     KIS_ASSERT_RECOVER_RETURN(node->hasEditablePaintDevice());
 
     KisPaintDeviceSP srcDevice = node->paintDevice();
     const KoColorSpace *srcCS = srcDevice->colorSpace();
     const QRect processRect =
         srcDevice->exactBounds() |
         srcDevice->defaultBounds()->bounds();
 
     KisPaintDeviceSP selectionDevice =
         new KisPaintDevice(KoColorSpaceRegistry::instance()->alpha8());
 
     m_d->commandsAdapter.beginMacro(kundo2_i18n("Split Alpha into a Mask"));
     KisTransaction transaction(kundo2_noi18n("__split_alpha_channel__"), srcDevice);
 
     KisSequentialIterator srcIt(srcDevice, processRect);
     KisSequentialIterator dstIt(selectionDevice, processRect);
 
     while (srcIt.nextPixel() && dstIt.nextPixel()) {
         quint8 *srcPtr = srcIt.rawData();
         quint8 *alpha8Ptr = dstIt.rawData();
 
         *alpha8Ptr = srcCS->opacityU8(srcPtr);
         srcCS->setOpacity(srcPtr, OPACITY_OPAQUE_U8, 1);
     }
 
     m_d->commandsAdapter.addExtraCommand(transaction.endAndTake());
 
     createNode("KisTransparencyMask", false, selectionDevice);
     m_d->commandsAdapter.endMacro();
 }
 
 void KisNodeManager::Private::mergeTransparencyMaskAsAlpha(bool writeToLayers)
 {
     KisNodeSP node = q->activeNode();
     KisNodeSP parentNode = node->parent();
 
     // guaranteed by KisActionManager
     KIS_ASSERT_RECOVER_RETURN(node->inherits("KisTransparencyMask"));
 
     if (writeToLayers && !parentNode->hasEditablePaintDevice()) {
         QMessageBox::information(view->mainWindow(),
                                  i18nc("@title:window", "Layer %1 is not editable").arg(parentNode->name()),
                                  i18n("Cannot write alpha channel of "
                                       "the parent layer \"%1\".\n"
                                       "The operation will be cancelled.").arg(parentNode->name()));
         return;
     }
 
     KisPaintDeviceSP dstDevice;
     if (writeToLayers) {
         KIS_ASSERT_RECOVER_RETURN(parentNode->paintDevice());
         dstDevice = parentNode->paintDevice();
     } else {
         KisPaintDeviceSP copyDevice = parentNode->paintDevice();
         if (!copyDevice) {
             copyDevice = parentNode->original();
         }
         dstDevice = new KisPaintDevice(*copyDevice);
     }
 
     const KoColorSpace *dstCS = dstDevice->colorSpace();
 
     KisPaintDeviceSP selectionDevice = node->paintDevice();
     KIS_ASSERT_RECOVER_RETURN(selectionDevice->colorSpace()->pixelSize() == 1);
 
     const QRect processRect =
         selectionDevice->exactBounds() |
         dstDevice->exactBounds() |
         selectionDevice->defaultBounds()->bounds();
 
     QScopedPointer<KisTransaction> transaction;
 
     if (writeToLayers) {
         commandsAdapter.beginMacro(kundo2_i18n("Write Alpha into a Layer"));
         transaction.reset(new KisTransaction(kundo2_noi18n("__write_alpha_channel__"), dstDevice));
     }
 
     KisSequentialIterator srcIt(selectionDevice, processRect);
     KisSequentialIterator dstIt(dstDevice, processRect);
 
     while (srcIt.nextPixel() && dstIt.nextPixel()) {
         quint8 *alpha8Ptr = srcIt.rawData();
         quint8 *dstPtr = dstIt.rawData();
 
         dstCS->setOpacity(dstPtr, *alpha8Ptr, 1);
     }
 
     if (writeToLayers) {
         commandsAdapter.addExtraCommand(transaction->endAndTake());
         commandsAdapter.removeNode(node);
         commandsAdapter.endMacro();
     } else {
         KisImageWSP image = view->image();
         QRect saveRect = image->bounds();
 
         saveDeviceAsImage(dstDevice, parentNode->name(),
                           saveRect,
                           image->xRes(), image->yRes(),
                           OPACITY_OPAQUE_U8);
     }
 }
 
 
 void KisNodeManager::slotSplitAlphaWrite()
 {
     m_d->mergeTransparencyMaskAsAlpha(true);
 }
 
 void KisNodeManager::slotSplitAlphaSaveMerged()
 {
     m_d->mergeTransparencyMaskAsAlpha(false);
 }
 
 void KisNodeManager::toggleLock()
 {
     KisNodeList nodes = this->selectedNodes();
     KisNodeSP active = activeNode();
     if (nodes.isEmpty() || !active) return;
 
     bool isLocked = active->userLocked();
 
     for (auto &node : nodes) {
         node->setUserLocked(!isLocked);
     }
 }
 
 void KisNodeManager::toggleVisibility()
 {
     KisNodeList nodes = this->selectedNodes();
     KisNodeSP active = activeNode();
     if (nodes.isEmpty() || !active) return;
 
     bool isVisible = active->visible();
 
     for (auto &node : nodes) {
         node->setVisible(!isVisible);
         node->setDirty();
     }
 }
 
 void KisNodeManager::toggleAlphaLock()
 {
     KisNodeList nodes = this->selectedNodes();
     KisNodeSP active = activeNode();
     if (nodes.isEmpty() || !active) return;
 
     auto layer = qobject_cast<KisPaintLayer*>(active.data());
     if (!layer) {
         return;
     }
 
     bool isAlphaLocked = layer->alphaLocked();
     for (auto &node : nodes) {
         auto layer = qobject_cast<KisPaintLayer*>(node.data());
         if (layer) {
             layer->setAlphaLocked(!isAlphaLocked);
         }
     }
 }
 
 void KisNodeManager::toggleInheritAlpha()
 {
     KisNodeList nodes = this->selectedNodes();
     KisNodeSP active = activeNode();
     if (nodes.isEmpty() || !active) return;
 
     auto layer = qobject_cast<KisLayer*>(active.data());
     if (!layer) {
         return;
     }
 
     bool isAlphaDisabled = layer->alphaChannelDisabled();
     for (auto &node : nodes) {
         auto layer = qobject_cast<KisLayer*>(node.data());
         if (layer) {
             layer->disableAlphaChannel(!isAlphaDisabled);
             node->setDirty();
         }
     }
 }
 
 void KisNodeManager::cutLayersToClipboard()
 {
     KisNodeList nodes = this->selectedNodes();
     if (nodes.isEmpty()) return;
 
     KisClipboard::instance()->setLayers(nodes, m_d->view->image(), false);
 
     KUndo2MagicString actionName = kundo2_i18n("Cut Nodes");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
     juggler->removeNode(nodes);
 }
 
 void KisNodeManager::copyLayersToClipboard()
 {
     KisNodeList nodes = this->selectedNodes();
     KisClipboard::instance()->setLayers(nodes, m_d->view->image(), true);
 }
 
 void KisNodeManager::pasteLayersFromClipboard()
 {
     const QMimeData *data = KisClipboard::instance()->layersMimeData();
     if (!data) return;
 
     KisNodeSP activeNode = this->activeNode();
 
     KisShapeController *shapeController = dynamic_cast<KisShapeController*>(m_d->imageView->document()->shapeController());
     Q_ASSERT(shapeController);
 
     KisDummiesFacadeBase *dummiesFacade = dynamic_cast<KisDummiesFacadeBase*>(m_d->imageView->document()->shapeController());
     Q_ASSERT(dummiesFacade);
 
     const bool copyNode = false;
     KisImageSP image = m_d->view->image();
     KisNodeDummy *parentDummy = dummiesFacade->dummyForNode(activeNode);
     KisNodeDummy *aboveThisDummy = parentDummy ? parentDummy->lastChild() : 0;
 
     KisMimeData::insertMimeLayers(data,
                                   image,
                                   shapeController,
                                   parentDummy,
                                   aboveThisDummy,
                                   copyNode,
                                   nodeInsertionAdapter());
 }
 
 void KisNodeManager::createQuickGroupImpl(KisNodeJugglerCompressed *juggler,
                                           const QString &overrideGroupName,
                                           KisNodeSP *newGroup,
                                           KisNodeSP *newLastChild)
 {
     KisNodeSP active = activeNode();
     if (!active) return;
 
     KisImageSP image = m_d->view->image();
     QString groupName = !overrideGroupName.isEmpty() ? overrideGroupName : image->nextLayerName();
     KisGroupLayerSP group = new KisGroupLayer(image.data(), groupName, OPACITY_OPAQUE_U8);
 
     KisNodeList nodes1;
     nodes1 << group;
 
     KisNodeList nodes2;
     nodes2 = KisLayerUtils::sortMergableNodes(image->root(), selectedNodes());
     KisLayerUtils::filterMergableNodes(nodes2);
 
     if (KisLayerUtils::checkIsChildOf(active, nodes2)) {
         active = nodes2.first();
     }
 
     KisNodeSP parent = active->parent();
     KisNodeSP aboveThis = active;
 
     juggler->addNode(nodes1, parent, aboveThis);
     juggler->moveNode(nodes2, group, 0);
 
     *newGroup = group;
     *newLastChild = nodes2.last();
 }
 
 void KisNodeManager::createQuickGroup()
 {
     KUndo2MagicString actionName = kundo2_i18n("Quick Group");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
 
     KisNodeSP parent;
     KisNodeSP above;
 
     createQuickGroupImpl(juggler, "", &parent, &above);
 }
 
 void KisNodeManager::createQuickClippingGroup()
 {
     KUndo2MagicString actionName = kundo2_i18n("Quick Clipping Group");
     KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
 
     KisNodeSP parent;
     KisNodeSP above;
 
     KisImageSP image = m_d->view->image();
     createQuickGroupImpl(juggler, image->nextLayerName(i18nc("default name for a clipping group layer", "Clipping Group")), &parent, &above);
 
     KisPaintLayerSP maskLayer = new KisPaintLayer(image.data(), i18nc("default name for quick clip group mask layer", "Mask Layer"), OPACITY_OPAQUE_U8, image->colorSpace());
     maskLayer->disableAlphaChannel(true);
 
     juggler->addNode(KisNodeList() << maskLayer, parent, above);
 }
 
 void KisNodeManager::quickUngroup()
 {
     KisNodeSP active = activeNode();
     if (!active) return;
 
     KisNodeSP parent = active->parent();
     KisNodeSP aboveThis = active;
 
     KUndo2MagicString actionName = kundo2_i18n("Quick Ungroup");
 
     if (parent && dynamic_cast<KisGroupLayer*>(active.data())) {
         KisNodeList nodes = active->childNodes(QStringList(), KoProperties());
 
         KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
         juggler->moveNode(nodes, parent, active);
         juggler->removeNode(KisNodeList() << active);
     } else if (parent && parent->parent()) {
         KisNodeSP grandParent = parent->parent();
 
         KisNodeList allChildNodes = parent->childNodes(QStringList(), KoProperties());
         KisNodeList allSelectedNodes = selectedNodes();
 
         const bool removeParent = KritaUtils::compareListsUnordered(allChildNodes, allSelectedNodes);
 
         KisNodeJugglerCompressed *juggler = m_d->lazyGetJuggler(actionName);
         juggler->moveNode(allSelectedNodes, grandParent, parent);
         if (removeParent) {
             juggler->removeNode(KisNodeList() << parent);
         }
     }
 }
 
 void KisNodeManager::selectLayersImpl(const KoProperties &props, const KoProperties &invertedProps)
 {
     KisImageSP image = m_d->view->image();
     KisNodeList nodes = KisLayerUtils::findNodesWithProps(image->root(), props, true);
 
     KisNodeList selectedNodes = this->selectedNodes();
 
     if (KritaUtils::compareListsUnordered(nodes, selectedNodes)) {
         nodes = KisLayerUtils::findNodesWithProps(image->root(), invertedProps, true);
     }
 
     if (!nodes.isEmpty()) {
         slotImageRequestNodeReselection(nodes.last(), nodes);
     }
 }
 
 void KisNodeManager::selectAllNodes()
 {
     KoProperties props;
     selectLayersImpl(props, props);
 }
 
 void KisNodeManager::selectVisibleNodes()
 {
     KoProperties props;
     props.setProperty("visible", true);
 
     KoProperties invertedProps;
     invertedProps.setProperty("visible", false);
 
     selectLayersImpl(props, invertedProps);
 }
 
 void KisNodeManager::selectLockedNodes()
 {
     KoProperties props;
     props.setProperty("locked", true);
 
     KoProperties invertedProps;
     invertedProps.setProperty("locked", false);
 
     selectLayersImpl(props, invertedProps);
 }
 
 void KisNodeManager::selectInvisibleNodes()
 {
     KoProperties props;
     props.setProperty("visible", false);
 
     KoProperties invertedProps;
     invertedProps.setProperty("visible", true);
 
     selectLayersImpl(props, invertedProps);
 }
 
 void KisNodeManager::selectUnlockedNodes()
 {
     KoProperties props;
     props.setProperty("locked", false);
 
     KoProperties invertedProps;
     invertedProps.setProperty("locked", true);
 
     selectLayersImpl(props, invertedProps);
 }
diff --git a/libs/ui/opengl/kis_opengl.cpp b/libs/ui/opengl/kis_opengl.cpp
index 351ae2e70f..fa1f0e43cf 100644
--- a/libs/ui/opengl/kis_opengl.cpp
+++ b/libs/ui/opengl/kis_opengl.cpp
@@ -1,307 +1,307 @@
 /*
  *  Copyright (c) 2007 Adrian Page <adrian@pagenet.plus.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "opengl/kis_opengl.h"
 #include "opengl/kis_opengl_p.h"
 
 #include <QOpenGLContext>
 #include <QOpenGLDebugLogger>
 #include <QOpenGLFunctions>
 
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QPixmapCache>
 
 #include <QDir>
 #include <QFile>
 #include <QStandardPaths>
 #include <QVector>
 #include <QWindow>
 
 #include <klocalizedstring.h>
 
 #include <kis_debug.h>
 #include <kis_config.h>
 
 #include <boost/optional.hpp>
 
 #ifndef GL_RENDERER
 #  define GL_RENDERER 0x1F01
 #endif
 
 using namespace KisOpenGLPrivate;
 
 namespace
 {
     bool defaultFormatIsSet = false;
     bool isDebugEnabled = false;
     bool isDebugSynchronous = false;
 
     boost::optional<OpenGLCheckResult> openGLCheckResult;
 
     bool NeedsFenceWorkaround = false;
     bool NeedsPixmapCacheWorkaround = false;
 
     QString debugText("OpenGL Info\n  **OpenGL not initialized**");
 
     QVector<KLocalizedString> openglWarningStrings;
 
     void openglOnMessageLogged(const QOpenGLDebugMessage& debugMessage) {
         qDebug() << "OpenGL:" << debugMessage;
     }
 }
 
 KisOpenGLPrivate::OpenGLCheckResult::OpenGLCheckResult(QOpenGLContext &context) {
     if (!context.isValid()) {
         return;
     }
 
     QOpenGLFunctions *funcs = context.functions(); // funcs is ready to be used
 
     m_rendererString = QString(reinterpret_cast<const char *>(funcs->glGetString(GL_RENDERER)));
     m_driverVersionString = QString(reinterpret_cast<const char *>(funcs->glGetString(GL_VERSION)));
     m_glMajorVersion = context.format().majorVersion();
     m_glMinorVersion = context.format().minorVersion();
     m_supportsDeprecatedFunctions = (context.format().options() & QSurfaceFormat::DeprecatedFunctions);
     m_isOpenGLES = context.isOpenGLES();
 }
 
 void KisOpenGLPrivate::appendOpenGLWarningString(KLocalizedString warning)
 {
     openglWarningStrings << warning;
 }
 
 bool KisOpenGLPrivate::isDefaultFormatSet() {
     return defaultFormatIsSet;
 }
 
 void KisOpenGL::initialize()
 {
     if (openGLCheckResult) return;
 
     KIS_SAFE_ASSERT_RECOVER(defaultFormatIsSet) {
         qWarning() << "Default OpenGL format was not set before calling KisOpenGL::initialize. This might be a BUG!";
         setDefaultFormat();
     }
 
     // we need a QSurface active to get our GL functions from the context
     QWindow  surface;
     surface.setSurfaceType( QSurface::OpenGLSurface );
     surface.create();
 
     QOpenGLContext context;
     if (!context.create()) {
         qDebug() << "OpenGL context cannot be created";
         return;
     }
     if (!context.isValid()) {
         qDebug() << "OpenGL context is not valid";
         return;
     }
 
     if (!context.makeCurrent(&surface)) {
         qDebug() << "OpenGL context cannot be made current";
         return;
     }
 
     QOpenGLFunctions  *funcs = context.functions();
 
     openGLCheckResult = OpenGLCheckResult(context);
 
-    debugText.clear();
-    QDebug debugOut(&debugText);
-    debugOut << "OpenGL Info";
-    debugOut << "\n  Vendor: " << reinterpret_cast<const char *>(funcs->glGetString(GL_VENDOR));
-    debugOut << "\n  Renderer: " << openGLCheckResult->rendererString();
-    debugOut << "\n  Version: " << openGLCheckResult->driverVersionString();
-    debugOut << "\n  Shading language: " << reinterpret_cast<const char *>(funcs->glGetString(GL_SHADING_LANGUAGE_VERSION));
-    debugOut << "\n  Requested format: " << QSurfaceFormat::defaultFormat();
-    debugOut << "\n  Current format:   " << context.format();
-    debugOut.nospace();
-    debugOut << "\n     Version: " << openGLCheckResult->glMajorVersion() << "." << openGLCheckResult->glMinorVersion();
-    debugOut.resetFormat();
-    debugOut << "\n     Supports deprecated functions" << openGLCheckResult->supportsDeprecatedFunctions();
-    debugOut << "\n     is OpenGL ES:" << openGLCheckResult->isOpenGLES();
-    appendPlatformOpenGLDebugText(debugOut);
-
-    qDebug().noquote() << debugText;
+//    debugText.clear();
+//    QDebug debugOut(&debugText);
+//    debugOut << "OpenGL Info";
+//    debugOut << "\n  Vendor: " << reinterpret_cast<const char *>(funcs->glGetString(GL_VENDOR));
+//    debugOut << "\n  Renderer: " << openGLCheckResult->rendererString();
+//    debugOut << "\n  Version: " << openGLCheckResult->driverVersionString();
+//    debugOut << "\n  Shading language: " << reinterpret_cast<const char *>(funcs->glGetString(GL_SHADING_LANGUAGE_VERSION));
+//    debugOut << "\n  Requested format: " << QSurfaceFormat::defaultFormat();
+//    debugOut << "\n  Current format:   " << context.format();
+//    debugOut.nospace();
+//    debugOut << "\n     Version: " << openGLCheckResult->glMajorVersion() << "." << openGLCheckResult->glMinorVersion();
+//    debugOut.resetFormat();
+//    debugOut << "\n     Supports deprecated functions" << openGLCheckResult->supportsDeprecatedFunctions();
+//    debugOut << "\n     is OpenGL ES:" << openGLCheckResult->isOpenGLES();
+//    appendPlatformOpenGLDebugText(debugOut);
+
+//    qDebug().noquote() << debugText;
 
 }
 
 void KisOpenGL::initializeContext(QOpenGLContext *ctx)
 {
     KisConfig cfg;
     initialize();
 
     dbgUI << "OpenGL: Opening new context";
     if (isDebugEnabled) {
         // Passing ctx for ownership management only, not specifying context.
         // QOpenGLDebugLogger only function on the current active context.
         // FIXME: Do we need to make sure ctx is the active context?
         QOpenGLDebugLogger* openglLogger = new QOpenGLDebugLogger(ctx);
         if (openglLogger->initialize()) {
             qDebug() << "QOpenGLDebugLogger is initialized. Check whether you get a message below.";
             QObject::connect(openglLogger, &QOpenGLDebugLogger::messageLogged, &openglOnMessageLogged);
             openglLogger->startLogging(isDebugSynchronous ? QOpenGLDebugLogger::SynchronousLogging : QOpenGLDebugLogger::AsynchronousLogging);
             openglLogger->logMessage(QOpenGLDebugMessage::createApplicationMessage(QStringLiteral("QOpenGLDebugLogger is logging.")));
         } else {
             qDebug() << "QOpenGLDebugLogger cannot be initialized.";
             delete openglLogger;
         }
     }
 
     // Double check we were given the version we requested
     QSurfaceFormat format = ctx->format();
     QOpenGLFunctions *f = ctx->functions();
     f->initializeOpenGLFunctions();
 
     QFile log(QStandardPaths::writableLocation(QStandardPaths::TempLocation) + "/krita-opengl.txt");
     log.open(QFile::WriteOnly);
     QString vendor((const char*)f->glGetString(GL_VENDOR));
     log.write(vendor.toLatin1());
     log.write(", ");
     log.write(openGLCheckResult->rendererString().toLatin1());
     log.write(", ");
     QString version((const char*)f->glGetString(GL_VERSION));
     log.write(version.toLatin1());
     log.close();
 
     // Check if we have a bugged driver that needs fence workaround
     bool isOnX11 = false;
 #ifdef HAVE_X11
     isOnX11 = true;
 #endif
 
     if ((isOnX11 && openGLCheckResult->rendererString().startsWith("AMD")) || cfg.forceOpenGLFenceWorkaround()) {
         NeedsFenceWorkaround = true;
     }
 
 
     /**
      * NVidia + Qt's openGL don't play well together and one cannot
      * draw a pixmap on a widget more than once in one rendering cycle.
      *
      * It can be workarounded by drawing strictly via QPixmapCache and
      * only when the pixmap size in bigger than doubled size of the
      * display framebuffer. That is for 8-bit HD display, you should have
      * a cache bigger than 16 MiB. Don't ask me why. (DK)
      *
      * See bug: https://bugs.kde.org/show_bug.cgi?id=361709
      *
      * TODO: check if this workaround is still needed after merging
      *       Qt5+openGL3 branch.
      */
 
     if (vendor.toUpper().contains("NVIDIA")) {
         NeedsPixmapCacheWorkaround = true;
 
         const QRect screenSize = QApplication::desktop()->screenGeometry();
         const int minCacheSize = 20 * 1024;
         const int cacheSize = 2048 + 2 * 4 * screenSize.width() * screenSize.height() / 1024; //KiB
 
         QPixmapCache::setCacheLimit(qMax(minCacheSize, cacheSize));
     }
 
 
 }
 
 const QString &KisOpenGL::getDebugText()
 {
     initialize();
     return debugText;
 }
 
 QStringList KisOpenGL::getOpenGLWarnings() {
     QStringList strings;
     Q_FOREACH (const KLocalizedString &item, openglWarningStrings) {
         strings << item.toString();
     }
     return strings;
 }
 
 // XXX Temporary function to allow LoD on OpenGL3 without triggering
 // all of the other 3.2 functionality, can be removed once we move to Qt5.7
 bool KisOpenGL::supportsLoD()
 {
     initialize();
     return openGLCheckResult->supportsLoD();
 }
 
 bool KisOpenGL::hasOpenGL3()
 {
     initialize();
     return openGLCheckResult->hasOpenGL3();
 }
 
 bool KisOpenGL::hasOpenGLES()
 {
     initialize();
     return openGLCheckResult->isOpenGLES();
 }
 
 bool KisOpenGL::supportsFenceSync()
 {
     initialize();
     return openGLCheckResult->supportsFenceSync();
 }
 
 bool KisOpenGL::needsFenceWorkaround()
 {
     initialize();
     return NeedsFenceWorkaround;
 }
 
 bool KisOpenGL::needsPixmapCacheWorkaround()
 {
     initialize();
     return NeedsPixmapCacheWorkaround;
 }
 
 void KisOpenGL::setDefaultFormat(bool enableDebug, bool debugSynchronous)
 {
     if (defaultFormatIsSet) {
         return;
     }
     defaultFormatIsSet = true;
     QSurfaceFormat format;
 #ifdef Q_OS_OSX
     format.setVersion(3, 2);
     format.setProfile(QSurfaceFormat::CoreProfile);
 #else
     // XXX This can be removed once we move to Qt5.7
     format.setVersion(3, 0);
     format.setProfile(QSurfaceFormat::CompatibilityProfile);
     format.setOptions(QSurfaceFormat::DeprecatedFunctions);
 #endif
     format.setDepthBufferSize(24);
     format.setStencilBufferSize(8);
     format.setSwapBehavior(QSurfaceFormat::DoubleBuffer);
     format.setSwapInterval(0); // Disable vertical refresh syncing
     isDebugEnabled = enableDebug;
     if (enableDebug) {
         format.setOption(QSurfaceFormat::DebugContext, true);
         isDebugSynchronous = debugSynchronous;
         qDebug() << "QOpenGLDebugLogger will be enabled, synchronous:" << debugSynchronous;
     }
     QSurfaceFormat::setDefaultFormat(format);
 }
 
 bool KisOpenGL::hasOpenGL()
 {
     return openGLCheckResult->isSupportedVersion();
 }
diff --git a/libs/ui/tool/kis_tool_paint.cc b/libs/ui/tool/kis_tool_paint.cc
index e45cc12fa9..7b32baba97 100644
--- a/libs/ui/tool/kis_tool_paint.cc
+++ b/libs/ui/tool/kis_tool_paint.cc
@@ -1,815 +1,815 @@
 /*
  *  Copyright (c) 2003-2009 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2015 Moritz Molch <kde@moritzmolch.de>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_tool_paint.h"
 
 #include <algorithm>
 
 #include <QWidget>
 #include <QRect>
 #include <QLayout>
 #include <QLabel>
 #include <QPushButton>
 #include <QWhatsThis>
 #include <QCheckBox>
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 #include <QGridLayout>
 #include <QKeyEvent>
 #include <QEvent>
 #include <QVariant>
 #include <QAction>
 #include <kis_debug.h>
 #include <QPoint>
 
 #include <kis_debug.h>
 #include <klocalizedstring.h>
 #include <kactioncollection.h>
 #include <QAction>
 
 #include <kis_icon.h>
 #include <KoShape.h>
 #include <KoCanvasResourceManager.h>
 #include <KoColorSpace.h>
 #include <KoPointerEvent.h>
 #include <KoColor.h>
 #include <KoCanvasBase.h>
 #include <KoCanvasController.h>
 
 #include <kis_types.h>
 #include <kis_global.h>
 #include <kis_image.h>
 #include <kis_paint_device.h>
 #include <kis_layer.h>
 #include <KisViewManager.h>
 #include <kis_canvas2.h>
 #include <kis_cubic_curve.h>
 #include "kis_display_color_converter.h"
 #include <KisDocument.h>
 #include <KisReferenceImagesLayer.h>
 
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_cursor.h"
 #include "widgets/kis_cmb_composite.h"
 #include "widgets/kis_slider_spin_box.h"
 #include "kis_canvas_resource_provider.h"
 #include <recorder/kis_recorded_paint_action.h>
 #include "kis_tool_utils.h"
 #include <brushengine/kis_paintop.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <kis_action_manager.h>
 #include <kis_action.h>
 #include "strokes/kis_color_picker_stroke_strategy.h"
 #include <kis_canvas_resource_provider.h>
 
 
 KisToolPaint::KisToolPaint(KoCanvasBase *canvas, const QCursor &cursor)
     : KisTool(canvas, cursor),
       m_showColorPreview(false),
       m_colorPreviewShowComparePlate(false),
       m_colorPickerDelayTimer(),
       m_isOutlineEnabled(true)
 {
     m_specialHoverModifier = false;
     m_optionsWidgetLayout = 0;
 
     m_opacity = OPACITY_OPAQUE_U8;
 
     m_supportOutline = false;
 
     {
         int maxSize = KisConfig().readEntry("maximumBrushSize", 1000);
 
         int brushSize = 1;
         do {
             m_standardBrushSizes.push_back(brushSize);
             int increment = qMax(1, int(std::ceil(qreal(brushSize) / 15)));
             brushSize += increment;
         } while (brushSize < maxSize);
 
         m_standardBrushSizes.push_back(maxSize);
     }
 
     KisCanvas2 *kiscanvas = dynamic_cast<KisCanvas2*>(canvas);
     KisActionManager *actionManager = kiscanvas->viewManager()->actionManager();
 
     // XXX: Perhaps a better place for these?
     if (!actionManager->actionByName("increase_brush_size")) {
         KisAction *increaseBrushSize = new KisAction(i18n("Increase Brush Size"));
         increaseBrushSize->setShortcut(Qt::Key_BracketRight);
         actionManager->addAction("increase_brush_size", increaseBrushSize);
     }
 
     if (!actionManager->actionByName("decrease_brush_size")) {
         KisAction *decreaseBrushSize = new KisAction(i18n("Decrease Brush Size"));
         decreaseBrushSize->setShortcut(Qt::Key_BracketLeft);
         actionManager->addAction("decrease_brush_size", decreaseBrushSize);
     }
 
     addAction("increase_brush_size", dynamic_cast<QAction *>(actionManager->actionByName("increase_brush_size")));
     addAction("decrease_brush_size", dynamic_cast<QAction *>(actionManager->actionByName("decrease_brush_size")));
 
     connect(this, SIGNAL(sigPaintingFinished()), kiscanvas->viewManager()->resourceProvider(), SLOT(slotPainting()));
 
     m_colorPickerDelayTimer.setSingleShot(true);
     connect(&m_colorPickerDelayTimer, SIGNAL(timeout()), this, SLOT(activatePickColorDelayed()));
 
     using namespace std::placeholders; // For _1 placeholder
     std::function<void(PickingJob)> callback =
         std::bind(&KisToolPaint::addPickerJob, this, _1);
     m_colorPickingCompressor.reset(
         new PickingCompressor(100, callback, KisSignalCompressor::FIRST_ACTIVE));
 }
 
 
 KisToolPaint::~KisToolPaint()
 {
 }
 
 int KisToolPaint::flags() const
 {
     return KisTool::FLAG_USES_CUSTOM_COMPOSITEOP;
 }
 
 void KisToolPaint::canvasResourceChanged(int key, const QVariant& v)
 {
     KisTool::canvasResourceChanged(key, v);
 
     switch(key) {
     case(KisCanvasResourceProvider::Opacity):
         setOpacity(v.toDouble());
         break;
     default: //nothing
         break;
     }
 
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(resetCursorStyle()), Qt::UniqueConnection);
 
 }
 
 
 void KisToolPaint::activate(ToolActivation toolActivation, const QSet<KoShape*> &shapes)
 {
     if (currentPaintOpPreset()) {
         QString formattedBrushName = currentPaintOpPreset()->name().replace("_", " ");
         emit statusTextChanged(formattedBrushName);
     }
 
     KisTool::activate(toolActivation, shapes);
     if (flags() & KisTool::FLAG_USES_CUSTOM_SIZE) {
         connect(action("increase_brush_size"), SIGNAL(triggered()), SLOT(increaseBrushSize()), Qt::UniqueConnection);
         connect(action("decrease_brush_size"), SIGNAL(triggered()), SLOT(decreaseBrushSize()), Qt::UniqueConnection);
     }
 
     KisCanvasResourceProvider *provider = qobject_cast<KisCanvas2*>(canvas())->viewManager()->resourceProvider();
     m_oldOpacity = provider->opacity();
     provider->setOpacity(m_localOpacity);
 }
 
 void KisToolPaint::deactivate()
 {
     if (flags() & KisTool::FLAG_USES_CUSTOM_SIZE) {
         disconnect(action("increase_brush_size"), 0, this, 0);
         disconnect(action("decrease_brush_size"), 0, this, 0);
     }
 
     KisCanvasResourceProvider *provider = qobject_cast<KisCanvas2*>(canvas())->viewManager()->resourceProvider();
     m_localOpacity = provider->opacity();
     provider->setOpacity(m_oldOpacity);
 
     KisTool::deactivate();
 }
 
 QPainterPath KisToolPaint::tryFixBrushOutline(const QPainterPath &originalOutline)
 {
     KisConfig cfg;
     if (cfg.newOutlineStyle() == OUTLINE_NONE) return originalOutline;
 
     const qreal minThresholdSize = cfg.outlineSizeMinimum();
 
     /**
      * If the brush outline is bigger than the canvas itself (which
      * would make it invisible for a user in most of the cases) just
      * add a cross in the center of it
      */
 
     QSize widgetSize = canvas()->canvasWidget()->size();
     const int maxThresholdSum = widgetSize.width() + widgetSize.height();
 
     QPainterPath outline = originalOutline;
     QRectF boundingRect = outline.boundingRect();
     const qreal sum = boundingRect.width() + boundingRect.height();
 
     QPointF center = boundingRect.center();
 
     if (sum > maxThresholdSum) {
         const int hairOffset = 7;
 
         outline.moveTo(center.x(), center.y() - hairOffset);
         outline.lineTo(center.x(), center.y() + hairOffset);
 
         outline.moveTo(center.x() - hairOffset, center.y());
         outline.lineTo(center.x() + hairOffset, center.y());
     } else if (sum < minThresholdSize && !outline.isEmpty()) {
         outline = QPainterPath();
         outline.addEllipse(center, 0.5 * minThresholdSize, 0.5 * minThresholdSize);
     }
 
     return outline;
 }
 
 void KisToolPaint::paint(QPainter &gc, const KoViewConverter &converter)
 {
     Q_UNUSED(converter);
 
     QPainterPath path = tryFixBrushOutline(pixelToView(m_currentOutline));
     paintToolOutline(&gc, path);
 
     if (m_showColorPreview) {
         QRectF viewRect = converter.documentToView(m_oldColorPreviewRect);
         gc.fillRect(viewRect, m_colorPreviewCurrentColor);
 
         if (m_colorPreviewShowComparePlate) {
             QRectF baseColorRect = viewRect.translated(viewRect.width(), 0);
             gc.fillRect(baseColorRect, m_colorPreviewBaseColor);
         }
     }
 }
 
 void KisToolPaint::setMode(ToolMode mode)
 {
     if(this->mode() == KisTool::PAINT_MODE &&
             mode != KisTool::PAINT_MODE) {
 
         // Let's add history information about recently used colors
         emit sigPaintingFinished();
     }
 
     KisTool::setMode(mode);
 }
 
 void KisToolPaint::activatePickColor(AlternateAction action)
 {
     m_showColorPreview = true;
 
     requestUpdateOutline(m_outlineDocPoint, 0);
 
     int resource = colorPreviewResourceId(action);
     KoColor color = canvas()->resourceManager()->koColorResource(resource);
 
     KisCanvas2 * kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     KIS_ASSERT_RECOVER_RETURN(kisCanvas);
 
     m_colorPreviewCurrentColor = kisCanvas->displayColorConverter()->toQColor(color);
 
     if (!m_colorPreviewBaseColor.isValid()) {
         m_colorPreviewBaseColor = m_colorPreviewCurrentColor;
     }
 }
 
 void KisToolPaint::deactivatePickColor(AlternateAction action)
 {
     Q_UNUSED(action);
 
     m_showColorPreview = false;
     m_oldColorPreviewRect = QRect();
     m_oldColorPreviewUpdateRect = QRect();
     m_colorPreviewCurrentColor = QColor();
 }
 
 void KisToolPaint::pickColorWasOverridden()
 {
     m_colorPreviewShowComparePlate = false;
     m_colorPreviewBaseColor = QColor();
 }
 
 void KisToolPaint::activateAlternateAction(AlternateAction action)
 {
     switch (action) {
     case PickFgNode:
         /* Falls through */
     case PickBgNode:
         /* Falls through */
     case PickFgImage:
         /* Falls through */
     case PickBgImage:
         delayedAction = action;
         m_colorPickerDelayTimer.start(100);
         /* Falls through */
     default:
         pickColorWasOverridden();
         KisTool::activateAlternateAction(action);
     };
 }
 
 void KisToolPaint::activatePickColorDelayed()
 {
     switch (delayedAction) {
         case PickFgNode:
         useCursor(KisCursor::pickerLayerForegroundCursor());
         activatePickColor(delayedAction);
         break;
     case PickBgNode:
         useCursor(KisCursor::pickerLayerBackgroundCursor());
         activatePickColor(delayedAction);
         break;
     case PickFgImage:
         useCursor(KisCursor::pickerImageForegroundCursor());
         activatePickColor(delayedAction);
         break;
     case PickBgImage:
         useCursor(KisCursor::pickerImageBackgroundCursor());
         activatePickColor(delayedAction);
         break;
     default:
         break;
     };
 
     repaintDecorations();
 }
 
 bool KisToolPaint::isPickingAction(AlternateAction action) {
     return action == PickFgNode ||
         action == PickBgNode ||
         action == PickFgImage ||
         action == PickBgImage;
 }
 
 void KisToolPaint::deactivateAlternateAction(AlternateAction action)
 {
     if (!isPickingAction(action)) {
         KisTool::deactivateAlternateAction(action);
         return;
     }
 
     delayedAction = KisTool::NONE;
     m_colorPickerDelayTimer.stop();
 
     resetCursorStyle();
     deactivatePickColor(action);
 }
 
 void KisToolPaint::addPickerJob(const PickingJob &pickingJob)
 {
     /**
      * The actual picking is delayed by a compressor, so we can get this
      * event when the stroke is already closed
      */
     if (!m_pickerStrokeId) return;
 
     KIS_ASSERT_RECOVER_RETURN(isPickingAction(pickingJob.action));
 
     const QPoint imagePoint = image()->documentToImagePixelFloored(pickingJob.documentPixel);
     const bool fromCurrentNode = pickingJob.action == PickFgNode || pickingJob.action == PickBgNode;
     m_pickingResource = colorPreviewResourceId(pickingJob.action);
 
     if (!fromCurrentNode) {
         auto *kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
         KIS_SAFE_ASSERT_RECOVER_RETURN(kisCanvas);
-        auto *referencesLayer = kisCanvas->imageView()->document()->referenceImagesLayer();
+        KisSharedPtr<KisReferenceImagesLayer> referencesLayer = kisCanvas->imageView()->document()->referenceImagesLayer();
         if (referencesLayer) {
             QColor color = referencesLayer->getPixel(imagePoint);
             if (color.isValid() && color.alpha() != 0) {
                 slotColorPickingFinished(KoColor(color, image()->colorSpace()));
                 return;
             }
         }
     }
 
     KisPaintDeviceSP device = fromCurrentNode ?
         currentNode()->colorPickSourceDevice() : image()->projection();
 
     // Used for color picker blending.
     KoColor currentColor = canvas()->resourceManager()->foregroundColor();
     if( pickingJob.action == PickBgNode || pickingJob.action == PickBgImage ){
         currentColor = canvas()->resourceManager()->backgroundColor();
     }
 
     image()->addJob(m_pickerStrokeId,
                     new KisColorPickerStrokeStrategy::Data(device, imagePoint, currentColor));
 }
 
 void KisToolPaint::beginAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     if (isPickingAction(action)) {
         KIS_ASSERT_RECOVER_RETURN(!m_pickerStrokeId);
         setMode(SECONDARY_PAINT_MODE);
 
         KisColorPickerStrokeStrategy *strategy = new KisColorPickerStrokeStrategy();
         connect(strategy, &KisColorPickerStrokeStrategy::sigColorUpdated,
                 this, &KisToolPaint::slotColorPickingFinished);
 
         m_pickerStrokeId = image()->startStroke(strategy);
         m_colorPickingCompressor->start(PickingJob(event->point, action));
         requestUpdateOutline(event->point, event);
     } else {
         KisTool::beginAlternateAction(event, action);
     }
 }
 
 void KisToolPaint::continueAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     if (isPickingAction(action)) {
         KIS_ASSERT_RECOVER_RETURN(m_pickerStrokeId);
         m_colorPickingCompressor->start(PickingJob(event->point, action));
         requestUpdateOutline(event->point, event);
     } else {
         KisTool::continueAlternateAction(event, action);
     }
 }
 
 void KisToolPaint::endAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     if (isPickingAction(action)) {
         KIS_ASSERT_RECOVER_RETURN(m_pickerStrokeId);
         image()->endStroke(m_pickerStrokeId);
         m_pickerStrokeId.clear();
         requestUpdateOutline(event->point, event);
         setMode(HOVER_MODE);
     } else {
         KisTool::endAlternateAction(event, action);
     }
 }
 
 int KisToolPaint::colorPreviewResourceId(AlternateAction action)
 {
     bool toForegroundColor = action == PickFgNode || action == PickFgImage;
     int resource = toForegroundColor ?
         KoCanvasResourceManager::ForegroundColor : KoCanvasResourceManager::BackgroundColor;
 
     return resource;
 }
 
 void KisToolPaint::slotColorPickingFinished(const KoColor &color)
 {
     canvas()->resourceManager()->setResource(m_pickingResource, color);
 
     if (!m_showColorPreview) return;
 
     KisCanvas2 * kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     KIS_ASSERT_RECOVER_RETURN(kisCanvas);
     QColor previewColor = kisCanvas->displayColorConverter()->toQColor(color);
 
     m_colorPreviewShowComparePlate = true;
     m_colorPreviewCurrentColor = previewColor;
 
     requestUpdateOutline(m_outlineDocPoint, 0);
 }
 
 void KisToolPaint::mousePressEvent(KoPointerEvent *event)
 {
     KisTool::mousePressEvent(event);
     if (mode() == KisTool::HOVER_MODE) {
         requestUpdateOutline(event->point, event);
     }
 }
 
 void KisToolPaint::mouseMoveEvent(KoPointerEvent *event)
 {
     KisTool::mouseMoveEvent(event);
     if (mode() == KisTool::HOVER_MODE) {
         requestUpdateOutline(event->point, event);
     }
 }
 
 void KisToolPaint::mouseReleaseEvent(KoPointerEvent *event)
 {
     KisTool::mouseReleaseEvent(event);
     if (mode() == KisTool::HOVER_MODE) {
         requestUpdateOutline(event->point, event);
     }
 }
 
 QWidget * KisToolPaint::createOptionWidget()
 {
     QWidget *optionWidget = new QWidget();
     optionWidget->setObjectName(toolId());
 
     QVBoxLayout *verticalLayout = new QVBoxLayout(optionWidget);
     verticalLayout->setObjectName("KisToolPaint::OptionWidget::VerticalLayout");
     verticalLayout->setContentsMargins(0,0,0,0);
     verticalLayout->setSpacing(5);
 
     // See https://bugs.kde.org/show_bug.cgi?id=316896
     QWidget *specialSpacer = new QWidget(optionWidget);
     specialSpacer->setObjectName("SpecialSpacer");
     specialSpacer->setFixedSize(0, 0);
     verticalLayout->addWidget(specialSpacer);
     verticalLayout->addWidget(specialSpacer);
 
     m_optionsWidgetLayout = new QGridLayout();
     m_optionsWidgetLayout->setColumnStretch(1, 1);
 
     verticalLayout->addLayout(m_optionsWidgetLayout);
     m_optionsWidgetLayout->setContentsMargins(0,0,0,0);
     m_optionsWidgetLayout->setSpacing(5);
 
     if (!quickHelp().isEmpty()) {
         QPushButton *push = new QPushButton(KisIconUtils::loadIcon("help-contents"), QString(), optionWidget);
         connect(push, SIGNAL(clicked()), this, SLOT(slotPopupQuickHelp()));
 
         QHBoxLayout *hLayout = new QHBoxLayout(optionWidget);
         hLayout->addWidget(push);
         hLayout->addItem(new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Fixed));
         verticalLayout->addLayout(hLayout);
     }
 
     return optionWidget;
 }
 
 QWidget* findLabelWidget(QGridLayout *layout, QWidget *control)
 {
     QWidget *result = 0;
 
     int index = layout->indexOf(control);
 
     int row, col, rowSpan, colSpan;
     layout->getItemPosition(index, &row, &col, &rowSpan, &colSpan);
 
     if (col > 0) {
         QLayoutItem *item = layout->itemAtPosition(row, col - 1);
 
         if (item) {
             result = item->widget();
         }
     } else {
         QLayoutItem *item = layout->itemAtPosition(row, col + 1);
         if (item) {
             result = item->widget();
         }
     }
 
     return result;
 }
 
 void KisToolPaint::showControl(QWidget *control, bool value)
 {
     control->setVisible(value);
     QWidget *label = findLabelWidget(m_optionsWidgetLayout, control);
     if (label) {
         label->setVisible(value);
     }
 }
 
 void KisToolPaint::enableControl(QWidget *control, bool value)
 {
     control->setEnabled(value);
     QWidget *label = findLabelWidget(m_optionsWidgetLayout, control);
     if (label) {
         label->setEnabled(value);
     }
 }
 
 void KisToolPaint::addOptionWidgetLayout(QLayout *layout)
 {
     Q_ASSERT(m_optionsWidgetLayout != 0);
     int rowCount = m_optionsWidgetLayout->rowCount();
     m_optionsWidgetLayout->addLayout(layout, rowCount, 0, 1, 2);
 }
 
 
 void KisToolPaint::addOptionWidgetOption(QWidget *control, QWidget *label)
 {
     Q_ASSERT(m_optionsWidgetLayout != 0);
     if (label) {
         m_optionsWidgetLayout->addWidget(label, m_optionsWidgetLayout->rowCount(), 0);
         m_optionsWidgetLayout->addWidget(control, m_optionsWidgetLayout->rowCount() - 1, 1);
     }
     else {
         m_optionsWidgetLayout->addWidget(control, m_optionsWidgetLayout->rowCount(), 0, 1, 2);
     }
 }
 
 
 void KisToolPaint::setOpacity(qreal opacity)
 {
     m_opacity = quint8(opacity * OPACITY_OPAQUE_U8);
 }
 
 const KoCompositeOp* KisToolPaint::compositeOp()
 {
     if (currentNode()) {
         KisPaintDeviceSP device = currentNode()->paintDevice();
         if (device) {
             QString op = canvas()->resourceManager()->resource(KisCanvasResourceProvider::CurrentCompositeOp).toString();
             return device->colorSpace()->compositeOp(op);
         }
     }
     return 0;
 }
 
 void KisToolPaint::slotPopupQuickHelp()
 {
     QWhatsThis::showText(QCursor::pos(), quickHelp());
 }
 
 void KisToolPaint::setupPaintAction(KisRecordedPaintAction* action)
 {
     KisTool::setupPaintAction(action);
     action->setOpacity(m_opacity / qreal(255.0));
     const KoCompositeOp *op = compositeOp();
     if (op) {
         action->setCompositeOp(op->id());
     }
 }
 
 KisToolPaint::NodePaintAbility KisToolPaint::nodePaintAbility()
 {
     KisNodeSP node = currentNode();
     if (!node) {
         return NONE;
     }
     if (node->inherits("KisShapeLayer")) {
         return VECTOR;
     }
     if (node->inherits("KisCloneLayer")) {
         return CLONE;
     }
     if (node->paintDevice()) {
         return PAINT;
     }
     return NONE;
 }
 
 void KisToolPaint::activatePrimaryAction()
 {
     pickColorWasOverridden();
     setOutlineEnabled(true);
     KisTool::activatePrimaryAction();
 }
 
 void KisToolPaint::deactivatePrimaryAction()
 {
     setOutlineEnabled(false);
     KisTool::deactivatePrimaryAction();
 }
 
 bool KisToolPaint::isOutlineEnabled() const
 {
     return m_isOutlineEnabled;
 }
 
 void KisToolPaint::setOutlineEnabled(bool value)
 {
     m_isOutlineEnabled = value;
     requestUpdateOutline(m_outlineDocPoint, 0);
 }
 
 void KisToolPaint::increaseBrushSize()
 {
     qreal paintopSize = currentPaintOpPreset()->settings()->paintOpSize();
 
     std::vector<int>::iterator result =
         std::upper_bound(m_standardBrushSizes.begin(),
                          m_standardBrushSizes.end(),
                          qRound(paintopSize));
 
     int newValue = result != m_standardBrushSizes.end() ? *result : m_standardBrushSizes.back();
 
     currentPaintOpPreset()->settings()->setPaintOpSize(newValue);
     requestUpdateOutline(m_outlineDocPoint, 0);
 }
 
 void KisToolPaint::decreaseBrushSize()
 {
     qreal paintopSize = currentPaintOpPreset()->settings()->paintOpSize();
 
     std::vector<int>::reverse_iterator result =
         std::upper_bound(m_standardBrushSizes.rbegin(),
                          m_standardBrushSizes.rend(),
                          (int)paintopSize,
                          std::greater<int>());
 
     int newValue = result != m_standardBrushSizes.rend() ? *result : m_standardBrushSizes.front();
 
     currentPaintOpPreset()->settings()->setPaintOpSize(newValue);
     requestUpdateOutline(m_outlineDocPoint, 0);
 }
 
 QRectF KisToolPaint::colorPreviewDocRect(const QPointF &outlineDocPoint)
 {
     if (!m_showColorPreview) return QRect();
 
     KisConfig cfg;
 
     const QRectF colorPreviewViewRect = cfg.colorPreviewRect();
     const QRectF colorPreviewDocumentRect = canvas()->viewConverter()->viewToDocument(colorPreviewViewRect);
 
     return colorPreviewDocumentRect.translated(outlineDocPoint);
 }
 
 void KisToolPaint::requestUpdateOutline(const QPointF &outlineDocPoint, const KoPointerEvent *event)
 {
     if (!m_supportOutline) return;
 
     KisConfig cfg;
     KisPaintOpSettings::OutlineMode outlineMode;
 
     if (isOutlineEnabled() &&
         (mode() == KisTool::GESTURE_MODE ||
          ((cfg.newOutlineStyle() == OUTLINE_FULL ||
            cfg.newOutlineStyle() == OUTLINE_CIRCLE ||
            cfg.newOutlineStyle() == OUTLINE_TILT) &&
           ((mode() == HOVER_MODE) ||
            (mode() == PAINT_MODE && cfg.showOutlineWhilePainting()))))) { // lisp forever!
 
         outlineMode.isVisible = true;
 
         if (cfg.newOutlineStyle() == OUTLINE_CIRCLE) {
             outlineMode.forceCircle = true;
         } else if(cfg.newOutlineStyle() == OUTLINE_TILT) {
             outlineMode.forceCircle = true;
             outlineMode.showTiltDecoration = true;
         } else {
             // noop
         }
     }
 
     outlineMode.forceFullSize = cfg.forceAlwaysFullSizedOutline();
 
     m_outlineDocPoint = outlineDocPoint;
     m_currentOutline = getOutlinePath(m_outlineDocPoint, event, outlineMode);
 
     QRectF outlinePixelRect = m_currentOutline.boundingRect();
     QRectF outlineDocRect = currentImage()->pixelToDocument(outlinePixelRect);
 
     // This adjusted call is needed as we paint with a 3 pixel wide brush and the pen is outside the bounds of the path
     // Pen uses view coordinates so we have to zoom the document value to match 2 pixel in view coordiates
     // See BUG 275829
     qreal zoomX;
     qreal zoomY;
     canvas()->viewConverter()->zoom(&zoomX, &zoomY);
     qreal xoffset = 2.0/zoomX;
     qreal yoffset = 2.0/zoomY;
 
     if (!outlineDocRect.isEmpty()) {
         outlineDocRect.adjust(-xoffset,-yoffset,xoffset,yoffset);
     }
 
     QRectF colorPreviewDocRect = this->colorPreviewDocRect(m_outlineDocPoint);
     QRectF colorPreviewDocUpdateRect;
     if (!colorPreviewDocRect.isEmpty()) {
         colorPreviewDocUpdateRect.adjust(-xoffset,-yoffset,xoffset,yoffset);
     }
 
     // DIRTY HACK ALERT: we should fetch the assistant's dirty rect when requesting
     //                   the update, instead of just dumbly update the entire canvas!
 
     KisCanvas2 * kiscanvas = dynamic_cast<KisCanvas2*>(canvas());
     KisPaintingAssistantsDecorationSP decoration = kiscanvas->paintingAssistantsDecoration();
     if (decoration && decoration->visible()) {
         kiscanvas->updateCanvas();
     } else {
         // TODO: only this branch should be present!
         if (!m_oldColorPreviewUpdateRect.isEmpty()) {
             canvas()->updateCanvas(m_oldColorPreviewUpdateRect);
         }
 
         if (!m_oldOutlineRect.isEmpty()) {
             canvas()->updateCanvas(m_oldOutlineRect);
         }
 
         if (!outlineDocRect.isEmpty()) {
             canvas()->updateCanvas(outlineDocRect);
         }
 
         if (!colorPreviewDocUpdateRect.isEmpty()) {
             canvas()->updateCanvas(colorPreviewDocUpdateRect);
         }
     }
 
     m_oldOutlineRect = outlineDocRect;
     m_oldColorPreviewRect = colorPreviewDocRect;
     m_oldColorPreviewUpdateRect = colorPreviewDocUpdateRect;
 }
 
 QPainterPath KisToolPaint::getOutlinePath(const QPointF &documentPos,
                                           const KoPointerEvent *event,
                                           KisPaintOpSettings::OutlineMode outlineMode)
 {
     Q_UNUSED(event);
 
     QPointF imagePos = currentImage()->documentToPixel(documentPos);
     QPainterPath path = currentPaintOpPreset()->settings()->
         brushOutline(KisPaintInformation(imagePos), outlineMode);
 
     return path;
 }
 
diff --git a/libs/ui/widgets/kis_paintop_presets_popup.cpp b/libs/ui/widgets/kis_paintop_presets_popup.cpp
index 859d5602f3..39593323eb 100644
--- a/libs/ui/widgets/kis_paintop_presets_popup.cpp
+++ b/libs/ui/widgets/kis_paintop_presets_popup.cpp
@@ -1,848 +1,848 @@
 /* This file is part of the KDE project
  * Copyright (C) 2008 Boudewijn Rempt <boud@valdyas.org>
  * Copyright (C) 2010 Lukáš Tvrdý <lukast.dev@gmail.com>
  * Copyright (C) 2011 Silvio Heinrich <plassy@web.de>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "widgets/kis_paintop_presets_popup.h"
 
 #include <QList>
 #include <QComboBox>
 #include <QHBoxLayout>
 #include <QToolButton>
 #include <QGridLayout>
 #include <QFont>
 #include <QMenu>
 #include <QAction>
 #include <QShowEvent>
 #include <QFontDatabase>
 #include <QWidgetAction>
 
 #include <kconfig.h>
 #include <klocalizedstring.h>
 
 #include <KoDockRegistry.h>
 
 #include <kis_icon.h>
 #include <kis_icon.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <brushengine/kis_paintop_config_widget.h>
 #include <kis_canvas_resource_provider.h>
 #include <widgets/kis_preset_chooser.h>
 #include <widgets/kis_preset_selector_strip.h>
 
 #include <ui_wdgpaintopsettings.h>
 #include <kis_node.h>
 #include "kis_config.h"
 
 #include "KisResourceServerProvider.h"
 #include "kis_lod_availability_widget.h"
 
 #include "kis_signal_auto_connection.h"
 #include <kis_paintop_settings_update_proxy.h>
 
 
 // ones from brush engine selector
 #include <brushengine/kis_paintop_factory.h>
 #include <kis_preset_live_preview_view.h>
 
 
 struct KisPaintOpPresetsPopup::Private
 {
 
 public:
 
     Ui_WdgPaintOpSettings uiWdgPaintOpPresetSettings;
     QGridLayout *layout;
     KisPaintOpConfigWidget *settingsWidget;
     QFont smallFont;
     KisCanvasResourceProvider *resourceProvider;
     KisFavoriteResourceManager *favoriteResManager;
 
     bool detached;
     bool ignoreHideEvents;
     bool isCreatingBrushFromScratch = false;
     QSize minimumSettingsWidgetSize;
     QRect detachedGeometry;
 
     KisSignalAutoConnectionsStore widgetConnections;
 };
 
 KisPaintOpPresetsPopup::KisPaintOpPresetsPopup(KisCanvasResourceProvider * resourceProvider,
                                                KisFavoriteResourceManager* favoriteResourceManager,
                                                KisPresetSaveWidget* savePresetWidget,
                                                QWidget * parent)
     : QWidget(parent)
     , m_d(new Private())
 {
     setObjectName("KisPaintOpPresetsPopup");
     setFont(KoDockRegistry::dockFont());
 
     current_paintOpId = "";
 
     m_d->resourceProvider = resourceProvider;
     m_d->favoriteResManager = favoriteResourceManager;
 
     m_d->uiWdgPaintOpPresetSettings.setupUi(this);
 
     m_d->layout = new QGridLayout(m_d->uiWdgPaintOpPresetSettings.frmOptionWidgetContainer);
     m_d->layout->setSizeConstraint(QLayout::SetFixedSize);
 
     m_d->uiWdgPaintOpPresetSettings.scratchPad->setupScratchPad(resourceProvider, Qt::white);
     m_d->uiWdgPaintOpPresetSettings.scratchPad->setCutoutOverlayRect(QRect(25, 25, 200, 200));
 
 
 
     m_d->uiWdgPaintOpPresetSettings.dirtyPresetIndicatorButton->setToolTip(i18n("The settings for this preset have changed from their default."));
 
 
     m_d->uiWdgPaintOpPresetSettings.showPresetsButton->setToolTip(i18n("Toggle showing presets"));
 
     m_d->uiWdgPaintOpPresetSettings.showScratchpadButton->setToolTip(i18n("Toggle showing scratchpad"));
 
     m_d->uiWdgPaintOpPresetSettings.reloadPresetButton->setToolTip(i18n("Reload the brush preset"));
     m_d->uiWdgPaintOpPresetSettings.renameBrushPresetButton->setToolTip(i18n("Rename the brush preset"));
 
 
     // creating a new preset from scratch. Part of the brush presets area
     // the menu options will get filled up later when we are generating all available paintops
     // in the filter drop-down
     newPresetBrushEnginesMenu = new QMenu();
 
     // overwrite existing preset and saving a new preset use the same dialog
     saveDialog = savePresetWidget;
     saveDialog->scratchPadSetup(resourceProvider);
     saveDialog->setFavoriteResourceManager(m_d->favoriteResManager); // this is needed when saving the preset
     saveDialog->hide();
 
     // the area on the brush editor for renaming the brush. make sure edit fields are hidden by default
     toggleBrushRenameUIActive(false);
 
 
     // DETAIL and THUMBNAIL view changer
     QMenu* menu = new QMenu(this);
 
     menu->setStyleSheet("margin: 6px");
     menu->addSection(i18n("Display"));
 
     QActionGroup *actionGroup = new QActionGroup(this);
 
     KisPresetChooser::ViewMode mode = (KisPresetChooser::ViewMode)KisConfig().presetChooserViewMode();
 
     QAction* action = menu->addAction(KisIconUtils::loadIcon("view-preview"), i18n("Thumbnails"), m_d->uiWdgPaintOpPresetSettings.presetWidget, SLOT(slotThumbnailMode()));
     action->setCheckable(true);
     action->setChecked(mode == KisPresetChooser::THUMBNAIL);
     action->setActionGroup(actionGroup);
 
     action = menu->addAction(KisIconUtils::loadIcon("view-list-details"), i18n("Details"), m_d->uiWdgPaintOpPresetSettings.presetWidget, SLOT(slotDetailMode()));
     action->setCheckable(true);
     action->setChecked(mode == KisPresetChooser::DETAIL);
     action->setActionGroup(actionGroup);
 
 
     // add horizontal slider for the icon size
     QSlider* iconSizeSlider = new QSlider(this);
     iconSizeSlider->setOrientation(Qt::Horizontal);
     iconSizeSlider->setRange(30, 80);
     iconSizeSlider->setValue(m_d->uiWdgPaintOpPresetSettings.presetWidget->iconSize());
     iconSizeSlider->setMinimumHeight(20);
     iconSizeSlider->setMinimumWidth(40);
     iconSizeSlider->setTickInterval(10);
 
 
     QWidgetAction *sliderAction= new QWidgetAction(this);
     sliderAction->setDefaultWidget(iconSizeSlider);
 
     menu->addSection(i18n("Icon Size"));
     menu->addAction(sliderAction);
 
 
     // configure the button and assign menu
     m_d->uiWdgPaintOpPresetSettings.presetChangeViewToolButton->setMenu(menu);
 
     m_d->uiWdgPaintOpPresetSettings.presetChangeViewToolButton->setPopupMode(QToolButton::InstantPopup);
 
 
     // loading preset from scratch option
     m_d->uiWdgPaintOpPresetSettings.newPresetEngineButton->setPopupMode(QToolButton::InstantPopup);
 
 
     // show/hide buttons
 
     KisConfig cfg;
 
     m_d->uiWdgPaintOpPresetSettings.showScratchpadButton->setCheckable(true);
     m_d->uiWdgPaintOpPresetSettings.showScratchpadButton->setChecked(cfg.scratchpadVisible());
 
     if (cfg.scratchpadVisible()) {
         slotSwitchScratchpad(true); // show scratchpad
     } else {
         slotSwitchScratchpad(false);
     }
 
     m_d->uiWdgPaintOpPresetSettings.showPresetsButton->setCheckable(true);
     m_d->uiWdgPaintOpPresetSettings.showPresetsButton->setChecked(false);
     slotSwitchShowPresets(false); // hide presets by default
 
 
     // Connections
     connect(m_d->uiWdgPaintOpPresetSettings.paintPresetIcon, SIGNAL(clicked()),
             m_d->uiWdgPaintOpPresetSettings.scratchPad, SLOT(paintPresetImage()));
 
     connect(saveDialog, SIGNAL(resourceSelected(KoResource*)), this, SLOT(resourceSelected(KoResource*)));
 
     connect (m_d->uiWdgPaintOpPresetSettings.renameBrushPresetButton, SIGNAL(clicked(bool)),
              this, SLOT(slotRenameBrushActivated()));
 
     connect (m_d->uiWdgPaintOpPresetSettings.cancelBrushNameUpdateButton, SIGNAL(clicked(bool)),
              this, SLOT(slotRenameBrushDeactivated()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.updateBrushNameButton, SIGNAL(clicked(bool)),
             this, SLOT(slotSaveRenameCurrentBrush()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.renameBrushNameTextField, SIGNAL(returnPressed()),
             SLOT(slotSaveRenameCurrentBrush()));
 
     connect(iconSizeSlider, SIGNAL(sliderMoved(int)),
             m_d->uiWdgPaintOpPresetSettings.presetWidget, SLOT(slotSetIconSize(int)));
 
     connect(iconSizeSlider, SIGNAL(sliderReleased()),
             m_d->uiWdgPaintOpPresetSettings.presetWidget, SLOT(slotSaveIconSize()));
 
 
     connect(m_d->uiWdgPaintOpPresetSettings.showScratchpadButton, SIGNAL(clicked(bool)),
             this, SLOT(slotSwitchScratchpad(bool)));
 
 
     connect(m_d->uiWdgPaintOpPresetSettings.showPresetsButton, SIGNAL(clicked(bool)), this, SLOT(slotSwitchShowPresets(bool)));
 
     connect(m_d->uiWdgPaintOpPresetSettings.eraseScratchPad, SIGNAL(clicked()),
             m_d->uiWdgPaintOpPresetSettings.scratchPad, SLOT(fillDefault()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.fillLayer, SIGNAL(clicked()),
             m_d->uiWdgPaintOpPresetSettings.scratchPad, SLOT(fillLayer()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.fillGradient, SIGNAL(clicked()),
             m_d->uiWdgPaintOpPresetSettings.scratchPad, SLOT(fillGradient()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.fillSolid, SIGNAL(clicked()),
             m_d->uiWdgPaintOpPresetSettings.scratchPad, SLOT(fillBackground()));
 
 
     m_d->settingsWidget = 0;
     setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed));
 
     connect(m_d->uiWdgPaintOpPresetSettings.saveBrushPresetButton, SIGNAL(clicked()),
             this, SLOT(slotSaveBrushPreset()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.saveNewBrushPresetButton, SIGNAL(clicked()),
             this, SLOT(slotSaveNewBrushPreset()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.reloadPresetButton, SIGNAL(clicked()),
             this, SIGNAL(reloadPresetClicked()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.dirtyPresetCheckBox, SIGNAL(toggled(bool)),
             this, SIGNAL(dirtyPresetToggled(bool)));
 
     connect(m_d->uiWdgPaintOpPresetSettings.eraserBrushSizeCheckBox, SIGNAL(toggled(bool)),
             this, SIGNAL(eraserBrushSizeToggled(bool)));
 
     connect(m_d->uiWdgPaintOpPresetSettings.eraserBrushOpacityCheckBox, SIGNAL(toggled(bool)),
             this, SIGNAL(eraserBrushOpacityToggled(bool)));
 
 
     // preset widget connections
     connect(m_d->uiWdgPaintOpPresetSettings.presetWidget->smallPresetChooser, SIGNAL(resourceSelected(KoResource*)),
             this, SIGNAL(signalResourceSelected(KoResource*)));
 
     connect(m_d->uiWdgPaintOpPresetSettings.reloadPresetButton, SIGNAL(clicked()),
             m_d->uiWdgPaintOpPresetSettings.presetWidget->smallPresetChooser, SLOT(updateViewSettings()));
 
 
 
     connect(m_d->uiWdgPaintOpPresetSettings.reloadPresetButton, SIGNAL(clicked()), SLOT(slotUpdatePresetSettings()));
 
     m_d->detached = false;
     m_d->ignoreHideEvents = false;
     m_d->minimumSettingsWidgetSize = QSize(0, 0);
 
     m_d->detachedGeometry = QRect(100, 100, 0, 0);
     m_d->uiWdgPaintOpPresetSettings.dirtyPresetCheckBox->setChecked(cfg.useDirtyPresets());
     m_d->uiWdgPaintOpPresetSettings.eraserBrushSizeCheckBox->setChecked(cfg.useEraserBrushSize());
     m_d->uiWdgPaintOpPresetSettings.eraserBrushOpacityCheckBox->setChecked(cfg.useEraserBrushOpacity());
 
     m_d->uiWdgPaintOpPresetSettings.wdgLodAvailability->setCanvasResourceManager(resourceProvider->resourceManager());
 
     connect(resourceProvider->resourceManager(),
             SIGNAL(canvasResourceChanged(int,QVariant)),
             SLOT(slotResourceChanged(int, QVariant)));
 
     connect(m_d->uiWdgPaintOpPresetSettings.wdgLodAvailability,
             SIGNAL(sigUserChangedLodAvailability(bool)),
             SLOT(slotLodAvailabilityChanged(bool)));
 
     connect(m_d->uiWdgPaintOpPresetSettings.wdgLodAvailability,
             SIGNAL(sigUserChangedLodThreshold(qreal)),
             SLOT(slotLodThresholdChanged(qreal)));
 
     slotResourceChanged(KisCanvasResourceProvider::LodAvailability,
                         resourceProvider->resourceManager()->
                         resource(KisCanvasResourceProvider::LodAvailability));
 
     slotResourceChanged(KisCanvasResourceProvider::LodSizeThreshold,
                         resourceProvider->resourceManager()->
                         resource(KisCanvasResourceProvider::LodSizeThreshold));
 
     connect(m_d->uiWdgPaintOpPresetSettings.brushEgineComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(slotUpdatePaintOpFilter()));
 
 
     connect(m_d->uiWdgPaintOpPresetSettings.bnBlacklistPreset, SIGNAL(clicked()), this, SLOT(slotBlackListCurrentPreset()));
 
     updateThemedIcons();
 
     // setup things like the scene construct images, layers, etc that is a one-time thing
     m_d->uiWdgPaintOpPresetSettings.liveBrushPreviewView->setup();
 
 }
 
 void KisPaintOpPresetsPopup::slotBlackListCurrentPreset()
 {
     KisPaintOpPresetResourceServer * rServer = KisResourceServerProvider::instance()->paintOpPresetServer();
     KisPaintOpPresetSP curPreset = m_d->resourceProvider->currentPreset();
 
     if (rServer->resourceByName(curPreset->name())) {
         rServer->removeResourceAndBlacklist(curPreset);
     }
 }
 
 
 void KisPaintOpPresetsPopup::slotRenameBrushActivated()
 {
     toggleBrushRenameUIActive(true);
 }
 
 void KisPaintOpPresetsPopup::slotRenameBrushDeactivated()
 {
     toggleBrushRenameUIActive(false);
 }
 
 void KisPaintOpPresetsPopup::toggleBrushRenameUIActive(bool isRenaming)
 {
     // This function doesn't really do anything except get the UI in a state to rename a brush preset
     m_d->uiWdgPaintOpPresetSettings.renameBrushNameTextField->setVisible(isRenaming);
     m_d->uiWdgPaintOpPresetSettings.updateBrushNameButton->setVisible(isRenaming);
     m_d->uiWdgPaintOpPresetSettings.cancelBrushNameUpdateButton->setVisible(isRenaming);
 
 
     // hide these below areas while renaming
     m_d->uiWdgPaintOpPresetSettings.currentBrushNameLabel->setVisible(!isRenaming);
     m_d->uiWdgPaintOpPresetSettings.renameBrushPresetButton->setVisible(!isRenaming);
     m_d->uiWdgPaintOpPresetSettings.saveBrushPresetButton->setEnabled(!isRenaming);
     m_d->uiWdgPaintOpPresetSettings.saveBrushPresetButton->setVisible(!isRenaming);
     m_d->uiWdgPaintOpPresetSettings.saveNewBrushPresetButton->setEnabled(!isRenaming);
     m_d->uiWdgPaintOpPresetSettings.saveNewBrushPresetButton->setVisible(!isRenaming);
 
     // if the presets area is shown, only then can you show/hide the load default brush
     // need to think about weird state when you are in the middle of renaming a brush
     // what happens if you try to change presets. maybe we should auto-hide (or disable)
     // the presets area in this case
     if (m_d->uiWdgPaintOpPresetSettings.presetWidget->isVisible()) {
         m_d->uiWdgPaintOpPresetSettings.newPresetEngineButton->setVisible(!isRenaming);
         m_d->uiWdgPaintOpPresetSettings.bnBlacklistPreset->setVisible(!isRenaming);
     }
 
 }
 
 void KisPaintOpPresetsPopup::slotSaveRenameCurrentBrush()
 {
     // if you are renaming a brush, that is different than updating the settings
     // make sure we are in a clean state before renaming. This logic might change,
     // but that is what we are going with for now
     emit reloadPresetClicked();
 
 
     m_d->favoriteResManager->setBlockUpdates(true);
 
     // get a reference to the existing (and new) file name and path that we are working with
     KisPaintOpPresetSP curPreset = m_d->resourceProvider->currentPreset();
 
     if (!curPreset)
         return;
 
     KisPaintOpPresetResourceServer * rServer = KisResourceServerProvider::instance()->paintOpPresetServer();
     QString saveLocation = rServer->saveLocation();
 
     QString originalPresetName = curPreset->name();
     QString renamedPresetName = m_d->uiWdgPaintOpPresetSettings.renameBrushNameTextField->text();
     QString originalPresetPathAndFile = saveLocation + originalPresetName + curPreset->defaultFileExtension();
     QString renamedPresetPathAndFile = saveLocation + renamedPresetName + curPreset->defaultFileExtension();
 
 
     // create a new brush preset with the name specified and add to resource provider
     KisPaintOpPresetSP newPreset = curPreset->clone();
     newPreset->setFilename(renamedPresetPathAndFile); // this also contains the path
     newPreset->setName(renamedPresetName);
     newPreset->setImage(curPreset->image()); // use existing thumbnail (might not need to do this)
     newPreset->setPresetDirty(false);
     newPreset->setValid(true);
     rServer->addResource(newPreset);
 
     resourceSelected(newPreset.data()); // refresh and select our freshly renamed resource
 
 
     // Now blacklist the original file
     if (rServer->resourceByName(originalPresetName)) {
         rServer->removeResourceAndBlacklist(curPreset);
     }
 
     m_d->favoriteResManager->setBlockUpdates(false);
 
     toggleBrushRenameUIActive(false); // this returns the UI to its original state after saving
 
     slotUpdatePresetSettings(); // update visibility of dirty preset and icon
 }
 
 void KisPaintOpPresetsPopup::slotResourceChanged(int key, const QVariant &value)
 {
     if (key == KisCanvasResourceProvider::LodAvailability) {
         m_d->uiWdgPaintOpPresetSettings.wdgLodAvailability->slotUserChangedLodAvailability(value.toBool());
     } else if (key == KisCanvasResourceProvider::LodSizeThreshold) {
         m_d->uiWdgPaintOpPresetSettings.wdgLodAvailability->slotUserChangedLodThreshold(value.toDouble());
     } else if (key == KisCanvasResourceProvider::Size) {
         m_d->uiWdgPaintOpPresetSettings.wdgLodAvailability->slotUserChangedSize(value.toDouble());
     }
 }
 
 void KisPaintOpPresetsPopup::slotLodAvailabilityChanged(bool value)
 {
     m_d->resourceProvider->resourceManager()->setResource(KisCanvasResourceProvider::LodAvailability, QVariant(value));
 }
 
 void KisPaintOpPresetsPopup::slotLodThresholdChanged(qreal value)
 {
     m_d->resourceProvider->resourceManager()->setResource(KisCanvasResourceProvider::LodSizeThreshold, QVariant(value));
 }
 
 KisPaintOpPresetsPopup::~KisPaintOpPresetsPopup()
 {
     if (m_d->settingsWidget) {
         m_d->layout->removeWidget(m_d->settingsWidget);
         m_d->settingsWidget->hide();
         m_d->settingsWidget->setParent(0);
         m_d->settingsWidget = 0;
     }
     delete m_d;
     delete newPresetBrushEnginesMenu;
 }
 
 void KisPaintOpPresetsPopup::setPaintOpSettingsWidget(QWidget * widget)
 {
     if (m_d->settingsWidget) {
         m_d->layout->removeWidget(m_d->settingsWidget);
         m_d->uiWdgPaintOpPresetSettings.frmOptionWidgetContainer->updateGeometry();
     }
     m_d->layout->update();
     updateGeometry();
 
     m_d->widgetConnections.clear();
     m_d->settingsWidget = 0;
 
     if (widget) {
 
         m_d->settingsWidget = dynamic_cast<KisPaintOpConfigWidget*>(widget);
         KIS_ASSERT_RECOVER_RETURN(m_d->settingsWidget);
 
         KisConfig cfg;
         if (m_d->settingsWidget->supportScratchBox() && cfg.scratchpadVisible()) {
             slotSwitchScratchpad(true);
         } else {
             slotSwitchScratchpad(false);
         }
 
         m_d->widgetConnections.addConnection(m_d->settingsWidget, SIGNAL(sigConfigurationItemChanged()),
                                              this, SLOT(slotUpdateLodAvailability()));
 
         widget->setFont(m_d->smallFont);
 
         QSize hint = widget->sizeHint();
         m_d->minimumSettingsWidgetSize = QSize(qMax(hint.width(), m_d->minimumSettingsWidgetSize.width()),
                                                qMax(hint.height(), m_d->minimumSettingsWidgetSize.height()));
         widget->setMinimumSize(m_d->minimumSettingsWidgetSize);
         m_d->layout->addWidget(widget);
 
         // hook up connections that will monitor if our preset is dirty or not. Show a notification if it is
         if (m_d->resourceProvider && m_d->resourceProvider->currentPreset() ) {
 
             KisPaintOpPresetSP preset = m_d->resourceProvider->currentPreset();
             m_d->widgetConnections.addConnection(preset->updateProxy(), SIGNAL(sigSettingsChanged()),
                                                  this, SLOT(slotUpdatePresetSettings()));
         }
 
         m_d->layout->update();
         widget->show();
 
     }
     slotUpdateLodAvailability();
 }
 
 void KisPaintOpPresetsPopup::slotUpdateLodAvailability()
 {
     if (!m_d->settingsWidget) return;
 
     KisPaintopLodLimitations l = m_d->settingsWidget->lodLimitations();
     m_d->uiWdgPaintOpPresetSettings.wdgLodAvailability->setLimitations(l);
 }
 
 QImage KisPaintOpPresetsPopup::cutOutOverlay()
 {
     return m_d->uiWdgPaintOpPresetSettings.scratchPad->cutoutOverlay();
 }
 
 void KisPaintOpPresetsPopup::contextMenuEvent(QContextMenuEvent *e)
 {
     Q_UNUSED(e);
 }
 
 void KisPaintOpPresetsPopup::switchDetached(bool show)
 {
     if (parentWidget()) {
 
         m_d->detached = !m_d->detached;
 
         if (m_d->detached) {
             m_d->ignoreHideEvents = true;
 
             if (show) {
                 parentWidget()->show();
             }
             m_d->ignoreHideEvents = false;
 
         }
         else {
             KisConfig cfg;
             parentWidget()->hide();
         }
 
         KisConfig cfg;
         cfg.setPaintopPopupDetached(m_d->detached);
     }
 }
 
 void KisPaintOpPresetsPopup::setCreatingBrushFromScratch(bool enabled)
 {
     m_d->isCreatingBrushFromScratch = enabled;
 }
 
 void KisPaintOpPresetsPopup::resourceSelected(KoResource* resource)
 {
     // this gets called every time the brush editor window is opened
     // TODO: this gets called multiple times whenever the preset is changed in the presets area
     // the connections probably need to be thought about with this a bit more to keep things in sync
 
     m_d->uiWdgPaintOpPresetSettings.presetWidget->smallPresetChooser->setCurrentResource(resource);
 
     // find the display name of the brush engine and append it to the selected preset display
     QString currentBrushEngineName;
     QPixmap currentBrushEngineIcon = QPixmap(26, 26);
     currentBrushEngineIcon.fill(Qt::transparent);
     for(int i=0; i < sortedBrushEnginesList.length(); i++) {
         if (sortedBrushEnginesList.at(i).id == currentPaintOpId() ) {
             currentBrushEngineName = sortedBrushEnginesList.at(i).name;
             currentBrushEngineIcon = sortedBrushEnginesList.at(i).icon.pixmap(26, 26);
         }
     }
 
     // brush names have underscores as part of the file name (to help with building). We don't really need underscores
     // when viewing the names, so replace them with spaces
     QString formattedBrushName = resource->name().replace("_", " ");
 
     m_d->uiWdgPaintOpPresetSettings.currentBrushNameLabel->setText(formattedBrushName);
-    m_d->uiWdgPaintOpPresetSettings.currentBrushEngineLabel->setText(currentBrushEngineName.append(" ").append("Engine"));
+    m_d->uiWdgPaintOpPresetSettings.currentBrushEngineLabel->setText(i18nc("%1 is the name of a brush engine", "%1 Engine", currentBrushEngineName));
     m_d->uiWdgPaintOpPresetSettings.currentBrushEngineIcon->setPixmap(currentBrushEngineIcon);
     m_d->uiWdgPaintOpPresetSettings.renameBrushNameTextField->setText(resource->name()); // use file name
 
     // get the preset image and pop it into the thumbnail area on the top of the brush editor
     m_d->uiWdgPaintOpPresetSettings.presetThumbnailicon->setPixmap(QPixmap::fromImage(resource->image().scaled(55, 55, Qt::KeepAspectRatio, Qt::SmoothTransformation)));
 
     toggleBrushRenameUIActive(false); // reset the UI state of renaming a brush if we are changing brush presets
     slotUpdatePresetSettings(); // check to see if the dirty preset icon needs to be shown
 }
 
 bool variantLessThan(const KisPaintOpInfo v1, const KisPaintOpInfo v2)
 {
     return v1.priority < v2.priority;
 }
 
 void KisPaintOpPresetsPopup::setPaintOpList(const QList< KisPaintOpFactory* >& list)
 {
     m_d->uiWdgPaintOpPresetSettings.brushEgineComboBox->clear(); // reset combobox list just in case
 
 
     // create a new list so we can sort it and populate the brush engine combo box
     sortedBrushEnginesList.clear(); // just in case this function is called again, don't keep adding to the list
 
     for(int i=0; i < list.length(); i++) {
         KisPaintOpInfo paintOpInfo;
         paintOpInfo.id = list.at(i)->id();
         paintOpInfo.name = list.at(i)->name();
         paintOpInfo.icon = list.at(i)->icon();
         paintOpInfo.priority = list.at(i)->priority();
 
         sortedBrushEnginesList.append(paintOpInfo);
     }
 
     std::stable_sort(sortedBrushEnginesList.begin(), sortedBrushEnginesList.end(), variantLessThan );
 
     // add an "All" option at the front to show all presets
     QPixmap emptyPixmap = QPixmap(22,22);
     emptyPixmap.fill(Qt::transparent);
 
     // if we create a new brush from scratch, we need a full list of paintops to choose from
     // we don't want "All", so populate the list before that is added
     newPresetBrushEnginesMenu->actions().clear(); // clean out list in case we run this again
     newBrushEngineOptions.clear();
 
     for (int j = 0; j < sortedBrushEnginesList.length(); j++) {
         KisAction * newEngineAction = static_cast<KisAction*>( newPresetBrushEnginesMenu->addAction(sortedBrushEnginesList[j].name));
         newEngineAction->setObjectName(sortedBrushEnginesList[j].id); // we need the ID for changing the paintop when action triggered
         newEngineAction->setIcon(sortedBrushEnginesList[j].icon);
         newBrushEngineOptions.append(newEngineAction);
         connect(newEngineAction, SIGNAL(triggered()), this, SLOT(slotCreateNewBrushPresetEngine()));
     }
     m_d->uiWdgPaintOpPresetSettings.newPresetEngineButton->setMenu(newPresetBrushEnginesMenu);
 
     // fill the list into the brush combo box
     sortedBrushEnginesList.push_front(KisPaintOpInfo(QString("all_options"), i18n("All"), QString(""), QIcon(emptyPixmap), 0 ));
     for (int m = 0; m < sortedBrushEnginesList.length(); m++) {
         m_d->uiWdgPaintOpPresetSettings.brushEgineComboBox->addItem(sortedBrushEnginesList[m].icon, sortedBrushEnginesList[m].name, QVariant(sortedBrushEnginesList[m].id));
     }
 }
 
 
 void KisPaintOpPresetsPopup::setCurrentPaintOpId(const QString& paintOpId)
 {
     current_paintOpId = paintOpId;
 }
 
 
 QString KisPaintOpPresetsPopup::currentPaintOpId() {
     return current_paintOpId;
 }
 
 void KisPaintOpPresetsPopup::setPresetImage(const QImage& image)
 {
     m_d->uiWdgPaintOpPresetSettings.scratchPad->setPresetImage(image);
     saveDialog->brushPresetThumbnailWidget->setPresetImage(image);
 }
 
 void KisPaintOpPresetsPopup::hideEvent(QHideEvent *event)
 {
     if (m_d->ignoreHideEvents) {
         return;
     }
     if (m_d->detached) {
         m_d->detachedGeometry = window()->geometry();
     }
     QWidget::hideEvent(event);
 }
 
 void KisPaintOpPresetsPopup::showEvent(QShowEvent *)
 {
     if (m_d->detached) {
         window()->setGeometry(m_d->detachedGeometry);
     }
 
     emit brushEditorShown();
 }
 
 void KisPaintOpPresetsPopup::resizeEvent(QResizeEvent* event)
 {
     QWidget::resizeEvent(event);
     emit sizeChanged();
 }
 
 bool KisPaintOpPresetsPopup::detached() const
 {
     return m_d->detached;
 }
 
 void KisPaintOpPresetsPopup::slotSwitchScratchpad(bool visible)
 {
     // hide all the internal controls except the toggle button
     m_d->uiWdgPaintOpPresetSettings.scratchPad->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.paintPresetIcon->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.fillGradient->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.fillLayer->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.fillSolid->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.eraseScratchPad->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.scratchpadSidebarLabel->setVisible(visible);
 
     if (visible) {
         m_d->uiWdgPaintOpPresetSettings.showScratchpadButton->setIcon(KisIconUtils::loadIcon("arrow-left"));
     } else {
         m_d->uiWdgPaintOpPresetSettings.showScratchpadButton->setIcon(KisIconUtils::loadIcon("arrow-right"));
     }
 
     KisConfig cfg;
     cfg.setScratchpadVisible(visible);
 }
 
 void KisPaintOpPresetsPopup::slotSwitchShowEditor(bool visible) {
     m_d->uiWdgPaintOpPresetSettings.brushEditorSettingsControls->setVisible(visible);
 }
 
 void KisPaintOpPresetsPopup::slotSwitchShowPresets(bool visible) {
 
     m_d->uiWdgPaintOpPresetSettings.presetWidget->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.presetChangeViewToolButton->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.brushEgineComboBox->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.engineFilterLabel->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.presetsSidebarLabel->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.newPresetEngineButton->setVisible(visible);
     m_d->uiWdgPaintOpPresetSettings.bnBlacklistPreset->setVisible(visible);
 
     // we only want a spacer to work when the toggle icon is present. Otherwise the list of presets will shrink
     // which is something we don't want
     if (visible) {
         m_d->uiWdgPaintOpPresetSettings.presetsSpacer->changeSize(0,0, QSizePolicy::Ignored,QSizePolicy::Ignored);
         m_d->uiWdgPaintOpPresetSettings.showPresetsButton->setIcon(KisIconUtils::loadIcon("arrow-right"));
     } else {
         m_d->uiWdgPaintOpPresetSettings.presetsSpacer->changeSize(0,0, QSizePolicy::MinimumExpanding,QSizePolicy::MinimumExpanding);
         m_d->uiWdgPaintOpPresetSettings.showPresetsButton->setIcon(KisIconUtils::loadIcon("arrow-left"));
     }
 
 }
 
 void KisPaintOpPresetsPopup::slotUpdatePaintOpFilter() {
     QVariant userData = m_d->uiWdgPaintOpPresetSettings.brushEgineComboBox->currentData(); // grab paintOpID from data
     QString filterPaintOpId = userData.toString();
 
     if (filterPaintOpId == "all_options") {
         filterPaintOpId = "";
     }
     m_d->uiWdgPaintOpPresetSettings.presetWidget->setPresetFilter(filterPaintOpId);
 }
 
 void KisPaintOpPresetsPopup::slotSaveBrushPreset() {
     // here we are assuming that people want to keep their existing preset icon. We will just update the
     // settings and save a new copy with the same name.
     // there is a dialog with save options, but we don't need to show it in this situation
 
     saveDialog->useNewBrushDialog(false); // this mostly just makes sure we keep the existing brush preset name when saving
     saveDialog->loadExistingThumbnail(); // This makes sure we use the existing preset icon when updating the existing brush preset
     saveDialog->savePreset();
 
     // refresh the view settings so the brush doesn't appear dirty
     slotUpdatePresetSettings();
 }
 
 void KisPaintOpPresetsPopup::slotSaveNewBrushPreset() {
     saveDialog->useNewBrushDialog(true);
     saveDialog->saveScratchPadThumbnailArea(m_d->uiWdgPaintOpPresetSettings.scratchPad->cutoutOverlay());
     saveDialog->showDialog();
 }
 
 void KisPaintOpPresetsPopup::slotCreateNewBrushPresetEngine()
 {
     emit createPresetFromScratch(sender()->objectName());
 }
 
 void KisPaintOpPresetsPopup::updateViewSettings()
 {
     m_d->uiWdgPaintOpPresetSettings.presetWidget->smallPresetChooser->updateViewSettings();
 }
 
 void KisPaintOpPresetsPopup::currentPresetChanged(KisPaintOpPresetSP preset)
 {
     if (preset) {
         m_d->uiWdgPaintOpPresetSettings.presetWidget->smallPresetChooser->setCurrentResource(preset.data());
         setCurrentPaintOpId(preset->paintOp().id());
     }
 }
 
 void KisPaintOpPresetsPopup::updateThemedIcons()
 {
     m_d->uiWdgPaintOpPresetSettings.paintPresetIcon->setIcon(KisIconUtils::loadIcon("krita_tool_freehand"));
     m_d->uiWdgPaintOpPresetSettings.fillLayer->setIcon(KisIconUtils::loadIcon("document-new"));
     m_d->uiWdgPaintOpPresetSettings.fillLayer->hide();
     m_d->uiWdgPaintOpPresetSettings.fillGradient->setIcon(KisIconUtils::loadIcon("krita_tool_gradient"));
     m_d->uiWdgPaintOpPresetSettings.fillSolid->setIcon(KisIconUtils::loadIcon("krita_tool_color_fill"));
     m_d->uiWdgPaintOpPresetSettings.eraseScratchPad->setIcon(KisIconUtils::loadIcon("edit-delete"));
 
     m_d->uiWdgPaintOpPresetSettings.newPresetEngineButton->setIcon(KisIconUtils::loadIcon("addlayer"));
     m_d->uiWdgPaintOpPresetSettings.bnBlacklistPreset->setIcon(KisIconUtils::loadIcon("deletelayer"));
     m_d->uiWdgPaintOpPresetSettings.reloadPresetButton->setIcon(KisIconUtils::loadIcon("updateColorize")); // refresh icon
     m_d->uiWdgPaintOpPresetSettings.renameBrushPresetButton->setIcon(KisIconUtils::loadIcon("dirty-preset")); // edit icon
     m_d->uiWdgPaintOpPresetSettings.dirtyPresetIndicatorButton->setIcon(KisIconUtils::loadIcon("warning"));
 
     m_d->uiWdgPaintOpPresetSettings.newPresetEngineButton->setIcon(KisIconUtils::loadIcon("addlayer"));
     m_d->uiWdgPaintOpPresetSettings.bnBlacklistPreset->setIcon(KisIconUtils::loadIcon("deletelayer"));
     m_d->uiWdgPaintOpPresetSettings.presetChangeViewToolButton->setIcon(KisIconUtils::loadIcon("configure"));
 
     // if we cannot see the "Preset label", we know it is not visible
     // maybe this can also be stored in the config like the scratchpad?
     if (m_d->uiWdgPaintOpPresetSettings.presetsSidebarLabel->isVisible()) {
         m_d->uiWdgPaintOpPresetSettings.presetsSpacer->changeSize(0,0, QSizePolicy::Ignored,QSizePolicy::Ignored);
         m_d->uiWdgPaintOpPresetSettings.showPresetsButton->setIcon(KisIconUtils::loadIcon("arrow-right"));
     } else {
         m_d->uiWdgPaintOpPresetSettings.presetsSpacer->changeSize(0,0, QSizePolicy::MinimumExpanding,QSizePolicy::MinimumExpanding);
         m_d->uiWdgPaintOpPresetSettings.showPresetsButton->setIcon(KisIconUtils::loadIcon("arrow-left"));
     }
 
     // we store whether the scratchpad if visible in the config.
     KisConfig cfg;
     if (cfg.scratchpadVisible()) {
         m_d->uiWdgPaintOpPresetSettings.showScratchpadButton->setIcon(KisIconUtils::loadIcon("arrow-left"));
     } else {
         m_d->uiWdgPaintOpPresetSettings.showScratchpadButton->setIcon(KisIconUtils::loadIcon("arrow-right"));
     }
 }
 
 void KisPaintOpPresetsPopup::slotUpdatePresetSettings()
 {
     if (!m_d->resourceProvider) {
         return;
     }
 
     if (!m_d->resourceProvider->currentPreset()) {
         return;
     }
 
     // hide options on UI if we are creating a brush preset from scratch to prevent confusion
     if (m_d->isCreatingBrushFromScratch) {
         m_d->uiWdgPaintOpPresetSettings.dirtyPresetIndicatorButton->setVisible(false);
         m_d->uiWdgPaintOpPresetSettings.reloadPresetButton->setVisible(false);
         m_d->uiWdgPaintOpPresetSettings.saveBrushPresetButton->setVisible(false);
         m_d->uiWdgPaintOpPresetSettings.renameBrushPresetButton->setVisible(false);
     } else {
         bool isPresetDirty = m_d->resourceProvider->currentPreset()->isPresetDirty();
 
         // don't need to reload or overwrite a clean preset
         m_d->uiWdgPaintOpPresetSettings.dirtyPresetIndicatorButton->setVisible(isPresetDirty);
         m_d->uiWdgPaintOpPresetSettings.reloadPresetButton->setVisible(isPresetDirty);
         m_d->uiWdgPaintOpPresetSettings.saveBrushPresetButton->setEnabled(isPresetDirty);
         m_d->uiWdgPaintOpPresetSettings.renameBrushPresetButton->setVisible(true);
     }
 
     // update live preview area in here...
     // don't update the live preview if the widget is not visible.
     if (m_d->uiWdgPaintOpPresetSettings.liveBrushPreviewView->isVisible()) {
         m_d->uiWdgPaintOpPresetSettings.liveBrushPreviewView->setCurrentPreset(m_d->resourceProvider->currentPreset());
         m_d->uiWdgPaintOpPresetSettings.liveBrushPreviewView->updateStroke();
     }
 }
diff --git a/libs/ui/widgets/kis_paintop_presets_save.cpp b/libs/ui/widgets/kis_paintop_presets_save.cpp
index 65a8038225..e137b9231d 100644
--- a/libs/ui/widgets/kis_paintop_presets_save.cpp
+++ b/libs/ui/widgets/kis_paintop_presets_save.cpp
@@ -1,271 +1,271 @@
 /* This file is part of the KDE project
  * Copyright (C) 2017 Scott Petrovic <scottpetrovic@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "widgets/kis_paintop_presets_save.h"
 #include <QDebug>
 #include <QDate>
 #include <QTime>
 #include <QVBoxLayout>
 #include <QDialogButtonBox>
 
 
 #include <KoFileDialog.h>
 #include "KisImportExportManager.h"
 #include "QDesktopServices"
 #include "KisResourceServerProvider.h"
 #include <kis_paintop_preset_icon_library.h>
 
 
 KisPresetSaveWidget::KisPresetSaveWidget(QWidget * parent)
     : KisPaintOpPresetSaveDialog(parent)
 {
     // this is setting the area we will "capture" for saving the brush preset. It can potentially be a different
     // area that the entire scratchpad
     brushPresetThumbnailWidget->setCutoutOverlayRect(QRect(0, 0, brushPresetThumbnailWidget->height(), brushPresetThumbnailWidget->width()));
 
 
     // we will default to reusing the previous preset thumbnail
     // have that checked by default, hide the other elements, and load the last preset image
     connect(clearBrushPresetThumbnailButton, SIGNAL(clicked(bool)), brushPresetThumbnailWidget, SLOT(fillDefault()));
     connect(loadImageIntoThumbnailButton, SIGNAL(clicked(bool)), this, SLOT(loadImageFromFile()));
 
     connect(loadScratchPadThumbnailButton, SIGNAL(clicked(bool)), this, SLOT(loadScratchpadThumbnail()));
     connect(loadExistingThumbnailButton, SIGNAL(clicked(bool)), this, SLOT(loadExistingThumbnail()));
     connect(loadIconLibraryThumbnailButton, SIGNAL(clicked(bool)), this, SLOT(loadImageFromLibrary()));
 
     connect(savePresetButton, SIGNAL(clicked(bool)), this, SLOT(savePreset()));
     connect(cancelButton, SIGNAL(clicked(bool)), this, SLOT(close()));
 }
 
 KisPresetSaveWidget::~KisPresetSaveWidget()
 {
 
 }
 
 void KisPresetSaveWidget::scratchPadSetup(KisCanvasResourceProvider* resourceProvider)
 {
     m_resourceProvider = resourceProvider;
 
     brushPresetThumbnailWidget->setupScratchPad(m_resourceProvider, Qt::white);
 }
 
 void KisPresetSaveWidget::showDialog()
 {
     setModal(true);
 
     // set the name of the current brush preset area.
     KisPaintOpPresetSP preset = m_resourceProvider->currentPreset();
 
     // UI will look a bit different if we are saving a new brush
     if (m_useNewBrushDialog) {
            setWindowTitle(i18n("Save New Brush Preset"));
            newBrushNameTexField->setVisible(true);
            clearBrushPresetThumbnailButton->setVisible(true);
            loadImageIntoThumbnailButton->setVisible(true);
            currentBrushNameLabel->setVisible(false);
 
            if (preset) {
                newBrushNameTexField->setText(preset->name().append(" ").append(i18n("Copy")));
            }
 
 
     } else {
         setWindowTitle(i18n("Save Brush Preset"));
 
         if (preset) {
             currentBrushNameLabel->setText(preset->name());
         }
 
         newBrushNameTexField->setVisible(false);
         currentBrushNameLabel->setVisible(true);
     }
 
      brushPresetThumbnailWidget->paintPresetImage();
 
     show();
 }
 
 void KisPresetSaveWidget::loadImageFromFile()
 {
     // create a dialog to retrieve an image file.
     KoFileDialog dialog(0, KoFileDialog::OpenFile, "OpenDocument");
-    dialog.setMimeTypeFilters(KisImportExportManager::mimeFilter(KisImportExportManager::Import));
+    dialog.setMimeTypeFilters(KisImportExportManager::supportedMimeTypes(KisImportExportManager::Import));
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::HomeLocation));
     QString filename = dialog.filename(); // the filename() returns the entire path & file name, not just the file name
 
 
     if (filename != "") { // empty if "cancel" is pressed
         // take that file and load it into the thumbnail are
         const QImage imageToLoad(filename);
 
         brushPresetThumbnailWidget->fillTransparent(); // clear the background in case our new image has transparency
         brushPresetThumbnailWidget->paintCustomImage(imageToLoad);
     }
 
 }
 
 void KisPresetSaveWidget::loadScratchpadThumbnail()
 {
     brushPresetThumbnailWidget->paintCustomImage(scratchPadThumbnailArea);
 }
 
 void KisPresetSaveWidget::loadExistingThumbnail()
 {
     brushPresetThumbnailWidget->paintPresetImage();
 }
 
 void KisPresetSaveWidget::loadImageFromLibrary()
 {
     //add dialog code here.
     QDialog *dlg = new QDialog(this);
     dlg->setWindowTitle(i18n("Preset Icon Library"));
     QVBoxLayout *layout = new QVBoxLayout();
     dlg->setLayout(layout);
     KisPaintopPresetIconLibrary *libWidget = new KisPaintopPresetIconLibrary(dlg);
     layout->addWidget(libWidget);
     QDialogButtonBox *buttons = new QDialogButtonBox(QDialogButtonBox::Ok|QDialogButtonBox::Cancel, dlg);
     connect(buttons, SIGNAL(accepted()), dlg, SLOT(accept()));
     connect(buttons, SIGNAL(rejected()), dlg, SLOT(reject()));
     layout->addWidget(buttons);
 
     //if dialog accepted, get image.
     if (dlg->exec()==QDialog::Accepted) {
 
         QImage presetImage = libWidget->getImage();
         brushPresetThumbnailWidget->paintCustomImage(presetImage);
     }
 }
 
 void KisPresetSaveWidget::setFavoriteResourceManager(KisFavoriteResourceManager * favManager)
 {
     m_favoriteResourceManager = favManager;
 }
 
 void KisPresetSaveWidget::savePreset()
 {
     KisPaintOpPresetSP curPreset = m_resourceProvider->currentPreset();
     if (!curPreset)
         return;
 
     m_favoriteResourceManager->setBlockUpdates(true);
 
     KisPaintOpPresetSP oldPreset = curPreset->clone(); // tags are not cloned with this
     oldPreset->load();
     KisPaintOpPresetResourceServer * rServer = KisResourceServerProvider::instance()->paintOpPresetServer();
     QString saveLocation = rServer->saveLocation();
 
     // if we are saving a new brush, use what we type in for the input
     QString presetName = m_useNewBrushDialog ? newBrushNameTexField->text() : curPreset->name();
     QString currentPresetFileName = saveLocation + presetName.replace(" ", "_") + curPreset->defaultFileExtension();
     bool isSavingOverExistingPreset = rServer->resourceByName(presetName);
 
     // make a back up of the existing preset if we are saving over it
     if (isSavingOverExistingPreset) {
         QString currentDate = QDate::currentDate().toString(Qt::ISODate);
         QString currentTime = QTime::currentTime().toString(Qt::ISODate).remove(QChar(':'));
         QString presetFilename = saveLocation + presetName.replace(" ", "_") + "_backup_" + currentDate + "-" + currentTime + oldPreset->defaultFileExtension();
         oldPreset->setFilename(presetFilename);
         oldPreset->setName(presetName);
         oldPreset->setPresetDirty(false);
         oldPreset->setValid(true);
 
         // add backup resource to the blacklist
         rServer->addResource(oldPreset);
         rServer->removeResourceAndBlacklist(oldPreset.data());
 
 
         QStringList tags;
         tags = rServer->assignedTagsList(curPreset.data());
         Q_FOREACH (const QString & tag, tags) {
             rServer->addTag(oldPreset.data(), tag);
         }
     }
 
 
     if (m_useNewBrushDialog) {
         KisPaintOpPresetSP newPreset = curPreset->clone();
         newPreset->setFilename(currentPresetFileName);
         newPreset->setName(presetName);
         newPreset->setImage(brushPresetThumbnailWidget->cutoutOverlay());
         newPreset->setPresetDirty(false);
         newPreset->setValid(true);
 
 
         // keep tags if we are saving over existing preset
         if (isSavingOverExistingPreset) {
             QStringList tags;
             tags = rServer->assignedTagsList(curPreset.data());
             Q_FOREACH (const QString & tag, tags) {
                 rServer->addTag(newPreset.data(), tag);
             }
         }
 
         rServer->addResource(newPreset);
 
         // trying to get brush preset to load after it is created
         emit resourceSelected(newPreset.data());
     }
     else { // saving a preset that is replacing an existing one
 
         if (curPreset->filename().contains(saveLocation) == false || curPreset->filename().contains(presetName) == false) {
             rServer->removeResourceAndBlacklist(curPreset.data());
             curPreset->setFilename(currentPresetFileName);
             curPreset->setName(presetName);
         }
 
         if (!rServer->resourceByFilename(curPreset->filename())){
             //this is necessary so that we can get the preset afterwards.
             rServer->addResource(curPreset, false, false);
             rServer->removeFromBlacklist(curPreset.data());
         }
         if (curPreset->image().isNull()) {
             curPreset->setImage(brushPresetThumbnailWidget->cutoutOverlay());
         }
 
         // we should not load() the brush right after saving because it will reset all our saved
         // eraser size and opacity values
         curPreset->save();
     }
 
 
     // HACK ALERT! the server does not notify the observers
     // automatically, so we need to call theupdate manually!
     rServer->tagCategoryMembersChanged();
 
     m_favoriteResourceManager->setBlockUpdates(false);
 
     close(); // we are done... so close the save brush dialog
 
 }
 
 
 
 void KisPresetSaveWidget::saveScratchPadThumbnailArea(QImage image)
 {
     scratchPadThumbnailArea = image;
 }
 
 
 void KisPresetSaveWidget::useNewBrushDialog(bool show)
 {
     m_useNewBrushDialog = show;
 }
 
 
 #include "moc_kis_paintop_presets_save.cpp"
diff --git a/libs/widgets/KoResourceTaggingManager.cpp b/libs/widgets/KoResourceTaggingManager.cpp
index 79a2fa3d0c..4f60fc0156 100644
--- a/libs/widgets/KoResourceTaggingManager.cpp
+++ b/libs/widgets/KoResourceTaggingManager.cpp
@@ -1,390 +1,392 @@
 /*
  *    This file is part of the KDE project
  *    Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *    Copyright (c) 2007 Jan Hambrecht <jaham@gmx.net>
  *    Copyright (c) 2007 Sven Langkamp <sven.langkamp@gmail.com>
  *    Copyright (C) 2011 Srikanth Tiyyagura <srikanth.tulasiram@gmail.com>
  *    Copyright (c) 2011 José Luis Vergara <pentalis@gmail.com>
  *    Copyright (c) 2013 Sascha Suelzer <s.suelzer@gmail.com>
  *
  *    This library is free software; you can redistribute it and/or
  *    modify it under the terms of the GNU Library General Public
  *    License as published by the Free Software Foundation; either
  *    version 2 of the License, or (at your option) any later version.
  *
  *    This library is distributed in the hope that it will be useful,
  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *    Library General Public License for more details.
  *
  *    You should have received a copy of the GNU Library General Public License
  *    along with this library; see the file COPYING.LIB.  If not, write to
  *    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  *    Boston, MA 02110-1301, USA.
  */
 
 #include "KoResourceTaggingManager.h"
 
 #include <QInputDialog>
 #include <QMessageBox>
 #include <QPointer>
 #include <QStringList>
 
 #include <WidgetsDebug.h>
 
 #include <klocalizedstring.h>
 #include <ksharedconfig.h>
 
 #include "KoTagFilterWidget.h"
 #include "KoTagChooserWidget.h"
 #include "KoResourceModel.h"
 #include <resources/KoResource.h>
 #include "KoResourceItemChooserContextMenu.h"
 
 #include <kconfiggroup.h>
 
 class TaggedResourceSet
 {
 public:
     TaggedResourceSet()
     {}
 
     TaggedResourceSet(const QString& tagName, const QList<KoResource*>& resources)
         : tagName(tagName)
         , resources(resources)
     {}
 
     QString tagName;
     QList<KoResource*> resources;
 };
 
 
 class KoResourceTaggingManager::Private
 {
 public:
     QString currentTag;
     QList<KoResource*> originalResources;
     TaggedResourceSet lastDeletedTag;
 
     KoTagChooserWidget* tagChooser;
     KoTagFilterWidget* tagFilter;
 
     QCompleter* tagCompleter;
 
     QPointer<KoResourceModel> model;
 };
 
 
 KoResourceTaggingManager::KoResourceTaggingManager(KoResourceModel *model, QWidget* parent)
     : QObject(parent)
     , d(new Private())
 {
     d->model = model;
 
     d->tagChooser = new KoTagChooserWidget(parent);
     d->tagChooser->addReadOnlyItem("All"); // not translatable until other tags made translatable!
     d->tagChooser->addItems(d->model->tagNamesList());
 
     d->tagFilter = new KoTagFilterWidget(parent);
 
     connect(d->tagChooser, SIGNAL(tagChosen(QString)),
             this, SLOT(tagChooserIndexChanged(QString)));
     connect(d->tagChooser, SIGNAL(newTagRequested(QString)),
             this, SLOT(contextCreateNewTag(QString)));
     connect(d->tagChooser, SIGNAL(tagDeletionRequested(QString)),
             this, SLOT(removeTagFromComboBox(QString)));
     connect(d->tagChooser, SIGNAL(tagRenamingRequested(QString, QString)),
             this, SLOT(renameTag(QString, QString)));
     connect(d->tagChooser, SIGNAL(tagUndeletionRequested(QString)),
             this, SLOT(undeleteTag(QString)));
     connect(d->tagChooser, SIGNAL(tagUndeletionListPurgeRequested()),
             this, SLOT(purgeTagUndeleteList()));
 
     connect(d->tagFilter, SIGNAL(saveButtonClicked()),
             this, SLOT(tagSaveButtonPressed()));
     connect(d->tagFilter, SIGNAL(filterTextChanged(QString)),
             this, SLOT(tagSearchLineEditTextChanged(QString)));
 
     connect(d->model, SIGNAL(tagBoxEntryAdded(QString)),
             this, SLOT(syncTagBoxEntryAddition(QString)));
     connect(d->model, SIGNAL(tagBoxEntryRemoved(QString)),
             this, SLOT(syncTagBoxEntryRemoval(QString)));
     connect(d->model, SIGNAL(tagBoxEntryModified()),
             this, SLOT(syncTagBoxEntries()));
 
     // FIXME: fix tag completer
     // d->tagCompleter = new QCompleter(this);
     //  d->tagSearchLineEdit->setCompleter(d->tagCompleter);
 
     syncTagBoxEntries();
 }
 
 KoResourceTaggingManager::~KoResourceTaggingManager()
 {
     delete d;
 }
 
 void KoResourceTaggingManager::showTaggingBar(bool show)
 {
     show ? d->tagFilter->show() : d->tagFilter->hide();
     show ? d->tagChooser->show() : d->tagChooser->hide();
 
     blockSignals(!show);
 
     QString tag("All");
     if (show) {
         KConfigGroup group =  KSharedConfig::openConfig()->group("SelectedTags");
         tag = group.readEntry<QString>(d->model->serverType(), "All");
     }
     int idx = d->tagChooser->findIndexOf(tag);
     if (idx < 0) idx = 0;
     d->tagChooser->setCurrentIndex(idx);
 }
 
 void KoResourceTaggingManager::purgeTagUndeleteList()
 {
     d->lastDeletedTag = TaggedResourceSet();
     d->tagChooser->setUndeletionCandidate(QString());
 }
 
 void KoResourceTaggingManager::undeleteTag(const QString & tagToUndelete)
 {
     QString tagName = tagToUndelete;
     QStringList allTags = availableTags();
 
     if (allTags.contains(tagName)) {
         bool ok;
         tagName = QInputDialog::getText(
                     d->tagChooser, i18n("Unable to undelete tag"),
                     i18n("<qt>The tag you are trying to undelete already exists in tag list.<br>Please enter a new, unique name for it.</qt>"),
                     QLineEdit::Normal,
                     tagName, &ok);
 
         if (!ok || allTags.contains(tagName) || tagName.isEmpty()) {
             QMessageBox msgBox;
             msgBox.setIcon(QMessageBox::Warning);
             msgBox.setText(i18n("Tag was not undeleted."));
             msgBox.exec();
             return;
         }
     }
 
     QList<KoResource*> serverResources = d->model->serverResources();
 
     Q_FOREACH (KoResource * resource, d->lastDeletedTag.resources) {
         if (serverResources.contains(resource)) {
             addResourceTag(resource, tagName);
         }
     }
     d->model->tagCategoryAdded(tagName);
     d->tagChooser->setCurrentIndex(d->tagChooser->findIndexOf(tagName));
     d->tagChooser->setUndeletionCandidate(QString());
     d->lastDeletedTag = TaggedResourceSet();
 }
 
 QStringList KoResourceTaggingManager::availableTags() const
 {
     return d->tagChooser->allTags();
 }
 
 void KoResourceTaggingManager::addResourceTag(KoResource* resource, const QString& tagName)
 {
     QStringList tagsList = d->model->assignedTagsList(resource);
     if (tagsList.isEmpty()) {
         d->model->addTag(resource, tagName);
     } else {
         Q_FOREACH (const QString & tag, tagsList) {
             if (tag.compare(tagName)) {
                 d->model->addTag(resource, tagName);
             }
         }
     }
 }
 
 void KoResourceTaggingManager::syncTagBoxEntryAddition(const QString& tag)
 {
     d->tagChooser->insertItem(tag);
 }
 
 void KoResourceTaggingManager::contextCreateNewTag(const QString& tag)
 {
     if (!tag.isEmpty()) {
         d->model->addTag(0, tag);
         d->model->tagCategoryAdded(tag);
         d->tagChooser->setCurrentIndex(d->tagChooser->findIndexOf(tag));
         updateTaggedResourceView();
     }
 }
 
 void KoResourceTaggingManager::contextCreateNewTag(KoResource* resource , const QString& tag)
 {
     if (!tag.isEmpty()) {
         d->model->tagCategoryAdded(tag);
         if (resource) {
             addResourceTag(resource, tag);
         }
     }
 }
 
 void KoResourceTaggingManager::syncTagBoxEntryRemoval(const QString& tag)
 {
     d->tagChooser->removeItem(tag);
 }
 
 void KoResourceTaggingManager::syncTagBoxEntries()
 {
     QStringList tags = d->model->tagNamesList();
     tags.sort();
     Q_FOREACH (const QString &tag, tags) {
         d->tagChooser->insertItem(tag);
     }
 }
 
 void KoResourceTaggingManager::contextAddTagToResource(KoResource* resource, const QString& tag)
 {
     addResourceTag(resource, tag);
     d->model->tagCategoryMembersChanged();
     updateTaggedResourceView();
 }
 
 void KoResourceTaggingManager::contextRemoveTagFromResource(KoResource* resource, const QString& tag)
 {
     removeResourceTag(resource, tag);
     d->model->tagCategoryMembersChanged();
     updateTaggedResourceView();
 }
 
 void KoResourceTaggingManager::removeTagFromComboBox(const QString &tag)
 {
     QList<KoResource*> resources = d->model->currentlyVisibleResources();
     Q_FOREACH (KoResource * resource, resources) {
         removeResourceTag(resource, tag);
     }
     d->model->tagCategoryRemoved(tag);
     d->lastDeletedTag = TaggedResourceSet(tag, resources);
     d->tagChooser->setUndeletionCandidate(tag);
 }
 
 void KoResourceTaggingManager::removeResourceTag(KoResource* resource, const QString& tagName)
 {
     QStringList tagsList = d->model->assignedTagsList(resource);
 
     Q_FOREACH (const QString & oldName, tagsList) {
         if (!oldName.compare(tagName)) {
             d->model->deleteTag(resource, oldName);
         }
     }
 }
 
 void KoResourceTaggingManager::renameTag(const QString &oldName, const QString& newName)
 {
     if (!d->model->tagNamesList().contains(newName)) {
         QList<KoResource*> resources = d->model->currentlyVisibleResources();
 
         Q_FOREACH (KoResource * resource, resources) {
             removeResourceTag(resource, oldName);
             addResourceTag(resource, newName);
         }
         contextCreateNewTag(newName);
         d->model->tagCategoryRemoved(oldName);
         d->model->tagCategoryAdded(newName);
     }
 }
 
 void KoResourceTaggingManager::updateTaggedResourceView()
 {
     d->model->setCurrentTag(d->currentTag);
     d->model->updateServer();
     d->originalResources = d->model->currentlyVisibleResources();
     emit updateView();
 }
 
 void KoResourceTaggingManager::tagChooserIndexChanged(const QString& lineEditText)
 {
     if (!d->tagChooser->selectedTagIsReadOnly()) {
         d->currentTag = lineEditText;
         d->tagFilter->allowSave(true);
         d->model->enableResourceFiltering(true);
     } else {
         d->model->enableResourceFiltering(false);
         d->tagFilter->allowSave(false);
         d->currentTag.clear();
     }
 
     d->tagFilter->clear();
     updateTaggedResourceView();
 }
 
 void KoResourceTaggingManager::tagSearchLineEditTextChanged(const QString& lineEditText)
 {
     if (d->tagChooser->selectedTagIsReadOnly()) {
         d->model->enableResourceFiltering(!lineEditText.isEmpty());
     } else {
         d->model->enableResourceFiltering(true);
     }
 
     d->model->searchTextChanged(lineEditText);
     d->model->updateServer();
 
     ///FIXME: fix completer
     //     d->tagCompleter = new QCompleter(tagNamesList(lineEditText),this);
     //    d->tagSearchLineEdit->setCompleter(d->tagCompleter);
+
+    emit updateView();
 }
 
 void KoResourceTaggingManager::tagSaveButtonPressed()
 {
     if (!d->tagChooser->selectedTagIsReadOnly()) {
         QList<KoResource*> newResources = d->model->currentlyVisibleResources();
         Q_FOREACH (KoResource * oldRes, d->originalResources) {
             if (!newResources.contains(oldRes))
                 removeResourceTag(oldRes, d->currentTag);
         }
         Q_FOREACH (KoResource * newRes, newResources) {
             if (!d->originalResources.contains(newRes))
                 addResourceTag(newRes, d->currentTag);
         }
         d->model->tagCategoryMembersChanged();
     }
     updateTaggedResourceView();
 }
 
 void KoResourceTaggingManager::contextMenuRequested(KoResource* resource, const QStringList& resourceTags, const QPoint& pos)
 {
     /* no visible tag chooser usually means no intended tag interaction,
      * context menu makes no sense then either */
     if (!resource || !d->tagChooser->isVisible())
         return;
 
     KoResourceItemChooserContextMenu menu(resource,
                                           resourceTags,
                                           d->tagChooser->currentlySelectedTag(),
                                           d->tagChooser->allTags());
 
     connect(&menu, SIGNAL(resourceTagAdditionRequested(KoResource*, QString)),
             this, SLOT(contextAddTagToResource(KoResource*, QString)));
 
     connect(&menu, SIGNAL(resourceTagRemovalRequested(KoResource*, QString)),
             this, SLOT(contextRemoveTagFromResource(KoResource*, QString)));
 
     connect(&menu, SIGNAL(resourceAssignmentToNewTagRequested(KoResource*, QString)),
             this, SLOT(contextCreateNewTag(KoResource*, QString)));
     menu.exec(pos);
 }
 
 void KoResourceTaggingManager::contextMenuRequested(KoResource* currentResource, QPoint pos)
 {
     if (currentResource) {
         contextMenuRequested(currentResource, d->model->assignedTagsList(currentResource), pos);
     }
 }
 
 KoTagChooserWidget* KoResourceTaggingManager::tagChooserWidget()
 {
     return d->tagChooser;
 }
 
 KoTagFilterWidget* KoResourceTaggingManager::tagFilterWidget()
 {
     return d->tagFilter;
 }
 
diff --git a/libs/widgets/KoToolDocker.cpp b/libs/widgets/KoToolDocker.cpp
index c6fe02aaa2..da7c01cf91 100644
--- a/libs/widgets/KoToolDocker.cpp
+++ b/libs/widgets/KoToolDocker.cpp
@@ -1,277 +1,220 @@
 /* This file is part of the KDE project
  *
  * Copyright (c) 2010-2011 C. Boemann <cbo@boemann.dk>
  * Copyright (c) 2005-2006 Boudewijn Rempt <boud@valdyas.org>
  * Copyright (c) 2006 Thomas Zander <zander@kde.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 #include "KoToolDocker.h"
 
 #include <KoIcon.h>
 
 #include <klocalizedstring.h>
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 
 #include <QIcon>
 #include <QApplication>
 #include <QPointer>
 #include <QGridLayout>
 #include <QScrollArea>
 #include <QScrollBar>
 #include <QLabel>
 #include <QSet>
 #include <QAction>
 #include <QStyleOptionFrame>
 #include <QToolButton>
-#include <QTabWidget>
 
 #include <WidgetsDebug.h>
 #include <kis_debug.h>
 
 class Q_DECL_HIDDEN KoToolDocker::Private
 {
 public:
     Private(KoToolDocker *dock)
         : q(dock)
-        , tabbed(false)
-        , tabIcon(koIcon("tab-new"))
-        , unTabIcon(koIcon("tab-close"))
     {
     }
 
     QList<QPointer<QWidget> > currentWidgetList;
     QSet<QWidget *> currentAuxWidgets;
     QScrollArea *scrollArea;
     QWidget *hiderWidget; // non current widgets are hidden by being children of this
     QWidget *housekeeperWidget;
     QGridLayout *housekeeperLayout;
     KoToolDocker *q;
     Qt::DockWidgetArea dockingArea;
-    bool tabbed;
-    QIcon tabIcon;
-    QIcon unTabIcon;
-    QToolButton *tabButton;
-
 
     void resetWidgets()
     {
         currentWidgetList.clear();
         qDeleteAll(currentAuxWidgets);
         currentAuxWidgets.clear();
     }
 
     void recreateLayout(const QList<QPointer<QWidget> > &optionWidgetList)
     {
         Q_FOREACH (QPointer<QWidget> widget, currentWidgetList) {
             if (!widget.isNull() && widget && hiderWidget) {
                 widget->setParent(hiderWidget);
             }
         }
         qDeleteAll(currentAuxWidgets);
         currentAuxWidgets.clear();
 
         currentWidgetList = optionWidgetList;
 
         // need to unstretch row that have previously been stretched
         housekeeperLayout->setRowStretch(housekeeperLayout->rowCount()-1, 0);
 
-        if (tabbed && currentWidgetList.size() > 1) {
-            QTabWidget *t;
-            housekeeperLayout->addWidget(t = new QTabWidget(), 0, 0);
-            t->setDocumentMode(true);
-            currentAuxWidgets.insert(t);
-            Q_FOREACH (QPointer<QWidget> widget, currentWidgetList) {
-                if (widget.isNull() || widget->objectName().isEmpty()) {
-                    continue;
-                }
-                t->addTab(widget, widget->windowTitle());
-            }
-        } else {
             int cnt = 0;
             QFrame *s;
             QLabel *l;
             switch(dockingArea) {
             case Qt::TopDockWidgetArea:
             case Qt::BottomDockWidgetArea:
                 housekeeperLayout->setHorizontalSpacing(2);
                 housekeeperLayout->setVerticalSpacing(0);
                 Q_FOREACH (QPointer<QWidget> widget, currentWidgetList) {
                     if (widget.isNull() || widget->objectName().isEmpty()) {
                         continue;
                     }
                     if (!widget->windowTitle().isEmpty()) {
                         housekeeperLayout->addWidget(l = new QLabel(widget->windowTitle()), 0, 2*cnt);
                         currentAuxWidgets.insert(l);
                     }
                     housekeeperLayout->addWidget(widget, 1, 2*cnt);
                     widget->show();
                     if (widget != currentWidgetList.last()) {
                         housekeeperLayout->addWidget(s = new QFrame(), 0, 2*cnt+1, 2, 1);
                         s->setFrameShape(QFrame::VLine);
                         currentAuxWidgets.insert(s);
                     }
                     cnt++;
                 }
                 break;
             case Qt::LeftDockWidgetArea:
             case Qt::RightDockWidgetArea: {
                 housekeeperLayout->setHorizontalSpacing(0);
                 housekeeperLayout->setVerticalSpacing(2);
                 int specialCount = 0;
                 Q_FOREACH (QPointer<QWidget> widget, currentWidgetList) {
                     if (widget.isNull() || widget->objectName().isEmpty()) {
                         continue;
                     }
                     if (!widget->windowTitle().isEmpty()) {
                         housekeeperLayout->addWidget(l = new QLabel(widget->windowTitle()), cnt++, 0);
                         currentAuxWidgets.insert(l);
                     }
                     housekeeperLayout->addWidget(widget, cnt++, 0);
                     QLayout *subLayout = widget->layout();
                     if (subLayout) {
                         for (int i = 0; i < subLayout->count(); ++i) {
                             QWidget *spacerWidget = subLayout->itemAt(i)->widget();
                             if (spacerWidget && spacerWidget->objectName().contains("SpecialSpacer")) {
                                 specialCount++;
                             }
                         }
                     }
                     widget->show();
                     if (widget != currentWidgetList.last()) {
                         housekeeperLayout->addWidget(s = new QFrame(), cnt++, 0);
                         s->setFrameShape(QFrame::HLine);
                         currentAuxWidgets.insert(s);
                     }
                 }
                 if (specialCount == currentWidgetList.count() || qApp->applicationName().contains("krita")) {
                     housekeeperLayout->setRowStretch(cnt, 10000);
                 }
                 break;
             }
             default:
                 break;
             }
-        }
+
         housekeeperLayout->setSizeConstraint(QLayout::SetMinAndMaxSize);
         housekeeperLayout->invalidate();
     }
 
     void locationChanged(Qt::DockWidgetArea area)
     {
         dockingArea = area;
         recreateLayout(currentWidgetList);
     }
 
-    void toggleTab()
-    {
-        if (!tabbed) {
-            tabbed = true;
-            tabButton->setIcon(unTabIcon);
-        } else {
-            tabbed = false;
-            tabButton->setIcon(tabIcon);
-        }
-        recreateLayout(currentWidgetList);
-    }
 };
 
 KoToolDocker::KoToolDocker(QWidget *parent)
     : QDockWidget(i18n("Tool Options"), parent),
       d(new Private(this))
 {
-    KConfigGroup cfg =  KSharedConfig::openConfig()->group("DockWidget sharedtooldocker");
-    d->tabbed = cfg.readEntry("TabbedMode", false);
-
     setFeatures(DockWidgetMovable|DockWidgetFloatable);
 
     connect(this, SIGNAL(dockLocationChanged(Qt::DockWidgetArea )), this, SLOT(locationChanged(Qt::DockWidgetArea)));
 
     d->housekeeperWidget = new QWidget();
     d->housekeeperLayout = new QGridLayout();
     d->housekeeperLayout->setContentsMargins(4,4,4,0);
     d->housekeeperWidget->setLayout(d->housekeeperLayout);
 
     d->housekeeperLayout->setSizeConstraint(QLayout::SetMinAndMaxSize);
 
     d->hiderWidget = new QWidget(d->housekeeperWidget);
     d->hiderWidget->setVisible(false);
 
     d->scrollArea = new QScrollArea();
     d->scrollArea->setWidget(d->housekeeperWidget);
     d->scrollArea->setFrameShape(QFrame::NoFrame);
     d->scrollArea->setWidgetResizable(true);
     d->scrollArea->setFocusPolicy(Qt::NoFocus);
 
     setWidget(d->scrollArea);
-
-    d->tabButton = new QToolButton(this); // parent hack in toggleLock to keep it clickable
-    d->tabButton->setIcon(d->tabIcon);
-    d->tabButton->setToolTip(i18n("Toggles organizing the options in tabs or not"));
-    d->tabButton->setAutoRaise(true);
-    connect(d->tabButton, SIGNAL(clicked()), SLOT(toggleTab()));
-    d->tabButton->resize(d->tabButton->sizeHint());
 }
 
 KoToolDocker::~KoToolDocker()
 {
-    KConfigGroup cfg =  KSharedConfig::openConfig()->group("DockWidget sharedtooldocker");
-    cfg.writeEntry("TabbedMode", d->tabbed);
-    cfg.sync();
-
     delete d;
 }
 
 bool KoToolDocker::hasOptionWidget()
 {
     return !d->currentWidgetList.isEmpty();
 }
 
-void KoToolDocker::setTabEnabled(bool enabled)
-{
-    d->tabButton->setVisible(enabled);
-}
-
 void KoToolDocker::setOptionWidgets(const QList<QPointer<QWidget> > &optionWidgetList)
 {
     d->recreateLayout(optionWidgetList);
 }
 
-void KoToolDocker::resizeEvent(QResizeEvent*)
-{
-    int fw = isFloating() ? style()->pixelMetric(QStyle::PM_DockWidgetFrameWidth, 0, this) : 0;
-    d->tabButton->move(width() - d->tabButton->width() - d->scrollArea->verticalScrollBar()->sizeHint().width(), fw);
-}
-
 void KoToolDocker::resetWidgets()
 {
     d->resetWidgets();
 }
 
 
 void KoToolDocker::setCanvas(KoCanvasBase *canvas)
 {
     setEnabled(canvas != 0);
 }
 
 void KoToolDocker::unsetCanvas()
 {
     setEnabled(false);
 }
 
 //have to include this because of Q_PRIVATE_SLOT
 #include <moc_KoToolDocker.cpp>
diff --git a/libs/widgets/KoToolDocker.h b/libs/widgets/KoToolDocker.h
index d24fa7b6c7..25f9993bc1 100644
--- a/libs/widgets/KoToolDocker.h
+++ b/libs/widgets/KoToolDocker.h
@@ -1,75 +1,66 @@
 /* This file is part of the KDE project
  *
  * Copyright (c) 2005-2006 Boudewijn Rempt <boud@valdyas.org>
  * Copyright (c) 2006 Thomas Zander <zander@kde.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 #ifndef KO_TOOL_DOCKER_H
 #define KO_TOOL_DOCKER_H
 
 #include <QDockWidget>
 #include <QPointer>
 
 class QWidget;
 
 #include <kritawidgets_export.h>
 #include <KoCanvasObserverBase.h>
 /**
  * The tool docker shows the tool option widget associated with the
  * current tool and the current canvas.
  */
 class KRITAWIDGETS_EXPORT KoToolDocker : public QDockWidget, public KoCanvasObserverBase
 {
     Q_OBJECT
 public:
     explicit KoToolDocker(QWidget *parent = 0);
     ~KoToolDocker() override;
 
     void resetWidgets();
 
     /// reimplemented
     void setCanvas(KoCanvasBase *canvas) override;
     void unsetCanvas() override;
 
-
-protected:
-    void resizeEvent(QResizeEvent* event) override; ///< reimplemented from QWidget
 public Q_SLOTS:
     /**
      * Update the option widgets to the argument one, removing the currently set widget.
      */
     void setOptionWidgets(const QList<QPointer<QWidget> > &optionWidgetList);
 
     /**
      * Returns whether the docker has an optionwidget attached
      */
     bool hasOptionWidget();
 
-    /**
-     * set the tab option
-     */
-    void setTabEnabled(bool enabled);
-
 private:
-    Q_PRIVATE_SLOT(d, void toggleTab())
     Q_PRIVATE_SLOT(d, void locationChanged(Qt::DockWidgetArea area))
 
     class Private;
     Private * const d;
 };
 
 #endif
diff --git a/libs/widgetutils/kis_icon_utils.cpp b/libs/widgetutils/kis_icon_utils.cpp
index fdec00745a..408174ff81 100644
--- a/libs/widgetutils/kis_icon_utils.cpp
+++ b/libs/widgetutils/kis_icon_utils.cpp
@@ -1,222 +1,222 @@
 /*
  *  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_icon_utils.h"
 
 #include <QApplication>
 #include <QAction>
 #include <QAbstractButton>
 #include <QComboBox>
 #include <QIcon>
 #include <QFile>
 #include <QPair>
 #include <QDebug>
 
 #include <KoIcon.h>
 #if QT_VERSION >= 0x050900
 #define CACHE_ICONS
 #endif
 
 namespace KisIconUtils
 {
 
 #if defined CACHE_ICONS
 static QMap<QString, QIcon> s_cache;
 #endif
 static QMap<qint64, QString> s_icons;
 
 QIcon loadIcon(const QString &name)
 {
 #if defined CACHE_ICONS
     QMap<QString, QIcon>::const_iterator cached = s_cache.constFind(name);
     if (cached != s_cache.constEnd()) {
         return cached.value();
     }
 #endif
     // try load themed icon
 
 
     const char * const prefix = useDarkIcons() ? "dark_" : "light_";
 
     QString  realName = QLatin1String(prefix) + name;
 
     // Dark and light, no size specified
     const QStringList names = { ":/pics/" + realName + ".png",
                                 ":/pics/" + realName + ".svg",
                                 ":/pics/" + realName + ".svgz",
                                 ":/pics/" + name + ".png",
                                 ":/pics/" + name + ".svg",
                                 ":/pics/" + name + ".svz",
                                 ":/" + realName + ".png",
                                 ":/" + realName + ".svg",
                                 ":/" + realName + ".svz",
                                 ":/" + name,
                                 ":/" + name + ".png",
                                 ":/" + name + ".svg",
                                 ":/" + name + ".svgz"};
 
     for (const QString &resname : names) {
         if (QFile(resname).exists()) {
             QIcon icon(resname);
             s_icons.insert(icon.cacheKey(), name);
 #if defined CACHE_ICONS
             s_cache.insert(name, icon);
 #endif
             return icon;
         }
     }
 
     // Now check for icons with sizes
     QStringList sizes = QStringList() << "16_" << "22_" << "32_" << "48_" << "64_" << "128_" << "256_" << "512_" << "1048_";
     QVector<QPair<QString, QString> > icons;
     Q_FOREACH (const QString &size, sizes) {
         const QStringList names = { ":/pics/" + size + realName + ".png",
                                     ":/pics/" + size + realName + ".svg",
                                     ":/pics/" + size + realName + ".svgz",
                                     ":/pics/" + size + name + ".png",
                                     ":/pics/" + size + name + ".svg",
                                     ":/pics/" + size + name + ".svz",
                                     ":/" + size + realName + ".png",
                                     ":/" + size + realName + ".svg",
                                     ":/" + size + realName + ".svz",
                                     ":/" + size + name,
                                     ":/" + size + name + ".png",
                                     ":/" + size + name + ".svg",
                                     ":/" + size + name + ".svgz"};
 
         for (const QString &resname : names) {
             if (QFile(resname).exists()) {
                 icons << qMakePair(size, resname);
             }
         }
     }
 
     if (!icons.isEmpty()) {
         QIcon icon;
         Q_FOREACH (auto p, icons) {
             QString sz = p.first;
             sz.chop(1);
             int size = sz.toInt();
             icon.addFile(p.second, QSize(size, size));
         }
         s_icons.insert(icon.cacheKey(), name);
 #if defined CACHE_ICONS
         s_cache.insert(name, icon);
 #endif
         return icon;
     }
 
     QIcon icon = QIcon::fromTheme(name);
-    qWarning() << "\tfalling back on QIcon::FromTheme:" << name;
+    //qDebug() << "falling back on QIcon::FromTheme:" << name;
     s_icons.insert(icon.cacheKey(), name);
 #if defined CACHE_ICONS
     s_cache.insert(name, icon);
 #endif
     return icon;
 }
 
 
 
 
 bool useDarkIcons() {
     QColor background = qApp->palette().background().color();
     return  background.value() > 100;
 }
 
 bool adjustIcon(QIcon *icon)
 {
     bool result = false;
 
     QString iconName = icon->name();
     if (iconName.isNull()) {
         if (s_icons.contains(icon->cacheKey())) {
             iconName = s_icons.take(icon->cacheKey());
         }
     }
 
     QString realIconName = iconName;
 
     if (iconName.startsWith("dark_")) {
         realIconName = iconName.mid(5);
     }
 
     if (iconName.startsWith("light_")) {
         realIconName = iconName.mid(6);
     }
 
     if (!realIconName.isNull()) {
         *icon = loadIcon(realIconName);
         result = !icon->isNull();
         s_icons.insert(icon->cacheKey(), iconName);
     }
 
     return result;
 }
 
 void updateIconCommon(QObject *object)
 {
     QAbstractButton* button = qobject_cast<QAbstractButton*>(object);
     if (button) {
         updateIcon(button);
     }
 
     QComboBox* comboBox = qobject_cast<QComboBox*>(object);
     if (comboBox) {
         updateIcon(comboBox);
     }
 
     QAction* action = qobject_cast<QAction*>(object);
     if (action) {
         updateIcon(action);
     }
 }
 
 void clearIconCache() {
     #if defined CACHE_ICONS
         s_cache.clear();
     #endif
 }
 
 void updateIcon(QAbstractButton *button)
 {
     QIcon icon = button->icon();
 
     if (adjustIcon(&icon)) {
         button->setIcon(icon);
     }
 }
 
 void updateIcon(QComboBox *comboBox)
 {
     for (int i = 0; i < comboBox->count(); i++) {
         QIcon icon = comboBox->itemIcon(i);
         if (adjustIcon(&icon)) {
             comboBox->setItemIcon(i, icon);
         }
     }
 }
 
 void updateIcon(QAction *action)
 {
     QIcon icon = action->icon();
 
     if (adjustIcon(&icon)) {
         action->setIcon(icon);
     }
 }
 }
diff --git a/libs/widgetutils/xmlgui/kcheckaccelerators.cpp b/libs/widgetutils/xmlgui/kcheckaccelerators.cpp
index 33afe67ee4..596af2f4ba 100644
--- a/libs/widgetutils/xmlgui/kcheckaccelerators.cpp
+++ b/libs/widgetutils/xmlgui/kcheckaccelerators.cpp
@@ -1,317 +1,317 @@
 /* This file is part of the KDE libraries
     Copyright (C) 1997 Matthias Kalle Dalheimer (kalle@kde.org)
     Copyright (C) 1998, 1999, 2000 KDE Team
     Copyright (C) 2008 Nick Shaforostoff <shaforostoff@kde.ru>
 
     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 "kcheckaccelerators.h"
 
 #include <QApplication>
 #include <QCheckBox>
 #include <QDialog>
 #include <QShortcutEvent>
 #include <QMouseEvent>
 #include <QLayout>
 #include <QMenuBar>
 #include <QPushButton>
 #include <QTabBar>
 #include <QTextBrowser>
 #include <QChar>
 #include <QLabel>
 #include <QComboBox>
 #include <QGroupBox>
 #include <QClipboard>
 #include <QProcess>
+#include <QDialogButtonBox>
 
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 #include <klocalizedstring.h>
 #include <kacceleratormanager.h>
 
 class KCheckAcceleratorsInitializer : public QObject
 {
     Q_OBJECT
 public:
     explicit KCheckAcceleratorsInitializer(QObject *parent = Q_NULLPTR)
         : QObject(parent)
     {
     }
 
 public Q_SLOTS:
     void initiateIfNeeded()
     {
         KConfigGroup cg(KSharedConfig::openConfig(), "Development");
         QString sKey = cg.readEntry("CheckAccelerators").trimmed();
         int key = 0;
         if (!sKey.isEmpty()) {
             QList<QKeySequence> cuts = QKeySequence::listFromString(sKey);
             if (!cuts.isEmpty()) {
                 key = cuts.first()[0];
             }
         }
         const bool autoCheck = cg.readEntry("AutoCheckAccelerators", true);
         const bool copyWidgetText = cg.readEntry("CopyWidgetText", false);
         if (!copyWidgetText && key == 0 && !autoCheck) {
             deleteLater();
             return;
         }
 
         new KCheckAccelerators(qApp, key, autoCheck, copyWidgetText);
         deleteLater();
     }
 };
 
 static void startupFunc()
 {
     // Call initiateIfNeeded once we're in the event loop
     // This is to prevent using KSharedConfig before main() can set the app name
     QCoreApplication *app = QCoreApplication::instance();
     KCheckAcceleratorsInitializer *initializer = new KCheckAcceleratorsInitializer(app);
     QMetaObject::invokeMethod(initializer, "initiateIfNeeded", Qt::QueuedConnection);
 }
 
 Q_COREAPP_STARTUP_FUNCTION(startupFunc)
 
 KCheckAccelerators::KCheckAccelerators(QObject *parent, int key_, bool autoCheck_, bool copyWidgetText_)
     : QObject(parent)
     , key(key_)
     , block(false)
     , autoCheck(autoCheck_)
     , copyWidgetText(copyWidgetText_)
     , drklash(0)
 {
     setObjectName(QStringLiteral("kapp_accel_filter"));
 
     KConfigGroup cg(KSharedConfig::openConfig(), "Development");
     alwaysShow = cg.readEntry("AlwaysShowCheckAccelerators", false);
     copyWidgetTextCommand = cg.readEntry("CopyWidgetTextCommand", QString());
 
     parent->installEventFilter(this);
     connect(&autoCheckTimer, SIGNAL(timeout()), SLOT(autoCheckSlot()));
 }
 
 bool KCheckAccelerators::eventFilter(QObject *obj, QEvent *e)
 {
     if (block) {
         return false;
     }
 
     switch (e->type()) {   // just simplify debuggin
     case QEvent::ShortcutOverride:
         if (key && (static_cast<QKeyEvent *>(e)->key() == key)) {
             block = true;
             checkAccelerators(false);
             block = false;
             e->accept();
             return true;
         }
         break;
     case QEvent::ChildAdded:
     case QEvent::ChildRemoved:
         // Only care about widgets; this also avoids starting the timer in other threads
         if (!static_cast<QChildEvent *>(e)->child()->isWidgetType()) {
             break;
         }
     // fall-through
     case QEvent::Resize:
     case QEvent::LayoutRequest:
     case QEvent::WindowActivate:
     case QEvent::WindowDeactivate:
         if (autoCheck) {
             autoCheckTimer.setSingleShot(true);
             autoCheckTimer.start(20);   // 20 ms
         }
         break;
     //case QEvent::MouseButtonDblClick:
     case QEvent::MouseButtonPress:
         if (copyWidgetText && static_cast<QMouseEvent *>(e)->button() == Qt::MidButton) {
             //kWarning()<<"obj"<<obj;
             QWidget *w = static_cast<QWidget *>(obj)->childAt(static_cast<QMouseEvent *>(e)->pos());
             if (!w) {
                 w = static_cast<QWidget *>(obj);
             }
             if (!w) {
                 return false;
             }
             //kWarning()<<"MouseButtonDblClick"<<w;
             QString text;
             if (qobject_cast<QLabel *>(w)) {
                 text = static_cast<QLabel *>(w)->text();
             } else if (qobject_cast<QAbstractButton *>(w)) {
                 text = static_cast<QAbstractButton *>(w)->text();
             } else if (qobject_cast<QComboBox *>(w)) {
                 text = static_cast<QComboBox *>(w)->currentText();
             } else if (qobject_cast<QTabBar *>(w)) {
                 text = static_cast<QTabBar *>(w)->tabText(static_cast<QTabBar *>(w)->tabAt(static_cast<QMouseEvent *>(e)->pos()));
             } else if (qobject_cast<QGroupBox *>(w)) {
                 text = static_cast<QGroupBox *>(w)->title();
             } else if (qobject_cast<QMenu *>(obj)) {
                 QAction *a = static_cast<QMenu *>(obj)->actionAt(static_cast<QMouseEvent *>(e)->pos());
                 if (!a) {
                     return false;
                 }
                 text = a->text();
                 if (text.isEmpty()) {
                     text = a->iconText();
                 }
             }
             if (text.isEmpty()) {
                 return false;
             }
 
             if (static_cast<QMouseEvent *>(e)->modifiers() == Qt::ControlModifier) {
                 text.remove(QChar::fromLatin1('&'));
             }
 
             //kWarning()<<KGlobal::activeComponent().catalogName()<<text;
             if (copyWidgetTextCommand.isEmpty()) {
                 QClipboard *clipboard = QApplication::clipboard();
                 clipboard->setText(text);
             } else {
                 QProcess *script = new QProcess(this);
                 script->start(copyWidgetTextCommand.arg(text).arg(QFile::decodeName(KLocalizedString::applicationDomain())));
                 connect(script, SIGNAL(finished(int,QProcess::ExitStatus)), script, SLOT(deleteLater()));
             }
             e->accept();
             return true;
 
             //kWarning()<<"MouseButtonDblClick"<<static_cast<QWidget*>(obj)->childAt(static_cast<QMouseEvent*>(e)->globalPos());
         }
         return false;
     case QEvent::Timer:
     case QEvent::MouseMove:
     case QEvent::Paint:
         return false;
     default:
         // qDebug() << "KCheckAccelerators::eventFilter " << e->type() << " " << autoCheck;
         break;
     }
     return false;
 }
 
 void KCheckAccelerators::autoCheckSlot()
 {
     if (block) {
         autoCheckTimer.setSingleShot(true);
         autoCheckTimer.start(20);
         return;
     }
     block = true;
     checkAccelerators(!alwaysShow);
     block = false;
 }
 
 void KCheckAccelerators::createDialog(QWidget *actWin, bool automatic)
 {
     if (drklash) {
         return;
     }
 
     drklash = new QDialog(actWin);
     drklash->setAttribute(Qt::WA_DeleteOnClose);
     drklash->setObjectName(QStringLiteral("kapp_accel_check_dlg"));
     drklash->setWindowTitle(i18nc("@title:window", "Dr. Klash' Accelerator Diagnosis"));
     drklash->resize(500, 460);
     QVBoxLayout *layout = new QVBoxLayout(drklash);
     drklash_view = new QTextBrowser(drklash);
     layout->addWidget(drklash_view);
     QCheckBox *disableAutoCheck = 0;
     if (automatic)  {
         disableAutoCheck = new QCheckBox(i18nc("@option:check", "Disable automatic checking"), drklash);
         connect(disableAutoCheck, SIGNAL(toggled(bool)), SLOT(slotDisableCheck(bool)));
         layout->addWidget(disableAutoCheck);
     }
-    QPushButton *btnClose = new QPushButton(i18nc("@action:button", "Close"), drklash);
-    btnClose->setDefault(true);
-    layout->addWidget(btnClose);
-    connect(btnClose, SIGNAL(clicked()), drklash, SLOT(close()));
+    QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Close, drklash);
+    layout->addWidget(buttonBox);
+    connect(buttonBox, SIGNAL(rejected()), drklash, SLOT(close()));
     if (disableAutoCheck) {
         disableAutoCheck->setFocus();
     } else {
         drklash_view->setFocus();
     }
 }
 
 void KCheckAccelerators::slotDisableCheck(bool on)
 {
     autoCheck = !on;
     if (!on) {
         autoCheckSlot();
     }
 }
 
 void KCheckAccelerators::checkAccelerators(bool automatic)
 {
     QWidget *actWin = qApp->activeWindow();
     if (!actWin) {
         return;
     }
 
     KAcceleratorManager::manage(actWin);
     QString a, c, r;
     KAcceleratorManager::last_manage(a, c,  r);
 
     if (automatic) { // for now we only show dialogs on F12 checks
         return;
     }
 
     if (c.isEmpty() && r.isEmpty() && (automatic || a.isEmpty())) {
         return;
     }
 
     QString s;
 
     if (! c.isEmpty())  {
         s += i18n("<h2>Accelerators changed</h2>");
         s += QStringLiteral("<table border><tr><th><b>");
         s += i18n("Old Text");
         s += QStringLiteral("</b></th><th><b>");
         s += i18n("New Text");
         s += QStringLiteral("</b></th></tr>");
         s += c;
         s += QStringLiteral("</table>");
     }
 
     if (! r.isEmpty())  {
         s += i18n("<h2>Accelerators removed</h2>");
         s += QStringLiteral("<table border><tr><th><b>");
         s += i18n("Old Text");
         s += QStringLiteral("</b></th></tr>");
         s += r;
         s += QStringLiteral("</table>");
     }
 
     if (! a.isEmpty())  {
         s += i18n("<h2>Accelerators added (just for your info)</h2>");
         s += QStringLiteral("<table border><tr><th><b>");
         s += i18n("New Text");
         s += QStringLiteral("</b></th></tr>");
         s += a;
         s += QStringLiteral("</table>");
     }
 
     createDialog(actWin, automatic);
     drklash_view->setHtml(s);
     drklash->show();
     drklash->raise();
 
     // dlg will be destroyed before returning
 }
 
 #include "kcheckaccelerators.moc"
diff --git a/plugins/dockers/CMakeLists.txt b/plugins/dockers/CMakeLists.txt
index 6dd261fcca..9429916ba7 100644
--- a/plugins/dockers/CMakeLists.txt
+++ b/plugins/dockers/CMakeLists.txt
@@ -1,32 +1,31 @@
 add_subdirectory(defaultdockers)
 add_subdirectory(smallcolorselector)
 add_subdirectory(specificcolorselector)
 add_subdirectory(digitalmixer)
 add_subdirectory(advancedcolorselector)
 add_subdirectory(presetdocker)
 add_subdirectory(historydocker)
 add_subdirectory(channeldocker)
 add_subdirectory(artisticcolorselector)
 add_subdirectory(tasksetdocker)
 add_subdirectory(compositiondocker)
 add_subdirectory(patterndocker)
 add_subdirectory(griddocker)
 add_subdirectory(arrangedocker)
 if(HAVE_OCIO)
     add_subdirectory(lut)
 endif()
 add_subdirectory(overview)
 add_subdirectory(palettedocker)
-add_subdirectory(colorslider)
 add_subdirectory(animation)
 add_subdirectory(presethistory)
 add_subdirectory(svgcollectiondocker)
 add_subdirectory(histogram)
 if(NOT APPLE AND HAVE_QT_QUICK)
     add_subdirectory(touchdocker)
     option(ENABLE_CPU_THROTTLE "Build the CPU Throttle Docker" OFF)
     if (ENABLE_CPU_THROTTLE)
         add_subdirectory(throttle)
     endif()
 endif()
 
diff --git a/plugins/dockers/animation/timeline_insert_keyframe_dialog.cpp b/plugins/dockers/animation/timeline_insert_keyframe_dialog.cpp
index cb66d5b68b..1cf6af47ea 100644
--- a/plugins/dockers/animation/timeline_insert_keyframe_dialog.cpp
+++ b/plugins/dockers/animation/timeline_insert_keyframe_dialog.cpp
@@ -1,94 +1,90 @@
 /*
  *  Copyright (c) 2018 Emmet O'Neill <emmetoneill.pdx@gmail.com>
  *  Copyright (c) 2018 Eoin O'Neill <eoinoneill1991@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "timeline_insert_keyframe_dialog.h"
 #include "timeline_frames_view.h"
 
 #include <QLabel>
 #include <QGroupBox>
 #include <QSpinBox>
 #include <QRadioButton>
 #include <QDialogButtonBox>
 #include <QVBoxLayout>
 #include <QFormLayout>
 #include <klocalizedstring.h>
 
 TimelineInsertKeyframeDialog::TimelineInsertKeyframeDialog(QWidget *parent) :
     QDialog(parent)
 {
     setWindowTitle(i18nc("@title:window","Insert Keyframes"));
     setModal(true);
     setLayout(new QVBoxLayout(this));
-
     {   // Count and Spacing Forms.
         QWidget *forms = new QWidget(this);
         layout()->addWidget(forms);
 
         frameCountSpinbox.setMinimum(1);
         frameCountSpinbox.setValue(1);
 
         frameTimingSpinbox.setMinimum(1);
         frameTimingSpinbox.setValue(1);
 
-        QFormLayout *LO = new QFormLayout(this);
-        forms->setLayout(LO);
+        QFormLayout *LO = new QFormLayout(forms);
+
 
         LO->addRow(QString(i18nc("@label:spinbox", "Number of frames:")), &frameCountSpinbox);
         LO->addRow(QString(i18nc("@label:spinbox", "Frame timing:")), &frameTimingSpinbox);
     }
-
     {   // Side Buttons.
         QGroupBox *sideRadioButtons = new QGroupBox(i18nc("@label:group","Side:"), this);
         layout()->addWidget(sideRadioButtons);
 
         leftBefore = new QRadioButton(i18nc("@label:radio", "Left / Before"), sideRadioButtons);
         rightAfter = new QRadioButton(i18nc("@label:radio", "Right / After"), sideRadioButtons);
         leftBefore->setChecked(true);
 
-        QVBoxLayout *LO = new QVBoxLayout(this);
-        sideRadioButtons->setLayout(LO);
+        QVBoxLayout *LO = new QVBoxLayout(sideRadioButtons);
 
         LO->addWidget(leftBefore);
         LO->addWidget(rightAfter);
     }
-
     {   // Cancel / OK Buttons.
         QDialogButtonBox *buttonbox = new QDialogButtonBox(QDialogButtonBox::Cancel | QDialogButtonBox::Ok);
         layout()->addWidget(buttonbox);
 
         connect(buttonbox, SIGNAL(accepted()), this, SLOT(accept()));
         connect(buttonbox, SIGNAL(rejected()), this, SLOT(reject()));
     }
 }
 
 bool TimelineInsertKeyframeDialog::promptUserSettings(int &out_count, int &out_timing, TimelineDirection &out_direction)
 {
     if (exec() == QDialog::Accepted) {
         out_count = frameCountSpinbox.value();
         out_timing = frameTimingSpinbox.value();
 
         out_direction = TimelineDirection::LEFT; // Default
         if (rightAfter && rightAfter->isChecked()) {
             out_direction = TimelineDirection::RIGHT;
         }
 
         return true;
     }
     return false;
 }
diff --git a/plugins/dockers/colorslider/CMakeLists.txt b/plugins/dockers/colorslider/CMakeLists.txt
deleted file mode 100644
index 1e5cdf1c02..0000000000
--- a/plugins/dockers/colorslider/CMakeLists.txt
+++ /dev/null
@@ -1,13 +0,0 @@
-set(kritacolorslider_SOURCES
-    kis_color_slider.cpp
-    kis_color_slider_dock.cpp
-    kis_color_slider_widget.cpp
-    kis_color_slider_input.cpp
-    kis_color_slider_input.cpp
-    kis_hsv_slider.cpp
-
-)
-
-add_library(kritacolorslider MODULE ${kritacolorslider_SOURCES})
-target_link_libraries(kritacolorslider kritaui ${OPENEXR_LIBRARIES})
-install(TARGETS kritacolorslider  DESTINATION ${KRITA_PLUGIN_INSTALL_DIR})
diff --git a/plugins/dockers/colorslider/kis_color_slider.cpp b/plugins/dockers/colorslider/kis_color_slider.cpp
deleted file mode 100644
index 5af64ce658..0000000000
--- a/plugins/dockers/colorslider/kis_color_slider.cpp
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- *  Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
- *  Copyright (c) 2014 Wolthera van Hövell <griffinvalley@gmail.com>
- *
- *  This library is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser General Public License as published by
- *  the Free Software Foundation; version 2.1 of the License.
- *
- *  This library is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU Lesser General Public License for more details.
- *
- *  You should have received a copy of the GNU Lesser General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-
-#include "kis_color_slider.h"
-#include <stdlib.h>
-
-#include <QTimer>
-
-
-#include <kis_debug.h>
-#include <kpluginfactory.h>
-#include <klocalizedstring.h>
-
-#include <KoDockFactoryBase.h>
-#include <KoDockRegistry.h>
-
-#include "kis_config.h"
-#include "kis_cursor.h"
-#include "kis_global.h"
-#include "kis_types.h"
-#include "KisViewManager.h"
-
-#include "kis_color_slider_dock.h"
-
-K_PLUGIN_FACTORY_WITH_JSON(ColorSliderPluginFactory, "krita_colorslider.json", registerPlugin<ColorSliderPlugin>();)
-
-class ColorSliderDockFactory : public KoDockFactoryBase
-{
-public:
-    ColorSliderDockFactory() {
-    }
-
-    QString id() const override {
-        return QString("ColorSlider");
-    }
-
-    virtual Qt::DockWidgetArea defaultDockWidgetArea() const {
-        return Qt::RightDockWidgetArea;
-    }
-
-    QDockWidget* createDockWidget() override {
-        ColorSliderDock * dockWidget = new ColorSliderDock();
-
-        dockWidget->setObjectName(id());
-
-        return dockWidget;
-    }
-
-    KoDockFactoryBase::DockPosition defaultDockPosition() const override {
-        return DockMinimized;
-    }
-};
-
-
-ColorSliderPlugin::ColorSliderPlugin(QObject *parent, const QVariantList &)
-        : QObject(parent)
-{
-    dbgPlugins << "ColorSliderPlugin";
-
-    KoDockRegistry::instance()->add(new ColorSliderDockFactory());
-}
-
-ColorSliderPlugin::~ColorSliderPlugin()
-{
-}
-
-#include "kis_color_slider.moc"
diff --git a/plugins/dockers/colorslider/kis_color_slider.h b/plugins/dockers/colorslider/kis_color_slider.h
deleted file mode 100644
index ff2ecfe3bf..0000000000
--- a/plugins/dockers/colorslider/kis_color_slider.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- *  Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
- *  Copyright (c) 2014 Wolthera van Hövell <griffinvalley@gmail.com>
- *
- *  This library is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser General Public License as published by
- *  the Free Software Foundation; version 2.1 of the License.
- *
- *  This library is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU Lesser General Public License for more details.
- *
- *  You should have received a copy of the GNU Lesser General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-
-#ifndef _COLORSLIDER_H_
-#define _COLORSLIDER_H_
-
-#include <QObject>
-#include <QVariant>
-
-class KisViewManager;
-
-/**
- * Template of view plugin
- */
-class ColorSliderPlugin : public QObject
-{
-    Q_OBJECT
-public:
-    ColorSliderPlugin(QObject *parent, const QVariantList &);
-    ~ColorSliderPlugin() override;
-private:
-    KisViewManager* m_view;
-};
-
-#endif
diff --git a/plugins/dockers/colorslider/kis_color_slider_dock.cpp b/plugins/dockers/colorslider/kis_color_slider_dock.cpp
deleted file mode 100644
index d1e939009d..0000000000
--- a/plugins/dockers/colorslider/kis_color_slider_dock.cpp
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
- *  Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
- *  Copyright (c) 2014 Wolthera van Hövell <griffinvalley@gmail.com>
- *  Copyright (c) 2015 Moritz Molch <kde@moritzmolch.de>
- *
- *  This library is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser General Public License as published by
- *  the Free Software Foundation; version 2.1 of the License.
- *
- *  This library is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU Lesser General Public License for more details.
- *
- *  You should have received a copy of the GNU Lesser General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-
-#include "kis_color_slider_dock.h"
-
-//#include <QWidget>
-#include <QVBoxLayout>
-#include <QBitArray>
-
-#include <ksharedconfig.h>
-#include <klocalizedstring.h>
-#include <kconfig.h>
-#include "kis_config_notifier.h"
-#include <kconfiggroup.h>
-
-#include <kis_layer.h>
-#include <KisViewManager.h>
-#include <canvas/kis_canvas2.h>
-#include <kis_canvas_resource_provider.h>
-#include <kis_image.h>
-#include <kis_display_color_converter.h>
-
-#include "kis_color_slider_widget.h"
-
-ColorSliderDock::ColorSliderDock()
-    : QDockWidget(i18n("Color Sliders"))
-    , m_canvas(0)
-    , m_view(0)
-    , m_colorSliders(0)
-{
-}
-
-void ColorSliderDock::setCanvas(KoCanvasBase *canvas)
-{
-    setEnabled(canvas != 0);
-
-    if (m_canvas) {
-        m_canvas->disconnectCanvasObserver(this);
-    }
-    if (m_view) {
-        m_canvasConnections.clear();
-    }
-
-    KisCanvas2* kisCanvas = dynamic_cast<KisCanvas2*>(canvas);
-    if (kisCanvas) {
-        KisViewManager* view = kisCanvas->viewManager();
-
-        if (m_colorSliders) {
-            m_colorSliders->disconnect(); // explicit disconnect in case Qt gets confused.
-            delete m_colorSliders;
-        }
-        QWidget *m_sliderdockerwidget = new QWidget;
-        QVBoxLayout *m_layout = new QVBoxLayout(m_sliderdockerwidget);
-        m_layout->setContentsMargins(4,4,4,0);
-        m_layout->setSpacing(1);
-        setWidget(m_sliderdockerwidget);
-        //m_updateAllowed = true;
-
-        //settings//
-        QBitArray m_SlidersConfigArray(12);
-
-        KConfigGroup cfg =  KSharedConfig::openConfig()->group("hsxColorSlider");
-
-        m_SlidersConfigArray[0] =cfg.readEntry("hsvH", false);
-        m_SlidersConfigArray[1] =cfg.readEntry("hsvS", false);
-        m_SlidersConfigArray[2] =cfg.readEntry("hsvV", false);
-
-        m_SlidersConfigArray[3] =cfg.readEntry("hslH", true);
-        m_SlidersConfigArray[4] =cfg.readEntry("hslS", true);
-        m_SlidersConfigArray[5] =cfg.readEntry("hslL", true);
-
-        m_SlidersConfigArray[6] =cfg.readEntry("hsiH", false);
-        m_SlidersConfigArray[7] =cfg.readEntry("hsiS", false);
-        m_SlidersConfigArray[8] =cfg.readEntry("hsiI", false);
-
-        m_SlidersConfigArray[9] =cfg.readEntry("hsyH", false);
-        m_SlidersConfigArray[10]=cfg.readEntry("hsyS", false);
-        m_SlidersConfigArray[11]=cfg.readEntry("hsyY", false);
-
-
-        m_colorSliders = new KisColorSliderWidget(kisCanvas->displayColorConverter()->displayRendererInterface(), this, kisCanvas, m_SlidersConfigArray);
-        m_layout->addWidget(m_colorSliders);
-
-        m_canvasConnections.addConnection(m_colorSliders, SIGNAL(colorChanged(const KoColor&)), view->resourceProvider(), SLOT(slotSetFGColor(const KoColor&)));
-        m_canvasConnections.addConnection(view->resourceProvider(), SIGNAL(sigFGColorChanged(const KoColor&)), m_colorSliders, SLOT(setColor(const KoColor&)));
-        m_canvasConnections.addConnection(kisCanvas->displayColorConverter(), SIGNAL(displayConfigurationChanged()), this, SLOT(udpateSliders()));
-        m_canvasConnections.addConnection(KisConfigNotifier::instance(), SIGNAL(configChanged()), m_colorSliders, SLOT(slotConfigChanged()));
-
-        m_canvas = kisCanvas;
-        m_view = view;
-    }
-}
-
-
-void ColorSliderDock::unsetCanvas()
-{
-    setEnabled(false);
-    m_canvas = 0;
-    m_view = 0;
-
-    delete m_colorSliders;
-    m_colorSliders = 0;
-}
-
-void ColorSliderDock::udpateSliders()
-{
-    if (!m_colorSliders) return;
-    m_colorSliders->setColor(m_view->resourceProvider()->fgColor());
-}
-
-
-#include "moc_kis_color_slider_dock.cpp"
-
-
-
diff --git a/plugins/dockers/colorslider/kis_color_slider_dock.h b/plugins/dockers/colorslider/kis_color_slider_dock.h
deleted file mode 100644
index 4bc1f3fbe0..0000000000
--- a/plugins/dockers/colorslider/kis_color_slider_dock.h
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- *  Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
- *  Copyright (c) 2014 Wolthera van Hövell <griffinvalley@gmail.com>
- *
- *  This library is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser General Public License as published by
- *  the Free Software Foundation; version 2.1 of the License.
- *
- *  This library is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU Lesser General Public License for more details.
- *
- *  You should have received a copy of the GNU Lesser General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-
-#ifndef _COLORSLIDER_DOCK_H_
-#define _COLORSLIDER_DOCK_H_
-
-#include <QDockWidget>
-#include <QPointer>
-#include <KoCanvasObserverBase.h>
-#include "kis_signal_auto_connection.h"
-
-#include <kis_types.h>
-#include <kis_canvas2.h>
-
-class KisViewManager;
-class KisColorSliderWidget;
-
-class ColorSliderDock : public QDockWidget, public KoCanvasObserverBase
-{
-    Q_OBJECT
-public:
-    ColorSliderDock();
-    QString observerName() override { return "ColorSliderDock"; }
-    /// reimplemented from KoCanvasObserverBase
-    void setCanvas(KoCanvasBase *canvas) override;
-    void unsetCanvas() override;
-public Q_SLOTS:
-    void udpateSliders();
-
-private:
-    QPointer<KisCanvas2> m_canvas;
-    KisViewManager *m_view;
-    KisColorSliderWidget* m_colorSliders;
-    KisSignalAutoConnectionsStore m_canvasConnections;
-};
-
-
-#endif
diff --git a/plugins/dockers/colorslider/kis_color_slider_input.cpp b/plugins/dockers/colorslider/kis_color_slider_input.cpp
deleted file mode 100644
index 1054cc0beb..0000000000
--- a/plugins/dockers/colorslider/kis_color_slider_input.cpp
+++ /dev/null
@@ -1,709 +0,0 @@
-/*
- *  Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
- *  Copyright (c) 2014 Wolthera van Hövell <griffinvalley@gmail.com>
- *  Copyright (c) 2015 Moritz Molch <kde@moritzmolch.de>
- *
- *  This library is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser General Public License as published by
- *  the Free Software Foundation; version 2.1 of the License.
- *
- *  This library is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU Lesser General Public License for more details.
- *
- *  You should have received a copy of the GNU Lesser General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-
-#include "kis_color_slider_input.h"
-
-#include <KoConfig.h>
-#ifdef HAVE_OPENEXR
-#include <half.h>
-#endif
-
-#include <cmath>
-
-#include <kis_debug.h>
-
-#include <QHBoxLayout>
-#include <QLabel>
-#include <QFontMetrics>
-
-#include <klocalizedstring.h>
-#include <kconfiggroup.h>
-#include <ksharedconfig.h>
-
-#include <QDoubleSpinBox>
-
-#include <KoColor.h>
-#include <KoColorSpace.h>
-
-#include "kis_hsv_slider.h"
-#include "kis_display_color_converter.h"
-
-#include "kis_double_parse_spin_box.h"
-
-KisColorSliderInput::KisColorSliderInput(QWidget* parent, KoColor* color, const int type, KoColorDisplayRendererInterface *displayRenderer, KisCanvas2* canvas)
-    : QWidget(parent),
-    m_type(type),
-    m_color(color),
-    m_displayRenderer(displayRenderer),
-    m_canvas(canvas)
-{
-    //init
-}
-
-void KisColorSliderInput::init()
-{
-    QHBoxLayout* m_layout = new QHBoxLayout(this);
-    m_layout->setContentsMargins(0, 0, 0, 0);
-    m_layout->setSpacing(1);
-
-    QString m_name;
-    switch (m_type){
-    case 0: m_name=i18n("Hue"); break;
-    case 1: m_name=i18n("Saturation"); break;
-    case 2: m_name=i18nc("HSV Value","Value"); break;
-    case 3: m_name=i18n("Hue"); break;
-    case 4: m_name=i18n("Saturation"); break;
-    case 5: m_name=i18n("Lightness"); break;
-    case 6: m_name=i18n("Hue"); break;
-    case 7: m_name=i18n("Saturation"); break;
-    case 8: m_name=i18n("Intensity"); break;
-    case 9: m_name=i18n("Hue"); break;
-    case 10: m_name=i18n("Saturation"); break;
-    case 11: m_name=i18n("Luma"); break;
-    }
-
-    QLabel* m_label = new QLabel(i18n("%1:", m_name), this);
-    m_layout->addWidget(m_label);
-
-    m_hsvSlider = new KisHSVSlider(Qt::Horizontal, this, m_displayRenderer, m_canvas);
-    m_hsvSlider->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
-    m_layout->addWidget(m_hsvSlider);
-    connect (m_hsvSlider,  SIGNAL(sliderPressed()), SLOT(sliderIn()));
-    connect (m_hsvSlider,  SIGNAL(sliderReleased()), SLOT(sliderOut()));
-
-    QWidget* m_input = createInput();
-    m_hsvSlider->setFixedHeight(m_input->sizeHint().height());
-    m_layout->addWidget(m_input);
-}
-
-KisHSXColorSliderInput::KisHSXColorSliderInput(QWidget* parent, const int type, KoColor* color, KoColorDisplayRendererInterface *displayRenderer, KisCanvas2* canvas) : KisColorSliderInput(parent, color, type, displayRenderer, canvas),
-    m_canvas(canvas),
-    m_hue(0),
-    m_sat(0),
-    m_val(0),
-    R(0),
-    G(0),
-    B(0),
-    Gamma(0)
-{
-    m_hueupdating = false;
-    m_satupdating = false;
-    m_toneupdating = false;
-    m_sliderisupdating = false;
-    init();
-}
-
-void KisHSXColorSliderInput::setValue(double v)
-{
-
-    //This function returns the colour based on the type of the slider as well as the value//
-
-    qreal h=0.0;
-    qreal s=0.0;
-    qreal l=0.0;
-    KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
-    R = cfg.readEntry("lumaR", 0.2126);
-    G = cfg.readEntry("lumaG", 0.7152);
-    B = cfg.readEntry("lumaB", 0.0722);
-    Gamma = cfg.readEntry("gamma", 2.2);
-
-    switch (m_type) {
-    case 0:
-        m_hue = v;
-        h=m_hue/360.0;
-        s=m_sat/100.0;
-        l=m_val/100.0;
-        *m_color = this->converter()->fromHsvF(h, s, l);
-        if (m_hueupdating==false) {
-            emit(hueUpdated(static_cast<int>(m_hue)));
-        }
-        else {
-            m_hueupdating=false;
-        }
-        break;
-    case 3:
-        m_hue = v;
-        h=m_hue/360.0;
-        s=m_sat/100.0;
-        l=m_val/100.0;
-        *m_color = this->converter()->fromHslF(h, s, l);
-        if (m_hueupdating==false) {
-            emit(hueUpdated(static_cast<int>(m_hue)));
-        }
-        else {
-            m_hueupdating=false;
-        }
-        break;
-    case 6:
-        m_hue = v;
-        h=m_hue/360.0;
-        s=m_sat/100.0;
-        l=m_val/100.0;
-        *m_color = this->converter()->fromHsiF(h, s, l);
-        if (m_hueupdating==false) {
-            emit(hueUpdated(static_cast<int>(m_hue)));
-        }
-        else {
-            m_hueupdating=false;
-        }
-        break;
-    case 9:
-        m_hue = v;
-        h=m_hue/360.0f;
-        s=m_sat/100.0f;
-        l=m_val/100.0f;
-        *m_color = this->converter()->fromHsyF(h, s, l, R, G, B, Gamma);
-        if (m_hueupdating==false) {
-            emit(hueUpdated(static_cast<int>(m_hue)));
-        }
-        else {
-            m_hueupdating=false;
-        }
-        break;
-    case 1:
-        m_sat = v;
-        h=m_hue/360.0f;
-        s=m_sat/100.0f;
-        l=m_val/100.0f;
-        *m_color = this->converter()->fromHsvF(h, s, l);
-        if (m_satupdating==false) {
-            emit(satUpdated(static_cast<int>(m_sat), m_type));
-        }
-        else {
-            m_satupdating=false;
-        }
-        break;
-    case 2:
-        m_val = v;
-        h=m_hue/360.0f;
-        s=m_sat/100.0f;
-        l=m_val/100.0f;
-        *m_color = this->converter()->fromHsvF(h, s, l);
-        if (m_toneupdating==false) {
-            emit(toneUpdated(static_cast<int>(m_val), m_type));
-        }
-        else {
-            m_toneupdating=false;
-        }
-        break;
-    case 4:
-        m_sat = v;
-        h=m_hue/360.0f;
-        s=m_sat/100.0f;
-        l=m_val/100.0f;
-        *m_color = this->converter()->fromHslF(h, s, l);
-        if (m_satupdating==false) {
-            emit(satUpdated(static_cast<int>(m_sat), m_type));
-        }
-        else {
-            m_satupdating=false;
-        }
-        break;
-    case 5:
-        m_val = v;
-        h=m_hue/360.0f;
-        s=m_sat/100.0f;
-        l=m_val/100.0f;
-        *m_color = this->converter()->fromHslF(h, s, l);
-        if (m_toneupdating==false) {
-            emit(toneUpdated(static_cast<int>(m_val), m_type));
-        }
-        else {
-            m_toneupdating=false;
-        }
-        break;
-    case 7:
-        m_sat = v;
-        h=m_hue/360.0f;
-        s=m_sat/100.0f;
-        l=m_val/100.0f;
-        *m_color = this->converter()->fromHsiF(h, s, l);
-        if (m_satupdating==false) {
-            emit(satUpdated(static_cast<int>(m_sat), m_type));
-        }
-        else {
-            m_satupdating=false;
-        }
-        break;
-    case 8:
-        m_val = v;
-        h=m_hue/360.0f;
-        s=m_sat/100.0f;
-        l=m_val/100.0f;
-        *m_color = this->converter()->fromHsiF(h, s, l);
-        if (m_toneupdating==false) {
-            emit(toneUpdated(static_cast<int>(m_val), m_type));
-        }
-        else {
-            m_toneupdating=false;
-        }
-        break;
-    case 10:
-        m_sat = v;
-        h=m_hue/360.0f;
-        s=m_sat/100.0f;
-        l=m_val/100.0f;
-        *m_color = this->converter()->fromHsyF(h, s, l, R, G, B, Gamma);
-        if (m_satupdating==false) {
-            emit(satUpdated(static_cast<int>(m_sat), m_type));
-        }
-        else {
-            m_satupdating=false;
-        }
-        break;
-    case 11:
-        m_val = v;
-        h=m_hue/360.0f;
-        s=m_sat/100.0f;
-        l=m_val/100.0f;
-        *m_color = this->converter()->fromHsyF(h, s, l, R, G, B, Gamma);
-        if (m_toneupdating==false) {
-            emit(toneUpdated(static_cast<int>(m_val), m_type));
-        }
-        else {
-            m_toneupdating=false;
-        }
-        break;
-    default:
-        Q_ASSERT(false);
-    }
-    emit(updated());
-}
-//update
-void KisHSXColorSliderInput::update()
-{
-
-//    KoColor min = *m_color;
-//    KoColor max = *m_color;
-
-    qreal hue = 0.0;
-    qreal sat = 0.0;
-    qreal val = 0.0;
-    qreal hue_backup, sat_backup, val_backup;
-    //gets the hsv for the appropriate type//
-    hue_backup = m_hue;
-    sat_backup = m_sat;
-    val_backup = m_val;
-
-    switch (m_type) {
-    case 0:
-        this->converter()->getHsvF(*m_color, &hue, &sat, &val);
-        if (m_sliderisupdating) {
-            if ((sat * 100.0) < m_sat + 2 && (sat * 100.0) > m_sat - 2) {
-                sat = (sat_backup * 0.01);
-            }
-            if ((val * 100.0) < m_val + 2 && (val * 100.0) > m_val - 2) {
-                val = (val_backup*0.01);
-            }
-
-        }
-        else {
-            if((hue * 360.0) < m_hue + 2 && (hue * 360.0) > m_hue - 2) {
-                hue = (hue_backup/360.0);
-            }
-        }
-        break;
-    case 1:
-        this->converter()->getHsvF(*m_color, &hue, &sat, &val);
-        if (m_sliderisupdating) {
-            if ((hue * 360.0) < m_hue + 2 && (hue * 360.0) > m_hue - 2 ) {
-                hue = (hue_backup/360.0);
-            }
-            if ((val * 100.0) < m_val + 2 && (val * 100.0) > m_val - 2) {
-                val = (val_backup*0.01);
-            }
-        }
-        else {
-            if ((sat*100.0)<m_sat+2 && (sat*100.0)>m_sat-2) {
-                sat = (sat_backup*0.01);
-            }
-        }
-        break;
-    case 2:
-        this->converter()->getHsvF(*m_color, &hue, &sat, &val);
-        if (m_sliderisupdating==true)
-        {
-            if((sat*100.0)<m_sat+2 && (sat*100.0)>m_sat-2) {
-                sat = (sat_backup*0.01);
-            }
-            if((hue*360.0)<m_hue+2 && (hue*360.0)>m_hue-2) {
-                hue = (hue_backup/360.0);
-            }
-        }
-        else{
-            if((val*100.0)<m_val+2 && (val*100.0)>m_val-2) {
-                val = (val_backup*0.01);
-            }
-        }
-        break;
-    case 3:
-        this->converter()->getHslF(*m_color, &hue, &sat, &val);
-        if (m_sliderisupdating==true)
-        {
-            if((sat*100.0)<m_sat+2 && (sat*100.0)>m_sat-2) {
-                sat = (sat_backup*0.01);
-            }
-            if((val*100.0)<m_val+2 && (val*100.0)>m_val-2) {
-                val = (val_backup*0.01);
-            }
-
-
-        }
-        else{
-            if((hue*360.0)<m_hue+2 && (hue*360.0)>m_hue-2) {
-                hue = (hue_backup/360.0);
-            }
-        }
-        break;
-    case 4:
-        this->converter()->getHslF(*m_color, &hue, &sat, &val);
-        if (m_sliderisupdating==true)
-        {
-            if((hue*360.0)<m_hue+2 && (hue*360.0)>m_hue-2) {
-                hue = (hue_backup/360.0);
-            }
-            if((val*100.0)<m_val+2 && (val*100.0)>m_val-2) {
-                val = (val_backup*0.01);
-            }
-
-
-        }
-        else{
-
-            if((sat*100.0)<m_sat+2 && (sat*100.0)>m_sat-2) {
-                sat = (sat_backup*0.01);
-            }
-        }
-        break;
-    case 5:
-        this->converter()->getHslF(*m_color, &hue, &sat, &val);
-        if (m_sliderisupdating==true)
-        {
-            if((sat*100.0)<m_sat+2 && (sat*100.0)>m_sat-2) {
-                sat = (sat_backup*0.01);
-            }
-            if((hue*360.0)<m_hue+2 && (hue*360.0)>m_hue-2) {
-                hue = (hue_backup/360.0);
-            }
-        }
-        else{
-            if((val*100.0)<m_val+2 && (val*100.0)>m_val-2) {
-                val = (val_backup*0.01);
-            }
-        }
-        break;
-    case 6:
-        this->converter()->getHsiF(*m_color, &hue, &sat, &val);
-        if (m_sliderisupdating==true)
-        {
-            if((sat*100.0)<m_sat+2 && (sat*100.0)>m_sat-2) {
-                sat = (sat_backup*0.01);
-            }
-            if((val*100.0)<m_val+2 && (val*100.0)>m_val-2) {
-                val = (val_backup*0.01);
-            }
-
-
-        }
-        else{
-            if((hue*360.0)<m_hue+2 && (hue*360.0)>m_hue-2) {
-                hue = (hue_backup/360.0);
-            }
-        }
-        break;
-    case 7:
-        this->converter()->getHsiF(*m_color, &hue, &sat, &val);
-        if (m_sliderisupdating==true)
-        {
-            if((hue*360.0)<m_hue+2 && (hue*360.0)>m_hue-2) {
-                hue = (hue_backup/360.0);
-            }
-            if((val*100.0)<m_val+2 && (val*100.0)>m_val-2) {
-                val = (val_backup*0.01);
-            }
-
-
-        }
-        else{
-
-            if((sat*100.0)<m_sat+2 && (sat*100.0)>m_sat-2) {
-                sat = (sat_backup*0.01);
-            }
-        }
-        break;
-    case 8:
-        this->converter()->getHsiF(*m_color, &hue, &sat, &val);
-        if (m_sliderisupdating==true)
-        {
-            if((sat*100.0)<m_sat+2 && (sat*100.0)>m_sat-2) {
-                sat = (sat_backup*0.01);
-            }
-            if((hue*360.0)<m_hue+2 && (hue*360.0)>m_hue-2) {
-                hue = (hue_backup/360.0);
-            }
-        }
-        else{
-            if((val*100.0)<m_val+2 && (val*100.0)>m_val-2) {
-                val = (val_backup*0.01);
-            }
-        }
-        break;
-    case 9:
-        this->converter()->getHsyF(*m_color, &hue, &sat, &val, R, G, B, Gamma);
-        if (m_sliderisupdating==true)
-        {
-            if((sat*100.0)<m_sat+2 && (sat*100.0)>m_sat-2) {
-                sat = (sat_backup*0.01);
-            }
-            if((val*100.0)<m_val+2 && (val*100.0)>m_val-2) {
-                val = (val_backup*0.01);
-            }
-
-
-        }
-        else{
-            if((hue*360.0)<m_hue+2 && (hue*360.0)>m_hue-2) {
-                hue = (hue_backup/360.0);
-            }
-        }
-        break;
-    case 10:
-        this->converter()->getHsyF(*m_color, &hue, &sat, &val, R, G, B, Gamma);
-        if (m_sliderisupdating==true)
-        {
-            if((hue*360.0)<m_hue+2 && (hue*360.0)>m_hue-2) {
-                hue = (hue_backup/360.0);
-            }
-            if((val*100.0)<m_val+2 && (val*100.0)>m_val-2) {
-                val = (val_backup*0.01);
-            }
-
-
-        }
-        else{
-
-            if((sat*100.0)<m_sat+2 && (sat*100.0)>m_sat-2) {
-                sat = (sat_backup*0.01);
-            }
-        }
-        break;
-    case 11:
-        this->converter()->getHsyF(*m_color, &hue, &sat, &val, R, G, B, Gamma);
-        if (m_sliderisupdating == true)
-        {
-            if((sat*100.0)<m_sat+2 && (sat*100.0)>m_sat-2) {
-                sat = (sat_backup*0.01);
-            }
-            if((hue*360.0)<m_hue+2 && (hue*360.0)>m_hue-2) {
-                hue = (hue_backup/360.0);
-            }
-        }
-        else{
-            if((val*100.0)<m_val+2 && (val*100.0)>m_val-2) {
-                val = (val_backup*0.01);
-            }
-        }
-        break;
-    }
-    //this prevents the hue going to 0 when used with grey//
-
-    if (sat<=0.0) {
-        m_hue = hue_backup;
-    }
-    else{
-        m_hue=(hue*360.0);
-    }
-
-    if (val == 0) {
-        m_sat = sat_backup;
-    }
-    else{
-        m_sat=(sat*100.0);
-    }
-
-    m_val=(val*100.0);
-
-    if (m_hueupdating==true){m_val=val_backup; m_sat = sat_backup; m_hueupdating=false;}
-    else if (m_satupdating==true){m_val=val_backup; m_hue = hue_backup; m_satupdating=false;}
-    else if (m_toneupdating==true){m_sat=sat_backup; m_hue = hue_backup;m_toneupdating=false;}
-
-    //sets slider and num-input according to type//
-    switch (m_type) {
-    case 0:
-    case 3:
-    case 6:
-    case 9:
-        m_NumInput->setValue(m_hue);
-        m_hsvSlider->setValue(static_cast<int>(m_hue));
-        break;
-    case 1:
-        m_NumInput->setValue(m_sat);
-        m_hsvSlider->setValue(static_cast<int>(m_sat));
-        break;
-    case 2:
-        m_NumInput->setValue(m_val);
-        m_hsvSlider->setValue(static_cast<int>(m_val));
-        break;
-    case 4:
-        m_NumInput->setValue(m_sat);
-        m_hsvSlider->setValue(static_cast<int>(m_sat));
-        break;
-    case 5:
-        m_NumInput->setValue(m_val);
-        m_hsvSlider->setValue(static_cast<int>(m_val));
-        break;
-    case 7:
-        m_NumInput->setValue(m_sat);
-        m_hsvSlider->setValue(static_cast<int>(m_sat));
-        break;
-    case 8:
-        m_NumInput->setValue(m_val);
-        m_hsvSlider->setValue(static_cast<int>(m_val));
-        break;
-    case 10:
-        m_NumInput->setValue(m_sat);
-        m_hsvSlider->setValue(static_cast<int>(m_sat));
-        break;
-    case 11:
-        m_NumInput->setValue(m_val);
-        m_hsvSlider->setValue(static_cast<int>(m_val));
-        break;
-    default:
-        Q_ASSERT(false);
-    }
-    m_hsvSlider->setColors(*m_color,m_type, m_hue, R, G, B, Gamma);
-}
-
-QWidget* KisHSXColorSliderInput::createInput()
-{
-    m_NumInput = new KisDoubleParseSpinBox(this);
-    m_NumInput->setMinimum(0);
-    m_NumInput->setMaximum(100.0);
-    m_NumInput->setKeyboardTracking(false);//this makes sure that only full values are sent after loss of focus. Much more user friendly//
-    m_hsvSlider->setMaximum(100);
-    switch (m_type) {
-    case 0:
-    case 3:
-    case 6:
-    case 9:
-        m_NumInput->setMaximum(360.0);
-        m_NumInput->setWrapping(true);
-        m_hsvSlider->setMaximum(360);
-        m_NumInput->setSingleStep (5.0);
-        break;
-    case 1:
-    case 2:
-    case 4:
-    case 5:
-    case 7:
-    case 8:
-    case 10:
-    case 11:
-        m_NumInput->setMaximum(100.0);
-        m_hsvSlider->setMaximum(100);
-        m_NumInput->setSingleStep (10.0);
-        break;
-    default:
-        Q_ASSERT(false);
-    }
-    connect(m_hsvSlider, SIGNAL(valueChanged(int)), this, SLOT(sliderChanged(int)));
-    connect(m_NumInput, SIGNAL(valueChanged(double)), this, SLOT(numInputChanged(double)));
-    return m_NumInput;
-}
-
-void KisHSXColorSliderInput::sliderChanged(int i)
-{
-    m_NumInput->setValue(i*1.0);
-    setValue(i*1.0);
-}
-
-void KisHSXColorSliderInput::sliderIn(){
-    m_sliderisupdating=true;
-}
-
-void KisHSXColorSliderInput::sliderOut(){
-    m_sliderisupdating=false;
-}
-//attempt at getting rid of dancing sliders... #2859
-//The nminput should not be changing the sliders if the sliders are the one changing the input.
-//As numinpit rounds off at 2 decimals(and there's no point at letting it continue the signal circle).
-void KisHSXColorSliderInput::numInputChanged(double v)
-{
-    if (m_sliderisupdating==true){
-        return;
-    }
-    else {
-        setValue(v);
-    }
-}
-
-//this connects to the display converter. Important for OCIO, breaks on missing of m_canvas somehow.
-KisDisplayColorConverter* KisHSXColorSliderInput::converter() const
-{
-    return m_canvas ?
-                m_canvas->displayColorConverter() :
-                KisDisplayColorConverter::dumbConverterInstance();
-}
-
-void KisHSXColorSliderInput::hueUpdate(int h)
-{
-    if (h<=m_hue-2 || h>=m_hue+2) {
-        m_hue=h;
-        m_hueupdating=true;
-        update();
-    }
-}
-
-void KisHSXColorSliderInput::satUpdate(int s, int type)
-{
-    if (m_type==type+1 || m_type==type-1)
-    {
-        if (s<=m_sat-3 || s>=m_sat+3) {
-            m_sat=s;
-            m_satupdating=true;
-            update();
-        }
-    }
-}
-
-void KisHSXColorSliderInput::toneUpdate(int l, int type)
-{
-    if (m_type==type-1 || m_type==type-2)
-    {
-        if (l<25 || l>75){
-
-            if (l<=m_val-10 || l>=m_val+10) {
-                m_val=l;
-                m_toneupdating=true;
-                update();
-            }
-        }
-        else {
-            if (l<=m_val-3 || l>=m_val+3) {
-                m_val=l;
-                m_toneupdating=true;
-                update();
-            }
-        }
-
-
-    }
-}
-
-#include "moc_kis_color_slider_input.cpp"
diff --git a/plugins/dockers/colorslider/kis_color_slider_input.h b/plugins/dockers/colorslider/kis_color_slider_input.h
deleted file mode 100644
index dfd8f26e7d..0000000000
--- a/plugins/dockers/colorslider/kis_color_slider_input.h
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
- *  Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
- *  Copyright (c) 2014 Wolthera van Hövell <griffinvalley@gmail.com>    
- *
- *  This library is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser General Public License as published by
- *  the Free Software Foundation; version 2.1 of the License.
- *
- *  This library is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU Lesser General Public License for more details.
- *
- *  You should have received a copy of the GNU Lesser General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-
-#ifndef _KIS_COLOR_SLIDER_INPUT_H_
-#define _KIS_COLOR_SLIDER_INPUT_H_
-
-#include <QWidget>
-#include <QPointer>
-
-#include "KoColorDisplayRendererInterface.h"
-
-#include "kis_canvas2.h"
-
-class KoColor;
-class QWidget;
-class QDoubleSpinBox;
-class KisDoubleParseSpinBox;
-class KisHSVSlider;
-class KisDisplayColorConverter;
-
-
-class KisColorSliderInput : public QWidget
-{
-    Q_OBJECT
-public:
-    KisColorSliderInput(QWidget* parent, KoColor* color, const int type, KoColorDisplayRendererInterface *displayRenderer, KisCanvas2* canvas);
-protected:
-    void init();
-    virtual QWidget* createInput() = 0;
-Q_SIGNALS:
-    void updated();
-    
-protected:
-    const int m_type;
-    KoColor* m_color;
-    KoColorDisplayRendererInterface *m_displayRenderer;
-    QPointer<KisCanvas2> m_canvas;
-    KisHSVSlider* m_hsvSlider;
-};
-
-class KisHSXColorSliderInput : public KisColorSliderInput
-{
-    Q_OBJECT
-public:
-    KisHSXColorSliderInput(QWidget* parent, const int type, KoColor* color, KoColorDisplayRendererInterface *displayRenderer, KisCanvas2* canvas);
-    
-    KisDisplayColorConverter* converter() const;
-protected:
-    QWidget* createInput() override;
-    QPointer<KisCanvas2> m_canvas;
-public Q_SLOTS:
-    void setValue(double);
-    void update();
-    void hueUpdate(int h);
-    void satUpdate(int s, int type);
-    void toneUpdate(int l, int type);
-    void sliderChanged(int i);
-    void sliderIn();
-    void sliderOut();
-    void numInputChanged(double v);
-Q_SIGNALS:
-    void hueUpdated(int);
-    void satUpdated(int, int);
-    void toneUpdated(int, int);
-private:
-    KisDoubleParseSpinBox* m_NumInput;
-    qreal m_hue;
-    qreal m_sat;
-    qreal m_val;
-    qreal R, G, B, Gamma;
-    bool m_hueupdating;
-    bool m_satupdating;
-    bool m_toneupdating;
-    bool m_sliderisupdating;
-};
-
-#endif
diff --git a/plugins/dockers/colorslider/kis_color_slider_widget.cpp b/plugins/dockers/colorslider/kis_color_slider_widget.cpp
deleted file mode 100644
index ba4c48524a..0000000000
--- a/plugins/dockers/colorslider/kis_color_slider_widget.cpp
+++ /dev/null
@@ -1,483 +0,0 @@
-/*
- *  Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
- *  Copyright (c) 2014 Wolthera van Hövell <griffinvalley@gmail.com>
- *  Copyright (c) 2015 Moritz Molch <kde@moritzmolch.de>
- *
- *  This library is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser General Public License as published by
- *  the Free Software Foundation; version 2.1 of the License.
- *
- *  This library is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU Lesser General Public License for more details.
- *
- *  You should have received a copy of the GNU Lesser General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-
-#include "kis_color_slider_widget.h"
-#include <QLabel>
-#include <QVBoxLayout>
-#include <QBitArray>
-#include <QSpacerItem>
-
-
-#include <klocalizedstring.h>
-#include <kconfiggroup.h>
-#include <kconfig.h>
-#include <ksharedconfig.h>
-
-#include <KoChannelInfo.h>
-#include <KoColorSpace.h>
-#include <KoColorSpaceRegistry.h>
-
-#include "kis_color_slider_input.h"
-#include <KoColorProfile.h>
-#include "kis_debug.h"
-#include "kis_signal_compressor.h"
-//#include "kis_color_space_selector.h"
-
-
-
-KisColorSliderWidget::KisColorSliderWidget(KoColorDisplayRendererInterface *displayRenderer, QWidget* parent, KisCanvas2* canvas, QBitArray SlidersConfigArray)
-    : QWidget(parent)
-    //, m_colorSpace(0)
-    //, m_customColorSpaceSelected(false)
-    , m_updateCompressor(new KisSignalCompressor(10, KisSignalCompressor::POSTPONE, this))
-    , m_displayRenderer(displayRenderer)
-    , m_canvas(canvas)
-{
-    m_layout = new QVBoxLayout(this);
-    m_layout->setContentsMargins(0,0,0,0);
-    m_layout->setSpacing(1);
-    m_updateAllowed = true;
-    
-    connect(m_updateCompressor, SIGNAL(timeout()), SLOT(updateTimeout()));
-    m_configCompressor = new KisSignalCompressor(10, KisSignalCompressor::POSTPONE, this);
-    connect(m_configCompressor, SIGNAL(timeout()), SLOT(setConfig()));
-    //dbgKrita<<"m_canvas:"<<m_canvas;
-        
-    m_inputs.clear();
-    
-    //this first creates and set the sliders.
-    //then setslidervisible is called to make them visible and connect them.
-    //This way they can also be disabled more easily.
-    
-    //hsv sliders//
-        
-    hsvH = new KisHSXColorSliderInput(this, 0, &m_color, m_displayRenderer, m_canvas);
-    m_inputs.append(hsvH);
-    m_layout->addWidget(hsvH);
-    hsvH->setVisible(false);
-    
-    hsvS = new KisHSXColorSliderInput(this, 1, &m_color, m_displayRenderer, m_canvas);
-    m_inputs.append(hsvS);
-    m_layout->addWidget(hsvS);
-    hsvS->setVisible(false);
-
-    hsvV = new KisHSXColorSliderInput(this, 2, &m_color, m_displayRenderer, m_canvas);
-    m_inputs.append(hsvV);
-    m_layout->addWidget(hsvV);
-    hsvV->setVisible(false);
-    
-    //hsl sliders//
-    
-    hslH = new KisHSXColorSliderInput(this, 3, &m_color, m_displayRenderer, m_canvas);
-    m_inputs.append(hslH);
-    m_layout->addWidget(hslH);
-    hslH->setVisible(false);
-
-    hslS = new KisHSXColorSliderInput(this, 4, &m_color, m_displayRenderer, m_canvas);
-    m_inputs.append(hslS);
-    m_layout->addWidget(hslS);
-    hslS->setVisible(false);
-    
-    hslL = new KisHSXColorSliderInput(this, 5, &m_color, m_displayRenderer, m_canvas);
-    m_inputs.append(hslL);
-    m_layout->addWidget(hslL);
-    hslL->setVisible(false);
-    
-    
-    //hsi sliders//
-    
-    hsiH = new KisHSXColorSliderInput(this, 6, &m_color, m_displayRenderer, m_canvas);
-    m_inputs.append(hsiH);
-    m_layout->addWidget(hsiH);
-    hsiH->setVisible(false);
-    
-    hsiS = new KisHSXColorSliderInput(this, 7, &m_color, m_displayRenderer, m_canvas);
-    m_inputs.append(hsiS);
-    m_layout->addWidget(hsiS);
-    hsiS->setVisible(false);
-    
-    hsiI = new KisHSXColorSliderInput(this, 8, &m_color, m_displayRenderer, m_canvas);
-    m_inputs.append(hsiI);
-    m_layout->addWidget(hsiI);
-    hsiI->setVisible(false);
-    
-    //hsy'sliders//
-    
-    hsyH = new KisHSXColorSliderInput(this, 9, &m_color, m_displayRenderer, m_canvas);
-    m_inputs.append(hsyH);
-    m_layout->addWidget(hsyH);
-    hsyH->setVisible(false);
-    
-    hsyS = new KisHSXColorSliderInput(this, 10, &m_color, m_displayRenderer, m_canvas);
-    m_inputs.append(hsyS);
-    m_layout->addWidget(hsyS);
-    hsyS->setVisible(false);
-    
-    hsyY = new KisHSXColorSliderInput(this, 11, &m_color, m_displayRenderer, m_canvas);
-    m_inputs.append(hsyY);
-    m_layout->addWidget(hsyY);
-    hsyY->setVisible(false);
-
-    m_layout->addStretch(1);
-
-    setSlidersVisible(SlidersConfigArray);
-    
-
-}
-
-KisColorSliderWidget::~KisColorSliderWidget()
-{
-    //KConfigGroup cfg =  KSharedConfig::openConfig()->group(QString());
-    //cfg.writeEntry("SpecificColorSelector/ShowColorSpaceSelector", m_chkShowColorSpaceSelector->isChecked());
-
-}
-
-void KisColorSliderWidget::update()
-{
-    if (m_updateAllowed) {
-        m_updateCompressor->start();
-    }
-}
-
-void KisColorSliderWidget::setColor(const KoColor& c)
-{
-    m_updateAllowed = false;
-    m_color.fromKoColor(c);
-    emit(updated());
-    m_updateAllowed = true;
-}
-
-void KisColorSliderWidget::updateTimeout()
-{
-    emit(colorChanged(m_color));
-    
-}
-
-void KisColorSliderWidget::setSlidersVisible(QBitArray SlidersConfigArray)
-{
-    //dbgKrita<<"check2";
-    QList<KisColorSliderInput*> visibleInputs;
-    
-    if (SlidersConfigArray[0]==true) {
-        visibleInputs.append(hsvH);
-        hsvH->setVisible(true);
-        connect(hsvH, SIGNAL(updated()), this, SLOT(update()));
-        connect(this, SIGNAL(updated()), hsvH, SLOT(update()));
-        connect(hsvH, SIGNAL(hueUpdated(int)), this, SLOT(hueUpdate(int)));
-        connect(this, SIGNAL(hueUpdated(int)), hsvH, SLOT(hueUpdate(int)));
-        connect(this, SIGNAL(satUpdated(int, int)), hsvH, SLOT(satUpdate(int, int)));
-        connect(this, SIGNAL(toneUpdated(int, int)), hsvH, SLOT(toneUpdate(int, int)));
-    }
-    else {
-        hsvH->setVisible(false);
-        disconnect(hsvH, SIGNAL(updated()), this, SLOT(update()));
-        disconnect(this, SIGNAL(updated()), hsvH, SLOT(update()));
-        disconnect(hsvH, SIGNAL(hueUpdated(int)), this, SLOT(hueUpdate(int)));
-        disconnect(this, SIGNAL(hueUpdated(int)), hsvH, SLOT(hueUpdate(int)));
-        disconnect(this, SIGNAL(satUpdated(int, int)), hsvH, SLOT(satUpdate(int, int)));
-        disconnect(this, SIGNAL(toneUpdated(int, int)), hsvH, SLOT(toneUpdate(int, int)));
-    }
-
-    if (SlidersConfigArray[1]==true) {
-        visibleInputs.append(hsvS);
-        hsvS->setVisible(true);
-        connect(hsvS, SIGNAL(updated()), this, SLOT(update()));
-        connect(this, SIGNAL(updated()), hsvS, SLOT(update()));
-        connect(this, SIGNAL(hueUpdated(int)), hsvS, SLOT(hueUpdate(int)));
-        connect(hsvS, SIGNAL(satUpdated(int, int)), this, SLOT(satUpdate(int, int)));
-        connect(this, SIGNAL(satUpdated(int, int)), hsvS, SLOT(satUpdate(int, int)));
-        connect(this, SIGNAL(toneUpdated(int, int)), hsvS, SLOT(toneUpdate(int, int)));
-    }
-    else {
-        hsvS->setVisible(false);
-        disconnect(hsvS, SIGNAL(updated()), this, SLOT(update()));
-        disconnect(this, SIGNAL(updated()), hsvS, SLOT(update()));
-        disconnect(this, SIGNAL(hueUpdated(int)), hsvS, SLOT(hueUpdate(int)));
-        disconnect(hsvS, SIGNAL(satUpdated(int, int)), this, SLOT(satUpdate(int, int)));
-        disconnect(this, SIGNAL(satUpdated(int, int)), hsvS, SLOT(satUpdate(int, int)));
-        disconnect(this, SIGNAL(toneUpdated(int, int)), hsvS, SLOT(toneUpdate(int, int)));
-    }
-
-    if (SlidersConfigArray[2]==true) {
-        visibleInputs.append(hsvV);
-        hsvV->setVisible(true);
-        connect(hsvV, SIGNAL(updated()), this, SLOT(update()));
-        connect(this, SIGNAL(updated()), hsvV, SLOT(update()));
-        connect(this, SIGNAL(hueUpdated(int)), hsvV, SLOT(hueUpdate(int)));
-        connect(this, SIGNAL(satUpdated(int, int)), hsvV, SLOT(satUpdate(int, int)));
-        connect(this, SIGNAL(toneUpdated(int, int)), hsvV, SLOT(toneUpdate(int, int)));
-        connect(hsvV, SIGNAL(toneUpdated(int, int)), this, SLOT(toneUpdate(int, int)));
-    }
-    else {
-        hsvV->setVisible(false);
-        disconnect(hsvV, SIGNAL(updated()), this, SLOT(update()));
-        disconnect(this, SIGNAL(updated()), hsvV, SLOT(update()));
-        disconnect(this, SIGNAL(hueUpdated(int)), hsvV, SLOT(hueUpdate(int)));
-        disconnect(this, SIGNAL(satUpdated(int, int)), hsvV, SLOT(satUpdate(int, int)));
-        disconnect(this, SIGNAL(toneUpdated(int, int)), hsvV, SLOT(toneUpdate(int, int)));
-        disconnect(hsvV, SIGNAL(toneUpdated(int, int)), this, SLOT(toneUpdate(int, int)));
-    }
-
-    if (SlidersConfigArray[3]==true) {
-        visibleInputs.append(hslH);
-        hslH->setVisible(true);
-        connect(hslH, SIGNAL(updated()), this, SLOT(update()));
-        connect(this, SIGNAL(updated()), hslH, SLOT(update()));
-        connect(hslH, SIGNAL(hueUpdated(int)), this, SLOT(hueUpdate(int)));
-        connect(this, SIGNAL(hueUpdated(int)), hslH, SLOT(hueUpdate(int)));
-        connect(this, SIGNAL(satUpdated(int, int)), hslH, SLOT(satUpdate(int, int)));
-        connect(this, SIGNAL(toneUpdated(int, int)), hslH, SLOT(toneUpdate(int, int)));
-    }
-    else {
-        hslH->setVisible(false);
-        disconnect(hslH, SIGNAL(updated()), this,  SLOT(update()));
-        disconnect(this, SIGNAL(updated()), hslH, SLOT(update()));
-        disconnect(hslH, SIGNAL(hueUpdated(int)), this,  SLOT(hueUpdate(int)));
-        disconnect(this, SIGNAL(hueUpdated(int)), hslH, SLOT(hueUpdate(int)));
-        disconnect(this, SIGNAL(satUpdated(int, int)), hslH, SLOT(satUpdate(int, int)));
-        disconnect(this, SIGNAL(toneUpdated(int, int)), hslH, SLOT(toneUpdate(int, int)));
-    }
-
-    if (SlidersConfigArray[4]==true) {
-        visibleInputs.append(hslS);
-        hslS->setVisible(true);
-        connect(hslS, SIGNAL(updated()), this, SLOT(update()));
-        connect(this, SIGNAL(updated()), hslS, SLOT(update()));
-        connect(this, SIGNAL(hueUpdated(int)), hslS, SLOT(hueUpdate(int)));
-        connect(hslS, SIGNAL(satUpdated(int, int)), this, SLOT(satUpdate(int, int)));
-        connect(this, SIGNAL(satUpdated(int, int)), hslS, SLOT(satUpdate(int, int)));
-        connect(this, SIGNAL(toneUpdated(int, int)), hslS, SLOT(toneUpdate(int, int)));
-    }
-    else {
-        hslS->setVisible(false);
-        disconnect(hslS, SIGNAL(updated()), this,  SLOT(update()));
-        disconnect(this, SIGNAL(updated()), hslS, SLOT(update()));
-        disconnect(this, SIGNAL(hueUpdated(int)), hslS, SLOT(hueUpdate(int)));
-        disconnect(hslS, SIGNAL(satUpdated(int, int)), this, SLOT(satUpdate(int, int)));
-        disconnect(this, SIGNAL(satUpdated(int, int)), hslS, SLOT(satUpdate(int, int)));
-        disconnect(this, SIGNAL(toneUpdated(int, int)), hslS, SLOT(toneUpdate(int, int)));
-    }
-
-    if (SlidersConfigArray[5]==true) {
-        visibleInputs.append(hslL);
-        hslL->setVisible(true);
-        connect(hslL, SIGNAL(updated()), this,  SLOT(update()));
-        connect(this, SIGNAL(updated()), hslL, SLOT(update()));
-        connect(this, SIGNAL(hueUpdated(int)), hslL, SLOT(hueUpdate(int)));
-        connect(this, SIGNAL(satUpdated(int, int)), hslL, SLOT(satUpdate(int, int)));
-        connect(this, SIGNAL(toneUpdated(int, int)), hslL, SLOT(toneUpdate(int, int)));
-        connect(hslL, SIGNAL(toneUpdated(int, int)), this, SLOT(toneUpdate(int, int)));
-    }
-    else {
-        hslL->setVisible(false);
-        disconnect(hslL, SIGNAL(updated()), this,  SLOT(update()));
-        disconnect(this, SIGNAL(updated()), hslL, SLOT(update()));
-        disconnect(this, SIGNAL(hueUpdated(int)), hslL, SLOT(hueUpdate(int)));
-        disconnect(this, SIGNAL(satUpdated(int, int)), hslL, SLOT(satUpdate(int, int)));
-        disconnect(this, SIGNAL(toneUpdated(int, int)), hslL, SLOT(toneUpdate(int, int)));
-        disconnect(hslL, SIGNAL(toneUpdated(int, int)), this, SLOT(toneUpdate(int, int)));
-    }
-
-    if (SlidersConfigArray[6]==true) {
-        visibleInputs.append(hsiH);
-        hsiH->setVisible(true);
-        connect(hsiH, SIGNAL(updated()), this, SLOT(update()));
-        connect(this, SIGNAL(updated()), hsiH, SLOT(update()));
-        connect(hsiH, SIGNAL(hueUpdated(int)), this, SLOT(hueUpdate(int)));
-        connect(this, SIGNAL(hueUpdated(int)), hsiH, SLOT(hueUpdate(int)));
-        connect(this, SIGNAL(satUpdated(int, int)), hsiH, SLOT(satUpdate(int, int)));
-        connect(this, SIGNAL(toneUpdated(int, int)), hsiH, SLOT(toneUpdate(int, int)));
-    }
-    else {
-        hsiH->setVisible(false);
-        disconnect(hsiH, SIGNAL(updated()), this, SLOT(update()));
-        disconnect(this, SIGNAL(updated()), hsiH, SLOT(update()));
-        disconnect(hsiH, SIGNAL(hueUpdated(int)), this, SLOT(hueUpdate(int)));
-        disconnect(this, SIGNAL(hueUpdated(int)), hsiH, SLOT(hueUpdate(int)));
-        disconnect(this, SIGNAL(satUpdated(int, int)), hsiH, SLOT(satUpdate(int, int)));
-        disconnect(this, SIGNAL(toneUpdated(int, int)), hsiH, SLOT(toneUpdate(int, int)));
-    }
-
-    if (SlidersConfigArray[7]==true) {
-        visibleInputs.append(hsiS);
-        hsiS->setVisible(true);
-        connect(hsiS, SIGNAL(updated()), this, SLOT(update()));
-        connect(this, SIGNAL(updated()), hsiS, SLOT(update()));
-        connect(this, SIGNAL(hueUpdated(int)), hsiS, SLOT(hueUpdate(int)));
-        connect(hsiS, SIGNAL(satUpdated(int, int)), this, SLOT(satUpdate(int, int)));
-        connect(this, SIGNAL(satUpdated(int, int)), hsiS, SLOT(satUpdate(int, int)));
-        connect(this, SIGNAL(toneUpdated(int, int)), hsiS, SLOT(toneUpdate(int, int)));
-    }
-    else {
-        hsiS->setVisible(false);
-        disconnect(hsiS, SIGNAL(updated()), this,  SLOT(update()));
-        disconnect(this, SIGNAL(updated()), hsiS, SLOT(update()));
-        disconnect(this, SIGNAL(hueUpdated(int)), hsiS, SLOT(hueUpdate(int)));
-        disconnect(hsiS, SIGNAL(satUpdated(int, int)), this, SLOT(satUpdate(int, int)));
-        disconnect(this, SIGNAL(satUpdated(int, int)), hsiS, SLOT(satUpdate(int, int)));
-        disconnect(this, SIGNAL(toneUpdated(int, int)), hsiS, SLOT(toneUpdate(int, int)));
-    }
-
-    if (SlidersConfigArray[8]==true) {
-        visibleInputs.append(hsiI);
-        hsiI->setVisible(true);
-        connect(hsiI, SIGNAL(updated()), this, SLOT(update()));
-        connect(this, SIGNAL(updated()), hsiI, SLOT(update()));
-        connect(this, SIGNAL(hueUpdated(int)), hsiI, SLOT(hueUpdate(int)));
-        connect(this, SIGNAL(satUpdated(int, int)), hsiI, SLOT(satUpdate(int, int)));
-        connect(this, SIGNAL(toneUpdated(int, int)), hsiI, SLOT(toneUpdate(int, int)));
-        connect(hsiI, SIGNAL(toneUpdated(int, int)), this, SLOT(toneUpdate(int, int)));
-    }
-    else {
-        hsiI->setVisible(false);
-        disconnect(hsiI, SIGNAL(updated()), this, SLOT(update()));
-        disconnect(this, SIGNAL(updated()), hsiI, SLOT(update()));
-        disconnect(this, SIGNAL(hueUpdated(int)), hsiI, SLOT(hueUpdate(int)));
-        disconnect(this, SIGNAL(satUpdated(int, int)), hsiI, SLOT(satUpdate(int, int)));
-        disconnect(this, SIGNAL(toneUpdated(int, int)), hsiI, SLOT(toneUpdate(int, int)));
-        disconnect(hsiI, SIGNAL(toneUpdated(int, int)), this, SLOT(toneUpdate(int, int)));
-    }
-
-    if (SlidersConfigArray[9]==true) {
-        visibleInputs.append(hsyH);
-        hsyH->setVisible(true);
-        connect(hsyH, SIGNAL(updated()), this, SLOT(update()));
-        connect(this, SIGNAL(updated()), hsyH, SLOT(update()));
-        connect(hsyH, SIGNAL(hueUpdated(int)), this, SLOT(hueUpdate(int)));
-        connect(this, SIGNAL(hueUpdated(int)), hsyH, SLOT(hueUpdate(int)));
-        connect(this, SIGNAL(satUpdated(int, int)), hsyH, SLOT(satUpdate(int, int)));
-        connect(this, SIGNAL(toneUpdated(int, int)), hsyH, SLOT(toneUpdate(int, int)));
-    }
-    else {
-        hsyH->setVisible(false);
-        disconnect(hsyH, SIGNAL(updated()), this, SLOT(update()));
-        disconnect(this, SIGNAL(updated()), hsyH, SLOT(update()));
-        disconnect(hsyH, SIGNAL(hueUpdated(int)), this, SLOT(hueUpdate(int)));
-        disconnect(this, SIGNAL(hueUpdated(int)), hsyH, SLOT(hueUpdate(int)));
-        disconnect(this, SIGNAL(satUpdated(int, int)), hsyH, SLOT(satUpdate(int, int)));
-        disconnect(this, SIGNAL(toneUpdated(int, int)), hsyH, SLOT(toneUpdate(int, int)));
-    }
-
-    if (SlidersConfigArray[10]==true) {
-        visibleInputs.append(hsyS);
-        hsyS->setVisible(true);
-        connect(hsyS, SIGNAL(updated()), this, SLOT(update()));
-        connect(this, SIGNAL(updated()), hsyS, SLOT(update()));
-        connect(this, SIGNAL(hueUpdated(int)), hsyS, SLOT(hueUpdate(int)));
-        connect(hsyS, SIGNAL(satUpdated(int, int)), this, SLOT(satUpdate(int, int)));
-        connect(this, SIGNAL(satUpdated(int, int)), hsyS, SLOT(satUpdate(int, int)));
-        connect(this, SIGNAL(toneUpdated(int, int)), hsyS, SLOT(toneUpdate(int, int)));
-    }
-    else {
-        hsyS->setVisible(false);
-        disconnect(hsyS, SIGNAL(updated()), this, SLOT(update()));
-        disconnect(this, SIGNAL(updated()), hsyS, SLOT(update()));
-        disconnect(this, SIGNAL(hueUpdated(int)), hsyS, SLOT(hueUpdate(int)));
-        disconnect(hsyS, SIGNAL(satUpdated(int, int)), this, SLOT(satUpdate(int, int)));
-        disconnect(this, SIGNAL(satUpdated(int, int)), hsyS, SLOT(satUpdate(int, int)));
-        disconnect(this, SIGNAL(toneUpdated(int, int)), hsyS, SLOT(toneUpdate(int, int)));
-    }
-
-    if (SlidersConfigArray[11]==true) {
-        visibleInputs.append(hsyY);
-        hsyY->setVisible(true);
-        connect(hsyY, SIGNAL(updated()), this, SLOT(update()));
-        connect(this, SIGNAL(updated()), hsyY, SLOT(update()));
-        connect(this, SIGNAL(hueUpdated(int)), hsyY, SLOT(hueUpdate(int)));
-        connect(this, SIGNAL(satUpdated(int, int)), hsyY, SLOT(satUpdate(int, int)));
-        connect(this, SIGNAL(toneUpdated(int, int)), hsyY, SLOT(toneUpdate(int, int)));
-        connect(hsyY, SIGNAL(toneUpdated(int, int)), this, SLOT(toneUpdate(int, int)));
-    }
-    else {
-        hsyY->setVisible(false);
-        disconnect(hsyY, SIGNAL(updated()), this, SLOT(update()));
-        disconnect(this, SIGNAL(updated()), hsyY, SLOT(update()));
-        disconnect(this, SIGNAL(hueUpdated(int)), hsyY, SLOT(hueUpdate(int)));
-        disconnect(this, SIGNAL(satUpdated(int, int)), hsyY, SLOT(satUpdate(int, int)));
-        disconnect(this, SIGNAL(toneUpdated(int, int)), hsyY, SLOT(toneUpdate(int, int)));
-        disconnect(hsyY, SIGNAL(toneUpdated(int, int)), this, SLOT(toneUpdate(int, int)));
-    }
-
-    QList<QLabel*> labels;
-    int labelWidth = 0;
-
-    Q_FOREACH (KisColorSliderInput* input, visibleInputs) {
-        Q_FOREACH (QLabel* label, input->findChildren<QLabel*>()) {
-            labels.append(label);
-            labelWidth = qMax(labelWidth, label->sizeHint().width());
-        }
-    }
-
-    Q_FOREACH (QLabel *label, labels) {
-        label->setMinimumWidth(labelWidth);
-    }
-
-
-    updateTimeout();
-}
-void KisColorSliderWidget::slotConfigChanged()
-{
-    if (m_updateAllowed) {
-        m_configCompressor->start();
-    }
-}
-
-void KisColorSliderWidget::setConfig()
-{
-    //QTimer::singleShot(1, this, SLOT(update()));//need to wait a bit before accessing the config.
-
-    QBitArray m_SlidersConfigArray(12);
-    //dbgKrita<<"check";
-    KConfigGroup cfg =  KSharedConfig::openConfig()->group("hsxColorSlider");
-
-    m_SlidersConfigArray[0] =cfg.readEntry("hsvH", false);
-    m_SlidersConfigArray[1] =cfg.readEntry("hsvS", false);
-    m_SlidersConfigArray[2] =cfg.readEntry("hsvV", false);
-    
-    m_SlidersConfigArray[3] =cfg.readEntry("hslH", true);
-    m_SlidersConfigArray[4] =cfg.readEntry("hslS", true);
-    m_SlidersConfigArray[5] =cfg.readEntry("hslL", true);
-    
-    m_SlidersConfigArray[6] =cfg.readEntry("hsiH", false);
-    m_SlidersConfigArray[7] =cfg.readEntry("hsiS", false);
-    m_SlidersConfigArray[8] =cfg.readEntry("hsiI", false);
-    
-    m_SlidersConfigArray[9] =cfg.readEntry("hsyH", false);
-    m_SlidersConfigArray[10]=cfg.readEntry("hsyS", false);
-    m_SlidersConfigArray[11]=cfg.readEntry("hsyY", false);
-    
-    setSlidersVisible(m_SlidersConfigArray);
-    
-}
-
-void KisColorSliderWidget::hueUpdate(int h)
-{
-    emit(hueUpdated(h));
-}
-
-void KisColorSliderWidget::satUpdate(int s, int type)
-{
-    emit(satUpdated(s, type));
-}
-void KisColorSliderWidget::toneUpdate(int l, int type)
-{
-    emit(toneUpdated(l, type));
-}
-
-#include "moc_kis_color_slider_widget.cpp"
diff --git a/plugins/dockers/colorslider/kis_color_slider_widget.h b/plugins/dockers/colorslider/kis_color_slider_widget.h
deleted file mode 100644
index 89fa226a93..0000000000
--- a/plugins/dockers/colorslider/kis_color_slider_widget.h
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- *  Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
- *  Copyright (c) 2014 Wolthera van Hövell <griffinvalley@gmail.com>
-
- *
- *  This library is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser General Public License as published by
- *  the Free Software Foundation; version 2.1 of the License.
- *
- *  This library is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU Lesser General Public License for more details.
- *
- *  You should have received a copy of the GNU Lesser General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-
-#ifndef _KIS_COLOR_SLIDER_WIDGET_H_
-#define _KIS_COLOR_SLIDER_WIDGET_H_
-
-#include <QWidget>
-#include <QPointer>
-
-#include <KoColor.h>
-
-#include "kis_canvas2.h"
-
-class KoColorSpace;
-class KoColorDisplayRendererInterface;
-class QVBoxLayout;
-class KisColorSliderInput;
-class KisSignalCompressor;
-class QBitArray;
-
-class KisColorSliderWidget : public QWidget
-{
-    Q_OBJECT
-public:
-    KisColorSliderWidget(KoColorDisplayRendererInterface *displayRenderer, QWidget* parent, KisCanvas2* canvas, QBitArray SlidersConfigArray);
-    ~KisColorSliderWidget() override;
-
-    //bool customColorSpaceUsed();
-public Q_SLOTS:
-    //void setColorSpace(const KoColorSpace*);
-    void setColor(const KoColor&);
-    void slotConfigChanged();
-private Q_SLOTS:
-    void update();
-    void updateTimeout();
-    void hueUpdate(int h);
-    void satUpdate(int s, int type);
-    void toneUpdate(int l, int type);
-    void setSlidersVisible(QBitArray SlidersConfigArray);
-    void setConfig();
-    //void setCustomColorSpace(const KoColorSpace *);
-Q_SIGNALS:
-    void colorChanged(const KoColor&);
-    void updated();
-    void hueUpdated(int);
-    void satUpdated(int, int);
-    void toneUpdated(int, int);
-private:
-    QList<KisColorSliderInput*> m_inputs;
-//    const KoColorSpace* m_colorSpace;
-    QVBoxLayout *m_layout;
-    KoColor m_color;
-    bool m_updateAllowed;
-    KisSignalCompressor *m_updateCompressor;
-    KisSignalCompressor *m_configCompressor;
-    KoColorDisplayRendererInterface *m_displayRenderer;
-    QPointer<KisCanvas2> m_canvas;
-    KisColorSliderInput* hsvH;
-    KisColorSliderInput* hsvS;
-    KisColorSliderInput* hsvV;
-    KisColorSliderInput* hslH;
-    KisColorSliderInput* hslS;
-    KisColorSliderInput* hslL;
-    KisColorSliderInput* hsiH;
-    KisColorSliderInput* hsiS;
-    KisColorSliderInput* hsiI;
-    KisColorSliderInput* hsyH;
-    KisColorSliderInput* hsyS;
-    KisColorSliderInput* hsyY;
-};
-#endif
diff --git a/plugins/dockers/colorslider/kis_hsv_slider.cpp b/plugins/dockers/colorslider/kis_hsv_slider.cpp
deleted file mode 100644
index 354eb3eb93..0000000000
--- a/plugins/dockers/colorslider/kis_hsv_slider.cpp
+++ /dev/null
@@ -1,268 +0,0 @@
-/* This file is part of the KDE project
-   Copyright (C) 2006 Sven Langkamp <sven.langkamp@gmail.com>
-   Copyright (c) 2009 Cyrille Berger <cberger@cberger.net>
-   Copyright (c) 2014 Wolthera van Hövell <griffinvalley@gmail.com>
-   Copyright (c) 2015 Moritz Molch <kde@moritzmolch.de>
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public
-   License as published by the Free Software Foundation; either
-   version 2 of the License, or (at your option) any later version.
-
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public License
-   along with this library; see the file COPYING.LIB.  If not, write to
-   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
-*/
-#include "kis_hsv_slider.h"
-#include "KoColorSpace.h"
-
-#include <KoColor.h>
-#include <KoMixColorsOp.h>
-#include <QPainter>
-#include <QTimer>
-#include <QStyleOption>
-
-#include "kis_display_color_converter.h"
-
-#define ARROWSIZE 8
-
-struct KisHSVSlider::Private
-{
-    Private() : upToDate(false), displayRenderer(0) {}
-    KoColor currentColorF;
-    int HSVtype;
-    KoColor minColor;
-    qreal hue_b;
-    QPixmap pixmap;
-    bool upToDate;
-    KoColorDisplayRendererInterface *displayRenderer;
-};
-
-KisHSVSlider::KisHSVSlider(QWidget* parent, KoColorDisplayRendererInterface *displayRenderer)
-  : KSelector(parent), d(new Private),
-  R(0),
-  G(0),
-  B(0),
-  Gamma(0)
-{
-    setMaximum(255);
-    d->displayRenderer = displayRenderer;
-    connect(d->displayRenderer, SIGNAL(displayConfigurationChanged()), SLOT(update()));
-}
-
-KisHSVSlider::KisHSVSlider(Qt::Orientation o, QWidget *parent, KoColorDisplayRendererInterface *displayRenderer, KisCanvas2* canvas)
-  : KSelector(o, parent), d(new Private), m_canvas(canvas)
-{
-    setMaximum(255);
-    d->displayRenderer = displayRenderer;
-    connect(d->displayRenderer, SIGNAL(displayConfigurationChanged()), SLOT(update()));
-}
-
-KisHSVSlider::~KisHSVSlider()
-{
-    delete d;
-}
-
-
-void KisHSVSlider::setColors(const KoColor& currentc, const int type, qreal hue_backup, qreal l_R, qreal l_G, qreal l_B, qreal gamma)
-{
-    d->currentColorF = currentc;
-//    KoColor c = currentc;
-    d->HSVtype = type;
-    d->hue_b = hue_backup/360.0f;
-    R=l_R;
-    G=l_G;
-    B=l_B;
-    Gamma=gamma;
-
-    d->upToDate = false;
-
-    QTimer::singleShot(1, this, SLOT(update()));
-}
-
-void KisHSVSlider::drawContents( QPainter *painter )
-{
-    QPixmap checker(8, 8);
-    QPainter p(&checker);
-    p.fillRect(0, 0, 4, 4, Qt::lightGray);
-    p.fillRect(4, 0, 4, 4, Qt::darkGray);
-    p.fillRect(0, 4, 4, 4, Qt::darkGray);
-    p.fillRect(4, 4, 4, 4, Qt::lightGray);
-    p.end();
-    QRect contentsRect_(contentsRect());
-    painter->fillRect(contentsRect_, QBrush(checker));
-
-    if( !d->upToDate || d->pixmap.isNull() || d->pixmap.width() != contentsRect_.width()
-        || d->pixmap.height() != contentsRect_.height() )
-    {
-        KoColor c = d->currentColorF; // smart way to fetch colorspace
-        QColor color;
-        int type = d->HSVtype;
-
-        QImage image(contentsRect_.width(), contentsRect_.height(), QImage::Format_ARGB32 );
-
-        if( orientation() == Qt::Horizontal ) {
-            for (int x = 0; x < contentsRect_.width(); x++) {
-
-                qreal t = static_cast<qreal>(x) / (contentsRect_.width() - 1);
-                t = 1.0-t;
-
-                //function find current color from hsv thingymabobs.
-                c = HSXcolor(type, t);
-
-                color = d->displayRenderer->toQColor(c);
-
-                for (int y = 0; y < contentsRect_.height(); y++)
-                image.setPixel(x, y, color.rgba());
-            }
-        }
-        else {
-            for (int y = 0; y < contentsRect_.height(); y++) {
-
-                qreal t = static_cast<qreal>(y) / (contentsRect_.height() - 1);
-
-                c = HSXcolor(type, t);
-
-                color = d->displayRenderer->toQColor(c);
-
-                for (int x = 0; x < contentsRect_.width(); x++)
-                image.setPixel(x, y, color.rgba());
-            }
-        }
-        d->pixmap = QPixmap::fromImage(image);
-        d->upToDate = true;
-    }
-    painter->drawPixmap( contentsRect_, d->pixmap, QRect( 0, 0, d->pixmap.width(), d->pixmap.height()) );
-}
-
-KoColor KisHSVSlider::currentColor() const
-{
-    KoColor c(d->minColor.colorSpace());
-    int type = d->HSVtype;
-    qreal t = (value() - minimum()) / qreal(maximum() - minimum()) * 255;
-    c = HSXcolor(type, t);
-    return c;
-}
-
-KoColor KisHSVSlider::HSXcolor(int type, qreal t) const
-{
-    KoColor coordinate_color(d->currentColorF.colorSpace());
-    KoColor c = d->currentColorF;
-    qreal hue, sat, val;
-    qreal hue_backup = d->hue_b;
-
-    switch(type){
-        case 0:
-            this->converter()->getHsvF(c, &hue, &sat, &val);
-            coordinate_color = this->converter()->fromHsvF( (1.0 - t) , sat, val);
-            break;//hsv hue
-        case 1:
-            this->converter()->getHsvF(c, &hue, &sat, &val);
-            if (sat<=0.0 && t<1.0) {
-                hue=hue_backup;
-                }
-            coordinate_color = this->converter()->fromHsvF( hue, (1.0 - t), val);
-            break;//hsv sat
-        case 2:
-            this->converter()->getHsvF(c, &hue, &sat, &val);
-            coordinate_color = this->converter()->fromHsvF( hue, sat, (1.0 - t));
-            break;//hsv value
-        case 3:
-            this->converter()->getHslF(c, &hue, &sat, &val);
-            coordinate_color = this->converter()->fromHslF( (1.0 - t) , sat, val);
-            break;//hsl hue
-        case 4:
-            this->converter()->getHslF(c, &hue, &sat, &val);
-            if (sat<=0.0 && t<1.0) {
-                hue=hue_backup;
-                }
-            coordinate_color = this->converter()->fromHslF( hue, (1.0 - t), val);
-            break;//hsl sat
-        case 5:
-            this->converter()->getHslF(c, &hue, &sat, &val);
-            coordinate_color = this->converter()->fromHslF( hue, sat, (1.0 - t));
-            break;//hsl value
-        case 6:
-            this->converter()->getHsiF(c, &hue, &sat, &val);
-            coordinate_color = this->converter()->fromHsiF( (1.0 - t) , sat, val);
-            break;//hsi hue
-        case 7:
-            this->converter()->getHsiF(c, &hue, &sat, &val);
-            if (sat<=0.0 && t<1.0) {
-                hue=hue_backup;
-                }
-            coordinate_color = this->converter()->fromHsiF( hue, (1.0 - t), val);
-            break;//hsi sat
-        case 8:
-            this->converter()->getHsiF(c, &hue, &sat, &val);
-            coordinate_color = this->converter()->fromHsiF( hue, sat, (1.0 - t));
-            break;//hsi value
-        case 9:
-            this->converter()->getHsyF(c, &hue, &sat, &val, R, G, B, Gamma);
-            coordinate_color = this->converter()->fromHsyF( (1.0 - t) , sat, val, R, G, B, Gamma);
-            break;//hsy hue
-        case 10:
-            this->converter()->getHsyF(c, &hue, &sat, &val, R, G, B, Gamma);
-            if (sat==0 && (1.0-t)>0) {
-                hue=hue_backup;
-                }
-            coordinate_color = this->converter()->fromHsyF( hue, (1.0 - t), val, R, G, B, Gamma);
-            break;//hsy sat
-        case 11:
-            this->converter()->getHsyF(c, &hue, &sat, &val, R, G, B, Gamma);
-            coordinate_color = this->converter()->fromHsyF( hue, sat, (1.0 - t), R, G, B, Gamma);
-            break;//hsy value
-        }
-    return coordinate_color;
-}
-
-KisDisplayColorConverter* KisHSVSlider::converter() const
-{
-    return m_canvas ?
-        m_canvas->displayColorConverter() :
-        KisDisplayColorConverter::dumbConverterInstance();
-}
-
-void KisHSVSlider::drawArrow(QPainter *painter, const QPoint &pos)
-{
-    painter->setPen(palette().text().color());
-    painter->setBrush(palette().text());
-
-    QStyleOption o;
-    o.initFrom(this);
-    o.state &= ~QStyle::State_MouseOver;
-
-    if ( orientation() == Qt::Vertical ) {
-        o.rect = QRect( pos.x(), pos.y() - ARROWSIZE / 2,
-                        ARROWSIZE, ARROWSIZE );
-    } else {
-        o.rect = QRect( pos.x() - ARROWSIZE / 2, pos.y(),
-                        ARROWSIZE, ARROWSIZE );
-    }
-
-    QStyle::PrimitiveElement arrowPE;
-    switch (arrowDirection()) {
-    case Qt::UpArrow:
-        arrowPE = QStyle::PE_IndicatorArrowUp;
-        break;
-    case Qt::DownArrow:
-        arrowPE = QStyle::PE_IndicatorArrowDown;
-        break;
-    case Qt::RightArrow:
-        arrowPE = QStyle::PE_IndicatorArrowRight;
-        break;
-    case Qt::LeftArrow:
-    default:
-        arrowPE = QStyle::PE_IndicatorArrowLeft;
-        break;
-    }
-
-    style()->drawPrimitive(arrowPE, &o, painter, this);
-
-}
diff --git a/plugins/dockers/colorslider/kis_hsv_slider.h b/plugins/dockers/colorslider/kis_hsv_slider.h
deleted file mode 100644
index e447c52271..0000000000
--- a/plugins/dockers/colorslider/kis_hsv_slider.h
+++ /dev/null
@@ -1,62 +0,0 @@
-/* This file is part of the KDE project
-   Copyright (C) 2006 Sven Langkamp <sven.langkamp@gmail.com>
-   Copyright (C) 2014 Wolthera van Hövell <griffinvalley@gmail.com>
-   Copyright (c) 2015 Moritz Molch <kde@moritzmolch.de>
-
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU 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_HSVSLIDER_H
-#define KIS_HSVSLIDER_H
-
-#include <QPointer>
-
-#include <kselector.h>
-#include "KoColorDisplayRendererInterface.h"
-#include "kis_canvas2.h"
-
-
-class KoColor;
-class KisDisplayColorConverter;
-
-class KisHSVSlider : public KSelector
-{
-    Q_OBJECT
-public:
-    explicit KisHSVSlider(QWidget *parent = 0, KoColorDisplayRendererInterface *displayRenderer = KoDumbColorDisplayRenderer::instance());
-    explicit KisHSVSlider(Qt::Orientation orientation, QWidget *parent = 0, KoColorDisplayRendererInterface *displayRenderer = KoDumbColorDisplayRenderer::instance(), KisCanvas2* canvas = 0);
-    ~KisHSVSlider() override;
-
-public:
-    void setColors( const KoColor& currentcolor, const int type, qreal hue_backup, qreal l_R=0.2126, qreal l_G=0.7152, qreal l_B=0.0722, qreal gamma=2.2);
-    /**
-     * Return the current color
-     */
-    KoColor currentColor() const;
-    KoColor HSXcolor(int type, qreal t) const;
-    KisDisplayColorConverter* converter() const;
-protected:
-    void drawContents( QPainter* ) override;
-    void drawArrow(QPainter *painter, const QPoint &pos) override;
-    struct Private;
-    Private* const d;
-private:
-    qreal R, G, B, Gamma;
-    KoColorDisplayRendererInterface *m_displayRenderer;
-    QPointer<KisCanvas2> m_canvas;
-};
-
-#endif
diff --git a/plugins/dockers/colorslider/krita_colorslider.json b/plugins/dockers/colorslider/krita_colorslider.json
deleted file mode 100644
index d8d9f7a7a5..0000000000
--- a/plugins/dockers/colorslider/krita_colorslider.json
+++ /dev/null
@@ -1,9 +0,0 @@
-{
-    "Id": "ColorSlider",
-    "Type": "Service",
-    "X-KDE-Library": "kritacolorslider",
-    "X-KDE-ServiceTypes": [
-        "Krita/Dock"
-    ],
-    "X-Krita-Version": "28"
-}
diff --git a/plugins/extensions/animationrenderer/DlgAnimationRenderer.cpp b/plugins/extensions/animationrenderer/DlgAnimationRenderer.cpp
index 70dfd6bf80..daf29cc5b2 100644
--- a/plugins/extensions/animationrenderer/DlgAnimationRenderer.cpp
+++ b/plugins/extensions/animationrenderer/DlgAnimationRenderer.cpp
@@ -1,627 +1,627 @@
 /*
  *  Copyright (c) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "DlgAnimationRenderer.h"
 
 #include <QStandardPaths>
 #include <QPluginLoader>
 #include <QJsonObject>
 #include <QMessageBox>
 #include <QStringList>
 #include <QProcess>
 
 #include <klocalizedstring.h>
 #include <kpluginfactory.h>
 
 #include <KoResourcePaths.h>
 #include <kis_properties_configuration.h>
 #include <kis_debug.h>
 #include <KisMimeDatabase.h>
 #include <KoJsonTrader.h>
 #include <KisImportExportFilter.h>
 #include <kis_image.h>
 #include <kis_image_animation_interface.h>
 #include <kis_time_range.h>
 #include <KisImportExportManager.h>
 #include <kis_config_widget.h>
 #include <KisDocument.h>
 #include <QHBoxLayout>
 #include <KisImportExportFilter.h>
 #include <kis_config.h>
 #include <kis_file_name_requester.h>
 #include <KisDocument.h>
 #include <KoDialog.h>
 #include "kis_slider_spin_box.h"
 #include "kis_acyclic_signal_connector.h"
 
 DlgAnimationRenderer::DlgAnimationRenderer(KisDocument *doc, QWidget *parent)
     : KoDialog(parent)
     , m_image(doc->image())
     , m_doc(doc)
     , m_defaultFileName(QFileInfo(doc->url().toLocalFile()).completeBaseName())
 {
     KisConfig cfg;
 
     setCaption(i18n("Render Animation"));
     setButtons(Ok | Cancel);
     setDefaultButton(Ok);
 
     if (m_defaultFileName.isEmpty()) {
         m_defaultFileName = i18n("Untitled");
     }
 
     m_page = new WdgAnimationRenderer(this);
     m_page->layout()->setMargin(0);
 
     m_page->dirRequester->setMode(KoFileDialog::OpenDirectory);
     QString lastLocation = cfg.readEntry<QString>("AnimationRenderer/last_sequence_export_location", QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
     m_page->dirRequester->setFileName(lastLocation);
 
     m_page->intStart->setMinimum(doc->image()->animationInterface()->fullClipRange().start());
     m_page->intStart->setMaximum(doc->image()->animationInterface()->fullClipRange().end());
     m_page->intStart->setValue(doc->image()->animationInterface()->playbackRange().start());
 
     m_page->intEnd->setMinimum(doc->image()->animationInterface()->fullClipRange().start());
    //m_page->intEnd->setMaximum(doc->image()->animationInterface()->fullClipRange().end()); // animators sometimes want to export after end frame
     m_page->intEnd->setValue(doc->image()->animationInterface()->playbackRange().end());
 
 
 
     m_page->intHeight->setMinimum(1);
     m_page->intHeight->setMaximum(10000);
     m_page->intHeight->setValue(doc->image()->height());
 
     m_page->intWidth->setMinimum(1);
     m_page->intWidth->setMaximum(10000);
     m_page->intWidth->setValue(doc->image()->width());
 
 
     // try to lock the width and height being updated
 
     KisAcyclicSignalConnector *constrainsConnector = new KisAcyclicSignalConnector(this);
     constrainsConnector->createCoordinatedConnector()->connectBackwardInt(m_page->intWidth, SIGNAL(valueChanged(int)), this, SLOT(slotLockAspectRatioDimensionsWidth(int)));
     constrainsConnector->createCoordinatedConnector()->connectForwardInt(m_page->intHeight, SIGNAL(valueChanged(int)), this, SLOT(slotLockAspectRatioDimensionsHeight(int)));
 
     m_page->intFramesPerSecond->setValue(doc->image()->animationInterface()->framerate());
 
     QFileInfo audioFileInfo(doc->image()->animationInterface()->audioChannelFileName());
     const bool hasAudio = audioFileInfo.exists();
     m_page->chkIncludeAudio->setEnabled(hasAudio);
     m_page->chkIncludeAudio->setChecked(hasAudio && !doc->image()->animationInterface()->isAudioMuted());
 
-    QStringList mimes = KisImportExportManager::mimeFilter(KisImportExportManager::Export);
+    QStringList mimes = KisImportExportManager::supportedMimeTypes(KisImportExportManager::Export);
     mimes.sort();
     Q_FOREACH(const QString &mime, mimes) {
         QString description = KisMimeDatabase::descriptionForMimeType(mime);
         if (description.isEmpty()) {
             description = mime;
         }
         m_page->cmbMimetype->addItem(description, mime);
         if (mime == "image/png") {
             m_page->cmbMimetype->setCurrentIndex(m_page->cmbMimetype->count() - 1);
         }
 
     }
 
     setMainWidget(m_page);
 
     QList<QPluginLoader *>list = KoJsonTrader::instance()->query("Krita/AnimationExporter", "");
     Q_FOREACH(QPluginLoader *loader, list) {
         QJsonObject json = loader->metaData().value("MetaData").toObject();
         QStringList mimetypes = json.value("X-KDE-Export").toString().split(",");
         Q_FOREACH(const QString &mime, mimetypes) {
 
             KLibFactory *factory = qobject_cast<KLibFactory *>(loader->instance());
             if (!factory) {
                 warnUI << loader->errorString();
                 continue;
             }
 
             QObject* obj = factory->create<KisImportExportFilter>(0);
             if (!obj || !obj->inherits("KisImportExportFilter")) {
                 delete obj;
                 continue;
             }
 
             QSharedPointer<KisImportExportFilter>filter(static_cast<KisImportExportFilter*>(obj));
             if (!filter) {
                 delete obj;
                 continue;
             }
 
             m_renderFilters.append(filter);
 
             QString description = KisMimeDatabase::descriptionForMimeType(mime);
             if (description.isEmpty()) {
                 description = mime;
             }
             m_page->cmbRenderType->addItem(description, mime);
 
         }
     }
     m_page->videoFilename->setMode(KoFileDialog::SaveFile);
     m_page->videoFilename->setStartDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
 
     qDeleteAll(list);
 
     connect(m_page->bnExportOptions, SIGNAL(clicked()), this, SLOT(sequenceMimeTypeSelected()));
     connect(m_page->bnRenderOptions, SIGNAL(clicked()), this, SLOT(selectRenderOptions()));
 
     m_page->ffmpegLocation->setFileName(findFFMpeg());
     m_page->ffmpegLocation->setMode(KoFileDialog::OpenFile);
     connect(m_page->ffmpegLocation, SIGNAL(fileSelected(QString)), this, SLOT(ffmpegLocationChanged(QString)));
 
     m_page->cmbRenderType->setCurrentIndex(cfg.readEntry<int>("AnimationRenderer/render_type", 0));
 
 
     connect(m_page->shouldExportOnlyImageSequence, SIGNAL(toggled(bool)), this, SLOT(slotExportTypeChanged()));
     connect(m_page->shouldExportOnlyVideo, SIGNAL(toggled(bool)), this, SLOT(slotExportTypeChanged()));
     connect(m_page->shouldExportAll, SIGNAL(toggled(bool)), this, SLOT(slotExportTypeChanged()));
 
     updateExportUIOptions();
 
     // connect and cold init
     connect(m_page->cmbRenderType, SIGNAL(currentIndexChanged(int)), this, SLOT(selectRenderType(int)));
     selectRenderType(m_page->cmbRenderType->currentIndex());
 
     resize(m_page->sizeHint());
 }
 
 DlgAnimationRenderer::~DlgAnimationRenderer()
 {
     KisConfig cfg;
 
     cfg.writeEntry<QString>("AnimationRenderer/last_sequence_export_location", m_page->dirRequester->fileName());
     cfg.writeEntry<int>("AnimationRenderer/render_type", m_page->cmbRenderType->currentIndex());
     cfg.setCustomFFMpegPath(m_page->ffmpegLocation->fileName());
 
     if (m_encoderConfigWidget)  {
         m_encoderConfigWidget->setParent(0);
         m_encoderConfigWidget->deleteLater();
     }
     if (m_frameExportConfigWidget) {
         m_frameExportConfigWidget->setParent(0);
         m_frameExportConfigWidget->deleteLater();
     }
 
     delete m_page;
 
 }
 
 QString DlgAnimationRenderer::fetchRenderingDirectory() const
 {
     QString result = m_page->dirRequester->fileName();
 
     if (m_page->shouldExportOnlyVideo->isChecked()) {
         const QFileInfo info(fetchRenderingFileName());
 
         if (info.isAbsolute()) {
             result = info.absolutePath();
         }
     }
 
     return result;
 }
 
 QString DlgAnimationRenderer::fetchRenderingFileName() const
 {
     QString filename = m_page->videoFilename->fileName();
 
     if (QFileInfo(filename).completeSuffix().isEmpty()) {
         QString mimetype = m_page->cmbRenderType->itemData(m_page->cmbRenderType->currentIndex()).toString();
         filename += "." + KisMimeDatabase::suffixesForMimeType(mimetype).first();
     }
 
     if (QFileInfo(filename).isRelative()) {
         QDir baseDir(m_page->dirRequester->fileName());
 
         if (m_page->shouldExportOnlyVideo->isChecked()) {
             QString documentDir = QFileInfo(m_doc->url().toLocalFile()).absolutePath();
             if (!documentDir.isEmpty()) {
                 baseDir = documentDir;
             }
         }
 
         filename = baseDir.absoluteFilePath(filename);
     }
 
     return filename;
 }
 
 KisPropertiesConfigurationSP DlgAnimationRenderer::getSequenceConfiguration() const
 {
     KisPropertiesConfigurationSP cfg = new KisPropertiesConfiguration();
     cfg->setProperty("basename", m_page->txtBasename->text());
     cfg->setProperty("last_document_path", m_doc->localFilePath());
     cfg->setProperty("directory", fetchRenderingDirectory());
     cfg->setProperty("first_frame", m_page->intStart->value());
     cfg->setProperty("last_frame", m_page->intEnd->value());
     cfg->setProperty("sequence_start", m_page->sequenceStart->value());
     cfg->setProperty("mimetype", m_page->cmbMimetype->currentData().toString());
     return cfg;
 }
 
 void DlgAnimationRenderer::setSequenceConfiguration(KisPropertiesConfigurationSP cfg)
 {
     m_page->txtBasename->setText(cfg->getString("basename", "frame"));
 
     if (cfg->getString("last_document_path") != m_doc->localFilePath()) {
         cfg->removeProperty("first_frame");
         cfg->removeProperty("last_frame");
         cfg->removeProperty("sequence_start");
     }
 
     m_page->dirRequester->setFileName(cfg->getString("directory", QStandardPaths::writableLocation(QStandardPaths::PicturesLocation)));
     m_page->intStart->setValue(cfg->getInt("first_frame", m_image->animationInterface()->playbackRange().start()));
     m_page->intEnd->setValue(cfg->getInt("last_frame", m_image->animationInterface()->playbackRange().end()));
     m_page->sequenceStart->setValue(cfg->getInt("sequence_start", m_image->animationInterface()->playbackRange().start()));
 
     QString mimetype = cfg->getString("mimetype");
     for (int i = 0; i < m_page->cmbMimetype->count(); ++i) {
         if (m_page->cmbMimetype->itemData(i).toString() == mimetype) {
             m_page->cmbMimetype->setCurrentIndex(i);
             break;
         }
     }
 }
 
 KisPropertiesConfigurationSP DlgAnimationRenderer::getFrameExportConfiguration() const
 {
     if (m_frameExportConfigWidget) {
         KisPropertiesConfigurationSP cfg = m_frameExportConfigWidget->configuration();
         cfg->setProperty("basename", m_page->txtBasename->text());
         cfg->setProperty("directory", fetchRenderingDirectory());
         cfg->setProperty("first_frame", m_page->intStart->value());
         cfg->setProperty("last_frame", m_page->intEnd->value());
         cfg->setProperty("sequence_start", m_page->sequenceStart->value());
         cfg->setProperty("ffmpeg_path", m_page->ffmpegLocation->fileName());
 
         return m_frameExportConfigWidget->configuration();
     }
     return 0;
 }
 
 KisPropertiesConfigurationSP DlgAnimationRenderer::getVideoConfiguration() const
 {
     // don't continue if we are only exporting image sequence
     if (m_page->shouldExportOnlyImageSequence->isChecked()) {
         return 0;
     }
 
     KisPropertiesConfigurationSP cfg = new KisPropertiesConfiguration();
     cfg->setProperty("filename", fetchRenderingFileName());
     cfg->setProperty("first_frame", m_page->intStart->value());
     cfg->setProperty("last_frame", m_page->intEnd->value());
     cfg->setProperty("sequence_start", m_page->sequenceStart->value());
 
     // delete image sequence if we are only exporting out video
     cfg->setProperty("delete_sequence", m_page->shouldExportOnlyVideo->isChecked());
 
 
     return cfg;
 }
 
 void DlgAnimationRenderer::setVideoConfiguration(KisPropertiesConfigurationSP /*cfg*/)
 {
 }
 
 KisPropertiesConfigurationSP DlgAnimationRenderer::getEncoderConfiguration() const
 {
     // don't continue if we are only exporting image sequence
     if (m_page->shouldExportOnlyImageSequence->isChecked()) {
         return 0;
     }
 
     KisPropertiesConfigurationSP cfg = new KisPropertiesConfiguration();
     if (m_encoderConfigWidget) {
         cfg = m_encoderConfigWidget->configuration();
     }
     cfg->setProperty("mimetype", m_page->cmbRenderType->currentData().toString());
     cfg->setProperty("directory", fetchRenderingDirectory());
     cfg->setProperty("first_frame", m_page->intStart->value());
     cfg->setProperty("last_frame", m_page->intEnd->value());
     cfg->setProperty("framerate", m_page->intFramesPerSecond->value());
     cfg->setProperty("height", m_page->intHeight->value());
     cfg->setProperty("width", m_page->intWidth->value());
     cfg->setProperty("sequence_start", m_page->sequenceStart->value());
     cfg->setProperty("include_audio", m_page->chkIncludeAudio->isChecked());
 
     return cfg;
 }
 
 void DlgAnimationRenderer::setEncoderConfiguration(KisPropertiesConfigurationSP cfg)
 {
     m_page->intHeight->setValue(cfg->getInt("height", int(m_image->height())));
     m_page->intWidth->setValue(cfg->getInt("width", int(m_image->width())));
     m_page->intFramesPerSecond->setValue(cfg->getInt("framerate", int(m_image->animationInterface()->framerate())));
 
     if (m_encoderConfigWidget) {
         m_encoderConfigWidget->setConfiguration(cfg);
     }
 }
 
 QSharedPointer<KisImportExportFilter> DlgAnimationRenderer::encoderFilter() const
 {
     if (m_page->cmbRenderType->currentIndex() < m_renderFilters.size()) {
         return m_renderFilters[m_page->cmbRenderType->currentIndex()];
     }
     return QSharedPointer<KisImportExportFilter>(0);
 }
 
 void DlgAnimationRenderer::selectRenderType(int index)
 {
     if (index >= m_renderFilters.size()) return;
     QString mimetype = m_page->cmbRenderType->itemData(index).toString();
 
     if (!m_page->videoFilename->fileName().isEmpty() && QFileInfo(m_page->videoFilename->fileName()).completeBaseName() != m_defaultFileName) {
         m_defaultFileName = QFileInfo(m_page->videoFilename->fileName()).completeBaseName();
     }
     m_page->videoFilename->setMimeTypeFilters(QStringList() << mimetype, mimetype);
 
     m_page->videoFilename->setFileName(m_defaultFileName + "." + KisMimeDatabase::suffixesForMimeType(mimetype).first());
 }
 
 void DlgAnimationRenderer::selectRenderOptions()
 {
     int index = m_page->cmbRenderType->currentIndex();
 
     if (m_encoderConfigWidget) {
         m_encoderConfigWidget->deleteLater();
         m_encoderConfigWidget = 0;
     }
 
     if (index >= m_renderFilters.size()) return;
 
     QSharedPointer<KisImportExportFilter> filter = m_renderFilters[index];
     QString mimetype = m_page->cmbRenderType->itemData(index).toString();
     if (filter) {
         m_encoderConfigWidget = filter->createConfigurationWidget(0, KisDocument::nativeFormatMimeType(), mimetype.toLatin1());
         if (m_encoderConfigWidget) {
             m_encoderConfigWidget->setConfiguration(filter->lastSavedConfiguration("", mimetype.toLatin1()));
             KoDialog dlg(this);
             dlg.setMainWidget(m_encoderConfigWidget);
             dlg.setButtons(KoDialog::Ok | KoDialog::Cancel);
             if (!dlg.exec()) {
                 m_encoderConfigWidget->setConfiguration(filter->lastSavedConfiguration());
             } else {
                 KisConfig().setExportConfiguration(mimetype.toLatin1(), m_encoderConfigWidget->configuration());
             }
             dlg.setMainWidget(0);
             m_encoderConfigWidget->hide();
             m_encoderConfigWidget->setParent(0);
         }
     }
     else {
         m_encoderConfigWidget = 0;
     }
 
 }
 
 void DlgAnimationRenderer::sequenceMimeTypeSelected()
 {
     int index = m_page->cmbMimetype->currentIndex();
 
     if (m_frameExportConfigWidget) {
         m_frameExportConfigWidget->deleteLater();
         m_frameExportConfigWidget = 0;
     }
 
     QString mimetype = m_page->cmbMimetype->itemData(index).toString();
     QSharedPointer<KisImportExportFilter> filter(KisImportExportManager::filterForMimeType(mimetype, KisImportExportManager::Export));
     if (filter) {
         m_frameExportConfigWidget = filter->createConfigurationWidget(0, KisDocument::nativeFormatMimeType(), mimetype.toLatin1());
         if (m_frameExportConfigWidget) {
             m_frameExportConfigWidget->setConfiguration(filter->lastSavedConfiguration("", mimetype.toLatin1()));
             KoDialog dlg(this);
             dlg.setMainWidget(m_frameExportConfigWidget);
             dlg.setButtons(KoDialog::Ok | KoDialog::Cancel);
             if (!dlg.exec()) {
                 m_frameExportConfigWidget->setConfiguration(filter->lastSavedConfiguration());
             }
             m_frameExportConfigWidget->hide();
             m_frameExportConfigWidget->setParent(0);
             dlg.setMainWidget(0);
         }
     }
 }
 
 void DlgAnimationRenderer::ffmpegLocationChanged(const QString &s)
 {
     KisConfig cfg;
     cfg.setCustomFFMpegPath(s);
 }
 
 void DlgAnimationRenderer::updateExportUIOptions() {
 
     KisConfig cfg;
 
     // read in what type to export to. Defaults to image sequence only
     QString exportType = cfg.readEntry<QString>("AnimationRenderer/export_type", "ImageSequence");
     if (exportType == "ImageSequence") {
         m_page->shouldExportOnlyImageSequence->setChecked(true);
     } else if (exportType == "Video") {
         m_page->shouldExportOnlyVideo->setChecked(true);
     } else {
         m_page->shouldExportAll->setChecked(true); // export to both
     }
 }
 
 void DlgAnimationRenderer::slotButtonClicked(int button)
 {
     if (button == KoDialog::Ok && !m_page->shouldExportOnlyImageSequence->isChecked()) {
         QString ffmpeg = m_page->ffmpegLocation->fileName();
         if (m_page->videoFilename->fileName().isEmpty()) {
             QMessageBox::warning(this, i18nc("@title:window", "Krita"), i18n("Please enter a file name to render to."));
             return;
         }
         else if (ffmpeg.isEmpty()) {
             QMessageBox::warning(this, i18nc("@title:window", "Krita"), i18n("The location of FFmpeg is unknown. Please install FFmpeg first: Krita cannot render animations without FFmpeg. (<a href=\"https://www.ffmpeg.org\">www.ffmpeg.org</a>)"));
             return;
         }
         else {
             QFileInfo fi(ffmpeg);
             if (!fi.exists()) {
                 QMessageBox::warning(this, i18nc("@title:window", "Krita"), i18n("The location of FFmpeg is invalid. Please select the correct location of the FFmpeg executable on your system."));
                 return;
             }
         }
     }
     KoDialog::slotButtonClicked(button);
 }
 
 QString DlgAnimationRenderer::findFFMpeg()
 {
     QString result;
 
     QStringList proposedPaths;
 
     QString customPath = KisConfig().customFFMpegPath();
     if (!customPath.isEmpty()) {
         proposedPaths << customPath;
         proposedPaths << customPath + QDir::separator() + "ffmpeg";
     }
 
 #ifndef Q_OS_WIN
     proposedPaths << QDir::homePath() + "/bin/ffmpeg";
     proposedPaths << "/usr/bin/ffmpeg";
     proposedPaths << "/usr/local/bin/ffmpeg";
 #endif
     proposedPaths << KoResourcePaths::getApplicationRoot() +
         QDir::separator() + "bin" + QDir::separator() + "ffmpeg";
 
     Q_FOREACH (QString path, proposedPaths) {
         if (path.isEmpty()) continue;
 
 #ifdef Q_OS_WIN
         path = QDir::toNativeSeparators(QDir::cleanPath(path));
         if (path.endsWith(QDir::separator())) {
             continue;
         }
         if (!path.endsWith(".exe")) {
             if (!QFile::exists(path)) {
                 path += ".exe";
                 if (!QFile::exists(path)) {
                     continue;
                 }
             }
         }
 #endif
         QProcess testProcess;
         testProcess.start(path, QStringList() << "-version");
         if (testProcess.waitForStarted(1000)) {
             testProcess.waitForFinished(1000);
         }
 
         const bool successfulStart =
             testProcess.state() == QProcess::NotRunning &&
             testProcess.error() == QProcess::UnknownError;
 
         if (successfulStart) {
             result = path;
             break;
         }
     }
 
     return result;
 }
 
 void DlgAnimationRenderer::slotExportTypeChanged()
 {
     KisConfig cfg;
 
     bool willEncodeVideo =
         m_page->shouldExportAll->isChecked() || m_page->shouldExportOnlyVideo->isChecked();
 
     // if a video format needs to be outputted
     if (willEncodeVideo) {
          // videos always uses PNG for creating video, so disable the ability to change the format
          m_page->cmbMimetype->setEnabled(false);
          for (int i = 0; i < m_page->cmbMimetype->count(); ++i) {
              if (m_page->cmbMimetype->itemData(i).toString() == "image/png") {
                  m_page->cmbMimetype->setCurrentIndex(i);
                  break;
              }
          }
     }
 
     m_page->intWidth->setVisible(willEncodeVideo);
     m_page->intHeight->setVisible(willEncodeVideo);
     m_page->intFramesPerSecond->setVisible(willEncodeVideo);
     m_page->fpsLabel->setVisible(willEncodeVideo);
     m_page->lblWidth->setVisible(willEncodeVideo);
     m_page->lblHeight->setVisible(willEncodeVideo);
 
     // if only exporting video
     if (m_page->shouldExportOnlyVideo->isChecked()) {
         m_page->cmbMimetype->setEnabled(false); // allow to change image format
         m_page->imageSequenceOptionsGroup->setVisible(false);
         m_page->videoOptionsGroup->setVisible(false); //shrinks the horizontal space temporarily to help resize() work
         m_page->videoOptionsGroup->setVisible(true);
 
         cfg.writeEntry<QString>("AnimationRenderer/export_type", "Video");
     }
 
 
     // if only an image sequence needs to be output
     if (m_page->shouldExportOnlyImageSequence->isChecked()) {
         m_page->cmbMimetype->setEnabled(true); // allow to change image format
         m_page->videoOptionsGroup->setVisible(false);
         m_page->imageSequenceOptionsGroup->setVisible(false);
         m_page->imageSequenceOptionsGroup->setVisible(true);
 
         cfg.writeEntry<QString>("AnimationRenderer/export_type", "ImageSequence");
     }
 
     // show all options
      if (m_page->shouldExportAll->isChecked() ) {
          m_page->imageSequenceOptionsGroup->setVisible(true);
          m_page->videoOptionsGroup->setVisible(true);
 
          cfg.writeEntry<QString>("AnimationRenderer/export_type", "VideoAndImageSequence");
      }
 
 
      // for the resize to work as expected, try to hide elements first before displaying other ones.
      // if the widget gets bigger at any point, the resize will use that, even if elements are hidden later to make it smaller
      resize(m_page->sizeHint());
 }
 
 void DlgAnimationRenderer::slotLockAspectRatioDimensionsWidth(int width)
 {
     Q_UNUSED(width);
 
     float aspectRatio = (float)m_image->width() / (float)m_image->height();
 
     // update height here
     float newHeight = m_page->intWidth->value() / aspectRatio  ;
 
     m_page->intHeight->setValue(newHeight);
 
 }
 
 void DlgAnimationRenderer::slotLockAspectRatioDimensionsHeight(int height)
 {
     Q_UNUSED(height);
 
     float aspectRatio = (float)m_image->width() / (float)m_image->height();
 
     // update width here
      float newWidth = aspectRatio *  m_page->intHeight->value();
 
      m_page->intWidth->setValue(newWidth);
 }
diff --git a/plugins/extensions/imagesplit/imagesplit.cpp b/plugins/extensions/imagesplit/imagesplit.cpp
index 0316741d44..3a7e9ec8f9 100644
--- a/plugins/extensions/imagesplit/imagesplit.cpp
+++ b/plugins/extensions/imagesplit/imagesplit.cpp
@@ -1,207 +1,207 @@
 /*
  * imagesplit.cc -- Part of Krita
  *
  * Copyright (c) 2004 Boudewijn Rempt (boud@valdyas.org)
  * Copyright (c) 2011 Srikanth Tiyyagura <srikanth.tulasiram@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "imagesplit.h"
 
 #include <QStringList>
 #include <QDir>
 #include <QStandardPaths>
 #include <QMessageBox>
 
 #include <klocalizedstring.h>
 #include <kpluginfactory.h>
 
 #include <KisImportExportManager.h>
 #include <KoFileDialog.h>
 #include <KisDocument.h>
 
 #include <KisPart.h>
 #include <kis_debug.h>
 #include <kis_types.h>
 #include <KisViewManager.h>
 #include <kis_image.h>
 #include <kis_action.h>
 #include <KisDocument.h>
 #include <kis_paint_layer.h>
 #include <kis_painter.h>
 #include <kis_paint_device.h>
 #include <KisMimeDatabase.h>
 
 #include "dlg_imagesplit.h"
 
 K_PLUGIN_FACTORY_WITH_JSON(ImagesplitFactory, "kritaimagesplit.json", registerPlugin<Imagesplit>();)
 
 Imagesplit::Imagesplit(QObject *parent, const QVariantList &)
     : KisActionPlugin(parent)
 {
     KisAction *action  = createAction("imagesplit");
     connect(action, SIGNAL(triggered()), this, SLOT(slotImagesplit()));
 }
 
 Imagesplit::~Imagesplit()
 {
 }
 
 bool Imagesplit::saveAsImage(const QRect &imgSize, const QString &mimeType, const QString &url)
 {
     KisImageSP image = viewManager()->image();
 
     KisDocument *document = KisPart::instance()->createDocument();
 
     KisImageSP dst = new KisImage(document->createUndoStore(), imgSize.width(), imgSize.height(), image->colorSpace(), image->objectName());
     dst->setResolution(image->xRes(), image->yRes());
     document->setCurrentImage(dst);
 
     KisPaintLayer* paintLayer = new KisPaintLayer(dst, dst->nextLayerName(), 255);
     KisPainter gc(paintLayer->paintDevice());
     gc.bitBlt(QPoint(0, 0), image->projection(), imgSize);
 
     dst->addNode(paintLayer, KisNodeSP(0));
     dst->refreshGraph();
     document->setFileBatchMode(true);
     if (!document->exportDocumentSync(QUrl::fromLocalFile(url), mimeType.toLatin1())) {
         if (document->errorMessage().isEmpty()) {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not save\n%1", document->localFilePath()));
         } else {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not save %1\nReason: %2", document->localFilePath(), document->errorMessage()));
         }
         return false;
     }
 
     delete document;
 
     return true;
 }
 
 void Imagesplit::slotImagesplit()
 {
     // Taking the title - url from caption function and removing file extension
     QStringList strList = ((viewManager()->document())->caption()).split('.');
     QString suffix = strList.at(0);
 
     // Getting all mime types and converting them into names which are displayed at combo box
-    QStringList listMimeFilter = KisImportExportManager::mimeFilter(KisImportExportManager::Export);
+    QStringList listMimeFilter = KisImportExportManager::supportedMimeTypes(KisImportExportManager::Export);
     QString defaultMime = QString::fromLatin1(viewManager()->document()->mimeType());
     int defaultMimeIndex = 0;
 
     listMimeFilter.sort();
     QStringList filteredMimeTypes;
     QStringList listFileType;
     int i = 0;
     Q_FOREACH (const QString & mimeType, listMimeFilter) {
         listFileType.append(KisMimeDatabase::descriptionForMimeType(mimeType));
         filteredMimeTypes.append(mimeType);
         if (mimeType == defaultMime) {
             defaultMimeIndex = i;
         }
         i++;
     }
 
     listMimeFilter = filteredMimeTypes;
 
     Q_ASSERT(listMimeFilter.size() == listFileType.size());
 
     DlgImagesplit *dlgImagesplit = new DlgImagesplit(viewManager(), suffix, listFileType, defaultMimeIndex);
     dlgImagesplit->setObjectName("Imagesplit");
     Q_CHECK_PTR(dlgImagesplit);
 
     KisImageWSP image = viewManager()->image();
 
     if (dlgImagesplit->exec() == QDialog::Accepted) {
 
         int numHorizontalLines = dlgImagesplit->horizontalLines();
         int numVerticalLines = dlgImagesplit->verticalLines();
 
         int img_width = image->width() / (numVerticalLines + 1);
         int img_height = image->height() / (numHorizontalLines + 1);
 
 
         bool stop = false;
         if (dlgImagesplit->autoSave()) {
             KoFileDialog dialog(viewManager()->mainWindow(), KoFileDialog::OpenDirectory, "OpenDocument");
             dialog.setCaption(i18n("Save Image on Split"));
             dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
-            QStringList mimeFilter = viewManager()->document()->importExportManager()->mimeFilter(KisImportExportManager::Export);
+            QStringList mimeFilter = viewManager()->document()->importExportManager()->supportedMimeTypes(KisImportExportManager::Export);
             QString defaultMime = QString::fromLatin1(viewManager()->document()->mimeType());
             dialog.setMimeTypeFilters(mimeFilter, defaultMime);
 
             QUrl directory = QUrl::fromUserInput(dialog.filename());
 
             if (directory.isEmpty())
                 return;
             for (int i = 0, k = 1; i < (numVerticalLines + 1); i++) {
                 for (int j = 0; j < (numHorizontalLines + 1); j++, k++) {
                     QString mimeTypeSelected = listMimeFilter.at(dlgImagesplit->cmbIndex);
                     QString homepath = directory.toLocalFile();
                     QString suffix = KisMimeDatabase::suffixesForMimeType(mimeTypeSelected).first();
                     qDebug() << "suffix" << suffix;
                     if (suffix.startsWith("*.")) {
                         suffix = suffix.remove(0, 1);
                     }
                     qDebug() << "\tsuffix" << suffix;
                     if (!suffix.startsWith(".")) {
                         suffix = suffix.prepend('.');
                     }
                     qDebug() << "\tsuffix" << suffix;
                     QString fileName = dlgImagesplit->suffix() + '_' + QString::number(k) + suffix;
                     QString url = homepath  + '/' + fileName;
                     if (!saveAsImage(QRect((i * img_width), (j * img_height), img_width, img_height), listMimeFilter.at(dlgImagesplit->cmbIndex), url)) {
                         stop = true;
                         break;
                     }
                 }
                 if (stop) {
                     break;
                 }
             }
         }
         else {
 
             for (int i = 0; i < (numVerticalLines + 1); i++) {
                 for (int j = 0; j < (numHorizontalLines + 1); j++) {
                     KoFileDialog dialog(viewManager()->mainWindow(), KoFileDialog::SaveFile, "OpenDocument");
                     dialog.setCaption(i18n("Save Image on Split"));
                     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
                     dialog.setMimeTypeFilters(listMimeFilter, defaultMime);
 
                     QUrl url = QUrl::fromUserInput(dialog.filename());
 
                     QString mimefilter = KisMimeDatabase::mimeTypeForFile(url.toLocalFile(), false);
 
                     if (url.isEmpty())
                         return;
                     if (!saveAsImage(QRect((i * img_width), (j * img_height), img_width, img_height), mimefilter, url.toLocalFile())) {
                         stop = true;
                         break;
                     }
                 }
                 if (stop) {
                     break;
                 }
             }
 
         }
 
     }
     delete dlgImagesplit;
 }
 
 #include "imagesplit.moc"
diff --git a/plugins/extensions/pykrita/plugin/utilities.cpp b/plugins/extensions/pykrita/plugin/utilities.cpp
index b6e6753107..df098486d7 100644
--- a/plugins/extensions/pykrita/plugin/utilities.cpp
+++ b/plugins/extensions/pykrita/plugin/utilities.cpp
@@ -1,679 +1,678 @@
 // This file is part of PyKrita, Krita' Python scripting plugin.
 //
 // Copyright (C) 2006 Paul Giannaros <paul@giannaros.org>
 // Copyright (C) 2012, 2013 Shaheed Haque <srhaque@theiet.org>
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public
 // License as published by the Free Software Foundation; either
 // version 2.1 of the License, or (at your option) version 3, or any
 // later version accepted by the membership of KDE e.V. (or its
 // successor approved by the membership of KDE e.V.), which shall
 // act as a proxy defined in Section 6 of version 3 of the license.
 //
 // This library is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 // Lesser General Public License for more details.
 //
 // You should have received a copy of the GNU Lesser General Public
 // License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 //
 
 // config.h defines PYKRITA_PYTHON_LIBRARY, the path to libpython.so
 // on the build system
 
 #include "config.h"
 #include "utilities.h"
 #include "PythonPluginManager.h"
 
 #include <algorithm>
 
 #include <cmath>
 #include <Python.h>
 
 #include <QDir>
 #include <QLibrary>
 #include <QString>
 #include <QStringList>
 #include <QVector>
 #include <QFileInfo>
 
 #include <kconfigbase.h>
 #include <kconfiggroup.h>
 #include <klocalizedstring.h>
 #include <KoResourcePaths.h>
 
 #include <kis_debug.h>
 
 #include "PykritaModule.h"
 
 #define THREADED 1
 
 namespace PyKrita
 {
     static InitResult initStatus = INIT_UNINITIALIZED;
     static QScopedPointer<PythonPluginManager> pluginManagerInstance;
 
     InitResult initialize()
     {
         // Already initialized?
         if (initStatus == INIT_OK) return INIT_OK;
 
         dbgScript << "Initializing Python plugin for Python" << PY_MAJOR_VERSION << "," << PY_MINOR_VERSION;
 
         if (!Python::libraryLoad()) {
             return INIT_CANNOT_LOAD_PYTHON_LIBRARY;
         }
 
         // Update PYTHONPATH
         // 0) custom plugin directories (prefer local dir over systems')
         // 1) shipped krita module's dir
         QStringList pluginDirectories = KoResourcePaths::findDirs("pythonscripts");
         dbgScript << "Plugin Directories: " << pluginDirectories;
         if (!Python::setPath(pluginDirectories)) {
             initStatus = INIT_CANNOT_SET_PYTHON_PATHS;
             return initStatus;
         }
 
 #if defined(IS_PY3K)
         if (0 != PyImport_AppendInittab(Python::PYKRITA_ENGINE, PyInit_pykrita)) {
 #else
         if (0 != PyImport_AppendInittab(Python::PYKRITA_ENGINE, initpykrita)) {
 #endif
             initStatus = INIT_CANNOT_LOAD_PYKRITA_MODULE;
             return initStatus;
         }
 
         Python::ensureInitialized();
         Python py = Python();
 
         PyRun_SimpleString(
                 "import sip\n"
                         "sip.setapi('QDate', 2)\n"
                         "sip.setapi('QTime', 2)\n"
                         "sip.setapi('QDateTime', 2)\n"
                         "sip.setapi('QUrl', 2)\n"
                         "sip.setapi('QTextStream', 2)\n"
                         "sip.setapi('QString', 2)\n"
                         "sip.setapi('QVariant', 2)\n"
         );
 
         // Initialize 'plugins' dict of module 'pykrita'
         PyObject* plugins = PyDict_New();
         py.itemStringSet("plugins", plugins);
 
         pluginManagerInstance.reset(new PythonPluginManager());
 
 #if defined(IS_PY3K)
         // Initialize our built-in module.
         auto pykritaModule = PyInit_pykrita();
 
         if (!pykritaModule) {
             initStatus = INIT_CANNOT_LOAD_PYKRITA_MODULE;
             return initStatus;
             //return i18nc("@info:tooltip ", "No <icode>pykrita</icode> built-in module");
         }
 #else
         initpykrita();
 #endif
 
         initStatus = INIT_OK;
         return initStatus;
     }
 
     PythonPluginManager *pluginManager()
     {
         auto pluginManager = pluginManagerInstance.data();
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(pluginManager, nullptr);
         return pluginManager;
     }
 
     void finalize() {
         dbgScript << "Going to destroy the Python engine";
         if (pluginManagerInstance) {
             pluginManagerInstance->unloadAllModules();
 
             PyKrita::Python::maybeFinalize();
             PyKrita::Python::libraryUnload();
 
             pluginManagerInstance.reset();
             initStatus = INIT_UNINITIALIZED;
         }
     }
 
     namespace
 {
 #ifndef Q_OS_WIN
 QLibrary* s_pythonLibrary = 0;
 #endif
 PyThreadState* s_pythonThreadState = 0;
 bool isPythonPathSet = false;
 }                                                           // anonymous namespace
 
 const char* Python::PYKRITA_ENGINE = "pykrita";
 
 Python::Python()
 {
 #if THREADED
     m_state = PyGILState_Ensure();
 #endif
 }
 
 Python::~Python()
 {
 #if THREADED
     PyGILState_Release(m_state);
 #endif
 }
 
 bool Python::prependStringToList(PyObject* const list, const QString& value)
 {
     PyObject* const u = unicode(value);
     bool result = !PyList_Insert(list, 0, u);
     Py_DECREF(u);
     if (!result)
         traceback(QString("Failed to prepend %1").arg(value));
     return result;
 }
 
 bool Python::functionCall(const char* const functionName, const char* const moduleName)
 {
     PyObject* const result = functionCall(functionName, moduleName, PyTuple_New(0));
     if (result)
         Py_DECREF(result);
     return bool(result);
 }
 
 PyObject* Python::functionCall(
     const char* const functionName
     , const char* const moduleName
     , PyObject* const arguments
 )
 {
     if (!arguments) {
         errScript << "Missing arguments for" << moduleName << functionName;
         return 0;
     }
     PyObject* const func = itemString(functionName, moduleName);
     if (!func) {
         errScript << "Failed to resolve" << moduleName << functionName;
         return 0;
     }
     if (!PyCallable_Check(func)) {
         traceback(QString("Not callable %1.%2").arg(moduleName).arg(functionName));
         return 0;
     }
     PyObject* const result = PyObject_CallObject(func, arguments);
     Py_DECREF(arguments);
     if (!result)
         traceback(QString("No result from %1.%2").arg(moduleName).arg(functionName));
 
     return result;
 }
 
 bool Python::itemStringDel(const char* const item, const char* const moduleName)
 {
     PyObject* const dict = moduleDict(moduleName);
     const bool result = dict && PyDict_DelItemString(dict, item);
     if (!result)
         traceback(QString("Could not delete item string %1.%2").arg(moduleName).arg(item));
     return result;
 }
 
 PyObject* Python::itemString(const char* const item, const char* const moduleName)
 {
     if (PyObject* const value = itemString(item, moduleDict(moduleName)))
         return value;
 
     errScript << "Could not get item string" << moduleName << item;
     return 0;
 }
 
 PyObject* Python::itemString(const char* item, PyObject* dict)
 {
     if (dict)
         if (PyObject* const value = PyDict_GetItemString(dict, item))
             return value;
     traceback(QString("Could not get item string %1").arg(item));
     return 0;
 }
 
 bool Python::itemStringSet(const char* const item, PyObject* const value, const char* const moduleName)
 {
     PyObject* const dict = moduleDict(moduleName);
     const bool result = dict && !PyDict_SetItemString(dict, item, value);
     if (!result)
         traceback(QString("Could not set item string %1.%2").arg(moduleName).arg(item));
     return result;
 }
 
 PyObject* Python::kritaHandler(const char* const moduleName, const char* const handler)
 {
     if (PyObject* const module = moduleImport(moduleName))
         return functionCall(handler, "krita", Py_BuildValue("(O)", module));
     return 0;
 }
 
 QString Python::lastTraceback() const
 {
     QString result;
     result.swap(m_traceback);
     return result;
 }
 
 bool Python::libraryLoad()
 {
     // no-op on Windows
 #if defined(Q_OS_UNIX) && !defined(Q_OS_MAC)
     if (!s_pythonLibrary) {
 
         QFileInfo fi(PYKRITA_PYTHON_LIBRARY);
         // get the filename of the configured Python library, without the .so suffix
         const QString libraryName = fi.completeBaseName();
         // 1.0 is the SONAME of the shared Python library
         s_pythonLibrary = new QLibrary(libraryName, "1.0");
         s_pythonLibrary->setLoadHints(QLibrary::ExportExternalSymbolsHint);
         if (!s_pythonLibrary->load()) {
             dbgScript << QString("Could not load %1 -- Reason: %2").arg(s_pythonLibrary->fileName()).arg(s_pythonLibrary->errorString());
             delete s_pythonLibrary;
             s_pythonLibrary = 0;
             return false;
         }
+        dbgScript << QString("Loaded %1").arg(s_pythonLibrary->fileName());
     }
 #endif
     return true;
 }
 
 namespace
 {
 
 QString findKritaPythonLibsPath(const QString &libdir)
 {
     QDir rootDir(KoResourcePaths::getApplicationRoot());
     QFileInfoList candidates =  rootDir.entryInfoList(QStringList() << "lib*", QDir::Dirs | QDir::NoDotAndDotDot) + rootDir.entryInfoList(QStringList() << "Frameworks", QDir::Dirs | QDir::NoDotAndDotDot);
     Q_FOREACH (const QFileInfo &entry, candidates) {
         QDir libDir(entry.absoluteFilePath());
         if (libDir.cd(libdir)) {
             return libDir.absolutePath();
         } else {
             // Handle cases like Linux where libs are placed in a sub-dir
             // with the ABI name
             Q_FOREACH (const QFileInfo &subEntry, libDir.entryInfoList(QDir::Dirs | QDir::NoDotAndDotDot)) {
                 QDir subDir(subEntry.absoluteFilePath());
                 if (subDir.cd(libdir)) {
                     return subDir.absolutePath();
                 }
             }
         }
     }
     return QString();
 }
 
 } // namespace
 
 bool Python::setPath(const QStringList& scriptPaths)
 {
 
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!Py_IsInitialized(), false);
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!isPythonPathSet, false);
 
-    bool runningInBundle = (KoResourcePaths::getApplicationRoot().toLower().contains(".mount_krita") || KoResourcePaths::getApplicationRoot().toLower().contains("krita.app"));
-    qDebug() << "Python::setPath. Script paths:" << scriptPaths << runningInBundle;
+    bool runningInBundle = ((!qgetenv("APPDIR").isNull() && KoResourcePaths::getApplicationRoot().toLower().contains(qgetenv("APPDIR"))) || KoResourcePaths::getApplicationRoot().toLower().contains("krita.app"));
+    dbgScript << "Python::setPath. Script paths:" << scriptPaths << runningInBundle;
 
 #ifdef Q_OS_WIN
     constexpr char pathSeparator = ';';
 #else
     constexpr char pathSeparator = ':';
 #endif
 
     QString originalPath;
     // Start with the script paths
     QStringList paths(scriptPaths);
 
     // Append the Krita libraries path
     QString pythonLibsPath = findKritaPythonLibsPath("krita-python-libs");
-    qDebug() << "pythonLibsPath (krita-python-libs)" << pythonLibsPath;
+    dbgScript << "pythonLibsPath (krita-python-libs)" << pythonLibsPath;
     if (pythonLibsPath.isEmpty()) {
         dbgScript << "Cannot find krita-python-libs";
         return false;
     }
     dbgScript << "Found krita-python-libs at" << pythonLibsPath;
     paths.append(pythonLibsPath);
 
 #ifndef Q_OS_WIN
     // Append the sip libraries path
     pythonLibsPath = findKritaPythonLibsPath("sip");
-    qDebug() << "pythonLibsPath (sip)" << pythonLibsPath;
+    dbgScript << "pythonLibsPath (sip)" << pythonLibsPath;
     if (!pythonLibsPath.isEmpty()) {
         dbgScript << "Found sip at" << pythonLibsPath;
         paths.append(pythonLibsPath);
     }
 #endif
 
 #ifdef Q_OS_WIN
     // Find embeddable Python at <root>/python
     QDir pythonDir(KoResourcePaths::getApplicationRoot());
     if (pythonDir.cd("python")) {
         dbgScript << "Found bundled Python at" << pythonDir.absolutePath();
         // The default paths for Windows embeddable Python is ./python36.zip;./
         // HACK: Assuming bundled Python is version 3.6.*
         // FIXME: Should we read python36._pth for the paths or use Py_GetPath?
         paths.append(pythonDir.absoluteFilePath("python36.zip"));
         paths.append(pythonDir.absolutePath());
     } else {
         errScript << "Bundled Python not found, cannot set Python library paths";
         return false;
     }
 #else
     // If using a system Python install, respect the current PYTHONPATH
-    if (KoResourcePaths::getApplicationRoot().toLower().contains(".mount_krita")) {
+    if (runningInBundle) {
         // We're running from an appimage, so we need our local python
         QString p = QFileInfo(PYKRITA_PYTHON_LIBRARY).fileName();
         QString p2 = p.remove("lib").remove("m.so");
         dbgScript << "\t" << p << p2;
         originalPath = findKritaPythonLibsPath(p);
         paths.append(originalPath + "/lib-dynload");
         paths.append(originalPath + "/site-packages");
         paths.append(originalPath + "/site-packages/PyQt5");
     }
     else {
         // Use the system path
         originalPath = QString::fromLocal8Bit(qgetenv("PYTHONPATH"));
     }
 #endif
 
     QString joinedPaths = paths.join(pathSeparator);
     if (!originalPath.isEmpty()) {
         joinedPaths = joinedPaths + pathSeparator + originalPath;
     }
     dbgScript << "Setting python paths:" << joinedPaths;
 #ifdef Q_OS_WIN
     QVector<wchar_t> joinedPathsWChars(joinedPaths.size() + 1, 0);
     joinedPaths.toWCharArray(joinedPathsWChars.data());
     Py_SetPath(joinedPathsWChars.data());
 #else
-    if (KoResourcePaths::getApplicationRoot().contains(".mount_Krita")) {
+    if (runningInBundle) {
         QVector<wchar_t> joinedPathsWChars(joinedPaths.size() + 1, 0);
         joinedPaths.toWCharArray(joinedPathsWChars.data());
-        PyRun_SimpleString("import sys; import os");
-        QString pathCommand = QString("sys.path += '") + joinedPaths + QString("'.split(os.pathsep)");
-        PyRun_SimpleString(pathCommand.toUtf8().constData());
+        Py_SetPath(joinedPathsWChars.data());
     }
     else {
         qputenv("PYTHONPATH", joinedPaths.toLocal8Bit());
     }
 #endif
     isPythonPathSet = true;
     return true;
 }
 
 void Python::ensureInitialized()
 {
     if (Py_IsInitialized()) {
         warnScript << "Python interpreter is already initialized, not initializing again";
     } else {
         dbgScript << "Initializing Python interpreter";
         Py_InitializeEx(0);
         if (!Py_IsInitialized()) {
             errScript << "Could not initialize Python interpreter";
         }
 #if THREADED
         PyEval_InitThreads();
         s_pythonThreadState = PyGILState_GetThisThreadState();
         PyEval_ReleaseThread(s_pythonThreadState);
 #endif
     }
 }
 
 void Python::maybeFinalize()
 {
     if (!Py_IsInitialized()) {
         warnScript << "Python interpreter not initialized, no need to finalize";
     } else {
 #if THREADED
         PyEval_AcquireThread(s_pythonThreadState);
 #endif
         Py_Finalize();
     }
 }
 
 void Python::libraryUnload()
 {
     // no-op on Windows
 #ifndef Q_OS_WIN
     if (s_pythonLibrary) {
         // Shut the interpreter down if it has been started.
         if (s_pythonLibrary->isLoaded()) {
             s_pythonLibrary->unload();
         }
         delete s_pythonLibrary;
         s_pythonLibrary = 0;
     }
 #endif
 }
 
 PyObject* Python::moduleActions(const char* moduleName)
 {
     return kritaHandler(moduleName, "moduleGetActions");
 }
 
 PyObject* Python::moduleConfigPages(const char* const moduleName)
 {
     return kritaHandler(moduleName, "moduleGetConfigPages");
 }
 
 QString Python::moduleHelp(const char* moduleName)
 {
     QString r;
     PyObject* const result = kritaHandler(moduleName, "moduleGetHelp");
     if (result) {
         r = unicode(result);
         Py_DECREF(result);
     }
     return r;
 }
 
 PyObject* Python::moduleDict(const char* const moduleName)
 {
     PyObject* const module = moduleImport(moduleName);
     if (module)
         if (PyObject* const dictionary = PyModule_GetDict(module))
             return dictionary;
 
     traceback(QString("Could not get dict %1").arg(moduleName));
     return 0;
 }
 
 PyObject* Python::moduleImport(const char* const moduleName)
 {
     PyObject* const module = PyImport_ImportModule(moduleName);
     if (module)
         return module;
 
     traceback(QString("Could not import %1").arg(moduleName));
     return 0;
 }
 
 // Inspired by http://www.gossamer-threads.com/lists/python/python/150924.
 void Python::traceback(const QString& description)
 {
     m_traceback.clear();
     if (!PyErr_Occurred())
         // Return an empty string on no error.
         // NOTE "Return a string?" really??
         return;
 
     PyObject* exc_typ;
     PyObject* exc_val;
     PyObject* exc_tb;
     PyErr_Fetch(&exc_typ, &exc_val, &exc_tb);
     PyErr_NormalizeException(&exc_typ, &exc_val, &exc_tb);
 
     // Include the traceback.
     if (exc_tb) {
         m_traceback = "Traceback (most recent call last):\n";
         PyObject* const arguments = PyTuple_New(1);
         PyTuple_SetItem(arguments, 0, exc_tb);
         PyObject* const result = functionCall("format_tb", "traceback", arguments);
         if (result) {
             for (int i = 0, j = PyList_Size(result); i < j; i++) {
                 PyObject* const tt = PyList_GetItem(result, i);
                 PyObject* const t = Py_BuildValue("(O)", tt);
                 char* buffer;
                 if (!PyArg_ParseTuple(t, "s", &buffer))
                     break;
                 m_traceback += buffer;
             }
             Py_DECREF(result);
         }
         Py_DECREF(exc_tb);
     }
 
     // Include the exception type and value.
     if (exc_typ) {
         PyObject* const temp = PyObject_GetAttrString(exc_typ, "__name__");
         if (temp) {
             m_traceback += unicode(temp);
             m_traceback += ": ";
         }
         Py_DECREF(exc_typ);
     }
 
     if (exc_val) {
         PyObject* const temp = PyObject_Str(exc_val);
         if (temp) {
             m_traceback += unicode(temp);
             m_traceback += "\n";
         }
         Py_DECREF(exc_val);
     }
     m_traceback += description;
 
     QStringList l = m_traceback.split("\n");
     Q_FOREACH(const QString &s, l) {
         errScript << s;
     }
     /// \todo How about to show it somewhere else than "console output"?
 }
 
 PyObject* Python::unicode(const QString& string)
 {
 #if PY_MAJOR_VERSION < 3
     /* Python 2.x. http://docs.python.org/2/c-api/unicode.html */
     PyObject* s = PyString_FromString(PQ(string));
     PyObject* u = PyUnicode_FromEncodedObject(s, "utf-8", "strict");
     Py_DECREF(s);
     return u;
 #elif PY_MINOR_VERSION < 3
     /* Python 3.2 or less. http://docs.python.org/3.2/c-api/unicode.html#unicode-objects */
 # ifdef Py_UNICODE_WIDE
     return PyUnicode_DecodeUTF16((const char*)string.constData(), string.length() * 2, 0, 0);
 # else
     return PyUnicode_FromUnicode(string.constData(), string.length());
 # endif
 #else /* Python 3.3 or greater. http://docs.python.org/3.3/c-api/unicode.html#unicode-objects */
     return PyUnicode_FromKindAndData(PyUnicode_2BYTE_KIND, string.constData(), string.length());
 #endif
 }
 
 QString Python::unicode(PyObject* const string)
 {
 #if PY_MAJOR_VERSION < 3
     /* Python 2.x. http://docs.python.org/2/c-api/unicode.html */
     if (PyString_Check(string))
         return QString(PyString_AsString(string));
     else if (PyUnicode_Check(string)) {
         const int unichars = PyUnicode_GetSize(string);
 # ifdef HAVE_USABLE_WCHAR_T
         return QString::fromWCharArray(PyUnicode_AsUnicode(string), unichars);
 # else
 #   ifdef Py_UNICODE_WIDE
         return QString::fromUcs4((const unsigned int*)PyUnicode_AsUnicode(string), unichars);
 #   else
         return QString::fromUtf16(PyUnicode_AsUnicode(string), unichars);
 #   endif
 # endif
     } else return QString();
 #elif PY_MINOR_VERSION < 3
     /* Python 3.2 or less. http://docs.python.org/3.2/c-api/unicode.html#unicode-objects */
     if (!PyUnicode_Check(string))
         return QString();
 
     const int unichars = PyUnicode_GetSize(string);
 # ifdef HAVE_USABLE_WCHAR_T
     return QString::fromWCharArray(PyUnicode_AsUnicode(string), unichars);
 # else
 #   ifdef Py_UNICODE_WIDE
     return QString::fromUcs4(PyUnicode_AsUnicode(string), unichars);
 #   else
     return QString::fromUtf16(PyUnicode_AsUnicode(string), unichars);
 #   endif
 # endif
 #else /* Python 3.3 or greater. http://docs.python.org/3.3/c-api/unicode.html#unicode-objects */
     if (!PyUnicode_Check(string))
         return QString();
 
     const int unichars = PyUnicode_GetLength(string);
     if (0 != PyUnicode_READY(string))
         return QString();
 
     switch (PyUnicode_KIND(string)) {
     case PyUnicode_1BYTE_KIND:
         return QString::fromLatin1((const char*)PyUnicode_1BYTE_DATA(string), unichars);
     case PyUnicode_2BYTE_KIND:
         return QString::fromUtf16(PyUnicode_2BYTE_DATA(string), unichars);
     case PyUnicode_4BYTE_KIND:
         return QString::fromUcs4(PyUnicode_4BYTE_DATA(string), unichars);
     default:
         break;
     }
     return QString();
 #endif
 }
 
 bool Python::isUnicode(PyObject* const string)
 {
 #if PY_MAJOR_VERSION < 3
     return PyString_Check(string) || PyUnicode_Check(string);
 #else
     return PyUnicode_Check(string);
 #endif
 }
 
 bool Python::prependPythonPaths(const QString& path)
 {
     PyObject* sys_path = itemString("path", "sys");
     return bool(sys_path) && prependPythonPaths(path, sys_path);
 }
 
 bool Python::prependPythonPaths(const QStringList& paths)
 {
     PyObject* sys_path = itemString("path", "sys");
     if (!sys_path)
         return false;
 
     /// \todo Heh, boosts' range adaptors would be good here!
     QStringList reversed_paths;
     std::reverse_copy(
         paths.begin()
         , paths.end()
         , std::back_inserter(reversed_paths)
     );
 
     Q_FOREACH(const QString & path, reversed_paths)
     if (!prependPythonPaths(path, sys_path))
         return false;
 
     return true;
 }
 
 bool Python::prependPythonPaths(const QString& path, PyObject* sys_path)
 {
     Q_ASSERT("Dir entry expected to be valid" && sys_path);
     return bool(prependStringToList(sys_path, path));
 }
 
 }                                                           // namespace PyKrita
 
 // krita: indent-width 4;
diff --git a/plugins/extensions/resourcemanager/dlg_create_bundle.cpp b/plugins/extensions/resourcemanager/dlg_create_bundle.cpp
index 0e7b927a30..02f7b3d04f 100644
--- a/plugins/extensions/resourcemanager/dlg_create_bundle.cpp
+++ b/plugins/extensions/resourcemanager/dlg_create_bundle.cpp
@@ -1,438 +1,438 @@
 /*
  *  Copyright (c) 2014 Victor Lafon metabolic.ewilan@hotmail.fr
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 #include "dlg_create_bundle.h"
 
 #include "ui_wdgdlgcreatebundle.h"
 
 #include <QProcessEnvironment>
 #include <QFileInfo>
 #include <QMessageBox>
 #include <QStandardPaths>
 #include <QGridLayout>
 #include <QTableWidget>
 #include <QPainter>
 
 #include <KisImportExportManager.h>
 #include <KoDocumentInfo.h>
 #include <KoFileDialog.h>
 #include <kis_icon.h>
 #include <resources/KoResource.h>
 #include <KoResourceServer.h>
 #include <KoResourceServerProvider.h>
 
 #include <KisResourceServerProvider.h>
 #include <kis_workspace_resource.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <kis_brush_server.h>
 
 #include <kis_config.h>
 
 #include "KisResourceBundle.h"
 
 #define ICON_SIZE 48
 
 DlgCreateBundle::DlgCreateBundle(KisResourceBundle *bundle, QWidget *parent)
     : KoDialog(parent)
     , m_ui(new Ui::WdgDlgCreateBundle)
     , m_bundle(bundle)
 {
     m_page = new QWidget();
     m_ui->setupUi(m_page);
     setMainWidget(m_page);
     setFixedSize(m_page->sizeHint());
     setButtons(Ok | Cancel);
     setDefaultButton(Ok);
     setButtonText(Ok, i18n("Save"));
 
     connect(m_ui->bnSelectSaveLocation, SIGNAL(clicked()), SLOT(selectSaveLocation()));
 
     KoDocumentInfo info;
     info.updateParameters();
 
     if (bundle) {
 
         setCaption(i18n("Edit Resource Bundle"));
 
         m_ui->lblSaveLocation->setText(QFileInfo(bundle->filename()).absolutePath());
         m_ui->editBundleName->setText(bundle->name());
         m_ui->editAuthor->setText(bundle->getMeta("author"));
         m_ui->editEmail->setText(bundle->getMeta("email"));
         m_ui->editLicense->setText(bundle->getMeta("license"));
         m_ui->editWebsite->setText(bundle->getMeta("website"));
         m_ui->editDescription->document()->setPlainText(bundle->getMeta("description"));
         m_ui->lblPreview->setPixmap(QPixmap::fromImage(bundle->image().scaled(256, 256, Qt::KeepAspectRatio, Qt::SmoothTransformation)));
 
         Q_FOREACH (const QString & resType, bundle->resourceTypes()) {
             if (resType == "gradients") {
                 Q_FOREACH (const KoResource *res, bundle->resources(resType)) {
                     if (res) {
                         m_selectedGradients << res->shortFilename();
                     }
                 }
 
             }
             else if (resType  == "patterns") {
                 Q_FOREACH (const KoResource *res, bundle->resources(resType)) {
                     if (res) {
                         m_selectedPatterns << res->shortFilename();
                     }
                 }
 
             }
             else if (resType  == "brushes") {
                 Q_FOREACH (const KoResource *res, bundle->resources(resType)) {
                     if (res) {
                         m_selectedBrushes << res->shortFilename();
                     }
                 }
 
             }
             else if (resType  == "palettes") {
                 Q_FOREACH (const KoResource *res, bundle->resources(resType)) {
                     if (res) {
                         m_selectedPalettes << res->shortFilename();
                     }
                 }
 
             }
             else if (resType  == "workspaces") {
                 Q_FOREACH (const KoResource *res, bundle->resources(resType)) {
                     if (res) {
                         m_selectedWorkspaces << res->shortFilename();
                     }
                 }
 
             }
             else if (resType  == "paintoppresets") {
                 Q_FOREACH (const KoResource *res, bundle->resources(resType)) {
                     if (res) {
                         m_selectedPresets << res->shortFilename();
                     }
                 }
             }
         }
     }
     else {
 
         setCaption(i18n("Create Resource Bundle"));
 
         KisConfig cfg;
 
         m_ui->editAuthor->setText(cfg.readEntry<QString>("BundleAuthorName", info.authorInfo("creator")));
         m_ui->editEmail->setText(cfg.readEntry<QString>("BundleAuthorEmail", info.authorInfo("email")));
         m_ui->editWebsite->setText(cfg.readEntry<QString>("BundleWebsite", "http://"));
         m_ui->editLicense->setText(cfg.readEntry<QString>("BundleLicense", "CC-BY-SA"));
         m_ui->lblSaveLocation->setText(cfg.readEntry<QString>("BundleExportLocation", QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation)));
     }
 
     m_ui->bnAdd->setIcon(KisIconUtils::loadIcon("arrow-right"));
     connect(m_ui->bnAdd, SIGNAL(clicked()), SLOT(addSelected()));
 
     m_ui->bnRemove->setIcon(KisIconUtils::loadIcon("arrow-left"));
     connect(m_ui->bnRemove, SIGNAL(clicked()), SLOT(removeSelected()));
 
     m_ui->cmbResourceTypes->addItem(i18n("Brushes"), QString("brushes"));
     m_ui->cmbResourceTypes->addItem(i18n("Brush Presets"), QString("presets"));
     m_ui->cmbResourceTypes->addItem(i18n("Gradients"), QString("gradients"));
     m_ui->cmbResourceTypes->addItem(i18n("Patterns"), QString("patterns"));
     m_ui->cmbResourceTypes->addItem(i18n("Palettes"), QString("palettes"));
     m_ui->cmbResourceTypes->addItem(i18n("Workspaces"), QString("workspaces"));
     connect(m_ui->cmbResourceTypes, SIGNAL(activated(int)), SLOT(resourceTypeSelected(int)));
 
     m_ui->tableAvailable->setIconSize(QSize(ICON_SIZE, ICON_SIZE));
     m_ui->tableAvailable->setSelectionMode(QAbstractItemView::ExtendedSelection);
 
     m_ui->tableSelected->setIconSize(QSize(ICON_SIZE, ICON_SIZE));
     m_ui->tableSelected->setSelectionMode(QAbstractItemView::ExtendedSelection);
 
     connect(m_ui->bnGetPreview, SIGNAL(clicked()), SLOT(getPreviewImage()));
 
     resourceTypeSelected(0);
 }
 
 DlgCreateBundle::~DlgCreateBundle()
 {
     delete m_ui;
 }
 
 QString DlgCreateBundle::bundleName() const
 {
     return m_ui->editBundleName->text().replace(" ", "_");
 }
 
 QString DlgCreateBundle::authorName() const
 {
     return m_ui->editAuthor->text();
 }
 
 QString DlgCreateBundle::email() const
 {
     return m_ui->editEmail->text();
 }
 
 QString DlgCreateBundle::website() const
 {
     return m_ui->editWebsite->text();
 }
 
 QString DlgCreateBundle::license() const
 {
     return m_ui->editLicense->text();
 }
 
 QString DlgCreateBundle::description() const
 {
     return m_ui->editDescription->document()->toPlainText();
 }
 
 QString DlgCreateBundle::saveLocation() const
 {
     return m_ui->lblSaveLocation->text();
 }
 
 QString DlgCreateBundle::previewImage() const
 {
     return m_previewImage;
 }
 
 void DlgCreateBundle::accept()
 {
     QString name = m_ui->editBundleName->text().remove(" ");
 
     if (name.isEmpty()) {
         m_ui->editBundleName->setStyleSheet(QString(" border: 1px solid red"));
         QMessageBox::warning(this, i18nc("@title:window", "Krita"), i18n("The resource bundle name cannot be empty."));
         return;
     }
     else {
         QFileInfo fileInfo(m_ui->lblSaveLocation->text() + "/" + name + ".bundle");
 
         if (fileInfo.exists() && !m_bundle) {
             m_ui->editBundleName->setStyleSheet("border: 1px solid red");
             QMessageBox::warning(this, i18nc("@title:window", "Krita"), i18n("A bundle with this name already exists."));
             return;
         }
         else {
             if (!m_bundle) {
                 KisConfig cfg;
                 cfg.writeEntry<QString>("BunleExportLocation", m_ui->lblSaveLocation->text());
                 cfg.writeEntry<QString>("BundleAuthorName", m_ui->editAuthor->text());
                 cfg.writeEntry<QString>("BundleAuthorEmail", m_ui->editEmail->text());
                 cfg.writeEntry<QString>("BundleWebsite", m_ui->editWebsite->text());
                 cfg.writeEntry<QString>("BundleLicense", m_ui->editLicense->text());
             }
             KoDialog::accept();
         }
     }
 }
 
 void DlgCreateBundle::selectSaveLocation()
 {
     KoFileDialog dialog(this, KoFileDialog::OpenDirectory, "resourcebundlesavelocation");
     dialog.setDefaultDir(m_ui->lblSaveLocation->text());
     dialog.setCaption(i18n("Select a directory to save the bundle"));
     QString location = dialog.filename();
     m_ui->lblSaveLocation->setText(location);
 }
 
 void DlgCreateBundle::addSelected()
 {
     int row = m_ui->tableAvailable->currentRow();
 
     Q_FOREACH (QListWidgetItem *item, m_ui->tableAvailable->selectedItems()) {
         m_ui->tableSelected->addItem(m_ui->tableAvailable->takeItem(m_ui->tableAvailable->row(item)));
         QString resourceType = m_ui->cmbResourceTypes->itemData(m_ui->cmbResourceTypes->currentIndex()).toString();
         if (resourceType == "brushes") {
             m_selectedBrushes.append(item->data(Qt::UserRole).toString());
         }
         else if (resourceType == "presets") {
             m_selectedPresets.append(item->data(Qt::UserRole).toString());
         }
         else if (resourceType == "gradients") {
             m_selectedGradients.append(item->data(Qt::UserRole).toString());
 
         }
         else if (resourceType == "patterns") {
             m_selectedPatterns.append(item->data(Qt::UserRole).toString());
         }
         else if (resourceType == "palettes") {
             m_selectedPalettes.append(item->data(Qt::UserRole).toString());
         }
         else if (resourceType == "workspaces") {
             m_selectedWorkspaces.append(item->data(Qt::UserRole).toString());
         }
     }
 
     m_ui->tableAvailable->setCurrentRow(row);
 }
 
 void DlgCreateBundle::removeSelected()
 {
     int row = m_ui->tableSelected->currentRow();
 
     Q_FOREACH (QListWidgetItem *item, m_ui->tableSelected->selectedItems()) {
         m_ui->tableAvailable->addItem(m_ui->tableSelected->takeItem(m_ui->tableSelected->row(item)));
         QString resourceType = m_ui->cmbResourceTypes->itemData(m_ui->cmbResourceTypes->currentIndex()).toString();
         if (resourceType == "brushes") {
             m_selectedBrushes.removeAll(item->data(Qt::UserRole).toString());
         }
         else if (resourceType == "presets") {
             m_selectedPresets.removeAll(item->data(Qt::UserRole).toString());
         }
         else if (resourceType == "gradients") {
             m_selectedGradients.removeAll(item->data(Qt::UserRole).toString());
 
         }
         else if (resourceType == "patterns") {
             m_selectedPatterns.removeAll(item->data(Qt::UserRole).toString());
         }
         else if (resourceType == "palettes") {
             m_selectedPalettes.removeAll(item->data(Qt::UserRole).toString());
         }
         else if (resourceType == "workspaces") {
             m_selectedWorkspaces.removeAll(item->data(Qt::UserRole).toString());
         }
     }
 
     m_ui->tableSelected->setCurrentRow(row);
 }
 
 QPixmap imageToIcon(const QImage &img) {
     QPixmap pixmap(ICON_SIZE, ICON_SIZE);
     pixmap.fill();
     QImage scaled = img.scaled(ICON_SIZE, ICON_SIZE, Qt::KeepAspectRatio, Qt::SmoothTransformation);
     int x = (ICON_SIZE - scaled.width()) / 2;
     int y = (ICON_SIZE - scaled.height()) / 2;
     QPainter gc(&pixmap);
     gc.drawImage(x, y, scaled);
     gc.end();
     return pixmap;
 }
 
 void DlgCreateBundle::resourceTypeSelected(int idx)
 {
     QString resourceType = m_ui->cmbResourceTypes->itemData(idx).toString();
 
     m_ui->tableAvailable->clear();
     m_ui->tableSelected->clear();
 
     if (resourceType == "brushes") {
         KisBrushResourceServer *server = KisBrushServer::instance()->brushServer();
         Q_FOREACH (KisBrushSP res, server->resources()) {
             QListWidgetItem *item = new QListWidgetItem(imageToIcon(res->image()), res->name());
             item->setData(Qt::UserRole, res->shortFilename());
 
             if (m_selectedBrushes.contains(res->shortFilename())) {
                 m_ui->tableSelected->addItem(item);
             }
             else {
                 m_ui->tableAvailable->addItem(item);
             }
         }
     }
     else if (resourceType == "presets") {
         KisPaintOpPresetResourceServer* server = KisResourceServerProvider::instance()->paintOpPresetServer();
         Q_FOREACH (KisPaintOpPresetSP res, server->resources()) {
             QListWidgetItem *item = new QListWidgetItem(imageToIcon(res->image()), res->name());
             item->setData(Qt::UserRole, res->shortFilename());
 
             if (m_selectedPresets.contains(res->shortFilename())) {
                 m_ui->tableSelected->addItem(item);
             }
             else {
                 m_ui->tableAvailable->addItem(item);
             }
         }
     }
     else if (resourceType == "gradients") {
         KoResourceServer<KoAbstractGradient>* server = KoResourceServerProvider::instance()->gradientServer();
         Q_FOREACH (KoResource *res, server->resources()) {
             if (res->filename()!="Foreground to Transparent" && res->filename()!="Foreground to Background") {
             //technically we should read from the file-name whether or not the file can be opened, but this works for now. The problem is making sure that bundle-resource know where they are stored.//
             //dbgKrita<<res->filename();
                 QListWidgetItem *item = new QListWidgetItem(imageToIcon(res->image()), res->name());
                 item->setData(Qt::UserRole, res->shortFilename());
 
                 if (m_selectedGradients.contains(res->shortFilename())) {
                     m_ui->tableSelected->addItem(item);
                 }
                 else {
                     m_ui->tableAvailable->addItem(item);
                 }
             }
         }
     }
     else if (resourceType == "patterns") {
         KoResourceServer<KoPattern>* server = KoResourceServerProvider::instance()->patternServer();
         Q_FOREACH (KoResource *res, server->resources()) {
             QListWidgetItem *item = new QListWidgetItem(imageToIcon(res->image()), res->name());
             item->setData(Qt::UserRole, res->shortFilename());
 
             if (m_selectedPatterns.contains(res->shortFilename())) {
                 m_ui->tableSelected->addItem(item);
             }
             else {
                 m_ui->tableAvailable->addItem(item);
             }
         }
     }
     else if (resourceType == "palettes") {
         KoResourceServer<KoColorSet>* server = KoResourceServerProvider::instance()->paletteServer();
         Q_FOREACH (KoResource *res, server->resources()) {
             QListWidgetItem *item = new QListWidgetItem(imageToIcon(res->image()), res->name());
             item->setData(Qt::UserRole, res->shortFilename());
 
             if (m_selectedPalettes.contains(res->shortFilename())) {
                 m_ui->tableSelected->addItem(item);
             }
             else {
                 m_ui->tableAvailable->addItem(item);
             }
         }
     }
     else if (resourceType == "workspaces") {
         KoResourceServer<KisWorkspaceResource>* server = KisResourceServerProvider::instance()->workspaceServer();
         Q_FOREACH (KoResource *res, server->resources()) {
             QListWidgetItem *item = new QListWidgetItem(imageToIcon(res->image()), res->name());
             item->setData(Qt::UserRole, res->shortFilename());
 
             if (m_selectedWorkspaces.contains(res->shortFilename())) {
                 m_ui->tableSelected->addItem(item);
             }
             else {
                 m_ui->tableAvailable->addItem(item);
             }
         }
     }
 }
 
 void DlgCreateBundle::getPreviewImage()
 {
     KoFileDialog dialog(this, KoFileDialog::OpenFile, "BundlePreviewImage");
     dialog.setCaption(i18n("Select file to use as bundle icon"));
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
-    dialog.setMimeTypeFilters(KisImportExportManager::mimeFilter(KisImportExportManager::Import));
+    dialog.setMimeTypeFilters(KisImportExportManager::supportedMimeTypes(KisImportExportManager::Import));
     m_previewImage = dialog.filename();
     QImage img(m_previewImage);
     img = img.scaled(256, 256, Qt::KeepAspectRatio, Qt::SmoothTransformation);
     m_ui->lblPreview->setPixmap(QPixmap::fromImage(img));
 }
 
 
 
diff --git a/plugins/extensions/separate_channels/kis_channel_separator.cc b/plugins/extensions/separate_channels/kis_channel_separator.cc
index 66b9f7c6b3..b1504a4789 100644
--- a/plugins/extensions/separate_channels/kis_channel_separator.cc
+++ b/plugins/extensions/separate_channels/kis_channel_separator.cc
@@ -1,272 +1,272 @@
 /*
  * This file is part of Krita
  *
  * Copyright (c) 2005 Michael Thaler <michael.thaler@physik.tu-muenchen.de>
  *
  * ported from Gimp, Copyright (C) 1997 Eiichi Takamori <taka@ma1.seikyou.ne.jp>
  * original pixelize.c for GIMP 0.54 by Tracy Scott
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_channel_separator.h"
 
 #include <limits.h>
 #include <stdlib.h>
 #include <vector>
 
 #include <QStandardPaths>
 
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 #include <kpluginfactory.h>
 
 
 #include <KisImportExportManager.h>
 #include <KoUpdater.h>
 #include <KoFileDialog.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoChannelInfo.h>
 #include <KoColorModelStandardIds.h>
 
 #include <KisDocument.h>
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <kis_paint_layer.h>
 #include <kis_group_layer.h>
 #include <kis_transaction.h>
 #include <kis_undo_adapter.h>
 #include <kis_global.h>
 #include <kis_types.h>
 #include "kis_iterator_ng.h"
 #include <KisPart.h>
 #include <KisViewManager.h>
 #include <kis_paint_device.h>
 #include <kis_node_manager.h>
 #include <kis_node_commands_adapter.h>
 #include <KisMimeDatabase.h>
 
 KisChannelSeparator::KisChannelSeparator(KisViewManager * view)
         : m_viewManager(view)
 {
 }
 
 void KisChannelSeparator::separate(KoUpdater * progressUpdater, enumSepAlphaOptions alphaOps, enumSepSource sourceOps, enumSepOutput outputOps, bool downscale, bool toColor)
 {
     KisImageSP image = m_viewManager->image();
     if (!image) return;
 
     KisPaintDeviceSP src;
 
     // Use the flattened image, if required
     switch (sourceOps) {
     case ALL_LAYERS:
         // the content will be locked later
         src = image->projection();
         break;
     case CURRENT_LAYER:
         src = m_viewManager->activeDevice();
         break;
     default:
         break;
     }
 
     if (!src) return;
 
     progressUpdater->setProgress(1);
 
     const KoColorSpace * dstCs = 0;
 
     quint32 numberOfChannels = src->channelCount();
     const KoColorSpace * srcCs  = src->colorSpace();
     QList<KoChannelInfo *> channels = srcCs->channels();
     vKisPaintDeviceSP layers;
 
     QList<KoChannelInfo *>::const_iterator begin = channels.constBegin();
     QList<KoChannelInfo *>::const_iterator end = channels.constEnd();
 
     QRect rect = src->exactBounds();
 
     image->lock();
     int i = 0;
     for (QList<KoChannelInfo *>::const_iterator it = begin; it != end; ++it) {
 
         KoChannelInfo * ch = (*it);
 
         if (ch->channelType() == KoChannelInfo::ALPHA && alphaOps != CREATE_ALPHA_SEPARATION) {
             continue;
         }
 
         qint32 channelSize = ch->size();
         qint32 channelPos = ch->pos();
         qint32 destSize = 1;
 
         KisPaintDeviceSP dev;
         if (toColor) {
             // We don't downscale if we separate to color channels
             dev = new KisPaintDevice(srcCs);
         } else {
             if (channelSize == 1 || downscale) {
                 dev = new KisPaintDevice(KoColorSpaceRegistry::instance()->colorSpace(GrayAColorModelID.id(), Integer8BitsColorDepthID.id(), 0));
             } else {
                 dev = new KisPaintDevice(KoColorSpaceRegistry::instance()->colorSpace(GrayAColorModelID.id(), Integer16BitsColorDepthID.id(), 0));
                 destSize = 2;
             }
         }
 
         dstCs = dev->colorSpace();
 
         layers.push_back(dev);
 
         KisHLineConstIteratorSP srcIt = src->createHLineConstIteratorNG(rect.x(), rect.y(), rect.width());
         KisHLineIteratorSP dstIt = dev->createHLineIteratorNG(rect.x(), rect.y(), rect.width());
 
         for (qint32 row = 0; row < rect.height(); ++row) {
             do {
                 if (toColor) {
                     dstCs->singleChannelPixel(dstIt->rawData(), srcIt->oldRawData(), channelPos);
 
                     if (alphaOps == COPY_ALPHA_TO_SEPARATIONS) {
                         //dstCs->setAlpha(dstIt->rawData(), srcIt->oldRawData()[srcAlphaPos], 1);
                         dstCs->setOpacity(dstIt->rawData(), srcCs->opacityU8(srcIt->oldRawData()), 1);
                     } else {
                         dstCs->setOpacity(dstIt->rawData(), OPACITY_OPAQUE_U8, 1);
                     }
                 } else {
 
                     // To grayscale
 
                     // Decide whether we need downscaling
                     if (channelSize == 1 && destSize == 1) {
 
                         // Both 8-bit channels
                         dstIt->rawData()[0] = srcIt->oldRawData()[channelPos];
 
                         if (alphaOps == COPY_ALPHA_TO_SEPARATIONS) {
                             dstCs->setOpacity(dstIt->rawData(), srcCs->opacityU8(srcIt->oldRawData()), 1);
                         } else {
                             dstCs->setOpacity(dstIt->rawData(), OPACITY_OPAQUE_U8, 1);
                         }
                     } else if (channelSize == 2 && destSize == 2) {
 
                         // Both 16-bit
                         dstIt->rawData()[0] = srcIt->oldRawData()[channelPos];
                         dstIt->rawData()[1] = srcIt->oldRawData()[channelPos + 1];
 
                         if (alphaOps == COPY_ALPHA_TO_SEPARATIONS) {
                             dstCs->setOpacity(dstIt->rawData(), srcCs->opacityU8(srcIt->oldRawData()), 1);
                         } else {
                             dstCs->setOpacity(dstIt->rawData(), OPACITY_OPAQUE_U8, 1);
                         }
                     } else if (channelSize != 1 && destSize == 1) {
                         // Downscale
                         memset(dstIt->rawData(), srcCs->scaleToU8(srcIt->oldRawData(), channelPos), 1);
 
                         // XXX: Do alpha
                         dstCs->setOpacity(dstIt->rawData(), OPACITY_OPAQUE_U8, 1);
                     } else if (channelSize != 2 && destSize == 2) {
                         // Upscale
                         dstIt->rawData()[0] = srcCs->scaleToU8(srcIt->oldRawData(), channelPos);
 
                         // XXX: Do alpha
                         dstCs->setOpacity(dstIt->rawData(), OPACITY_OPAQUE_U8, 1);
 
                     }
                 }
 
             } while (dstIt->nextPixel() && srcIt->nextPixel());
             dstIt->nextRow();
             srcIt->nextRow();
         }
         ++i;
 
         progressUpdater->setProgress((i * 100) / numberOfChannels);
         if (progressUpdater->interrupted()) {
             break;
         }
     }
 
     vKisPaintDeviceSP_it deviceIt = layers.begin();
 
     progressUpdater->setProgress(100);
 
     if (!progressUpdater->interrupted()) {
 
         KisUndoAdapter * undo = image->undoAdapter();
         if (outputOps == TO_LAYERS) {
             undo->beginMacro(kundo2_i18n("Separate Image"));
         }
 
         // Flatten the image if required
         switch (sourceOps) {
         case(ALL_LAYERS):
             image->flatten();
             break;
         default:
             break;
         }
         KisNodeCommandsAdapter adapter(m_viewManager);
 
         for (QList<KoChannelInfo *>::const_iterator it = begin; it != end; ++it) {
 
             KoChannelInfo * ch = (*it);
 
             if (ch->channelType() == KoChannelInfo::ALPHA && alphaOps != CREATE_ALPHA_SEPARATION) {
                 // Don't make an separate separation of the alpha channel if the user didn't ask for it.
                 continue;
             }
 
             if (outputOps == TO_LAYERS) {
                 KisPaintLayerSP l = KisPaintLayerSP(new KisPaintLayer(image.data(), ch->name(), OPACITY_OPAQUE_U8, *deviceIt));
                 adapter.addNode(l.data(), image->rootLayer(), 0);
             }
             else {
                 KoFileDialog dialog(m_viewManager->mainWindow(), KoFileDialog::SaveFile, "OpenDocument");
                 dialog.setCaption(i18n("Export Layer") + '(' + ch->name() + ')');
                 dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
-                dialog.setMimeTypeFilters(KisImportExportManager::mimeFilter(KisImportExportManager::Export));
+                dialog.setMimeTypeFilters(KisImportExportManager::supportedMimeTypes(KisImportExportManager::Export));
                 QUrl url = QUrl::fromUserInput(dialog.filename());
 
                 if (url.isEmpty())
                     return;
 
                 const QString mimeType = KisMimeDatabase::mimeTypeForFile(url.toLocalFile(), false);
 
                 KisPaintLayerSP l = KisPaintLayerSP(new KisPaintLayer(image.data(), ch->name(), OPACITY_OPAQUE_U8, *deviceIt));
                 QRect r = l->exactBounds();
 
                 KisDocument *d = KisPart::instance()->createDocument();
 
                 KisImageWSP dst = KisImageWSP(new KisImage(d->createUndoStore(), r.width(), r.height(), (*deviceIt)->colorSpace(), l->name()));
                 d->setCurrentImage(dst);
                 dst->addNode(l->clone().data(), dst->rootLayer());
 
                 d->exportDocumentSync(url, mimeType.toLatin1());
 
                 delete d;
 
             }
 
             ++deviceIt;
         }
 
         if (outputOps == TO_LAYERS) {
             undo->endMacro();
         }
         image->unlock();
         image->setModified();
     }
 }
diff --git a/plugins/filters/fastcolortransfer/kis_wdg_fastcolortransfer.cpp b/plugins/filters/fastcolortransfer/kis_wdg_fastcolortransfer.cpp
index f4d3cbfb6c..5484b945d0 100644
--- a/plugins/filters/fastcolortransfer/kis_wdg_fastcolortransfer.cpp
+++ b/plugins/filters/fastcolortransfer/kis_wdg_fastcolortransfer.cpp
@@ -1,146 +1,146 @@
 /*
  * This file is part of Krita
  *
  * Copyright (c) 2006 Cyrille Berger <cberger@cberger.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_wdg_fastcolortransfer.h"
 
 #include <QLayout>
 
 #include <KisImportExportFilter.h>
 #include <KisImportExportManager.h>
 
 #include <filter/kis_filter_configuration.h>
 #include <KisDocument.h>
 #include <KisPart.h>
 #include <kis_image.h>
 #include <kis_iterator_ng.h>
 #include <kis_paint_device.h>
 #include <kundo2command.h>
 #include <KoColorSpaceRegistry.h>
 #include <KisImportExportManager.h>
 #include <kis_file_name_requester.h>
 #include "ui_wdgfastcolortransfer.h"
 
 KisWdgFastColorTransfer::KisWdgFastColorTransfer(QWidget * parent) : KisConfigWidget(parent)
 {
     m_widget = new Ui_WdgFastColorTransfer();
     m_widget->setupUi(this);
-    m_widget->fileNameURLRequester->setMimeTypeFilters(KisImportExportManager::mimeFilter(KisImportExportManager::Import));
+    m_widget->fileNameURLRequester->setMimeTypeFilters(KisImportExportManager::supportedMimeTypes(KisImportExportManager::Import));
     connect(m_widget->fileNameURLRequester, SIGNAL(textChanged(const QString&)), this, SIGNAL(sigConfigurationItemChanged()));
 }
 
 
 KisWdgFastColorTransfer::~KisWdgFastColorTransfer()
 {
     delete m_widget;
 }
 
 void KisWdgFastColorTransfer::setConfiguration(const KisPropertiesConfigurationSP config)
 {
     QVariant value;
     if (config->getProperty("filename", value)) {
         widget()->fileNameURLRequester->setFileName(value.toString());
     }
 
 }
 
 KisPropertiesConfigurationSP KisWdgFastColorTransfer::configuration() const
 {
     KisFilterConfigurationSP config = new KisFilterConfiguration("colortransfer", 1);
     QString fileName = this->widget()->fileNameURLRequester->fileName();
 
     if (fileName.isEmpty()) return config;
 
     KisPaintDeviceSP ref;
 
     dbgPlugins << "Use as reference file : " << fileName;
 
     KisDocument *d = KisPart::instance()->createDocument();
 
     KisImportExportManager manager(d);
     KisImportExportFilter::ConversionStatus status = manager.importDocument(fileName, QString());
     dbgPlugins << "import returned status" << status;
     KisImageWSP importedImage = d->image();
 
     if (importedImage) {
         ref = importedImage->projection();
     }
     if (!ref) {
         dbgPlugins << "No reference image was specified.";
         delete d;
         return config;
     }
 
     // Convert ref to LAB
     const KoColorSpace* labCS = KoColorSpaceRegistry::instance()->lab16();
     if (!labCS) {
         dbgPlugins << "The LAB colorspace is not available.";
         delete d;
         return config;
     }
 
     dbgPlugins << "convert ref to lab";
     KUndo2Command* cmd = ref->convertTo(labCS, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
     delete cmd;
 
     // Compute the means and sigmas of ref
     double meanL_ref = 0., meanA_ref = 0., meanB_ref = 0.;
     double sigmaL_ref = 0., sigmaA_ref = 0., sigmaB_ref = 0.;
 
     KisSequentialConstIterator refIt(ref, importedImage->bounds());
     while (refIt.nextPixel()) {
         const quint16* data = reinterpret_cast<const quint16*>(refIt.oldRawData());
 
         quint32 L = data[0];
         quint32 A = data[1];
         quint32 B = data[2];
 
         meanL_ref += L;
         meanA_ref += A;
         meanB_ref += B;
 
         sigmaL_ref += L * L;
         sigmaA_ref += A * A;
         sigmaB_ref += B * B;
 
     }
 
     double totalSize = 1. / (importedImage->width() * importedImage->height());
 
     meanL_ref *= totalSize;
     meanA_ref *= totalSize;
     meanB_ref *= totalSize;
     sigmaL_ref *= totalSize;
     sigmaA_ref *= totalSize;
     sigmaB_ref *= totalSize;
 
     dbgPlugins << totalSize << "" << meanL_ref << "" << meanA_ref << "" << meanB_ref << "" << sigmaL_ref << "" << sigmaA_ref << "" << sigmaB_ref;
 
     config->setProperty("filename", fileName);
     config->setProperty("meanL", meanL_ref);
     config->setProperty("meanA", meanA_ref);
     config->setProperty("meanB", meanB_ref);
     config->setProperty("sigmaL", sigmaL_ref);
     config->setProperty("sigmaA", sigmaA_ref);
     config->setProperty("sigmaB", sigmaB_ref);
 
     delete d;
 
     return config;
 }
diff --git a/plugins/impex/libkra/kis_kra_loader.cpp b/plugins/impex/libkra/kis_kra_loader.cpp
index b31696e568..fec9d966d5 100644
--- a/plugins/impex/libkra/kis_kra_loader.cpp
+++ b/plugins/impex/libkra/kis_kra_loader.cpp
@@ -1,1197 +1,1197 @@
 /* This file is part of the KDE project
  * Copyright (C) Boudewijn Rempt <boud@valdyas.org>, (C) 2007
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "kis_kra_loader.h"
 
 #include <QApplication>
 #include <QStringList>
 
 #include <QMessageBox>
 
 #include <QUrl>
 #include <QBuffer>
 
 #include <KoStore.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorSpaceEngine.h>
 #include <KoColorProfile.h>
 #include <KoDocumentInfo.h>
 #include <KoFileDialog.h>
 #include <KisImportExportManager.h>
 #include <KoXmlReader.h>
 #include <KoStoreDevice.h>
 
 #include <filter/kis_filter.h>
 #include <filter/kis_filter_registry.h>
 #include <generator/kis_generator.h>
 #include <generator/kis_generator_layer.h>
 #include <generator/kis_generator_registry.h>
 #include <kis_adjustment_layer.h>
 #include <kis_annotation.h>
 #include <kis_base_node.h>
 #include <kis_clone_layer.h>
 #include <kis_debug.h>
 #include <kis_assert.h>
 #include <kis_external_layer_iface.h>
 #include <kis_filter_mask.h>
 #include <kis_transform_mask.h>
 #include "lazybrush/kis_colorize_mask.h"
 #include <kis_group_layer.h>
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <kis_name_server.h>
 #include <kis_paint_layer.h>
 #include <kis_selection.h>
 #include <kis_selection_mask.h>
 #include <kis_shape_layer.h>
 #include <kis_transparency_mask.h>
 #include <kis_layer_composition.h>
 #include <kis_file_layer.h>
 #include <kis_psd_layer_style.h>
 #include <kis_psd_layer_style_resource.h>
 #include "KisResourceServerProvider.h"
 #include "kis_keyframe_channel.h"
 #include <kis_filter_configuration.h>
 #include "KisReferenceImagesLayer.h"
 #include "KisReferenceImage.h"
 
 #include "KisDocument.h"
 #include "kis_config.h"
 #include "kis_kra_tags.h"
 #include "kis_kra_utils.h"
 #include "kis_kra_load_visitor.h"
 #include "kis_dom_utils.h"
 #include "kis_image_animation_interface.h"
 #include "kis_time_range.h"
 #include "kis_grid_config.h"
 #include "kis_guides_config.h"
 #include "kis_image_config.h"
 #include "KisProofingConfiguration.h"
 #include "kis_layer_properties_icons.h"
 #include "kis_node_view_color_scheme.h"
 
 /*
 
   Color model id comparison through the ages:
 
 2.4        2.5          2.6         ideal
 
 ALPHA      ALPHA        ALPHA       ALPHAU8
 
 CMYK       CMYK         CMYK        CMYKAU8
            CMYKAF32     CMYKAF32
 CMYKA16    CMYKAU16     CMYKAU16
 
 GRAYA      GRAYA        GRAYA       GRAYAU8
 GrayF32    GRAYAF32     GRAYAF32
 GRAYA16    GRAYAU16     GRAYAU16
 
 LABA       LABA         LABA        LABAU16
            LABAF32      LABAF32
            LABAU8       LABAU8
 
 RGBA       RGBA         RGBA        RGBAU8
 RGBA16     RGBA16       RGBA16      RGBAU16
 RgbAF32    RGBAF32      RGBAF32
 RgbAF16    RgbAF16      RGBAF16
 
 XYZA16     XYZA16       XYZA16      XYZAU16
            XYZA8        XYZA8       XYZAU8
 XyzAF16    XyzAF16      XYZAF16
 XyzAF32    XYZAF32      XYZAF32
 
 YCbCrA     YCBCRA8      YCBCRA8     YCBCRAU8
 YCbCrAU16  YCBCRAU16    YCBCRAU16
            YCBCRF32     YCBCRF32
  */
 
 using namespace KRA;
 
 struct KisKraLoader::Private
 {
 public:
 
     KisDocument* document;
     QString imageName; // used to be stored in the image, is now in the documentInfo block
     QString imageComment; // used to be stored in the image, is now in the documentInfo block
     QMap<KisNode*, QString> layerFilenames; // temp storage during loading
     int syntaxVersion; // version of the fileformat we are loading
     vKisNodeSP selectedNodes; // the nodes that were active when saving the document.
     QMap<QString, QString> assistantsFilenames;
     QList<KisPaintingAssistantSP> assistants;
     QMap<KisNode*, QString> keyframeFilenames;
     QStringList errorMessages;
     QStringList warningMessages;
 };
 
 void convertColorSpaceNames(QString &colorspacename, QString &profileProductName) {
     if (colorspacename  == "Grayscale + Alpha") {
         colorspacename  = "GRAYA";
         profileProductName.clear();
     }
     else if (colorspacename == "RgbAF32") {
         colorspacename = "RGBAF32";
         profileProductName.clear();
     }
     else if (colorspacename == "RgbAF16") {
         colorspacename = "RGBAF16";
         profileProductName.clear();
     }
     else if (colorspacename == "CMYKA16") {
         colorspacename = "CMYKAU16";
     }
     else if (colorspacename == "GrayF32") {
         colorspacename =  "GRAYAF32";
         profileProductName.clear();
     }
     else if (colorspacename == "GRAYA16") {
         colorspacename  = "GRAYAU16";
     }
     else if (colorspacename == "XyzAF16") {
         colorspacename  = "XYZAF16";
         profileProductName.clear();
     }
     else if (colorspacename == "XyzAF32") {
         colorspacename  = "XYZAF32";
         profileProductName.clear();
     }
     else if (colorspacename == "YCbCrA") {
         colorspacename  = "YCBCRA8";
     }
     else if (colorspacename == "YCbCrAU16") {
         colorspacename  = "YCBCRAU16";
     }
 }
 
 KisKraLoader::KisKraLoader(KisDocument * document, int syntaxVersion)
         : m_d(new Private())
 {
     m_d->document = document;
     m_d->syntaxVersion = syntaxVersion;
 }
 
 
 KisKraLoader::~KisKraLoader()
 {
     delete m_d;
 }
 
 
 KisImageSP KisKraLoader::loadXML(const KoXmlElement& element)
 {
     QString attr;
     KisImageSP image = 0;
     QString name;
     qint32 width;
     qint32 height;
     QString profileProductName;
     double xres;
     double yres;
     QString colorspacename;
     const KoColorSpace * cs;
 
     if ((attr = element.attribute(MIME)) == NATIVE_MIMETYPE) {
 
         if ((m_d->imageName = element.attribute(NAME)).isNull()) {
             m_d->errorMessages << i18n("Image does not have a name.");
             return KisImageSP(0);
         }
 
         if ((attr = element.attribute(WIDTH)).isNull()) {
             m_d->errorMessages << i18n("Image does not specify a width.");
             return KisImageSP(0);
         }
         width = KisDomUtils::toInt(attr);
 
         if ((attr = element.attribute(HEIGHT)).isNull()) {
             m_d->errorMessages << i18n("Image does not specify a height.");
             return KisImageSP(0);
         }
 
         height = KisDomUtils::toInt(attr);
 
         m_d->imageComment = element.attribute(DESCRIPTION);
 
         xres = 100.0 / 72.0;
         if (!(attr = element.attribute(X_RESOLUTION)).isNull()) {
             qreal value = KisDomUtils::toDouble(attr);
 
             if (value > 1.0) {
                 xres = value / 72.0;
             }
         }
 
         yres = 100.0 / 72.0;
         if (!(attr = element.attribute(Y_RESOLUTION)).isNull()) {
             qreal value = KisDomUtils::toDouble(attr);
             if (value > 1.0) {
                 yres = value / 72.0;
             }
         }
 
         if ((colorspacename = element.attribute(COLORSPACE_NAME)).isNull()) {
             // An old file: take a reasonable default.
             // Krita didn't support anything else in those
             // days anyway.
             colorspacename = "RGBA";
         }
 
         profileProductName = element.attribute(PROFILE);
         // A hack for an old colorspacename
         convertColorSpaceNames(colorspacename, profileProductName);
 
         QString colorspaceModel = KoColorSpaceRegistry::instance()->colorSpaceColorModelId(colorspacename).id();
         QString colorspaceDepth = KoColorSpaceRegistry::instance()->colorSpaceColorDepthId(colorspacename).id();
 
         if (profileProductName.isNull()) {
             // no mention of profile so get default profile";
             cs = KoColorSpaceRegistry::instance()->colorSpace(colorspaceModel, colorspaceDepth, "");
         } else {
             cs = KoColorSpaceRegistry::instance()->colorSpace(colorspaceModel, colorspaceDepth, profileProductName);
         }
 
         if (cs == 0) {
             // try once more without the profile
             cs = KoColorSpaceRegistry::instance()->colorSpace(colorspaceModel, colorspaceDepth, "");
             if (cs == 0) {
                 m_d->errorMessages << i18n("Image specifies an unsupported color model: %1.", colorspacename);
                 return KisImageSP(0);
             }
         }
         KisImageConfig cfgImage;
         KisProofingConfigurationSP proofingConfig = cfgImage.defaultProofingconfiguration();
         if (!(attr = element.attribute(PROOFINGPROFILENAME)).isNull()) {
             proofingConfig->proofingProfile = attr;
         }
         if (!(attr = element.attribute(PROOFINGMODEL)).isNull()) {
             proofingConfig->proofingModel = attr;
         }
         if (!(attr = element.attribute(PROOFINGDEPTH)).isNull()) {
             proofingConfig->proofingDepth = attr;
         }
         if (!(attr = element.attribute(PROOFINGINTENT)).isNull()) {
             proofingConfig->intent = (KoColorConversionTransformation::Intent) KisDomUtils::toInt(attr);
         }
 
         if (!(attr = element.attribute(PROOFINGADAPTATIONSTATE)).isNull()) {
             proofingConfig->adaptationState = KisDomUtils::toDouble(attr);
         }
 
         if (m_d->document) {
             image = new KisImage(m_d->document->createUndoStore(), width, height, cs, name);
         }
         else {
             image = new KisImage(0, width, height, cs, name);
         }
         image->setResolution(xres, yres);
         loadNodes(element, image, const_cast<KisGroupLayer*>(image->rootLayer().data()));
 
 
         KoXmlNode child;
         for (child = element.lastChild(); !child.isNull(); child = child.previousSibling()) {
             KoXmlElement e = child.toElement();
             if(e.tagName() == CANVASPROJECTIONCOLOR) {
                 if (e.hasAttribute(COLORBYTEDATA)) {
                     QByteArray colorData = QByteArray::fromBase64(e.attribute(COLORBYTEDATA).toLatin1());
                     KoColor color((const quint8*)colorData.data(), image->colorSpace());
                     image->setDefaultProjectionColor(color);
                 }
             }
 
             if(e.tagName()== PROOFINGWARNINGCOLOR) {
                 QDomDocument dom;
                 KoXml::asQDomElement(dom, e);
                 QDomElement eq = dom.firstChildElement();
                 proofingConfig->warningColor = KoColor::fromXML(eq.firstChildElement(), Integer8BitsColorDepthID.id());
             }
 
             if (e.tagName().toLower() == "animation") {
                 loadAnimationMetadata(e, image);
             }
         }
 
         image->setProofingConfiguration(proofingConfig);
 
         for (child = element.lastChild(); !child.isNull(); child = child.previousSibling()) {
             KoXmlElement e = child.toElement();
             if(e.tagName() == "compositions") {
                 loadCompositions(e, image);
             }
         }
     }
     KoXmlNode child;
 
     for (child = element.lastChild(); !child.isNull(); child = child.previousSibling()) {
         KoXmlElement e = child.toElement();
         if (e.tagName() == "grid") {
             loadGrid(e);
         } else if (e.tagName() == "guides") {
             loadGuides(e);
         } else if (e.tagName() == "assistants") {
             loadAssistantsList(e);
         } else if (e.tagName() == "audio") {
             loadAudio(e, image);
         }
     }
 
     return image;
 }
 
 void KisKraLoader::loadBinaryData(KoStore * store, KisImageSP image, const QString & uri, bool external)
 {
     // icc profile: if present, this overrides the profile product name loaded in loadXML.
     QString location = external ? QString() : uri;
     location += m_d->imageName + ICC_PATH;
     if (store->hasFile(location)) {
         if (store->open(location)) {
             QByteArray data; data.resize(store->size());
             bool res = (store->read(data.data(), store->size()) > -1);
             store->close();
             if (res) {
                 const KoColorProfile *profile = KoColorSpaceRegistry::instance()->createColorProfile(image->colorSpace()->colorModelId().id(), image->colorSpace()->colorDepthId().id(), data);
                 if (profile && profile->valid()) {
                     res = image->assignImageProfile(profile);
                 }
                 if (!res) {
                     const QString defaultProfileId = KoColorSpaceRegistry::instance()->defaultProfileForColorSpace(image->colorSpace()->id());
                     profile = KoColorSpaceRegistry::instance()->profileByName(defaultProfileId);
                     Q_ASSERT(profile && profile->valid());
                     image->assignImageProfile(profile);
                 }
             }
         }
     }
     //load the embed proofing profile, it only needs to be loaded into Krita, not assigned.
     location = external ? QString() : uri;
     location += m_d->imageName + ICC_PROOFING_PATH;
     if (store->hasFile(location)) {
         if (store->open(location)) {
             QByteArray proofingData;
             proofingData.resize(store->size());
             bool proofingProfileRes = (store->read(proofingData.data(), store->size())>-1);
             store->close();
 
             KisProofingConfigurationSP proofingConfig = image->proofingConfiguration();
             if (!proofingConfig) {
                 proofingConfig = KisImageConfig().defaultProofingconfiguration();
             }
 
             if (proofingProfileRes) {
                 const KoColorProfile *proofingProfile = KoColorSpaceRegistry::instance()->createColorProfile(proofingConfig->proofingModel, proofingConfig->proofingDepth, proofingData);
                 if (proofingProfile->valid()){
                     KoColorSpaceRegistry::instance()->addProfile(proofingProfile);
                 }
             }
         }
     }
 
 
     // Load the layers data: if there is a profile associated with a layer it will be set now.
     KisKraLoadVisitor visitor(image, store, m_d->layerFilenames, m_d->keyframeFilenames, m_d->imageName, m_d->syntaxVersion);
 
     if (external) {
         visitor.setExternalUri(uri);
     }
 
     image->rootLayer()->accept(visitor);
     if (!visitor.errorMessages().isEmpty()) {
         m_d->errorMessages.append(visitor.errorMessages());
     }
     if (!visitor.warningMessages().isEmpty()) {
         m_d->warningMessages.append(visitor.warningMessages());
     }
 
     // annotations
     // exif
     location = external ? QString() : uri;
     location += m_d->imageName + EXIF_PATH;
     if (store->hasFile(location)) {
         QByteArray data;
         store->open(location);
         data = store->read(store->size());
         store->close();
         image->addAnnotation(KisAnnotationSP(new KisAnnotation("exif", "", data)));
     }
 
 
     // layer styles
     location = external ? QString() : uri;
     location += m_d->imageName + LAYER_STYLES_PATH;
     if (store->hasFile(location)) {
         KisPSDLayerStyleCollectionResource *collection =
             new KisPSDLayerStyleCollectionResource("Embedded Styles.asl");
 
         collection->setName(i18nc("Auto-generated layer style collection name for embedded styles (collection)", "<%1> (embedded)", m_d->imageName));
 
         KIS_ASSERT_RECOVER_NOOP(!collection->valid());
 
         store->open(location);
         {
             KoStoreDevice device(store);
             device.open(QIODevice::ReadOnly);
 
             /**
              * ASL loading code cannot work with non-sequential IO devices,
              * so convert the device beforehand!
              */
             QByteArray buf = device.readAll();
             QBuffer raDevice(&buf);
             raDevice.open(QIODevice::ReadOnly);
             collection->loadFromDevice(&raDevice);
         }
         store->close();
 
         if (collection->valid()) {
             KoResourceServer<KisPSDLayerStyleCollectionResource> *server = KisResourceServerProvider::instance()->layerStyleCollectionServer();
             server->addResource(collection, false);
 
             collection->assignAllLayerStyles(image->root());
         } else {
             warnKrita << "WARNING: Couldn't load layer styles library from .kra!";
             delete collection;
         }
     }
 
     if (m_d->document && m_d->document->documentInfo()->aboutInfo("title").isNull())
         m_d->document->documentInfo()->setAboutInfo("title", m_d->imageName);
     if (m_d->document && m_d->document->documentInfo()->aboutInfo("comment").isNull())
         m_d->document->documentInfo()->setAboutInfo("comment", m_d->imageComment);
 
     loadAssistants(store, uri, external);
 }
 
 vKisNodeSP KisKraLoader::selectedNodes() const
 {
     return m_d->selectedNodes;
 }
 
 QList<KisPaintingAssistantSP> KisKraLoader::assistants() const
 {
     return m_d->assistants;
 }
 
 QStringList KisKraLoader::errorMessages() const
 {
     return m_d->errorMessages;
 }
 
 QStringList KisKraLoader::warningMessages() const
 {
     return m_d->warningMessages;
 }
 
 
 void KisKraLoader::loadAssistants(KoStore *store, const QString &uri, bool external)
 {
     QString file_path;
     QString location;
     QMap<int ,KisPaintingAssistantHandleSP> handleMap;
     KisPaintingAssistant* assistant = 0;
     QMap<QString,QString>::const_iterator loadedAssistant = m_d->assistantsFilenames.constBegin();
     while (loadedAssistant != m_d->assistantsFilenames.constEnd()){
         const KisPaintingAssistantFactory* factory = KisPaintingAssistantFactoryRegistry::instance()->get(loadedAssistant.value());
         if (factory) {
             assistant = factory->createPaintingAssistant();
             location = external ? QString() : uri;
             location += m_d->imageName + ASSISTANTS_PATH;
             file_path = location + loadedAssistant.key();
             assistant->loadXml(store, handleMap, file_path);
 
             //If an assistant has too few handles than it should according to it's own setup, just don't load it//
             if (assistant->handles().size()==assistant->numHandles()){
                 m_d->assistants.append(toQShared(assistant));
             }
         }
         loadedAssistant++;
     }
 }
 
 void KisKraLoader::loadAnimationMetadata(const KoXmlElement &element, KisImageSP image)
 {
     QDomDocument qDom;
     KoXml::asQDomElement(qDom, element);
     QDomElement qElement = qDom.firstChildElement();
 
     float framerate;
     KisTimeRange range;
     int currentTime;
 
     KisImageAnimationInterface *animation = image->animationInterface();
 
     if (KisDomUtils::loadValue(qElement, "framerate", &framerate)) {
         animation->setFramerate(framerate);
     }
 
     if (KisDomUtils::loadValue(qElement, "range", &range)) {
         animation->setFullClipRange(range);
     }
 
     if (KisDomUtils::loadValue(qElement, "currentTime", &currentTime)) {
         animation->switchCurrentTimeAsync(currentTime);
     }
 }
 
 KisNodeSP KisKraLoader::loadNodes(const KoXmlElement& element, KisImageSP image, KisNodeSP parent)
 {
 
     KoXmlNode node = element.firstChild();
     KoXmlNode child;
 
     if (!node.isNull()) {
 
         if (node.isElement()) {
 
             if (node.nodeName().toUpper() == LAYERS.toUpper() || node.nodeName().toUpper() == MASKS.toUpper()) {
                 for (child = node.lastChild(); !child.isNull(); child = child.previousSibling()) {
                     KisNodeSP node = loadNode(child.toElement(), image);
                     if (node) {
                         image->nextLayerName(); // Make sure the nameserver is current with the number of nodes.
                         image->addNode(node, parent);
                         if (node->inherits("KisLayer") && KoXml::childNodesCount(child) > 0) {
                             loadNodes(child.toElement(), image, node);
                         }
                     }
                 }
             }
         }
     }
 
     return parent;
 }
 
 KisNodeSP KisKraLoader::loadNode(const KoXmlElement& element, KisImageSP image)
 {
     // Nota bene: If you add new properties to layers, you should
     // ALWAYS define a default value in case the property is not
     // present in the layer definition: this helps a LOT with backward
     // compatibility.
     QString name = element.attribute(NAME, "No Name");
 
     QUuid id = QUuid(element.attribute(UUID, QUuid().toString()));
 
     qint32 x = element.attribute(X, "0").toInt();
     qint32 y = element.attribute(Y, "0").toInt();
 
     qint32 opacity = element.attribute(OPACITY, QString::number(OPACITY_OPAQUE_U8)).toInt();
     if (opacity < OPACITY_TRANSPARENT_U8) opacity = OPACITY_TRANSPARENT_U8;
     if (opacity > OPACITY_OPAQUE_U8) opacity = OPACITY_OPAQUE_U8;
 
     const KoColorSpace* colorSpace = 0;
     if ((element.attribute(COLORSPACE_NAME)).isNull()) {
         dbgFile << "No attribute color space for layer: " << name;
         colorSpace = image->colorSpace();
     }
     else {
         QString colorspacename = element.attribute(COLORSPACE_NAME);
         QString profileProductName;
 
         convertColorSpaceNames(colorspacename, profileProductName);
 
         QString colorspaceModel = KoColorSpaceRegistry::instance()->colorSpaceColorModelId(colorspacename).id();
         QString colorspaceDepth = KoColorSpaceRegistry::instance()->colorSpaceColorDepthId(colorspacename).id();
         dbgFile << "Searching color space: " << colorspacename << colorspaceModel << colorspaceDepth << " for layer: " << name;
         // use default profile - it will be replaced later in completeLoading
 
         colorSpace = KoColorSpaceRegistry::instance()->colorSpace(colorspaceModel, colorspaceDepth, "");
         dbgFile << "found colorspace" << colorSpace;
         if (!colorSpace) {
             m_d->warningMessages << i18n("Layer %1 specifies an unsupported color model: %2.", name, colorspacename);
             return 0;
         }
     }
 
     const bool visible = element.attribute(VISIBLE, "1") == "0" ? false : true;
     const bool locked = element.attribute(LOCKED, "0") == "0" ? false : true;
     const bool collapsed = element.attribute(COLLAPSED, "0") == "0" ? false : true;
     int colorLabelIndex = element.attribute(COLOR_LABEL, "0").toInt();
     QVector<QColor> labels = KisNodeViewColorScheme::instance()->allColorLabels();
     if (colorLabelIndex >= labels.size()) {
         colorLabelIndex = labels.size() - 1;
     }
 
     // Now find out the layer type and do specific handling
     QString nodeType;
 
     if (m_d->syntaxVersion == 1) {
         nodeType = element.attribute("layertype");
         if (nodeType.isEmpty()) {
             nodeType = PAINT_LAYER;
         }
     }
     else {
         nodeType = element.attribute(NODE_TYPE);
     }
 
     if (nodeType.isEmpty()) {
         m_d->warningMessages << i18n("Layer %1 has an unsupported type.", name);
         return 0;
     }
 
 
     KisNodeSP node = 0;
 
     if (nodeType == PAINT_LAYER)
         node = loadPaintLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == GROUP_LAYER)
         node = loadGroupLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == ADJUSTMENT_LAYER)
         node = loadAdjustmentLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == SHAPE_LAYER)
         node = loadShapeLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == GENERATOR_LAYER)
         node = loadGeneratorLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == CLONE_LAYER)
         node = loadCloneLayer(element, image, name, colorSpace, opacity);
     else if (nodeType == FILTER_MASK)
         node = loadFilterMask(element);
     else if (nodeType == TRANSFORM_MASK)
         node = loadTransformMask(element);
     else if (nodeType == TRANSPARENCY_MASK)
         node = loadTransparencyMask(element);
     else if (nodeType == SELECTION_MASK)
         node = loadSelectionMask(image, element);
     else if (nodeType == COLORIZE_MASK)
         node = loadColorizeMask(image, element, colorSpace);
     else if (nodeType == FILE_LAYER)
         node = loadFileLayer(element, image, name, opacity);
     else if (nodeType == REFERENCE_IMAGES_LAYER)
         node = loadReferenceImagesLayer(element, image);
     else {
         m_d->warningMessages << i18n("Layer %1 has an unsupported type: %2.", name, nodeType);
         return 0;
     }
 
     // Loading the node went wrong. Return empty node and leave to
     // upstream to complain to the user
     if (!node) {
         m_d->warningMessages << i18n("Failure loading layer %1 of type: %2.", name, nodeType);
         return 0;
     }
 
     node->setVisible(visible, true);
     node->setUserLocked(locked);
     node->setCollapsed(collapsed);
     node->setColorLabelIndex(colorLabelIndex);
     node->setX(x);
     node->setY(y);
     node->setName(name);
 
     if (! id.isNull())          // if no uuid in file, new one has been generated already
         node->setUuid(id);
 
     if (node->inherits("KisLayer") || node->inherits("KisColorizeMask")) {
         QString compositeOpName = element.attribute(COMPOSITE_OP, "normal");
         node->setCompositeOpId(compositeOpName);
     }
 
     if (node->inherits("KisLayer")) {
         KisLayer* layer           = qobject_cast<KisLayer*>(node.data());
         QBitArray channelFlags    = stringToFlags(element.attribute(CHANNEL_FLAGS, ""), colorSpace->channelCount());
         layer->setChannelFlags(channelFlags);
 
         if (element.hasAttribute(LAYER_STYLE_UUID)) {
             QString uuidString = element.attribute(LAYER_STYLE_UUID);
             QUuid uuid(uuidString);
             if (!uuid.isNull()) {
                 KisPSDLayerStyleSP dumbLayerStyle(new KisPSDLayerStyle());
                 dumbLayerStyle->setUuid(uuid);
                 layer->setLayerStyle(dumbLayerStyle);
             } else {
                 warnKrita << "WARNING: Layer style for layer" << layer->name() << "contains invalid UUID" << uuidString;
             }
         }
     }
 
     if (node->inherits("KisGroupLayer")) {
         if (element.hasAttribute(PASS_THROUGH_MODE)) {
             bool value = element.attribute(PASS_THROUGH_MODE, "0") != "0";
 
             KisGroupLayer *group = qobject_cast<KisGroupLayer*>(node.data());
             group->setPassThroughMode(value);
         }
     }
 
     const bool timelineEnabled = element.attribute(VISIBLE_IN_TIMELINE, "0") == "0" ? false : true;
     node->setUseInTimeline(timelineEnabled);
 
     if (node->inherits("KisPaintLayer")) {
         KisPaintLayer* layer            = qobject_cast<KisPaintLayer*>(node.data());
         bool onionEnabled = element.attribute(ONION_SKIN_ENABLED, "0") == "0" ? false : true;
         layer->setOnionSkinEnabled(onionEnabled);
     }
 
     if (element.attribute(FILE_NAME).isNull()) {
         m_d->layerFilenames[node.data()] = name;
     }
     else {
         m_d->layerFilenames[node.data()] = element.attribute(FILE_NAME);
     }
 
     if (element.hasAttribute("selected") && element.attribute("selected") == "true")  {
         m_d->selectedNodes.append(node);
     }
 
     if (element.hasAttribute(KEYFRAME_FILE)) {
         m_d->keyframeFilenames.insert(node.data(), element.attribute(KEYFRAME_FILE));
     }
 
     return node;
 }
 
 
 KisNodeSP KisKraLoader::loadPaintLayer(const KoXmlElement& element, KisImageSP image,
                                       const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
     Q_UNUSED(element);
     KisPaintLayer* layer;
 
     layer = new KisPaintLayer(image, name, opacity, cs);
     Q_CHECK_PTR(layer);
     return layer;
 
 }
 
 KisNodeSP KisKraLoader::loadFileLayer(const KoXmlElement& element, KisImageSP image, const QString& name, quint32 opacity)
 {
     QString filename = element.attribute("source", QString());
     if (filename.isNull()) return 0;
     bool scale = (element.attribute("scale", "true")  == "true");
     int scalingMethod = element.attribute("scalingmethod", "-1").toInt();
     if (scalingMethod < 0) {
         if (scale) {
             scalingMethod = KisFileLayer::ToImagePPI;
         }
         else {
             scalingMethod = KisFileLayer::None;
         }
     }
 
     QString documentPath;
     if (m_d->document) {
         documentPath = m_d->document->url().toLocalFile();
     }
     QFileInfo info(documentPath);
     QString basePath = info.absolutePath();
 
     QString fullPath = QDir(basePath).filePath(QDir::cleanPath(filename));
     if (!QFileInfo(fullPath).exists()) {
 
         qApp->setOverrideCursor(Qt::ArrowCursor);
         QString msg = i18nc(
             "@info",
             "The file associated to a file layer with the name \"%1\" is not found.\n\n"
             "Expected path:\n"
             "%2\n\n"
             "Do you want to locate it manually?", name, fullPath);
 
         int result = QMessageBox::warning(0, i18nc("@title:window", "File not found"), msg, QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
 
         if (result == QMessageBox::Yes) {
 
             KoFileDialog dialog(0, KoFileDialog::OpenFile, "OpenDocument");
-            dialog.setMimeTypeFilters(KisImportExportManager::mimeFilter(KisImportExportManager::Import));
+            dialog.setMimeTypeFilters(KisImportExportManager::supportedMimeTypes(KisImportExportManager::Import));
             dialog.setDefaultDir(basePath);
             QString url = dialog.filename();
 
             if (!QFileInfo(basePath).exists()) {
                 filename = url;
             } else {
                 QDir d(basePath);
                 filename = d.relativeFilePath(url);
             }
         }
 
         qApp->restoreOverrideCursor();
     }
 
     KisLayer *layer = new KisFileLayer(image, basePath, filename, (KisFileLayer::ScalingMethod)scalingMethod, name, opacity);
     Q_CHECK_PTR(layer);
 
     return layer;
 }
 
 KisNodeSP KisKraLoader::loadGroupLayer(const KoXmlElement& element, KisImageSP image,
                                       const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
     Q_UNUSED(element);
     Q_UNUSED(cs);
     QString attr;
     KisGroupLayer* layer;
 
     layer = new KisGroupLayer(image, name, opacity);
     Q_CHECK_PTR(layer);
 
     return layer;
 
 }
 
 KisNodeSP KisKraLoader::loadAdjustmentLayer(const KoXmlElement& element, KisImageSP image,
         const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
     // XXX: do something with filterversion?
     Q_UNUSED(cs);
     QString attr;
     KisAdjustmentLayer* layer;
     QString filtername;
     QString legacy = filtername;
 
     if ((filtername = element.attribute(FILTER_NAME)).isNull()) {
         // XXX: Invalid adjustmentlayer! We should warn about it!
         warnFile << "No filter in adjustment layer";
         return 0;
     }
 
     //get deprecated filters.
     if (filtername=="brightnesscontrast") {
         legacy = filtername;
         filtername = "perchannel";
     }
     if (filtername=="left edge detections"
             || filtername=="right edge detections"
             || filtername=="top edge detections"
             || filtername=="bottom edge detections") {
         legacy = filtername;
         filtername = "edge detection";
     }
 
     KisFilterSP f = KisFilterRegistry::instance()->value(filtername);
     if (!f) {
         warnFile << "No filter for filtername" << filtername << "";
         return 0; // XXX: We don't have this filter. We should warn about it!
     }
 
     KisFilterConfigurationSP  kfc = f->defaultConfiguration();
     kfc->setProperty("legacy", legacy);
     if (legacy=="brightnesscontrast") {
         kfc->setProperty("colorModel", cs->colorModelId().id());
     }
 
     // We'll load the configuration and the selection later.
     layer = new KisAdjustmentLayer(image, name, kfc, 0);
     Q_CHECK_PTR(layer);
 
     layer->setOpacity(opacity);
 
     return layer;
 
 }
 
 
 KisNodeSP KisKraLoader::loadShapeLayer(const KoXmlElement& element, KisImageSP image,
                                       const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
 
     Q_UNUSED(element);
     Q_UNUSED(cs);
 
     QString attr;
     KoShapeBasedDocumentBase * shapeController = 0;
     if (m_d->document) {
         shapeController = m_d->document->shapeController();
     }
     KisShapeLayer* layer = new KisShapeLayer(shapeController, image, name, opacity);
     Q_CHECK_PTR(layer);
 
     return layer;
 
 }
 
 
 KisNodeSP KisKraLoader::loadGeneratorLayer(const KoXmlElement& element, KisImageSP image,
         const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
     Q_UNUSED(cs);
     // XXX: do something with generator version?
     KisGeneratorLayer* layer;
     QString generatorname = element.attribute(GENERATOR_NAME);
 
     if (generatorname.isNull()) {
         // XXX: Invalid generator layer! We should warn about it!
         warnFile << "No generator in generator layer";
         return 0;
     }
 
     KisGeneratorSP generator = KisGeneratorRegistry::instance()->value(generatorname);
     if (!generator) {
         warnFile << "No generator for generatorname" << generatorname << "";
         return 0; // XXX: We don't have this generator. We should warn about it!
     }
 
     KisFilterConfigurationSP  kgc = generator->defaultConfiguration();
 
     // We'll load the configuration and the selection later.
     layer = new KisGeneratorLayer(image, name, kgc, 0);
     Q_CHECK_PTR(layer);
 
     layer->setOpacity(opacity);
 
     return layer;
 
 }
 
 KisNodeSP KisKraLoader::loadCloneLayer(const KoXmlElement& element, KisImageSP image,
                                       const QString& name, const KoColorSpace* cs, quint32 opacity)
 {
     Q_UNUSED(cs);
 
     KisCloneLayerSP layer = new KisCloneLayer(0, image, name, opacity);
 
     KisNodeUuidInfo info;
     if (! (element.attribute(CLONE_FROM_UUID)).isNull()) {
         info = KisNodeUuidInfo(QUuid(element.attribute(CLONE_FROM_UUID)));
     } else {
         if ((element.attribute(CLONE_FROM)).isNull()) {
             return 0;
         } else {
             info = KisNodeUuidInfo(element.attribute(CLONE_FROM));
         }
     }
     layer->setCopyFromInfo(info);
 
     if ((element.attribute(CLONE_TYPE)).isNull()) {
         return 0;
     } else {
         layer->setCopyType((CopyLayerType) element.attribute(CLONE_TYPE).toInt());
     }
 
     return layer;
 }
 
 
 KisNodeSP KisKraLoader::loadFilterMask(const KoXmlElement& element)
 {
     QString attr;
     KisFilterMask* mask;
     QString filtername;
 
     // XXX: should we check the version?
 
     if ((filtername = element.attribute(FILTER_NAME)).isNull()) {
         // XXX: Invalid filter layer! We should warn about it!
         warnFile << "No filter in filter layer";
         return 0;
     }
 
     KisFilterSP f = KisFilterRegistry::instance()->value(filtername);
     if (!f) {
         warnFile << "No filter for filtername" << filtername << "";
         return 0; // XXX: We don't have this filter. We should warn about it!
     }
 
     KisFilterConfigurationSP  kfc = f->defaultConfiguration();
 
     // We'll load the configuration and the selection later.
     mask = new KisFilterMask();
     mask->setFilter(kfc);
     Q_CHECK_PTR(mask);
 
     return mask;
 }
 
 KisNodeSP KisKraLoader::loadTransformMask(const KoXmlElement& element)
 {
     Q_UNUSED(element);
 
     KisTransformMask* mask;
 
     /**
      * We'll load the transform configuration later on a stage
      * of binary data loading
      */
     mask = new KisTransformMask();
     Q_CHECK_PTR(mask);
 
     return mask;
 }
 
 KisNodeSP KisKraLoader::loadTransparencyMask(const KoXmlElement& element)
 {
     Q_UNUSED(element);
     KisTransparencyMask* mask = new KisTransparencyMask();
     Q_CHECK_PTR(mask);
 
     return mask;
 }
 
 KisNodeSP KisKraLoader::loadSelectionMask(KisImageSP image, const KoXmlElement& element)
 {
     KisSelectionMaskSP mask = new KisSelectionMask(image);
     bool active = element.attribute(ACTIVE, "1") == "0" ? false : true;
     mask->setActive(active);
     Q_CHECK_PTR(mask);
 
     return mask;
 }
 
 KisNodeSP KisKraLoader::loadColorizeMask(KisImageSP image, const KoXmlElement& element, const KoColorSpace *colorSpace)
 {
     KisColorizeMaskSP mask = new KisColorizeMask();
     const bool editKeystrokes = element.attribute(COLORIZE_EDIT_KEYSTROKES, "1") == "0" ? false : true;
     const bool showColoring = element.attribute(COLORIZE_SHOW_COLORING, "1") == "0" ? false : true;
 
     KisLayerPropertiesIcons::setNodeProperty(mask, KisLayerPropertiesIcons::colorizeEditKeyStrokes, editKeystrokes, image);
     KisLayerPropertiesIcons::setNodeProperty(mask, KisLayerPropertiesIcons::colorizeShowColoring, showColoring, image);
 
     const bool useEdgeDetection = KisDomUtils::toInt(element.attribute(COLORIZE_USE_EDGE_DETECTION, "0"));
     const qreal edgeDetectionSize = KisDomUtils::toDouble(element.attribute(COLORIZE_EDGE_DETECTION_SIZE, "4"));
     const qreal radius = KisDomUtils::toDouble(element.attribute(COLORIZE_FUZZY_RADIUS, "0"));
     const int cleanUp = KisDomUtils::toInt(element.attribute(COLORIZE_CLEANUP, "0"));
     const bool limitToDevice = KisDomUtils::toInt(element.attribute(COLORIZE_LIMIT_TO_DEVICE, "0"));
 
     mask->setUseEdgeDetection(useEdgeDetection);
     mask->setEdgeDetectionSize(edgeDetectionSize);
     mask->setFuzzyRadius(radius);
     mask->setCleanUpAmount(qreal(cleanUp) / 100.0);
     mask->setLimitToDeviceBounds(limitToDevice);
 
     delete mask->setColorSpace(colorSpace);
     mask->setImage(image);
 
     return mask;
 }
 
 void KisKraLoader::loadCompositions(const KoXmlElement& elem, KisImageSP image)
 {
     KoXmlNode child;
 
     for (child = elem.firstChild(); !child.isNull(); child = child.nextSibling()) {
 
         KoXmlElement e = child.toElement();
         QString name = e.attribute("name");
         bool exportEnabled = e.attribute("exportEnabled", "1") == "0" ? false : true;
 
         KisLayerCompositionSP composition(new KisLayerComposition(image, name));
         composition->setExportEnabled(exportEnabled);
 
         KoXmlNode value;
         for (value = child.lastChild(); !value.isNull(); value = value.previousSibling()) {
             KoXmlElement e = value.toElement();
             QUuid uuid(e.attribute("uuid"));
             bool visible = e.attribute("visible", "1") == "0" ? false : true;
             composition->setVisible(uuid, visible);
             bool collapsed = e.attribute("collapsed", "1") == "0" ? false : true;
             composition->setCollapsed(uuid, collapsed);
         }
 
         image->addComposition(composition);
     }
 }
 
 void KisKraLoader::loadAssistantsList(const KoXmlElement &elem)
 {
     KoXmlNode child;
     int count = 0;
     for (child = elem.firstChild(); !child.isNull(); child = child.nextSibling()) {
         KoXmlElement e = child.toElement();
         QString type = e.attribute("type");
         QString file_name = e.attribute("filename");
         m_d->assistantsFilenames.insert(file_name,type);
         count++;
 
     }
 }
 
 void KisKraLoader::loadGrid(const KoXmlElement& elem)
 {
     QDomDocument dom;
     KoXml::asQDomElement(dom, elem);
     QDomElement domElement = dom.firstChildElement();
 
     KisGridConfig config;
     config.loadDynamicDataFromXml(domElement);
     config.loadStaticData();
     m_d->document->setGridConfig(config);
 }
 
 void KisKraLoader::loadGuides(const KoXmlElement& elem)
 {
     QDomDocument dom;
     KoXml::asQDomElement(dom, elem);
     QDomElement domElement = dom.firstChildElement();
 
     KisGuidesConfig guides;
     guides.loadFromXml(domElement);
     m_d->document->setGuidesConfig(guides);
 }
 
 void KisKraLoader::loadAudio(const KoXmlElement& elem, KisImageSP image)
 {
     QDomDocument dom;
     KoXml::asQDomElement(dom, elem);
     QDomElement qElement = dom.firstChildElement();
 
     QString fileName;
     if (KisDomUtils::loadValue(qElement, "masterChannelPath", &fileName)) {
         fileName = QDir::toNativeSeparators(fileName);
 
         QDir baseDirectory = QFileInfo(m_d->document->localFilePath()).absoluteDir();
         fileName = baseDirectory.absoluteFilePath(fileName);
 
         QFileInfo info(fileName);
 
         if (!info.exists()) {
             qApp->setOverrideCursor(Qt::ArrowCursor);
             QString msg = i18nc(
                 "@info",
                 "Audio channel file \"%1\" doesn't exist!\n\n"
                 "Expected path:\n"
                 "%2\n\n"
                 "Do you want to locate it manually?", info.fileName(), info.absoluteFilePath());
 
             int result = QMessageBox::warning(0, i18nc("@title:window", "File not found"), msg, QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
 
             if (result == QMessageBox::Yes) {
                 info.setFile(KisImportExportManager::askForAudioFileName(info.absolutePath(), 0));
             }
 
             qApp->restoreOverrideCursor();
         }
 
         if (info.exists()) {
             image->animationInterface()->setAudioChannelFileName(info.absoluteFilePath());
         }
     }
 
     bool audioMuted = false;
     if (KisDomUtils::loadValue(qElement, "audioMuted", &audioMuted)) {
         image->animationInterface()->setAudioMuted(audioMuted);
     }
 
     qreal audioVolume = 0.5;
     if (KisDomUtils::loadValue(qElement, "audioVolume", &audioVolume)) {
         image->animationInterface()->setAudioVolume(audioVolume);
     }
 }
 
 KisNodeSP KisKraLoader::loadReferenceImagesLayer(const KoXmlElement &elem, KisImageSP image)
 {
     KisSharedPtr<KisReferenceImagesLayer> layer =
         new KisReferenceImagesLayer(m_d->document->shapeController(), image);
 
-    m_d->document->setReferenceImagesLayer(layer);
+    m_d->document->setReferenceImagesLayer(layer, false);
 
     for (QDomElement child = elem.firstChildElement(); !child.isNull(); child = child.nextSiblingElement()) {
         if (child.nodeName().toLower() == "referenceimage") {
             auto* reference = KisReferenceImage::fromXml(child);
             layer->addShape(reference);
         }
     }
 
     return layer;
 }
diff --git a/plugins/paintops/spray/kis_spray_shape_option.cpp b/plugins/paintops/spray/kis_spray_shape_option.cpp
index 71c421bf1c..9dbb4458d7 100644
--- a/plugins/paintops/spray/kis_spray_shape_option.cpp
+++ b/plugins/paintops/spray/kis_spray_shape_option.cpp
@@ -1,144 +1,144 @@
 /*
  *  Copyright (c) 2008,2009,2010 Lukáš Tvrdý <lukast.dev@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "kis_spray_shape_option.h"
 #include <klocalizedstring.h>
 
 #include <QImage>
 #include <QFile>
 #include <KisImportExportManager.h>
 #include <kis_file_name_requester.h>
 #include "kis_aspect_ratio_locker.h"
 #include "kis_signals_blocker.h"
 
 #include "ui_wdgsprayshapeoptions.h"
 
 class KisShapeOptionsWidget: public QWidget, public Ui::WdgSprayShapeOptions
 {
 public:
     KisShapeOptionsWidget(QWidget *parent = 0)
         : QWidget(parent) {
         setupUi(this);
-        imageUrl->setMimeTypeFilters(KisImportExportManager::mimeFilter(KisImportExportManager::Import));
+        imageUrl->setMimeTypeFilters(KisImportExportManager::supportedMimeTypes(KisImportExportManager::Import));
     }
 
 };
 
 KisSprayShapeOption::KisSprayShapeOption()
     : KisPaintOpOption(KisPaintOpOption::GENERAL, true),
       m_sizeRatioLocker(new KisAspectRatioLocker(this))
 {
 
     setObjectName("KisSprayShapeOption");
 
     m_checkable = true;
     // save this to be able to restore it back
     m_maxSize = 1000;
 
     m_options = new KisShapeOptionsWidget();
 
     //initializer slider values
     m_options->widthSpin->setRange(1, 1000, 0);
     m_options->widthSpin->setValue(6);
     m_options->widthSpin->setSuffix(i18n(" px"));
 
     m_options->heightSpin->setRange(1, 1000, 0);
     m_options->heightSpin->setValue(6);
     m_options->heightSpin->setSuffix(i18n(" px"));
 
     // UI signals
     connect(m_options->proportionalBox, SIGNAL(clicked(bool)), SLOT(changeSizeUI(bool)));
     connect(m_options->imageUrl, SIGNAL(textChanged(QString)), this, SLOT(prepareImage()));
 
     m_sizeRatioLocker->connectSpinBoxes(m_options->widthSpin, m_options->heightSpin, m_options->aspectButton);
     m_sizeRatioLocker->setBlockUpdateSignalOnDrag(true);
     connect(m_sizeRatioLocker, SIGNAL(sliderValueChanged()), SLOT(emitSettingChanged()));
     connect(m_sizeRatioLocker, SIGNAL(aspectButtonChanged()), SLOT(emitSettingChanged()));
 
     connect(m_options->proportionalBox, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
     connect(m_options->proportionalBox, SIGNAL(clicked(bool)), SLOT(emitSettingChanged()));
     connect(m_options->shapeBox, SIGNAL(currentIndexChanged(int)), SLOT(emitSettingChanged()));
     connect(m_options->imageUrl, SIGNAL(textChanged(QString)), SLOT(emitSettingChanged()));
 
     setConfigurationPage(m_options);
 }
 
 KisSprayShapeOption::~KisSprayShapeOption()
 {
     delete m_options;
 }
 
 int KisSprayShapeOption::shape() const
 {
     return m_options->shapeBox->currentIndex();
 }
 
 
 void KisSprayShapeOption::writeOptionSetting(KisPropertiesConfigurationSP setting) const
 {
     setting->setProperty(SPRAYSHAPE_ENABLED, isChecked());
     setting->setProperty(SPRAYSHAPE_SHAPE, shape());
     setting->setProperty(SPRAYSHAPE_USE_ASPECT, m_options->aspectButton->keepAspectRatio());
     setting->setProperty(SPRAYSHAPE_PROPORTIONAL, m_options->proportionalBox->isChecked());
     setting->setProperty(SPRAYSHAPE_WIDTH, m_options->widthSpin->value());
     setting->setProperty(SPRAYSHAPE_HEIGHT, m_options->heightSpin->value());
     setting->setProperty(SPRAYSHAPE_IMAGE_URL, m_options->imageUrl->fileName());
 }
 
 
 void KisSprayShapeOption::readOptionSetting(const KisPropertiesConfigurationSP setting)
 {
     // in 2.2 there is not shape enabled so true by default
     setChecked(setting->getBool(SPRAYSHAPE_ENABLED, true));
     m_options->shapeBox->setCurrentIndex(setting->getInt(SPRAYSHAPE_SHAPE));
     m_options->proportionalBox->setChecked(setting->getBool(SPRAYSHAPE_PROPORTIONAL));
     m_options->aspectButton->setKeepAspectRatio(setting->getBool(SPRAYSHAPE_USE_ASPECT, false));
     m_options->widthSpin->setValue(setting->getInt(SPRAYSHAPE_WIDTH));
     m_options->heightSpin->setValue(setting->getInt(SPRAYSHAPE_HEIGHT));
     m_options->imageUrl->setFileName(setting->getString(SPRAYSHAPE_IMAGE_URL));
 }
 
 
 void KisSprayShapeOption::prepareImage()
 {
     QString path = m_options->imageUrl->fileName();
     if (QFile::exists(path)) {
         QImage image(path);
         if (!image.isNull()) {
             KisSignalsBlocker b(m_options->widthSpin, m_options->heightSpin);
             m_options->widthSpin->setValue(image.width());
             m_options->heightSpin->setValue(image.height());
         }
     }
 }
 
 void KisSprayShapeOption::changeSizeUI(bool proportionalSize)
 {
     // if proportionalSize is false, pixel size is used
     if (!proportionalSize) {
         m_options->widthSpin->setMaximum(m_maxSize);
         m_options->widthSpin->setSuffix(i18n(" px"));
         m_options->heightSpin->setMaximum(m_maxSize);
         m_options->heightSpin->setSuffix(i18n(" px"));
     }
     else {
         m_options->widthSpin->setMaximum(100);
         m_options->widthSpin->setSuffix("%");
         m_options->heightSpin->setMaximum(100);
         m_options->heightSpin->setSuffix("%");
     }
 }
diff --git a/plugins/python/assignprofiledialog/kritapykrita_assignprofiledialog.desktop b/plugins/python/assignprofiledialog/kritapykrita_assignprofiledialog.desktop
index 4f3ef47654..c75af67766 100644
--- a/plugins/python/assignprofiledialog/kritapykrita_assignprofiledialog.desktop
+++ b/plugins/python/assignprofiledialog/kritapykrita_assignprofiledialog.desktop
@@ -1,47 +1,47 @@
 [Desktop Entry]
 Type=Service
 ServiceTypes=Krita/PythonPlugin
 X-KDE-Library=assignprofiledialog
 X-Python-2-Compatible=true
 X-Krita-Manual=Manual.html
 Name=Assign Profile to Image
 Name[ar]=إسناد اللاحات إلى الصّور
 Name[ca]=Assigna un perfil a una imatge
 Name[ca@valencia]=Assigna un perfil a una imatge
 Name[cs]=Přiřadit obrázku profil
 Name[el]=Αντιστοίχιση προφίλ σε εικόνα
 Name[en_GB]=Assign Profile to Image
 Name[es]=Asignar perfil a imagen
 Name[gl]=Asignar un perfil á imaxe
 Name[is]=Úthluta litasniði á myndina
 Name[it]=Assegna profilo a immagine
-Name[nl]=Profiel aan afbeelding toekennen
+Name[nl]=Profiel aan afbeelding toewijzen
 Name[pl]=Przypisz profil do obrazu
 Name[pt]=Atribuir um Perfil à Imagem
 Name[pt_BR]=Atribuir perfil a imagem
 Name[sv]=Tilldela profil till bild
 Name[tr]=Görüntüye Profil Ata
 Name[uk]=Призначити профіль до зображення
 Name[x-test]=xxAssign Profile to Imagexx
 Name[zh_CN]=为图像指定色彩配置文件
 Name[zh_TW]=指定設定檔到圖像
 Comment=Assign a profile to an image without converting it.
 Comment[ar]=أسنِد لاحة إلى صورة دون تحويلها.
 Comment[ca]=Assigna un perfil a una imatge sense convertir-la.
 Comment[ca@valencia]=Assigna un perfil a una imatge sense convertir-la.
 Comment[el]=Αντιστοιχίζει ένα προφίλ σε μια εικόνα χωρίς μετατροπή.
 Comment[en_GB]=Assign a profile to an image without converting it.
 Comment[es]=Asignar un perfil a una imagen sin convertirla.
 Comment[gl]=Asignar un perfil a unha imaxe sen convertela.
 Comment[is]=Úthluta litasniði á myndina án þess að umbreyta henni.
 Comment[it]=Assegna un profilo a un'immagine senza convertirla.
-Comment[nl]=Een profiel aan een afbeelding toekennen zonder het te converteren.
+Comment[nl]=Een profiel aan een afbeelding toewijzen zonder het te converteren.
 Comment[pl]=Przypisz profil do obrazu bez jego przekształcania.
 Comment[pt]=Atribui um perfil à imagem sem a converter.
 Comment[pt_BR]=Atribui um perfil para uma imagem sem convertê-la.
 Comment[sv]=Tilldela en profil till en bild utan att konvertera den.
 Comment[tr]=Bir görüntüye, görüntüyü değiştirmeden bir profil ata.
 Comment[uk]=Призначити профіль до зображення без його перетворення.
 Comment[x-test]=xxAssign a profile to an image without converting it.xx
 Comment[zh_CN]=仅为图像指定色彩配置文件，不转换其色彩空间
 Comment[zh_TW]=將設定檔指定給圖像，而不進行轉換。
diff --git a/plugins/python/documenttools/tools/canvassizetool/canvassizetool.py b/plugins/python/documenttools/tools/canvassizetool/canvassizetool.py
index b459cc3637..5d26f7575c 100644
--- a/plugins/python/documenttools/tools/canvassizetool/canvassizetool.py
+++ b/plugins/python/documenttools/tools/canvassizetool/canvassizetool.py
@@ -1,52 +1,53 @@
 '''
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 '''
 from PyQt5.QtWidgets import (QWidget, QSpinBox, QHBoxLayout,
                              QVBoxLayout, QFormLayout)
+import krita
 
 
 class CanvasSizeTool(QWidget):
 
     def __init__(self, mainDialog, parent=None):
         super(CanvasSizeTool, self).__init__(parent)
 
         self.setObjectName("Canvas Size")
 
         self.layout = QFormLayout()
         self.offsetLayout = QVBoxLayout()
 
         self.widthSpinBox = QSpinBox()
         self.heightSpinBox = QSpinBox()
         self.xOffsetSpinBox = QSpinBox()
         self.yOffsetSpinBox = QSpinBox()
 
         self.setLayout(self.layout)
         self.initialize()
 
     def initialize(self):
         self.widthSpinBox.setRange(1, 10000)
         self.heightSpinBox.setRange(1, 10000)
         self.xOffsetSpinBox.setRange(-10000, 10000)
         self.yOffsetSpinBox.setRange(-10000, 10000)
 
         self.offsetLayout.addWidget(self.xOffsetSpinBox)
         self.offsetLayout.addWidget(self.yOffsetSpinBox)
 
-        self.layout.addRow('Width', self.widthSpinBox)
-        self.layout.addRow('Height', self.heightSpinBox)
-        self.layout.addRow('Offset', self.offsetLayout)
+        self.layout.addRow(i18n("Width:"), self.widthSpinBox)
+        self.layout.addRow(i18n("Height:"), self.heightSpinBox)
+        self.layout.addRow(i18n("Offset:"), self.offsetLayout)
 
     def adjust(self, documents):
         for document in documents:
             document.resizeImage(self.xOffsetSpinBox.value(),
                                  self.yOffsetSpinBox.value(),
                                  self.widthSpinBox.value(),
                                  self.heightSpinBox.value())
diff --git a/plugins/python/documenttools/tools/rotatetool/rotatetool.py b/plugins/python/documenttools/tools/rotatetool/rotatetool.py
index 19d55da8e5..ae3f1e20e0 100644
--- a/plugins/python/documenttools/tools/rotatetool/rotatetool.py
+++ b/plugins/python/documenttools/tools/rotatetool/rotatetool.py
@@ -1,39 +1,40 @@
 '''
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 '''
 from PyQt5.QtWidgets import (QWidget, QSpinBox, QHBoxLayout,
                              QVBoxLayout, QFormLayout)
 import math
+import krita
 
 
 class RotateTool(QWidget):
 
     def __init__(self, mainDialog, parent=None):
         super(RotateTool, self).__init__(parent)
 
         self.setObjectName("Rotate")
 
         self.layout = QFormLayout()
 
         self.degreesSpinBox = QSpinBox()
 
         self.setLayout(self.layout)
         self.initialize()
 
     def initialize(self):
         self.degreesSpinBox.setRange(-180, 180)
-        self.degreesSpinBox.setToolTip("Negative degrees will rotate the image to the left")
+        self.degreesSpinBox.setToolTip(i18n("Negative degrees will rotate the image to the left"))
 
-        self.layout.addRow('Degrees', self.degreesSpinBox)
+        self.layout.addRow(i18n("Degrees:"), self.degreesSpinBox)
 
     def adjust(self, documents):
         for document in documents:
             document.rotateImage(math.radians(self.degreesSpinBox.value()))
diff --git a/plugins/python/documenttools/tools/scaletool/scaletool.py b/plugins/python/documenttools/tools/scaletool/scaletool.py
index d015354bc3..f71e59fe85 100644
--- a/plugins/python/documenttools/tools/scaletool/scaletool.py
+++ b/plugins/python/documenttools/tools/scaletool/scaletool.py
@@ -1,60 +1,61 @@
 '''
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 '''
 from PyQt5.QtWidgets import (QWidget, QSpinBox, QHBoxLayout,
                              QVBoxLayout, QFormLayout, QComboBox)
+import krita
 
 
 class ScaleTool(QWidget):
 
     def __init__(self, mainDialog, parent=None):
         super(ScaleTool, self).__init__(parent)
 
         self.setObjectName("Scale")
 
         self.layout = QFormLayout()
         self.resolutionLayout = QVBoxLayout()
         self.widthSpinBox = QSpinBox()
         self.heightSpinBox = QSpinBox()
         self.xResSpinBox = QSpinBox()
         self.yResSpinBox = QSpinBox()
         self.strategyComboBox = QComboBox()
 
         self.strategyComboBox.setSizeAdjustPolicy(QComboBox.AdjustToContents)
         self.setLayout(self.layout)
         self.initialize()
 
     def initialize(self):
         self.widthSpinBox.setRange(1, 10000)
         self.heightSpinBox.setRange(1, 10000)
         self.xResSpinBox.setRange(1, 10000)
         self.yResSpinBox.setRange(1, 10000)
 
         strategies = ['Hermite', 'Bicubic', 'Box',
                       'Bilinear', 'Bell', 'BSpline',
                       'Kanczos3', 'Mitchell']
         self.strategyComboBox.addItems(strategies)
 
         self.resolutionLayout.addWidget(self.xResSpinBox)
         self.resolutionLayout.addWidget(self.yResSpinBox)
 
-        self.layout.addRow('Width', self.widthSpinBox)
-        self.layout.addRow('Height', self.heightSpinBox)
-        self.layout.addRow('Resolution', self.resolutionLayout)
-        self.layout.addRow('Filter', self.strategyComboBox)
+        self.layout.addRow(i18n("Width:"), self.widthSpinBox)
+        self.layout.addRow(i18n("Height:"), self.heightSpinBox)
+        self.layout.addRow(i18n("Resolution:"), self.resolutionLayout)
+        self.layout.addRow(i18n("Filter:"), self.strategyComboBox)
 
     def adjust(self, documents):
         for document in documents:
             document.scaleImage(self.widthSpinBox.value(),
                                 self.heightSpinBox.value(),
                                 self.xResSpinBox.value(),
                                 self.yResSpinBox.value(),
                                 self.strategyComboBox.currentText())
diff --git a/plugins/python/hello/hello.py b/plugins/python/hello/hello.py
index 677d85af87..cf2c6b3c8a 100644
--- a/plugins/python/hello/hello.py
+++ b/plugins/python/hello/hello.py
@@ -1,88 +1,88 @@
 '''
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 '''
 #
 # This is a simple example of a Python script for Krita.
 # It demonstrates how to set up a custom extension and a custom docker!
 #
 
 from PyQt5.QtWidgets import QWidget, QLabel, QMessageBox
 from krita import (Krita, Extension, DockWidget,
                    DockWidgetFactory, DockWidgetFactoryBase)
 
 
 def hello():
     """
     Show a test message box.
     """
     QMessageBox.information(QWidget(), i18n("Test"), i18n("Hello! This is Krita version %s") % Application.version())
 
 
 class HelloExtension(Extension):
     """
     HelloExtension is a small example extension demonstrating basic Python scripting support in Krita!
     """
 
     def __init__(self, parent):
         """
         Standard Krita Python extension constructor.
         Most of the initialization happens in :func:`setup`
 
         :param parent: Parent widget
         :type parent: :class:`QWidget` or None
         """
         super(HelloExtension, self).__init__(parent)
 
     def setup(self):
         pass
 
     def createActions(self, window):
         """
         This is where most of the setup takes place!
         """
-        action = window.createAction("hello_python", "hello")
+        action = window.createAction("hello_python", i18n("Hello"))
         action.triggered.connect(hello)
 
 
 # Initialize and add the extension
 Scripter.addExtension(HelloExtension(Krita.instance()))
 
 
 class HelloDocker(DockWidget):
     """
     The HelloDocker is an example of a simple Python-based docker.
     """
 
     def __init__(self):
         """
         Constructs an instance of HelloDocker and the widget it contains
         """
         super(HelloDocker, self).__init__()
 
         # The window title is also used in the Docker menu,
         # so it should be set to something sensible!
         self.setWindowTitle("HelloDocker")
         label = QLabel("Hello", self)
         self.setWidget(label)
         self._label = label
 
     def canvasChanged(self, canvas):
         """
         Override canvasChanged from :class:`DockWidget`.
         This gets called when the canvas changes.
         You can also access the active canvas via :func:`DockWidget.canvas`
         Parameter `canvas` can be null if the last document is closed
         """
         self._label.setText("HelloDocker: canvas changed")
 
 
 # Register the docker so Krita can use it!
 Application.addDockWidgetFactory(DockWidgetFactory("hello", DockWidgetFactoryBase.DockRight, HelloDocker))
diff --git a/plugins/python/highpass/kritapykrita_highpass.desktop b/plugins/python/highpass/kritapykrita_highpass.desktop
index c8a92caec8..5aadd0f5d3 100644
--- a/plugins/python/highpass/kritapykrita_highpass.desktop
+++ b/plugins/python/highpass/kritapykrita_highpass.desktop
@@ -1,45 +1,45 @@
 [Desktop Entry]
 Type=Service
 ServiceTypes=Krita/PythonPlugin
 X-KDE-Library=highpass
 X-Python-2-Compatible=false
 Name=Highpass Filter
-Name[ca]=Filtre passa-alt
-Name[ca@valencia]=Filtre passa-alt
+Name[ca]=Filtre passaalt
+Name[ca@valencia]=Filtre passaalt
 Name[cs]=Filtr s horní propustí
 Name[de]=Hochpassfilter
 Name[el]=Υψιπερατό φίλτρο
 Name[en_GB]=Highpass Filter
 Name[es]=Filtro paso alto
 Name[gl]=Filtro de paso alto
 Name[it]=Filtro di accentuazione passaggio
 Name[nl]=Hoogdoorlaatfilter
 Name[pl]=Filtr górnoprzepustowy
 Name[pt]=Filtro Passa-Alto
 Name[pt_BR]=Filtro passa alta
 Name[sv]=Högpassfilter
 Name[tr]=Yüksek Geçirgen Süzgeç
 Name[uk]=Високочастотний фільтр
 Name[x-test]=xxHighpass Filterxx
 Name[zh_CN]=高通滤镜
 Name[zh_TW]=高通濾鏡
 Comment=Highpass Filter, based on http://registry.gimp.org/node/7385
-Comment[ca]=Filtre passa-alt, basat en el http://registry.gimp.org/node/7385
-Comment[ca@valencia]=Filtre passa-alt, basat en el http://registry.gimp.org/node/7385
+Comment[ca]=Filtre passaalt, basat en el http://registry.gimp.org/node/7385
+Comment[ca@valencia]=Filtre passaalt, basat en el http://registry.gimp.org/node/7385
 Comment[cs]=Filtr s horní propustí založený na http://registry.gimp.org/node/7385
 Comment[de]=Hochpassfilter, Grundlage ist http://registry.gimp.org/node/7385
 Comment[el]=Υψιπερατό φίλτρο, με βάση το http://registry.gimp.org/node/7385
 Comment[en_GB]=Highpass Filter, based on http://registry.gimp.org/node/7385
 Comment[es]=Filtro paso alto, basado en http://registry.gimp.org/node/7385
 Comment[gl]=Filtro de paso alto, baseado en http://registry.gimp.org/node/7385.
 Comment[it]=Filtro di accentuazione passaggio, basato su http://registry.gimp.org/node/7385
 Comment[nl]=Hoogdoorlaatfilter, gebaseerd op http://registry.gimp.org/node/7385
 Comment[pl]=Filtr górnoprzepustowy, oparty na http://registry.gimp.org/node/7385
 Comment[pt]=Filtro passa-alto, baseado em http://registry.gimp.org/node/7385
 Comment[pt_BR]=Filtro passa alta, baseado em http://registry.gimp.org/node/7385
 Comment[sv]=Högpassfilter, baserat på http://registry.gimp.org/node/7385
 Comment[tr]=http://registry.gimp.org/node/7385 tabanlı Yüksek Geçirgen Süzgeç
 Comment[uk]=Високочастотний фільтр, засновано на on http://registry.gimp.org/node/7385
 Comment[x-test]=xxHighpass Filter, based on http://registry.gimp.org/node/7385xx
 Comment[zh_CN]=高通滤镜，基于 http://registry.gimp.org/node/7385
 Comment[zh_TW]=高通濾鏡，基於 http://registry.gimp.org/node/7385
diff --git a/plugins/python/lastdocumentsdocker/lastdocumentsdocker.py b/plugins/python/lastdocumentsdocker/lastdocumentsdocker.py
index 449a4ba278..cec8fd6a9d 100644
--- a/plugins/python/lastdocumentsdocker/lastdocumentsdocker.py
+++ b/plugins/python/lastdocumentsdocker/lastdocumentsdocker.py
@@ -1,47 +1,47 @@
 '''
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 '''
 from PyQt5.QtWidgets import QWidget, QVBoxLayout, QListView, QPushButton
 import krita
 from . import lastdocumentslistmodel
 
 
 class LastDocumentsDocker(krita.DockWidget):
 
     def __init__(self):
         super(LastDocumentsDocker, self).__init__()
 
         self.baseWidget = QWidget()
         self.layout = QVBoxLayout()
         self.listView = QListView()
-        self.loadButton = QPushButton("Refresh")
+        self.loadButton = QPushButton(i18n("Refresh"))
         self.listModel = lastdocumentslistmodel.LastDocumentsListModel()
 
         self.listView.setModel(self.listModel)
         self.listView.setFlow(QListView.LeftToRight)
 
         self.layout.addWidget(self.listView)
         self.layout.addWidget(self.loadButton)
 
         self.baseWidget.setLayout(self.layout)
         self.setWidget(self.baseWidget)
 
         self.loadButton.clicked.connect(self.refreshRecentDocuments)
-        self.setWindowTitle("Last Documents Docker")
+        self.setWindowTitle(i18n("Last Documents Docker"))
 
     def canvasChanged(self, canvas):
         pass
 
     def refreshRecentDocuments(self):
         self.listModel.loadRecentDocuments()
 
 
 Application.addDockWidgetFactory(krita.DockWidgetFactory("lastdocumentsdocker", krita.DockWidgetFactoryBase.DockRight, LastDocumentsDocker))
diff --git a/plugins/python/palette_docker/palette_docker.py b/plugins/python/palette_docker/palette_docker.py
index c15949afd0..5344b302ef 100644
--- a/plugins/python/palette_docker/palette_docker.py
+++ b/plugins/python/palette_docker/palette_docker.py
@@ -1,262 +1,262 @@
 '''
 Description: A Python based docker that allows you to edit KPL color palettes.
 
 By Wolthera(originally)
 
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 
 @package palette_docker
 '''
 
 # Importing the relevant dependencies:
 import sys
 from PyQt5.QtGui import QPixmap, QIcon, QImage, QPainter, QBrush, QPalette
 from PyQt5.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout, QComboBox, QAction, QTabWidget, QLineEdit, QSpinBox, QDialogButtonBox, QToolButton, QDialog, QPlainTextEdit, QCompleter, QMenu
 from PyQt5.Qt import Qt, pyqtSignal, pyqtSlot
 import math
 from krita import *
 
 # import the exporters
 from . import palette_exporter_gimppalette, palette_exporter_inkscapeSVG, palette_sortColors
 
 
 class Palette_Docker(DockWidget):
     # Init the docker
 
     def __init__(self):
         super(Palette_Docker, self).__init__()
         # make base-widget and layout
         widget = QWidget()
         layout = QVBoxLayout()
         buttonLayout = QHBoxLayout()
         widget.setLayout(layout)
-        self.setWindowTitle("Python Palette Docker")
+        self.setWindowTitle(i18n("Python Palette Docker"))
 
         # Make a combobox and add palettes
         self.cmb_palettes = QComboBox()
         allPalettes = Application.resources("palette")
         for palette_name in allPalettes:
             self.cmb_palettes.addItem(palette_name)
             self.cmb_palettes.model().sort(0)
 
         if len(allPalettes.keys()) > 0:
             self.currentPalette = Palette(allPalettes[list(allPalettes.keys())[0]])
         else:
             self.currentPalette = None
 
         self.cmb_palettes.currentTextChanged.connect(self.slot_paletteChanged)
         layout.addWidget(self.cmb_palettes)  # add combobox to the layout
         self.paletteView = PaletteView()
         self.paletteView.setPalette(self.currentPalette)
         layout.addWidget(self.paletteView)
         self.paletteView.entrySelectedForeGround.connect(self.slot_swatchSelected)
 
         self.colorComboBox = QComboBox()
         self.colorList = list()
         buttonLayout.addWidget(self.colorComboBox)
         self.bnSetColor = QToolButton()
-        self.bnSetColor.setText("Set")
+        self.bnSetColor.setText(i18n("Set"))
         self.bnSetColor.clicked.connect(self.slot_get_color_from_combobox)
         buttonLayout.addWidget(self.bnSetColor)
         
         self.addEntry = QAction(self)
-        self.addEntry.setIconText("+")
+        self.addEntry.setIconText(i18n("+"))
         self.addEntry.triggered.connect(self.slot_add_entry)
         self.addGroup = QAction(self)
         self.addGroup.triggered.connect(self.slot_add_group)
-        self.addGroup.setText("Add Group")
+        self.addGroup.setText(i18n("Add Group"))
         self.addGroup.setIconText(str("\U0001F4C2"))
         self.removeEntry = QAction(self)
-        self.removeEntry.setText("Remove Entry")
+        self.removeEntry.setText(i18n("Remove Entry"))
         self.removeEntry.setIconText("-")
         self.removeEntry.triggered.connect(self.slot_remove_entry)
         addEntryButton = QToolButton()
         addEntryButton.setDefaultAction(self.addEntry)
         buttonLayout.addWidget(addEntryButton)
         addGroupButton = QToolButton()
         addGroupButton.setDefaultAction(self.addGroup)
         buttonLayout.addWidget(addGroupButton)
         removeEntryButton = QToolButton()
         removeEntryButton.setDefaultAction(self.removeEntry)
         buttonLayout.addWidget(removeEntryButton)
 
         # QActions
         self.extra = QToolButton()
         self.editPaletteData = QAction(self)
-        self.editPaletteData.setText("Edit Palette Settings")
+        self.editPaletteData.setText(i18n("Edit Palette Settings"))
         self.editPaletteData.triggered.connect(self.slot_edit_palette_data)
         self.extra.setDefaultAction(self.editPaletteData)
         buttonLayout.addWidget(self.extra)
         self.actionMenu = QMenu()
         self.exportToGimp = QAction(self)
-        self.exportToGimp.setText("Export as GIMP palette file.")
+        self.exportToGimp.setText(i18n("Export as GIMP Palette File"))
         self.exportToGimp.triggered.connect(self.slot_export_to_gimp_palette)
         self.exportToInkscape = QAction(self)
-        self.exportToInkscape.setText("Export as Inkscape SVG with swatches.")
+        self.exportToInkscape.setText(i18n("Export as Inkscape SVG with Swatches"))
         self.exportToInkscape.triggered.connect(self.slot_export_to_inkscape_svg)
         self.sortColors = QAction(self)
-        self.sortColors.setText("Sort colors")
+        self.sortColors.setText(i18n("Sort Colors"))
         self.sortColors.triggered.connect(self.slot_sort_colors)
         self.actionMenu.addAction(self.editPaletteData)
         self.actionMenu.addAction(self.exportToGimp)
         self.actionMenu.addAction(self.exportToInkscape)
         # self.actionMenu.addAction(self.sortColors)
 
         self.extra.setMenu(self.actionMenu)
 
         layout.addLayout(buttonLayout)
         self.slot_fill_combobox()
         self.setWidget(widget)        # add widget to the docker
 
     def slot_paletteChanged(self, name):
         allPalettes = Application.resources("palette")
         if len(allPalettes) > 0 and name in allPalettes:
             self.currentPalette = Palette(Application.resources("palette")[name])
             self.paletteView.setPalette(self.currentPalette)
             self.slot_fill_combobox()
 
     @pyqtSlot('PaletteEntry')
     def slot_swatchSelected(self, entry):
         if (self.canvas()) is not None:
             if (self.canvas().view()) is not None:
                 name = entry.name()
                 if len(entry.id) > 0:
                     name = entry.id() + " - " + entry.name()
                 if len(name) > 0:
                     if name in self.colorList:
                         self.colorComboBox.setCurrentIndex(self.colorList.index(name))
                 color = self.currentPalette.colorForEntry(entry)
                 self.canvas().view().setForeGroundColor(color)
     '''
     A function for making a combobox with the available colors. We use QCompleter on the colorComboBox so that people
     can type in the name of a color to select it. This is useful for people with carefully made palettes where the colors
     are named properly, which makes it easier for them to find colors.
     '''
 
     def slot_fill_combobox(self):
         if self.currentPalette is None:
             pass
         palette = self.currentPalette
         self.colorComboBox.clear()
         self.colorList = list()
         for i in range(palette.colorsCountTotal()):
             entry = palette.colorSetEntryByIndex(i)
             color = palette.colorForEntry(entry).colorForCanvas(self.canvas())
             colorSquare = QPixmap(12, 12)
             if entry.spotColor() is True:
                 img = colorSquare.toImage()
                 circlePainter = QPainter()
                 img.fill(self.colorComboBox.palette().color(QPalette.Base))
                 circlePainter.begin(img)
                 brush = QBrush(Qt.SolidPattern)
                 brush.setColor(color)
                 circlePainter.setBrush(brush)
                 circlePainter.pen().setWidth(0)
                 circlePainter.drawEllipse(0, 0, 11, 11)
                 circlePainter.end()
                 colorSquare = QPixmap.fromImage(img)
             else:
                 colorSquare.fill(color)
             name = entry.name()
             if len(entry.id()) > 0:
                 name = entry.id() + " - " + entry.name()
             self.colorList.append(name)
             self.colorComboBox.addItem(QIcon(colorSquare), name)
         self.colorComboBox.setEditable(True)
         self.colorComboBox.setInsertPolicy(QComboBox.NoInsert)
         self.colorComboBox.completer().setCompletionMode(QCompleter.PopupCompletion)
         self.colorComboBox.completer().setCaseSensitivity(False)
         self.colorComboBox.completer().setFilterMode(Qt.MatchContains)
         
 
     def slot_get_color_from_combobox(self):
         if self.currentPalette is not None:
             entry = self.currentPalette.colorSetEntryByIndex(self.colorComboBox.currentIndex())
             self.slot_swatchSelected(entry)
 
     def slot_add_entry(self):
         if (self.canvas()) is not None:
             if (self.canvas().view()) is not None:
                 color = self.canvas().view().foregroundColor()
                 success = self.paletteView.addEntryWithDialog(color)
                 if success is True:
                     self.slot_fill_combobox()
 
     def slot_add_group(self):
         success = self.paletteView.addGroupWithDialog()
         if success is True:
             self.slot_fill_combobox()
 
     def slot_remove_entry(self):
         success = self.paletteView.removeSelectedEntryWithDialog()
         if success is True:
             self.slot_fill_combobox()
 
     '''
     A function for giving a gui to edit palette metadata... I also want this to be the way to edit the settings of the
     palette docker.
     '''
 
     def slot_edit_palette_data(self):
         dialog = QDialog(self)
         tabWidget = QTabWidget()
-        dialog.setWindowTitle("Edit Palette Data")
+        dialog.setWindowTitle(i18n("Edit Palette Data"))
         dialog.setLayout(QVBoxLayout())
         dialog.layout().addWidget(tabWidget)
         paletteWidget = QWidget()
         paletteWidget.setLayout(QVBoxLayout())
-        tabWidget.addTab(paletteWidget, "Palette Data")
+        tabWidget.addTab(paletteWidget, i18n("Palette Data"))
         paletteName = QLineEdit()
         paletteName.setText(self.cmb_palettes.currentText())
         paletteWidget.layout().addWidget(paletteName)
         paletteColumns = QSpinBox()
         paletteColumns.setValue(self.currentPalette.columnCount())
         paletteWidget.layout().addWidget(paletteColumns)
         paletteComment = QPlainTextEdit()
         paletteComment.appendPlainText(self.currentPalette.comment())
         paletteWidget.layout().addWidget(paletteComment)
         buttons = QDialogButtonBox(QDialogButtonBox.Ok)
         dialog.layout().addWidget(buttons)
         buttons.accepted.connect(dialog.accept)
         # buttons.rejected.connect(dialog.reject())
 
         if dialog.exec_() == QDialog.Accepted:
             Resource = Application.resources("palette")[self.cmb_palettes.currentText()]
             Resource.setName(paletteName.text())
             self.currentPalette = Palette(Resource)
             self.currentPalette.setColumnCount(paletteColumns.value())
             self.paletteView.setPalette(self.currentPalette)
             self.slot_fill_combobox()
             self.currentPalette.setComment(paletteComment.toPlainText())
             self.currentPalette.save()
 
     def slot_export_to_gimp_palette(self):
         palette_exporter_gimppalette.gimpPaletteExporter(self.cmb_palettes.currentText())
 
     def slot_export_to_inkscape_svg(self):
         palette_exporter_inkscapeSVG.inkscapeSVGExporter(self.cmb_palettes.currentText())
 
     def slot_sort_colors(self):
         colorSorter = palette_sortColors.sortColors(self.cmb_palettes.currentText())
         self.paletteView.setPalette(colorSorter.palette())
 
     def canvasChanged(self, canvas):
         self.cmb_palettes.clear()
         allPalettes = Application.resources("palette")
         for palette_name in allPalettes:
             self.cmb_palettes.addItem(palette_name)
             self.cmb_palettes.model().sort(0)
 
         if self.currentPalette == None and len(allPalettes.keys()) > 0:
             self.currentPalette = Palette(allPalettes[list(allPalettes.keys())[0]])
 
 # Add docker to the application :)
 Application.addDockWidgetFactory(DockWidgetFactory("palette_docker", DockWidgetFactoryBase.DockRight, Palette_Docker))
diff --git a/plugins/python/palette_docker/palette_exporter_gimppalette.py b/plugins/python/palette_docker/palette_exporter_gimppalette.py
index c0f7091f66..3724ab89e2 100644
--- a/plugins/python/palette_docker/palette_exporter_gimppalette.py
+++ b/plugins/python/palette_docker/palette_exporter_gimppalette.py
@@ -1,73 +1,73 @@
 '''
 A script that converts the palette with the given name to a gimp palette at the location asked for.
 
 By Wolthera(originally)
 
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 
 @package palette_docker
 '''
 
 
 # Importing the relevant dependencies:
 import sys
 from PyQt5.QtWidgets import QFileDialog, QMessageBox
 import math
 from krita import *
 
 
 class gimpPaletteExporter:
 
     def __init__(self, name):
         # We want people to select a palette and a location to save to...
         self.fileName = QFileDialog.getExistingDirectory()
         allPalettes = Application.resources("palette")
         self.paletteName = name
         self.currentPalette = Palette(allPalettes[self.paletteName])
         self.export()
         done = QMessageBox()
-        done.setWindowTitle("Export successful")
-        done.setText(self.paletteName + " has been exported to " + self.fileName + "!")
+        done.setWindowTitle(i18n("Export Successful"))
+        done.setText(str(i18n("{input} has been exported to {output}.")).format(input=self.paletteName, output=self.fileName))
         done.exec_()
         pass
 
     def export(self):
         # open the appropriate file...
         gplFile = open(self.fileName + "/" + self.paletteName + ".gpl", "w")
         gplFile.write("GIMP Palette\n")
         gplFile.write("Name: " + self.paletteName + "\n")
         gplFile.write("Columns: " + str(self.currentPalette.columnCount()) + "\n")
         gplFile.write("#" + self.currentPalette.comment() + "\n")
         colorCount = self.currentPalette.colorsCountGroup("")
 
         for i in range(colorCount):
             entry = self.currentPalette.colorSetEntryFromGroup(i, "")
             color = self.currentPalette.colorForEntry(entry)
             # convert to sRGB
             color.setColorSpace("RGBA", "U8", "sRGB built-in")
 
             red = max(min(int(color.componentsOrdered()[0] * 255), 255), 0)
             green = max(min(int(color.componentsOrdered()[1] * 255), 255), 0)
             blue = max(min(int(color.componentsOrdered()[2] * 255), 255), 0)
             gplFile.write(str(red) + " " + str(green) + " " + str(blue) + "    " + entry.id() + "-" + entry.name() + "\n")
             groupNames = self.currentPalette.groupNames()
             for groupName in groupNames:
                 colorCount = self.currentPalette.colorsCountGroup(groupName)
                 for i in range(colorCount):
                     entry = self.currentPalette.colorSetEntryFromGroup(i, groupName)
                     color = self.currentPalette.colorForEntry(entry)
                     # convert to sRGB
                     color.setColorSpace("RGBA", "U8", "sRGB built-in")
                     red = max(min(int(color.componentsOrdered()[0] * 255), 255), 0)
                     green = max(min(int(color.componentsOrdered()[1] * 255), 255), 0)
                     blue = max(min(int(color.componentsOrdered()[2] * 255), 255), 0)
                     gplFile.write(str(red) + " " + str(green) + " " + str(blue) + "    " + entry.id() + "-" + entry.name() + "\n")
         gplFile.close()
diff --git a/plugins/python/palette_docker/palette_exporter_inkscapeSVG.py b/plugins/python/palette_docker/palette_exporter_inkscapeSVG.py
index 913600db37..f782ca2059 100644
--- a/plugins/python/palette_docker/palette_exporter_inkscapeSVG.py
+++ b/plugins/python/palette_docker/palette_exporter_inkscapeSVG.py
@@ -1,186 +1,186 @@
 '''
 A script that converts the palette named "Default" to a SVG so that Inkscape may use the colors
 The icc-color stuff doesn't work right, because we'd need the ability to get the url of the colorprofile somehow, and then we can make color-profile things in the definitions.
 
 By Wolthera(originally)
 
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 
 @package palette_docker
 '''
 
 # Importing the relevant dependencies:
 import sys
 from PyQt5.QtXml import QDomDocument
 from PyQt5.QtWidgets import QFileDialog, QMessageBox
 import math
 from krita import *
 
 
 class inkscapeSVGExporter:
 
     def __init__(self, name):
         # We want people to select a palette and a location to save to...
         self.fileName = QFileDialog.getExistingDirectory()
         allPalettes = Application.resources("palette")
         self.paletteName = name
         self.currentPalette = Palette(allPalettes[self.paletteName])
         self.export()
         done = QMessageBox()
-        done.setWindowTitle("Export successful")
-        done.setText(self.paletteName + " has been exported to " + self.fileName + "!")
+        done.setWindowTitle(i18n("Export Successful"))
+        done.setText(str(i18n("{input} has been exported to {output}.")).format(input=self.paletteName, output=self.fileName))
         done.exec_()
         pass
 
     def export(self):
         # open the appropriate file...
         svgFile = open(self.fileName + "/" + self.paletteName + ".svg", "w")
         svgDoc = QDomDocument()
         svgBaseElement = svgDoc.createElement("svg")
         svgBaseElement.setAttribute("xmlns:osb", "http://www.openswatchbook.org/uri/2009/osb")
         svgBaseElement.setAttribute("xmlns:svg", "http://www.w3.org/2000/svg")
         svgBaseElement.setAttribute("xmlns:dc", "http://purl.org/dc/elements/1.1/")
         svgBaseElement.setAttribute("xmlns:cc", "http://creativecommons.org/ns#")
         svgBaseElement.setAttribute("xmlns:rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#")
         svgDefs = svgDoc.createElement("defs")
         svgSwatches = svgDoc.createElement("g")
         svgSwatches.setAttribute("id", "Swatches")
 
         svgMeta = svgDoc.createElement("metadata")
         svgBaseElement.appendChild(svgMeta)
         rdf = svgDoc.createElement("rdf:RDF")
         ccwork = svgDoc.createElement("cc:Work")
         dctitle = svgDoc.createElement("dc:title")
         dcdescription = svgDoc.createElement("dc:description")
         dctitle.appendChild(svgDoc.createTextNode(self.paletteName))
         dcdescription.appendChild(svgDoc.createTextNode(self.currentPalette.comment()))
         ccwork.appendChild(dctitle)
         ccwork.appendChild(dcdescription)
         rdf.appendChild(ccwork)
         svgMeta.appendChild(rdf)
         Row = 0
         Column = 0
         iccProfileList = []
 
         colorCount = self.currentPalette.colorsCountGroup("")
 
         for i in range(colorCount):
             entry = self.currentPalette.colorSetEntryFromGroup(i, "")
             color = self.currentPalette.colorForEntry(entry)
 
             iccColor = "icc-color(" + color.colorProfile()
             for c in range(len(color.componentsOrdered()) - 1):
                 iccColor = iccColor + "," + str(color.componentsOrdered()[c])
             iccColor = iccColor + ")"
             if color.colorProfile() not in iccProfileList:
                 iccProfileList.append(color.colorProfile())
 
             # convert to sRGB
             color.setColorSpace("RGBA", "U8", "sRGB built-in")
             red = max(min(int(color.componentsOrdered()[0] * 255), 255), 0)
             green = max(min(int(color.componentsOrdered()[1] * 255), 255), 0)
             blue = max(min(int(color.componentsOrdered()[2] * 255), 255), 0)
             hexcode = "#" + str(format(red, '02x')) + str(format(green, '02x')) + str(format(blue, '02x'))
             swatchName = str(i) + "-" + entry.name()
             swatchName = swatchName.replace(" ", "-")
             swatchName = swatchName.replace("(", "-")
             swatchName = swatchName.replace(")", "-")
             swatchMain = svgDoc.createElement("linearGradient")
             swatchMain.setAttribute("osb:paint", "solid")
             swatchMain.setAttribute("id", swatchName)
             swatchSub = svgDoc.createElement("stop")
             swatchSub.setAttribute("style", "stop-color: " + hexcode + " " + iccColor + ";stop-opacity:1;")
             swatchMain.appendChild(swatchSub)
             svgDefs.appendChild(swatchMain)
             svgSingleSwatch = svgDoc.createElement("rect")
             svgSingleSwatch.setAttribute("x", str(int(Column * 20)))
             svgSingleSwatch.setAttribute("y", str(int(Row * 20)))
             svgSingleSwatch.setAttribute("width", str(int(20)))
             svgSingleSwatch.setAttribute("height", str(int(20)))
             svgSingleSwatch.setAttribute("fill", "url(#" + swatchName + ")")
             svgSingleSwatch.setAttribute("id", "swatch" + swatchName)
             if entry.spotColor() is True:
                 svgSingleSwatch.setAttribute("rx", str(10))
                 svgSingleSwatch.setAttribute("ry", str(10))
             svgSwatches.appendChild(svgSingleSwatch)
             Column += 1
             if (Column >= self.currentPalette.columnCount()):
                 Column = 0
                 Row += 1
 
         groupNames = self.currentPalette.groupNames()
         for groupName in groupNames:
             Column = 0
             Row += 1
             groupTitle = svgDoc.createElement("text")
             groupTitle.setAttribute("x", str(int(Column * 20)))
             groupTitle.setAttribute("y", str(int(Row * 20) + 15))
             groupTitle.appendChild(svgDoc.createTextNode(groupName))
             svgSwatches.appendChild(groupTitle)
             Row += 1
             colorCount = self.currentPalette.colorsCountGroup(groupName)
             for i in range(colorCount):
                 entry = self.currentPalette.colorSetEntryFromGroup(i, groupName)
                 color = self.currentPalette.colorForEntry(entry)
                 iccColor = "icc-color(" + color.colorProfile()
                 for c in range(len(color.componentsOrdered()) - 1):
                     iccColor = iccColor + "," + str(color.componentsOrdered()[c])
                 iccColor = iccColor + ")"
                 if color.colorProfile() not in iccProfileList:
                     iccProfileList.append(color.colorProfile())
                 # convert to sRGB
                 color.setColorSpace("RGBA", "U8", "sRGB built-in")
                 red = max(min(int(color.componentsOrdered()[0] * 255), 255), 0)
                 green = max(min(int(color.componentsOrdered()[1] * 255), 255), 0)
                 blue = max(min(int(color.componentsOrdered()[2] * 255), 255), 0)
                 hexcode = "#" + str(format(red, '02x')) + str(format(green, '02x')) + str(format(blue, '02x'))
 
                 swatchName = groupName + str(i) + "-" + entry.name()
                 swatchName = swatchName.replace(" ", "-")
                 swatchName = swatchName.replace("(", "-")
                 swatchName = swatchName.replace(")", "-")
                 swatchMain = svgDoc.createElement("linearGradient")
                 swatchMain.setAttribute("osb:paint", "solid")
                 swatchMain.setAttribute("id", swatchName)
                 swatchSub = svgDoc.createElement("stop")
                 swatchSub.setAttribute("style", "stop-color: " + hexcode + " " + iccColor + ";stop-opacity:1;")
                 swatchMain.appendChild(swatchSub)
                 svgDefs.appendChild(swatchMain)
                 svgSingleSwatch = svgDoc.createElement("rect")
                 svgSingleSwatch.setAttribute("x", str(int(Column * 20)))
                 svgSingleSwatch.setAttribute("y", str(int(Row * 20)))
                 svgSingleSwatch.setAttribute("width", str(int(20)))
                 svgSingleSwatch.setAttribute("height", str(int(20)))
                 svgSingleSwatch.setAttribute("fill", "url(#" + swatchName + ")")
                 svgSingleSwatch.setAttribute("id", "swatch " + swatchName)
                 if entry.spotColor() is True:
                     svgSingleSwatch.setAttribute("rx", str(10))
                     svgSingleSwatch.setAttribute("ry", str(10))
                 svgSwatches.appendChild(svgSingleSwatch)
                 Column += 1
                 if (Column >= self.currentPalette.columnCount()):
                     Column = 0
                     Row += 1
 
         for profile in iccProfileList:
             svgProfileDesc = svgDoc.createElement("color-profile")
             svgProfileDesc.setAttribute("name", profile)
             # This is incomplete because python api doesn't have any way to ask for this data yet.
             # svgProfileDesc.setAttribute("local", "sRGB")
             # svgProfileDesc.setAttribute("xlink:href", colorprofileurl)
             svgProfileDesc.setAttribute("rendering-intent", "perceptual")
             svgDefs.appendChild(svgProfileDesc)
         svgBaseElement.appendChild(svgDefs)
         svgBaseElement.appendChild(svgSwatches)
         svgBaseElement.setAttribute("viewBox", "0 0 " + str(self.currentPalette.columnCount() * 20) + " " + str(int((Row + 1) * 20)))
         svgDoc.appendChild(svgBaseElement)
         svgFile.write(svgDoc.toString())
         svgFile.close()
diff --git a/plugins/python/quick_settings_docker/quick_settings_docker.py b/plugins/python/quick_settings_docker/quick_settings_docker.py
index 1add2d6a18..9d27ae8a3b 100644
--- a/plugins/python/quick_settings_docker/quick_settings_docker.py
+++ b/plugins/python/quick_settings_docker/quick_settings_docker.py
@@ -1,175 +1,175 @@
 '''
 Description: A Python based docker for quickly choosing the brushsize like similar dockers in other drawing programs.
 
 By Wolthera(originally)
 
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 
 @package quick_settings_docker
 '''
 
 # Importing the relevant dependencies:
 import sys
 from PyQt5.QtCore import pyqtSlot, Qt, QPointF
 from PyQt5.QtGui import QStandardItem, QStandardItemModel, QPainter, QPalette, QPixmap, QImage, QBrush, QPen, QIcon
 from PyQt5.QtWidgets import QWidget, QTabWidget, QListView, QVBoxLayout
 from krita import *
 
 
 class QuickSettingsDocker(DockWidget):
     # Init the docker
 
     def __init__(self):
         super(QuickSettingsDocker, self).__init__()
         # make base-widget and layout
         widget = QWidget()
         layout = QVBoxLayout()
         widget.setLayout(layout)
-        self.setWindowTitle("Quick Settings Docker")
+        self.setWindowTitle(i18n("Quick Settings Docker"))
         tabWidget = QTabWidget()
 
         self.brushSizeTableView = QListView()
         self.brushSizeTableView.setViewMode(QListView.IconMode)
         self.brushSizeTableView.setMovement(QListView.Static)
         self.brushSizeTableView.setResizeMode(QListView.Adjust)
         self.brushSizeTableView.setUniformItemSizes(True)
         self.brushSizeTableView.setSelectionMode(QListView.SingleSelection)
 
         self.brushOpacityTableView = QListView()
         self.brushOpacityTableView.setViewMode(QListView.IconMode)
         self.brushOpacityTableView.setMovement(QListView.Static)
         self.brushOpacityTableView.setResizeMode(QListView.Adjust)
         self.brushOpacityTableView.setUniformItemSizes(True)
         self.brushOpacityTableView.setSelectionMode(QListView.SingleSelection)
 
         self.brushFlowTableView = QListView()
         self.brushFlowTableView.setViewMode(QListView.IconMode)
         self.brushFlowTableView.setMovement(QListView.Static)
         self.brushFlowTableView.setResizeMode(QListView.Adjust)
         self.brushFlowTableView.setUniformItemSizes(True)
         self.brushFlowTableView.setSelectionMode(QListView.SingleSelection)
 
-        tabWidget.addTab(self.brushSizeTableView, "Size")
-        tabWidget.addTab(self.brushOpacityTableView, "Opacity")
-        tabWidget.addTab(self.brushFlowTableView, "Flow")
+        tabWidget.addTab(self.brushSizeTableView, i18n("Size"))
+        tabWidget.addTab(self.brushOpacityTableView, i18n("Opacity"))
+        tabWidget.addTab(self.brushFlowTableView, i18n("Flow"))
         layout.addWidget(tabWidget)
         self.setWidget(widget)  # Add the widget to the docker.
 
         # amount of columns in each row for all the tables.
 
         # We want a grid with possible options to select.
         # To do this, we'll make a ListView widget and use a standarditemmodel for the entries.
         # The entries are filled out based on the sizes and opacity lists.
 
         # Sizes and opacity lists. The former is half-way copied from ptsai, the latter is based on personal experience of useful opacities.
         self.sizesList = [0.7, 1.0, 1.5, 2, 2.5, 3, 3.5, 4, 5, 6, 7, 8, 9, 10, 12, 14, 16, 20, 25, 30, 35, 40, 50, 60, 70, 80, 100, 120, 160, 200, 250, 300, 350, 400, 450, 500]
         self.opacityList = [0.1, 0.5, 1, 5, 10, 15, 20, 30, 40, 50, 60, 70, 80, 90, 100]
         self.brushSizeModel = QStandardItemModel()
         self.brushOpacityModel = QStandardItemModel()
         self.brushFlowModel = QStandardItemModel()
         self.fillSizesModel()
         self.fillOpacityModel()
 
         # Now we're done filling out our tables, we connect the views to the functions that'll change the settings.
         self.brushSizeTableView.clicked.connect(self.setBrushSize)
         self.brushOpacityTableView.clicked.connect(self.setBrushOpacity)
         self.brushFlowTableView.clicked.connect(self.setBrushFlow)
 
     def fillSizesModel(self):
         # First we empty the old model. We might wanna use this function in the future to fill it with the brushmask of the selected brush, but there's currently no API for recognising changes in the current brush nor is there a way to get its brushmask.
         self.brushSizeModel.clear()
         for s in range(len(self.sizesList)):
             # we're gonna itterate over our list, and make a new item for each entry.
             # We need to disable a bunch of stuff to make sure people won't do funny things to our entries.
             item = QStandardItem()
             item.setCheckable(False)
             item.setEditable(False)
             item.setDragEnabled(False)
             item.setText(str(self.sizesList[s])+" px")
             # And from here on we'll make an icon.
             brushImage = QPixmap(64, 64)
             img = QImage(64, 64, QImage.Format_RGBA8888)
             circlePainter = QPainter()
             img.fill(Qt.transparent)
             circlePainter.begin(img)
             brush = QBrush(Qt.SolidPattern)
             brush.setColor(self.brushSizeTableView.palette().color(QPalette.Text))
             circlePainter.setBrush(brush)
             circlePainter.setPen(QPen(QBrush(Qt.transparent), 0))
             brushSize = max(min(self.sizesList[s], 64), 1)
             brushSize = brushSize * 0.5
             circlePainter.drawEllipse(QPointF(32, 32), brushSize, brushSize)
             circlePainter.end()
             brushImage = QPixmap.fromImage(img)
             # now we're done with drawing the icon, so we set it on the item.
             item.setIcon(QIcon(brushImage))
             self.brushSizeModel.appendRow(item)
         self.brushSizeTableView.setModel(self.brushSizeModel)
 
     def fillOpacityModel(self):
         self.brushOpacityModel.clear()
         self.brushFlowModel.clear()
         for s in range(len(self.opacityList)):
             # we're gonna itterate over our list, and make a new item for each entry.
             item = QStandardItem()
             item.setCheckable(False)
             item.setEditable(False)
             item.setDragEnabled(False)
             item.setText(str(self.opacityList[s])+" %")
             brushImage = QPixmap(64, 64)
             img = QImage(64, 64, QImage.Format_RGBA8888)
             circlePainter = QPainter()
             img.fill(Qt.transparent)
             circlePainter.begin(img)
             brush = QBrush(Qt.SolidPattern)
             brush.setColor(self.brushSizeTableView.palette().color(QPalette.Text))
             circlePainter.setBrush(brush)
             circlePainter.setPen(QPen(QBrush(Qt.transparent), 0))
             circlePainter.setOpacity(float(self.opacityList[s]) / 100.0)
             circlePainter.drawEllipse(QPointF(32, 32), 32, 32)
             circlePainter.end()
             brushImage = QPixmap.fromImage(img)
             item.setIcon(QIcon(brushImage))
             # the flow and opacity models will use virtually the same items, but Qt would like us to make sure we understand
             # these are not really the same items, so hence the clone.
             itemFlow = item.clone()
             self.brushOpacityModel.appendRow(item)
             self.brushFlowModel.appendRow(itemFlow)
         self.brushOpacityTableView.setModel(self.brushOpacityModel)
         self.brushFlowTableView.setModel(self.brushFlowModel)
 
     def canvasChanged(self, canvas):
         pass
 
     @pyqtSlot('QModelIndex')
     def setBrushSize(self, index):
         i = index.row()
         brushSize = self.sizesList[i]
         if Application.activeWindow() and len(Application.activeWindow().views()) > 0:
             Application.activeWindow().views()[0].setBrushSize(brushSize)
 
     @pyqtSlot('QModelIndex')
     def setBrushOpacity(self, index):
         i = index.row()
         brushOpacity = float(self.opacityList[i]) / 100.0
         if Application.activeWindow() and len(Application.activeWindow().views()) > 0:
             Application.activeWindow().views()[0].setPaintingOpacity(brushOpacity)
 
     @pyqtSlot('QModelIndex')
     def setBrushFlow(self, index):
         i = index.row()
         brushOpacity = float(self.opacityList[i]) / 100.0
         if Application.activeWindow() and len(Application.activeWindow().views()) > 0:
             Application.activeWindow().views()[0].setPaintingFlow(brushOpacity)
 
 
 # Add docker to the application :)
 Application.addDockWidgetFactory(DockWidgetFactory("quick_settings_docker", DockWidgetFactoryBase.DockRight, QuickSettingsDocker))
diff --git a/plugins/python/scriptdocker/scriptdocker.py b/plugins/python/scriptdocker/scriptdocker.py
index a113f2d851..3b865c610a 100644
--- a/plugins/python/scriptdocker/scriptdocker.py
+++ b/plugins/python/scriptdocker/scriptdocker.py
@@ -1,66 +1,66 @@
 '''
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 '''
 rom PyQt5.QtWidgets import (QWidget, QVBoxLayout, QListView, QFormLayout,
                              QHBoxLayout, QPushButton, QLineEdit, QListWidget)
 from PyQt5.QtCore import QObject
 import krita
 
 
 class ScriptDocker(krita.DockWidget):
 
     def __init__(self):
         super(ScriptDocker, self).__init__()
 
         self.baseWidget = QWidget()
         self.layout = QVBoxLayout()
         self.scriptsLayout = QFormLayout()
-        self.addButton = QPushButton("Add Script")
+        self.addButton = QPushButton(i18n("Add Script"))
         self.actions = []
 
         self.layout.addLayout(self.scriptsLayout)
         self.layout.addWidget(self.addButton)
         self.baseWidget.setLayout(self.layout)
         self.setWidget(self.baseWidget)
 
-        self.setWindowTitle("Script Docker")
+        self.setWindowTitle(i18n("Script Docker"))
         self.addButton.clicked.connect(self.addNewRow)
 
     def canvasChanged(self, canvas):
         pass
 
     def addNewRow(self):
         directorySelectorLayout = QHBoxLayout()
         directoryTextField = QLineEdit()
-        directoryDialogButton = QPushButton("...")
+        directoryDialogButton = QPushButton(i18n("..."))
 
         directoryDialogButton.clicked.connect(self.test)
 
         directorySelectorLayout.addWidget(directoryTextField)
         directorySelectorLayout.addWidget(directoryDialogButton)
 
-        self.scriptsLayout.addRow("Script {0}".format(self.scriptsLayout.rowCount() + 1), directorySelectorLayout)
+        self.scriptsLayout.addRow(str(i18n("Script {0}")).format(self.scriptsLayout.rowCount() + 1), directorySelectorLayout)
 
     def test(self):
         obj = self.sender()
         print('button', obj)
 
     def loadActions(self):
         pass
 
     def readSettings(self):
         pass
 
     def writeSettings(self):
         pass
 
 
 Application.addDockWidgetFactory(krita.DockWidgetFactory("scriptdocker", krita.DockWidgetFactoryBase.DockRight, ScriptDocker))
diff --git a/plugins/python/scripter/ui_scripter/actions/closeaction/closeaction.py b/plugins/python/scripter/ui_scripter/actions/closeaction/closeaction.py
index 064a889f53..3b5b5938fb 100644
--- a/plugins/python/scripter/ui_scripter/actions/closeaction/closeaction.py
+++ b/plugins/python/scripter/ui_scripter/actions/closeaction/closeaction.py
@@ -1,54 +1,55 @@
 """
 Copyright (c) 2017 Eliakin Costa <eliakim170@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 """
 from PyQt5.QtWidgets import QAction, QMessageBox
 from PyQt5.QtGui import QKeySequence
 from PyQt5.QtCore import Qt
+import krita
 
 
 class CloseAction(QAction):
 
     def __init__(self, scripter, parent=None):
         super(CloseAction, self).__init__(parent)
         self.scripter = scripter
 
         self.triggered.connect(self.close)
 
-        self.setText('Close')
+        self.setText(i18n("Close"))
         self.setObjectName('close')
         self.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_Q))
 
     @property
     def parent(self):
         return 'File'
 
     def close(self):
         msgBox = QMessageBox(self.scripter.uicontroller.mainWidget)
 
-        msgBox.setInformativeText("Do you want to save the current document?")
+        msgBox.setInformativeText(i18n("Do you want to save the current document?"))
         msgBox.setStandardButtons(QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel)
         msgBox.setDefaultButton(QMessageBox.Save)
 
         ret = msgBox.exec_()
 
         if ret == QMessageBox.Cancel:
             return
         if ret == QMessageBox.Save:
             if not self.scripter.uicontroller.invokeAction('save'):
                 return
 
         self.scripter.uicontroller.closeScripter()
diff --git a/plugins/python/scripter/ui_scripter/actions/debugaction/debugaction.py b/plugins/python/scripter/ui_scripter/actions/debugaction/debugaction.py
index e5ae9512ad..4063a8e7a0 100644
--- a/plugins/python/scripter/ui_scripter/actions/debugaction/debugaction.py
+++ b/plugins/python/scripter/ui_scripter/actions/debugaction/debugaction.py
@@ -1,46 +1,47 @@
 """
 Copyright (c) 2017 Eliakin Costa <eliakim170@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 """
 from PyQt5.QtWidgets import QAction
 from PyQt5.QtGui import QIcon, QPixmap, QKeySequence
 from scripter import resources_rc
 from PyQt5.QtCore import Qt
+import krita
 
 
 class DebugAction(QAction):
 
     def __init__(self, scripter, parent=None):
         super(DebugAction, self).__init__(parent)
         self.scripter = scripter
 
         self.triggered.connect(self.debug)
 
-        self.setText('Debug')
-        self.setToolTip('Debug Ctrl+D')
+        self.setText(i18n("Debug"))
+        self.setToolTip(i18n("Debug Ctrl+D"))
         self.setIcon(QIcon(':/icons/debug.svg'))
         self.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_D))
 
     @property
     def parent(self):
         return 'toolBar'
 
     def debug(self):
         if self.scripter.uicontroller.invokeAction('save'):
             self.scripter.uicontroller.setActiveWidget('Debugger')
             self.scripter.debugcontroller.start(self.scripter.documentcontroller.activeDocument)
             widget = self.scripter.uicontroller.findTabWidget('Debugger')
             widget.startDebugger()
diff --git a/plugins/python/scripter/ui_scripter/actions/newaction/newaction.py b/plugins/python/scripter/ui_scripter/actions/newaction/newaction.py
index e5761f2b7e..d446281fad 100644
--- a/plugins/python/scripter/ui_scripter/actions/newaction/newaction.py
+++ b/plugins/python/scripter/ui_scripter/actions/newaction/newaction.py
@@ -1,56 +1,57 @@
 """
 Copyright (c) 2017 Eliakin Costa <eliakim170@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 """
 from PyQt5.QtWidgets import QAction, QMessageBox
 from PyQt5.QtGui import QKeySequence
 from PyQt5.QtCore import Qt
+import krita
 
 
 class NewAction(QAction):
 
     def __init__(self, scripter, parent=None):
         super(NewAction, self).__init__(parent)
         self.scripter = scripter
 
         self.triggered.connect(self.new)
 
-        self.setText('New')
+        self.setText(i18n("New"))
         self.setObjectName('new')
         self.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_N))
 
     @property
     def parent(self):
         return 'File'
 
     def new(self):
         msgBox = QMessageBox(self.scripter.uicontroller.mainWidget)
 
-        msgBox.setText("The document has been modified.")
-        msgBox.setInformativeText("Do you want to save your changes?")
+        msgBox.setText(i18n("The document has been modified."))
+        msgBox.setInformativeText(i18n("Do you want to save your changes?"))
         msgBox.setStandardButtons(QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel)
         msgBox.setDefaultButton(QMessageBox.Save)
 
         ret = msgBox.exec_()
 
         if ret == QMessageBox.Cancel:
             return
         if ret == QMessageBox.Save:
             self.scripter.uicontroller.invokeAction('save')
 
         self.scripter.documentcontroller.clearActiveDocument()
         self.scripter.uicontroller.setStatusBar()
         self.scripter.uicontroller.clearEditor()
diff --git a/plugins/python/scripter/ui_scripter/actions/openaction/openaction.py b/plugins/python/scripter/ui_scripter/actions/openaction/openaction.py
index 209b371185..eb88385e9d 100644
--- a/plugins/python/scripter/ui_scripter/actions/openaction/openaction.py
+++ b/plugins/python/scripter/ui_scripter/actions/openaction/openaction.py
@@ -1,57 +1,58 @@
 """
 Copyright (c) 2017 Eliakin Costa <eliakim170@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 """
 from PyQt5.QtWidgets import QAction, QFileDialog, QMessageBox
 from PyQt5.QtGui import QKeySequence
 from PyQt5.QtCore import Qt
+import krita
 
 import os
 
 
 class OpenAction(QAction):
 
     def __init__(self, scripter, parent=None):
         super(OpenAction, self).__init__(parent)
         self.scripter = scripter
 
         self.triggered.connect(self.open)
 
-        self.setText('Open')
+        self.setText(i18n("Open"))
         self.setObjectName('open')
         self.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_O))
 
     @property
     def parent(self):
         return 'File'
 
     def open(self):
         dialog = QFileDialog(self.scripter.uicontroller.mainWidget)
-        dialog.setNameFilter('Python files (*.py)')
+        dialog.setNameFilter(i18n("Python Files (*.py)"))
 
         if dialog.exec_():
             try:
                 selectedFile = dialog.selectedFiles()[0]
                 _, fileExtension = os.path.splitext(selectedFile)
 
                 if fileExtension == '.py':
                     document = self.scripter.documentcontroller.openDocument(selectedFile)
                     self.scripter.uicontroller.setDocumentEditor(document)
                     self.scripter.uicontroller.setStatusBar(document.filePath)
             except Exception:
                 QMessageBox.information(self.scripter.uicontroller.mainWidget,
-                                        'Invalid File',
-                                        'Open files with .py extension')
+                                        i18n("Invalid File"),
+                                        i18n("Open files with .py extension"))
diff --git a/plugins/python/scripter/ui_scripter/actions/reloadaction/reloadaction.py b/plugins/python/scripter/ui_scripter/actions/reloadaction/reloadaction.py
index 7b6ebbb0e3..ec142f21dc 100644
--- a/plugins/python/scripter/ui_scripter/actions/reloadaction/reloadaction.py
+++ b/plugins/python/scripter/ui_scripter/actions/reloadaction/reloadaction.py
@@ -1,62 +1,63 @@
 """
 Copyright (c) 2017 Eliakin Costa <eliakim170@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 """
 from PyQt5.QtWidgets import QAction, QMessageBox
 from PyQt5.QtGui import QKeySequence
 from PyQt5.QtCore import Qt
+import krita
 
 
 class ReloadAction(QAction):
 
     def __init__(self, scripter, parent=None):
         super(ReloadAction, self).__init__(parent)
         self.scripter = scripter
         self.editor = self.scripter.uicontroller.editor
 
         self.triggered.connect(self.reloadFile)
 
-        self.setText('Reload File')
+        self.setText(i18n("Reload File"))
         self.setObjectName('reloadfile')
         self.setShortcut(QKeySequence(Qt.ALT + Qt.Key_R))
 
     @property
     def parent(self):
         return 'File'
 
     def reloadFile(self):
         # get the currently open document's path
         curr_doc_fpath = ''
         document = self.scripter.documentcontroller._activeDocument
         if document is None:
             QMessageBox.critical(self.scripter.uicontroller.mainWidget,
-                                 'No existing document',
-                                 'Please specify a document by opening it before reloading')
+                                 i18n("No existing document"),
+                                 i18n("Please specify a document by opening it before reloading"))
             return
         else:
             curr_doc_fpath = document.filePath
 
         # clear the editor
         self.scripter.documentcontroller.clearActiveDocument()
         self.scripter.uicontroller.setStatusBar()
         self.scripter.uicontroller.clearEditor()
 
         # reload the document
         document = self.scripter.documentcontroller.openDocument(curr_doc_fpath)
         self.scripter.uicontroller.setDocumentEditor(document)
         self.scripter.uicontroller.setStatusBar(document.filePath)
 
         return document
diff --git a/plugins/python/scripter/ui_scripter/actions/runaction/runaction.py b/plugins/python/scripter/ui_scripter/actions/runaction/runaction.py
index 66f2d909d1..98dfb2b550 100644
--- a/plugins/python/scripter/ui_scripter/actions/runaction/runaction.py
+++ b/plugins/python/scripter/ui_scripter/actions/runaction/runaction.py
@@ -1,155 +1,156 @@
 """
 Copyright (c) 2017 Eliakin Costa <eliakim170@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 """
 from PyQt5.QtWidgets import QAction
 from PyQt5.QtGui import QIcon, QKeySequence
 from PyQt5.QtCore import Qt
 import sys
 import traceback
 import inspect
 from . import docwrapper
+import krita
 
 if sys.version_info[0] > 2:
     import importlib
     from importlib.machinery import SourceFileLoader
 else:
     import imp
 
 PYTHON27 = sys.version_info.major == 2 and sys.version_info.minor == 7
 PYTHON33 = sys.version_info.major == 3 and sys.version_info.minor == 3
 PYTHON34 = sys.version_info.major == 3 and sys.version_info.minor == 4
 EXEC_NAMESPACE = "__main__"  # namespace that user scripts will run in
 
 
 class RunAction(QAction):
 
     def __init__(self, scripter, parent=None):
         super(RunAction, self).__init__(parent)
         self.scripter = scripter
 
         self.editor = self.scripter.uicontroller.editor
         self.output = self.scripter.uicontroller.findTabWidget('OutPut', 'OutPutTextEdit')
 
         self.triggered.connect(self.run)
 
-        self.setText('Run')
+        self.setText(i18n("Run"))
         self.setToolTip('Run Ctrl+R')
         self.setIcon(QIcon(':/icons/run.svg'))
         self.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_R))
 
     @property
     def parent(self):
         return 'toolBar'
 
     def run(self):
         """ This method execute python code from an activeDocument (file) or direct
             from editor (ui_scripter/editor/pythoneditor.py). When executing code
             from a file, we use importlib to load this module/file and with
             "users_script" name. That's implementation seeks for a "main()" function in the script.
             When executing code from editor without creating a file, we compile
             this script to bytecode and we execute this in an empty scope. That's
             faster than use exec directly and cleaner, because we are using an empty scope. """
 
         self.scripter.uicontroller.setActiveWidget('OutPut')
         stdout = sys.stdout
         stderr = sys.stderr
         output = docwrapper.DocWrapper(self.output.document())
         if (self.editor._documentModified is True):
             output.write("==== Warning: Script not saved! ====\n")
         else:
             output.write("======================================\n")
         sys.stdout = output
         sys.stderr = output
 
         script = self.editor.document().toPlainText()
         document = self.scripter.documentcontroller.activeDocument
 
         try:
             if document and self.editor._documentModified is False:
                 if PYTHON27:
                     users_module = self.run_py2_document(document)
                 else:
                     users_module = self.run_py3_document(document)
 
                 # maybe script is to be execed, maybe main needs to be invoked
                 # if there is a main() then execute it, otherwise don't worry...
                 if hasattr(users_module, "main") and inspect.isfunction(users_module.main):
                     users_module.main()
             else:
                 code = compile(script, '<string>', 'exec')
                 globals_dict = {"__name__": EXEC_NAMESPACE}
                 exec(code, globals_dict)
 
         except Exception:
             # Provide context (line number and text) for an error that is caught.
             # Ordinarily, syntax and Indent errors are caught during initial
             # compilation in exec(), and the traceback traces back to this file.
             # So these need to be treated separately.
             # Other errors trace back to the file/script being run.
             type_, value_, traceback_ = sys.exc_info()
             if type_ == SyntaxError:
                 errorMessage = "%s\n%s" % (value_.text.rstrip(), " " * (value_.offset - 1) + "^")
                 # rstrip to remove trailing \n, output needs to be fixed width font for the ^ to align correctly
                 errorText = "Syntax Error on line %s" % value_.lineno
             elif type_ == IndentationError:
                 # (no offset is provided for an IndentationError
                 errorMessage = value_.text.rstrip()
                 errorText = "Unexpected Indent on line %s" % value_.lineno
             else:
                 errorText = traceback.format_exception_only(type_, value_)[0]
                 format_string = "In file: {0}\nIn function: {2} at line: {1}. Line with error:\n{3}"
                 tbList = traceback.extract_tb(traceback_)
                 tb = tbList[-1]
                 errorMessage = format_string.format(*tb)
             m = "\n**********************\n%s\n%s\n**********************\n" % (errorText, errorMessage)
             output.write(m)
 
         sys.stdout = stdout
         sys.stderr = stderr
 
         # scroll to bottom of output
         bottom = self.output.verticalScrollBar().maximum()
         self.output.verticalScrollBar().setValue(bottom)
 
     def run_py2_document(self, document):
         """ Loads and executes an external script using Python 2 specific operations
         and returns the loaded module for further execution if needed.
         """
         try:
             user_module = imp.load_source(EXEC_NAMESPACE, document.filePath)
         except Exception as e:
             raise e
 
         return user_module
 
     def run_py3_document(self, document):
         """ Loads and executes an external script using Python 3 specific operations
         and returns the loaded module for further execution if needed.
         """
         spec = importlib.util.spec_from_file_location(EXEC_NAMESPACE, document.filePath)
         try:
             users_module = importlib.util.module_from_spec(spec)
             spec.loader.exec_module(users_module)
 
         except AttributeError as e:  # no module from spec
             if PYTHON34 or PYTHON33:
                 loader = SourceFileLoader(EXEC_NAMESPACE, document.filePath)
                 users_module = loader.load_module()
             else:
                 raise e
 
         return users_module
diff --git a/plugins/python/scripter/ui_scripter/actions/saveaction/saveaction.py b/plugins/python/scripter/ui_scripter/actions/saveaction/saveaction.py
index 4fea1c0e89..887395ba8b 100644
--- a/plugins/python/scripter/ui_scripter/actions/saveaction/saveaction.py
+++ b/plugins/python/scripter/ui_scripter/actions/saveaction/saveaction.py
@@ -1,62 +1,63 @@
 """
 Copyright (c) 2017 Eliakin Costa <eliakim170@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 """
 from PyQt5.QtWidgets import QAction, QFileDialog
 from PyQt5.QtGui import QKeySequence
 from PyQt5.QtCore import Qt
+import krita
 
 
 class SaveAction(QAction):
 
     def __init__(self, scripter, parent=None):
         super(SaveAction, self).__init__(parent)
         self.scripter = scripter
         self.editor = self.scripter.uicontroller.editor
 
         self.triggered.connect(self.save)
 
-        self.setText('Save')
+        self.setText(i18n("Save"))
         self.setObjectName('save')
         self.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_S))
 
     @property
     def parent(self):
         return 'File'
 
     def save(self):
         text = self.editor.toPlainText()
         fileName = ''
 
         if not self.scripter.documentcontroller.activeDocument:
             fileName = QFileDialog.getSaveFileName(self.scripter.uicontroller.mainWidget,
-                                                   'Save Python File', '',
-                                                   'Python File (*.py)')[0]
+                                                   i18n("Save Python File"), '',
+                                                   i18n("Python File (*.py)"))[0]
             if not fileName:
                 return
 
             # don't validate file name - trust user to specify the extension they want
             # getSaveFileName will add ".py" if there is no extension.
             # It will strip a trailing period and, in each case,  test for file collisions
 
         document = self.scripter.documentcontroller.saveDocument(text, fileName)
         if document:
             self.scripter.uicontroller.setStatusBar(document.filePath)
         else:
             self.scripter.uicontroller.setStatusBar('untitled')
         self.editor._documentModified = False
         self.scripter.uicontroller.setStatusModified()
         return document
diff --git a/plugins/python/scripter/ui_scripter/actions/saveasaction/saveasaction.py b/plugins/python/scripter/ui_scripter/actions/saveasaction/saveasaction.py
index 97c1e8509f..2687e44bfa 100644
--- a/plugins/python/scripter/ui_scripter/actions/saveasaction/saveasaction.py
+++ b/plugins/python/scripter/ui_scripter/actions/saveasaction/saveasaction.py
@@ -1,60 +1,61 @@
 """
 Copyright (c) 2017 Eliakin Costa <eliakim170@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 """
 from PyQt5.QtWidgets import QAction, QFileDialog
 from PyQt5.QtGui import QKeySequence
 from PyQt5.QtCore import Qt
+import krita
 
 
 class SaveAsAction(QAction):
 
     def __init__(self, scripter, parent=None):
         super(SaveAsAction, self).__init__(parent)
         self.scripter = scripter
         self.editor = self.scripter.uicontroller.editor
 
         self.triggered.connect(self.save)
 
-        self.setText('Save As')
+        self.setText(i18n("Save As"))
         self.setObjectName('saveas')
         self.setShortcut(QKeySequence(Qt.CTRL + Qt.SHIFT + Qt.Key_S))
 
     @property
     def parent(self):
         return 'File'
 
     def save(self):
         text = self.editor.toPlainText()
 
         fileName = QFileDialog.getSaveFileName(self.scripter.uicontroller.mainWidget,
-                                               'Save Python File', '',
-                                               'Python File (*.py)')[0]
+                                               i18n("Save Python File"), '',
+                                               i18n("Python File (*.py)"))[0]
         if not fileName:
             return
 
         # don't validate file name - trust user to specify the extension they want
         # getSaveFileName will add ".py" if there is no extension.
         # It will strip a trailing period and, in each case,  test for file collisions
 
         document = self.scripter.documentcontroller.saveDocument(text, fileName, save_as=True)
         if document:
             self.scripter.uicontroller.setStatusBar(document.filePath)
         else:
             self.scripter.uicontroller.setStatusBar('untitled')
         self.editor._documentModified = False
         self.scripter.uicontroller.setStatusModified()
         return document
diff --git a/plugins/python/scripter/ui_scripter/actions/settingsaction/settingsaction.py b/plugins/python/scripter/ui_scripter/actions/settingsaction/settingsaction.py
index 34f0f88b96..c5e138e851 100644
--- a/plugins/python/scripter/ui_scripter/actions/settingsaction/settingsaction.py
+++ b/plugins/python/scripter/ui_scripter/actions/settingsaction/settingsaction.py
@@ -1,49 +1,50 @@
 """
 Copyright (c) 2017 Eliakin Costa <eliakim170@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 """
 from PyQt5.QtWidgets import QAction
 from PyQt5.QtCore import Qt
 from . import settingsdialog
+import krita
 
 
 class SettingsAction(QAction):
 
     def __init__(self, scripter, parent=None):
         super(SettingsAction, self).__init__(parent)
         self.scripter = scripter
 
         self.triggered.connect(self.openSettings)
 
         self.settingsDialog = settingsdialog.SettingsDialog(self.scripter)
         self.settingsDialog.setWindowModality(Qt.WindowModal)
         self.settingsDialog.setFixedSize(400, 250)
 
-        self.setText('Settings')
+        self.setText(i18n("Settings"))
 
     @property
     def parent(self):
         return 'File'
 
     def openSettings(self):
         self.settingsDialog.show()
         self.settingsDialog.exec_()
 
     def readSettings(self):
         self.settingsDialog.readSettings(self.scripter.settings)
 
     def writeSettings(self):
         self.settingsDialog.writeSettings(self.scripter.settings)
diff --git a/plugins/python/scripter/ui_scripter/actions/settingsaction/settingsdialog.py b/plugins/python/scripter/ui_scripter/actions/settingsaction/settingsdialog.py
index fd80bd9807..f9df6c880a 100644
--- a/plugins/python/scripter/ui_scripter/actions/settingsaction/settingsdialog.py
+++ b/plugins/python/scripter/ui_scripter/actions/settingsaction/settingsdialog.py
@@ -1,41 +1,42 @@
 """
 Copyright (c) 2017 Eliakin Costa <eliakim170@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 """
 from PyQt5.QtWidgets import QDialog, QFormLayout
 from . import syntaxstylescombobox, fontscombobox
+import krita
 
 
 class SettingsDialog(QDialog):
 
     def __init__(self, scripter, parent=None):
         super(SettingsDialog, self).__init__(parent)
 
         self.scripter = scripter
-        self.setWindowTitle('Settings')
+        self.setWindowTitle(i18n("Settings"))
         self.mainLayout = QFormLayout(self)
-        self.mainLayout.addRow('Syntax Highlither', syntaxstylescombobox.SyntaxStylesComboBox(self.scripter.uicontroller.highlight, self.scripter.uicontroller.editor))
-        self.mainLayout.addRow('Fonts', fontscombobox.FontsComboBox(self.scripter.uicontroller.editor))
+        self.mainLayout.addRow(i18n("Syntax highlighter:"), syntaxstylescombobox.SyntaxStylesComboBox(self.scripter.uicontroller.highlight, self.scripter.uicontroller.editor))
+        self.mainLayout.addRow(i18n("Fonts:"), fontscombobox.FontsComboBox(self.scripter.uicontroller.editor))
 
     def readSettings(self, settings):
         for index in range(self.mainLayout.rowCount()):
             widget = self.mainLayout.itemAt(index, QFormLayout.FieldRole).widget()
             widget.readSettings(settings)
 
     def writeSettings(self, settings):
         for index in range(self.mainLayout.rowCount()):
             widget = self.mainLayout.itemAt(index, QFormLayout.FieldRole).widget()
             widget.writeSettings(settings)
diff --git a/plugins/python/scripter/ui_scripter/tabwidgets/debuggerwidget/stepaction.py b/plugins/python/scripter/ui_scripter/tabwidgets/debuggerwidget/stepaction.py
index 6385290d77..097b40a7eb 100644
--- a/plugins/python/scripter/ui_scripter/tabwidgets/debuggerwidget/stepaction.py
+++ b/plugins/python/scripter/ui_scripter/tabwidgets/debuggerwidget/stepaction.py
@@ -1,41 +1,42 @@
 """
 Copyright (c) 2017 Eliakin Costa <eliakim170@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 """
 from PyQt5.QtWidgets import QAction
 from PyQt5.QtGui import QIcon
 from scripter import resources_rc
+import krita
 
 
 class StepAction(QAction):
 
     def __init__(self, scripter, toolbar, parent=None):
         super(StepAction, self).__init__(parent)
         self.scripter = scripter
         self.toolbar = toolbar
 
         self.triggered.connect(self.step)
 
-        self.setText('Step Over')
+        self.setText(i18n("Step Over"))
         # path to the icon
         self.setIcon(QIcon(':/icons/step.svg'))
 
     def step(self):
         status = self.scripter.debugcontroller.isActive
         if status:
             self.scripter.debugcontroller.step()
         else:
             self.toolbar.disableToolbar(True)
diff --git a/plugins/python/scripter/ui_scripter/tabwidgets/debuggerwidget/stopaction.py b/plugins/python/scripter/ui_scripter/tabwidgets/debuggerwidget/stopaction.py
index 47aeb8d5cc..1d49380919 100644
--- a/plugins/python/scripter/ui_scripter/tabwidgets/debuggerwidget/stopaction.py
+++ b/plugins/python/scripter/ui_scripter/tabwidgets/debuggerwidget/stopaction.py
@@ -1,38 +1,39 @@
 """
 Copyright (c) 2017 Eliakin Costa <eliakim170@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 """
 from PyQt5.QtWidgets import QAction
 from PyQt5.QtGui import QIcon
 from scripter import resources_rc
+import krita
 
 
 class StopAction(QAction):
 
     def __init__(self, scripter, toolbar, parent=None):
         super(StopAction, self).__init__(parent)
         self.scripter = scripter
         self.toolbar = toolbar
 
         self.triggered.connect(self.stop)
 
-        self.setText('Stop')
+        self.setText(i18n("Stop"))
         # path to the icon
         self.setIcon(QIcon(':/icons/stop.svg'))
 
     def stop(self):
         self.scripter.debugcontroller.stop()
         self.toolbar.disableToolbar(True)
diff --git a/plugins/python/scripter/ui_scripter/tabwidgets/outputwidget/clearaction.py b/plugins/python/scripter/ui_scripter/tabwidgets/outputwidget/clearaction.py
index c86ec7eea0..d23bc3fba0 100644
--- a/plugins/python/scripter/ui_scripter/tabwidgets/outputwidget/clearaction.py
+++ b/plugins/python/scripter/ui_scripter/tabwidgets/outputwidget/clearaction.py
@@ -1,37 +1,38 @@
 """
 Copyright (c) 2017 Eliakin Costa <eliakim170@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 """
 from PyQt5.QtWidgets import QAction
 from PyQt5.QtGui import QIcon
 from scripter import resources_rc
+import krita
 
 
 class ClearAction(QAction):
 
     def __init__(self, scripter, toolbar, parent=None):
         super(ClearAction, self).__init__(parent)
         self.scripter = scripter
         self.toolbar = toolbar
 
         self.triggered.connect(self.clear)
 
-        self.setText('Clear')
+        self.setText(i18n("Clear"))
         # path to the icon
         # self.setIcon(QIcon(':/icons/clear.svg'))
 
     def clear(self):
         self.toolbar.outputtextedit.clear()
diff --git a/plugins/python/scripter/uicontroller.py b/plugins/python/scripter/uicontroller.py
index e02cabb330..d663c355ca 100644
--- a/plugins/python/scripter/uicontroller.py
+++ b/plugins/python/scripter/uicontroller.py
@@ -1,264 +1,265 @@
 """
 Copyright (c) 2017 Eliakin Costa <eliakim170@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 """
 from PyQt5.QtCore import Qt, QObject, QFileInfo, QRect
 from PyQt5.QtGui import QTextCursor, QPalette
 from PyQt5.QtWidgets import (QToolBar, QMenuBar, QTabWidget,
                              QLabel, QVBoxLayout, QMessageBox,
                              QSplitter, QSizePolicy)
 from .ui_scripter.syntax import syntax, syntaxstyles
 from .ui_scripter.editor import pythoneditor
 from . import scripterdialog
 import importlib
+import krita
 
 KEY_GEOMETRY = "geometry"
 DEFAULT_GEOMETRY = QRect(600, 200, 400, 500)
 # essentially randomly placed
 
 
 class Elided_Text_Label(QLabel):
     mainText = str()
 
     def __init__(self, parent=None):
         super(QLabel, self).__init__(parent)
         self.setMinimumWidth(self.fontMetrics().width("..."))
         self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
 
     def setMainText(self, text=str()):
         self.mainText = text
         self.elideText()
 
     def elideText(self):
         self.setText(self.fontMetrics().elidedText(self.mainText, Qt.ElideRight, self.width()))
 
     def resizeEvent(self, event):
         self.elideText()
 
 
 class UIController(object):
     documentModifiedText = ""
     documentStatusBarText = "untitled"
 
     def __init__(self):
         self.mainWidget = scripterdialog.ScripterDialog(self)
         self.actionToolbar = QToolBar('toolBar', self.mainWidget)
         self.menu_bar = QMenuBar(self.mainWidget)
 
         self.actionToolbar.setObjectName('toolBar')
         self.menu_bar.setObjectName('menuBar')
 
         self.actions = []
 
         self.mainWidget.setWindowModality(Qt.NonModal)
 
     def initialize(self, scripter):
         self.editor = pythoneditor.CodeEditor(scripter)
         self.tabWidget = QTabWidget()
         self.statusBar = Elided_Text_Label()
         self.statusBar.setMainText('untitled')
         self.splitter = QSplitter()
         self.splitter.setOrientation(Qt.Vertical)
         self.highlight = syntax.PythonHighlighter(self.editor.document(), syntaxstyles.DefaultSyntaxStyle())
         p = self.editor.palette()
         p.setColor(QPalette.Base, syntaxstyles.DefaultSyntaxStyle()['background'].foreground().color())
         p.setColor(QPalette.Text, syntaxstyles.DefaultSyntaxStyle()['foreground'].foreground().color())
         self.editor.setPalette(p)
 
         self.scripter = scripter
 
         self.loadMenus()
         self.loadWidgets()
         self.loadActions()
         self._readSettings()  # sets window size
 
         vbox = QVBoxLayout(self.mainWidget)
         vbox.addWidget(self.menu_bar)
         vbox.addWidget(self.actionToolbar)
         self.splitter.addWidget(self.editor)
         self.splitter.addWidget(self.tabWidget)
         vbox.addWidget(self.splitter)
         vbox.addWidget(self.statusBar)
 
-        self.mainWidget.setWindowTitle("Scripter")
+        self.mainWidget.setWindowTitle(i18n("Scripter"))
         self.mainWidget.setSizeGripEnabled(True)
         self.mainWidget.show()
         self.mainWidget.activateWindow()
 
         self.editor.undoAvailable.connect(self.setStatusModified)
 
     def loadMenus(self):
         self.addMenu('File', 'File')
 
     def addMenu(self, menuName, parentName):
         parent = self.menu_bar.findChild(QObject, parentName)
         self.newMenu = None
 
         if parent:
             self.newMenu = parent.addMenu(menuName)
         else:
             self.newMenu = self.menu_bar.addMenu(menuName)
 
         self.newMenu.setObjectName(menuName)
 
         return self.newMenu
 
     def loadActions(self):
         module_path = 'scripter.ui_scripter.actions'
         actions_module = importlib.import_module(module_path)
         modules = []
 
         for class_path in actions_module.action_classes:
             _module = class_path[:class_path.rfind(".")]
             _klass = class_path[class_path.rfind(".") + 1:]
             modules.append(dict(module='{0}.{1}'.format(module_path, _module),
                                 klass=_klass))
 
         for module in modules:
             m = importlib.import_module(module['module'])
             action_class = getattr(m, module['klass'])
             obj = action_class(self.scripter)
             parent = self.mainWidget.findChild(QObject, obj.parent)
             self.actions.append(dict(action=obj, parent=parent))
 
         for action in self.actions:
             action['parent'].addAction(action['action'])
 
     def loadWidgets(self):
         modulePath = 'scripter.ui_scripter.tabwidgets'
         widgetsModule = importlib.import_module(modulePath)
         modules = []
 
         for class_path in widgetsModule.widgetClasses:
             _module = class_path[:class_path.rfind(".")]
             _klass = class_path[class_path.rfind(".") + 1:]
             modules.append(dict(module='{0}.{1}'.format(modulePath, _module),
                                 klass=_klass))
 
         for module in modules:
             m = importlib.import_module(module['module'])
             widgetClass = getattr(m, module['klass'])
             obj = widgetClass(self.scripter)
             self.tabWidget.addTab(obj, obj.objectName())
 
     def invokeAction(self, actionName):
         for action in self.actions:
             if action['action'].objectName() == actionName:
                 method = getattr(action['action'], actionName)
                 if method:
                     return method()
 
     def findTabWidget(self, widgetName, childName=''):
         for index in range(self.tabWidget.count()):
             widget = self.tabWidget.widget(index)
             if widget.objectName() == widgetName:
                 if childName:
                     widget = widget.findChild(QObject, childName)
                 return widget
 
     def showException(self, exception):
-        QMessageBox.critical(self.editor, "Error running script", str(exception))
+        QMessageBox.critical(self.editor, i18n("Error Running Script"), str(exception))
 
     def setDocumentEditor(self, document):
         self.editor.clear()
         self.editor.moveCursor(QTextCursor.Start)
         self.editor._documentModified = False
         self.editor.setPlainText(document.data)
         self.editor.moveCursor(QTextCursor.End)
 
     def setStatusBar(self, value='untitled'):
         self.documentStatusBarText = value
         self.statusBar.setMainText(self.documentStatusBarText + self.documentModifiedText)
 
     def setStatusModified(self):
         self.documentModifiedText = ""
         if (self.editor._documentModified is True):
             self.documentModifiedText = " [Modified]"
         self.statusBar.setMainText(self.documentStatusBarText + self.documentModifiedText)
 
     def setActiveWidget(self, widgetName):
         widget = self.findTabWidget(widgetName)
 
         if widget:
             self.tabWidget.setCurrentWidget(widget)
 
     def setStepped(self, status):
         self.editor.setStepped(status)
 
     def clearEditor(self):
         self.editor.clear()
 
     def repaintDebugArea(self):
         self.editor.repaintDebugArea()
 
     def closeScripter(self):
         self.mainWidget.close()
 
     def _writeSettings(self):
         """ _writeSettings is a method invoked when the scripter starts, making
             control inversion. Actions can implement a writeSettings method to
             save your own settings without this method to know about it. """
 
         self.scripter.settings.beginGroup('scripter')
 
         document = self.scripter.documentcontroller.activeDocument
         if document:
             self.scripter.settings.setValue('activeDocumentPath', document.filePath)
         else:
             self.scripter.settings.setValue('activeDocumentPath', '')
 
         self.scripter.settings.setValue('editorFontSize', self.editor.fontInfo().pointSize())
 
         for action in self.actions:
             writeSettings = getattr(action['action'], "writeSettings", None)
             if callable(writeSettings):
                 writeSettings()
 
         #  Window Geometry
         rect = self.mainWidget.geometry()
         self.scripter.settings.setValue(KEY_GEOMETRY, rect)
 
         self.scripter.settings.endGroup()
 
     def _readSettings(self):
         """ It's similar to _writeSettings, but reading the settings when the ScripterDialog is closed. """
 
         self.scripter.settings.beginGroup('scripter')
 
         activeDocumentPath = self.scripter.settings.value('activeDocumentPath', '')
 
         if activeDocumentPath:
             if QFileInfo(activeDocumentPath).exists():
                 document = self.scripter.documentcontroller.openDocument(activeDocumentPath)
                 self.setStatusBar(document.filePath)
                 self.setDocumentEditor(document)
 
         for action in self.actions:
             readSettings = getattr(action['action'], "readSettings", None)
             if callable(readSettings):
                 readSettings()
 
         pointSize = self.scripter.settings.value('editorFontSize', str(self.editor.fontInfo().pointSize()))
         self.editor.setFontSize(int(pointSize))
 
         # Window Geometry
         rect = self.scripter.settings.value(KEY_GEOMETRY, DEFAULT_GEOMETRY)
         self.mainWidget.setGeometry(rect)
 
         self.scripter.settings.endGroup()
 
     def _saveSettings(self):
         self.scripter.settings.sync()
diff --git a/plugins/python/selectionsbagdocker/selectionsbagdocker.py b/plugins/python/selectionsbagdocker/selectionsbagdocker.py
index 78784353e4..5d90cfedb2 100644
--- a/plugins/python/selectionsbagdocker/selectionsbagdocker.py
+++ b/plugins/python/selectionsbagdocker/selectionsbagdocker.py
@@ -1,31 +1,31 @@
 '''
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 '''
 from PyQt5.QtCore import *
 from PyQt5.QtGui import *
 from PyQt5.QtWidgets import *
 
 from PyQt5 import uic
 from krita import *
 import os
 
 
 class SelectionsBagDocker(DockWidget):
 
     def __init__(self):
         super().__init__()
         widget = QWidget(self)
         uic.loadUi(os.path.dirname(os.path.realpath(__file__)) + '/selectionsbagdocker.ui', widget)
         self.setWidget(widget)
-        self.setWindowTitle("Selections bag")
+        self.setWindowTitle(i18n("Selections Bag"))
 
     def canvasChanged(self, canvas):
         print("Canvas", canvas)
diff --git a/plugins/tools/basictools/kis_tool_colorpicker.cc b/plugins/tools/basictools/kis_tool_colorpicker.cc
index d5d981ffc0..9b3487da52 100644
--- a/plugins/tools/basictools/kis_tool_colorpicker.cc
+++ b/plugins/tools/basictools/kis_tool_colorpicker.cc
@@ -1,350 +1,350 @@
 /*
  *  Copyright (c) 1999 Matthias Elter <me@kde.org>
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2010 Lukáš Tvrdý <lukast.dev@gmail.com>
  *  Copyright (c) 2018 Emmet & Eoin O'Neill <emmetoneill.pdx@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_tool_colorpicker.h"
 
 #include <boost/thread/locks.hpp>
 #include <QMessageBox>
 #include "kis_cursor.h"
 #include "KisDocument.h"
 #include "kis_canvas2.h"
 #include "KisReferenceImagesLayer.h"
 #include "KoCanvasBase.h"
 #include "kis_random_accessor_ng.h"
 #include "KoResourceServerProvider.h"
 #include <KoMixColorsOp.h>
 #include "kis_wrapped_rect.h"
 #include "kis_tool_utils.h"
 
 namespace
 {
 // GUI ComboBox index constants
 const int SAMPLE_MERGED = 0;
 }
 
 KisToolColorPicker::KisToolColorPicker(KoCanvasBase *canvas)
     : KisTool(canvas, KisCursor::pickerCursor()),
       m_config(new KisToolUtils::ColorPickerConfig)
 {
     setObjectName("tool_colorpicker");
     m_isActivated = false;
     m_optionsWidget = 0;
     m_pickedColor = KoColor();
 }
 
 KisToolColorPicker::~KisToolColorPicker()
 {
     if (m_isActivated) {
         m_config->save(m_toolActivationSource == KisTool::DefaultActivation);
     }
 }
 
 void KisToolColorPicker::paint(QPainter &gc, const KoViewConverter &converter)
 {
     Q_UNUSED(gc);
     Q_UNUSED(converter);
 }
 
 void KisToolColorPicker::activate(ToolActivation activation, const QSet<KoShape*> &shapes)
 {
     m_isActivated = true;
     m_toolActivationSource = activation;
     m_config->load(m_toolActivationSource == KisTool::DefaultActivation);
     updateOptionWidget();
 
     KisTool::activate(activation, shapes);
 }
 
 void KisToolColorPicker::deactivate()
 {
     m_config->save(m_toolActivationSource == KisTool::DefaultActivation);
     m_isActivated = false;
     KisTool::deactivate();
 }
 
 void KisToolColorPicker::pickColor(const QPointF &pos)
 {
     // Timer check.
     if (m_colorPickerDelayTimer.isActive()) {
         return;
     }
     else {
         m_colorPickerDelayTimer.setSingleShot(true);
         m_colorPickerDelayTimer.start(100);
     }
 
     QScopedPointer<boost::lock_guard<KisImage>> imageLocker;
 
     m_pickedColor.setOpacity(0.0);
 
     // Pick from reference images.
     if (m_optionsWidget->cmbSources->currentIndex() == SAMPLE_MERGED) {
         auto *kisCanvas = dynamic_cast<KisCanvas2 *>(canvas());
         KIS_SAFE_ASSERT_RECOVER_RETURN(kisCanvas);
-        KisReferenceImagesLayer *referenceImageLayer =
+        KisSharedPtr<KisReferenceImagesLayer> referenceImageLayer =
             kisCanvas->imageView()->document()->referenceImagesLayer();
 
         if (referenceImageLayer) {
             QColor color = referenceImageLayer->getPixel(pos);
             if (color.isValid()) {
                 m_pickedColor.fromQColor(color);
             }
         }
     }
 
     if (m_pickedColor.opacityU8() == OPACITY_TRANSPARENT_U8) {
         KisPaintDeviceSP dev;
 
         if (m_optionsWidget->cmbSources->currentIndex() != SAMPLE_MERGED &&
             currentNode() && currentNode()->colorPickSourceDevice()) {
             dev = currentNode()->colorPickSourceDevice();
         }
         else {
             imageLocker.reset(new boost::lock_guard<KisImage>(*currentImage()));
             dev = currentImage()->projection();
         }
 
         KoColor previousColor = canvas()->resourceManager()->foregroundColor();
 
         KisToolUtils::pickColor(m_pickedColor, dev, pos.toPoint(), &previousColor, m_config->radius, m_config->blend); /*!*/
 
         if (m_config->updateColor &&
                 m_pickedColor.opacityU8() != OPACITY_TRANSPARENT_U8) {
 
             KoColor publicColor = m_pickedColor;
             publicColor.setOpacity(OPACITY_OPAQUE_U8);
 
             if (m_config->toForegroundColor) {
                 canvas()->resourceManager()->setResource(KoCanvasResourceManager::ForegroundColor, publicColor);
             }
             else {
                 canvas()->resourceManager()->setResource(KoCanvasResourceManager::BackgroundColor, publicColor);
             }
         }
     }
 }
 
 void KisToolColorPicker::beginPrimaryAction(KoPointerEvent *event)
 {
     bool sampleMerged = m_optionsWidget->cmbSources->currentIndex() == SAMPLE_MERGED;
     if (!sampleMerged) {
         if (!currentNode()) {
             QMessageBox::information(0, i18nc("@title:window", "Krita"), i18n("Cannot pick a color as no layer is active."));
             event->ignore();
             return;
         }
         if (!currentNode()->visible()) {
             QMessageBox::information(0, i18nc("@title:window", "Krita"), i18n("Cannot pick a color as the active layer is not visible."));
             event->ignore();
             return;
         }
     }
 
     QPoint pos = convertToImagePixelCoordFloored(event);
     // Color picking has to start in the visible part of the layer
     if (!currentImage()->bounds().contains(pos) &&
         !currentImage()->wrapAroundModePermitted()) {
         event->ignore();
         return;
     }
 
     setMode(KisTool::PAINT_MODE);
     pickColor(pos);
     displayPickedColor();
 }
 
 void KisToolColorPicker::continuePrimaryAction(KoPointerEvent *event)
 {
     CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
 
     QPoint pos = convertToImagePixelCoordFloored(event);
     pickColor(pos);
     displayPickedColor();
 }
 
 void KisToolColorPicker::endPrimaryAction(KoPointerEvent *event)
 {
     Q_UNUSED(event);
     CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
 
     if (m_config->addPalette) {
         KoColorSetEntry ent;
         ent.setColor(m_pickedColor);
         // We don't ask for a name, too intrusive here
 
         KoColorSet *palette = m_palettes.at(m_optionsWidget->cmbPalette->currentIndex());
         palette->add(ent);
 
         if (!palette->save()) {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Cannot write to palette file %1. Maybe it is read-only.", palette->filename()));
         }
     }
 }
 
 struct PickedChannel {
     QString name;
     QString valueText;
 };
 
 void KisToolColorPicker::displayPickedColor()
 {
     if (m_pickedColor.data() && m_optionsWidget) {
 
         QList<KoChannelInfo *> channels = m_pickedColor.colorSpace()->channels();
         m_optionsWidget->listViewChannels->clear();
 
         QVector<PickedChannel> pickedChannels;
         for (int i = 0; i < channels.count(); ++i) {
             pickedChannels.append(PickedChannel());
         }
 
         for (int i = 0; i < channels.count(); ++i) {
 
             PickedChannel pc;
             pc.name = channels[i]->name();
 
             if (m_config->normaliseValues) {
                 pc.valueText = m_pickedColor.colorSpace()->normalisedChannelValueText(m_pickedColor.data(), i);
             } else {
                 pc.valueText = m_pickedColor.colorSpace()->channelValueText(m_pickedColor.data(), i);
             }
 
             pickedChannels[channels[i]->displayPosition()] = pc;
 
         }
 
         Q_FOREACH (const PickedChannel &pc, pickedChannels) {
             QTreeWidgetItem *item = new QTreeWidgetItem(m_optionsWidget->listViewChannels);
             item->setText(0, pc.name);
             item->setText(1, pc.valueText);
         }
     }
 }
 
 QWidget* KisToolColorPicker::createOptionWidget()
 {
     m_optionsWidget = new ColorPickerOptionsWidget(0);
     m_optionsWidget->setObjectName(toolId() + " option widget");
     m_optionsWidget->listViewChannels->setSortingEnabled(false);
 
     // See https://bugs.kde.org/show_bug.cgi?id=316896
     QWidget *specialSpacer = new QWidget(m_optionsWidget);
     specialSpacer->setObjectName("SpecialSpacer");
     specialSpacer->setFixedSize(0, 0);
     m_optionsWidget->layout()->addWidget(specialSpacer);
 
     // Initialize blend KisSliderSpinBox
     m_optionsWidget->blend->setRange(0,100);
     m_optionsWidget->blend->setSuffix("%");
 
     updateOptionWidget();
 
     connect(m_optionsWidget->cbUpdateCurrentColor, SIGNAL(toggled(bool)), SLOT(slotSetUpdateColor(bool)));
     connect(m_optionsWidget->cbNormaliseValues, SIGNAL(toggled(bool)), SLOT(slotSetNormaliseValues(bool)));
     connect(m_optionsWidget->cbPalette, SIGNAL(toggled(bool)),
             SLOT(slotSetAddPalette(bool)));
     connect(m_optionsWidget->radius, SIGNAL(valueChanged(int)),
             SLOT(slotChangeRadius(int)));
     connect(m_optionsWidget->blend, SIGNAL(valueChanged(int)),
             SLOT(slotChangeBlend(int)));
     connect(m_optionsWidget->cmbSources, SIGNAL(currentIndexChanged(int)),
             SLOT(slotSetColorSource(int)));
 
     KoResourceServer<KoColorSet> *srv = KoResourceServerProvider::instance()->paletteServer();
 
     if (!srv) {
         return m_optionsWidget;
     }
 
     QList<KoColorSet*> palettes = srv->resources();
 
     Q_FOREACH (KoColorSet *palette, palettes) {
         if (palette) {
             m_optionsWidget->cmbPalette->addSqueezedItem(palette->name());
             m_palettes.append(palette);
         }
     }
 
     return m_optionsWidget;
 }
 
 void KisToolColorPicker::updateOptionWidget()
 {
     if (!m_optionsWidget) return;
 
     m_optionsWidget->cbNormaliseValues->setChecked(m_config->normaliseValues);
     m_optionsWidget->cbUpdateCurrentColor->setChecked(m_config->updateColor);
     m_optionsWidget->cmbSources->setCurrentIndex(SAMPLE_MERGED + !m_config->sampleMerged);
     m_optionsWidget->cbPalette->setChecked(m_config->addPalette);
     m_optionsWidget->radius->setValue(m_config->radius);
     m_optionsWidget->blend->setValue(m_config->blend);
 }
 
 void KisToolColorPicker::setToForeground(bool newValue)
 {
     m_config->toForegroundColor = newValue;
     emit toForegroundChanged();
 }
 
 bool KisToolColorPicker::toForeground() const
 {
     return m_config->toForegroundColor;
 }
 
 void KisToolColorPicker::slotSetUpdateColor(bool state)
 {
     m_config->updateColor = state;
 }
 
 void KisToolColorPicker::slotSetNormaliseValues(bool state)
 {
     m_config->normaliseValues = state;
     displayPickedColor();
 }
 
 void KisToolColorPicker::slotSetAddPalette(bool state)
 {
     m_config->addPalette = state;
 }
 
 void KisToolColorPicker::slotChangeRadius(int value)
 {
     m_config->radius = value;
 }
 
 void KisToolColorPicker::slotChangeBlend(int value)
 {
     m_config->blend = value;
 }
 
 void KisToolColorPicker::slotSetColorSource(int value)
 {
     m_config->sampleMerged = value == SAMPLE_MERGED;
 }
 
 void KisToolColorPicker::slotAddPalette(KoResource *resource)
 {
     KoColorSet *palette = dynamic_cast<KoColorSet*>(resource);
     if (palette) {
         m_optionsWidget->cmbPalette->addSqueezedItem(palette->name());
         m_palettes.append(palette);
     }
 }
diff --git a/plugins/tools/defaulttool/referenceimagestool/ToolReferenceImages.cpp b/plugins/tools/defaulttool/referenceimagestool/ToolReferenceImages.cpp
index d9ee6bc26a..d339ce9e79 100644
--- a/plugins/tools/defaulttool/referenceimagestool/ToolReferenceImages.cpp
+++ b/plugins/tools/defaulttool/referenceimagestool/ToolReferenceImages.cpp
@@ -1,229 +1,262 @@
 /*
  * Copyright (c) 2017 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2.1 of the License.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "ToolReferenceImages.h"
 
 #include <QDesktopServices>
 #include <QFile>
 #include <QLayout>
 #include <QMenu>
 #include <QMessageBox>
 #include <QVector>
 
+#include <KoSelection.h>
 #include <KoShapeRegistry.h>
 #include <KoShapeManager.h>
 #include <KoShapeController.h>
 #include <KoFileDialog.h>
 
 #include <kis_canvas2.h>
 #include <kis_canvas_resource_provider.h>
 #include <KisViewManager.h>
 #include <KisDocument.h>
 #include <KisReferenceImagesLayer.h>
+#include <kis_image.h>
 
 #include "ToolReferenceImagesWidget.h"
 #include "KisReferenceImageCollection.h"
 
 ToolReferenceImages::ToolReferenceImages(KoCanvasBase * canvas)
     : DefaultTool(canvas)
 {
     setObjectName("ToolReferenceImages");
 }
 
 ToolReferenceImages::~ToolReferenceImages()
 {
 }
 
 void ToolReferenceImages::activate(ToolActivation toolActivation, const QSet<KoShape*> &shapes)
 {
-    // Add code here to initialize your tool when it got activated
     DefaultTool::activate(toolActivation, shapes);
 
-    KisReferenceImagesLayer *layer = getOrCreateReferenceImagesLayer();
-    connect(layer, SIGNAL(selectionChanged()), this, SLOT(slotSelectionChanged()));
+    auto kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
+    connect(kisCanvas->image(), SIGNAL(sigNodeAddedAsync(KisNodeSP)), this, SLOT(slotNodeAdded(KisNodeSP)));
+
+    auto referenceImageLayer = document()->referenceImagesLayer();
+    if (referenceImageLayer) {
+        setReferenceImageLayer(referenceImageLayer);
+    }
 }
 
 void ToolReferenceImages::deactivate()
 {
     DefaultTool::deactivate();
 }
 
+void ToolReferenceImages::slotNodeAdded(KisNodeSP node)
+{
+    auto *referenceImagesLayer = dynamic_cast<KisReferenceImagesLayer*>(node.data());
+
+    if (referenceImagesLayer) {
+        setReferenceImageLayer(referenceImagesLayer);
+    }
+}
+
+void ToolReferenceImages::setReferenceImageLayer(KisSharedPtr<KisReferenceImagesLayer> layer)
+{
+    m_layer = layer;
+    connect(layer.data(), SIGNAL(selectionChanged()), this, SLOT(slotSelectionChanged()));
+}
+
 void ToolReferenceImages::addReferenceImage()
 {
     auto kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     KIS_ASSERT_RECOVER_RETURN(kisCanvas)
 
     KoFileDialog dialog(kisCanvas->viewManager()->mainWindow(), KoFileDialog::OpenFile, "OpenReferenceImage");
     dialog.setCaption(i18n("Select a Reference Image"));
 
     QStringList locations = QStandardPaths::standardLocations(QStandardPaths::PicturesLocation);
     if (!locations.isEmpty()) {
         dialog.setDefaultDir(locations.first());
     }
 
     QString filename = dialog.filename();
     if (filename.isEmpty()) return;
     if (!QFileInfo(filename).exists()) return;
 
     auto *reference = KisReferenceImage::fromFile(filename, *kisCanvas->coordinatesConverter());
-    KisReferenceImagesLayer *layer = getOrCreateReferenceImagesLayer();
-    kisCanvas->imageView()->document()->addCommand(layer->addReferenceImage(reference));
+
+    KisDocument *doc = document();
+    doc->addCommand(KisReferenceImagesLayer::addReferenceImages(doc, {reference}));
 }
 
 void ToolReferenceImages::removeAllReferenceImages()
 {
-    KisReferenceImagesLayer *layer = getOrCreateReferenceImagesLayer();
-    canvas()->addCommand(canvas()->shapeController()->removeShapes(layer->shapes()));
+    auto layer = m_layer.toStrongRef();
+    if (!layer) return;
+
+    canvas()->addCommand(layer->removeReferenceImages(document(), layer->shapes()));
 }
 
 void ToolReferenceImages::loadReferenceImages()
 {
-      auto kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
+    auto kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     KIS_ASSERT_RECOVER_RETURN(kisCanvas)
 
     KoFileDialog dialog(kisCanvas->viewManager()->mainWindow(), KoFileDialog::OpenFile, "OpenReferenceImageCollection");
     dialog.setMimeTypeFilters(QStringList() << "application/x-krita-reference-images");
     dialog.setCaption(i18n("Load Reference Images"));
 
     QStringList locations = QStandardPaths::standardLocations(QStandardPaths::PicturesLocation);
     if (!locations.isEmpty()) {
         dialog.setDefaultDir(locations.first());
     }
 
     QString filename = dialog.filename();
     if (filename.isEmpty()) return;
     if (!QFileInfo(filename).exists()) return;
 
     QFile file(filename);
     if (!file.open(QIODevice::ReadOnly)) {
         QMessageBox::critical(nullptr, i18nc("@title:window", "Krita"), i18n("Could not open '%1'.", filename));
         return;
     }
 
     KisReferenceImageCollection collection;
     if (collection.load(&file)) {
-        KisReferenceImagesLayer *layer = referenceImagesLayer();
-
-        Q_FOREACH(KisReferenceImage *reference, collection.referenceImages()) {
-            layer->addShape(reference);
+        QList<KoShape*> shapes;
+        Q_FOREACH(auto *reference, collection.referenceImages()) {
+            shapes.append(reference);
         }
+
+        KisDocument *doc = document();
+        doc->addCommand(KisReferenceImagesLayer::addReferenceImages(doc, shapes));
     } else {
         QMessageBox::critical(nullptr, i18nc("@title:window", "Krita"), i18n("Could not load reference images from '%1'.", filename));
     }
     file.close();
 }
 
 void ToolReferenceImages::saveReferenceImages()
 {
+    auto layer = m_layer.toStrongRef();
+    if (!layer || layer->shapeCount() == 0) return;
+
     auto kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     KIS_ASSERT_RECOVER_RETURN(kisCanvas)
 
     KoFileDialog dialog(kisCanvas->viewManager()->mainWindow(), KoFileDialog::SaveFile, "SaveReferenceImageCollection");
     dialog.setMimeTypeFilters(QStringList() << "application/x-krita-reference-images");
     dialog.setCaption(i18n("Save Reference Images"));
 
     QStringList locations = QStandardPaths::standardLocations(QStandardPaths::PicturesLocation);
     if (!locations.isEmpty()) {
         dialog.setDefaultDir(locations.first());
     }
 
     QString filename = dialog.filename();
     if (filename.isEmpty()) return;
 
     QFile file(filename);
     if (!file.open(QIODevice::WriteOnly)) {
         QMessageBox::critical(nullptr, i18nc("@title:window", "Krita"), i18n("Could not open '%1' for saving.", filename));
         return;
     }
 
-    KisReferenceImageCollection collection(referenceImagesLayer()->referenceImages());
+    KisReferenceImageCollection collection(layer->referenceImages());
     bool ok = collection.save(&file);
     file.close();
 
     if (!ok) {
         QMessageBox::critical(nullptr, i18nc("@title:window", "Krita"), i18n("Failed to save reference images.", filename));
     }
 }
 
 void ToolReferenceImages::slotSelectionChanged()
 {
-    KisReferenceImagesLayer *layer = getOrCreateReferenceImagesLayer();
+    auto layer = m_layer.toStrongRef();
+    if (!layer) return;
+
     m_optionsWidget->selectionChanged(layer->shapeManager()->selection());
     updateActions();
 }
 
 QList<QPointer<QWidget>> ToolReferenceImages::createOptionWidgets()
 {
     // Instead of inheriting DefaultTool's multi-tab implementation, inherit straight from KoToolBase
     return KoToolBase::createOptionWidgets();
 }
 
 QWidget *ToolReferenceImages::createOptionWidget()
 {
     if (!m_optionsWidget) {
         m_optionsWidget = new ToolReferenceImagesWidget(this);
         // See https://bugs.kde.org/show_bug.cgi?id=316896
         QWidget *specialSpacer = new QWidget(m_optionsWidget);
         specialSpacer->setObjectName("SpecialSpacer");
         specialSpacer->setFixedSize(0, 0);
         m_optionsWidget->layout()->addWidget(specialSpacer);
     }
     return m_optionsWidget;
  }
 
 bool ToolReferenceImages::isValidForCurrentLayer() const
 {
     return true;
 }
 
 KoShapeManager *ToolReferenceImages::shapeManager() const
 {
-    auto layer = referenceImagesLayer();
-    return layer ? referenceImagesLayer()->shapeManager() : nullptr;
-}
-
-KisReferenceImagesLayer *ToolReferenceImages::referenceImagesLayer() const
-{
-    auto kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
-    KisDocument *document = kisCanvas->imageView()->document();
-
-    return document->referenceImagesLayer();
-}
-
-KisReferenceImagesLayer *ToolReferenceImages::getOrCreateReferenceImagesLayer()
-{
-    auto kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
-    KisDocument *document = kisCanvas->imageView()->document();
-
-    return document->getOrCreateReferenceImagesLayer().data();
+    auto layer = m_layer.toStrongRef();
+    return layer ? layer->shapeManager() : nullptr;
 }
 
 KoSelection *ToolReferenceImages::koSelection() const
 {
     auto manager = shapeManager();
     return manager ? manager->selection() : nullptr;
 }
 
 void ToolReferenceImages::updateDistinctiveActions(const QList<KoShape*> &)
 {
     action("object_group")->setEnabled(false);
     action("object_unite")->setEnabled(false);
     action("object_intersect")->setEnabled(false);
     action("object_subtract")->setEnabled(false);
     action("object_split")->setEnabled(false);
     action("object_ungroup")->setEnabled(false);
 }
+
+void ToolReferenceImages::deleteSelection()
+{
+    auto layer = m_layer.toStrongRef();
+    if (!layer) return;
+
+    QList<KoShape *> shapes = koSelection()->selectedShapes();
+
+    if (!shapes.empty()) {
+        canvas()->addCommand(layer->removeReferenceImages(document(), shapes));
+    }
+}
+
+KisDocument *ToolReferenceImages::document() const
+{
+    auto kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
+    return kisCanvas->imageView()->document();
+}
diff --git a/plugins/tools/defaulttool/referenceimagestool/ToolReferenceImages.h b/plugins/tools/defaulttool/referenceimagestool/ToolReferenceImages.h
index 90feeef4b1..3b3ab30fe5 100644
--- a/plugins/tools/defaulttool/referenceimagestool/ToolReferenceImages.h
+++ b/plugins/tools/defaulttool/referenceimagestool/ToolReferenceImages.h
@@ -1,103 +1,107 @@
 /*
  * Copyright (c) 2017 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2.1 of the License.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef TOOL_REFERENCE_IMAGES_H
 #define TOOL_REFERENCE_IMAGES_H
 
 #include <QPointer>
 
 #include <KoToolFactoryBase.h>
 #include <KoIcon.h>
 
 #include <kis_tool.h>
 #include "kis_painting_assistant.h"
 #include <kis_icon.h>
 #include <kis_canvas2.h>
 
 #include <defaulttool/DefaultTool.h>
 
 class ToolReferenceImagesWidget;
 class KisReferenceImagesLayer;
 
 class ToolReferenceImages : public DefaultTool
 {
     Q_OBJECT
 
 public:
     ToolReferenceImages(KoCanvasBase * canvas);
     ~ToolReferenceImages() override;
 
     virtual quint32 priority() {
         return 3;
     }
 
     void mouseDoubleClickEvent(KoPointerEvent */*event*/) override {}
 
+    void deleteSelection() override;
+
 protected:
     QList<QPointer<QWidget>> createOptionWidgets() override;
     QWidget *createOptionWidget() override;
 
     bool isValidForCurrentLayer() const override;
     KoShapeManager *shapeManager() const override;
     KoSelection *koSelection() const override;
 
     void updateDistinctiveActions(const QList<KoShape*> &editableShapes) override;
 
 public Q_SLOTS:
     void activate(ToolActivation toolActivation, const QSet<KoShape*> &shapes) override;
     void deactivate() override;
 
     void addReferenceImage();
     void removeAllReferenceImages();
     void saveReferenceImages();
     void loadReferenceImages();
 
+    void slotNodeAdded(KisNodeSP node);
     void slotSelectionChanged();
 
 private:
     friend class ToolReferenceImagesWidget;
     ToolReferenceImagesWidget *m_optionsWidget = nullptr;
+    KisWeakSharedPtr<KisReferenceImagesLayer> m_layer;
 
-    KisReferenceImagesLayer *referenceImagesLayer() const;
-    KisReferenceImagesLayer *getOrCreateReferenceImagesLayer();
+    KisDocument *document() const;
+    void setReferenceImageLayer(KisSharedPtr<KisReferenceImagesLayer> layer);
 };
 
 
 class ToolReferenceImagesFactory : public KoToolFactoryBase
 {
 public:
     ToolReferenceImagesFactory()
     : KoToolFactoryBase("ToolReferenceImages") {
         setToolTip(i18n("Reference Images Tool"));
         setSection(TOOL_TYPE_VIEW);
         setIconName(koIconNameCStr("krita_tool_reference_images"));
-        setPriority(0);
+        setPriority(2);
         setActivationShapeId(KRITA_TOOL_ACTIVATION_ID);
     };
 
 
     ~ToolReferenceImagesFactory() override {}
 
     KoToolBase * createTool(KoCanvasBase * canvas) override {
         return new ToolReferenceImages(canvas);
     }
 
 };
 
 
 #endif