diff --git a/CMakeLists.txt b/CMakeLists.txt
index 52404ea16d..c151aad813 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,640 +1,639 @@
 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)
 option(OVERRIDE_QT_VERSION "Use this to make it possible to build with Qt < 5.6.0. There will be bugs." OFF)
 if (OVERRIDE_QT_VERSION)
     set(MIN_QT_VERSION 5.4.0)
 endif()
 
 set(MIN_FRAMEWORKS_VERSION 5.7.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.9 -Wno-deprecated-register)
 endif()
 
  ######################
 #######################
 ## Constants defines ##
 #######################
 ######################
 
 # define common versions of Krita applications, used to generate kritaversion.h
 # update these version for every release:
 set(KRITA_VERSION_STRING "3.0.92")
 set(KRITA_STABLE_VERSION_MAJOR 3) # 3 for 3.x, 4 for 4.x, etc.
 set(KRITA_STABLE_VERSION_MINOR 0) # 0 for 3.0, 1 for 3.1, etc.
 set(KRITA_VERSION_RELEASE 91)     # 89 for Alpha, increase for next test releases, set 0 for first Stable, etc.
 #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 2016) # 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.
 if(KRITA_STABLE_VERSION_MAJOR EQUAL 3)
     math(EXPR GENERIC_KRITA_LIB_VERSION_MAJOR "${KRITA_STABLE_VERSION_MINOR} + 15")
 else()
     # let's make sure we won't forget to update the "15"
     message(FATAL_ERROR "Reminder: please update offset == 15 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_revision(GIT_REFSPEC GIT_SHA1)
 get_git_branch(GIT_BRANCH)
 
 if(GIT_SHA1 AND GIT_BRANCH)
     string(SUBSTRING ${GIT_SHA1} 0 7 GIT_SHA1)
     set(KRITA_GIT_SHA1_STRING ${GIT_SHA1})
     set(KRITA_GIT_BRANCH_STRING ${GIT_BRANCH})
 endif()
 
 if(NOT DEFINED RELEASE_BUILD)
     # estimate mode by CMAKE_BUILD_TYPE content if not set on cmdline
     string(TOLOWER "${CMAKE_BUILD_TYPE}" CMAKE_BUILD_TYPE_TOLOWER)
     set(RELEASE_BUILD_TYPES "release" "relwithdebinfo" "minsizerel")
     list(FIND RELEASE_BUILD_TYPES "${CMAKE_BUILD_TYPE_TOLOWER}" INDEX)
     if (INDEX EQUAL -1)
         set(RELEASE_BUILD FALSE)
     else()
         set(RELEASE_BUILD TRUE)
     endif()
 endif()
 message(STATUS "Release build: ${RELEASE_BUILD}")
 
  ############
 #############
 ## Options ##
 #############
 ############
 
 include(FeatureSummary)
 
 option(PACKAGERS_BUILD "Build support of multiple CPU architectures in one binary. Should be used by packagers only or Krita developers. Only switch off when you're an artist optimizing a build for your very own machine." ON)
 add_feature_info("Packagers' Build" PACKAGERS_BUILD "Support several CPU arch in one binary. Recommended for packages. Switch this off to make a build for only your machine.")
 
 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")
 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.")
 
  #######################
 ########################
 ## Productset setting ##
 ########################
 #######################
 
 # For predefined productsets see the definitions in KritaProducts.cmake and
 # in the files in the folder cmake/productsets.
 
 # Finding out the products & features to build is done in 5 steps:
 # 1. have the user define the products/features wanted, by giving a productset
 # 2. estimate all additional required products/features
 # 3. estimate which of the products/features can be build by external deps
 # 4. find which products/features have been temporarily disabled due to problems
 # 5. estimate which of the products/features can be build by internal deps
 
 # get the special macros
 include(MacroJPEG)
-include(GenerateTestExportHeader)
 
  ########################
 #########################
 ## Look for KDE and Qt ##
 #########################
 ########################
 
 find_package(ECM 1.7.0 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)
 if (NOT WIN32 AND NOT APPLE)
 
     find_package(Qt5 ${MIN_QT_VERSION} REQUIRED X11Extras)
 
     find_package(Qt5DBus ${MIN_QT_VERSION} QUIET)
     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} QUIET)
     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} QUIET) 
     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
   -DQT_DISABLE_DEPRECATED_BEFORE=0
 )
 
 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()
 
 # enable exceptions globally
 kde_enable_exceptions()
 
 
 # only with this definition will all the FOO_TEST_EXPORT macro do something
 # TODO: check if this can be moved to only those places which make use of it,
 # to reduce global compiler definitions that would trigger a recompile of
 # everything on a change (like adding/removing tests to/from the build)
 if(BUILD_TESTING)
     add_definitions(-DCOMPILING_TESTS)
 endif()
 
 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}")
 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 REQUIRED COMPONENTS system) # for pigment and stage
 include_directories(${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  ##
 ############################
 ###########################
 
 ##
 ## Check for OpenEXR
 ##
 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")
 
 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)
 
 ##
 ## 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 REQUIRED "3.0")
 set_package_properties(Eigen3 PROPERTIES
     DESCRIPTION "C++ template library for linear algebra"
     URL "http://eigen.tuxfamily.org"
     TYPE REQUIRED)
 
 ##
 ## Test for exiv2
 ##
 set(EXIV2_MIN_VERSION "0.16")
 find_package(Exiv2 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 REQUIRED "2.4")
 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 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)
     macro_bool_to_01(PACKAGERS_BUILD DO_PACKAGERS_BUILD)
 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 -fPIC")
     elseif (NOT MSVC)
         set(ADDITIONAL_VC_FLAGS "-Wabi -fabi-version=0 -ffp-contract=fast -fPIC")
     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)
     if(PACKAGERS_BUILD)
         vc_compile_for_all_implementations(${_objs} ${_src} FLAGS ${ADDITIONAL_VC_FLAGS} ONLY SSE2 SSSE3 SSE4_1 AVX AVX2+FMA+BMI2)
     else()
         set(${_objs} ${_src})
     endif()
     endmacro()
 
     macro(ko_compile_for_all_implementations _objs _src)
     if(PACKAGERS_BUILD)
         vc_compile_for_all_implementations(${_objs} ${_src} FLAGS ${ADDITIONAL_VC_FLAGS} ONLY Scalar SSE2 SSSE3 SSE4_1 AVX AVX2+FMA+BMI2)
     else()
         set(${_objs} ${_src})
     endif()
     endmacro()
 
     if (NOT PACKAGERS_BUILD)
         # Optimize everything for the current architecture
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${Vc_DEFINITIONS}")
     endif ()
 endif()
 set(CMAKE_MODULE_PATH ${OLD_CMAKE_MODULE_PATH} )
 
 add_definitions(${QT_DEFINITIONS} ${QT_QTDBUS_DEFINITIONS})
 
 if(WIN32)
     set(LIB_INSTALL_DIR ${LIB_INSTALL_DIR}
                         RUNTIME DESTINATION ${BIN_INSTALL_DIR}
                         LIBRARY ${INSTALL_TARGETS_DEFAULT_ARGS}
                         ARCHIVE ${INSTALL_TARGETS_DEFAULT_ARGS} )
 endif()
 
 ##
 ## Test endianess
 ##
 include (TestBigEndian)
 test_big_endian(CMAKE_WORDS_BIGENDIAN)
 
 ##
 ## Test for qt-poppler
 ##
 find_package(Poppler)
 set_package_properties(Poppler PROPERTIES
     DESCRIPTION "A PDF rendering library"
     URL "http://poppler.freedesktop.org"
     TYPE OPTIONAL
     PURPOSE "Required by the Krita PDF filter.")
 
 ##
 ## Test for pthreads (for G'Mic)
 ##
 find_package(Threads)
 set_package_properties(Threads PROPERTIES
     DESCRIPTION "PThreads - A low-level threading library"
     TYPE OPTIONAL
     PURPOSE "Optionally used by the G'Mic plugin")
 
 ##
 ## Test for OpenMP (for G'Mic)
 ##
 find_package(OpenMP)
 set_package_properties(OpenMP PROPERTIES
     DESCRIPTION "A low-level parallel execution library"
     URL "http://openmp.org/wp/"
     TYPE OPTIONAL
     PURPOSE "Optionally used by the G'Mic plugin")
 
 ##
 ## Test for Curl (for G'Mic)
 ##
 find_package(CURL)
 set_package_properties(CURL PROPERTIES
     DESCRIPTION "A tool to fetch remote data"
     URL "http://curl.haxx.se/"
     TYPE OPTIONAL
     PURPOSE "Optionally used by the G'Mic plugin")
 
  ############################
 #############################
 ## 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 
 )
 
 feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)
 
 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)
 
 
diff --git a/cmake/modules/GenerateTestExportHeader.cmake b/cmake/modules/GenerateTestExportHeader.cmake
deleted file mode 100644
index a412d6fd12..0000000000
--- a/cmake/modules/GenerateTestExportHeader.cmake
+++ /dev/null
@@ -1,255 +0,0 @@
-#.rst:
-# GenerateTestExportHeader
-# --------------------
-#
-# This module provides the function GENERATE_TEST_EXPORT_HEADER().
-# It is almost identical to generate_export_header() but produces
-# additional test export symbols using exporttestheader.cmake.in
-#
-# The standard format is ${BASE_NAME}_TEST_EXPORT
-# If you use a custom export symbol like EXPORTMYLIB
-# the test symbol will be of the format EXPORTMYLIB_TEST
-#
-
-#=============================================================================
-# Copyright 2011 Stephen Kelly <steveire@gmail.com>
-# Copyright 2015 Michael Abrahams <miabraha@gmail.com>
-#
-# All rights reserved.
-
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#     * Redistributions of source code must retain the above copyright
-#       notice, this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above copyright
-#       notice, this list of conditions and the following disclaimer in the
-#       documentation and/or other materials provided with the distribution.
-#     * Neither the name of the <organization> nor the
-#       names of its contributors may be used to endorse or promote products
-#       derived from this software without specific prior written permission.
-
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-# DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#=============================================================================
-
-include(CMakeParseArguments)
-include(CheckCXXCompilerFlag)
-
-# TODO: Install this macro separately?
-macro(_check_cxx_compiler_attribute _ATTRIBUTE _RESULT)
-  check_cxx_source_compiles("${_ATTRIBUTE} int somefunc() { return 0; }
-    int main() { return somefunc();}" ${_RESULT}
-  )
-endmacro()
-
-macro(_test_compiler_hidden_visibility)
-
-  if(CMAKE_COMPILER_IS_GNUCXX AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS "4.2")
-    set(GCC_TOO_OLD TRUE)
-  elseif(CMAKE_COMPILER_IS_GNUC AND CMAKE_C_COMPILER_VERSION VERSION_LESS "4.2")
-    set(GCC_TOO_OLD TRUE)
-  elseif(CMAKE_CXX_COMPILER_ID MATCHES Intel AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS "12.0")
-    set(_INTEL_TOO_OLD TRUE)
-  endif()
-
-  # Exclude XL here because it misinterprets -fvisibility=hidden even though
-  # the check_cxx_compiler_flag passes
-  if(NOT GCC_TOO_OLD
-      AND NOT _INTEL_TOO_OLD
-      AND NOT WIN32
-      AND NOT CYGWIN
-      AND NOT CMAKE_CXX_COMPILER_ID MATCHES XL
-      AND NOT CMAKE_CXX_COMPILER_ID MATCHES PGI
-      AND NOT CMAKE_CXX_COMPILER_ID MATCHES Watcom)
-    check_cxx_compiler_flag(-fvisibility=hidden COMPILER_HAS_HIDDEN_VISIBILITY)
-    check_cxx_compiler_flag(-fvisibility-inlines-hidden
-      COMPILER_HAS_HIDDEN_INLINE_VISIBILITY)
-    option(USE_COMPILER_HIDDEN_VISIBILITY
-      "Use HIDDEN visibility support if available." ON)
-    mark_as_advanced(USE_COMPILER_HIDDEN_VISIBILITY)
-  endif()
-endmacro()
-
-macro(_test_compiler_has_deprecated)
-  if(CMAKE_CXX_COMPILER_ID MATCHES Borland
-      OR CMAKE_CXX_COMPILER_ID MATCHES HP
-      OR GCC_TOO_OLD
-      OR CMAKE_CXX_COMPILER_ID MATCHES PGI
-      OR CMAKE_CXX_COMPILER_ID MATCHES Watcom)
-    set(COMPILER_HAS_DEPRECATED "" CACHE INTERNAL
-      "Compiler support for a deprecated attribute")
-  else()
-    _check_cxx_compiler_attribute("__attribute__((__deprecated__))"
-      COMPILER_HAS_DEPRECATED_ATTR)
-    if(COMPILER_HAS_DEPRECATED_ATTR)
-      set(COMPILER_HAS_DEPRECATED "${COMPILER_HAS_DEPRECATED_ATTR}"
-        CACHE INTERNAL "Compiler support for a deprecated attribute")
-    else()
-      _check_cxx_compiler_attribute("__declspec(deprecated)"
-        COMPILER_HAS_DEPRECATED)
-    endif()
-  endif()
-endmacro()
-
-get_filename_component(_GENERATE_TEST_EXPORT_HEADER_MODULE_DIR
-  "${CMAKE_CURRENT_LIST_FILE}" PATH)
-
-macro(_DO_SET_MACRO_VALUES TARGET_LIBRARY)
-  set(DEFINE_DEPRECATED)
-  set(DEFINE_EXPORT)
-  set(DEFINE_IMPORT)
-  set(DEFINE_NO_EXPORT)
-
-  if (COMPILER_HAS_DEPRECATED_ATTR)
-    set(DEFINE_DEPRECATED "__attribute__ ((__deprecated__))")
-  elseif(COMPILER_HAS_DEPRECATED)
-    set(DEFINE_DEPRECATED "__declspec(deprecated)")
-  endif()
-
-  get_property(type TARGET ${TARGET_LIBRARY} PROPERTY TYPE)
-
-  if(NOT ${type} STREQUAL "STATIC_LIBRARY")
-    if(WIN32)
-      set(DEFINE_EXPORT "__declspec(dllexport)")
-      set(DEFINE_IMPORT "__declspec(dllimport)")
-    elseif(COMPILER_HAS_HIDDEN_VISIBILITY AND USE_COMPILER_HIDDEN_VISIBILITY)
-      set(DEFINE_EXPORT "__attribute__((visibility(\"default\")))")
-      set(DEFINE_IMPORT "__attribute__((visibility(\"default\")))")
-      set(DEFINE_NO_EXPORT "__attribute__((visibility(\"hidden\")))")
-    endif()
-  endif()
-endmacro()
-
-macro(_DO_GENERATE_TEST_EXPORT_HEADER TARGET_LIBRARY)
-  # Option overrides
-  set(options DEFINE_NO_DEPRECATED)
-  set(oneValueArgs PREFIX_NAME BASE_NAME EXPORT_MACRO_NAME EXPORT_FILE_NAME
-    DEPRECATED_MACRO_NAME NO_EXPORT_MACRO_NAME STATIC_DEFINE
-    NO_DEPRECATED_MACRO_NAME)
-  set(multiValueArgs)
-
-  cmake_parse_arguments(_GEH "${options}" "${oneValueArgs}" "${multiValueArgs}"
-    ${ARGN})
-
-  set(BASE_NAME "${TARGET_LIBRARY}")
-
-  if(_GEH_BASE_NAME)
-    set(BASE_NAME ${_GEH_BASE_NAME})
-  endif()
-
-  string(TOUPPER ${BASE_NAME} BASE_NAME_UPPER)
-  string(TOLOWER ${BASE_NAME} BASE_NAME_LOWER)
-
-  # Default options
-  set(EXPORT_MACRO_NAME "${_GEH_PREFIX_NAME}${BASE_NAME_UPPER}_EXPORT")
-  set(EXPORT_TEST_MACRO_NAME "${_GEH_PREFIX_NAME}${BASE_NAME_UPPER}_TEST_EXPORT")
-  set(NO_EXPORT_MACRO_NAME "${_GEH_PREFIX_NAME}${BASE_NAME_UPPER}_NO_EXPORT")
-  set(EXPORT_FILE_NAME "${CMAKE_CURRENT_BINARY_DIR}/${BASE_NAME_LOWER}_export.h")
-  set(DEPRECATED_MACRO_NAME "${_GEH_PREFIX_NAME}${BASE_NAME_UPPER}_DEPRECATED")
-  set(STATIC_DEFINE "${_GEH_PREFIX_NAME}${BASE_NAME_UPPER}_STATIC_DEFINE")
-  set(NO_DEPRECATED_MACRO_NAME
-    "${_GEH_PREFIX_NAME}${BASE_NAME_UPPER}_NO_DEPRECATED")
-
-  if(_GEH_UNPARSED_ARGUMENTS)
-    message(FATAL_ERROR "Unknown keywords given to GENERATE_TEST_EXPORT_HEADER(): \"${_GEH_UNPARSED_ARGUMENTS}\"")
-  endif()
-
-  if(_GEH_EXPORT_MACRO_NAME)
-    set(EXPORT_MACRO_NAME ${_GEH_PREFIX_NAME}${_GEH_EXPORT_MACRO_NAME})
-    set(EXPORT_TEST_MACRO_NAME "${_GEH_PREFIX_NAME}${_GEH_EXPORT_MACRO_NAME}_TEST")
-  endif()
-  string(MAKE_C_IDENTIFIER ${EXPORT_MACRO_NAME} EXPORT_MACRO_NAME)
-  string(MAKE_C_IDENTIFIER ${EXPORT_MACRO_NAME} EXPORT_TEST_MACRO_NAME)
-  if(_GEH_EXPORT_FILE_NAME)
-    if(IS_ABSOLUTE ${_GEH_EXPORT_FILE_NAME})
-      set(EXPORT_FILE_NAME ${_GEH_EXPORT_FILE_NAME})
-    else()
-      set(EXPORT_FILE_NAME "${CMAKE_CURRENT_BINARY_DIR}/${_GEH_EXPORT_FILE_NAME}")
-    endif()
-  endif()
-  if(_GEH_DEPRECATED_MACRO_NAME)
-    set(DEPRECATED_MACRO_NAME ${_GEH_PREFIX_NAME}${_GEH_DEPRECATED_MACRO_NAME})
-  endif()
-  string(MAKE_C_IDENTIFIER ${DEPRECATED_MACRO_NAME} DEPRECATED_MACRO_NAME)
-  if(_GEH_NO_EXPORT_MACRO_NAME)
-    set(NO_EXPORT_MACRO_NAME ${_GEH_PREFIX_NAME}${_GEH_NO_EXPORT_MACRO_NAME})
-  endif()
-  string(MAKE_C_IDENTIFIER ${NO_EXPORT_MACRO_NAME} NO_EXPORT_MACRO_NAME)
-  if(_GEH_STATIC_DEFINE)
-    set(STATIC_DEFINE ${_GEH_PREFIX_NAME}${_GEH_STATIC_DEFINE})
-  endif()
-  string(MAKE_C_IDENTIFIER ${STATIC_DEFINE} STATIC_DEFINE)
-
-  if(_GEH_DEFINE_NO_DEPRECATED)
-    set(DEFINE_NO_DEPRECATED TRUE)
-  endif()
-
-  if(_GEH_NO_DEPRECATED_MACRO_NAME)
-    set(NO_DEPRECATED_MACRO_NAME
-      ${_GEH_PREFIX_NAME}${_GEH_NO_DEPRECATED_MACRO_NAME})
-  endif()
-  string(MAKE_C_IDENTIFIER ${NO_DEPRECATED_MACRO_NAME} NO_DEPRECATED_MACRO_NAME)
-
-  set(INCLUDE_GUARD_NAME "${EXPORT_MACRO_NAME}_H")
-
-  get_target_property(EXPORT_IMPORT_CONDITION ${TARGET_LIBRARY} DEFINE_SYMBOL)
-
-  if(NOT EXPORT_IMPORT_CONDITION)
-    set(EXPORT_IMPORT_CONDITION ${TARGET_LIBRARY}_EXPORTS)
-  endif()
-  string(MAKE_C_IDENTIFIER ${EXPORT_IMPORT_CONDITION} EXPORT_IMPORT_CONDITION)
-
-  configure_file("${_GENERATE_TEST_EXPORT_HEADER_MODULE_DIR}/exporttestheader.cmake.in"
-    "${EXPORT_FILE_NAME}" @ONLY)
-endmacro()
-
-function(GENERATE_TEST_EXPORT_HEADER TARGET_LIBRARY)
-  get_property(type TARGET ${TARGET_LIBRARY} PROPERTY TYPE)
-  if(NOT ${type} STREQUAL "STATIC_LIBRARY"
-      AND NOT ${type} STREQUAL "SHARED_LIBRARY"
-      AND NOT ${type} STREQUAL "OBJECT_LIBRARY"
-      AND NOT ${type} STREQUAL "MODULE_LIBRARY")
-    message(WARNING "This macro can only be used with libraries")
-    return()
-  endif()
-  _test_compiler_hidden_visibility()
-  _test_compiler_has_deprecated()
-  _do_set_macro_values(${TARGET_LIBRARY})
-  _do_generate_test_export_header(${TARGET_LIBRARY} ${ARGN})
-endfunction()
-
-function(add_compiler_export_flags)
-  if(NOT CMAKE_MINIMUM_REQUIRED_VERSION VERSION_LESS 2.8.12)
-    message(DEPRECATION "The add_compiler_export_flags function is obsolete. Use the CXX_VISIBILITY_PRESET and VISIBILITY_INLINES_HIDDEN target properties instead.")
-  endif()
-
-  _test_compiler_hidden_visibility()
-  _test_compiler_has_deprecated()
-
-  if(NOT (USE_COMPILER_HIDDEN_VISIBILITY AND COMPILER_HAS_HIDDEN_VISIBILITY))
-    # Just return if there are no flags to add.
-    return()
-  endif()
-
-  set (EXTRA_FLAGS "-fvisibility=hidden")
-
-  if(COMPILER_HAS_HIDDEN_INLINE_VISIBILITY)
-    set (EXTRA_FLAGS "${EXTRA_FLAGS} -fvisibility-inlines-hidden")
-  endif()
-
-  # Either return the extra flags needed in the supplied argument, or to the
-  # CMAKE_CXX_FLAGS if no argument is supplied.
-  if(ARGC GREATER 0)
-    set(${ARGV0} "${EXTRA_FLAGS}" PARENT_SCOPE)
-  else()
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_FLAGS}" PARENT_SCOPE)
-  endif()
-endfunction()