diff --git a/libs/image/CMakeLists.txt b/libs/image/CMakeLists.txt
index 12449658eb..a28bbf86ca 100644
--- a/libs/image/CMakeLists.txt
+++ b/libs/image/CMakeLists.txt
@@ -1,379 +1,380 @@
 add_subdirectory( tests )
 
 add_subdirectory( tiles3 )
 
 include_directories(
     ${CMAKE_CURRENT_BINARY_DIR}
     ${CMAKE_CURRENT_SOURCE_DIR}/3rdparty
     ${CMAKE_CURRENT_SOURCE_DIR}/brushengine
     ${CMAKE_CURRENT_SOURCE_DIR}/commands
     ${CMAKE_CURRENT_SOURCE_DIR}/commands_new
     ${CMAKE_CURRENT_SOURCE_DIR}/filter
     ${CMAKE_CURRENT_SOURCE_DIR}/floodfill
     ${CMAKE_CURRENT_SOURCE_DIR}/generator
     ${CMAKE_CURRENT_SOURCE_DIR}/layerstyles
     ${CMAKE_CURRENT_SOURCE_DIR}/processing
 
     ${CMAKE_SOURCE_DIR}/sdk/tests
 )
 
 include_directories(SYSTEM
     ${EIGEN3_INCLUDE_DIR}
 )
 
 if(FFTW3_FOUND)
   include_directories(${FFTW3_INCLUDE_DIR})
 endif()
 
 if(HAVE_VC)
   include_directories(SYSTEM ${Vc_INCLUDE_DIR} ${Qt5Core_INCLUDE_DIRS} ${Qt5Gui_INCLUDE_DIRS})
   ko_compile_for_all_implementations(__per_arch_circle_mask_generator_objs kis_brush_mask_applicator_factories.cpp)
 else()
   set(__per_arch_circle_mask_generator_objs kis_brush_mask_applicator_factories.cpp)
 endif()
 
 set(kritaimage_LIB_SRCS
     tiles3/kis_tile.cc
     tiles3/kis_tile_data.cc
     tiles3/kis_tile_data_store.cc
     tiles3/kis_tile_data_pooler.cc
     tiles3/kis_tiled_data_manager.cc
     tiles3/KisTiledExtentManager.cpp
     tiles3/kis_memento_manager.cc
     tiles3/kis_hline_iterator.cpp
     tiles3/kis_vline_iterator.cpp
     tiles3/kis_random_accessor.cc
     tiles3/swap/kis_abstract_compression.cpp
     tiles3/swap/kis_lzf_compression.cpp
     tiles3/swap/kis_abstract_tile_compressor.cpp
     tiles3/swap/kis_legacy_tile_compressor.cpp
     tiles3/swap/kis_tile_compressor_2.cpp
     tiles3/swap/kis_chunk_allocator.cpp
     tiles3/swap/kis_memory_window.cpp
     tiles3/swap/kis_swapped_data_store.cpp
     tiles3/swap/kis_tile_data_swapper.cpp
    kis_distance_information.cpp
    kis_painter.cc
    kis_painter_blt_multi_fixed.cpp
    kis_marker_painter.cpp
    KisPrecisePaintDeviceWrapper.cpp
    kis_progress_updater.cpp
    brushengine/kis_paint_information.cc
    brushengine/kis_random_source.cpp
    brushengine/KisPerStrokeRandomSource.cpp
    brushengine/kis_stroke_random_source.cpp
    brushengine/kis_paintop.cc
    brushengine/kis_paintop_factory.cpp
    brushengine/kis_paintop_preset.cpp
    brushengine/kis_paintop_registry.cc
    brushengine/kis_paintop_settings.cpp
    brushengine/kis_paintop_settings_update_proxy.cpp
    brushengine/kis_paintop_utils.cpp
    brushengine/kis_no_size_paintop_settings.cpp
    brushengine/kis_locked_properties.cc
    brushengine/kis_locked_properties_proxy.cpp
    brushengine/kis_locked_properties_server.cpp
    brushengine/kis_paintop_config_widget.cpp
    brushengine/kis_uniform_paintop_property.cpp
    brushengine/kis_combo_based_paintop_property.cpp
    brushengine/kis_slider_based_paintop_property.cpp
    brushengine/kis_standard_uniform_properties_factory.cpp
    brushengine/KisStrokeSpeedMeasurer.cpp
    brushengine/KisPaintopSettingsIds.cpp
    commands/kis_deselect_global_selection_command.cpp
    commands/KisDeselectActiveSelectionCommand.cpp
    commands/kis_image_change_layers_command.cpp
    commands/kis_image_change_visibility_command.cpp
    commands/kis_image_command.cpp
    commands/kis_image_set_projection_color_space_command.cpp
    commands/kis_image_layer_add_command.cpp
    commands/kis_image_layer_move_command.cpp
    commands/kis_image_layer_remove_command.cpp
    commands/kis_image_layer_remove_command_impl.cpp
    commands/kis_image_lock_command.cpp
    commands/kis_node_command.cpp
    commands/kis_node_compositeop_command.cpp
    commands/kis_node_opacity_command.cpp
    commands/kis_node_property_list_command.cpp
    commands/kis_reselect_global_selection_command.cpp
    commands/KisReselectActiveSelectionCommand.cpp
    commands/kis_set_global_selection_command.cpp
    commands/KisNodeRenameCommand.cpp
    commands_new/kis_saved_commands.cpp
    commands_new/kis_processing_command.cpp
    commands_new/kis_image_resize_command.cpp
    commands_new/kis_image_set_resolution_command.cpp
    commands_new/kis_node_move_command2.cpp
    commands_new/kis_set_layer_style_command.cpp
    commands_new/kis_selection_move_command2.cpp
    commands_new/kis_update_command.cpp
    commands_new/kis_switch_current_time_command.cpp
    commands_new/kis_change_projection_color_command.cpp
    commands_new/kis_activate_selection_mask_command.cpp
    commands_new/kis_transaction_based_command.cpp
    commands_new/KisHoldUIUpdatesCommand.cpp
    processing/kis_do_nothing_processing_visitor.cpp
    processing/kis_simple_processing_visitor.cpp
    processing/kis_crop_processing_visitor.cpp
    processing/kis_crop_selections_processing_visitor.cpp
    processing/kis_transform_processing_visitor.cpp
    processing/kis_mirror_processing_visitor.cpp
    processing/KisSelectionBasedProcessingHelper.cpp
    filter/kis_filter.cc
    filter/kis_filter_category_ids.cpp
    filter/kis_filter_configuration.cc
    filter/kis_color_transformation_configuration.cc
    filter/kis_filter_registry.cc
    filter/kis_color_transformation_filter.cc
    generator/kis_generator.cpp
    generator/kis_generator_layer.cpp
    generator/kis_generator_registry.cpp
    floodfill/kis_fill_interval_map.cpp
    floodfill/kis_scanline_fill.cpp
    lazybrush/kis_min_cut_worker.cpp
    lazybrush/kis_lazy_fill_tools.cpp
    lazybrush/kis_multiway_cut.cpp
    lazybrush/KisWatershedWorker.cpp
    lazybrush/kis_colorize_mask.cpp
    lazybrush/kis_colorize_stroke_strategy.cpp
    KisDelayedUpdateNodeInterface.cpp
    KisCroppedOriginalLayerInterface.cpp
    kis_adjustment_layer.cc
    kis_selection_based_layer.cpp
    kis_node_filter_interface.cpp
    kis_base_accessor.cpp
    kis_base_node.cpp
    kis_base_processor.cpp
    kis_bookmarked_configuration_manager.cc
    kis_node_uuid_info.cpp
    kis_clone_layer.cpp
    kis_colorspace_convert_visitor.cpp
    kis_config_widget.cpp
    kis_convolution_kernel.cc
    kis_convolution_painter.cc
    kis_gaussian_kernel.cpp
    kis_edge_detection_kernel.cpp
    kis_cubic_curve.cpp
    kis_default_bounds.cpp
    kis_default_bounds_base.cpp
    kis_effect_mask.cc
    kis_fast_math.cpp
    kis_fill_painter.cc
    kis_filter_mask.cpp
    kis_filter_strategy.cc
    kis_transform_mask.cpp
    kis_transform_mask_params_interface.cpp
    kis_recalculate_transform_mask_job.cpp
    kis_recalculate_generator_layer_job.cpp
    kis_transform_mask_params_factory_registry.cpp
    kis_safe_transform.cpp
    kis_gradient_painter.cc
    kis_gradient_shape_strategy.cpp
    kis_cached_gradient_shape_strategy.cpp
    kis_polygonal_gradient_shape_strategy.cpp
    kis_iterator_ng.cpp
    kis_async_merger.cpp
    kis_merge_walker.cc
    kis_updater_context.cpp
    kis_update_job_item.cpp
    kis_stroke_strategy_undo_command_based.cpp
    kis_simple_stroke_strategy.cpp
    KisRunnableBasedStrokeStrategy.cpp
    KisRunnableStrokeJobDataBase.cpp
    KisRunnableStrokeJobData.cpp
    KisRunnableStrokeJobsInterface.cpp
    KisFakeRunnableStrokeJobsExecutor.cpp
    kis_stroke_job_strategy.cpp
    kis_stroke_strategy.cpp
    kis_stroke.cpp
    kis_strokes_queue.cpp
    KisStrokesQueueMutatedJobInterface.cpp
    kis_simple_update_queue.cpp
    kis_update_scheduler.cpp
    kis_queues_progress_updater.cpp
    kis_composite_progress_proxy.cpp
    kis_sync_lod_cache_stroke_strategy.cpp
    kis_lod_capable_layer_offset.cpp
    kis_update_time_monitor.cpp
    KisImageConfigNotifier.cpp
    kis_group_layer.cc
    kis_count_visitor.cpp
    kis_histogram.cc
    kis_image_interfaces.cpp
    kis_image_animation_interface.cpp
    kis_time_range.cpp
    kis_node_graph_listener.cpp
    kis_image.cc
    kis_image_signal_router.cpp
    KisImageSignals.cpp
    kis_image_config.cpp
    kis_projection_updates_filter.cpp
    kis_suspend_projection_updates_stroke_strategy.cpp
    kis_regenerate_frame_stroke_strategy.cpp
    kis_switch_time_stroke_strategy.cpp
    kis_crop_saved_extra_data.cpp
    kis_timed_signal_threshold.cpp
    kis_layer.cc
    kis_indirect_painting_support.cpp
    kis_abstract_projection_plane.cpp
    kis_layer_projection_plane.cpp
    kis_layer_utils.cpp
    kis_mask_projection_plane.cpp
    kis_projection_leaf.cpp
    KisSafeNodeProjectionStore.cpp
    kis_mask.cc
    kis_base_mask_generator.cpp
    kis_rect_mask_generator.cpp
    kis_circle_mask_generator.cpp
    kis_gauss_circle_mask_generator.cpp
    kis_gauss_rect_mask_generator.cpp
    ${__per_arch_circle_mask_generator_objs}
    kis_curve_circle_mask_generator.cpp
    kis_curve_rect_mask_generator.cpp
    kis_math_toolbox.cpp
    kis_memory_statistics_server.cpp
    kis_name_server.cpp
    kis_node.cpp
    kis_node_facade.cpp
    kis_node_progress_proxy.cpp
    kis_busy_progress_indicator.cpp
    kis_node_visitor.cpp
    kis_paint_device.cc
    kis_paint_device_debug_utils.cpp
    kis_fixed_paint_device.cpp
    KisOptimizedByteArray.cpp
    kis_paint_layer.cc
    kis_perspective_math.cpp
    kis_pixel_selection.cpp
    kis_processing_information.cpp
    kis_properties_configuration.cc
    kis_random_accessor_ng.cpp
    kis_random_generator.cc
    kis_random_sub_accessor.cpp
    kis_wrapped_random_accessor.cpp
    kis_selection.cc
    KisSelectionUpdateCompressor.cpp
    kis_selection_mask.cpp
    kis_update_outline_job.cpp
    kis_update_selection_job.cpp
    kis_serializable_configuration.cc
    kis_transaction_data.cpp
    kis_transform_worker.cc
    kis_perspectivetransform_worker.cpp
    bsplines/kis_bspline_1d.cpp
    bsplines/kis_bspline_2d.cpp
    bsplines/kis_nu_bspline_2d.cpp
    kis_warptransform_worker.cc
    kis_cage_transform_worker.cpp
    kis_liquify_transform_worker.cpp
    kis_green_coordinates_math.cpp
    kis_transparency_mask.cc
    kis_undo_adapter.cpp
    kis_macro_based_undo_store.cpp
    kis_surrogate_undo_adapter.cpp
    kis_legacy_undo_adapter.cpp
    kis_post_execution_undo_adapter.cpp
    kis_processing_visitor.cpp
    kis_processing_applicator.cpp
    krita_utils.cpp
    kis_outline_generator.cpp
    kis_layer_composition.cpp
    kis_selection_filters.cpp
    KisProofingConfiguration.h
    KisRecycleProjectionsJob.cpp
 
    kis_keyframe.cpp
    kis_keyframe_channel.cpp
    kis_keyframe_commands.cpp
    kis_scalar_keyframe_channel.cpp
    kis_raster_keyframe_channel.cpp
    kis_onion_skin_compositor.cpp
    kis_onion_skin_cache.cpp
    kis_idle_watcher.cpp
 
    kis_psd_layer_style.cpp
    kis_layer_properties_icons.cpp
 
    layerstyles/kis_multiple_projection.cpp
    layerstyles/kis_layer_style_filter.cpp
    layerstyles/kis_layer_style_filter_environment.cpp
    layerstyles/kis_layer_style_filter_projection_plane.cpp
    layerstyles/kis_layer_style_projection_plane.cpp
    layerstyles/kis_ls_drop_shadow_filter.cpp
    layerstyles/kis_ls_satin_filter.cpp
    layerstyles/kis_ls_stroke_filter.cpp
    layerstyles/kis_ls_bevel_emboss_filter.cpp
    layerstyles/kis_ls_overlay_filter.cpp
    layerstyles/kis_ls_utils.cpp
    layerstyles/gimp_bump_map.cpp
+   layerstyles/KisLayerStyleKnockoutBlower.cpp
 
    KisProofingConfiguration.cpp
 
    kis_node_query_path.cc
 )
 
 set(einspline_SRCS
    3rdparty/einspline/bspline_create.cpp
    3rdparty/einspline/bspline_data.cpp
    3rdparty/einspline/multi_bspline_create.cpp
    3rdparty/einspline/nubasis.cpp
    3rdparty/einspline/nubspline_create.cpp
    3rdparty/einspline/nugrid.cpp
 )
 
 add_library(kritaimage SHARED ${kritaimage_LIB_SRCS} ${einspline_SRCS})
 generate_export_header(kritaimage BASE_NAME kritaimage)
 
 target_link_libraries(kritaimage 
     PUBLIC
         kritaversion 
         kritawidgets 
         kritaglobal 
         kritapsd 
         kritaodf 
         kritapigment 
         kritacommand
         kritawidgetutils 
         kritametadata
         Qt5::Concurrent
 )
 
 target_link_libraries(kritaimage PUBLIC ${Boost_SYSTEM_LIBRARY})
 
 if(NOT HAVE_CXX_ATOMICS_WITHOUT_LIB)
     if(NOT HAVE_CXX_ATOMICS64_WITHOUT_LIB)
         target_link_libraries(kritaimage PUBLIC atomic)
     endif()
 endif()
 
 if(OPENEXR_FOUND)
   target_link_libraries(kritaimage PUBLIC ${OPENEXR_LIBRARIES})
 endif()
 
 if(FFTW3_FOUND)
   target_link_libraries(kritaimage PRIVATE ${FFTW3_LIBRARIES})
 endif()
 
 if(HAVE_VC)
   target_link_libraries(kritaimage PUBLIC ${Vc_LIBRARIES})
 endif()
 
 if (NOT GSL_FOUND)
   message (WARNING "KRITA WARNING! No GNU Scientific Library was found! Krita's Shaped Gradients might be non-normalized! Please install GSL library.")
 else ()
   target_link_libraries(kritaimage PRIVATE ${GSL_LIBRARIES} ${GSL_CBLAS_LIBRARIES})
 endif ()
 
 target_include_directories(kritaimage
     PUBLIC
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/brushengine>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/filter>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/generator>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/layerstyles>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/processing>
 )
 
 set_target_properties(kritaimage PROPERTIES
     VERSION ${GENERIC_KRITA_LIB_VERSION} SOVERSION ${GENERIC_KRITA_LIB_SOVERSION}
 )
 install(TARGETS kritaimage  ${INSTALL_TARGETS_DEFAULT_ARGS})
diff --git a/libs/image/kis_cached_paint_device.h b/libs/image/kis_cached_paint_device.h
index 1cb038d39b..f83eb34480 100644
--- a/libs/image/kis_cached_paint_device.h
+++ b/libs/image/kis_cached_paint_device.h
@@ -1,73 +1,114 @@
 /*
  *  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_CACHED_PAINT_DEVICE_H
 #define __KIS_CACHED_PAINT_DEVICE_H
 
 #include "tiles3/kis_lockless_stack.h"
 #include "kis_paint_device.h"
 #include "kis_selection.h"
 
 class KisCachedPaintDevice
 {
 public:
     KisPaintDeviceSP getDevice(KisPaintDeviceSP prototype) {
         KisPaintDeviceSP device;
 
         if(!m_stack.pop(device)) {
             device = new KisPaintDevice(prototype->colorSpace());
         }
 
         device->prepareClone(prototype);
         return device;
     }
 
     void putDevice(KisPaintDeviceSP device) {
         device->clear();
         device->setDefaultBounds(new KisDefaultBounds());
         m_stack.push(device);
     }
 
+    struct Guard {
+        Guard(KisPaintDeviceSP prototype, KisCachedPaintDevice &parent)
+            : m_parent(parent)
+        {
+            m_device = m_parent.getDevice(prototype);
+        }
+
+        ~Guard() {
+            m_parent.putDevice(m_device);
+        }
+
+        KisPaintDeviceSP device() const {
+            return m_device;
+        }
+
+        private:
+        KisCachedPaintDevice &m_parent;
+        KisPaintDeviceSP m_device;
+    };
+
 private:
     KisLocklessStack<KisPaintDeviceSP> m_stack;
 };
 
 class KisCachedSelection
 {
 public:
     KisSelectionSP getSelection() {
         KisSelectionSP selection;
 
         if(!m_stack.pop(selection)) {
-            selection = new KisSelection();
+            selection = new KisSelection(new KisSelectionEmptyBounds(0));
         }
 
         return selection;
     }
 
     void putSelection(KisSelectionSP selection) {
         selection->clear();
-        selection->setDefaultBounds(new KisDefaultBounds());
+        selection->setDefaultBounds(new KisSelectionEmptyBounds(0));
+        selection->pixelSelection()->moveTo(QPoint());
         m_stack.push(selection);
     }
 
+    struct Guard {
+        Guard(KisCachedSelection &parent)
+            : m_parent(parent)
+        {
+            m_selection = m_parent.getSelection();
+        }
+
+        ~Guard() {
+            m_parent.putSelection(m_selection);
+        }
+
+        KisSelectionSP selection() const {
+            return m_selection;
+        }
+
+        private:
+        KisCachedSelection &m_parent;
+        KisSelectionSP m_selection;
+    };
+
 private:
     KisLocklessStack<KisSelectionSP> m_stack;
 };
 
 #endif /* __KIS_CACHED_PAINT_DEVICE_H */
diff --git a/libs/image/kis_gaussian_kernel.cpp b/libs/image/kis_gaussian_kernel.cpp
index 851bc5cc4d..d6966f1d49 100644
--- a/libs/image/kis_gaussian_kernel.cpp
+++ b/libs/image/kis_gaussian_kernel.cpp
@@ -1,400 +1,400 @@
 /*
  *  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());
 }
 
 KisConvolutionKernelSP
 KisGaussianKernel::createUniform2DKernel(qreal xRadius, qreal yRadius)
 {
     Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> h = createHorizontalMatrix(xRadius);
     Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> v = createVerticalMatrix(yRadius);
 
     Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> uni = v * h;
     return KisConvolutionKernel::fromMatrix(uni, 0, uni.sum());
 }
 
 
 void KisGaussianKernel::applyGaussian(KisPaintDeviceSP device,
                                       const QRect& rect,
                                       qreal xRadius, qreal yRadius,
                                       const QBitArray &channelFlags,
                                       KoUpdater *progressUpdater,
                                       bool createTransaction)
 {
     QPoint srcTopLeft = rect.topLeft();
 
 
     if (KisConvolutionPainter::supportsFFTW()) {
         KisConvolutionPainter painter(device, KisConvolutionPainter::FFTW);
         painter.setChannelFlags(channelFlags);
         painter.setProgress(progressUpdater);
 
         KisConvolutionKernelSP kernel2D = KisGaussianKernel::createUniform2DKernel(xRadius, yRadius);
 
         QScopedPointer<KisTransaction> transaction;
         if (createTransaction && painter.needsTransaction(kernel2D)) {
             transaction.reset(new KisTransaction(device));
         }
 
         painter.applyMatrix(kernel2D, device, srcTopLeft, srcTopLeft, rect.size(), BORDER_REPEAT);
 
     } else if (xRadius > 0.0 && yRadius > 0.0) {
         KisPaintDeviceSP interm = new KisPaintDevice(device->colorSpace());
         interm->prepareClone(device);
 
         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, bool zeroCentered, bool includeWrappedArea)
 {
     int kernelSize = 2 * (includeWrappedArea ? 2 : 1) * 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 totalSum = 0;
 
     if (zeroCentered) {
         for (int y = 0; y < kernelSize; y++) {
             for (int x = 0; x < kernelSize; x++) {
                 const qreal value = matrix(x, y);
                 totalSum += value;
             }
         }
     }
 
     qreal positiveSum = 0;
     qreal sideSum = 0;
     qreal quarterSum = 0;
     totalSum = 0;
 
     const qreal offset = totalSum / pow2(qreal(kernelSize));
 
     for (int y = 0; y < kernelSize; y++) {
         for (int x = 0; x < kernelSize; x++) {
             qreal value = matrix(x, y);
             value -= offset;
             matrix(x, y) = value;
 
             if (value > 0) {
                 positiveSum += value;
             }
             if (x > center) {
                 sideSum += value;
             }
             if (x > center && y > center) {
                 quarterSum += value;
             }
             totalSum += 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, false, true);
     KisConvolutionKernelSP kernel =
         KisConvolutionKernel::fromMatrix(matrix,
                                          0,
                                          0);
 
     painter.applyMatrix(kernel, device, srcTopLeft, srcTopLeft, rect.size(), BORDER_REPEAT);
 }
 
 void KisGaussianKernel::applyTightLoG(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, true, false);
     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)
 {
     const int kernelSize = 2 * std::ceil(radius) + 1;
     Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> matrix(kernelSize, kernelSize);
 
     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) {
+            if (distance > radius + 1e-3) {
                 value = 0.0;
             } else if (distance > fadeStart) {
-                value = radius - distance;
+                value = qMax(0.0, radius - distance);
             }
 
             matrix(x, y) = value;
         }
     }
 
     return matrix;
 }
 
 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,
                                          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, 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, createTransaction);
 
     {
         KisSequentialIterator dstIt(device, rect);
         while (dstIt.nextPixel()) {
             quint8 *dstPtr = dstIt.rawData();
             *dstPtr = 255 - *dstPtr;
         }
     }
 }
diff --git a/libs/image/kis_layer.cc b/libs/image/kis_layer.cc
index 6713137a8e..1d573758cc 100644
--- a/libs/image/kis_layer.cc
+++ b/libs/image/kis_layer.cc
@@ -1,990 +1,991 @@
 /*
  *  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 <QReadWriteLock>
 #include <QReadLocker>
 #include <QWriteLocker>
 
 #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"
 #include "kis_projection_leaf.h"
 #include "KisSafeNodeProjectionStore.h"
 
 
 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;
 };
 
 class KisLayerMasksCache {
 public:
     KisLayerMasksCache(KisLayer *parent)
         : m_parent(parent)
     {
     }
 
     KisSelectionMaskSP selectionMask() {
         QReadLocker readLock(&m_lock);
 
         if (!m_isSelectionMaskValid) {
             readLock.unlock();
 
             QWriteLocker writeLock(&m_lock);
             if (!m_isSelectionMaskValid) {
                 KoProperties properties;
                 properties.setProperty("active", true);
                 properties.setProperty("visible", true);
                 QList<KisNodeSP> masks = m_parent->childNodes(QStringList("KisSelectionMask"), properties);
 
                 // return the first visible mask
                 Q_FOREACH (KisNodeSP mask, masks) {
                     if (mask) {
                         m_selectionMask = dynamic_cast<KisSelectionMask*>(mask.data());
                         break;
                     }
                 }
                 m_isSelectionMaskValid = true;
             }
 
             // return under write lock
             return m_selectionMask;
         }
 
         // return under read lock
         return m_selectionMask;
     }
 
     QList<KisEffectMaskSP> effectMasks() {
         QReadLocker readLock(&m_lock);
 
         if (!m_isEffectMasksValid) {
             readLock.unlock();
 
             QWriteLocker writeLock(&m_lock);
             if (!m_isEffectMasksValid) {
                 m_effectMasks = m_parent->searchEffectMasks(0);
                 m_isEffectMasksValid = true;
             }
 
             // return under write lock
             return m_effectMasks;
         }
 
         // return under read lock
         return m_effectMasks;
     }
 
     void setDirty()
     {
         QWriteLocker l(&m_lock);
         m_isSelectionMaskValid = false;
         m_isEffectMasksValid = false;
         m_selectionMask = 0;
         m_effectMasks.clear();
     }
 
 private:
     KisLayer *m_parent;
 
     QReadWriteLock m_lock;
 
     bool m_isSelectionMaskValid = false;
     bool m_isEffectMasksValid = false;
     KisSelectionMaskSP m_selectionMask;
     QList<KisEffectMaskSP> m_effectMasks;
 };
 
 struct Q_DECL_HIDDEN KisLayer::Private
 {
     Private(KisLayer *q)
         : masksCache(q)
     {
     }
 
     QBitArray channelFlags;
     KisMetaData::Store* metaDataStore;
     KisCloneLayersList clonesList;
 
     KisPSDLayerStyleSP layerStyle;
     KisLayerStyleProjectionPlaneSP layerStyleProjectionPlane;
 
-    KisAbstractProjectionPlaneSP projectionPlane;
+    KisLayerProjectionPlaneSP projectionPlane;
     KisSafeNodeProjectionStoreSP safeProjection;
 
     KisLayerMasksCache masksCache;
 };
 
 
 KisLayer::KisLayer(KisImageWSP image, const QString &name, quint8 opacity)
         : KisNode(image)
         , m_d(new Private(this))
 {
     setName(name);
     setOpacity(opacity);
     m_d->metaDataStore = new KisMetaData::Store();
     m_d->projectionPlane = toQShared(new KisLayerProjectionPlane(this));
     m_d->safeProjection = new KisSafeNodeProjectionStore();
     m_d->safeProjection->setImage(image);
 }
 
 KisLayer::KisLayer(const KisLayer& rhs)
         : KisNode(rhs)
         , m_d(new Private(this))
 {
     if (this != &rhs) {
         m_d->metaDataStore = new KisMetaData::Store(*rhs.m_d->metaDataStore);
         m_d->channelFlags = rhs.m_d->channelFlags;
 
         setName(rhs.name());
         m_d->projectionPlane = toQShared(new KisLayerProjectionPlane(this));
         m_d->safeProjection = new KisSafeNodeProjectionStore(*rhs.m_d->safeProjection);
         m_d->safeProjection->setImage(image());
 
         if (rhs.m_d->layerStyle) {
             m_d->layerStyle = rhs.m_d->layerStyle->clone();
 
             if (rhs.m_d->layerStyleProjectionPlane) {
                 m_d->layerStyleProjectionPlane = toQShared(
                     new KisLayerStyleProjectionPlane(*rhs.m_d->layerStyleProjectionPlane,
                                                      this,
                                                      m_d->layerStyle));
             }
         }
     }
 }
 
 KisLayer::~KisLayer()
 {
     delete m_d->metaDataStore;
     delete m_d;
 }
 
 const KoColorSpace * KisLayer::colorSpace() const
 {
     KisImageSP image = this->image();
     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;
 
         KisLayerStyleProjectionPlaneSP plane = !layerStyle->isEmpty() ?
             KisLayerStyleProjectionPlaneSP(new KisLayerStyleProjectionPlane(this)) :
             KisLayerStyleProjectionPlaneSP(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);
 }
 
 void KisLayer::setImage(KisImageWSP 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));
     }
     m_d->safeProjection->setImage(image);
 
     KisNode::setImage(image);
 }
 
 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()
 {
     m_d->masksCache.setDirty();
 }
 
 KisSelectionMaskSP KisLayer::selectionMask() const
 {
     return m_d->masksCache.selectionMask();
 }
 
 KisSelectionSP KisLayer::selection() const
 {
     KisSelectionMaskSP mask = selectionMask();
 
     if (mask) {
         return mask->selection();
     }
 
     KisImageSP image = this->image();
     if (image) {
         return image->globalSelection();
     }
     return KisSelectionSP();
 }
 
 ///////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////
 
 QList<KisEffectMaskSP> KisLayer::effectMasks() const
 {
     return m_d->masksCache.effectMasks();
 }
 
 QList<KisEffectMaskSP> KisLayer::effectMasks(KisNodeSP lastNode) const
 {
     if (lastNode.isNull()) {
         return effectMasks();
     } else {
         // happens rarely.
         return searchEffectMasks(lastNode);
     }
 }
 
 QList<KisEffectMaskSP> KisLayer::searchEffectMasks(KisNodeSP lastNode) const
 {
     QList<KisEffectMaskSP> masks;
 
     KIS_SAFE_ASSERT_RECOVER_NOOP(projectionLeaf());
 
     KisProjectionLeafSP child = projectionLeaf()->firstChild();
     while (child) {
         if (child->node() == lastNode) break;
 
         KIS_SAFE_ASSERT_RECOVER_NOOP(child);
         KIS_SAFE_ASSERT_RECOVER_NOOP(child->node());
 
         if (child->visible()) {
             KisEffectMaskSP mask = dynamic_cast<KisEffectMask*>(const_cast<KisNode*>(child->node().data()));
             if (mask) {
                 masks.append(mask);
             }
         }
 
         child = child->nextSibling();
     }
 
     return masks;
 }
 
 bool KisLayer::hasEffectMasks() const
 {
     return  !m_d->masksCache.effectMasks().isEmpty();
 }
 
 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() && !hasClones()) ||
         !originalDevice) return QRect();
 
     if (!needProjection() && !hasEffectMasks()) {
         m_d->safeProjection->releaseDevice();
     } 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 ?
-        KisAbstractProjectionPlaneSP(m_d->layerStyleProjectionPlane) : m_d->projectionPlane;
+        KisAbstractProjectionPlaneSP(m_d->layerStyleProjectionPlane) :
+        KisAbstractProjectionPlaneSP(m_d->projectionPlane);
 }
 
-KisAbstractProjectionPlaneSP KisLayer::internalProjectionPlane() const
+KisLayerProjectionPlaneSP 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();
     }
 }
 
 QRect KisLayer::incomingChangeRect(const QRect &rect) const
 {
     return rect;
 }
 
 QRect KisLayer::outgoingChangeRect(const QRect &rect) const
 {
     return rect;
 }
 
 QRect KisLayer::needRectForOriginal(const QRect &rect) const
 {
     QRect needRect = rect;
 
     const QList<KisEffectMaskSP> masks = effectMasks();
 
     if (!masks.isEmpty()) {
         QStack<QRect> applyRects;
         bool needRectVaries;
 
         needRect = masksNeedRect(masks, rect,
                                  applyRects, needRectVaries);
     }
 
     return needRect;
 }
 
 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/kis_layer.h b/libs/image/kis_layer.h
index bd05ff04f0..380e3375ae 100644
--- a/libs/image/kis_layer.h
+++ b/libs/image/kis_layer.h
@@ -1,417 +1,419 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2005 C. Boemann <cbo@boemann.dk>
  *  Copyright (c) 2007 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2009 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef KIS_LAYER_H_
 #define KIS_LAYER_H_
 
 #include <QRect>
 #include <QRegion>
 #include <QMetaType>
 #include <QObject>
 
 #include "kritaimage_export.h"
 
 #include "kis_base_node.h"
 
 #include "kis_types.h"
 #include "kis_node.h"
 #include "kis_psd_layer_style.h"
 
 template <class T>
 class QStack;
 
 class QBitArray;
 class KisCloneLayer;
 class KisPSDLayerStyle;
 class KisAbstractProjectionPlane;
+class KisLayerProjectionPlane;
+typedef QSharedPointer<KisLayerProjectionPlane> KisLayerProjectionPlaneSP;
 
 
 namespace KisMetaData
 {
 class Store;
 }
 
 /**
  * Abstract class that represents the concept of a Layer in Krita. This is not related
  * to the paint devices: this is merely an abstraction of how layers can be stacked and
  * rendered differently.
  * Regarding the previous-, first-, next- and lastChild() calls, first means that it the layer
  * is at the top of the group in the layerlist, using next will iterate to the bottom to last,
  * whereas previous will go up to first again.
  *
  *
  * TODO: Add a layer mode whereby the projection of the layer is used
  * as a clipping path?
  **/
 class KRITAIMAGE_EXPORT KisLayer : public KisNode
 {
 
     Q_OBJECT
 
 public:
 
     /**
      * @param image is the pointer of the image or null
      * @param opacity is a value between OPACITY_TRANSPARENT_U8 and OPACITY_OPAQUE_U8
     **/
     KisLayer(KisImageWSP image, const QString &name, quint8 opacity);
     KisLayer(const KisLayer& rhs);
     ~KisLayer() override;
 
     /// returns the image's colorSpace or null, if there is no image
     const KoColorSpace * colorSpace() const override;
 
     /// returns the layer's composite op for the colorspace of the layer's parent.
     const KoCompositeOp * compositeOp() const override;
 
     KisPSDLayerStyleSP layerStyle() const;
     void setLayerStyle(KisPSDLayerStyleSP layerStyle);
 
     /**
      * \see a comment in KisNode::projectionPlane()
      */
     KisAbstractProjectionPlaneSP projectionPlane() const override;
 
     /**
      * The projection plane representing the layer itself without any
      * styles or anything else. It is used by the layer styles projection
      * plane to stack up the planes.
      */
-    virtual KisAbstractProjectionPlaneSP internalProjectionPlane() const;
+    virtual KisLayerProjectionPlaneSP internalProjectionPlane() const;
 
     QRect partialChangeRect(KisNodeSP lastNode, const QRect& rect);
     void buildProjectionUpToNode(KisPaintDeviceSP projection, KisNodeSP lastNode, const QRect& rect);
 
     virtual bool needProjection() const;
 
     /**
      * Return the fully rendered representation of this layer: its
      * data and its effect masks
      */
     KisPaintDeviceSP projection() const override;
 
     /**
      * Return the layer data before the effect masks have had their go
      * at it.
      */
     KisPaintDeviceSP original() const override = 0;
 
     /**
      * @return the selection associated with this layer, if there is
      * one. Otherwise, return 0;
      */
     virtual KisSelectionMaskSP selectionMask() const;
 
     /**
      * @return the selection contained in the first KisSelectionMask associated
      * with this layer or the image, if either exists, otherwise, return 0.
      */
     virtual KisSelectionSP selection() const;
 
     KisBaseNode::PropertyList sectionModelProperties() const override;
     void setSectionModelProperties(const KisBaseNode::PropertyList &properties) override;
 
     /**
      * set/unset the channel flag for the alpha channel of this layer
      */
     void disableAlphaChannel(bool disable);
 
     /**
      * returns true if the channel flag for the alpha channel
      * of this layer is not set.
      * returns false otherwise.
      */
     bool alphaChannelDisabled() const;
 
     /**
      * set the channelflags for this layer to the specified bit array.
      * The bit array must have exactly the same number of channels as
      * the colorspace this layer is in, or be empty, in which case all
      * channels are active.
      */
     virtual void setChannelFlags(const QBitArray & channelFlags);
 
     /**
      * Return a bit array where each bit indicates whether a
      * particular channel is active or not. If the channelflags bit
      * array is empty, all channels are active.
      */
     QBitArray & channelFlags() const;
 
     /**
      * Returns true if this layer is temporary: i.e., it should not
      * appear in the layerbox, even though it is temporarily in the
      * layer stack and taken into account on recomposition.
      */
     bool temporary() const;
 
     /**
      * Set to true if this layer should not appear in the layerbox,
      * even though it is temporarily in the layer stack and taken into
      * account on recomposition.
      */
     void setTemporary(bool t);
 
     /**
      * Set the image this layer belongs to.
      */
     void setImage(KisImageWSP image) override;
 
     /**
      * Create and return a layer that is the result of merging
      * this with layer.
      *
      * This method is designed to be called only within KisImage::mergeLayerDown().
      *
      * Decendands override this to create specific merged types when possible.
      * The KisLayer one creates a KisPaintLayerSP via a bitBlt, and can work on all layer types.
      *
      * Descendants that perform their own version do NOT call KisLayer::createMergedLayer
      */
     virtual KisLayerSP createMergedLayerTemplate(KisLayerSP prevLayer);
     virtual void fillMergedLayerTemplate(KisLayerSP dstLayer, KisLayerSP prevLayer);
 
     /**
      * Clones should be informed about updates of the original
      * layer, so this is a way to register them
      */
     void registerClone(KisCloneLayerWSP clone);
 
     /**
      * Deregisters the clone from the update list
      *
      * \see registerClone()
      */
     void unregisterClone(KisCloneLayerWSP clone);
 
     /**
      * Return the list of the clones of this node. Be careful
      * with the list, because it is not thread safe.
      */
     const QList<KisCloneLayerWSP> registeredClones() const;
 
 
     /**
      * Returns whether we have a clone.
      *
      * Be careful with it. It is not thread safe to add/remove
      * clone while checking hasClones(). So there should be no updates.
      */
     bool hasClones() const;
 
     /**
      * It is calles by the async merger after projection update is done
      */
     void updateClones(const QRect &rect);
 
     /**
      * Informs this layers that its masks might have changed.
      */
     void notifyChildMaskChanged();
 
 public:
     qint32 x() const override;
     qint32 y() const override;
 
     void setX(qint32 x) override;
     void setY(qint32 y) override;
 
     /**
      * Returns an approximation of where the bounds
      * of actual data of this layer are
      */
     QRect extent() const override;
 
     /**
      * Returns the exact bounds of where the actual data
      * of this layer resides
      */
     QRect exactBounds() const override;
 
     QImage createThumbnail(qint32 w, qint32 h) override;
 
     QImage createThumbnailForFrame(qint32 w, qint32 h, int time) override;
 
 public:
     /**
      * Returns true if there are any effect masks present
      */
     bool hasEffectMasks() const;
 
     /**
      * @return the list of effect masks
      */
     QList<KisEffectMaskSP> effectMasks() const;
 
     /**
      * @return the list of effect masks up to a certain node
      */
     QList<KisEffectMaskSP> effectMasks(KisNodeSP lastNode) const;
 
     /**
      * Get the group layer that contains this layer.
      */
     KisLayerSP parentLayer() const;
 
     /**
      * @return the metadata object associated with this object.
      */
     KisMetaData::Store* metaData();
 
 protected:
     // override from KisNode
     QRect changeRect(const QRect &rect, PositionToFilthy pos = N_FILTHY) const override;
 
     void childNodeChanged(KisNodeSP changedChildNode) override;
 
 protected:
 
     /**
      * Ask the layer to assemble its data & apply all the effect masks
      * to it.
      */
     QRect updateProjection(const QRect& rect, KisNodeSP filthyNode);
 
     /**
      * Layers can override this method to get some special behavior
      * when copying data from \p original to \p projection, e.g. blend
      * in indirect painting device.  If you need to modify data
      * outside \p rect, please also override outgoingChangeRect()
      * method.
      */
     virtual void copyOriginalToProjection(const KisPaintDeviceSP original,
                                           KisPaintDeviceSP projection,
                                           const QRect& rect) const;
     /**
      * For KisLayer classes change rect transformation consists of two
      * parts: incoming and outgoing.
      *
      * 1) incomingChangeRect(rect) chande rect transformation
      *    performed by the transformations done basing on global
      *    projection. It is performed in KisAsyncMerger +
      *    KisUpdateOriginalVisitor classes. It happens before data
      *    coming to KisLayer::original() therefore it is
      *    'incoming'. See KisAdjustmentLayer for example of usage.
      *
      * 2) outgoingChangeRect(rect) change rect transformation that
      *    happens in KisLayer::copyOriginalToProjection(). It applies
      *    *only* when the layer is 'filthy', that is was the cause of
      *    the merge process. See KisCloneLayer for example of usage.
      *
      * The flow of changed areas can be illustrated in the
      * following way:
      *
      * 1. Current projection of size R1 is stored in KisAsyncMerger::m_currentProjection
      *      |
      *      | <-- KisUpdateOriginalVisitor writes data into layer's original() device.
      *      |     The changed area on KisLayer::original() is
      *      |     R2 = KisLayer::incomingChangeRect(R1)
      *      |
      * 2. KisLayer::original() / changed rect: R2
      *      |
      *      | <-- KisLayer::updateProjection() starts composing a layer
      *      |     It calls KisLayer::copyOriginalToProjection() which copies some area
      *      |     to a temporaty device. The temporary device now stores
      *      |     R3 = KisLayer::outgoingChangeRect(R2)
      *      |
      * 3. Temporary device / changed rect: R3
      *      |
      *      | <-- KisLayer::updateProjection() continues composing a layer. It merges a mask.
      *      |     R4 = KisMask::changeRect(R3)
      *      |
      * 4. KisLayer::original() / changed rect: R4
      *
      * So in the end rect R4 will be passed up to the next layers in the stack.
      */
     virtual QRect incomingChangeRect(const QRect &rect) const;
 
     /**
      * \see incomingChangeRect()
      */
     virtual QRect outgoingChangeRect(const QRect &rect) const;
 
     /**
      * Return need rect that should be prepared on original()
      * device of the layer to get \p rect on its projection.
      *
      * This method is used either for layers that can have other
      * layers as children (yes, KisGroupLayer, I'm looking at you!),
      * or for layers that depend on the lower nodes (it's you,
      * KisAdjustmentLayer!).
      *
      * These layers may have some filter masks that need a bit
      * more pixels than requested, therefore child nodes should do
      * a bit more work to prepare them.
      */
     QRect needRectForOriginal(const QRect &rect) const;
 
     /**
      * @param rectVariesFlag (out param) a flag, showing whether
      *        a rect varies from mask to mask
      * @return an area that should be updated because of
      *         the change of @requestedRect of the layer
      */
     QRect masksChangeRect(const QList<KisEffectMaskSP> &masks,
                           const QRect &requestedRect,
                           bool &rectVariesFlag) const;
 
     /**
      * Get needRects for all masks
      * @param changeRect requested rect to be updated on final
      *        projection. Should be a return value
      *        of @ref masksChangedRect()
      * @param applyRects (out param) a stack of the rects where filters
      *        should be applied
      * @param rectVariesFlag (out param) a flag, showing whether
      *        a rect varies from mask to mask
      * @return a needRect that should be prepared on the layer's
      *         paintDevice for all masks to succeed
      */
     QRect masksNeedRect(const QList<KisEffectMaskSP> &masks,
                         const QRect &changeRect,
                         QStack<QRect> &applyRects,
                         bool &rectVariesFlag) const;
 
     QRect applyMasks(const KisPaintDeviceSP source,
                      KisPaintDeviceSP destination,
                      const QRect &requestedRect,
                      KisNodeSP filthyNode, KisNodeSP lastNode) const;
 
     bool canMergeAndKeepBlendOptions(KisLayerSP otherLayer);
 
     QList<KisEffectMaskSP> searchEffectMasks(KisNodeSP lastNode) const;
 
 private:
     friend class KisLayerMasksCache;
     friend class KisLayerProjectionPlane;
     friend class KisTransformMask;
     friend class KisLayerTest;
 
 private:
     QRect layerExtentImpl(bool exactBounds) const;
 
 private:
     struct Private;
     Private * const m_d;
 };
 
 Q_DECLARE_METATYPE(KisLayerSP)
 
 #endif // KIS_LAYER_H_
diff --git a/libs/image/kis_layer_projection_plane.cpp b/libs/image/kis_layer_projection_plane.cpp
index 534f6334dc..0ee62c63e5 100644
--- a/libs/image/kis_layer_projection_plane.cpp
+++ b/libs/image/kis_layer_projection_plane.cpp
@@ -1,126 +1,158 @@
 /*
  *  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_layer_projection_plane.h"
 
 #include <QBitArray>
 #include <KoColorSpace.h>
 #include <KoChannelInfo.h>
 #include <KoCompositeOpRegistry.h>
 #include "kis_painter.h"
 #include "kis_projection_leaf.h"
+#include "kis_cached_paint_device.h"
+#include "kis_sequential_iterator.h"
 
 
 struct KisLayerProjectionPlane::Private
 {
     KisLayer *layer;
+    KisCachedPaintDevice cachedDevice;
 };
 
 
 KisLayerProjectionPlane::KisLayerProjectionPlane(KisLayer *layer)
     : m_d(new Private)
 {
     m_d->layer = layer;
 }
 
 KisLayerProjectionPlane::~KisLayerProjectionPlane()
 {
 }
 
 QRect KisLayerProjectionPlane::recalculate(const QRect& rect, KisNodeSP filthyNode)
 {
     return m_d->layer->updateProjection(rect, filthyNode);
 }
 
-void KisLayerProjectionPlane::apply(KisPainter *painter, const QRect &rect)
+void KisLayerProjectionPlane::applyImpl(KisPainter *painter, const QRect &rect, bool maxOutAlpha)
 {
     KisPaintDeviceSP device = m_d->layer->projection();
     if (!device) return;
 
     QRect needRect = rect;
 
     if (m_d->layer->compositeOpId() != COMPOSITE_COPY &&
         m_d->layer->compositeOpId() != COMPOSITE_DESTINATION_IN  &&
         m_d->layer->compositeOpId() != COMPOSITE_DESTINATION_ATOP) {
 
         needRect &= device->extent();
     }
 
     if(needRect.isEmpty()) return;
 
     QBitArray channelFlags = m_d->layer->projectionLeaf()->channelFlags();
 
 
     // if the color spaces don't match we will have a problem with the channel flags
     // because the channel flags from the source layer doesn't match with the colorspace of the projection device
     // this leads to the situation that the wrong channels will be enabled/disabled
     const KoColorSpace* srcCS = device->colorSpace();
     const KoColorSpace* dstCS = painter->device()->colorSpace();
 
     if (!channelFlags.isEmpty() && srcCS != dstCS) {
         bool alphaFlagIsSet        = (srcCS->channelFlags(false,true) & channelFlags) == srcCS->channelFlags(false,true);
         bool allColorFlagsAreSet   = (srcCS->channelFlags(true,false) & channelFlags) == srcCS->channelFlags(true,false);
         bool allColorFlagsAreUnset = (srcCS->channelFlags(true,false) & channelFlags).count(true) == 0;
 
         if(allColorFlagsAreSet) {
             channelFlags = dstCS->channelFlags(true, alphaFlagIsSet);
         } else if(allColorFlagsAreUnset) {
             channelFlags = dstCS->channelFlags(false, alphaFlagIsSet);
         } else {
             //TODO: convert the cannel flags properly
             //      for now just the alpha channel bit is copied and the other channels are left alone
             for (quint32 i=0; i < dstCS->channelCount(); ++i) {
                 if (dstCS->channels()[i]->channelType() == KoChannelInfo::ALPHA) {
                     channelFlags.setBit(i, alphaFlagIsSet);
                     break;
                 }
             }
         }
     }
 
+    if (maxOutAlpha) {
+        KisPaintDeviceSP tmp = m_d->cachedDevice.getDevice(device);
+        tmp->makeCloneFromRough(device, needRect);
+        const KoColorSpace *cs = tmp->colorSpace();
+
+        KisSequentialIterator it(tmp, needRect);
+        int numConseqPixels = it.nConseqPixels();
+        while (it.nextPixels(numConseqPixels)) {
+            numConseqPixels = it.nConseqPixels();
+            cs->setOpacity(it.rawData(), quint8(255), numConseqPixels);
+        }
+
+        device = tmp;
+    }
+
     painter->setChannelFlags(channelFlags);
     painter->setCompositeOp(m_d->layer->compositeOpId());
     painter->setOpacity(m_d->layer->projectionLeaf()->opacity());
     painter->bitBlt(needRect.topLeft(), device, needRect);
+
+    if (maxOutAlpha) {
+        m_d->cachedDevice.putDevice(device);
+    }
+}
+
+void KisLayerProjectionPlane::apply(KisPainter *painter, const QRect &rect)
+{
+    applyImpl(painter, rect, false);
+}
+
+void KisLayerProjectionPlane::applyMaxOutAlpha(KisPainter *painter, const QRect &rect)
+{
+    applyImpl(painter, rect, true);
 }
 
 KisPaintDeviceList KisLayerProjectionPlane::getLodCapableDevices() const
 {
     return KisPaintDeviceList() << m_d->layer->projection();
 }
 
 QRect KisLayerProjectionPlane::needRect(const QRect &rect, KisLayer::PositionToFilthy pos) const
 {
     return m_d->layer->needRect(rect, pos);
 }
 
 QRect KisLayerProjectionPlane::changeRect(const QRect &rect, KisLayer::PositionToFilthy pos) const
 {
     return m_d->layer->changeRect(rect, pos);
 }
 
 QRect KisLayerProjectionPlane::accessRect(const QRect &rect, KisLayer::PositionToFilthy pos) const
 {
     return m_d->layer->accessRect(rect, pos);
 }
 
 QRect KisLayerProjectionPlane::needRectForOriginal(const QRect &rect) const
 {
     return m_d->layer->needRectForOriginal(rect);
 }
 
diff --git a/libs/image/kis_layer_projection_plane.h b/libs/image/kis_layer_projection_plane.h
index a684461cd9..141e4588d2 100644
--- a/libs/image/kis_layer_projection_plane.h
+++ b/libs/image/kis_layer_projection_plane.h
@@ -1,52 +1,60 @@
 /*
  *  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_LAYER_PROJECTION_PLANE_H
 #define __KIS_LAYER_PROJECTION_PLANE_H
 
 #include "kis_abstract_projection_plane.h"
 
 #include <QScopedPointer>
 
 
 /**
  * An implementation of the KisAbstractProjectionPlane interface for a
  * layer object
  */
 class KisLayerProjectionPlane : public KisAbstractProjectionPlane
 {
 public:
     KisLayerProjectionPlane(KisLayer *layer);
     ~KisLayerProjectionPlane() override;
 
     QRect recalculate(const QRect& rect, KisNodeSP filthyNode) override;
     void apply(KisPainter *painter, const QRect &rect) override;
+    void applyMaxOutAlpha(KisPainter *painter, const QRect &rect);
 
     QRect needRect(const QRect &rect, KisLayer::PositionToFilthy pos) const override;
     QRect changeRect(const QRect &rect, KisLayer::PositionToFilthy pos) const override;
     QRect accessRect(const QRect &rect, KisLayer::PositionToFilthy pos) const override;
     QRect needRectForOriginal(const QRect &rect) const override;
 
     KisPaintDeviceList getLodCapableDevices() const override;
 
+private:
+    void applyImpl(KisPainter *painter, const QRect &rect, bool maxOutAlpha);
+
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
+typedef QSharedPointer<KisLayerProjectionPlane> KisLayerProjectionPlaneSP;
+typedef QWeakPointer<KisLayerProjectionPlane> KisLayerProjectionPlaneWSP;
+
+
 #endif /* __KIS_LAYER_PROJECTION_PLANE_H */
diff --git a/libs/image/kis_mask.cc b/libs/image/kis_mask.cc
index b07dd02001..a3ae67b967 100644
--- a/libs/image/kis_mask.cc
+++ b/libs/image/kis_mask.cc
@@ -1,514 +1,513 @@
 /*
  *  Copyright (c) 2006 Boudewijn Rempt <boud@valdyas.org>
  *            (c) 2009 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_mask.h"
 
 
 #include <kis_debug.h>
 
 // to prevent incomplete class types on "delete selection->flatten();"
 #include <kundo2command.h>
 
 #include <QScopedPointer>
 
 #include <KoColor.h>
 #include <KoColorSpace.h>
 #include <KoCompositeOpRegistry.h>
 
 #include "kis_paint_device.h"
 #include "kis_selection.h"
 #include "kis_pixel_selection.h"
 #include "kis_painter.h"
 
 #include "kis_image.h"
 #include "kis_layer.h"
 
 #include "kis_cached_paint_device.h"
 #include "kis_mask_projection_plane.h"
 
 #include "kis_raster_keyframe_channel.h"
 #include "KisSafeNodeProjectionStore.h"
 
 
 struct Q_DECL_HIDDEN KisMask::Private {
     Private(KisMask *_q)
         : q(_q),
           projectionPlane(new KisMaskProjectionPlane(q))
     {
     }
 
     mutable KisSelectionSP selection;
     KisCachedPaintDevice paintDeviceCache;
     KisMask *q;
 
     /**
      * Due to the design of the Kra format the X,Y offset of the paint
      * device belongs to the node, but not to the device itself.  So
      * the offset is set when the node is created, but not when the
      * selection is initialized. This causes the X,Y values to be
      * lost, since the selection doen not exist at the moment. That is
      * why we save it separately.
      */
     QScopedPointer<QPoint> deferredSelectionOffset;
 
     KisAbstractProjectionPlaneSP projectionPlane;
     KisSafeSelectionNodeProjectionStoreSP safeProjection;
 
     void initSelectionImpl(KisSelectionSP copyFrom, KisLayerSP parentLayer, KisPaintDeviceSP copyFromDevice);
 };
 
 KisMask::KisMask(const QString & name)
         : KisNode(nullptr)
         , m_d(new Private(this))
 {
     setName(name);
     m_d->safeProjection = new KisSafeSelectionNodeProjectionStore();
     m_d->safeProjection->setImage(image());
 }
 
 KisMask::KisMask(const KisMask& rhs)
         : KisNode(rhs)
         , KisIndirectPaintingSupport()
         , m_d(new Private(this))
 {
     setName(rhs.name());
 
     m_d->safeProjection = new KisSafeSelectionNodeProjectionStore(*rhs.m_d->safeProjection);
 
     if (rhs.m_d->selection) {
         m_d->selection = new KisSelection(*rhs.m_d->selection.data());
         m_d->selection->setParentNode(this);
 
         KisPixelSelectionSP pixelSelection = m_d->selection->pixelSelection();
         if (pixelSelection->framesInterface()) {
             addKeyframeChannel(pixelSelection->keyframeChannel());
             enableAnimation();
         }
     }
 }
 
 KisMask::~KisMask()
 {
     if (m_d->selection) {
         m_d->selection->setParentNode(0);
     }
 
     delete m_d;
 }
 
 void KisMask::setImage(KisImageWSP image)
 {
     KisPaintDeviceSP parentPaintDevice = parent() ? parent()->original() : 0;
     KisDefaultBoundsBaseSP defaultBounds = new KisSelectionDefaultBounds(parentPaintDevice, image);
     if (m_d->selection) {
         m_d->selection->setDefaultBounds(defaultBounds);
     }
 
     m_d->safeProjection->setImage(image);
 
     KisNode::setImage(image);
 }
 
 bool KisMask::allowAsChild(KisNodeSP node) const
 {
     Q_UNUSED(node);
     return false;
 }
 
 const KoColorSpace * KisMask::colorSpace() const
 {
     KisNodeSP parentNode = parent();
     return parentNode ? parentNode->colorSpace() : 0;
 }
 
 const KoCompositeOp * KisMask::compositeOp() const
 {
     /**
      * FIXME: This function duplicates the same function from
      * KisLayer. We can't move it to KisBaseNode as it doesn't
      * know anything about parent() method of KisNode
      * Please think it over...
      */
 
     const KoColorSpace *colorSpace = this->colorSpace();
     if (!colorSpace) return 0;
 
     const KoCompositeOp* op = colorSpace->compositeOp(compositeOpId());
     return op ? op : colorSpace->compositeOp(COMPOSITE_OVER);
 }
 
 void KisMask::initSelection(KisSelectionSP copyFrom, KisLayerSP parentLayer)
 {
     m_d->initSelectionImpl(copyFrom, parentLayer, 0);
 }
 
 void KisMask::initSelection(KisPaintDeviceSP copyFromDevice, KisLayerSP parentLayer)
 {
     m_d->initSelectionImpl(0, parentLayer, copyFromDevice);
 }
 
 void KisMask::initSelection(KisLayerSP parentLayer)
 {
     m_d->initSelectionImpl(0, parentLayer, 0);
 }
 
 void KisMask::Private::initSelectionImpl(KisSelectionSP copyFrom, KisLayerSP parentLayer, KisPaintDeviceSP copyFromDevice)
 {
     Q_ASSERT(parentLayer);
 
     KisPaintDeviceSP parentPaintDevice = parentLayer->original();
 
     if (copyFrom) {
         /**
          * We can't use setSelection as we may not have parent() yet
          */
         selection = new KisSelection(*copyFrom);
         selection->setDefaultBounds(new KisSelectionDefaultBounds(parentPaintDevice, parentLayer->image()));
         if (copyFrom->hasShapeSelection()) {
             delete selection->flatten();
         }
     } else if (copyFromDevice) {
         KritaUtils::DeviceCopyMode copyMode =
             q->inherits("KisFilterMask") || q->inherits("KisTransparencyMask") ?
             KritaUtils::CopyAllFrames : KritaUtils::CopySnapshot;
 
         selection = new KisSelection(copyFromDevice, copyMode, new KisSelectionDefaultBounds(parentPaintDevice, parentLayer->image()));
 
         KisPixelSelectionSP pixelSelection = selection->pixelSelection();
         if (pixelSelection->framesInterface()) {
             KisRasterKeyframeChannel *keyframeChannel = pixelSelection->keyframeChannel();
             keyframeChannel->setFilenameSuffix(".pixelselection");
 
             q->addKeyframeChannel(keyframeChannel);
             q->enableAnimation();
         }
     } else {
         selection = new KisSelection(new KisSelectionDefaultBounds(parentPaintDevice, parentLayer->image()));
         selection->pixelSelection()->setDefaultPixel(KoColor(Qt::white, selection->pixelSelection()->colorSpace()));
 
         if (deferredSelectionOffset) {
             selection->setX(deferredSelectionOffset->x());
             selection->setY(deferredSelectionOffset->y());
             deferredSelectionOffset.reset();
         }
     }
     selection->setParentNode(q);
     selection->updateProjection();
 }
 
 KisSelectionSP KisMask::selection() const
 {
     return m_d->selection;
 }
 
 KisPaintDeviceSP KisMask::paintDevice() const
 {
     KisSelectionSP selection = this->selection();
     return selection ? selection->pixelSelection() : 0;
 }
 
 KisPaintDeviceSP KisMask::original() const
 {
     return paintDevice();
 }
 
 KisPaintDeviceSP KisMask::projection() const
 {
     KisPaintDeviceSP originalDevice = original();
     KisPaintDeviceSP result = originalDevice;
 
     KisSelectionSP selection = this->selection();
     if (selection && hasTemporaryTarget()) {
         result = m_d->safeProjection->getDeviceLazy(selection)->pixelSelection();
     }
 
     return result;
 }
 
 KisAbstractProjectionPlaneSP KisMask::projectionPlane() const
 {
     return m_d->projectionPlane;
 }
 
 void KisMask::setSelection(KisSelectionSP selection)
 {
     m_d->selection = selection;
     if (parent()) {
         const KisLayer *parentLayer = qobject_cast<const KisLayer*>(parent());
         m_d->selection->setDefaultBounds(new KisDefaultBounds(parentLayer->image()));
     }
     m_d->selection->setParentNode(this);
 }
 
 void KisMask::select(const QRect & rc, quint8 selectedness)
 {
     KisSelectionSP sel = selection();
     KisPixelSelectionSP psel = sel->pixelSelection();
     psel->select(rc, selectedness);
     sel->updateProjection(rc);
 }
 
 
 QRect KisMask::decorateRect(KisPaintDeviceSP &src,
                             KisPaintDeviceSP &dst,
                             const QRect & rc,
                             PositionToFilthy maskPos) const
 {
     Q_UNUSED(src);
     Q_UNUSED(dst);
     Q_UNUSED(maskPos);
     Q_ASSERT_X(0, "KisMask::decorateRect", "Should be overridden by successors");
     return rc;
 }
 
 bool KisMask::paintsOutsideSelection() const
 {
     return false;
 }
 
 void KisMask::apply(KisPaintDeviceSP projection, const QRect &applyRect, const QRect &needRect, PositionToFilthy maskPos) const
 {
     if (selection()) {
 
         flattenSelectionProjection(m_d->selection, applyRect);
 
         KisSelectionSP effectiveSelection = m_d->selection;
 
         {
             // Access temporary target under the lock held
             KisIndirectPaintingSupport::ReadLocker l(this);
 
             if (!paintsOutsideSelection()) {
                 // extent of m_d->selection should also be accessed under a lock,
                 // because it might be being merged in by the temporary target atm
                 QRect effectiveExtent = m_d->selection->selectedRect();
 
                 if (hasTemporaryTarget()) {
                     effectiveExtent |= temporaryTarget()->extent();
                 }
 
                 if(!effectiveExtent.intersects(applyRect)) {
                     return;
                 }
             }
 
             if (hasTemporaryTarget()) {
                 effectiveSelection = m_d->safeProjection->getDeviceLazy(m_d->selection);
 
                 KisPainter::copyAreaOptimized(applyRect.topLeft(),
                                               m_d->selection->pixelSelection(),
                                               effectiveSelection->pixelSelection(), applyRect);
 
                 KisPainter gc(effectiveSelection->pixelSelection());
                 setupTemporaryPainter(&gc);
                 gc.bitBlt(applyRect.topLeft(), temporaryTarget(), applyRect);
             } else {
                 m_d->safeProjection->releaseDevice();
             }
 
             mergeInMaskInternal(projection, effectiveSelection, applyRect, needRect, maskPos);
         }
 
     } else {
         mergeInMaskInternal(projection, 0, applyRect, needRect, maskPos);
     }
 }
 
 void KisMask::mergeInMaskInternal(KisPaintDeviceSP projection,
                                   KisSelectionSP effectiveSelection,
                                   const QRect &applyRect,
                                   const QRect &preparedNeedRect,
                                   KisNode::PositionToFilthy maskPos) const
 {
-    KisPaintDeviceSP cacheDevice = m_d->paintDeviceCache.getDevice(projection);
+    KisCachedPaintDevice::Guard d1(projection, m_d->paintDeviceCache);
+    KisPaintDeviceSP cacheDevice = d1.device();
 
     if (effectiveSelection) {
         QRect updatedRect = decorateRect(projection, cacheDevice, applyRect, maskPos);
 
         // masks don't have any compositioning
         KisPainter::copyAreaOptimized(updatedRect.topLeft(), cacheDevice, projection, updatedRect, effectiveSelection);
 
     } else {
         cacheDevice->makeCloneFromRough(projection, preparedNeedRect);
         projection->clear(preparedNeedRect);
 
         decorateRect(cacheDevice, projection, applyRect, maskPos);
     }
-
-    m_d->paintDeviceCache.putDevice(cacheDevice);
 }
 
 void KisMask::flattenSelectionProjection(KisSelectionSP selection, const QRect &dirtyRect) const
 {
     selection->updateProjection(dirtyRect);
 }
 
 QRect KisMask::needRect(const QRect &rect,  PositionToFilthy pos) const
 {
     Q_UNUSED(pos);
     QRect resultRect = rect;
     if (m_d->selection) {
         QRect selectionExtent = m_d->selection->selectedRect();
 
         // copy for thread safety!
         KisPaintDeviceSP temporaryTarget = this->temporaryTarget();
 
         if (temporaryTarget) {
             selectionExtent |= temporaryTarget->extent();
         }
 
         resultRect &= selectionExtent;
     }
 
     return resultRect;
 }
 
 QRect KisMask::changeRect(const QRect &rect, PositionToFilthy pos) const
 {
     return KisMask::needRect(rect, pos);
 }
 
 QRect KisMask::extent() const
 {
     QRect resultRect;
 
     if (m_d->selection) {
         resultRect = m_d->selection->selectedRect();
 
         // copy for thread safety!
         KisPaintDeviceSP temporaryTarget = this->temporaryTarget();
 
         if (temporaryTarget) {
             resultRect |= temporaryTarget->extent();
         }
     } else if (KisNodeSP parent = this->parent()) {
         resultRect = parent->extent();
     }
 
     return resultRect;
 }
 
 QRect KisMask::exactBounds() const
 {
     QRect resultRect;
 
     if (m_d->selection) {
         resultRect = m_d->selection->selectedExactRect();
 
         // copy for thread safety!
         KisPaintDeviceSP temporaryTarget = this->temporaryTarget();
 
         if (temporaryTarget) {
             resultRect |= temporaryTarget->exactBounds();
         }
     } else if (KisNodeSP parent = this->parent()) {
         resultRect = parent->exactBounds();
     }
 
     return resultRect;
 }
 
 qint32 KisMask::x() const
 {
     return m_d->selection ? m_d->selection->x() :
            m_d->deferredSelectionOffset ? m_d->deferredSelectionOffset->x() :
            parent() ? parent()->x() : 0;
 }
 
 qint32 KisMask::y() const
 {
     return m_d->selection ? m_d->selection->y() :
            m_d->deferredSelectionOffset ? m_d->deferredSelectionOffset->y() :
            parent() ? parent()->y() : 0;
 }
 
 void KisMask::setX(qint32 x)
 {
     if (m_d->selection) {
         m_d->selection->setX(x);
     } else if (!m_d->deferredSelectionOffset) {
         m_d->deferredSelectionOffset.reset(new QPoint(x, 0));
     } else {
         m_d->deferredSelectionOffset->rx() = x;
     }
 }
 
 void KisMask::setY(qint32 y)
 {
     if (m_d->selection) {
         m_d->selection->setY(y);
     } else if (!m_d->deferredSelectionOffset) {
         m_d->deferredSelectionOffset.reset(new QPoint(0, y));
     } else {
         m_d->deferredSelectionOffset->ry() = y;
     }
 }
 
 QRect KisMask::nonDependentExtent() const
 {
     return QRect();
 }
 
 QImage KisMask::createThumbnail(qint32 w, qint32 h)
 {
     KisPaintDeviceSP originalDevice =
         selection() ? selection()->projection() : 0;
 
     return originalDevice ?
            originalDevice->createThumbnail(w, h, 1,
                                            KoColorConversionTransformation::internalRenderingIntent(),
                                            KoColorConversionTransformation::internalConversionFlags()) : QImage();
 }
 
 void KisMask::testingInitSelection(const QRect &rect, KisLayerSP parentLayer)
 {
     if (parentLayer) {
         m_d->selection = new KisSelection(new KisSelectionDefaultBounds(parentLayer->paintDevice(), parentLayer->image()));
     } else {
         m_d->selection = new KisSelection();
     }
 
     m_d->selection->pixelSelection()->select(rect, OPACITY_OPAQUE_U8);
     m_d->selection->updateProjection(rect);
     m_d->selection->setParentNode(this);
 }
 
 KisKeyframeChannel *KisMask::requestKeyframeChannel(const QString &id)
 {
     if (id == KisKeyframeChannel::Content.id()) {
         KisPaintDeviceSP device = paintDevice();
         if (device) {
             KisRasterKeyframeChannel *contentChannel = device->createKeyframeChannel(KisKeyframeChannel::Content);
             contentChannel->setFilenameSuffix(".pixelselection");
             return contentChannel;
        }
     }
 
     return KisNode::requestKeyframeChannel(id);
 }
 
 void KisMask::baseNodeChangedCallback()
 {
     KisNodeSP up = parent();
     KisLayer *layer = dynamic_cast<KisLayer*>(up.data());
     if (layer) {
         layer->notifyChildMaskChanged();
     }
     KisNode::baseNodeChangedCallback();
 }
diff --git a/libs/image/kis_selection_mask.cpp b/libs/image/kis_selection_mask.cpp
index 81329a2fa4..6a3474dd26 100644
--- a/libs/image/kis_selection_mask.cpp
+++ b/libs/image/kis_selection_mask.cpp
@@ -1,323 +1,321 @@
 /*
  *  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_selection_mask.h"
 
 #include "kis_image.h"
 #include "kis_layer.h"
 #include "kis_selection.h"
 #include <KoColorSpaceRegistry.h>
 #include <KoColorSpace.h>
 #include <KoProperties.h>
 #include "kis_fill_painter.h"
 #include <KoCompositeOp.h>
 #include "kis_node_visitor.h"
 #include "kis_processing_visitor.h"
 #include "kis_pixel_selection.h"
 #include "kis_undo_adapter.h"
 #include <KoIcon.h>
 #include <kis_icon.h>
 #include "kis_thread_safe_signal_compressor.h"
 #include "kis_layer_properties_icons.h"
 #include "kis_cached_paint_device.h"
 
 #include "kis_image_config.h"
 #include "KisImageConfigNotifier.h"
 
 
 struct Q_DECL_HIDDEN KisSelectionMask::Private
 {
 public:
     Private(KisSelectionMask *_q)
         : q(_q)
         , updatesCompressor(0)
         , maskColor(Qt::green, KoColorSpaceRegistry::instance()->rgb8())
     {}
     KisSelectionMask *q;
     KisImageWSP image;
     KisCachedPaintDevice paintDeviceCache;
     KisCachedSelection cachedSelection;
     KisThreadSafeSignalCompressor *updatesCompressor;
     KoColor maskColor;
 
     void slotSelectionChangedCompressed();
     void slotConfigChanged();
 };
 
 KisSelectionMask::KisSelectionMask(KisImageWSP image)
     : KisEffectMask()
     , m_d(new Private(this))
 {
     setName("selection");
     setActive(false);
     setSupportsLodMoves(false);
 
     m_d->image = image;
 
     m_d->updatesCompressor =
             new KisThreadSafeSignalCompressor(50, KisSignalCompressor::FIRST_ACTIVE);
 
     connect(m_d->updatesCompressor, SIGNAL(timeout()), SLOT(slotSelectionChangedCompressed()));
     this->moveToThread(image->thread());
 
     connect(KisImageConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
     m_d->slotConfigChanged();
 }
 
 KisSelectionMask::KisSelectionMask(const KisSelectionMask& rhs)
     : KisEffectMask(rhs)
     , m_d(new Private(this))
 {
     m_d->image = rhs.image();
     m_d->updatesCompressor =
             new KisThreadSafeSignalCompressor(300, KisSignalCompressor::POSTPONE);
 
     connect(m_d->updatesCompressor, SIGNAL(timeout()), SLOT(slotSelectionChangedCompressed()));
     this->moveToThread(m_d->image->thread());
 
     connect(KisImageConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
     m_d->slotConfigChanged();
 }
 
 KisSelectionMask::~KisSelectionMask()
 {
     m_d->updatesCompressor->deleteLater();
     delete m_d;
 }
 
 QIcon KisSelectionMask::icon() const {
     return KisIconUtils::loadIcon("selectionMask");
 }
 
 void KisSelectionMask::mergeInMaskInternal(KisPaintDeviceSP projection,
                                            KisSelectionSP effectiveSelection,
                                            const QRect &applyRect,
                                            const QRect &preparedNeedRect,
                                            KisNode::PositionToFilthy maskPos) const
 {
     Q_UNUSED(maskPos);
     Q_UNUSED(preparedNeedRect);
     if (!effectiveSelection) return;
 
     {
         KisSelectionSP mainMaskSelection = this->selection();
         if (mainMaskSelection &&
             (!mainMaskSelection->isVisible() ||
              mainMaskSelection->pixelSelection()->defaultBounds()->externalFrameActive())) {
 
             return;
         }
     }
 
-    KisPaintDeviceSP fillDevice = m_d->paintDeviceCache.getDevice(projection);
+    KisCachedPaintDevice::Guard d1(projection, m_d->paintDeviceCache);
+    KisPaintDeviceSP fillDevice = d1.device();
     fillDevice->setDefaultPixel(m_d->maskColor);
 
     const QRect selectionExtent = effectiveSelection->selectedRect();
 
     if (selectionExtent.contains(applyRect) || selectionExtent.intersects(applyRect)) {
-        KisSelectionSP invertedSelection = m_d->cachedSelection.getSelection();
+        KisCachedSelection::Guard s1(m_d->cachedSelection);
+        KisSelectionSP invertedSelection = s1.selection();
 
         invertedSelection->pixelSelection()->makeCloneFromRough(effectiveSelection->pixelSelection(), applyRect);
         invertedSelection->pixelSelection()->invert();
 
         KisPainter gc(projection);
         gc.setSelection(invertedSelection);
         gc.bitBlt(applyRect.topLeft(), fillDevice, applyRect);
 
-        m_d->cachedSelection.putSelection(invertedSelection);
-
     } else {
         KisPainter gc(projection);
         gc.bitBlt(applyRect.topLeft(), fillDevice, applyRect);
     }
-
-    m_d->paintDeviceCache.putDevice(fillDevice);
 }
 
 bool KisSelectionMask::paintsOutsideSelection() const
 {
     return true;
 }
 
 void KisSelectionMask::setSelection(KisSelectionSP selection)
 {
     if (selection) {
         KisEffectMask::setSelection(selection);
     } else {
         KisEffectMask::setSelection(new KisSelection());
 
         const KoColorSpace * cs = KoColorSpaceRegistry::instance()->alpha8();
         KisFillPainter gc(KisPaintDeviceSP(this->selection()->pixelSelection().data()));
         gc.fillRect(image()->bounds(), KoColor(Qt::white, cs), MAX_SELECTED);
         gc.end();
     }
     setDirty();
 }
 
 KisImageWSP KisSelectionMask::image() const
 {
     return m_d->image;
 }
 
 bool KisSelectionMask::accept(KisNodeVisitor &v)
 {
     return v.visit(this);
 }
 
 void KisSelectionMask::accept(KisProcessingVisitor &visitor, KisUndoAdapter *undoAdapter)
 {
     return visitor.visit(this, undoAdapter);
 }
 
 KisBaseNode::PropertyList KisSelectionMask::sectionModelProperties() const
 {
     KisBaseNode::PropertyList l = KisBaseNode::sectionModelProperties();
     l << KisLayerPropertiesIcons::getProperty(KisLayerPropertiesIcons::selectionActive, active());
     return l;
 }
 
 void KisSelectionMask::setSectionModelProperties(const KisBaseNode::PropertyList &properties)
 {
     KisEffectMask::setSectionModelProperties(properties);
     setActive(properties.at(2).state.toBool());
 }
 
 void KisSelectionMask::setVisible(bool visible, bool isLoading)
 {
     const bool oldVisible = this->visible(false);
     setNodeProperty("visible", visible);
 
     if (!isLoading && visible != oldVisible) {
         if (selection())
             selection()->setVisible(visible);
     }
 }
 
 bool KisSelectionMask::active() const
 {
     return nodeProperties().boolProperty("active", true);
 }
 
 void KisSelectionMask::setActive(bool active)
 {
     KisImageWSP image = this->image();
     KisLayerSP parentLayer = qobject_cast<KisLayer*>(parent().data());
 
     if (active && parentLayer) {
         KisSelectionMaskSP activeMask = parentLayer->selectionMask();
         if (activeMask && activeMask != this) {
             activeMask->setActive(false);
         }
     }
 
     const bool oldActive = this->active();
     setNodeProperty("active", active);
 
 
     /**
      * WARNING: we have a direct link to the image here, but we
      * must not use it for notification until we are a part of
      * the nore graph! Notifications should be emitted iff we
      * have graph listener link set up.
      */
     if (graphListener() &&
         image && oldActive != active) {
 
         baseNodeChangedCallback();
         image->undoAdapter()->emitSelectionChanged();
     }
 }
 
 QRect KisSelectionMask::needRect(const QRect &rect, KisNode::PositionToFilthy pos) const
 {
     Q_UNUSED(pos);
 
     // selection masks just add an overlay, so the needed rect is simply passed through
     return rect;
 }
 
 QRect KisSelectionMask::changeRect(const QRect &rect, KisNode::PositionToFilthy pos) const
 {
     Q_UNUSED(pos);
 
     // selection masks just add an overlay, so the changed rect is simply passed through
     return rect;
 }
 
 QRect KisSelectionMask::extent() const
 {
     // since mask overlay is inverted, the mask paints over
     // the entire image bounds
 
     QRect resultRect;
 
     KisSelectionSP selection = this->selection();
 
     if (selection) {
         resultRect = selection->pixelSelection()->defaultBounds()->bounds();
     } else if (KisNodeSP parent = this->parent()) {
         KisPaintDeviceSP dev = parent->projection();
         if (dev) {
             resultRect = dev->defaultBounds()->bounds();
         }
     }
 
     return resultRect;
 }
 
 QRect KisSelectionMask::exactBounds() const
 {
     return extent();
 }
 
 void KisSelectionMask::notifySelectionChangedCompressed()
 {
     m_d->updatesCompressor->start();
 }
 
 void KisSelectionMask::flattenSelectionProjection(KisSelectionSP selection, const QRect &dirtyRect) const
 {
     Q_UNUSED(selection);
     Q_UNUSED(dirtyRect);
 }
 
 void KisSelectionMask::Private::slotSelectionChangedCompressed()
 {
     KisSelectionSP currentSelection = q->selection();
     if (!currentSelection) return;
 
     currentSelection->notifySelectionChanged();
 }
 
 void KisSelectionMask::Private::slotConfigChanged()
 {
     const KoColorSpace *cs = image ?
         image->colorSpace() :
         KoColorSpaceRegistry::instance()->rgb8();
 
     KisImageConfig cfg(true);
 
     maskColor = KoColor(cfg.selectionOverlayMaskColor(), cs);
 
     if (image && image->overlaySelectionMask() == q) {
         q->setDirty();
     }
 }
 
 #include "moc_kis_selection_mask.cpp"
diff --git a/libs/image/layerstyles/KisLayerStyleKnockoutBlower.cpp b/libs/image/layerstyles/KisLayerStyleKnockoutBlower.cpp
new file mode 100644
index 0000000000..1583567a0a
--- /dev/null
+++ b/libs/image/layerstyles/KisLayerStyleKnockoutBlower.cpp
@@ -0,0 +1,72 @@
+/*
+ *  Copyright (c) 2019 Dmitry Kazakov <dimula73@gmail.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+#include "KisLayerStyleKnockoutBlower.h"
+
+#include "kis_painter.h"
+#include "KoCompositeOpRegistry.h"
+
+KisSelectionSP KisLayerStyleKnockoutBlower::knockoutSelectionLazy()
+{
+    {
+        QReadLocker l(&m_lock);
+        if (m_knockoutSelection) {
+            return m_knockoutSelection;
+        }
+    }
+
+    {
+        QWriteLocker l(&m_lock);
+        if (m_knockoutSelection) {
+            return m_knockoutSelection;
+        } else {
+            m_knockoutSelection = new KisSelection(new KisSelectionEmptyBounds(0));
+            return m_knockoutSelection;
+        }
+    }
+}
+
+void KisLayerStyleKnockoutBlower::setKnockoutSelection(KisSelectionSP selection)
+{
+    QWriteLocker l(&m_lock);
+    m_knockoutSelection = selection;
+}
+
+void KisLayerStyleKnockoutBlower::resetKnockoutSelection()
+{
+    QWriteLocker l(&m_lock);
+    m_knockoutSelection = 0;
+}
+
+void KisLayerStyleKnockoutBlower::apply(KisPainter *painter, KisPaintDeviceSP mergedStyle, const QRect &rect) const
+{
+    QReadLocker l(&m_lock);
+
+    KIS_SAFE_ASSERT_RECOVER_NOOP(m_knockoutSelection);
+
+    painter->setOpacity(OPACITY_OPAQUE_U8);
+    painter->setChannelFlags(QBitArray());
+    painter->setCompositeOp(COMPOSITE_COPY);
+    painter->setSelection(m_knockoutSelection);
+    painter->bitBlt(rect.topLeft(), mergedStyle, rect);
+}
+
+bool KisLayerStyleKnockoutBlower::isEmpty() const
+{
+    QReadLocker l(&m_lock);
+    return !m_knockoutSelection;
+}
diff --git a/libs/image/layerstyles/KisLayerStyleKnockoutBlower.h b/libs/image/layerstyles/KisLayerStyleKnockoutBlower.h
new file mode 100644
index 0000000000..50188eff42
--- /dev/null
+++ b/libs/image/layerstyles/KisLayerStyleKnockoutBlower.h
@@ -0,0 +1,44 @@
+/*
+ *  Copyright (c) 2019 Dmitry Kazakov <dimula73@gmail.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+#ifndef KISLAYERSTYLEKNOCKOUTBLOWER_H
+#define KISLAYERSTYLEKNOCKOUTBLOWER_H
+
+#include "kis_selection.h"
+#include <QReadWriteLock>
+
+class KisPainter;
+
+
+class KRITAIMAGE_EXPORT KisLayerStyleKnockoutBlower
+{
+public:
+    KisSelectionSP knockoutSelectionLazy();
+
+    void setKnockoutSelection(KisSelectionSP selection);
+    void resetKnockoutSelection();
+
+
+    void apply(KisPainter *painter, KisPaintDeviceSP mergedStyle, const QRect &rect) const;
+    bool isEmpty() const;
+
+private:
+    mutable QReadWriteLock m_lock;
+    KisSelectionSP m_knockoutSelection;
+};
+
+#endif // KISLAYERSTYLEKNOCKOUTBLOWER_H
diff --git a/libs/image/layerstyles/kis_layer_style_filter.h b/libs/image/layerstyles/kis_layer_style_filter.h
index 30a311d404..2aca6515a0 100644
--- a/libs/image/layerstyles/kis_layer_style_filter.h
+++ b/libs/image/layerstyles/kis_layer_style_filter.h
@@ -1,72 +1,74 @@
 /*
  *  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_LAYER_STYLE_FILTER_H
 #define __KIS_LAYER_STYLE_FILTER_H
 
 #include "kis_types.h"
 #include "kis_shared.h"
 #include "kritaimage_export.h"
 #include "kis_psd_layer_style.h"
 #include <QScopedPointer>
 
 class KisLayerStyleFilterEnvironment;
 class KisMultipleProjection;
+class KisLayerStyleKnockoutBlower;
 
 class KRITAIMAGE_EXPORT KisLayerStyleFilter : public KisShared
 {
 public:
     KisLayerStyleFilter(const KoID &id);
     virtual ~KisLayerStyleFilter();
 
     /**
      * \return Unique identifier for this filter
      */
     QString id() const;
 
     virtual KisLayerStyleFilter* clone() const = 0;
 
     virtual void processDirectly(KisPaintDeviceSP src,
                                  KisMultipleProjection *dst,
+                                 KisLayerStyleKnockoutBlower *blower,
                                  const QRect &applyRect,
                                  KisPSDLayerStyleSP style,
                                  KisLayerStyleFilterEnvironment *env) const = 0;
 
     /**
      * Some filters need pixels outside the current processing rect to compute the new
      * value (for instance, convolution filters)
      */
     virtual QRect neededRect(const QRect & rect, KisPSDLayerStyleSP style, KisLayerStyleFilterEnvironment *env) const = 0;
 
     /**
      * Similar to \ref neededRect: some filters will alter a lot of pixels that are
      * near to each other at the same time. So when you changed a single rectangle
      * in a device, the actual rectangle that will feel the influence of this change
      * might be bigger. Use this function to determine that rect.
      */
     virtual QRect changedRect(const QRect & rect, KisPSDLayerStyleSP style, KisLayerStyleFilterEnvironment *env) const = 0;
 
 protected:
     KisLayerStyleFilter(const KisLayerStyleFilter &rhs);
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 #endif /* __KIS_LAYER_STYLE_FILTER_H */
diff --git a/libs/image/layerstyles/kis_layer_style_filter_environment.cpp b/libs/image/layerstyles/kis_layer_style_filter_environment.cpp
index a8cf6e834e..902a88bd8a 100644
--- a/libs/image/layerstyles/kis_layer_style_filter_environment.cpp
+++ b/libs/image/layerstyles/kis_layer_style_filter_environment.cpp
@@ -1,133 +1,146 @@
 /*
  *  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_layer_style_filter_environment.h"
 
 #include <QBitArray>
 
 #include "kis_layer.h"
 #include "kis_ls_utils.h"
 
 #include "kis_selection.h"
 #include "kis_pixel_selection.h"
 #include "kis_painter.h"
 #include "kis_image.h"
 
 #include "krita_utils.h"
 
 #include <boost/random/mersenne_twister.hpp>
 #include "kis_random_accessor_ng.h"
 #include "kis_iterator_ng.h"
+#include "kis_cached_paint_device.h"
 
 
 struct Q_DECL_HIDDEN KisLayerStyleFilterEnvironment::Private
 {
     KisLayer *sourceLayer;
     KisPixelSelectionSP cachedRandomSelection;
+    KisCachedSelection globalCachedSelection;
+    KisCachedPaintDevice globalCachedPaintDevice;
 
     static KisPixelSelectionSP generateRandomSelection(const QRect &rc);
 };
 
 
 KisPixelSelectionSP
 KisLayerStyleFilterEnvironment::Private::
 generateRandomSelection(const QRect &rc)
 {
     KisPixelSelectionSP selection = new KisPixelSelection();
     KisSequentialIterator dstIt(selection, rc);
 
     boost::mt11213b uniformSource;
 
     if (uniformSource.max() >= 0x00FFFFFF) {
         while (dstIt.nextPixel()) {
             int randValue = uniformSource();
             *dstIt.rawData() = (quint8) randValue;
 
             if (!dstIt.nextPixel()) break;
             randValue >>= 8;
             *dstIt.rawData() = (quint8) randValue;
 
             if (!dstIt.nextPixel()) break;
             randValue >>= 8;
             *dstIt.rawData() = (quint8) randValue;
         }
 
     } else {
         while (dstIt.nextPixel()) {
             *dstIt.rawData() = (quint8) uniformSource();
         }
     }
 
     return selection;
 }
 
 KisLayerStyleFilterEnvironment::KisLayerStyleFilterEnvironment(KisLayer *sourceLayer)
     : m_d(new Private)
 {
     Q_ASSERT(sourceLayer);
     m_d->sourceLayer = sourceLayer;
 }
 
 KisLayerStyleFilterEnvironment::~KisLayerStyleFilterEnvironment()
 {
 }
 
 QRect KisLayerStyleFilterEnvironment::layerBounds() const
 {
     return m_d->sourceLayer ? m_d->sourceLayer->projection()->exactBounds() : QRect();
 }
 
 QRect KisLayerStyleFilterEnvironment::defaultBounds() const
 {
     return m_d->sourceLayer ?
         m_d->sourceLayer->original()->defaultBounds()->bounds() : QRect();
 }
 
 int KisLayerStyleFilterEnvironment::currentLevelOfDetail() const
 {
     return m_d->sourceLayer ?
         m_d->sourceLayer->original()->defaultBounds()->currentLevelOfDetail() : 0;
 }
 
 void KisLayerStyleFilterEnvironment::setupFinalPainter(KisPainter *gc,
                                                        quint8 opacity,
                                                        const QBitArray &channelFlags) const
 {
     Q_ASSERT(m_d->sourceLayer);
     gc->setOpacity(KritaUtils::mergeOpacity(opacity, m_d->sourceLayer->opacity()));
     gc->setChannelFlags(KritaUtils::mergeChannelFlags(channelFlags, m_d->sourceLayer->channelFlags()));
 
 }
 
 KisPixelSelectionSP KisLayerStyleFilterEnvironment::cachedRandomSelection(const QRect &requestedRect) const
 {
     KisPixelSelectionSP selection = m_d->cachedRandomSelection;
 
     QRect existingRect;
 
     if (selection) {
         existingRect = selection->selectedExactRect();
     }
 
     if (!existingRect.contains(requestedRect)) {
         m_d->cachedRandomSelection =
             Private::generateRandomSelection(requestedRect | existingRect);
     }
 
     return m_d->cachedRandomSelection;
 }
+
+KisCachedSelection *KisLayerStyleFilterEnvironment::cachedSelection()
+{
+    return &m_d->globalCachedSelection;
+}
+
+KisCachedPaintDevice *KisLayerStyleFilterEnvironment::cachedPaintDevice()
+{
+    return &m_d->globalCachedPaintDevice;
+}
diff --git a/libs/image/layerstyles/kis_layer_style_filter_environment.h b/libs/image/layerstyles/kis_layer_style_filter_environment.h
index a54c9475c6..dfaa55cc1f 100644
--- a/libs/image/layerstyles/kis_layer_style_filter_environment.h
+++ b/libs/image/layerstyles/kis_layer_style_filter_environment.h
@@ -1,55 +1,60 @@
 /*
  *  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_LAYER_STYLE_FILTER_ENVIRONMENT_H
 #define __KIS_LAYER_STYLE_FILTER_ENVIRONMENT_H
 
 #include <QScopedPointer>
 #include <QRect>
 
 #include <kritaimage_export.h>
 #include "kis_types.h"
 
 class KisPainter;
 class KisLayer;
 class QPainterPath;
 class QBitArray;
+class KisCachedPaintDevice;
+class KisCachedSelection;
 
 
 class KRITAIMAGE_EXPORT KisLayerStyleFilterEnvironment
 {
 public:
     KisLayerStyleFilterEnvironment(KisLayer *sourceLayer);
     ~KisLayerStyleFilterEnvironment();
 
     QRect layerBounds() const;
     QRect defaultBounds() const;
     int currentLevelOfDetail() const;
 
     void setupFinalPainter(KisPainter *gc,
                            quint8 opacity,
                            const QBitArray &channelFlags) const;
 
     KisPixelSelectionSP cachedRandomSelection(const QRect &requestedRect) const;
 
+    KisCachedSelection* cachedSelection();
+    KisCachedPaintDevice* cachedPaintDevice();
+
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 #endif /* __KIS_LAYER_STYLE_FILTER_ENVIRONMENT_H */
diff --git a/libs/image/layerstyles/kis_layer_style_filter_projection_plane.cpp b/libs/image/layerstyles/kis_layer_style_filter_projection_plane.cpp
index 43c876d0d8..edc1f35503 100644
--- a/libs/image/layerstyles/kis_layer_style_filter_projection_plane.cpp
+++ b/libs/image/layerstyles/kis_layer_style_filter_projection_plane.cpp
@@ -1,142 +1,155 @@
 /*
  *  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_layer_style_filter_projection_plane.h"
 
 #include "filter/kis_filter.h"
 #include "filter/kis_filter_configuration.h"
 #include "filter/kis_filter_registry.h"
 #include "kis_layer_style_filter.h"
 #include "kis_layer_style_filter_environment.h"
 #include "kis_psd_layer_style.h"
 
 
 #include "kis_painter.h"
 #include "kis_multiple_projection.h"
+#include "KisLayerStyleKnockoutBlower.h"
 
 
 struct KisLayerStyleFilterProjectionPlane::Private
 {
     Private(KisLayer *_sourceLayer)
         : sourceLayer(_sourceLayer),
           environment(new KisLayerStyleFilterEnvironment(_sourceLayer))
     {
         KIS_SAFE_ASSERT_RECOVER_NOOP(_sourceLayer);
     }
 
     Private(const Private &rhs, KisLayer *_sourceLayer, KisPSDLayerStyleSP clonedStyle)
         : sourceLayer(_sourceLayer),
           filter(rhs.filter ? rhs.filter->clone() : 0),
           style(clonedStyle),
           environment(new KisLayerStyleFilterEnvironment(_sourceLayer)),
           projection(rhs.projection)
     {
         KIS_SAFE_ASSERT_RECOVER_NOOP(_sourceLayer);
     }
 
 
     KisLayer *sourceLayer;
 
     QScopedPointer<KisLayerStyleFilter> filter;
     KisPSDLayerStyleSP style;
     QScopedPointer<KisLayerStyleFilterEnvironment> environment;
+    KisLayerStyleKnockoutBlower knockoutBlower;
 
     KisMultipleProjection projection;
 };
 
 KisLayerStyleFilterProjectionPlane::
 KisLayerStyleFilterProjectionPlane(KisLayer *sourceLayer)
     : m_d(new Private(sourceLayer))
 {
 }
 
 KisLayerStyleFilterProjectionPlane::KisLayerStyleFilterProjectionPlane(const KisLayerStyleFilterProjectionPlane &rhs, KisLayer *sourceLayer, KisPSDLayerStyleSP clonedStyle)
     : m_d(new Private(*rhs.m_d, sourceLayer, clonedStyle))
 {
 }
 
 KisLayerStyleFilterProjectionPlane::~KisLayerStyleFilterProjectionPlane()
 {
 }
 
 void KisLayerStyleFilterProjectionPlane::setStyle(KisLayerStyleFilter *filter, KisPSDLayerStyleSP style)
 {
     m_d->filter.reset(filter);
     m_d->style = style;
 }
 
 QRect KisLayerStyleFilterProjectionPlane::recalculate(const QRect& rect, KisNodeSP filthyNode)
 {
     Q_UNUSED(filthyNode);
 
     if (!m_d->sourceLayer || !m_d->filter) {
         warnKrita << "KisLayerStyleFilterProjectionPlane::recalculate(): [BUG] is not initialized";
         return QRect();
     }
 
     m_d->projection.clear(rect);
     m_d->filter->processDirectly(m_d->sourceLayer->projection(),
                                  &m_d->projection,
+                                 &m_d->knockoutBlower,
                                  rect,
                                  m_d->style,
                                  m_d->environment.data());
     return rect;
 }
 
 void KisLayerStyleFilterProjectionPlane::apply(KisPainter *painter, const QRect &rect)
 {
     m_d->projection.apply(painter->device(), rect, m_d->environment.data());
 }
 
 KisPaintDeviceList KisLayerStyleFilterProjectionPlane::getLodCapableDevices() const
 {
     return m_d->projection.getLodCapableDevices();
 }
 
+bool KisLayerStyleFilterProjectionPlane::isEmpty() const
+{
+    return m_d->projection.isEmpty();
+}
+
+KisLayerStyleKnockoutBlower *KisLayerStyleFilterProjectionPlane::knockoutBlower() const
+{
+    return &m_d->knockoutBlower;
+}
+
 QRect KisLayerStyleFilterProjectionPlane::needRect(const QRect &rect, KisLayer::PositionToFilthy pos) const
 {
     if (!m_d->sourceLayer || !m_d->filter) {
         warnKrita << "KisLayerStyleFilterProjectionPlane::needRect(): [BUG] is not initialized";
         return rect;
     }
 
     KIS_ASSERT_RECOVER_NOOP(pos == KisLayer::N_ABOVE_FILTHY);
     return m_d->filter->neededRect(rect, m_d->style, m_d->environment.data());
 }
 
 QRect KisLayerStyleFilterProjectionPlane::changeRect(const QRect &rect, KisLayer::PositionToFilthy pos) const
 {
     if (!m_d->sourceLayer || !m_d->filter) {
         warnKrita << "KisLayerStyleFilterProjectionPlane::changeRect(): [BUG] is not initialized";
         return rect;
     }
 
     KIS_ASSERT_RECOVER_NOOP(pos == KisLayer::N_ABOVE_FILTHY);
     return m_d->filter->changedRect(rect, m_d->style, m_d->environment.data());
 }
 
 QRect KisLayerStyleFilterProjectionPlane::accessRect(const QRect &rect, KisLayer::PositionToFilthy pos) const
 {
     return needRect(rect, pos);
 }
 
 QRect KisLayerStyleFilterProjectionPlane::needRectForOriginal(const QRect &rect) const
 {
     return needRect(rect, KisLayer::N_ABOVE_FILTHY);
 }
 
diff --git a/libs/image/layerstyles/kis_layer_style_filter_projection_plane.h b/libs/image/layerstyles/kis_layer_style_filter_projection_plane.h
index e3d5cc76ea..71b6bb2e38 100644
--- a/libs/image/layerstyles/kis_layer_style_filter_projection_plane.h
+++ b/libs/image/layerstyles/kis_layer_style_filter_projection_plane.h
@@ -1,56 +1,66 @@
 /*
  *  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_LAYER_STYLE_FILTER_PROJECTION_PLANE_H
 #define __KIS_LAYER_STYLE_FILTER_PROJECTION_PLANE_H
 
 #include "kis_abstract_projection_plane.h"
 
 #include <QScopedPointer>
 
 #include "kis_types.h"
 
+class KisLayerStyleKnockoutBlower;
+
 
 class KisLayerStyleFilterProjectionPlane : public KisAbstractProjectionPlane
 {
 public:
     KisLayerStyleFilterProjectionPlane(KisLayer *sourceLayer);
     KisLayerStyleFilterProjectionPlane(const KisLayerStyleFilterProjectionPlane &rhs, KisLayer *sourceLayer, KisPSDLayerStyleSP clonedStyle);
     ~KisLayerStyleFilterProjectionPlane() override;
 
     void setStyle(KisLayerStyleFilter *filter, KisPSDLayerStyleSP style);
 
     QRect recalculate(const QRect& rect, KisNodeSP filthyNode) override;
     void apply(KisPainter *painter, const QRect &rect) override;
 
     QRect needRect(const QRect &rect, KisLayer::PositionToFilthy pos) const override;
     QRect changeRect(const QRect &rect, KisLayer::PositionToFilthy pos) const override;
     QRect accessRect(const QRect &rect, KisLayer::PositionToFilthy pos) const override;
     QRect needRectForOriginal(const QRect &rect) const override;
 
     KisPaintDeviceList getLodCapableDevices() const override;
 
+    /**
+     * \returns true if a call to apply() will actually paint anything. Basically,
+     * it is a cached version of isEnabled(), though the state may change after calling
+     * to recalculate().
+     */
+    bool isEmpty() const;
+
+    KisLayerStyleKnockoutBlower *knockoutBlower() const;
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 typedef QSharedPointer<KisLayerStyleFilterProjectionPlane> KisLayerStyleFilterProjectionPlaneSP;
 typedef QWeakPointer<KisLayerStyleFilterProjectionPlane> KisLayerStyleFilterProjectionPlaneWSP;
 
 #endif /* __KIS_LAYER_STYLE_FILTER_PROJECTION_PLANE_H */
diff --git a/libs/image/layerstyles/kis_layer_style_projection_plane.cpp b/libs/image/layerstyles/kis_layer_style_projection_plane.cpp
index 9b99308b48..c00214cee0 100644
--- a/libs/image/layerstyles/kis_layer_style_projection_plane.cpp
+++ b/libs/image/layerstyles/kis_layer_style_projection_plane.cpp
@@ -1,331 +1,410 @@
 /*
  *  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_layer_style_projection_plane.h"
 
 #include "kis_global.h"
 #include "kis_layer_style_filter_projection_plane.h"
+#include "kis_layer_projection_plane.h"
 #include "kis_psd_layer_style.h"
 
 #include "kis_ls_drop_shadow_filter.h"
 #include "kis_ls_satin_filter.h"
 #include "kis_ls_overlay_filter.h"
 #include "kis_ls_stroke_filter.h"
 #include "kis_ls_bevel_emboss_filter.h"
 #include "kis_projection_leaf.h"
+#include "kis_cached_paint_device.h"
+#include "kis_painter.h"
+#include "kis_ls_utils.h"
+#include "KisLayerStyleKnockoutBlower.h"
 
 
 struct Q_DECL_HIDDEN KisLayerStyleProjectionPlane::Private
 {
-    KisAbstractProjectionPlaneWSP sourceProjectionPlane;
+    KisLayerProjectionPlaneWSP sourceProjectionPlane;
 
     QVector<KisLayerStyleFilterProjectionPlaneSP> stylesBefore;
     QVector<KisLayerStyleFilterProjectionPlaneSP> stylesAfter;
+    QVector<KisLayerStyleFilterProjectionPlaneSP> stylesOverlay;
+
+    KisCachedPaintDevice cachedPaintDevice;
+    KisCachedSelection cachedSelection;
+    KisLayer *sourceLayer = 0;
+
 
     KisPSDLayerStyleSP style;
     bool canHaveChildNodes = false;
     bool dependsOnLowerNodes = false;
 
     void initSourcePlane(KisLayer *sourceLayer) {
         KIS_SAFE_ASSERT_RECOVER_RETURN(sourceLayer);
         sourceProjectionPlane = sourceLayer->internalProjectionPlane();
         canHaveChildNodes = sourceLayer->projectionLeaf()->canHaveChildLayers();
         dependsOnLowerNodes = sourceLayer->projectionLeaf()->dependsOnLowerNodes();
+        this->sourceLayer = sourceLayer;
+    }
+
+    QVector<KisLayerStyleFilterProjectionPlaneSP> allStyles() const {
+        return stylesBefore + stylesOverlay + stylesAfter;
+    }
+
+    bool hasOverlayStyles() const {
+        Q_FOREACH (KisLayerStyleFilterProjectionPlaneSP plane, stylesOverlay) {
+            if (!plane->isEmpty()) return true;
+        }
+
+        return false;
+    }
+
+    bool hasKnockoutStyles() const {
+        Q_FOREACH (KisLayerStyleFilterProjectionPlaneSP plane, stylesBefore) {
+            if (!plane->knockoutBlower()->isEmpty()) return true;
+        }
+
+        Q_FOREACH (KisLayerStyleFilterProjectionPlaneSP plane, stylesAfter) {
+            if (!plane->knockoutBlower()->isEmpty()) return true;
+        }
+
+        return false;
     }
+
+    void applyComplexPlane(KisPainter *painter,
+                           KisLayerStyleFilterProjectionPlaneSP plane,
+                           const QRect &rect,
+                           KisPaintDeviceSP originalClone);
 };
 
 KisLayerStyleProjectionPlane::KisLayerStyleProjectionPlane(KisLayer *sourceLayer)
     : m_d(new Private)
 {
     KisPSDLayerStyleSP style = sourceLayer->layerStyle();
 
     KIS_ASSERT_RECOVER(style) {
         style = toQShared(new KisPSDLayerStyle());
     }
 
     init(sourceLayer, style);
 }
 
 KisLayerStyleProjectionPlane::KisLayerStyleProjectionPlane(const KisLayerStyleProjectionPlane &rhs, KisLayer *sourceLayer, KisPSDLayerStyleSP clonedStyle)
     : m_d(new Private)
 {
     m_d->initSourcePlane(sourceLayer);
     m_d->style = clonedStyle;
 
     KIS_SAFE_ASSERT_RECOVER(m_d->style) {
         m_d->style = toQShared(new KisPSDLayerStyle());
     }
 
-    Q_FOREACH (KisLayerStyleFilterProjectionPlaneSP plane, rhs.m_d->stylesBefore) {
+    Q_FOREACH (KisLayerStyleFilterProjectionPlaneSP plane, rhs.m_d->allStyles()) {
         m_d->stylesBefore << toQShared(new KisLayerStyleFilterProjectionPlane(*plane, sourceLayer, m_d->style));
     }
-
-    Q_FOREACH (KisLayerStyleFilterProjectionPlaneSP plane, rhs.m_d->stylesAfter) {
-        m_d->stylesAfter << toQShared(new KisLayerStyleFilterProjectionPlane(*plane, sourceLayer, m_d->style));
-    }
 }
 
 // for testing purposes only!
 KisLayerStyleProjectionPlane::KisLayerStyleProjectionPlane(KisLayer *sourceLayer, KisPSDLayerStyleSP layerStyle)
     : m_d(new Private)
 {
     init(sourceLayer, layerStyle);
 }
 
 void KisLayerStyleProjectionPlane::init(KisLayer *sourceLayer, KisPSDLayerStyleSP style)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(sourceLayer);
     m_d->initSourcePlane(sourceLayer);
     m_d->style = style;
 
     {
         KisLayerStyleFilterProjectionPlane *dropShadow =
             new KisLayerStyleFilterProjectionPlane(sourceLayer);
         dropShadow->setStyle(new KisLsDropShadowFilter(KisLsDropShadowFilter::DropShadow), style);
         m_d->stylesBefore << toQShared(dropShadow);
     }
 
-    {
-        KisLayerStyleFilterProjectionPlane *innerShadow =
-            new KisLayerStyleFilterProjectionPlane(sourceLayer);
-        innerShadow->setStyle(new KisLsDropShadowFilter(KisLsDropShadowFilter::InnerShadow), style);
-        m_d->stylesAfter << toQShared(innerShadow);
-    }
-
     {
         KisLayerStyleFilterProjectionPlane *outerGlow =
             new KisLayerStyleFilterProjectionPlane(sourceLayer);
         outerGlow->setStyle(new KisLsDropShadowFilter(KisLsDropShadowFilter::OuterGlow), style);
         m_d->stylesAfter << toQShared(outerGlow);
     }
 
     {
-        KisLayerStyleFilterProjectionPlane *innerGlow =
+        KisLayerStyleFilterProjectionPlane *stroke =
             new KisLayerStyleFilterProjectionPlane(sourceLayer);
-        innerGlow->setStyle(new KisLsDropShadowFilter(KisLsDropShadowFilter::InnerGlow), style);
-        m_d->stylesAfter << toQShared(innerGlow);
+        stroke->setStyle(new KisLsStrokeFilter(), style);
+        m_d->stylesAfter << toQShared(stroke);
     }
 
     {
-        KisLayerStyleFilterProjectionPlane *satin =
+        KisLayerStyleFilterProjectionPlane *bevelEmboss =
             new KisLayerStyleFilterProjectionPlane(sourceLayer);
-        satin->setStyle(new KisLsSatinFilter(), style);
-        m_d->stylesAfter << toQShared(satin);
+        bevelEmboss->setStyle(new KisLsBevelEmbossFilter(), style);
+        m_d->stylesAfter << toQShared(bevelEmboss);
     }
 
     {
-        KisLayerStyleFilterProjectionPlane *colorOverlay =
+        KisLayerStyleFilterProjectionPlane *patternOverlay =
             new KisLayerStyleFilterProjectionPlane(sourceLayer);
-        colorOverlay->setStyle(new KisLsOverlayFilter(KisLsOverlayFilter::Color), style);
-        m_d->stylesAfter << toQShared(colorOverlay);
+        patternOverlay->setStyle(new KisLsOverlayFilter(KisLsOverlayFilter::Pattern), style);
+        m_d->stylesOverlay << toQShared(patternOverlay);
     }
 
     {
         KisLayerStyleFilterProjectionPlane *gradientOverlay =
             new KisLayerStyleFilterProjectionPlane(sourceLayer);
         gradientOverlay->setStyle(new KisLsOverlayFilter(KisLsOverlayFilter::Gradient), style);
-        m_d->stylesAfter << toQShared(gradientOverlay);
+        m_d->stylesOverlay << toQShared(gradientOverlay);
     }
 
     {
-        KisLayerStyleFilterProjectionPlane *patternOverlay =
+        KisLayerStyleFilterProjectionPlane *colorOverlay =
             new KisLayerStyleFilterProjectionPlane(sourceLayer);
-        patternOverlay->setStyle(new KisLsOverlayFilter(KisLsOverlayFilter::Pattern), style);
-        m_d->stylesAfter << toQShared(patternOverlay);
+        colorOverlay->setStyle(new KisLsOverlayFilter(KisLsOverlayFilter::Color), style);
+        m_d->stylesOverlay << toQShared(colorOverlay);
     }
 
     {
-        KisLayerStyleFilterProjectionPlane *stroke =
+        KisLayerStyleFilterProjectionPlane *satin =
             new KisLayerStyleFilterProjectionPlane(sourceLayer);
-        stroke->setStyle(new KisLsStrokeFilter(), style);
-        m_d->stylesAfter << toQShared(stroke);
+        satin->setStyle(new KisLsSatinFilter(), style);
+        m_d->stylesOverlay << toQShared(satin);
     }
 
     {
-        KisLayerStyleFilterProjectionPlane *bevelEmboss =
+        KisLayerStyleFilterProjectionPlane *innerGlow =
             new KisLayerStyleFilterProjectionPlane(sourceLayer);
-        bevelEmboss->setStyle(new KisLsBevelEmbossFilter(), style);
-        m_d->stylesAfter << toQShared(bevelEmboss);
+        innerGlow->setStyle(new KisLsDropShadowFilter(KisLsDropShadowFilter::InnerGlow), style);
+        m_d->stylesOverlay << toQShared(innerGlow);
+    }
+
+    {
+        KisLayerStyleFilterProjectionPlane *innerShadow =
+            new KisLayerStyleFilterProjectionPlane(sourceLayer);
+        innerShadow->setStyle(new KisLsDropShadowFilter(KisLsDropShadowFilter::InnerShadow), style);
+        m_d->stylesOverlay << toQShared(innerShadow);
     }
 }
 
 KisLayerStyleProjectionPlane::~KisLayerStyleProjectionPlane()
 {
 }
 
 KisAbstractProjectionPlaneSP KisLayerStyleProjectionPlane::factoryObject(KisLayer *sourceLayer)
 {
     Q_ASSERT(sourceLayer);
     return toQShared(new KisLayerStyleProjectionPlane(sourceLayer));
 }
 
 QRect KisLayerStyleProjectionPlane::recalculate(const QRect& rect, KisNodeSP filthyNode)
 {
     KisAbstractProjectionPlaneSP sourcePlane = m_d->sourceProjectionPlane.toStrongRef();
     QRect result = sourcePlane->recalculate(stylesNeedRect(rect), filthyNode);
 
     if (m_d->style->isEnabled()) {
-        Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->stylesBefore) {
-            plane->recalculate(rect, filthyNode);
-        }
-
-        Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->stylesAfter) {
+        Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->allStyles()) {
             plane->recalculate(rect, filthyNode);
         }
     }
 
     return result;
 }
 
-void KisLayerStyleProjectionPlane::apply(KisPainter *painter, const QRect &rect)
+void KisLayerStyleProjectionPlane::Private::applyComplexPlane(KisPainter *painter,
+                                                              KisLayerStyleFilterProjectionPlaneSP plane,
+                                                              const QRect &rect,
+                                                              KisPaintDeviceSP originalClone)
 {
-    KisAbstractProjectionPlaneSP sourcePlane = m_d->sourceProjectionPlane.toStrongRef();
+    if (plane->isEmpty()) return;
 
-    if (m_d->style->isEnabled()) {
-        Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->stylesBefore) {
-            plane->apply(painter, rect);
-        }
+    if (!plane->knockoutBlower()->isEmpty()) {
+        KisCachedPaintDevice::Guard d1(originalClone, cachedPaintDevice);
+        KisPaintDeviceSP mergedStyle = d1.device();
+        mergedStyle->makeCloneFromRough(originalClone, rect);
 
-        sourcePlane->apply(painter, rect);
+        KisPainter overlayPainter(mergedStyle);
+        plane->apply(&overlayPainter, rect);
+        plane->knockoutBlower()->apply(painter, mergedStyle, rect);
+
+    } else {
+        plane->apply(painter, rect);
+    }
+}
 
-        Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->stylesAfter) {
-            plane->apply(painter, rect);
+void KisLayerStyleProjectionPlane::apply(KisPainter *painter, const QRect &rect)
+{
+    KisLayerProjectionPlaneSP sourcePlane = m_d->sourceProjectionPlane.toStrongRef();
+
+    if (m_d->style->isEnabled()) {
+        if (m_d->hasOverlayStyles() || m_d->hasKnockoutStyles()) {
+            KisCachedPaintDevice::Guard d1(painter->device(), m_d->cachedPaintDevice);
+            KisPaintDeviceSP originalClone = d1.device();
+            originalClone->makeCloneFromRough(painter->device(), rect);
+
+            Q_FOREACH (const KisLayerStyleFilterProjectionPlaneSP plane, m_d->stylesBefore) {
+                m_d->applyComplexPlane(painter, plane, rect, originalClone);
+            }
+
+            if (m_d->hasOverlayStyles()) {
+                KisCachedSelection::Guard s1(m_d->cachedSelection);
+                KisSelectionSP knockoutSelection = s1.selection();
+                KisLsUtils::selectionFromAlphaChannel(m_d->sourceLayer->projection(), knockoutSelection, rect);
+
+                KisCachedPaintDevice::Guard d2(painter->device(), m_d->cachedPaintDevice);
+                KisPaintDeviceSP sourceProjection = d2.device();
+                sourceProjection->makeCloneFromRough(painter->device(), rect);
+
+                {
+                    KisPainter overlayPainter(sourceProjection);
+                    sourcePlane->applyMaxOutAlpha(&overlayPainter, rect);
+
+                    Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->stylesOverlay) {
+                        plane->apply(&overlayPainter, rect);
+                    }
+                }
+
+                KisLayerStyleKnockoutBlower blower;
+                blower.setKnockoutSelection(knockoutSelection);
+                blower.apply(painter, sourceProjection, rect);
+
+                blower.resetKnockoutSelection();
+            } else {
+                sourcePlane->apply(painter, rect);
+            }
+
+            Q_FOREACH (KisLayerStyleFilterProjectionPlaneSP plane, m_d->stylesAfter) {
+                m_d->applyComplexPlane(painter, plane, rect, originalClone);
+            }
+        } else {
+            Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->stylesBefore) {
+                plane->apply(painter, rect);
+            }
+
+            sourcePlane->apply(painter, rect);
+
+            Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->stylesAfter) {
+                plane->apply(painter, rect);
+            }
         }
     } else {
         sourcePlane->apply(painter, rect);
     }
 }
 
 KisPaintDeviceList KisLayerStyleProjectionPlane::getLodCapableDevices() const
 {
     KisPaintDeviceList list;
     KisAbstractProjectionPlaneSP sourcePlane = m_d->sourceProjectionPlane.toStrongRef();
 
     if (m_d->style->isEnabled()) {
-        Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->stylesBefore) {
+        Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->allStyles()) {
             list << plane->getLodCapableDevices();
         }
 
         list << sourcePlane->getLodCapableDevices();
-
-        Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->stylesAfter) {
-            list << plane->getLodCapableDevices();
-        }
     } else {
         list << sourcePlane->getLodCapableDevices();
     }
 
     return list;
 }
 
 QRect KisLayerStyleProjectionPlane::needRect(const QRect &rect, KisLayer::PositionToFilthy pos) const
 {
     /**
      * Need rect should also be adjust for the layers that generate their 'original'
      * based on the contents of the underlying layers like KisAdjustmentLayer
      *
      * \see bug 390299
      */
 
     QRect needRect = rect;
 
     const bool adjustmentAboveDirty = m_d->dependsOnLowerNodes &&
         (pos & KisLayer::N_FILTHY || pos & KisLayer::N_ABOVE_FILTHY);
 
     if (m_d->style->isEnabled() && adjustmentAboveDirty) {
         needRect |= stylesNeedRect(rect);
     }
 
     KisAbstractProjectionPlaneSP sourcePlane = m_d->sourceProjectionPlane.toStrongRef();
     needRect = sourcePlane->needRect(needRect, pos);
 
     return needRect;
 }
 
 QRect KisLayerStyleProjectionPlane::changeRect(const QRect &rect, KisLayer::PositionToFilthy pos) const
 {
     KisAbstractProjectionPlaneSP sourcePlane = m_d->sourceProjectionPlane.toStrongRef();
     QRect layerChangeRect = sourcePlane->changeRect(rect, pos);
     QRect changeRect = layerChangeRect;
 
     if (m_d->style->isEnabled()) {
-        Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->stylesBefore) {
-            changeRect |= plane->changeRect(layerChangeRect, KisLayer::N_ABOVE_FILTHY);
-        }
-
-        Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->stylesAfter) {
+        Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->allStyles()) {
             changeRect |= plane->changeRect(layerChangeRect, KisLayer::N_ABOVE_FILTHY);
         }
     }
 
     return changeRect;
 }
 
 QRect KisLayerStyleProjectionPlane::accessRect(const QRect &rect, KisLayer::PositionToFilthy pos) const
 {
     KisAbstractProjectionPlaneSP sourcePlane = m_d->sourceProjectionPlane.toStrongRef();
     QRect accessRect = sourcePlane->accessRect(rect, pos);
 
     if (m_d->style->isEnabled()) {
-        Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->stylesBefore) {
-            accessRect |= plane->accessRect(rect, KisLayer::N_ABOVE_FILTHY);
-        }
-
-        Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->stylesAfter) {
+        Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->allStyles()) {
             accessRect |= plane->accessRect(rect, KisLayer::N_ABOVE_FILTHY);
         }
     }
 
     return accessRect;
 }
 
 QRect KisLayerStyleProjectionPlane::needRectForOriginal(const QRect &rect) const
 {
     /**
      * Need rect should also be adjust for the layers that generate their 'original'
      * based on the contents of the child layers like KisGroupLayer
      *
      * \see bug 366419
      */
 
     QRect needRect = rect;
 
     if (m_d->style->isEnabled()) {
         needRect |= stylesNeedRect(needRect);
     }
 
     KisAbstractProjectionPlaneSP sourcePlane = m_d->sourceProjectionPlane.toStrongRef();
     needRect = sourcePlane->needRectForOriginal(needRect);
 
     return needRect;
 }
 
 QRect KisLayerStyleProjectionPlane::stylesNeedRect(const QRect &rect) const
 {
     QRect needRect = rect;
 
-    Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->stylesBefore) {
-        needRect |= plane->needRect(rect, KisLayer::N_ABOVE_FILTHY);
-    }
-
-    Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->stylesAfter) {
+    Q_FOREACH (const KisAbstractProjectionPlaneSP plane, m_d->allStyles()) {
         needRect |= plane->needRect(rect, KisLayer::N_ABOVE_FILTHY);
     }
 
     return needRect;
 }
diff --git a/libs/image/layerstyles/kis_ls_bevel_emboss_filter.cpp b/libs/image/layerstyles/kis_ls_bevel_emboss_filter.cpp
index 0702cd7e39..6dd739390c 100644
--- a/libs/image/layerstyles/kis_ls_bevel_emboss_filter.cpp
+++ b/libs/image/layerstyles/kis_ls_bevel_emboss_filter.cpp
@@ -1,502 +1,519 @@
 /*
  *  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"
+#include "kis_cached_paint_device.h"
 
 
 KisLsBevelEmbossFilter::KisLsBevelEmbossFilter()
     : KisLayerStyleFilter(KoID("lsstroke", i18n("Stroke (style)")))
 {
 }
 
 KisLayerStyleFilter *KisLsBevelEmbossFilter::clone() const
 {
     return new KisLsBevelEmbossFilter(*this);
 }
 
 KisLsBevelEmbossFilter::KisLsBevelEmbossFilter(const KisLsBevelEmbossFilter &rhs)
     : KisLayerStyleFilter(rhs)
 {
 }
 
 void paintBevelSelection(KisPixelSelectionSP srcSelection,
                          KisPixelSelectionSP dstSelection,
                          const QRect &applyRect,
                          int size,
                          int initialSize,
-                         bool invert)
+                         bool invert,
+                         KisLayerStyleFilterEnvironment *env)
 {
-    KisSelectionSP tmpBaseSelection = new KisSelection(new KisSelectionEmptyBounds(0));
+    KisCachedSelection::Guard s1(*env->cachedSelection());
+    KisSelectionSP tmpBaseSelection = s1.selection();
     KisPixelSelectionSP tmpSelection = tmpBaseSelection->pixelSelection();
 
     // NOTE: we are not using createCompositionSourceDevice() intentionally,
     //       because the source device doesn't have alpha channel
-    KisPixelSelectionSP fillDevice = new KisPixelSelection();
+    KisCachedSelection::Guard s2(*env->cachedSelection());
+    KisPixelSelectionSP fillDevice = s2.selection()->pixelSelection();
 
     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);
+    KisCachedSelection::Guard s1(*env->cachedSelection());
+    KisSelectionSP baseSelection = s1.selection();
+    KisLsUtils::selectionFromAlphaChannel(srcDevice, baseSelection, 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));
+    KisCachedSelection::Guard s2(*env->cachedSelection());
+    KisPixelSelectionSP bumpmapSelection = s2.selection()->pixelSelection();
 
     switch (config->style()) {
     case psd_bevel_outer_bevel:
-        paintBevelSelection(selection, bumpmapSelection, d.applyBevelRect, size, size, false);
+        paintBevelSelection(selection, bumpmapSelection, d.applyBevelRect, size, size, false, env);
         limitingGrowSize = size;
         break;
     case psd_bevel_inner_bevel:
-        paintBevelSelection(selection, bumpmapSelection, d.applyBevelRect, size, 0, false);
+        paintBevelSelection(selection, bumpmapSelection, d.applyBevelRect, size, 0, false, env);
         limitingGrowSize = 0;
         break;
     case psd_bevel_emboss: {
         const int initialSize = std::ceil(qreal(size) / 2.0);
-        paintBevelSelection(selection, bumpmapSelection, d.applyBevelRect, size, initialSize, false);
+        paintBevelSelection(selection, bumpmapSelection, d.applyBevelRect, size, initialSize, false, env);
         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);
+        paintBevelSelection(selection, bumpmapSelection, d.applyBevelRect, halfSizeC, halfSizeC, false, env);
+        paintBevelSelection(selection, bumpmapSelection, d.applyBevelRect, halfSizeF, 0, true, env);
         limitingGrowSize = halfSizeC;
         break;
     }
     case psd_bevel_stroke_emboss:
         warnKrita << "WARNING: Stroke Emboss style is not implemented yet!";
         return;
     }
 
-    KisPixelSelectionSP limitingSelection = new KisPixelSelection(*selection);
+    KisCachedSelection::Guard s3(*env->cachedSelection());
+    KisPixelSelectionSP limitingSelection = s3.selection()->pixelSelection();
+    limitingSelection->makeCloneFromRough(selection, selection->selectedRect());
     {
         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));
+        KisCachedSelection::Guard s4(*env->cachedSelection());
+        KisPixelSelectionSP textureSelection = s4.selection()->pixelSelection();
 
         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::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());
+
+        KisCachedPaintDevice::Guard d1(dstDevice, *env->cachedPaintDevice());
+        KisPaintDeviceSP fillDevice = d1.device();
         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());
+
+        KisCachedPaintDevice::Guard d1(dstDevice, *env->cachedPaintDevice());
+        KisPaintDeviceSP fillDevice = d1.device();
         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
+                                             KisLayerStyleKnockoutBlower *blower,
+                                             const QRect &applyRect,
+                                             KisPSDLayerStyleSP style,
+                                             KisLayerStyleFilterEnvironment *env) const
 {
     Q_UNUSED(env);
+    Q_UNUSED(blower);
     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_bevel_emboss_filter.h b/libs/image/layerstyles/kis_ls_bevel_emboss_filter.h
index 32787846ae..914f40c82f 100644
--- a/libs/image/layerstyles/kis_ls_bevel_emboss_filter.h
+++ b/libs/image/layerstyles/kis_ls_bevel_emboss_filter.h
@@ -1,57 +1,58 @@
 /*
  *  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_LS_BEVEL_EMBOSS_FILTER_H
 #define KIS_LS_BEVEL_EMBOSS_FILTER_H
 
 #include <QSharedPointer>
 
 #include "kis_layer_style_filter.h"
 #include <kritaimage_export.h>
 
 struct psd_layer_effects_bevel_emboss;
 
 
 class KRITAIMAGE_EXPORT KisLsBevelEmbossFilter : public KisLayerStyleFilter
 {
 public:
     KisLsBevelEmbossFilter();
 
     KisLayerStyleFilter* clone() const override;
 
     void processDirectly(KisPaintDeviceSP src,
                          KisMultipleProjection *dst,
+                         KisLayerStyleKnockoutBlower *blower,
                          const QRect &applyRect,
                          KisPSDLayerStyleSP style,
                          KisLayerStyleFilterEnvironment *env) const override;
 
     QRect neededRect(const QRect & rect, KisPSDLayerStyleSP style, KisLayerStyleFilterEnvironment *env) const override;
     QRect changedRect(const QRect & rect, KisPSDLayerStyleSP style, KisLayerStyleFilterEnvironment *env) const override;
 
 
 private:
     KisLsBevelEmbossFilter(const KisLsBevelEmbossFilter &rhs);
 
     void applyBevelEmboss(KisPaintDeviceSP srcDevice,
                           KisMultipleProjection *dst,
                           const QRect &applyRect,
                           const psd_layer_effects_bevel_emboss *config,
                           KisLayerStyleFilterEnvironment *env) const;
 };
 
 #endif
diff --git a/libs/image/layerstyles/kis_ls_drop_shadow_filter.cpp b/libs/image/layerstyles/kis_ls_drop_shadow_filter.cpp
index 39581b8951..562df8a4b3 100644
--- a/libs/image/layerstyles/kis_ls_drop_shadow_filter.cpp
+++ b/libs/image/layerstyles/kis_ls_drop_shadow_filter.cpp
@@ -1,294 +1,299 @@
 /*
  *  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"
+#include "kis_cached_paint_device.h"
 
 
 
 KisLsDropShadowFilter::KisLsDropShadowFilter(Mode mode)
     : KisLayerStyleFilter(KoID("lsdropshadow", i18n("Drop Shadow (style)")))
     , m_mode(mode)
 {
 }
 
 KisLsDropShadowFilter::KisLsDropShadowFilter(const KisLsDropShadowFilter &rhs)
     : KisLayerStyleFilter(rhs),
       m_mode(rhs.m_mode)
 {
 }
 
 KisLayerStyleFilter *KisLsDropShadowFilter::clone() const
 {
     return new KisLsDropShadowFilter(*this);
 }
 
 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)
+void KisLsDropShadowFilter::applyDropShadow(KisPaintDeviceSP srcDevice,
+                                            KisMultipleProjection *dst,
+                                            const QRect &applyRect,
+                                            const psd_layer_effects_context *context,
+                                            const psd_layer_effects_shadow_base *shadow,
+                                            KisLayerStyleFilterEnvironment *env) const
 {
     if (applyRect.isEmpty()) return;
 
     ShadowRectsData d(applyRect, context, shadow, ShadowRectsData::NEED_RECT);
 
-    KisSelectionSP baseSelection =
-        KisLsUtils::selectionFromAlphaChannel(srcDevice, d.spreadNeedRect);
+    KisCachedSelection::Guard s1(*env->cachedSelection());
+    KisSelectionSP baseSelection = s1.selection();
+    KisLsUtils::selectionFromAlphaChannel(srcDevice, baseSelection, 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
      */
+    KisCachedSelection::Guard s2(*env->cachedSelection());
     KisPixelSelectionSP knockOutSelection;
     if (shadow->knocksOut()) {
-        knockOutSelection = new KisPixelSelection(*selection);
+        knockOutSelection = s2.selection()->pixelSelection();
+        knockOutSelection->makeCloneFromRough(selection, selection->selectedRect());
     }
 
     if (shadow->technique() == psd_technique_precise) {
         KisLsUtils::findEdge(selection, d.blurNeedRect, true);
     }
 
     /**
      * Spread and blur the selection
      */
     if (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::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());
+        selection->moveTo(selection->offset() + d.offset);
     }
 
     /**
      * 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,
+                                            KisLayerStyleKnockoutBlower *blower,
                                             const QRect &applyRect,
                                             KisPSDLayerStyleSP style,
                                             KisLayerStyleFilterEnvironment *env) const
 {
+    Q_UNUSED(blower);
     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_drop_shadow_filter.h b/libs/image/layerstyles/kis_ls_drop_shadow_filter.h
index 30c5cc23df..5494f56572 100644
--- a/libs/image/layerstyles/kis_ls_drop_shadow_filter.h
+++ b/libs/image/layerstyles/kis_ls_drop_shadow_filter.h
@@ -1,62 +1,70 @@
 /*
  *  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_LS_DROP_SHADOW_FILTER_H
 #define KIS_LS_DROP_SHADOW_FILTER_H
 
 #include <QSharedPointer>
 
 #include "kis_layer_style_filter.h"
 #include <kritaimage_export.h>
 
 class psd_layer_effects_shadow_base;
 
 
 class KRITAIMAGE_EXPORT KisLsDropShadowFilter : public KisLayerStyleFilter
 {
 public:
 
     enum Mode {
         DropShadow,
         InnerShadow,
         OuterGlow,
         InnerGlow
     };
 
     KisLsDropShadowFilter(Mode mode = DropShadow);
 
     KisLayerStyleFilter* clone() const override;
 
     void processDirectly(KisPaintDeviceSP src,
                          KisMultipleProjection *dst,
+                         KisLayerStyleKnockoutBlower *blower,
                          const QRect &applyRect,
                          KisPSDLayerStyleSP style,
                          KisLayerStyleFilterEnvironment *env) const override;
 
     QRect neededRect(const QRect & rect, KisPSDLayerStyleSP style, KisLayerStyleFilterEnvironment *env) const override;
     QRect changedRect(const QRect & rect, KisPSDLayerStyleSP style, KisLayerStyleFilterEnvironment *env) const override;
 
 private:
     KisLsDropShadowFilter(const KisLsDropShadowFilter &rhs);
     const psd_layer_effects_shadow_base* getShadowStruct(KisPSDLayerStyleSP style) const;
 
+    void applyDropShadow(KisPaintDeviceSP srcDevice,
+                         KisMultipleProjection *dst,
+                         const QRect &applyRect,
+                         const psd_layer_effects_context *context,
+                         const psd_layer_effects_shadow_base *shadow,
+                         KisLayerStyleFilterEnvironment *env) const;
+
 private:
     const Mode m_mode;
 };
 
 #endif
diff --git a/libs/image/layerstyles/kis_ls_overlay_filter.cpp b/libs/image/layerstyles/kis_ls_overlay_filter.cpp
index 688fbb439d..9a424b9ec9 100644
--- a/libs/image/layerstyles/kis_ls_overlay_filter.cpp
+++ b/libs/image/layerstyles/kis_ls_overlay_filter.cpp
@@ -1,142 +1,131 @@
 /*
  *  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_overlay_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"
 
 
 
 KisLsOverlayFilter::KisLsOverlayFilter(Mode mode)
     : KisLayerStyleFilter(KoID("lsoverlay", i18n("Overlay (style)"))),
       m_mode(mode)
 {
 }
 
 KisLsOverlayFilter::KisLsOverlayFilter(const KisLsOverlayFilter &rhs)
     : KisLayerStyleFilter(rhs),
       m_mode(rhs.m_mode)
 {
 }
 
 KisLayerStyleFilter *KisLsOverlayFilter::clone() const
 {
     return new KisLsOverlayFilter(*this);
 }
 
 void KisLsOverlayFilter::applyOverlay(KisPaintDeviceSP srcDevice,
                                       KisMultipleProjection *dst,
                                       const QRect &applyRect,
                                       const psd_layer_effects_overlay_base *config,
                                       KisLayerStyleFilterEnvironment *env) const
 {
     if (applyRect.isEmpty()) return;
 
-    KisPaintDeviceSP overlayDevice = m_cachedDevices.getDevice(srcDevice);
-    KisLsUtils::fillOverlayDevice(overlayDevice, applyRect, config, env);
-
     const QString compositeOp = config->blendMode();
-    const quint8 opacityU8 = 255.0 / 100.0 * config->opacity();
+    const quint8 opacityU8 = quint8(qRound(255.0 / 100.0 * config->opacity()));
 
     KisPaintDeviceSP dstDevice = dst->getProjection(KisMultipleProjection::defaultProjectionId(),
                                                     compositeOp,
                                                     opacityU8,
                                                     QBitArray(),
                                                     srcDevice);
 
-    KisPainter::copyAreaOptimized(applyRect.topLeft(), srcDevice, dstDevice, applyRect);
-
-    KisPainter gc(dstDevice);
-    gc.setCompositeOp(COMPOSITE_OVER);
-
-    const QBitArray channelFlags = srcDevice->colorSpace()->channelFlags(true, false);
-    gc.setChannelFlags(channelFlags);
-    gc.bitBlt(applyRect.topLeft(), overlayDevice, applyRect);
-    gc.end();
-
-    m_cachedDevices.putDevice(overlayDevice);
+    KisLsUtils::fillOverlayDevice(dstDevice, applyRect, config, env);
 }
 
 const psd_layer_effects_overlay_base*
 KisLsOverlayFilter::getOverlayStruct(KisPSDLayerStyleSP style) const
 {
     const psd_layer_effects_overlay_base *config = 0;
 
     if (m_mode == Color) {
         config = style->colorOverlay();
     } else if (m_mode == Gradient) {
         config = style->gradientOverlay();
     } else if (m_mode == Pattern) {
         config = style->patternOverlay();
     }
 
     return config;
 }
 
 void KisLsOverlayFilter::processDirectly(KisPaintDeviceSP src,
                                          KisMultipleProjection *dst,
+                                         KisLayerStyleKnockoutBlower *blower,
                                          const QRect &applyRect,
                                          KisPSDLayerStyleSP style,
                                          KisLayerStyleFilterEnvironment *env) const
 {
     Q_UNUSED(env);
+    Q_UNUSED(blower);
     KIS_ASSERT_RECOVER_RETURN(style);
 
     const psd_layer_effects_overlay_base *config = getOverlayStruct(style);
     if (!KisLsUtils::checkEffectEnabled(config, dst)) return;
 
     applyOverlay(src, dst, applyRect, config, env);
 }
 
 QRect KisLsOverlayFilter::neededRect(const QRect &rect, KisPSDLayerStyleSP style, KisLayerStyleFilterEnvironment *env) const
 {
     Q_UNUSED(style);
     Q_UNUSED(env);
     return rect;
 }
 
 QRect KisLsOverlayFilter::changedRect(const QRect &rect, KisPSDLayerStyleSP style, KisLayerStyleFilterEnvironment *env) const
 {
     Q_UNUSED(style);
     Q_UNUSED(env);
     return rect;
 }
diff --git a/libs/image/layerstyles/kis_ls_overlay_filter.h b/libs/image/layerstyles/kis_ls_overlay_filter.h
index 79cfc6e6c6..73a624831c 100644
--- a/libs/image/layerstyles/kis_ls_overlay_filter.h
+++ b/libs/image/layerstyles/kis_ls_overlay_filter.h
@@ -1,70 +1,69 @@
 /*
  *  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_LS_OVERLAY_FILTER_H
 #define KIS_LS_OVERLAY_FILTER_H
 
 #include <QSharedPointer>
 
 #include "kis_layer_style_filter.h"
 #include <kritaimage_export.h>
-#include "kis_cached_paint_device.h"
 
 struct psd_layer_effects_overlay_base;
 
 
 class KRITAIMAGE_EXPORT KisLsOverlayFilter : public KisLayerStyleFilter
 {
 public:
     enum Mode {
         Color,
         Gradient,
         Pattern
     };
 
 public:
     KisLsOverlayFilter(Mode mode);
 
     KisLayerStyleFilter* clone() const override;
 
     void processDirectly(KisPaintDeviceSP src,
                          KisMultipleProjection *dst,
+                         KisLayerStyleKnockoutBlower *blower,
                          const QRect &applyRect,
                          KisPSDLayerStyleSP style,
                          KisLayerStyleFilterEnvironment *env) const override;
 
     QRect neededRect(const QRect & rect, KisPSDLayerStyleSP style, KisLayerStyleFilterEnvironment *env) const override;
     QRect changedRect(const QRect & rect, KisPSDLayerStyleSP style, KisLayerStyleFilterEnvironment *env) const override;
 
 private:
     KisLsOverlayFilter(const KisLsOverlayFilter &rhs);
 
     const psd_layer_effects_overlay_base* getOverlayStruct(KisPSDLayerStyleSP style) const;
 
     void applyOverlay(KisPaintDeviceSP srcDevice,
                       KisMultipleProjection *dst,
                       const QRect &applyRect,
                       const psd_layer_effects_overlay_base *config,
                       KisLayerStyleFilterEnvironment *env) const;
 
 private:
     Mode m_mode;
-    mutable KisCachedPaintDevice m_cachedDevices;
 };
 
 #endif
diff --git a/libs/image/layerstyles/kis_ls_satin_filter.cpp b/libs/image/layerstyles/kis_ls_satin_filter.cpp
index 4b96d0be63..90887601fe 100644
--- a/libs/image/layerstyles/kis_ls_satin_filter.cpp
+++ b/libs/image/layerstyles/kis_ls_satin_filter.cpp
@@ -1,240 +1,228 @@
 /*
  *  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"
+#include "kis_cached_paint_device.h"
 
 
 KisLsSatinFilter::KisLsSatinFilter()
     : KisLayerStyleFilter(KoID("lssatin", i18n("Satin (style)")))
 {
 }
 
 KisLsSatinFilter::KisLsSatinFilter(const KisLsSatinFilter &rhs)
     : KisLayerStyleFilter(rhs)
 {
 }
 
 KisLayerStyleFilter *KisLsSatinFilter::clone() const
 {
     return new KisLsSatinFilter(*this);
 }
 
 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;
+            *dstPixelPtr = qAbs(*src1PixelPtr - *src2PixelPtr);
         } else {
-            *dstPixelPtr = *dstPixelPtr * (255 - qAbs(*src1PixelPtr - *src2PixelPtr)) >> 8;
+            *dstPixelPtr = (255 - qAbs(*src1PixelPtr - *src2PixelPtr));
         }
     }
 }
 
-void applySatin(KisPaintDeviceSP srcDevice,
-                KisMultipleProjection *dst,
-                const QRect &applyRect,
-                const psd_layer_effects_context *context,
-                const psd_layer_effects_satin *config,
-                const KisLayerStyleFilterEnvironment *env)
+//#include "kis_paint_device_debug_utils.h"
+
+void KisLsSatinFilter::applySatin(KisPaintDeviceSP srcDevice,
+                                  KisMultipleProjection *dst,
+                                  const QRect &applyRect,
+                                  const psd_layer_effects_context *context,
+                                  const psd_layer_effects_satin *config,
+                                  KisLayerStyleFilterEnvironment *env) const
 {
     if (applyRect.isEmpty()) return;
 
     SatinRectsData d(applyRect, context, config, SatinRectsData::NEED_RECT);
 
-    KisSelectionSP baseSelection =
-        KisLsUtils::selectionFromAlphaChannel(srcDevice, d.blurNeedRect);
+    KisCachedSelection::Guard s1(*env->cachedSelection());
+    KisSelectionSP baseSelection = s1.selection();
+    KisLsUtils::selectionFromAlphaChannel(srcDevice, baseSelection, 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();
+    KisCachedSelection::Guard s2(*env->cachedSelection());
+    KisPixelSelectionSP tempSelection = s2.selection()->pixelSelection();
+    tempSelection->makeCloneFromRough(selection, selection->selectedRect());
 
-    //knockOutSelection->convertToQImage(0, QRect(0,0,300,300)).save("1_saved_knockout_selection.png");
-
-    KisPixelSelectionSP tempSelection = new KisPixelSelection(*selection);
+    //KIS_DUMP_DEVICE_2(tempSelection, QRect(0,0,64,64), "00_selection", "dd");
 
     KisLsUtils::applyGaussianWithTransaction(tempSelection, d.satinNeedRect, d.blur_size);
 
-    //tempSelection->convertToQImage(0, QRect(0,0,300,300)).save("2_selection_blurred.png");
+    //KIS_DUMP_DEVICE_2(tempSelection, QRect(0,0,64,64), "01_gauss", "dd");
 
     /**
      * 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");
+    //KIS_DUMP_DEVICE_2(tempSelection, QRect(0,0,64,64), "02_contour", "dd");
 
     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");
+    //KIS_DUMP_DEVICE_2(selection, QRect(0,0,64,64), "03_blended", "dd");
 
     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,
+                                       KisLayerStyleKnockoutBlower *blower,
                                        const QRect &applyRect,
                                        KisPSDLayerStyleSP style,
                                        KisLayerStyleFilterEnvironment *env) const
 {
+    Q_UNUSED(blower);
     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_satin_filter.h b/libs/image/layerstyles/kis_ls_satin_filter.h
index bb3c170e95..205eac0335 100644
--- a/libs/image/layerstyles/kis_ls_satin_filter.h
+++ b/libs/image/layerstyles/kis_ls_satin_filter.h
@@ -1,49 +1,58 @@
 /*
  *  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_LS_SATIN_FILTER_H
 #define KIS_LS_SATIN_FILTER_H
 
 #include <QSharedPointer>
 
 #include "kis_layer_style_filter.h"
 #include <kritaimage_export.h>
 
 
 
 class KRITAIMAGE_EXPORT KisLsSatinFilter : public KisLayerStyleFilter
 {
 public:
     KisLsSatinFilter();
 
     KisLayerStyleFilter* clone() const override;
 
     void processDirectly(KisPaintDeviceSP src,
                          KisMultipleProjection *dst,
+                         KisLayerStyleKnockoutBlower *blower,
                          const QRect &applyRect,
                          KisPSDLayerStyleSP style,
                          KisLayerStyleFilterEnvironment *env) const override;
 
     QRect neededRect(const QRect & rect, KisPSDLayerStyleSP style, KisLayerStyleFilterEnvironment *env) const override;
     QRect changedRect(const QRect & rect, KisPSDLayerStyleSP style, KisLayerStyleFilterEnvironment *env) const override;
 
 private:
     KisLsSatinFilter(const KisLsSatinFilter &rhs);
+
+
+    void applySatin(KisPaintDeviceSP srcDevice,
+                    KisMultipleProjection *dst,
+                    const QRect &applyRect,
+                    const psd_layer_effects_context *context,
+                    const psd_layer_effects_satin *config,
+                    KisLayerStyleFilterEnvironment *env) const;
 };
 
 #endif
diff --git a/libs/image/layerstyles/kis_ls_stroke_filter.cpp b/libs/image/layerstyles/kis_ls_stroke_filter.cpp
index db8d3890e6..db94fec07c 100644
--- a/libs/image/layerstyles/kis_ls_stroke_filter.cpp
+++ b/libs/image/layerstyles/kis_ls_stroke_filter.cpp
@@ -1,161 +1,171 @@
 /*
  *  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"
+#include "kis_cached_paint_device.h"
+#include "krita_utils.h"
+#include "KisLayerStyleKnockoutBlower.h"
+
 
 namespace {
 
 int borderSize(psd_stroke_position position, int size)
 {
     int border = 0;
 
     switch (position) {
     case psd_stroke_outside:
-        border = 2 * size + 1;
+        border = size + 1;
         break;
     case psd_stroke_center:
-        border = size + 1;
+        border = qCeil(0.5 * size) + 1;
         break;
     case psd_stroke_inside:
         border = 1;
         break;
     }
 
     return border;
 }
 
 }
 
 
 KisLsStrokeFilter::KisLsStrokeFilter()
     : KisLayerStyleFilter(KoID("lsstroke", i18n("Stroke (style)")))
 {
 }
 
 KisLsStrokeFilter::KisLsStrokeFilter(const KisLsStrokeFilter &rhs)
     : KisLayerStyleFilter(rhs)
 {
 }
 
 KisLayerStyleFilter *KisLsStrokeFilter::clone() const
 {
     return new KisLsStrokeFilter(*this);
 }
 
 void KisLsStrokeFilter::applyStroke(KisPaintDeviceSP srcDevice,
                                     KisMultipleProjection *dst,
+                                    KisLayerStyleKnockoutBlower *blower,
                                     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);
+    KisSelectionSP baseSelection = blower->knockoutSelectionLazy();
+
+    KisLsUtils::selectionFromAlphaChannel(srcDevice, baseSelection, needRect);
     KisPixelSelectionSP selection = baseSelection->pixelSelection();
 
+//    KritaUtils::filterAlpha8Device(selection, needRect,
+//                                   [](quint8 pixel) {
+//                                       return pixel > 0 ? 255 : 0;
+//                                   });
+//    KisGaussianKernel::applyGaussian(selection, needRect, 1.0, 1.0, QBitArray(), 0);
+
     {
-        KisPixelSelectionSP knockOutSelection = new KisPixelSelection(new KisSelectionEmptyBounds(0));
+        KisCachedSelection::Guard s2(*env->cachedSelection());
+        KisPixelSelectionSP knockOutSelection = s2.selection()->pixelSelection();
         knockOutSelection->makeCloneFromRough(selection, needRect);
 
         if (config->position() == psd_stroke_outside) {
-            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, true);
-        } else if (config->position() == psd_stroke_center) {
             KisGaussianKernel::applyDilate(selection, needRect, config->size(), QBitArray(), 0, true);
+        } else if (config->position() == psd_stroke_inside) {
             KisGaussianKernel::applyErodeU8(knockOutSelection, needRect, config->size(), QBitArray(), 0, true);
+        } else if (config->position() == psd_stroke_center) {
+            KisGaussianKernel::applyDilate(selection, needRect, 0.5 * config->size(), QBitArray(), 0, true);
+            KisGaussianKernel::applyErodeU8(knockOutSelection, needRect, 0.5 * 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();
+    const quint8 opacityU8 = quint8(qRound(255.0 / 100.0 * config->opacity()));
     KisPaintDeviceSP dstDevice = dst->getProjection(KisMultipleProjection::defaultProjectionId(),
                                                     compositeOp,
                                                     opacityU8,
                                                     QBitArray(),
                                                     srcDevice);
-
-    KisPainter::copyAreaOptimized(applyRect.topLeft(), fillDevice, dstDevice, applyRect, baseSelection);
+    KisLsUtils::fillOverlayDevice(dstDevice, applyRect, config, env);
 }
 
 void KisLsStrokeFilter::processDirectly(KisPaintDeviceSP src,
                                         KisMultipleProjection *dst,
-                                         const QRect &applyRect,
-                                         KisPSDLayerStyleSP style,
-                                         KisLayerStyleFilterEnvironment *env) const
+                                        KisLayerStyleKnockoutBlower *blower,
+                                        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);
+    applyStroke(src, dst, blower, 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_stroke_filter.h b/libs/image/layerstyles/kis_ls_stroke_filter.h
index 48a9c893ba..a9df43f64f 100644
--- a/libs/image/layerstyles/kis_ls_stroke_filter.h
+++ b/libs/image/layerstyles/kis_ls_stroke_filter.h
@@ -1,56 +1,58 @@
 /*
  *  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_LS_STROKE_FILTER_H
 #define KIS_LS_STROKE_FILTER_H
 
 #include <QSharedPointer>
 #include <kritaimage_export.h>
 
 #include "kis_layer_style_filter.h"
 
 struct psd_layer_effects_stroke;
 
 
 class KRITAIMAGE_EXPORT KisLsStrokeFilter : public KisLayerStyleFilter
 {
 public:
     KisLsStrokeFilter();
 
     KisLayerStyleFilter* clone() const override;
 
     void processDirectly(KisPaintDeviceSP src,
                          KisMultipleProjection *dst,
+                         KisLayerStyleKnockoutBlower *blower,
                          const QRect &applyRect,
                          KisPSDLayerStyleSP style,
                          KisLayerStyleFilterEnvironment *env) const override;
 
     QRect neededRect(const QRect & rect, KisPSDLayerStyleSP style, KisLayerStyleFilterEnvironment *env) const override;
     QRect changedRect(const QRect & rect, KisPSDLayerStyleSP style, KisLayerStyleFilterEnvironment *env) const override;
 
 private:
     KisLsStrokeFilter(const KisLsStrokeFilter &rhs);
 
     void applyStroke(KisPaintDeviceSP srcDevice,
                      KisMultipleProjection *dst,
+                     KisLayerStyleKnockoutBlower *blower,
                      const QRect &applyRect,
                      const psd_layer_effects_stroke *config,
                      KisLayerStyleFilterEnvironment *env) const;
 };
 
 #endif
diff --git a/libs/image/layerstyles/kis_ls_utils.cpp b/libs/image/layerstyles/kis_ls_utils.cpp
index 9cdae6b0ca..93b606ef05 100644
--- a/libs/image/layerstyles/kis_ls_utils.cpp
+++ b/libs/image/layerstyles/kis_ls_utils.cpp
@@ -1,588 +1,591 @@
 /*
  *  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"
 #include "kis_default_bounds_base.h"
-
+#include "kis_cached_paint_device.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, selection->defaultBounds());
             filter.process(selection, applyRect);
         } else if (growSize < 0) {
             KisShrinkSelectionFilter filter(qAbs(growSize), qAbs(growSize), false);
             changeRect = filter.changeRect(applyRect, selection->defaultBounds());
             filter.process(selection, applyRect);
         }
 
         return changeRect;
     }
 
-    KisSelectionSP selectionFromAlphaChannel(KisPaintDeviceSP device,
-                                             const QRect &srcRect)
+    void selectionFromAlphaChannel(KisPaintDeviceSP srcDevice,
+                                      KisSelectionSP dstSelection,
+                                      const QRect &srcRect)
     {
-        const KoColorSpace *cs = device->colorSpace();
+        const KoColorSpace *cs = srcDevice->colorSpace();
+
 
-        KisSelectionSP baseSelection = new KisSelection(new KisSelectionEmptyBounds(0));
-        KisPixelSelectionSP selection = baseSelection->pixelSelection();
+        KisPixelSelectionSP selection = dstSelection->pixelSelection();
 
-        KisSequentialConstIterator srcIt(device, srcRect);
+        KisSequentialConstIterator srcIt(srcDevice, 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 applyGaussianWithTransaction(KisPixelSelectionSP selection,
                                       const QRect &applyRect,
                                       qreal radius)
     {
         KisGaussianKernel::applyGaussian(selection, applyRect,
                                          radius, radius,
                                          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)
+                    KisLayerStyleFilterEnvironment *env)
     {
         Q_UNUSED(context);
 
         const QRect overlayRect = kisGrowRect(applyRect, noiseNeedBorder);
 
         KisPixelSelectionSP randomSelection = env->cachedRandomSelection(overlayRect);
-        KisPixelSelectionSP randomOverlay = new KisPixelSelection();
+
+
+        KisCachedSelection::Guard s1(*env->cachedSelection());
+        KisPixelSelectionSP randomOverlay = s1.selection()->pixelSelection();
 
         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!";
         }
         KIS_SAFE_ASSERT_RECOVER_RETURN(pattern);
 
         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();
+        const quint8 opacityU8 = quint8(qRound(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 4dacfc3e37..bd6c7e5ac7 100644
--- a/libs/image/layerstyles/kis_ls_utils.h
+++ b/libs/image/layerstyles/kis_ls_utils.h
@@ -1,126 +1,129 @@
 /*
  *  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 "kritaimage_export.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;
+class KisCachedSelection;
 
 
 namespace KisLsUtils
 {
 
     QRect growSelectionUniform(KisPixelSelectionSP selection, int growSize, const QRect &applyRect);
 
-    KisSelectionSP selectionFromAlphaChannel(KisPaintDeviceSP device,
-                                             const QRect &srcRect);
+    KRITAIMAGE_EXPORT void selectionFromAlphaChannel(KisPaintDeviceSP srcDevice,
+                                                        KisSelectionSP dstSelection,
+                                                        const QRect &srcRect);
 
     void findEdge(KisPixelSelectionSP selection, const QRect &applyRect, const bool edgeHidden);
     QRect growRectFromRadius(const QRect &rc, int 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);
+                    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/image/layerstyles/kis_multiple_projection.cpp b/libs/image/layerstyles/kis_multiple_projection.cpp
index 49905ec58f..9e4247e913 100644
--- a/libs/image/layerstyles/kis_multiple_projection.cpp
+++ b/libs/image/layerstyles/kis_multiple_projection.cpp
@@ -1,178 +1,183 @@
 /*
  *  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_multiple_projection.h"
 
 #include <QMap>
 #include <QReadWriteLock>
 
 
 #include <KoColorSpace.h>
 
 #include "kis_painter.h"
 #include "kis_paint_device.h"
 #include "kis_layer_style_filter_environment.h"
 
 
 struct ProjectionStruct {
     KisPaintDeviceSP device;
     QString compositeOpId;
     quint8 opacity = OPACITY_OPAQUE_U8;
     QBitArray channelFlags;
 };
 
 typedef QMap<QString, ProjectionStruct> PlanesMap;
 
 struct KisMultipleProjection::Private
 {
     QReadWriteLock lock;
     PlanesMap planes;
 };
 
 
 KisMultipleProjection::KisMultipleProjection()
     : m_d(new Private)
 {
 }
 
 KisMultipleProjection::KisMultipleProjection(const KisMultipleProjection &rhs)
     : m_d(new Private)
 {
     QReadLocker readLocker(&rhs.m_d->lock);
 
     auto it = rhs.m_d->planes.constBegin();
     for (; it != rhs.m_d->planes.constEnd(); ++it) {
         ProjectionStruct proj;
         proj.device = new KisPaintDevice(*it->device);
         proj.compositeOpId = it->compositeOpId;
         proj.opacity = it->opacity;
         proj.channelFlags = it->channelFlags;
 
         m_d->planes.insert(it.key(), proj);
     }
 }
 
 KisMultipleProjection::~KisMultipleProjection()
 {
 }
 
 QString KisMultipleProjection::defaultProjectionId()
 {
     return "00_default";
 }
 
 KisPaintDeviceSP KisMultipleProjection::getProjection(const QString &id,
                                                       const QString &compositeOpId,
                                                       quint8 opacity,
                                                       const QBitArray &channelFlags,
                                                       KisPaintDeviceSP prototype)
 {
     QReadLocker readLocker(&m_d->lock);
 
     PlanesMap::const_iterator constIt = m_d->planes.constFind(id);
 
     if (constIt == m_d->planes.constEnd() ||
         constIt->compositeOpId != compositeOpId ||
         constIt->opacity != opacity ||
         constIt->channelFlags != channelFlags ||
         *constIt->device->colorSpace() != *prototype->colorSpace()) {
 
         readLocker.unlock();
 
         {
             QWriteLocker writeLocker(&m_d->lock);
 
             PlanesMap::iterator writeIt = m_d->planes.find(id);
             if (writeIt == m_d->planes.end()) {
                 ProjectionStruct plane;
                 plane.device = new KisPaintDevice(prototype->colorSpace());
                 plane.device->prepareClone(prototype);
                 plane.compositeOpId = compositeOpId;
                 plane.opacity = opacity;
                 plane.channelFlags = channelFlags;
                 writeIt = m_d->planes.insert(id, plane);
             } else if (writeIt->compositeOpId != compositeOpId ||
                        *writeIt->device->colorSpace() != *prototype->colorSpace()) {
 
                 writeIt->device->prepareClone(prototype);
                 writeIt->compositeOpId = compositeOpId;
                 writeIt->opacity = opacity;
                 writeIt->channelFlags = channelFlags;
             }
 
             return writeIt->device;
         }
     }
 
     return constIt->device;
 }
 
 void KisMultipleProjection::freeProjection(const QString &id)
 {
     QWriteLocker writeLocker(&m_d->lock);
     m_d->planes.remove(id);
 }
 
 void KisMultipleProjection::freeAllProjections()
 {
     QWriteLocker writeLocker(&m_d->lock);
     m_d->planes.clear();
 }
 
 void KisMultipleProjection::clear(const QRect &rc)
 {
     QReadLocker readLocker(&m_d->lock);
 
     PlanesMap::const_iterator it = m_d->planes.constBegin();
     PlanesMap::const_iterator end = m_d->planes.constEnd();
 
     for (; it != end; ++it) {
         const_cast<KisPaintDevice*>(it->device.data())->clear(rc);
     }
 }
 
 void KisMultipleProjection::apply(KisPaintDeviceSP dstDevice, const QRect &rect, KisLayerStyleFilterEnvironment *env)
 {
     QReadLocker readLocker(&m_d->lock);
 
     PlanesMap::const_iterator it = m_d->planes.constBegin();
     PlanesMap::const_iterator end = m_d->planes.constEnd();
 
     for (; it != end; ++it) {
         KisPainter gc(dstDevice);
         gc.setCompositeOp(it->compositeOpId);
         env->setupFinalPainter(&gc, it->opacity, it->channelFlags);
         gc.bitBlt(rect.topLeft(), it->device, rect);
     }
 }
 
 KisPaintDeviceList KisMultipleProjection::getLodCapableDevices() const
 {
     QReadLocker readLocker(&m_d->lock);
 
     PlanesMap::const_iterator it = m_d->planes.constBegin();
     PlanesMap::const_iterator end = m_d->planes.constEnd();
 
     KisPaintDeviceList list;
     for (; it != end; ++it) {
         list << it->device;
     }
 
     return list;
 }
 
+bool KisMultipleProjection::isEmpty() const
+{
+    return m_d->planes.isEmpty();
+}
+
diff --git a/libs/image/layerstyles/kis_multiple_projection.h b/libs/image/layerstyles/kis_multiple_projection.h
index 8ce98d7689..6c8c948f1a 100644
--- a/libs/image/layerstyles/kis_multiple_projection.h
+++ b/libs/image/layerstyles/kis_multiple_projection.h
@@ -1,52 +1,54 @@
 /*
  *  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_MULTIPLE_PROJECTION_H
 #define __KIS_MULTIPLE_PROJECTION_H
 
 #include <QScopedPointer>
 #include "kis_types.h"
 #include "kritaimage_export.h"
 
 class KisLayerStyleFilterEnvironment;
 
 class KRITAIMAGE_EXPORT KisMultipleProjection
 {
 public:
     KisMultipleProjection();
     KisMultipleProjection(const KisMultipleProjection &rhs);
     ~KisMultipleProjection();
 
     static QString defaultProjectionId();
 
     KisPaintDeviceSP getProjection(const QString &id, const QString &compositeOpId, quint8 opacity, const QBitArray &channelFlags, KisPaintDeviceSP prototype);
     void freeProjection(const QString &id);
     void freeAllProjections();
 
     void clear(const QRect &rc);
 
     void apply(KisPaintDeviceSP dstDevice, const QRect &rect, KisLayerStyleFilterEnvironment *env);
 
     KisPaintDeviceList getLodCapableDevices() const;
 
+    bool isEmpty() const;
+
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 #endif /* __KIS_MULTIPLE_PROJECTION_H */
diff --git a/libs/image/lazybrush/kis_colorize_mask.cpp b/libs/image/lazybrush/kis_colorize_mask.cpp
index d5437bf9c4..f59a3eca84 100644
--- a/libs/image/lazybrush/kis_colorize_mask.cpp
+++ b/libs/image/lazybrush/kis_colorize_mask.cpp
@@ -1,1176 +1,1172 @@
 /*
  *  Copyright (c) 2016 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_colorize_mask.h"
 
 #include <QCoreApplication>
 #include <QStack>
 
 #include <KoColorSpaceRegistry.h>
 #include "kis_pixel_selection.h"
 
 #include "kis_icon_utils.h"
 
 #include "kis_node_visitor.h"
 #include "kis_processing_visitor.h"
 #include "kis_painter.h"
 #include "kis_fill_painter.h"
 #include "kis_lazy_fill_tools.h"
 #include "kis_cached_paint_device.h"
 #include "kis_paint_device_debug_utils.h"
 #include "kis_layer_properties_icons.h"
 #include "kis_thread_safe_signal_compressor.h"
 
 #include "kis_colorize_stroke_strategy.h"
 #include "kis_multiway_cut.h"
 #include "kis_image.h"
 #include "kis_layer.h"
 #include "kis_macro_based_undo_store.h"
 #include "kis_post_execution_undo_adapter.h"
 #include "kis_command_utils.h"
 #include "kis_processing_applicator.h"
 #include "krita_utils.h"
 
 
 using namespace KisLazyFillTools;
 
 struct KisColorizeMask::Private
 {
     Private(KisColorizeMask *_q)
         : q(_q),
           coloringProjection(new KisPaintDevice(KoColorSpaceRegistry::instance()->rgb8())),
           fakePaintDevice(new KisPaintDevice(KoColorSpaceRegistry::instance()->rgb8())),
           filteredSource(new KisPaintDevice(KoColorSpaceRegistry::instance()->rgb8())),
           needAddCurrentKeyStroke(false),
           showKeyStrokes(true),
           showColoring(true),
           needsUpdate(true),
           originalSequenceNumber(-1),
           updateCompressor(1000, KisSignalCompressor::FIRST_ACTIVE_POSTPONE_NEXT),
           dirtyParentUpdateCompressor(200, KisSignalCompressor::FIRST_ACTIVE_POSTPONE_NEXT),
           prefilterRecalculationCompressor(1000, KisSignalCompressor::POSTPONE),
           updateIsRunning(false),
           filteringOptions(false, 4.0, 15, 0.7),
           limitToDeviceBounds(false)
     {
     }
 
     Private(const Private &rhs, KisColorizeMask *_q)
         : q(_q),
           coloringProjection(new KisPaintDevice(*rhs.coloringProjection)),
           fakePaintDevice(new KisPaintDevice(*rhs.fakePaintDevice)),
           filteredSource(new KisPaintDevice(*rhs.filteredSource)),
           filteredDeviceBounds(rhs.filteredDeviceBounds),
           needAddCurrentKeyStroke(rhs.needAddCurrentKeyStroke),
           showKeyStrokes(rhs.showKeyStrokes),
           showColoring(rhs.showColoring),
           needsUpdate(false),
           originalSequenceNumber(-1),
           updateCompressor(1000, KisSignalCompressor::FIRST_ACTIVE_POSTPONE_NEXT),
           dirtyParentUpdateCompressor(200, KisSignalCompressor::FIRST_ACTIVE_POSTPONE_NEXT),
           prefilterRecalculationCompressor(1000, KisSignalCompressor::POSTPONE),
           offset(rhs.offset),
           updateIsRunning(false),
           filteringOptions(rhs.filteringOptions),
           limitToDeviceBounds(rhs.limitToDeviceBounds)
     {
         Q_FOREACH (const KeyStroke &stroke, rhs.keyStrokes) {
             keyStrokes << KeyStroke(KisPaintDeviceSP(new KisPaintDevice(*stroke.dev)), stroke.color, stroke.isTransparent);
         }
     }
 
     KisColorizeMask *q = 0;
 
     QList<KeyStroke> keyStrokes;
     KisPaintDeviceSP coloringProjection;
     KisPaintDeviceSP fakePaintDevice;
     KisPaintDeviceSP filteredSource;
     QRect filteredDeviceBounds;
 
     KoColor currentColor;
     KisPaintDeviceSP currentKeyStrokeDevice;
     bool needAddCurrentKeyStroke;
 
     bool showKeyStrokes;
     bool showColoring;
 
     KisCachedSelection cachedSelection;
-    KisCachedSelection cachedConversionSelection;
 
     bool needsUpdate;
     int originalSequenceNumber;
 
     KisThreadSafeSignalCompressor updateCompressor;
     KisThreadSafeSignalCompressor dirtyParentUpdateCompressor;
     KisThreadSafeSignalCompressor prefilterRecalculationCompressor;
     QPoint offset;
 
     bool updateIsRunning;
     QStack<QRect> extentBeforeUpdateStart;
 
     FilteringOptions filteringOptions;
     bool filteringDirty = true;
 
     bool limitToDeviceBounds = false;
 
     bool filteredSourceValid(KisPaintDeviceSP parentDevice) {
         return !filteringDirty && originalSequenceNumber == parentDevice->sequenceNumber();
     }
 
     void setNeedsUpdateImpl(bool value, bool requestedByUser);
 
     bool shouldShowFilteredSource() const;
     bool shouldShowColoring() const;
 };
 
 KisColorizeMask::KisColorizeMask()
     : m_d(new Private(this))
 {
     connect(&m_d->updateCompressor,
             SIGNAL(timeout()),
             SLOT(slotUpdateRegenerateFilling()));
 
     connect(this, SIGNAL(sigUpdateOnDirtyParent()),
             &m_d->dirtyParentUpdateCompressor, SLOT(start()));
 
     connect(&m_d->dirtyParentUpdateCompressor,
             SIGNAL(timeout()),
             SLOT(slotUpdateOnDirtyParent()));
 
     connect(&m_d->prefilterRecalculationCompressor,
             SIGNAL(timeout()),
             SLOT(slotRecalculatePrefilteredImage()));
 
 
     m_d->updateCompressor.moveToThread(qApp->thread());
 }
 
 KisColorizeMask::~KisColorizeMask()
 {
 }
 
 KisColorizeMask::KisColorizeMask(const KisColorizeMask& rhs)
     : KisEffectMask(rhs),
       m_d(new Private(*rhs.m_d, this))
 {
     connect(&m_d->updateCompressor,
             SIGNAL(timeout()),
             SLOT(slotUpdateRegenerateFilling()));
 
     connect(this, SIGNAL(sigUpdateOnDirtyParent()),
             &m_d->dirtyParentUpdateCompressor, SLOT(start()));
 
     connect(&m_d->dirtyParentUpdateCompressor,
             SIGNAL(timeout()),
             SLOT(slotUpdateOnDirtyParent()));
 
     m_d->updateCompressor.moveToThread(qApp->thread());
 }
 
 void KisColorizeMask::initializeCompositeOp()
 {
     KisLayerSP parentLayer(qobject_cast<KisLayer*>(parent().data()));
     if (!parentLayer || !parentLayer->original()) return;
 
     KisImageSP image = parentLayer->image();
     if (!image) return;
 
     const qreal samplePortion = 0.1;
     const qreal alphaPortion =
         KritaUtils::estimatePortionOfTransparentPixels(parentLayer->original(),
                                                        image->bounds(),
                                                        samplePortion);
 
     setCompositeOpId(alphaPortion > 0.3 ? COMPOSITE_BEHIND : COMPOSITE_MULT);
 }
 
 const KoColorSpace* KisColorizeMask::colorSpace() const
 {
     return m_d->fakePaintDevice->colorSpace();
 }
 
 struct SetKeyStrokesColorSpaceCommand : public KUndo2Command {
     SetKeyStrokesColorSpaceCommand(const KoColorSpace *dstCS,
                                    KoColorConversionTransformation::Intent renderingIntent,
                                    KoColorConversionTransformation::ConversionFlags conversionFlags,
                                    QList<KeyStroke> *list,
                                    KisColorizeMaskSP node)
         : m_dstCS(dstCS),
           m_renderingIntent(renderingIntent),
           m_conversionFlags(conversionFlags),
           m_list(list),
           m_node(node) {}
 
     void undo() override {
         KIS_ASSERT_RECOVER_RETURN(m_list->size() == m_oldColors.size());
 
         for (int i = 0; i < m_list->size(); i++) {
             (*m_list)[i].color = m_oldColors[i];
         }
 
         m_node->setNeedsUpdate(true);
     }
 
     void redo() override {
         if (m_oldColors.isEmpty()) {
             Q_FOREACH(const KeyStroke &stroke, *m_list) {
                 m_oldColors << stroke.color;
                 m_newColors << stroke.color;
                 m_newColors.last().convertTo(m_dstCS, m_renderingIntent, m_conversionFlags);
             }
         }
 
         KIS_ASSERT_RECOVER_RETURN(m_list->size() == m_newColors.size());
 
         for (int i = 0; i < m_list->size(); i++) {
             (*m_list)[i].color = m_newColors[i];
         }
 
         m_node->setNeedsUpdate(true);
     }
 
 private:
     QVector<KoColor> m_oldColors;
     QVector<KoColor> m_newColors;
 
     const KoColorSpace *m_dstCS;
     KoColorConversionTransformation::Intent m_renderingIntent;
     KoColorConversionTransformation::ConversionFlags m_conversionFlags;
     QList<KeyStroke> *m_list;
     KisColorizeMaskSP m_node;
 };
 
 
 void KisColorizeMask::setProfile(const KoColorProfile *profile)
 {
     // WARNING: there is no undo information, used only while loading!
 
     m_d->fakePaintDevice->setProfile(profile);
     m_d->coloringProjection->setProfile(profile);
 
     for (auto stroke : m_d->keyStrokes) {
         stroke.color.setProfile(profile);
     }
 }
 
 KUndo2Command* KisColorizeMask::setColorSpace(const KoColorSpace * dstColorSpace,
                                               KoColorConversionTransformation::Intent renderingIntent,
                                               KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     using namespace KisCommandUtils;
 
     CompositeCommand *composite = new CompositeCommand();
 
     m_d->fakePaintDevice->convertTo(dstColorSpace, renderingIntent, conversionFlags, composite);
     m_d->coloringProjection->convertTo(dstColorSpace, renderingIntent, conversionFlags, composite);
 
     KUndo2Command *strokesConversionCommand =
         new SetKeyStrokesColorSpaceCommand(
             dstColorSpace, renderingIntent, conversionFlags,
             &m_d->keyStrokes, KisColorizeMaskSP(this));
     strokesConversionCommand->redo();
 
     composite->addCommand(new SkipFirstRedoWrapper(strokesConversionCommand));
 
     return composite;
 }
 
 bool KisColorizeMask::needsUpdate() const
 {
     return m_d->needsUpdate;
 }
 
 void KisColorizeMask::setNeedsUpdate(bool value)
 {
     m_d->setNeedsUpdateImpl(value, true);
 }
 
 void KisColorizeMask::Private::setNeedsUpdateImpl(bool value, bool requestedByUser)
 {
     if (value != needsUpdate) {
         needsUpdate = value;
         q->baseNodeChangedCallback();
 
         if (!value && requestedByUser) {
             updateCompressor.start();
         }
     }
 }
 
 void KisColorizeMask::slotUpdateRegenerateFilling(bool prefilterOnly)
 {
     KisPaintDeviceSP src = parent()->original();
     KIS_ASSERT_RECOVER_RETURN(src);
 
     const bool filteredSourceValid = m_d->filteredSourceValid(src);
     m_d->originalSequenceNumber = src->sequenceNumber();
     m_d->filteringDirty = false;
 
     if (!prefilterOnly) {
         m_d->coloringProjection->clear();
     }
 
     KisLayerSP parentLayer(qobject_cast<KisLayer*>(parent().data()));
     if (!parentLayer) return;
 
     KisImageSP image = parentLayer->image();
     if (image) {
         m_d->updateIsRunning = true;
 
         QRect fillBounds;
 
         if (m_d->limitToDeviceBounds) {
             fillBounds |= src->exactBounds();
             Q_FOREACH (const KeyStroke &stroke, m_d->keyStrokes) {
                 fillBounds |= stroke.dev->exactBounds();
             }
             fillBounds &= image->bounds();
         } else {
             fillBounds = image->bounds();
         }
 
         m_d->filteredDeviceBounds = fillBounds;
 
         KisColorizeStrokeStrategy *strategy =
             new KisColorizeStrokeStrategy(src,
                                           m_d->coloringProjection,
                                           m_d->filteredSource,
                                           filteredSourceValid,
                                           fillBounds,
                                           this,
                                           prefilterOnly);
 
         strategy->setFilteringOptions(m_d->filteringOptions);
 
         Q_FOREACH (const KeyStroke &stroke, m_d->keyStrokes) {
             const KoColor color =
                 !stroke.isTransparent ?
                 stroke.color :
                 KoColor(Qt::transparent, stroke.color.colorSpace());
 
             strategy->addKeyStroke(stroke.dev, color);
         }
 
         m_d->extentBeforeUpdateStart.push(extent());
 
         connect(strategy, SIGNAL(sigFinished(bool)), SLOT(slotRegenerationFinished(bool)));
         connect(strategy, SIGNAL(sigCancelled()), SLOT(slotRegenerationCancelled()));
         KisStrokeId id = image->startStroke(strategy);
         image->endStroke(id);
     }
 }
 
 void KisColorizeMask::slotUpdateOnDirtyParent()
 {
     if (!parent()) {
         // When the colorize mask is being merged,
         // the update is performed for all the layers,
         // so the invisible areas around the canvas are included in the merged layer.
         // Colorize Mask gets the info that its parent is "dirty" (needs updating),
         // but when it arrives, the parent doesn't exists anymore and is set to null.
         // Colorize Mask doesn't work outside of the canvas anyway (at least in time of writing).
         return;
     }
     KisPaintDeviceSP src = parent()->original();
     KIS_ASSERT_RECOVER_RETURN(src);
 
     if (!m_d->filteredSourceValid(src)) {
         const QRect &oldExtent = extent();
 
         m_d->setNeedsUpdateImpl(true, false);
         m_d->filteringDirty = true;
 
         setDirty(oldExtent | extent());
     }
 }
 
 void KisColorizeMask::slotRecalculatePrefilteredImage()
 {
     slotUpdateRegenerateFilling(true);
 }
 
 void KisColorizeMask::slotRegenerationFinished(bool prefilterOnly)
 {
     m_d->updateIsRunning = false;
 
     if (!prefilterOnly) {
         m_d->setNeedsUpdateImpl(false, false);
     }
 
     QRect oldExtent;
 
     if (!m_d->extentBeforeUpdateStart.isEmpty()) {
         oldExtent = m_d->extentBeforeUpdateStart.pop();
     } else {
         KIS_SAFE_ASSERT_RECOVER_NOOP(!m_d->extentBeforeUpdateStart.isEmpty()); // always fail!
     }
 
     setDirty(oldExtent | extent());
 }
 
 void KisColorizeMask::slotRegenerationCancelled()
 {
     slotRegenerationFinished(true);
 }
 
 KisBaseNode::PropertyList KisColorizeMask::sectionModelProperties() const
 {
     KisBaseNode::PropertyList l = KisMask::sectionModelProperties();
     l << KisLayerPropertiesIcons::getProperty(KisLayerPropertiesIcons::colorizeNeedsUpdate, needsUpdate());
     l << KisLayerPropertiesIcons::getProperty(KisLayerPropertiesIcons::colorizeEditKeyStrokes, showKeyStrokes());
     l << KisLayerPropertiesIcons::getProperty(KisLayerPropertiesIcons::colorizeShowColoring, showColoring());
 
     return l;
 }
 
 void KisColorizeMask::setSectionModelProperties(const KisBaseNode::PropertyList &properties)
 {
     KisMask::setSectionModelProperties(properties);
 
     Q_FOREACH (const KisBaseNode::Property &property, properties) {
         if (property.id == KisLayerPropertiesIcons::colorizeNeedsUpdate.id()) {
             if (m_d->needsUpdate && m_d->needsUpdate != property.state.toBool()) {
                 setNeedsUpdate(property.state.toBool());
             }
         }
         if (property.id == KisLayerPropertiesIcons::colorizeEditKeyStrokes.id()) {
             if (m_d->showKeyStrokes != property.state.toBool()) {
                 setShowKeyStrokes(property.state.toBool());
             }
         }
         if (property.id == KisLayerPropertiesIcons::colorizeShowColoring.id()) {
             if (m_d->showColoring != property.state.toBool()) {
                 setShowColoring(property.state.toBool());
             }
         }
     }
 }
 
 KisPaintDeviceSP KisColorizeMask::paintDevice() const
 {
     return m_d->showKeyStrokes && !m_d->updateIsRunning ? m_d->fakePaintDevice : KisPaintDeviceSP();
 }
 
 KisPaintDeviceSP KisColorizeMask::coloringProjection() const
 {
     return m_d->coloringProjection;
 }
 
 KisPaintDeviceSP KisColorizeMask::colorPickSourceDevice() const
 {
     return
         m_d->shouldShowColoring() && !m_d->coloringProjection->extent().isEmpty() ?
             m_d->coloringProjection : projection();
 }
 
 QIcon KisColorizeMask::icon() const
 {
     return KisIconUtils::loadIcon("colorizeMask");
 }
 
 
 bool KisColorizeMask::accept(KisNodeVisitor &v)
 {
     return v.visit(this);
 }
 
 void KisColorizeMask::accept(KisProcessingVisitor &visitor, KisUndoAdapter *undoAdapter)
 {
     return visitor.visit(this, undoAdapter);
 }
 
 bool KisColorizeMask::Private::shouldShowFilteredSource() const
 {
     return !updateIsRunning &&
             showKeyStrokes &&
             !filteringDirty &&
             filteredSource &&
             !filteredSource->extent().isEmpty();
 }
 
 bool KisColorizeMask::Private::shouldShowColoring() const
 {
     return !updateIsRunning &&
             showColoring &&
             coloringProjection;
 }
 
 QRect KisColorizeMask::decorateRect(KisPaintDeviceSP &src,
                                     KisPaintDeviceSP &dst,
                                     const QRect &rect,
                                     PositionToFilthy maskPos) const
 {
     Q_UNUSED(maskPos);
 
     if (maskPos == N_ABOVE_FILTHY) {
         // the source layer has changed, we should update the filtered cache!
 
         if (!m_d->filteringDirty) {
             emit sigUpdateOnDirtyParent();
         }
     }
 
     KIS_ASSERT(dst != src);
 
     // Draw the filling and the original layer
     {
         KisPainter gc(dst);
 
         if (m_d->shouldShowFilteredSource()) {
             const QRect drawRect = m_d->limitToDeviceBounds ? rect & m_d->filteredDeviceBounds : rect;
 
             gc.setOpacity(128);
             gc.bitBlt(drawRect.topLeft(), m_d->filteredSource, drawRect);
         } else {
             gc.setOpacity(255);
             gc.bitBlt(rect.topLeft(), src, rect);
         }
 
         if (m_d->shouldShowColoring()) {
 
             gc.setOpacity(opacity());
             gc.setCompositeOp(compositeOpId());
             gc.bitBlt(rect.topLeft(), m_d->coloringProjection, rect);
         }
     }
 
     // Draw the key strokes
     if (m_d->showKeyStrokes) {
         KisIndirectPaintingSupport::ReadLocker locker(this);
 
-        KisSelectionSP selection = m_d->cachedSelection.getSelection();
-        KisSelectionSP conversionSelection = m_d->cachedConversionSelection.getSelection();
-        KisPixelSelectionSP tempSelection = conversionSelection->pixelSelection();
+        KisCachedSelection::Guard s1(m_d->cachedSelection);
+        KisCachedSelection::Guard s2(m_d->cachedSelection);
+
+        KisSelectionSP selection = s1.selection();
+        KisPixelSelectionSP tempSelection = s2.selection()->pixelSelection();
 
         KisPaintDeviceSP temporaryTarget = this->temporaryTarget();
         const bool isTemporaryTargetErasing = temporaryCompositeOp() == COMPOSITE_ERASE;
         const QRect temporaryExtent = temporaryTarget ? temporaryTarget->extent() : QRect();
 
 
         KisFillPainter gc(dst);
 
         QList<KeyStroke> extendedStrokes = m_d->keyStrokes;
 
         if (m_d->currentKeyStrokeDevice &&
             m_d->needAddCurrentKeyStroke &&
             !isTemporaryTargetErasing) {
 
             extendedStrokes << KeyStroke(m_d->currentKeyStrokeDevice, m_d->currentColor);
         }
 
         Q_FOREACH (const KeyStroke &stroke, extendedStrokes) {
             selection->pixelSelection()->makeCloneFromRough(stroke.dev, rect);
             gc.setSelection(selection);
 
             if (stroke.color == m_d->currentColor ||
                 (isTemporaryTargetErasing &&
                  temporaryExtent.intersects(selection->pixelSelection()->selectedRect()))) {
 
                 if (temporaryTarget) {
                     tempSelection->copyAlphaFrom(temporaryTarget, rect);
 
                     KisPainter selectionPainter(selection->pixelSelection());
                     setupTemporaryPainter(&selectionPainter);
                     selectionPainter.bitBlt(rect.topLeft(), tempSelection, rect);
                 }
             }
 
             gc.fillSelection(rect, stroke.color);
         }
-
-        m_d->cachedSelection.putSelection(selection);
-        m_d->cachedSelection.putSelection(conversionSelection);
     }
 
     return rect;
 }
 
 struct DeviceExtentPolicy
 {
     inline QRect operator() (const KisPaintDevice *dev) {
         return dev->extent();
     }
 };
 
 struct DeviceExactBoundsPolicy
 {
     inline QRect operator() (const KisPaintDevice *dev) {
         return dev->exactBounds();
     }
 };
 
 template <class DeviceMetricPolicy>
 QRect KisColorizeMask::calculateMaskBounds(DeviceMetricPolicy boundsPolicy) const
 {
     QRect rc;
 
     if (m_d->shouldShowFilteredSource()) {
         rc |= boundsPolicy(m_d->filteredSource);
     }
 
     if (m_d->shouldShowColoring()) {
         rc |= boundsPolicy(m_d->coloringProjection);
     }
 
     if (m_d->showKeyStrokes) {
         Q_FOREACH (const KeyStroke &stroke, m_d->keyStrokes) {
             rc |= boundsPolicy(stroke.dev);
         }
 
         KisIndirectPaintingSupport::ReadLocker locker(this);
 
         KisPaintDeviceSP temporaryTarget = this->temporaryTarget();
         if (temporaryTarget) {
             rc |= boundsPolicy(temporaryTarget);
         }
     }
 
     return rc;
 }
 
 
 QRect KisColorizeMask::extent() const
 {
     return calculateMaskBounds(DeviceExtentPolicy());
 }
 
 QRect KisColorizeMask::exactBounds() const
 {
     return calculateMaskBounds(DeviceExactBoundsPolicy());
 }
 
 QRect KisColorizeMask::nonDependentExtent() const
 {
     return extent();
 }
 
 KisImageSP KisColorizeMask::fetchImage() const
 {
     KisLayerSP parentLayer(qobject_cast<KisLayer*>(parent().data()));
     if (!parentLayer) return KisImageSP();
 
     return parentLayer->image();
 }
 
 void KisColorizeMask::setImage(KisImageWSP image)
 {
     KisDefaultBoundsSP bounds(new KisDefaultBounds(image));
 
     auto it = m_d->keyStrokes.begin();
     for(; it != m_d->keyStrokes.end(); ++it) {
         it->dev->setDefaultBounds(bounds);
     }
 
     m_d->coloringProjection->setDefaultBounds(bounds);
     m_d->fakePaintDevice->setDefaultBounds(bounds);
     m_d->filteredSource->setDefaultBounds(bounds);
 }
 
 void KisColorizeMask::setCurrentColor(const KoColor &_color)
 {
     KoColor color = _color;
     color.convertTo(colorSpace());
 
     WriteLocker locker(this);
 
     m_d->setNeedsUpdateImpl(true, false);
 
     QList<KeyStroke>::const_iterator it =
         std::find_if(m_d->keyStrokes.constBegin(),
                      m_d->keyStrokes.constEnd(),
                      [color] (const KeyStroke &s) {
                          return s.color == color;
                      });
 
     KisPaintDeviceSP activeDevice;
     bool newKeyStroke = false;
 
     if (it == m_d->keyStrokes.constEnd()) {
         activeDevice = new KisPaintDevice(KoColorSpaceRegistry::instance()->alpha8());
         activeDevice->setParentNode(this);
         activeDevice->setDefaultBounds(KisDefaultBoundsBaseSP(new KisDefaultBounds(fetchImage())));
         newKeyStroke = true;
     } else {
         activeDevice = it->dev;
     }
 
     m_d->currentColor = color;
     m_d->currentKeyStrokeDevice = activeDevice;
     m_d->needAddCurrentKeyStroke = newKeyStroke;
 }
 
 
 
 struct KeyStrokeAddRemoveCommand : public KisCommandUtils::FlipFlopCommand {
     KeyStrokeAddRemoveCommand(bool add, int index, KeyStroke stroke, QList<KeyStroke> *list, KisColorizeMaskSP node)
         : FlipFlopCommand(!add),
           m_index(index), m_stroke(stroke),
           m_list(list), m_node(node) {}
 
     void partA() override {
         m_list->insert(m_index, m_stroke);
         m_node->setNeedsUpdate(true);
         emit m_node->sigKeyStrokesListChanged();
     }
 
     void partB() override {
         KIS_ASSERT_RECOVER_RETURN((*m_list)[m_index] == m_stroke);
         m_list->removeAt(m_index);
         m_node->setNeedsUpdate(true);
         emit m_node->sigKeyStrokesListChanged();
     }
 
 private:
     int m_index;
     KeyStroke m_stroke;
     QList<KeyStroke> *m_list;
     KisColorizeMaskSP m_node;
 };
 
 void KisColorizeMask::mergeToLayer(KisNodeSP layer, KisPostExecutionUndoAdapter *undoAdapter, const KUndo2MagicString &transactionText,int timedID)
 {
     Q_UNUSED(layer);
 
     WriteLocker locker(this);
 
     KisPaintDeviceSP temporaryTarget = this->temporaryTarget();
     const bool isTemporaryTargetErasing = temporaryCompositeOp() == COMPOSITE_ERASE;
     const QRect temporaryExtent = temporaryTarget ? temporaryTarget->extent() : QRect();
 
     KisSavedMacroCommand *macro = undoAdapter->createMacro(transactionText);
     KisMacroBasedUndoStore store(macro);
     KisPostExecutionUndoAdapter fakeUndoAdapter(&store, undoAdapter->strokesFacade());
 
     /**
      * Add a new key stroke plane
      */
     if (m_d->needAddCurrentKeyStroke && !isTemporaryTargetErasing) {
         KeyStroke key(m_d->currentKeyStrokeDevice, m_d->currentColor);
 
         KUndo2Command *cmd =
             new KeyStrokeAddRemoveCommand(
                 true, m_d->keyStrokes.size(), key, &m_d->keyStrokes, KisColorizeMaskSP(this));
         cmd->redo();
         fakeUndoAdapter.addCommand(toQShared(cmd));
     }
 
     /**
      * When erasing, the brush affects all the key strokes, not only
      * the current one.
      */
     if (!isTemporaryTargetErasing) {
         mergeToLayerImpl(m_d->currentKeyStrokeDevice, &fakeUndoAdapter, transactionText, timedID, false);
     } else {
         Q_FOREACH (const KeyStroke &stroke, m_d->keyStrokes) {
             if (temporaryExtent.intersects(stroke.dev->extent())) {
                 mergeToLayerImpl(stroke.dev, &fakeUndoAdapter, transactionText, timedID, false);
             }
         }
     }
 
     mergeToLayerImpl(m_d->fakePaintDevice, &fakeUndoAdapter, transactionText, timedID, false);
 
     m_d->currentKeyStrokeDevice = 0;
     m_d->currentColor = KoColor();
     releaseResources();
 
     /**
      * Try removing the key strokes that has been completely erased
      */
     if (isTemporaryTargetErasing) {
         for (int index = 0; index < m_d->keyStrokes.size(); /*noop*/) {
             const KeyStroke &stroke = m_d->keyStrokes[index];
 
             if (stroke.dev->exactBounds().isEmpty()) {
                 KUndo2Command *cmd =
                     new KeyStrokeAddRemoveCommand(
                         false, index, stroke, &m_d->keyStrokes, KisColorizeMaskSP(this));
 
                 cmd->redo();
                 fakeUndoAdapter.addCommand(toQShared(cmd));
 
             } else {
                 index++;
             }
         }
     }
 
     undoAdapter->addMacro(macro);
 }
 
 void KisColorizeMask::writeMergeData(KisPainter *painter, KisPaintDeviceSP src)
 {
     const KoColorSpace *alpha8 = KoColorSpaceRegistry::instance()->alpha8();
     const bool nonAlphaDst = !(*painter->device()->colorSpace() == *alpha8);
 
     if (nonAlphaDst) {
         Q_FOREACH (const QRect &rc, src->region().rects()) {
             painter->bitBlt(rc.topLeft(), src, rc);
         }
     } else {
-        KisSelectionSP conversionSelection = m_d->cachedConversionSelection.getSelection();
-        KisPixelSelectionSP tempSelection = conversionSelection->pixelSelection();
+        KisCachedSelection::Guard s1(m_d->cachedSelection);
+        KisPixelSelectionSP tempSelection = s1.selection()->pixelSelection();
 
         Q_FOREACH (const QRect &rc, src->region().rects()) {
             tempSelection->copyAlphaFrom(src, rc);
             painter->bitBlt(rc.topLeft(), tempSelection, rc);
         }
-        m_d->cachedSelection.putSelection(conversionSelection);
     }
 }
 
 bool KisColorizeMask::supportsNonIndirectPainting() const
 {
     return false;
 }
 
 bool KisColorizeMask::showColoring() const
 {
     return m_d->showColoring;
 }
 
 void KisColorizeMask::setShowColoring(bool value)
 {
     QRect savedExtent;
     if (m_d->showColoring && !value) {
         savedExtent = extent();
     }
 
     m_d->showColoring = value;
     baseNodeChangedCallback();
 
     if (!savedExtent.isEmpty()) {
         setDirty(savedExtent);
     }
 }
 
 bool KisColorizeMask::showKeyStrokes() const
 {
     return m_d->showKeyStrokes;
 }
 
 void KisColorizeMask::setShowKeyStrokes(bool value)
 {
     QRect savedExtent;
     if (m_d->showKeyStrokes && !value) {
         savedExtent = extent();
     }
 
     m_d->showKeyStrokes = value;
     baseNodeChangedCallback();
 
     if (!savedExtent.isEmpty()) {
         setDirty(savedExtent);
     }
 
     regeneratePrefilteredDeviceIfNeeded();
 }
 
 KisColorizeMask::KeyStrokeColors KisColorizeMask::keyStrokesColors() const
 {
     KeyStrokeColors colors;
 
     // TODO: thread safety!
     for (int i = 0; i < m_d->keyStrokes.size(); i++) {
         colors.colors << m_d->keyStrokes[i].color;
 
         if (m_d->keyStrokes[i].isTransparent) {
             colors.transparentIndex = i;
         }
     }
 
     return colors;
 }
 
 struct SetKeyStrokeColorsCommand : public KUndo2Command {
     SetKeyStrokeColorsCommand(const QList<KeyStroke> newList, QList<KeyStroke> *list, KisColorizeMaskSP node)
         : m_newList(newList),
           m_oldList(*list),
           m_list(list),
           m_node(node) {}
 
     void redo() override {
         *m_list = m_newList;
 
         m_node->setNeedsUpdate(true);
         emit m_node->sigKeyStrokesListChanged();
         m_node->setDirty();
     }
 
     void undo() override {
         *m_list = m_oldList;
 
         m_node->setNeedsUpdate(true);
         emit m_node->sigKeyStrokesListChanged();
         m_node->setDirty();
     }
 
 private:
     QList<KeyStroke> m_newList;
     QList<KeyStroke> m_oldList;
     QList<KeyStroke> *m_list;
     KisColorizeMaskSP m_node;
 };
 
 void KisColorizeMask::setKeyStrokesColors(KeyStrokeColors colors)
 {
     KIS_ASSERT_RECOVER_RETURN(colors.colors.size() == m_d->keyStrokes.size());
 
     QList<KeyStroke> newList = m_d->keyStrokes;
 
     for (int i = 0; i < newList.size(); i++) {
         newList[i].color = colors.colors[i];
         newList[i].color.convertTo(colorSpace());
         newList[i].isTransparent = colors.transparentIndex == i;
     }
 
     KisProcessingApplicator applicator(fetchImage(), KisNodeSP(this),
                                        KisProcessingApplicator::NONE,
                                        KisImageSignalVector(),
                                        kundo2_i18n("Change Key Stroke Color"));
     applicator.applyCommand(
         new SetKeyStrokeColorsCommand(
             newList, &m_d->keyStrokes, KisColorizeMaskSP(this)));
 
     applicator.end();
 }
 
 void KisColorizeMask::removeKeyStroke(const KoColor &_color)
 {
     KoColor color = _color;
     color.convertTo(colorSpace());
 
     QList<KeyStroke>::iterator it =
         std::find_if(m_d->keyStrokes.begin(),
                      m_d->keyStrokes.end(),
                      [color] (const KeyStroke &s) {
                          return s.color == color;
                      });
 
     KIS_SAFE_ASSERT_RECOVER_RETURN(it != m_d->keyStrokes.end());
 
     const int index = it - m_d->keyStrokes.begin();
 
     KisProcessingApplicator applicator(KisImageWSP(fetchImage()), KisNodeSP(this),
                                        KisProcessingApplicator::NONE,
                                        KisImageSignalVector(),
                                        kundo2_i18n("Remove Key Stroke"));
     applicator.applyCommand(
         new KeyStrokeAddRemoveCommand(
             false, index, *it, &m_d->keyStrokes, KisColorizeMaskSP(this)));
 
     applicator.end();
 }
 
 
 QVector<KisPaintDeviceSP> KisColorizeMask::allPaintDevices() const
 {
     QVector<KisPaintDeviceSP> devices;
 
     Q_FOREACH (const KeyStroke &stroke, m_d->keyStrokes) {
         devices << stroke.dev;
     }
 
     devices << m_d->coloringProjection;
     devices << m_d->fakePaintDevice;
 
     return devices;
 }
 
 void KisColorizeMask::resetCache()
 {
     m_d->filteredSource->clear();
     m_d->originalSequenceNumber = -1;
     m_d->filteringDirty = true;
 
     rerenderFakePaintDevice();
     slotUpdateRegenerateFilling(true);
 }
 
 void KisColorizeMask::setUseEdgeDetection(bool value)
 {
     m_d->filteringOptions.useEdgeDetection = value;
     m_d->filteringDirty = true;
     setNeedsUpdate(true);
 }
 
 bool KisColorizeMask::useEdgeDetection() const
 {
     return m_d->filteringOptions.useEdgeDetection;
 }
 
 void KisColorizeMask::setEdgeDetectionSize(qreal value)
 {
     m_d->filteringOptions.edgeDetectionSize = value;
     m_d->filteringDirty = true;
     setNeedsUpdate(true);
 }
 
 qreal KisColorizeMask::edgeDetectionSize() const
 {
     return m_d->filteringOptions.edgeDetectionSize;
 }
 
 void KisColorizeMask::setFuzzyRadius(qreal value)
 {
     m_d->filteringOptions.fuzzyRadius = value;
     m_d->filteringDirty = true;
     setNeedsUpdate(true);
 }
 
 qreal KisColorizeMask::fuzzyRadius() const
 {
     return m_d->filteringOptions.fuzzyRadius;
 }
 
 void KisColorizeMask::setCleanUpAmount(qreal value)
 {
     m_d->filteringOptions.cleanUpAmount = value;
     setNeedsUpdate(true);
 }
 
 qreal KisColorizeMask::cleanUpAmount() const
 {
     return m_d->filteringOptions.cleanUpAmount;
 }
 
 void KisColorizeMask::setLimitToDeviceBounds(bool value)
 {
     m_d->limitToDeviceBounds = value;
     m_d->filteringDirty = true;
     setNeedsUpdate(true);
 }
 
 bool KisColorizeMask::limitToDeviceBounds() const
 {
     return m_d->limitToDeviceBounds;
 }
 
 void KisColorizeMask::rerenderFakePaintDevice()
 {
     m_d->fakePaintDevice->clear();
     KisFillPainter gc(m_d->fakePaintDevice);
 
-    KisSelectionSP selection = m_d->cachedSelection.getSelection();
+    KisCachedSelection::Guard s1(m_d->cachedSelection);
+    KisSelectionSP selection = s1.selection();
 
     Q_FOREACH (const KeyStroke &stroke, m_d->keyStrokes) {
         const QRect rect = stroke.dev->extent();
 
         selection->pixelSelection()->makeCloneFromRough(stroke.dev, rect);
         gc.setSelection(selection);
         gc.fillSelection(rect, stroke.color);
     }
-
-    m_d->cachedSelection.putSelection(selection);
 }
 
 void KisColorizeMask::testingAddKeyStroke(KisPaintDeviceSP dev, const KoColor &color, bool isTransparent)
 {
     m_d->keyStrokes << KeyStroke(dev, color, isTransparent);
 }
 
 void KisColorizeMask::testingRegenerateMask()
 {
     slotUpdateRegenerateFilling();
     m_d->updateIsRunning = false;
 }
 
 KisPaintDeviceSP KisColorizeMask::testingFilteredSource() const
 {
     return m_d->filteredSource;
 }
 
 QList<KeyStroke> KisColorizeMask::fetchKeyStrokesDirect() const
 {
     return m_d->keyStrokes;
 }
 
 void KisColorizeMask::setKeyStrokesDirect(const QList<KisLazyFillTools::KeyStroke> &strokes)
 {
     m_d->keyStrokes = strokes;
 
     for (auto it = m_d->keyStrokes.begin(); it != m_d->keyStrokes.end(); ++it) {
         it->dev->setParentNode(this);
     }
 
     KisImageSP image = fetchImage();
     KIS_SAFE_ASSERT_RECOVER_RETURN(image);
     setImage(image);
 }
 
 qint32 KisColorizeMask::x() const
 {
     return m_d->offset.x();
 }
 
 qint32 KisColorizeMask::y() const
 {
     return m_d->offset.y();
 }
 
 void KisColorizeMask::setX(qint32 x)
 {
     const QPoint oldOffset = m_d->offset;
     m_d->offset.rx() = x;
     moveAllInternalDevices(m_d->offset - oldOffset);
 }
 
 void KisColorizeMask::setY(qint32 y)
 {
     const QPoint oldOffset = m_d->offset;
     m_d->offset.ry() = y;
     moveAllInternalDevices(m_d->offset - oldOffset);
 }
 
 KisPaintDeviceList KisColorizeMask::getLodCapableDevices() const
 {
     KisPaintDeviceList list;
 
     auto it = m_d->keyStrokes.begin();
     for(; it != m_d->keyStrokes.end(); ++it) {
         list << it->dev;
     }
 
     list << m_d->coloringProjection;
     list << m_d->fakePaintDevice;
     list << m_d->filteredSource;
 
     return list;
 }
 
 void KisColorizeMask::regeneratePrefilteredDeviceIfNeeded()
 {
     if (!parent()) return;
 
     KisPaintDeviceSP src = parent()->original();
     KIS_ASSERT_RECOVER_RETURN(src);
 
     if (!m_d->filteredSourceValid(src)) {
         // update the prefiltered source if needed
         slotUpdateRegenerateFilling(true);
     }
 }
 
 void KisColorizeMask::moveAllInternalDevices(const QPoint &diff)
 {
     QVector<KisPaintDeviceSP> devices = allPaintDevices();
 
     Q_FOREACH (KisPaintDeviceSP dev, devices) {
         dev->moveTo(dev->offset() + diff);
     }
 }
diff --git a/libs/image/tests/kis_layer_style_projection_plane_test.cpp b/libs/image/tests/kis_layer_style_projection_plane_test.cpp
index 52105b92b5..095c1f56f7 100644
--- a/libs/image/tests/kis_layer_style_projection_plane_test.cpp
+++ b/libs/image/tests/kis_layer_style_projection_plane_test.cpp
@@ -1,499 +1,617 @@
 /*
  *  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_layer_style_projection_plane_test.h"
 
 #include <QTest>
 
 #include "testutil.h"
 
 #include <KoColor.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <resources/KoPattern.h>
 
 #include "kis_transparency_mask.h"
 #include "kis_paint_layer.h"
 #include "kis_image.h"
 #include "kis_painter.h"
 
 #include "kis_selection.h"
 #include "kis_pixel_selection.h"
 
 #include "layerstyles/kis_layer_style_projection_plane.h"
 #include "kis_psd_layer_style.h"
 #include "kis_paint_device_debug_utils.h"
 
 
 void KisLayerStyleProjectionPlaneTest::test(KisPSDLayerStyleSP style, const QString testName)
 {
     const QRect imageRect(0, 0, 200, 200);
     const QRect rFillRect(10, 10, 100, 100);
     const QRect tMaskRect(50, 50, 20, 20);
     const QRect partialSelectionRect(90, 50, 20, 20);
 
     const QRect updateRect1(10, 10, 50, 100);
     const QRect updateRect2(60, 10, 50, 100);
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
     KisImageSP image = new KisImage(0, imageRect.width(), imageRect.height(), cs, "styles test");
 
     KisPaintLayerSP layer = new KisPaintLayer(image, "test", OPACITY_OPAQUE_U8);
     image->addNode(layer);
 
     KisLayerStyleProjectionPlane plane(layer.data(), style);
 
     KIS_DUMP_DEVICE_2(layer->projection(), imageRect, "00L_initial", testName);
 
     //layer->paintDevice()->fill(rFillRect, KoColor(Qt::red, cs));
     {
         KisPainter gc(layer->paintDevice());
         gc.setPaintColor(KoColor(Qt::red, cs));
         gc.setFillStyle(KisPainter::FillStyleForegroundColor);
         gc.paintEllipse(rFillRect);
     }
 
     KIS_DUMP_DEVICE_2(layer->projection(), imageRect, "01L_fill", testName);
 
     KisPaintDeviceSP projection = new KisPaintDevice(cs);
 
     {
         const QRect changeRect = plane.changeRect(rFillRect, KisLayer::N_FILTHY);
         dbgKrita << ppVar(rFillRect) << ppVar(changeRect);
 
         plane.recalculate(changeRect, layer);
 
         KIS_DUMP_DEVICE_2(layer->projection(), imageRect, "02L_recalculate_fill", testName);
 
         KisPainter painter(projection);
         plane.apply(&painter, changeRect);
 
         KIS_DUMP_DEVICE_2(projection, imageRect, "03P_apply_on_fill", testName);
     }
 
     //return;
 
     KisTransparencyMaskSP transparencyMask = new KisTransparencyMask();
 
     KisSelectionSP selection = new KisSelection();
     selection->pixelSelection()->select(tMaskRect, OPACITY_OPAQUE_U8);
     transparencyMask->setSelection(selection);
     image->addNode(transparencyMask, layer);
 
     KIS_DUMP_DEVICE_2(layer->projection(), imageRect, "04L_mask_added", testName);
 
     plane.recalculate(imageRect, layer);
 
     KIS_DUMP_DEVICE_2(layer->projection(), imageRect, "05L_mask_added_recalculated", testName);
 
     {
         projection->clear();
 
         KisPainter painter(projection);
         plane.apply(&painter, imageRect);
 
         KIS_DUMP_DEVICE_2(projection, imageRect, "06P_apply_on_mask", testName);
     }
 
     selection->pixelSelection()->select(partialSelectionRect, OPACITY_OPAQUE_U8);
 
     {
         const QRect changeRect = plane.changeRect(partialSelectionRect, KisLayer::N_FILTHY);
         projection->clear(changeRect);
 
         dbgKrita << ppVar(partialSelectionRect) << ppVar(changeRect);
 
         plane.recalculate(changeRect, layer);
 
         KIS_DUMP_DEVICE_2(layer->projection(), imageRect, "07L_recalculate_partial", testName);
 
         KisPainter painter(projection);
         plane.apply(&painter, changeRect);
 
         KIS_DUMP_DEVICE_2(projection, imageRect, "08P_apply_partial", testName);
     }
 
     // half updates
     transparencyMask->setVisible(false);
 
     {
         const QRect changeRect = plane.changeRect(updateRect1, KisLayer::N_FILTHY);
         projection->clear(changeRect);
 
         dbgKrita << ppVar(updateRect1) << ppVar(changeRect);
 
         plane.recalculate(changeRect, layer);
 
         KIS_DUMP_DEVICE_2(layer->projection(), imageRect, "09L_recalculate_half1", testName);
 
         KisPainter painter(projection);
         plane.apply(&painter, changeRect);
 
         KIS_DUMP_DEVICE_2(projection, imageRect, "10P_apply_half1", testName);
     }
 
     {
         const QRect changeRect = plane.changeRect(updateRect2, KisLayer::N_FILTHY);
         projection->clear(changeRect);
 
         dbgKrita << ppVar(updateRect2) << ppVar(changeRect);
 
         plane.recalculate(changeRect, layer);
 
         KIS_DUMP_DEVICE_2(layer->projection(), imageRect, "09L_recalculate_half1", testName);
 
         KisPainter painter(projection);
         plane.apply(&painter, changeRect);
 
         KIS_DUMP_DEVICE_2(projection, imageRect, "10P_apply_half2", testName);
     }
 }
 
 void KisLayerStyleProjectionPlaneTest::testShadow()
 {
     KisPSDLayerStyleSP style(new KisPSDLayerStyle());
     style->dropShadow()->setSize(15);
     style->dropShadow()->setDistance(15);
     style->dropShadow()->setOpacity(70);
     style->dropShadow()->setNoise(30);
     style->dropShadow()->setEffectEnabled(true);
 
     style->innerShadow()->setSize(10);
     style->innerShadow()->setSpread(10);
     style->innerShadow()->setDistance(5);
     style->innerShadow()->setOpacity(70);
     style->innerShadow()->setNoise(30);
     style->innerShadow()->setEffectEnabled(true);
 
     test(style, "shadow");
 }
 
 void KisLayerStyleProjectionPlaneTest::testGlow()
 {
     KisPSDLayerStyleSP style(new KisPSDLayerStyle());
     style->outerGlow()->setSize(15);
     style->outerGlow()->setSpread(10);
     style->outerGlow()->setOpacity(70);
     style->outerGlow()->setNoise(30);
     style->outerGlow()->setEffectEnabled(true);
     style->outerGlow()->setColor(Qt::green);
 
     test(style, "glow_outer");
 }
 
 #include <resources/KoStopGradient.h>
 
 void KisLayerStyleProjectionPlaneTest::testGlowGradient()
 {
     KisPSDLayerStyleSP style(new KisPSDLayerStyle());
     style->outerGlow()->setSize(15);
     style->outerGlow()->setSpread(10);
     style->outerGlow()->setOpacity(70);
     style->outerGlow()->setNoise(10);
     style->outerGlow()->setEffectEnabled(true);
     style->outerGlow()->setColor(Qt::green);
 
     QLinearGradient testGradient;
     testGradient.setColorAt(0.0, Qt::white);
     testGradient.setColorAt(0.5, Qt::green);
     testGradient.setColorAt(1.0, Qt::black);
     testGradient.setSpread(QGradient::ReflectSpread);
     QSharedPointer<KoStopGradient> gradient(
         KoStopGradient::fromQGradient(&testGradient));
 
     style->outerGlow()->setGradient(gradient);
     style->outerGlow()->setFillType(psd_fill_gradient);
 
     test(style, "glow_outer_grad");
 }
 
 void KisLayerStyleProjectionPlaneTest::testGlowGradientJitter()
 {
     KisPSDLayerStyleSP style(new KisPSDLayerStyle());
     style->outerGlow()->setSize(15);
     style->outerGlow()->setSpread(10);
     style->outerGlow()->setOpacity(70);
     style->outerGlow()->setNoise(0);
     style->outerGlow()->setEffectEnabled(true);
     style->outerGlow()->setColor(Qt::green);
 
     QLinearGradient testGradient;
     testGradient.setColorAt(0.0, Qt::white);
     testGradient.setColorAt(0.5, Qt::green);
     testGradient.setColorAt(1.0, Qt::black);
     testGradient.setSpread(QGradient::ReflectSpread);
     QSharedPointer<KoStopGradient> gradient(
         KoStopGradient::fromQGradient(&testGradient));
 
     style->outerGlow()->setGradient(gradient);
     style->outerGlow()->setFillType(psd_fill_gradient);
     style->outerGlow()->setJitter(20);
 
     test(style, "glow_outer_grad_jit");
 }
 
 void KisLayerStyleProjectionPlaneTest::testGlowInnerGradient()
 {
     KisPSDLayerStyleSP style(new KisPSDLayerStyle());
     style->innerGlow()->setSize(15);
     style->innerGlow()->setSpread(10);
     style->innerGlow()->setOpacity(80);
     style->innerGlow()->setNoise(10);
     style->innerGlow()->setEffectEnabled(true);
     style->innerGlow()->setColor(Qt::white);
 
     QLinearGradient testGradient;
     testGradient.setColorAt(0.0, Qt::white);
     testGradient.setColorAt(0.5, Qt::green);
     testGradient.setColorAt(1.0, Qt::black);
     testGradient.setSpread(QGradient::ReflectSpread);
     QSharedPointer<KoStopGradient> gradient(
         KoStopGradient::fromQGradient(&testGradient));
 
     style->innerGlow()->setGradient(gradient);
     style->innerGlow()->setFillType(psd_fill_gradient);
 
     test(style, "glow_inner_grad");
 
     style->innerGlow()->setFillType(psd_fill_solid_color);
     style->innerGlow()->setSource(psd_glow_center);
     test(style, "glow_inner_grad_center");
 }
 
 #include <KoCompositeOpRegistry.h>
 
 
 void KisLayerStyleProjectionPlaneTest::testSatin()
 {
     KisPSDLayerStyleSP style(new KisPSDLayerStyle());
     style->satin()->setSize(15);
     style->satin()->setOpacity(80);
     style->satin()->setAngle(180);
     style->satin()->setEffectEnabled(true);
     style->satin()->setColor(Qt::white);
     style->satin()->setBlendMode(COMPOSITE_LINEAR_DODGE);
 
     test(style, "satin");
 }
 
 void KisLayerStyleProjectionPlaneTest::testColorOverlay()
 {
     KisPSDLayerStyleSP style(new KisPSDLayerStyle());
     style->colorOverlay()->setOpacity(80);
     style->colorOverlay()->setEffectEnabled(true);
     style->colorOverlay()->setColor(Qt::white);
     style->colorOverlay()->setBlendMode(COMPOSITE_LINEAR_DODGE);
 
     test(style, "color_overlay");
 }
 
 void KisLayerStyleProjectionPlaneTest::testGradientOverlay()
 {
     KisPSDLayerStyleSP style(new KisPSDLayerStyle());
     style->gradientOverlay()->setAngle(90);
     style->gradientOverlay()->setOpacity(80);
     style->gradientOverlay()->setEffectEnabled(true);
     style->gradientOverlay()->setBlendMode(COMPOSITE_LINEAR_DODGE);
     style->gradientOverlay()->setAlignWithLayer(true);
     style->gradientOverlay()->setScale(100);
     style->gradientOverlay()->setStyle(psd_gradient_style_diamond);
 
     QLinearGradient testGradient;
     testGradient.setColorAt(0.0, Qt::white);
     testGradient.setColorAt(0.5, Qt::green);
     testGradient.setColorAt(1.0, Qt::black);
     testGradient.setSpread(QGradient::ReflectSpread);
     QSharedPointer<KoStopGradient> gradient(
         KoStopGradient::fromQGradient(&testGradient));
 
     style->gradientOverlay()->setGradient(gradient);
 
     test(style, "grad_overlay");
 }
 
 void KisLayerStyleProjectionPlaneTest::testPatternOverlay()
 {
     KisPSDLayerStyleSP style(new KisPSDLayerStyle());
     style->patternOverlay()->setOpacity(80);
     style->patternOverlay()->setEffectEnabled(true);
     style->patternOverlay()->setBlendMode(COMPOSITE_LINEAR_DODGE);
     style->patternOverlay()->setScale(100);
 
     style->patternOverlay()->setAlignWithLayer(false);
 
     QString fileName(TestUtil::fetchDataFileLazy("pattern.pat"));
 
     KoPattern pattern(fileName);
     QVERIFY(pattern.load());
 
     style->patternOverlay()->setPattern(&pattern);
 
     test(style, "pat_overlay");
 }
 
 void KisLayerStyleProjectionPlaneTest::testStroke()
 {
     KisPSDLayerStyleSP style(new KisPSDLayerStyle());
     style->stroke()->setColor(Qt::blue);
     style->stroke()->setOpacity(80);
     style->stroke()->setEffectEnabled(true);
     style->stroke()->setBlendMode(COMPOSITE_OVER);
 
     style->stroke()->setSize(3);
     style->stroke()->setPosition(psd_stroke_center);
 
     test(style, "stroke_col_ctr");
 
     style->stroke()->setPosition(psd_stroke_outside);
 
     test(style, "stroke_col_out");
 
     style->stroke()->setPosition(psd_stroke_inside);
 
     test(style, "stroke_col_in");
 
 
     QString fileName(TestUtil::fetchDataFileLazy("pattern.pat"));
     KoPattern pattern(fileName);
     QVERIFY(pattern.load());
     style->stroke()->setPattern(&pattern);
     style->stroke()->setFillType(psd_fill_pattern);
 
     test(style, "stroke_pat");
 
 
     QLinearGradient testGradient;
     testGradient.setColorAt(0.0, Qt::white);
     testGradient.setColorAt(0.5, Qt::green);
     testGradient.setColorAt(1.0, Qt::black);
     testGradient.setSpread(QGradient::ReflectSpread);
     QSharedPointer<KoStopGradient> gradient(
         KoStopGradient::fromQGradient(&testGradient));
 
     style->stroke()->setGradient(gradient);
     style->stroke()->setFillType(psd_fill_gradient);
 
     test(style, "stroke_grad");
 
 }
 
 #include "layerstyles/gimp_bump_map.h"
 
 void KisLayerStyleProjectionPlaneTest::testBumpmap()
 {
     KisPixelSelectionSP device = new KisPixelSelection();
 
     const int numCycles = 30;
     const int step = 5;
 
     QRect applyRect(200, 100, 100, 100);
     QRect fillRect(210, 110, 80, 80);
     quint8 selectedness = 256 - numCycles * step;
 
 
     for (int i = 0; i < numCycles; i++) {
         device->select(fillRect, selectedness);
 
         fillRect = kisGrowRect(fillRect, -1);
         selectedness += step;
     }
 
     KIS_DUMP_DEVICE_2(device, applyRect, "00_initial", "bumpmap");
 
 
     bumpmap_vals_t bmvals;
 
     bmvals.azimuth = 240;
     bmvals.elevation = 30;
     bmvals.depth = 50;
     bmvals.ambient = 128;
     bmvals.compensate = false;
     bmvals.invert = false;
     bmvals.type = 0;
 
     bumpmap(device, applyRect, bmvals);
 
     KIS_DUMP_DEVICE_2(device, applyRect, "01_bumpmapped", "bumpmap");
 
 }
 
 void KisLayerStyleProjectionPlaneTest::testBevel()
 {
     KisPSDLayerStyleSP style(new KisPSDLayerStyle());
     style->bevelAndEmboss()->setEffectEnabled(true);
 
     style->bevelAndEmboss()->setAngle(135);
     style->bevelAndEmboss()->setAltitude(45);
     style->bevelAndEmboss()->setDepth(100);
 
     style->bevelAndEmboss()->setHighlightColor(Qt::white);
     style->bevelAndEmboss()->setHighlightBlendMode(COMPOSITE_OVER);
     style->bevelAndEmboss()->setHighlightOpacity(100);
 
     style->bevelAndEmboss()->setShadowColor(Qt::black);
     style->bevelAndEmboss()->setShadowBlendMode(COMPOSITE_OVER);
     style->bevelAndEmboss()->setShadowOpacity(100);
 
     QString fileName(TestUtil::fetchDataFileLazy("pattern.pat"));
     KoPattern pattern(fileName);
     QVERIFY(pattern.load());
 
     style->bevelAndEmboss()->setTexturePattern(&pattern);
 
     style->bevelAndEmboss()->setTextureEnabled(true);
     style->bevelAndEmboss()->setTextureDepth(-10);
     style->bevelAndEmboss()->setTextureInvert(false);
 
     style->bevelAndEmboss()->setStyle(psd_bevel_outer_bevel);
     style->bevelAndEmboss()->setDirection(psd_direction_up);
     style->bevelAndEmboss()->setSoften(0);
     test(style, "bevel_outer_up");
 
     style->bevelAndEmboss()->setTextureInvert(true);
     style->bevelAndEmboss()->setStyle(psd_bevel_outer_bevel);
     style->bevelAndEmboss()->setDirection(psd_direction_up);
     style->bevelAndEmboss()->setSoften(0);
     test(style, "bevel_outer_up_invert_texture");
     style->bevelAndEmboss()->setTextureInvert(false);
 
     style->bevelAndEmboss()->setStyle(psd_bevel_outer_bevel);
     style->bevelAndEmboss()->setDirection(psd_direction_down);
     style->bevelAndEmboss()->setSoften(0);
     test(style, "bevel_outer_down");
 
     style->bevelAndEmboss()->setStyle(psd_bevel_emboss);
     style->bevelAndEmboss()->setDirection(psd_direction_up);
     style->bevelAndEmboss()->setSoften(0);
     test(style, "bevel_emboss_up");
 
     style->bevelAndEmboss()->setStyle(psd_bevel_pillow_emboss);
     style->bevelAndEmboss()->setDirection(psd_direction_up);
     style->bevelAndEmboss()->setSoften(0);
     test(style, "bevel_pillow_up");
 
     style->bevelAndEmboss()->setStyle(psd_bevel_pillow_emboss);
     style->bevelAndEmboss()->setDirection(psd_direction_down);
     style->bevelAndEmboss()->setSoften(0);
     test(style, "bevel_pillow_down");
 
     style->bevelAndEmboss()->setStyle(psd_bevel_pillow_emboss);
     style->bevelAndEmboss()->setDirection(psd_direction_up);
     style->bevelAndEmboss()->setSoften(3);
     test(style, "bevel_pillow_up_soft");
 }
+
+#include "kis_ls_utils.h"
+
+void KisLayerStyleProjectionPlaneTest::testBlending()
+{
+    const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
+    KisPaintDeviceSP layer = new KisPaintDevice(cs);
+    KisPaintDeviceSP overlay = new KisPaintDevice(cs);
+    KisPaintDeviceSP bg = new KisPaintDevice(cs);
+    KisPaintDeviceSP result = new KisPaintDevice(cs);
+
+    const int width = 20;
+    KoColor color(Qt::transparent, cs);
+
+    QVector<QColor> layerColors;
+    QVector<QColor> overlayColors;
+    QVector<QColor> bgColors;
+
+    layerColors << QColor(0,   255, 0);
+    layerColors << QColor(128, 255, 64);
+
+    overlayColors << QColor(255,   0, 0);
+    overlayColors << QColor(255, 128, 64);
+
+    bgColors << QColor(0, 0, 0, 0);
+    bgColors << QColor(0, 0, 0, 255);
+    bgColors << QColor(255, 255, 255, 255);
+    bgColors << QColor(64, 128, 255, 255);
+
+    bgColors << QColor(0, 0, 0, 128);
+    bgColors << QColor(255, 255, 255, 128);
+    bgColors << QColor(64, 128, 255, 128);
+
+    const int overlayOpacity = 255;
+    const int layerOpacity = 255;
+    int y = 1;
+    Q_FOREACH(const QColor &layerColor, layerColors) {
+        Q_FOREACH(const QColor &overlayColor, overlayColors) {
+            Q_FOREACH(const QColor &bgColor, bgColors) {
+                bg->setPixel(0, y, layerColor);
+                bg->setPixel(1, y, overlayColor);
+                bg->setPixel(2, y, bgColor);
+                bg->setPixel(3, y, QColor(layerOpacity, layerOpacity, layerOpacity, 255));
+                bg->setPixel(4, y, QColor(overlayOpacity, overlayOpacity, overlayOpacity, 255));
+
+                for (int i = 5; i < width; i++) {
+                    bg->setPixel(i, y, bgColor);
+                }
+
+                for (int i = 0; i <= 10; i++) {
+                    const quint8 alpha = i == 0 ? 71 : qRound(255 * qreal(i) / 10);
+
+                    {
+                        QColor c(layerColor);
+                        c.setAlpha(alpha);
+                        layer->setPixel(7 + i, y, c);
+                    }
+
+                    {
+                        QColor c(overlayColor);
+                        c.setAlpha(alpha);
+                        overlay->setPixel(7 + i, y, c);
+                    }
+                }
+
+                y++;
+            }
+        }
+    }
+
+    const QRect rc = bg->exactBounds() | layer->exactBounds();
+
+
+    KIS_DUMP_DEVICE_2(layer, rc, "00_layer", "dd");
+    KIS_DUMP_DEVICE_2(overlay, rc, "01_overlay", "dd");
+    KIS_DUMP_DEVICE_2(bg, rc, "02_bg", "dd");
+
+    KisPaintDeviceSP originalBg = new KisPaintDevice(*bg);
+
+    KisSelectionSP selection = new KisSelection();
+    KisLsUtils::selectionFromAlphaChannel(layer, selection, rc);
+
+    {
+        KisSequentialIterator it(layer, rc);
+        while (it.nextPixel()) {
+            cs->setOpacity(it.rawData(), quint8(255), 1);
+        }
+    }
+
+    {
+        KisSequentialIterator it(overlay, rc);
+        while (it.nextPixel()) {
+            cs->setOpacity(it.rawData(), quint8(255), 1);
+        }
+    }
+
+    KisPainter painter(bg);
+
+    painter.setOpacity(layerOpacity);
+    painter.setCompositeOp(COMPOSITE_OVER);
+
+    painter.bitBlt(rc.topLeft(), layer, rc);
+
+    painter.setOpacity(overlayOpacity);
+    painter.setCompositeOp(COMPOSITE_ADD);
+
+    painter.bitBlt(rc.topLeft(), overlay, rc);
+
+    KIS_DUMP_DEVICE_2(bg, rc, "03_result", "dd");
+
+    KisPainter bgPainter(originalBg);
+    bgPainter.setCompositeOp(COMPOSITE_COPY);
+    bgPainter.setSelection(selection);
+    bgPainter.bitBlt(rc.topLeft(), bg, rc);
+
+    KIS_DUMP_DEVICE_2(originalBg, rc, "04_knockout", "dd");
+}
+
 QTEST_MAIN(KisLayerStyleProjectionPlaneTest)
diff --git a/libs/image/tests/kis_layer_style_projection_plane_test.h b/libs/image/tests/kis_layer_style_projection_plane_test.h
index ffbc4c5ad5..ab46f7cdd1 100644
--- a/libs/image/tests/kis_layer_style_projection_plane_test.h
+++ b/libs/image/tests/kis_layer_style_projection_plane_test.h
@@ -1,53 +1,55 @@
 /*
  *  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_LAYER_STYLE_PROJECTION_PLANE_TEST_H
 #define __KIS_LAYER_STYLE_PROJECTION_PLANE_TEST_H
 
 #include <QtTest/QtTest>
 
 #include "kis_types.h"
 
 #include <kis_psd_layer_style.h>
 
 class KisLayerStyleProjectionPlaneTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void testShadow();
     void testGlow();
     void testGlowGradient();
     void testGlowGradientJitter();
     void testGlowInnerGradient();
 
     void testSatin();
     void testColorOverlay();
     void testGradientOverlay();
     void testPatternOverlay();
 
     void testStroke();
 
     void testBumpmap();
 
     void testBevel();
 
+    void testBlending();
+
 private:
     void test(KisPSDLayerStyleSP style, const QString testName);
 };
 
 #endif /* __KIS_LAYER_STYLE_PROJECTION_PLANE_TEST_H */
diff --git a/libs/image/tests/kis_layer_styles_test.cpp b/libs/image/tests/kis_layer_styles_test.cpp
index 318984e647..c875ceaac8 100644
--- a/libs/image/tests/kis_layer_styles_test.cpp
+++ b/libs/image/tests/kis_layer_styles_test.cpp
@@ -1,279 +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_layer_styles_test.h"
 
 #include <QTest>
 
 #include "kis_transaction.h"
 #include "testutil.h"
 
 #include <KoColor.h>
 
 
 #include "layerstyles/kis_layer_style_filter.h"
 #include "layerstyles/kis_layer_style_filter_environment.h"
 #include "layerstyles/kis_ls_drop_shadow_filter.h"
 #include "kis_psd_layer_style.h"
 #include "layerstyles/kis_multiple_projection.h"
+#include "layerstyles/KisLayerStyleKnockoutBlower.h"
 
 
 struct TestConfig {
     TestConfig()
         : distance(0),
           angle(0),
           spread(0),
           size(0),
           noise(0),
           knocks_out(false),
           keep_original(false)
     {
     }
 
     int distance;
     int angle;
     int spread;
     int size;
     int noise;
     int knocks_out;
     int opacity;
     bool keep_original;
 
     void writeProperties(KisPSDLayerStyleSP style) const {
         style->context()->keep_original = keep_original;
 
         style->dropShadow()->setEffectEnabled(true);
         style->dropShadow()->setDistance(distance);
         style->dropShadow()->setSpread(spread);
         style->dropShadow()->setSize(size);
         style->dropShadow()->setNoise(noise);
         style->dropShadow()->setKnocksOut(knocks_out);
         style->dropShadow()->setOpacity(opacity);
     }
 
     QString genTestname(const QString &prefix) const {
         return QString("%1_d_%2_an_%3_sz_%4_spr_%5_nz_%6_ko_%7_keep_%8")
             .arg(prefix)
             .arg(distance)
             .arg(angle)
             .arg(size)
             .arg(spread)
             .arg(noise)
             .arg(knocks_out)
             .arg(keep_original);
     }
 };
 
 
 void testDropShadowImpl(const TestConfig &config,
                         const QVector<QRect> &applyRects,
                         const QString &testName,
                         bool useSeparateDevices)
 {
     Q_UNUSED(useSeparateDevices);
 
     const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
 
     QRect srcRect(50, 50, 100, 100);
     QRect dstRect(0, 0, 200, 200);
 
     KisPaintDeviceSP dev = new KisPaintDevice(cs);
     dev->fill(srcRect, KoColor(Qt::red, cs));
 
     KisMultipleProjection projection;
 
     KisLsDropShadowFilter lsFilter;
     KisPSDLayerStyleSP style(new KisPSDLayerStyle());
     config.writeProperties(style);
 
 
 
     TestUtil::MaskParent parent;
     KisLayerStyleFilterEnvironment env(parent.layer.data());
+    KisLayerStyleKnockoutBlower blower;
 
     Q_FOREACH (const QRect &rc, applyRects) {
-        lsFilter.processDirectly(dev, &projection, rc, style, &env);
+        lsFilter.processDirectly(dev, &projection, &blower, rc, style, &env);
     }
 
+    // drop shadow doesn't use global knockout
+    QVERIFY(blower.isEmpty());
+
 
     KisPaintDeviceSP dst = new KisPaintDevice(cs);
 
     projection.apply(dst, dstRect, &env);
 
     QImage resultImage =
         dst->convertToQImage(0, dstRect);
 
     TestUtil::checkQImage(resultImage,
                           "layer_styles_test",
                           "common",
                           config.genTestname(testName));
 }
 
 void KisLayerStylesTest::testLayerStylesFull()
 {
     TestConfig c;
     c.distance = 20;
     c.angle = 135;
     c.spread = 50;
     c.size = 10;
     c.noise = 30;
     c.knocks_out = false;
     c.opacity = 50;
     c.keep_original = false;
 
     testDropShadowImpl(c, QVector<QRect>() << QRect(0,0,200,200), "full", false);
 }
 
 void KisLayerStylesTest::testLayerStylesPartial()
 {
     QVector<QRect> rects;
 
     for (int y = 0; y < 200; y += 50) {
         for (int x = 0; x < 200; x += 50) {
             rects << QRect(x, y, 50, 50);
         }
     }
 
     TestConfig c;
     c.distance = 20;
     c.angle = 135;
     c.spread = 50;
     c.size = 10;
     c.noise = 30;
     c.knocks_out = false;
     c.opacity = 50;
     c.keep_original = false;
 
     testDropShadowImpl(c, rects, "partial", true);
 }
 
 void KisLayerStylesTest::testLayerStylesPartialVary()
 {
     QVector<QRect> rects;
 
     for (int y = 0; y < 200; y += 50) {
         for (int x = 0; x < 200; x += 50) {
             rects << QRect(x, y, 50, 50);
         }
     }
 
     TestConfig c;
     c.distance = 20;
     c.angle = 135;
     c.spread = 50;
     c.size = 10;
     c.noise = 30;
     c.knocks_out = false;
     c.opacity = 50;
     c.keep_original = true;
 
     testDropShadowImpl(c, rects, "partial", true);
 
     c.noise = 90;
     testDropShadowImpl(c, rects, "partial", true);
 
     c.noise = 0;
     testDropShadowImpl(c, rects, "partial", true);
 
     c.noise = 10;
     testDropShadowImpl(c, rects, "partial", true);
 
     c.angle = 90;
     testDropShadowImpl(c, rects, "partial", true);
 
     c.angle = 45;
     testDropShadowImpl(c, rects, "partial", true);
 
     c.knocks_out = true;
     testDropShadowImpl(c, rects, "partial", true);
 
     c.spread = 90;
     testDropShadowImpl(c, rects, "partial", true);
 
 
 }
 
 void testDropShadowNeedChangeRects(int distance,
                                    int noise,
                                    int size,
                                    int spread,
                                    const QRect &applyRect,
                                    const QRect &needRect,
                                    const QRect &changeRect)
 {
     TestConfig c;
     c.distance = distance;
     c.spread = spread;
     c.size = size;
     c.noise = noise;
     c.angle = 90;
     c.knocks_out = false;
     c.opacity = 50;
 
 
     KisLsDropShadowFilter lsFilter;
     KisPSDLayerStyleSP style(new KisPSDLayerStyle());
     c.writeProperties(style);
 
 
     TestUtil::MaskParent parent;
     KisLayerStyleFilterEnvironment env(parent.layer.data());
 
     QCOMPARE(lsFilter.neededRect(applyRect, style, &env), needRect);
     QCOMPARE(lsFilter.changedRect(applyRect, style, &env), changeRect);
 }
 
 void KisLayerStylesTest::testLayerStylesRects()
 {
     QRect applyRect;
     QRect needRect;
     QRect changeRect;
 
     applyRect = QRect(10,10,10,10);
     needRect = applyRect;
     changeRect = applyRect;
     testDropShadowNeedChangeRects(0, 0, 0, 0, applyRect, needRect, changeRect);
 
     applyRect = QRect(10,10,10,10);
     needRect = QRect(10,0,10,20);
     changeRect = QRect(10,10,10,20);
     testDropShadowNeedChangeRects(10, 0, 0, 0, applyRect, needRect, changeRect);
 
     applyRect = QRect(10,10,10,10);
     needRect = QRect(2,2,26,26);
     changeRect = QRect(2,2,26,26);
     testDropShadowNeedChangeRects(0, 30, 0, 0, applyRect, needRect, changeRect);
 
     applyRect = QRect(10,10,10,10);
     needRect = QRect(-2,-2,34,34);
     changeRect = QRect(-2,-2,34,34);
     testDropShadowNeedChangeRects(0, 0, 10, 0, applyRect, needRect, changeRect);
 
 
     applyRect = QRect(10,10,10,10);
     needRect = QRect(-2,-2,34,34);
     changeRect = QRect(-2,-2,34,34);
     testDropShadowNeedChangeRects(0, 0, 10, 50, applyRect, needRect, changeRect);
 
     applyRect = QRect(10,10,10,10);
     needRect = QRect(-2,-2,34,34);
     changeRect = QRect(-2,-2,34,34);
     testDropShadowNeedChangeRects(0, 0, 10, 75, applyRect, needRect, changeRect);
 }
 
 QTEST_MAIN(KisLayerStylesTest)
diff --git a/libs/pigment/KoCompositeOpRegistry.cpp b/libs/pigment/KoCompositeOpRegistry.cpp
index 6589bc6aa5..fc0806f2c4 100644
--- a/libs/pigment/KoCompositeOpRegistry.cpp
+++ b/libs/pigment/KoCompositeOpRegistry.cpp
@@ -1,268 +1,316 @@
 /*
  *  Copyright (c) 2005 Adrian Page <adrian@pagenet.plus.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; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #include "KoCompositeOpRegistry.h"
 
 #include <QGlobalStatic>
 #include <QList>
 
 #include <klocalizedstring.h>
 
 #include <KoID.h>
 #include "KoCompositeOp.h"
 #include "KoColorSpace.h"
 
+#include "kis_assert.h"
+
 Q_GLOBAL_STATIC(KoCompositeOpRegistry, registry)
 
 
 KoCompositeOpRegistry::KoCompositeOpRegistry()
 {
     m_categories
         << KoID("arithmetic", i18n("Arithmetic"))
         << KoID("binary"    , i18n("Binary"))
         << KoID("dark"      , i18n("Darken"))
         << KoID("light"     , i18n("Lighten"))
         << KoID("modulo"       , i18n("Modulo"))
         << KoID("negative"  , i18n("Negative"))
         << KoID("mix"       , i18n("Mix"))
         << KoID("misc"      , i18n("Misc"))
         << KoID("hsy"       , i18n("HSY"))
         << KoID("hsi"       , i18n("HSI"))
         << KoID("hsl"       , i18n("HSL"))
         << KoID("hsv"       , i18n("HSV"))
         << KoID("quadratic" , i18n("Quadratic"));
 
     m_map.insert(m_categories[0], KoID(COMPOSITE_ADD             , i18n("Addition")));
     m_map.insert(m_categories[0], KoID(COMPOSITE_SUBTRACT        , i18n("Subtract")));
     m_map.insert(m_categories[0], KoID(COMPOSITE_MULT            , i18n("Multiply")));
     m_map.insert(m_categories[0], KoID(COMPOSITE_DIVIDE          , i18n("Divide")));
     m_map.insert(m_categories[0], KoID(COMPOSITE_INVERSE_SUBTRACT, i18n("Inverse Subtract")));
     
     m_map.insert(m_categories[1], KoID(COMPOSITE_XOR             , i18n("XOR")));
     m_map.insert(m_categories[1], KoID(COMPOSITE_OR              , i18n("OR")));
     m_map.insert(m_categories[1], KoID(COMPOSITE_AND             , i18n("AND")));
     m_map.insert(m_categories[1], KoID(COMPOSITE_NAND            , i18n("NAND")));
     m_map.insert(m_categories[1], KoID(COMPOSITE_NOR             , i18n("NOR")));
     m_map.insert(m_categories[1], KoID(COMPOSITE_XNOR            , i18n("XNOR")));
     m_map.insert(m_categories[1], KoID(COMPOSITE_IMPLICATION     , i18n("IMPLICATION")));
     m_map.insert(m_categories[1], KoID(COMPOSITE_NOT_IMPLICATION , i18n("NOT IMPLICATION")));
     m_map.insert(m_categories[1], KoID(COMPOSITE_CONVERSE        , i18n("CONVERSE")));
     m_map.insert(m_categories[1], KoID(COMPOSITE_NOT_CONVERSE    , i18n("NOT CONVERSE")));
 
     m_map.insert(m_categories[2], KoID(COMPOSITE_BURN       , i18n("Burn")));
     m_map.insert(m_categories[2], KoID(COMPOSITE_LINEAR_BURN, i18n("Linear Burn")));
     m_map.insert(m_categories[2], KoID(COMPOSITE_DARKEN     , i18n("Darken")));
     m_map.insert(m_categories[2], KoID(COMPOSITE_GAMMA_DARK , i18n("Gamma Dark")));
     m_map.insert(m_categories[2], KoID(COMPOSITE_DARKER_COLOR     , i18n("Darker Color")));
     m_map.insert(m_categories[2], KoID(COMPOSITE_SHADE_IFS_ILLUSIONS, i18n("Shade (IFS Illusions)")));
     m_map.insert(m_categories[2], KoID(COMPOSITE_FOG_DARKEN_IFS_ILLUSIONS, i18n("Fog Darken (IFS Illusions)")));
     m_map.insert(m_categories[2], KoID(COMPOSITE_EASY_BURN       , i18n("Easy Burn")));
 
     m_map.insert(m_categories[3], KoID(COMPOSITE_DODGE       , i18n("Color Dodge")));
     m_map.insert(m_categories[3], KoID(COMPOSITE_LINEAR_DODGE, i18n("Linear Dodge")));
     m_map.insert(m_categories[3], KoID(COMPOSITE_LIGHTEN     , i18n("Lighten")));
     m_map.insert(m_categories[3], KoID(COMPOSITE_LINEAR_LIGHT, i18n("Linear Light")));
     m_map.insert(m_categories[3], KoID(COMPOSITE_SCREEN      , i18n("Screen")));
     m_map.insert(m_categories[3], KoID(COMPOSITE_PIN_LIGHT   , i18n("Pin Light")));
     m_map.insert(m_categories[3], KoID(COMPOSITE_VIVID_LIGHT , i18n("Vivid Light")));
     m_map.insert(m_categories[3], KoID(COMPOSITE_FLAT_LIGHT  , i18n("Flat Light")));
     m_map.insert(m_categories[3], KoID(COMPOSITE_HARD_LIGHT  , i18n("Hard Light")));
     m_map.insert(m_categories[3], KoID(COMPOSITE_SOFT_LIGHT_IFS_ILLUSIONS, i18n("Soft Light (IFS Illusions)")));
     m_map.insert(m_categories[3], KoID(COMPOSITE_SOFT_LIGHT_PEGTOP_DELPHI, i18n("Soft Light (Pegtop-Delphi)")));
     m_map.insert(m_categories[3], KoID(COMPOSITE_SOFT_LIGHT_PHOTOSHOP, i18n("Soft Light (Photoshop)")));
     m_map.insert(m_categories[3], KoID(COMPOSITE_SOFT_LIGHT_SVG, i18n("Soft Light (SVG)")));
     m_map.insert(m_categories[3], KoID(COMPOSITE_GAMMA_LIGHT , i18n("Gamma Light")));
     m_map.insert(m_categories[3], KoID(COMPOSITE_GAMMA_ILLUMINATION , i18n("Gamma Illumination")));
     m_map.insert(m_categories[3], KoID(COMPOSITE_LIGHTER_COLOR     , i18n("Lighter Color")));
     m_map.insert(m_categories[3], KoID(COMPOSITE_PNORM_A           , i18n("P-Norm A")));
     m_map.insert(m_categories[3], KoID(COMPOSITE_PNORM_B           , i18n("P-Norm B")));
     m_map.insert(m_categories[3], KoID(COMPOSITE_SUPER_LIGHT     , i18n("Super Light")));
     m_map.insert(m_categories[3], KoID(COMPOSITE_TINT_IFS_ILLUSIONS, i18n("Tint (IFS Illusions)")));
     m_map.insert(m_categories[3], KoID(COMPOSITE_FOG_LIGHTEN_IFS_ILLUSIONS, i18n("Fog Lighten (IFS Illusions)")));
     m_map.insert(m_categories[3], KoID(COMPOSITE_EASY_DODGE       , i18n("Easy Dodge")));
     m_map.insert(m_categories[3], KoID(COMPOSITE_LUMINOSITY_SAI       , i18n("Luminosity/Shine (SAI)")));
     
     m_map.insert(m_categories[4], KoID(COMPOSITE_MOD              , i18n("Modulo")));
     m_map.insert(m_categories[4], KoID(COMPOSITE_MOD_CON          , i18n("Modulo - Continuous")));
     m_map.insert(m_categories[4], KoID(COMPOSITE_DIVISIVE_MOD     , i18n("Divisive Modulo")));
     m_map.insert(m_categories[4], KoID(COMPOSITE_DIVISIVE_MOD_CON , i18n("Divisive Modulo - Continuous")));
     m_map.insert(m_categories[4], KoID(COMPOSITE_MODULO_SHIFT     , i18n("Modulo Shift")));
     m_map.insert(m_categories[4], KoID(COMPOSITE_MODULO_SHIFT_CON , i18n("Modulo Shift - Continuous")));
 
     m_map.insert(m_categories[5], KoID(COMPOSITE_DIFF                 , i18n("Difference")));
     m_map.insert(m_categories[5], KoID(COMPOSITE_EQUIVALENCE          , i18n("Equivalence")));
     m_map.insert(m_categories[5], KoID(COMPOSITE_ADDITIVE_SUBTRACTIVE , i18n("Additive Subtractive")));
     m_map.insert(m_categories[5], KoID(COMPOSITE_EXCLUSION            , i18n("Exclusion")));
     m_map.insert(m_categories[5], KoID(COMPOSITE_ARC_TANGENT          , i18n("Arcus Tangent")));
     m_map.insert(m_categories[5], KoID(COMPOSITE_NEGATION             , i18n("Negation")));
 
     m_map.insert(m_categories[6], KoID(COMPOSITE_OVER            , i18n("Normal")));
     m_map.insert(m_categories[6], KoID(COMPOSITE_BEHIND          , i18n("Behind")));
     m_map.insert(m_categories[6], KoID(COMPOSITE_GREATER         , i18n("Greater")));
     m_map.insert(m_categories[6], KoID(COMPOSITE_OVERLAY         , i18n("Overlay")));
     m_map.insert(m_categories[6], KoID(COMPOSITE_ERASE           , i18n("Erase")));
     m_map.insert(m_categories[6], KoID(COMPOSITE_ALPHA_DARKEN    , i18n("Alpha Darken")));
     m_map.insert(m_categories[6], KoID(COMPOSITE_HARD_MIX        , i18n("Hard Mix")));
     m_map.insert(m_categories[6], KoID(COMPOSITE_HARD_MIX_PHOTOSHOP, i18n("Hard Mix (Photoshop)")));
     m_map.insert(m_categories[6], KoID(COMPOSITE_GRAIN_MERGE     , i18n("Grain Merge")));
     m_map.insert(m_categories[6], KoID(COMPOSITE_GRAIN_EXTRACT   , i18n("Grain Extract")));
     m_map.insert(m_categories[6], KoID(COMPOSITE_PARALLEL        , i18n("Parallel")));
     m_map.insert(m_categories[6], KoID(COMPOSITE_ALLANON         , i18n("Allanon")));
     m_map.insert(m_categories[6], KoID(COMPOSITE_GEOMETRIC_MEAN  , i18n("Geometric Mean")));
     m_map.insert(m_categories[6], KoID(COMPOSITE_DESTINATION_ATOP, i18n("Destination Atop")));
     m_map.insert(m_categories[6], KoID(COMPOSITE_DESTINATION_IN  , i18n("Destination In")));
     m_map.insert(m_categories[6], KoID(COMPOSITE_HARD_OVERLAY    , i18n("Hard Overlay")));
     m_map.insert(m_categories[6], KoID(COMPOSITE_INTERPOLATION   , i18n("Interpolation")));
     m_map.insert(m_categories[6], KoID(COMPOSITE_INTERPOLATIONB  , i18n("Interpolation - 2X")));
     m_map.insert(m_categories[6], KoID(COMPOSITE_PENUMBRAA       , i18n("Penumbra A")));
     m_map.insert(m_categories[6], KoID(COMPOSITE_PENUMBRAB       , i18n("Penumbra B")));
     m_map.insert(m_categories[6], KoID(COMPOSITE_PENUMBRAC       , i18n("Penumbra C")));
     m_map.insert(m_categories[6], KoID(COMPOSITE_PENUMBRAD       , i18n("Penumbra D")));
 
     m_map.insert(m_categories[7], KoID(COMPOSITE_BUMPMAP   , i18n("Bumpmap")));
     m_map.insert(m_categories[7], KoID(COMPOSITE_COMBINE_NORMAL, i18n("Combine Normal Map")));
     m_map.insert(m_categories[7], KoID(COMPOSITE_DISSOLVE  , i18n("Dissolve")));
     m_map.insert(m_categories[7], KoID(COMPOSITE_COPY_RED  , i18n("Copy Red")));
     m_map.insert(m_categories[7], KoID(COMPOSITE_COPY_GREEN, i18n("Copy Green")));
     m_map.insert(m_categories[7], KoID(COMPOSITE_COPY_BLUE , i18n("Copy Blue")));
     m_map.insert(m_categories[7], KoID(COMPOSITE_COPY      , i18n("Copy")));
     m_map.insert(m_categories[7], KoID(COMPOSITE_TANGENT_NORMALMAP, i18n("Tangent Normalmap")));
 
     m_map.insert(m_categories[8], KoID(COMPOSITE_COLOR         , i18n("Color")));
     m_map.insert(m_categories[8], KoID(COMPOSITE_HUE           , i18n("Hue")));
     m_map.insert(m_categories[8], KoID(COMPOSITE_SATURATION    , i18n("Saturation")));
     m_map.insert(m_categories[8], KoID(COMPOSITE_LUMINIZE      , i18n("Luminosity")));
     m_map.insert(m_categories[8], KoID(COMPOSITE_DEC_SATURATION, i18n("Decrease Saturation")));
     m_map.insert(m_categories[8], KoID(COMPOSITE_INC_SATURATION, i18n("Increase Saturation")));
     m_map.insert(m_categories[8], KoID(COMPOSITE_DEC_LUMINOSITY, i18n("Decrease Luminosity")));
     m_map.insert(m_categories[8], KoID(COMPOSITE_INC_LUMINOSITY, i18n("Increase Luminosity")));
 
     m_map.insert(m_categories[9], KoID(COMPOSITE_COLOR_HSI         , i18n("Color HSI")));
     m_map.insert(m_categories[9], KoID(COMPOSITE_HUE_HSI           , i18n("Hue HSI")));
     m_map.insert(m_categories[9], KoID(COMPOSITE_SATURATION_HSI    , i18n("Saturation HSI")));
     m_map.insert(m_categories[9], KoID(COMPOSITE_INTENSITY         , i18n("Intensity")));
     m_map.insert(m_categories[9], KoID(COMPOSITE_DEC_SATURATION_HSI, i18n("Decrease Saturation HSI")));
     m_map.insert(m_categories[9], KoID(COMPOSITE_INC_SATURATION_HSI, i18n("Increase Saturation HSI")));
     m_map.insert(m_categories[9], KoID(COMPOSITE_DEC_INTENSITY     , i18n("Decrease Intensity")));
     m_map.insert(m_categories[9], KoID(COMPOSITE_INC_INTENSITY     , i18n("Increase Intensity")));
 
     m_map.insert(m_categories[10], KoID(COMPOSITE_COLOR_HSL         , i18n("Color HSL")));
     m_map.insert(m_categories[10], KoID(COMPOSITE_HUE_HSL           , i18n("Hue HSL")));
     m_map.insert(m_categories[10], KoID(COMPOSITE_SATURATION_HSL    , i18n("Saturation HSL")));
     m_map.insert(m_categories[10], KoID(COMPOSITE_LIGHTNESS         , i18n("Lightness")));
     m_map.insert(m_categories[10], KoID(COMPOSITE_DEC_SATURATION_HSL, i18n("Decrease Saturation HSL")));
     m_map.insert(m_categories[10], KoID(COMPOSITE_INC_SATURATION_HSL, i18n("Increase Saturation HSL")));
     m_map.insert(m_categories[10], KoID(COMPOSITE_DEC_LIGHTNESS     , i18n("Decrease Lightness")));
     m_map.insert(m_categories[10], KoID(COMPOSITE_INC_LIGHTNESS     , i18n("Increase Lightness")));
 
     m_map.insert(m_categories[11], KoID(COMPOSITE_COLOR_HSV         , i18n("Color HSV")));
     m_map.insert(m_categories[11], KoID(COMPOSITE_HUE_HSV           , i18n("Hue HSV")));
     m_map.insert(m_categories[11], KoID(COMPOSITE_SATURATION_HSV    , i18n("Saturation HSV")));
     m_map.insert(m_categories[11], KoID(COMPOSITE_VALUE             , i18nc("HSV Value", "Value")));
     m_map.insert(m_categories[11], KoID(COMPOSITE_DEC_SATURATION_HSV, i18n("Decrease Saturation HSV")));
     m_map.insert(m_categories[11], KoID(COMPOSITE_INC_SATURATION_HSV, i18n("Increase Saturation HSV")));
     m_map.insert(m_categories[11], KoID(COMPOSITE_DEC_VALUE         , i18n("Decrease Value")));
     m_map.insert(m_categories[11], KoID(COMPOSITE_INC_VALUE         , i18n("Increase Value")));
     
     m_map.insert(m_categories[12], KoID(COMPOSITE_REFLECT          , i18n("Reflect")));
     m_map.insert(m_categories[12], KoID(COMPOSITE_GLOW             , i18n("Glow")));
     m_map.insert(m_categories[12], KoID(COMPOSITE_FREEZE           , i18n("Freeze")));
     m_map.insert(m_categories[12], KoID(COMPOSITE_HEAT             , i18n("Heat")));
     m_map.insert(m_categories[12], KoID(COMPOSITE_GLEAT            , i18n("Glow-Heat")));
     m_map.insert(m_categories[12], KoID(COMPOSITE_HELOW            , i18n("Heat-Glow")));
     m_map.insert(m_categories[12], KoID(COMPOSITE_REEZE            , i18n("Reflect-Freeze")));
     m_map.insert(m_categories[12], KoID(COMPOSITE_FRECT            , i18n("Freeze-Reflect")));
     m_map.insert(m_categories[12], KoID(COMPOSITE_FHYRD            , i18n("Heat-Glow & Freeze-Reflect Hybrid")));
 }
 
 const KoCompositeOpRegistry& KoCompositeOpRegistry::instance()
 {
     return *registry;
 }
 
 KoID KoCompositeOpRegistry::getDefaultCompositeOp() const
 {
     return KoID(COMPOSITE_OVER, i18n("Normal"));
 }
 
 KoID KoCompositeOpRegistry::getKoID(const QString& compositeOpID) const
 {
     KoIDMap::const_iterator itr = std::find(m_map.begin(), m_map.end(), KoID(compositeOpID));
     return (itr != m_map.end()) ? *itr : KoID();
 }
 
 KoCompositeOpRegistry::KoIDMap KoCompositeOpRegistry::getCompositeOps() const
 {
     return m_map;
 }
 
+KoCompositeOpRegistry::KoIDMap KoCompositeOpRegistry::getLayerStylesCompositeOps() const
+{
+    QVector<QString> ids;
+
+    // not available via the blending modes list in Krita
+    // ids << COMPOSITE_PASS_THROUGH;
+
+    ids << COMPOSITE_OVER;
+    ids << COMPOSITE_DISSOLVE;
+    ids << COMPOSITE_DARKEN;
+    ids << COMPOSITE_MULT;
+    ids << COMPOSITE_BURN;
+    ids << COMPOSITE_LINEAR_BURN;
+    ids << COMPOSITE_DARKER_COLOR;
+    ids << COMPOSITE_LIGHTEN;
+    ids << COMPOSITE_SCREEN;
+    ids << COMPOSITE_DODGE;
+    ids << COMPOSITE_LINEAR_DODGE;
+    ids << COMPOSITE_LIGHTER_COLOR;
+    ids << COMPOSITE_OVERLAY;
+    ids << COMPOSITE_SOFT_LIGHT_PHOTOSHOP;
+    ids << COMPOSITE_HARD_LIGHT;
+    ids << COMPOSITE_VIVID_LIGHT;
+    ids << COMPOSITE_LINEAR_LIGHT;
+    ids << COMPOSITE_PIN_LIGHT;
+    ids << COMPOSITE_HARD_MIX_PHOTOSHOP;
+    ids << COMPOSITE_DIFF;
+    ids << COMPOSITE_EXCLUSION;
+    ids << COMPOSITE_SUBTRACT;
+    ids << COMPOSITE_DIVIDE;
+    ids << COMPOSITE_HUE;
+    ids << COMPOSITE_SATURATION;
+    ids << COMPOSITE_COLOR;
+    ids << COMPOSITE_LUMINIZE;
+
+    KoIDMap result;
+    Q_FOREACH (const QString &id, ids) {
+        KoIDMap::const_iterator iter = std::find(m_map.begin(), m_map.end(), KoID(id));
+        KIS_SAFE_ASSERT_RECOVER(iter != m_map.end()) { continue; }
+
+        result.insert(iter.key(), iter.value());
+    }
+
+    return result;
+}
+
 KoCompositeOpRegistry::KoIDList KoCompositeOpRegistry::getCategories() const
 {
     return m_categories;
 }
 
 KoCompositeOpRegistry::KoIDList KoCompositeOpRegistry::getCompositeOps(const KoID& category, const KoColorSpace* colorSpace) const
 {
     qint32                  num = m_map.count(category);
     KoIDMap::const_iterator beg = m_map.find(category);
     KoIDMap::const_iterator end = beg + num;
 
     KoIDList list;
     list.reserve(num);
 
     if(colorSpace) {
         for(; beg!=end; ++beg){
             if(colorSpace->hasCompositeOp(beg->id()))
                 list.push_back(*beg);
         }
     }
     else {
         for(; beg!=end; ++beg)
             list.push_back(*beg);
     }
 
     return list;
 }
 
 KoCompositeOpRegistry::KoIDList KoCompositeOpRegistry::getCompositeOps(const KoColorSpace* colorSpace) const
 {
     KoIDMap::const_iterator beg = m_map.begin();
     KoIDMap::const_iterator end = m_map.end();
 
     KoIDList list;
     list.reserve(m_map.size());
 
     if(colorSpace) {
         for(; beg!=end; ++beg){
             if(colorSpace->hasCompositeOp(beg->id()))
                 list.push_back(*beg);
         }
     }
     else {
         for(; beg!=end; ++beg)
             list.push_back(*beg);
     }
 
     return list;
 }
 
 bool KoCompositeOpRegistry::colorSpaceHasCompositeOp(const KoColorSpace* colorSpace, const KoID& compositeOp) const
 {
     return colorSpace ? colorSpace->hasCompositeOp(compositeOp.id()) : false;
 }
diff --git a/libs/pigment/KoCompositeOpRegistry.h b/libs/pigment/KoCompositeOpRegistry.h
index b71e61470f..6edae69baa 100644
--- a/libs/pigment/KoCompositeOpRegistry.h
+++ b/libs/pigment/KoCompositeOpRegistry.h
@@ -1,228 +1,229 @@
 /*
  * Copyright (c) 2005 Adrian Page <adrian@pagenet.plus.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 Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 #ifndef KOCOMPOSITEOPREGISTRY_H
 #define KOCOMPOSITEOPREGISTRY_H
 
 #include <QString>
 #include <QList>
 #include <QMultiMap>
 #include <QBitArray>
 
 #include "kritapigment_export.h"
 
 class KoColorSpace;
 #include <KoID.h>
 
 // TODO : convert this data blob into a modern design with an enum class.
 // This will reduce the need for runtime string comparisons.
 
 const QString COMPOSITE_OVER         = "normal";
 const QString COMPOSITE_ERASE        = "erase";
 const QString COMPOSITE_IN           = "in";
 const QString COMPOSITE_OUT          = "out";
 const QString COMPOSITE_ALPHA_DARKEN = "alphadarken";
 const QString COMPOSITE_DESTINATION_IN = "destination-in";
 const QString COMPOSITE_DESTINATION_ATOP = "destination-atop";
 
 const QString COMPOSITE_XOR                   = "xor";
 const QString COMPOSITE_OR                    = "or";
 const QString COMPOSITE_AND                   = "and";
 const QString COMPOSITE_NAND                  = "nand";
 const QString COMPOSITE_NOR                   = "nor";
 const QString COMPOSITE_XNOR                  = "xnor";
 const QString COMPOSITE_IMPLICATION           = "implication";
 const QString COMPOSITE_NOT_IMPLICATION       = "not_implication";
 const QString COMPOSITE_CONVERSE              = "converse";
 const QString COMPOSITE_NOT_CONVERSE          = "not_converse";
 
 const QString COMPOSITE_PLUS                  = "plus";
 const QString COMPOSITE_MINUS                 = "minus";
 const QString COMPOSITE_ADD                   = "add";
 const QString COMPOSITE_SUBTRACT              = "subtract";
 const QString COMPOSITE_INVERSE_SUBTRACT      = "inverse_subtract";
 const QString COMPOSITE_DIFF                  = "diff";
 const QString COMPOSITE_MULT                  = "multiply";
 const QString COMPOSITE_DIVIDE                = "divide";
 const QString COMPOSITE_ARC_TANGENT           = "arc_tangent";
 const QString COMPOSITE_GEOMETRIC_MEAN        = "geometric_mean";
 const QString COMPOSITE_ADDITIVE_SUBTRACTIVE  = "additive_subtractive";
 const QString COMPOSITE_NEGATION              = "negation";
 
 const QString COMPOSITE_MOD                = "modulo";
 const QString COMPOSITE_MOD_CON            = "modulo_continuous";
 const QString COMPOSITE_DIVISIVE_MOD       = "divisive_modulo";
 const QString COMPOSITE_DIVISIVE_MOD_CON   = "divisive_modulo_continuous";
 const QString COMPOSITE_MODULO_SHIFT       = "modulo_shift";
 const QString COMPOSITE_MODULO_SHIFT_CON   = "modulo_shift_continuous";
 
 const QString COMPOSITE_EQUIVALENCE   = "equivalence";
 const QString COMPOSITE_ALLANON       = "allanon";
 const QString COMPOSITE_PARALLEL      = "parallel";
 const QString COMPOSITE_GRAIN_MERGE   = "grain_merge";
 const QString COMPOSITE_GRAIN_EXTRACT = "grain_extract";
 const QString COMPOSITE_EXCLUSION     = "exclusion";
 const QString COMPOSITE_HARD_MIX      = "hard mix";
 const QString COMPOSITE_HARD_MIX_PHOTOSHOP = "hard_mix_photoshop";
 const QString COMPOSITE_OVERLAY       = "overlay";
 const QString COMPOSITE_BEHIND        = "behind";
 const QString COMPOSITE_GREATER       = "greater";
 const QString COMPOSITE_HARD_OVERLAY  = "hard overlay";
 const QString COMPOSITE_INTERPOLATION = "interpolation";
 const QString COMPOSITE_INTERPOLATIONB = "interpolation 2x";
 const QString COMPOSITE_PENUMBRAA     = "penumbra a";
 const QString COMPOSITE_PENUMBRAB     = "penumbra b";
 const QString COMPOSITE_PENUMBRAC     = "penumbra c";
 const QString COMPOSITE_PENUMBRAD     = "penumbra d";
 
 const QString COMPOSITE_DARKEN      = "darken";
 const QString COMPOSITE_BURN        = "burn";//this is also known as 'color burn'.
 const QString COMPOSITE_LINEAR_BURN = "linear_burn";
 const QString COMPOSITE_GAMMA_DARK  = "gamma_dark";
 const QString COMPOSITE_SHADE_IFS_ILLUSIONS = "shade_ifs_illusions";
 const QString COMPOSITE_FOG_DARKEN_IFS_ILLUSIONS = "fog_darken_ifs_illusions";
 const QString COMPOSITE_EASY_BURN        = "easy burn";
 
 const QString COMPOSITE_LIGHTEN      = "lighten";
 const QString COMPOSITE_DODGE        = "dodge";
 const QString COMPOSITE_LINEAR_DODGE = "linear_dodge";
 const QString COMPOSITE_SCREEN       = "screen";
 const QString COMPOSITE_HARD_LIGHT   = "hard_light";
 const QString COMPOSITE_SOFT_LIGHT_IFS_ILLUSIONS = "soft_light_ifs_illusions";
 const QString COMPOSITE_SOFT_LIGHT_PEGTOP_DELPHI = "soft_light_pegtop_delphi";
 const QString COMPOSITE_SOFT_LIGHT_PHOTOSHOP = "soft_light";
 const QString COMPOSITE_SOFT_LIGHT_SVG  = "soft_light_svg";
 const QString COMPOSITE_GAMMA_LIGHT  = "gamma_light";
 const QString COMPOSITE_GAMMA_ILLUMINATION  = "gamma_illumination";
 const QString COMPOSITE_VIVID_LIGHT  = "vivid_light";
 const QString COMPOSITE_FLAT_LIGHT   = "flat_light";
 const QString COMPOSITE_LINEAR_LIGHT = "linear light";
 const QString COMPOSITE_PIN_LIGHT    = "pin_light";
 const QString COMPOSITE_PNORM_A        = "pnorm_a";
 const QString COMPOSITE_PNORM_B        = "pnorm_b";
 const QString COMPOSITE_SUPER_LIGHT  = "super_light";
 const QString COMPOSITE_TINT_IFS_ILLUSIONS = "tint_ifs_illusions";
 const QString COMPOSITE_FOG_LIGHTEN_IFS_ILLUSIONS = "fog_lighten_ifs_illusions";
 const QString COMPOSITE_EASY_DODGE        = "easy dodge";
 const QString COMPOSITE_LUMINOSITY_SAI        = "luminosity_sai";
 
 
 const QString COMPOSITE_HUE            = "hue";
 const QString COMPOSITE_COLOR          = "color";
 const QString COMPOSITE_SATURATION     = "saturation";
 const QString COMPOSITE_INC_SATURATION = "inc_saturation";
 const QString COMPOSITE_DEC_SATURATION = "dec_saturation";
 const QString COMPOSITE_LUMINIZE       = "luminize";
 const QString COMPOSITE_INC_LUMINOSITY = "inc_luminosity";
 const QString COMPOSITE_DEC_LUMINOSITY = "dec_luminosity";
 
 const QString COMPOSITE_HUE_HSV            = "hue_hsv";
 const QString COMPOSITE_COLOR_HSV          = "color_hsv";
 const QString COMPOSITE_SATURATION_HSV     = "saturation_hsv";
 const QString COMPOSITE_INC_SATURATION_HSV = "inc_saturation_hsv";
 const QString COMPOSITE_DEC_SATURATION_HSV = "dec_saturation_hsv";
 const QString COMPOSITE_VALUE              = "value";
 const QString COMPOSITE_INC_VALUE          = "inc_value";
 const QString COMPOSITE_DEC_VALUE          = "dec_value";
 
 const QString COMPOSITE_HUE_HSL            = "hue_hsl";
 const QString COMPOSITE_COLOR_HSL          = "color_hsl";
 const QString COMPOSITE_SATURATION_HSL     = "saturation_hsl";
 const QString COMPOSITE_INC_SATURATION_HSL = "inc_saturation_hsl";
 const QString COMPOSITE_DEC_SATURATION_HSL = "dec_saturation_hsl";
 const QString COMPOSITE_LIGHTNESS          = "lightness";
 const QString COMPOSITE_INC_LIGHTNESS      = "inc_lightness";
 const QString COMPOSITE_DEC_LIGHTNESS      = "dec_lightness";
 
 const QString COMPOSITE_HUE_HSI            = "hue_hsi";
 const QString COMPOSITE_COLOR_HSI          = "color_hsi";
 const QString COMPOSITE_SATURATION_HSI     = "saturation_hsi";
 const QString COMPOSITE_INC_SATURATION_HSI = "inc_saturation_hsi";
 const QString COMPOSITE_DEC_SATURATION_HSI = "dec_saturation_hsi";
 const QString COMPOSITE_INTENSITY          = "intensity";
 const QString COMPOSITE_INC_INTENSITY      = "inc_intensity";
 const QString COMPOSITE_DEC_INTENSITY      = "dec_intensity";
 
 const QString COMPOSITE_COPY         = "copy";
 const QString COMPOSITE_COPY_RED     = "copy_red";
 const QString COMPOSITE_COPY_GREEN   = "copy_green";
 const QString COMPOSITE_COPY_BLUE    = "copy_blue";
 const QString COMPOSITE_TANGENT_NORMALMAP    = "tangent_normalmap";
 
 const QString COMPOSITE_COLORIZE     = "colorize";
 const QString COMPOSITE_BUMPMAP      = "bumpmap";
 const QString COMPOSITE_COMBINE_NORMAL = "combine_normal";
 const QString COMPOSITE_CLEAR        = "clear";
 const QString COMPOSITE_DISSOLVE     = "dissolve";
 const QString COMPOSITE_DISPLACE     = "displace";
 const QString COMPOSITE_NO           = "nocomposition";
 const QString COMPOSITE_PASS_THROUGH = "pass through"; // XXX: not implemented anywhere yet
 const QString COMPOSITE_DARKER_COLOR = "darker color";
 const QString COMPOSITE_LIGHTER_COLOR = "lighter color";
 const QString COMPOSITE_UNDEF        = "undefined";
 
 const QString COMPOSITE_REFLECT   = "reflect";
 const QString COMPOSITE_GLOW      = "glow";
 const QString COMPOSITE_FREEZE    = "freeze";
 const QString COMPOSITE_HEAT      = "heat";
 const QString COMPOSITE_GLEAT     = "glow_heat";
 const QString COMPOSITE_HELOW     = "heat_glow";
 const QString COMPOSITE_REEZE     = "reflect_freeze";
 const QString COMPOSITE_FRECT     = "freeze_reflect";
 const QString COMPOSITE_FHYRD     = "heat_glow_freeze_reflect_hybrid";
 
 
 
 class KRITAPIGMENT_EXPORT KoCompositeOpRegistry
 {
     typedef QMultiMap<KoID,KoID> KoIDMap;
     typedef QList<KoID>          KoIDList;
 
 public:
     KoCompositeOpRegistry();
     static const KoCompositeOpRegistry& instance();
 
     KoID     getDefaultCompositeOp() const;
     KoID     getKoID(const QString& compositeOpID) const;
     KoIDMap  getCompositeOps() const;
+    KoIDMap  getLayerStylesCompositeOps() const;
     KoIDList getCategories() const;
     KoIDList getCompositeOps(const KoColorSpace* colorSpace) const;
     KoIDList getCompositeOps(const KoID& category, const KoColorSpace* colorSpace=0) const;
     bool     colorSpaceHasCompositeOp(const KoColorSpace* colorSpace, const KoID& compositeOp) const;
 
     template<class TKoIdIterator>
     KoIDList filterCompositeOps(TKoIdIterator begin, TKoIdIterator end, const KoColorSpace* colorSpace, bool removeInvaliOps=true) const {
         KoIDList list;
 
         for(; begin!=end; ++begin){
             if (colorSpaceHasCompositeOp(colorSpace, *begin) == removeInvaliOps) {
                 list.push_back(*begin);
             }
         }
 
         return list;
     }
 
 private:
     KoIDList m_categories;
     KoIDMap  m_map;
 };
 
 
 #endif // KOCOMPOSITEOPREGISTRY_H
diff --git a/libs/psd/psd.h b/libs/psd/psd.h
index de131447f8..acb2b937e2 100644
--- a/libs/psd/psd.h
+++ b/libs/psd/psd.h
@@ -1,1168 +1,1169 @@
 /*
  *  Copyright (c) 2010 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 /*
  * Constants and defines taken from gimp and psdparse
  */
 #ifndef PSD_H
 #define PSD_H
 
 #include <QPair>
 #include <QString>
 #include <QColor>
 #include <QVector>
 
 #include <KoColorModelStandardIds.h>
 #include <KoCompositeOpRegistry.h>
 #include <resources/KoAbstractGradient.h>
 
 #include "kritapsd_export.h"
 
 class KoPattern;
 
 const int MAX_CHANNELS = 56;
 
 typedef qint32  Fixed;                  /* Represents a fixed point implied decimal */
 
 /**
  * Image color/depth modes
  */
 enum psd_color_mode {
     Bitmap = 0,
     Grayscale=1,
     Indexed=2,
     RGB=3,
     CMYK=4,
     MultiChannel=7,
     DuoTone=8,
     Lab=9,
     Gray16,
     RGB48,
     Lab48,
     CMYK64,
     DeepMultichannel,
     Duotone16,
     COLORMODE_UNKNOWN = 9000
  };
 
 
 /**
  * Color samplers, apparently distict from PSDColormode
  */
 namespace psd_color_sampler {
 enum PSDColorSamplers {
     RGB,
     HSB,
     CMYK,
     PANTONE, // LAB
     FOCOLTONE, // CMYK
     TRUMATCH, // CMYK
     TOYO, // LAB
     LAB,
     GRAYSCALE,
     HKS, // CMYK
     DIC, // LAB
     TOTAL_INK,
     MONITOR_RGB,
     DUOTONE,
     OPACITY,
     ANPA      = 3000 // LAB
 };
 }
 
 // EFFECTS
 enum psd_gradient_style {
     psd_gradient_style_linear,				// 'Lnr '
     psd_gradient_style_radial,				// 'Rdl '
     psd_gradient_style_angle,				// 'Angl'
     psd_gradient_style_reflected,			// 'Rflc'
     psd_gradient_style_diamond				// 'Dmnd'
 };
 
 enum psd_color_stop_type {
     psd_color_stop_type_foreground_color,	// 'FrgC'
     psd_color_stop_type_background_Color,	// 'BckC'
     psd_color_stop_type_user_stop			// 'UsrS'
 };
 
 enum psd_technique_type {
     psd_technique_softer,
     psd_technique_precise,
     psd_technique_slope_limit,
 };
 
 enum psd_stroke_position {
     psd_stroke_outside,
     psd_stroke_inside,
     psd_stroke_center
 };
 
 enum psd_fill_type {
     psd_fill_solid_color,
     psd_fill_gradient,
     psd_fill_pattern,
 };
 
 enum psd_glow_source {
     psd_glow_center,
     psd_glow_edge,
 };
 
 enum psd_bevel_style {
     psd_bevel_outer_bevel,
     psd_bevel_inner_bevel,
     psd_bevel_emboss,
     psd_bevel_pillow_emboss,
     psd_bevel_stroke_emboss,
 };
 
 enum psd_direction {
     psd_direction_up,
     psd_direction_down
 };
 
 enum psd_section_type {
     psd_other = 0,
     psd_open_folder,
     psd_closed_folder,
     psd_bounding_divider
 };
 
 
 
 // GRADIENT MAP
 // Each color stop
 struct psd_gradient_color_stop
 {
     qint32 location; // Location of color stop
     qint32 midpoint; // Midpoint of color stop
     QColor actual_color;
     psd_color_stop_type color_stop_type;
 };
 
 // Each transparency stop
 struct psd_gradient_transparency_stop
 {
     qint32 location; // Location of transparency stop
     qint32 midpoint; // Midpoint of transparency stop
     qint8 opacity; // Opacity of transparency stop
 };
 
 // Gradient settings (Photoshop 6.0)
 struct psd_layer_gradient_map
 {
     bool reverse; // Is gradient reverse
     bool dithered; // Is gradient dithered
     qint32 name_length;
     quint16 *name; // Name of the gradient: Unicode string, padded
     qint8 number_color_stops; // Number of color stops to follow
     psd_gradient_color_stop * color_stop;
     qint8 number_transparency_stops;// Number of transparency stops to follow
     psd_gradient_transparency_stop * transparency_stop;
     qint8 expansion_count; // Expansion count ( = 2 for Photoshop 6.0)
     qint8 interpolation; // Interpolation if length above is non-zero
     qint8 length; // Length (= 32 for Photoshop 6.0)
     qint8 mode; // Mode for this gradient
     qint32 random_number_seed; // Random number seed
     qint8 showing_transparency_flag;// Flag for showing transparency
     qint8 using_vector_color_flag;// Flag for using vector color
     qint32 roughness_factor; // Roughness factor
     QColor min_color;
     QColor max_color;
     QColor lookup_table[256];
 };
 
 
 struct psd_gradient_color {
     qint32 smoothness;
     qint32 name_length;
     quint16 * name; // Name of the gradient: Unicode string, padded
     qint8 number_color_stops; // Number of color stops to follow
     psd_gradient_color_stop * color_stop;
     qint8 number_transparency_stops;// Number of transparency stops to follow
     psd_gradient_transparency_stop *transparency_stop;
 };
 
 struct psd_pattern {
 
     psd_color_mode color_mode = Bitmap; // The image mode of the file.
     quint8 height = 0; // Point: vertical, 2 bytes and horizontal, 2 bytes
     quint8 width = 0;
     QString name;
     QString uuid;
     qint32 version = 0;
     quint8 top = 0; // Rectangle: top, left, bottom, right
     quint8 left = 0;
     quint8 bottom = 0;
     quint8 right = 0;
     qint32 max_channel = 0; // Max channels
     qint32 channel_number = 0;
     QVector<QRgb> color_table;
 };
 
 struct psd_layer_effects_context {
     psd_layer_effects_context()
         : keep_original(false)
     {
     }
 
     bool keep_original;
 };
 
 #define PSD_LOOKUP_TABLE_SIZE 256
 
 // dsdw, isdw: http://www.adobe.com/devnet-apps/photoshop/fileformatashtml/PhotoshopFileFormats.htm#50577409_22203
 class KRITAPSD_EXPORT psd_layer_effects_shadow_base {
 public:
     psd_layer_effects_shadow_base()
         : m_invertsSelection(false)
         , m_edgeHidden(true)
         , m_effectEnabled(false)
         , m_blendMode(COMPOSITE_MULT)
         , m_color(Qt::black)
         , m_nativeColor(Qt::black)
         , m_opacity(75)
         , m_angle(120)
         , m_useGlobalLight(true)
         , m_distance(21)
         , m_spread(0)
         , m_size(21)
         , m_antiAliased(0)
         , m_noise(0)
         , m_knocksOut(false)
         , m_fillType(psd_fill_solid_color)
         , m_technique(psd_technique_softer)
         , m_range(100)
         , m_jitter(0)
         , m_gradient(0)
     {
         for(int i = 0; i < PSD_LOOKUP_TABLE_SIZE; ++i) {
             m_contourLookupTable[i] = i;
         }
     }
 
     virtual ~psd_layer_effects_shadow_base() {
     }
 
     QPoint calculateOffset(const psd_layer_effects_context *context) const;
 
     void setEffectEnabled(bool value) {
         m_effectEnabled = value;
     }
 
     bool effectEnabled() const {
         return m_effectEnabled;
     }
 
     QString blendMode() const {
         return m_blendMode;
     }
 
     QColor color() const {
         return m_color;
     }
 
     QColor nativeColor() const {
         return m_nativeColor;
     }
 
     qint32 opacity() const {
         return m_opacity;
     }
 
     qint32 angle() const {
         return m_angle;
     }
 
     bool useGlobalLight() const {
         return m_useGlobalLight;
     }
 
     qint32 distance() const {
         return m_distance;
     }
 
     qint32 spread() const {
         return m_spread;
     }
 
     qint32 size() const {
         return m_size;
     }
 
     const quint8* contourLookupTable() const {
         return m_contourLookupTable;
     }
 
     bool antiAliased() const {
         return m_antiAliased;
     }
 
     qint32 noise() const {
         return m_noise;
     }
 
     bool knocksOut() const {
         return m_knocksOut;
     }
 
     bool invertsSelection() const {
         return m_invertsSelection;
     }
 
     bool edgeHidden() const {
         return m_edgeHidden;
     }
 
     psd_fill_type fillType() const {
         return m_fillType;
     }
 
     psd_technique_type technique() const {
         return m_technique;
     }
 
     qint32 range() const {
         return m_range;
     }
 
     qint32 jitter() const {
         return m_jitter;
     }
 
     KoAbstractGradientSP gradient() const {
         return m_gradient;
     }
 
 public:
 
     void setBlendMode(QString value) {
         m_blendMode = value;
     }
 
     void setColor(QColor value) {
         m_color = value;
     }
 
     void setNativeColor(QColor value) {
         m_nativeColor = value;
     }
 
     void setOpacity(qint32 value) {
         m_opacity = value;
     }
 
     void setAngle(qint32 value) {
         m_angle = value;
     }
 
     void setUseGlobalLight(bool value) {
         m_useGlobalLight = value;
     }
 
     void setDistance(qint32 value) {
         m_distance = value;
     }
 
     void setSpread(qint32 value) {
         m_spread = value;
     }
 
     void setSize(qint32 value) {
         m_size = value;
     }
 
     void setContourLookupTable(const quint8* value) {
         memcpy(m_contourLookupTable, value, PSD_LOOKUP_TABLE_SIZE * sizeof(quint8));
     }
 
     void setAntiAliased(bool value) {
         m_antiAliased = value;
     }
 
     void setNoise(qint32 value) {
         m_noise = value;
     }
 
     void setKnocksOut(bool value) {
         m_knocksOut = value;
     }
 
     void setInvertsSelection(bool value) {
         m_invertsSelection = value;
     }
 
     void setEdgeHidden(bool value) {
         m_edgeHidden = value;
     }
 
     void setFillType(psd_fill_type value) {
         m_fillType = value;
     }
 
     void setTechnique(psd_technique_type value) {
         m_technique = value;
     }
 
     void setRange(qint32 value) {
         m_range = value;
     }
 
     void setJitter(qint32 value) {
         m_jitter = value;
     }
 
     void setGradient(KoAbstractGradientSP value) {
         m_gradient = value;
     }
 
     virtual void scaleLinearSizes(qreal scale) {
         m_distance *= scale;
         m_size *= scale;
     }
 
 private:
     // internal
     bool m_invertsSelection;
     bool m_edgeHidden;
 
 private:
 
     bool m_effectEnabled; // Effect enabled
 
     QString m_blendMode; // already in Krita format!
     QColor m_color;
     QColor m_nativeColor;
     qint32 m_opacity; // Opacity as a percent (0...100)
     qint32 m_angle; // Angle in degrees
     bool m_useGlobalLight; // Use this angle in all of the layer effects
     qint32 m_distance; // Distance in pixels
     qint32 m_spread; // Intensity as a percent
     qint32 m_size; // Blur value in pixels
 
     quint8 m_contourLookupTable[PSD_LOOKUP_TABLE_SIZE];
     bool m_antiAliased;
     qint32 m_noise;
     bool m_knocksOut;
 
     // for Outer/Inner Glow
     psd_fill_type m_fillType;
     psd_technique_type m_technique;
     qint32 m_range;
     qint32 m_jitter;
     KoAbstractGradientSP m_gradient;
 };
 
 class KRITAPSD_EXPORT psd_layer_effects_shadow_common : public psd_layer_effects_shadow_base
 {
 public:
     /// FIXME: 'using' is not supported by MSVC, so please refactor in
     ///        some other way to ensure that the setters are not used
     ///        in the classes we don't want
 
     // using psd_layer_effects_shadow_base::setBlendMode;
     // using psd_layer_effects_shadow_base::setColor;
     // using psd_layer_effects_shadow_base::setOpacity;
     // using psd_layer_effects_shadow_base::setAngle;
     // using psd_layer_effects_shadow_base::setUseGlobalLight;
     // using psd_layer_effects_shadow_base::setDistance;
     // using psd_layer_effects_shadow_base::setSpread;
     // using psd_layer_effects_shadow_base::setSize;
     // using psd_layer_effects_shadow_base::setContourLookupTable;
     // using psd_layer_effects_shadow_base::setAntiAliased;
     // using psd_layer_effects_shadow_base::setNoise;
 };
 
 class KRITAPSD_EXPORT psd_layer_effects_drop_shadow : public psd_layer_effects_shadow_common
 {
 public:
     /// FIXME: 'using' is not supported by MSVC, so please refactor in
     ///        some other way to ensure that the setters are not used
     ///        in the classes we don't want
 
     //using psd_layer_effects_shadow_base::setKnocksOut;
 };
 
 // isdw: http://www.adobe.com/devnet-apps/photoshop/fileformatashtml/PhotoshopFileFormats.htm#50577409_22203
 class KRITAPSD_EXPORT psd_layer_effects_inner_shadow : public psd_layer_effects_shadow_common
 {
 public:
     psd_layer_effects_inner_shadow() {
-        setKnocksOut(true);
+        setKnocksOut(false);
         setInvertsSelection(true);
         setEdgeHidden(false);
     }
 };
 
 class KRITAPSD_EXPORT psd_layer_effects_glow_common : public psd_layer_effects_shadow_base
 {
 public:
     psd_layer_effects_glow_common() {
         setKnocksOut(true);
         setDistance(0);
         setBlendMode(COMPOSITE_LINEAR_DODGE);
         setColor(Qt::white);
     }
 
     /// FIXME: 'using' is not supported by MSVC, so please refactor in
     ///        some other way to ensure that the setters are not used
     ///        in the classes we don't want
 
     // using psd_layer_effects_shadow_base::setBlendMode;
     // using psd_layer_effects_shadow_base::setColor;
     // using psd_layer_effects_shadow_base::setOpacity;
 
     // using psd_layer_effects_shadow_base::setSpread;
     // using psd_layer_effects_shadow_base::setSize;
     // using psd_layer_effects_shadow_base::setContourLookupTable;
     // using psd_layer_effects_shadow_base::setAntiAliased;
     // using psd_layer_effects_shadow_base::setNoise;
 
     // using psd_layer_effects_shadow_base::setFillType;
     // using psd_layer_effects_shadow_base::setTechnique;
     // using psd_layer_effects_shadow_base::setRange;
     // using psd_layer_effects_shadow_base::setJitter;
     // using psd_layer_effects_shadow_base::setGradient;
 };
 
 // oglw: http://www.adobe.com/devnet-apps/photoshop/fileformatashtml/PhotoshopFileFormats.htm#50577409_25738
 class KRITAPSD_EXPORT psd_layer_effects_outer_glow : public psd_layer_effects_glow_common
 {
 };
 
 // iglw: http://www.adobe.com/devnet-apps/photoshop/fileformatashtml/PhotoshopFileFormats.htm#50577409_27692
 class KRITAPSD_EXPORT psd_layer_effects_inner_glow : public psd_layer_effects_glow_common
 {
 public:
     psd_layer_effects_inner_glow()
         : m_source(psd_glow_edge) {
         setInvertsSelection(true);
         setEdgeHidden(false);
+        setKnocksOut(false);
     }
 
     psd_glow_source source() const {
         return m_source;
     }
     void setSource(psd_glow_source value) {
         m_source = value;
     }
 
 private:
     psd_glow_source m_source;
 };
 
 struct psd_layer_effects_satin : public psd_layer_effects_shadow_base
 {
     psd_layer_effects_satin() {
         setInvert(false);
         setUseGlobalLight(false);
         setDistance(8);
         setSize(7);
         setSpread(0);
         setKnocksOut(true);
         setEdgeHidden(false);
         setBlendMode(COMPOSITE_LINEAR_BURN);
     }
 
     /// FIXME: 'using' is not supported by MSVC, so please refactor in
     ///        some other way to ensure that the setters are not used
     ///        in the classes we don't want
 
     // using psd_layer_effects_shadow_base::setBlendMode;
     // using psd_layer_effects_shadow_base::setColor;
     // using psd_layer_effects_shadow_base::setOpacity;
 
     // // NOTE: no global light setting explicitly!
     // using psd_layer_effects_shadow_base::setAngle;
     // using psd_layer_effects_shadow_base::setDistance;
 
     // using psd_layer_effects_shadow_base::setSize;
 
     // using psd_layer_effects_shadow_base::setContourLookupTable;
     // using psd_layer_effects_shadow_base::setAntiAliased;
 
     bool invert() const {
         return m_invert;
     }
 
     void setInvert(bool value) {
         m_invert = value;
     }
 
 private:
     bool m_invert;
 };
 
 struct psd_pattern_info {
     qint32 name_length;
     quint16 * name;
     quint8 identifier[256];
 };
 
 // bevl: http://www.adobe.com/devnet-apps/photoshop/fileformatashtml/PhotoshopFileFormats.htm#50577409_31889
 struct psd_layer_effects_bevel_emboss : public psd_layer_effects_shadow_base
 {
     psd_layer_effects_bevel_emboss()
         : m_style(psd_bevel_inner_bevel),
           m_technique(psd_technique_softer),
           m_depth(100),
           m_direction(psd_direction_up),
           m_soften(0),
 
           m_altitude(30),
 
           m_glossAntiAliased(false),
 
           m_highlightBlendMode(COMPOSITE_SCREEN),
           m_highlightColor(Qt::white),
           m_highlightOpacity(75),
 
           m_shadowBlendMode(COMPOSITE_MULT),
           m_shadowColor(Qt::black),
           m_shadowOpacity(75),
 
           m_contourEnabled(false),
           m_contourRange(100),
 
           m_textureEnabled(false),
           m_texturePattern(0),
           m_textureScale(100),
           m_textureDepth(100),
           m_textureInvert(false),
 
           m_textureAlignWithLayer(true),
           m_textureHorizontalPhase(0),
           m_textureVerticalPhase(0)
     {
         for(int i = 0; i < PSD_LOOKUP_TABLE_SIZE; ++i) {
             m_glossContourLookupTable[i] = i;
         }
     }
 
     /// FIXME: 'using' is not supported by MSVC, so please refactor in
     ///        some other way to ensure that the setters are not used
     ///        in the classes we don't want
 
     // using psd_layer_effects_shadow_base::setSize;
 
     // using psd_layer_effects_shadow_base::setAngle;
     // using psd_layer_effects_shadow_base::setUseGlobalLight;
 
     // using psd_layer_effects_shadow_base::setContourLookupTable;
     // using psd_layer_effects_shadow_base::setAntiAliased;
 
     psd_bevel_style style() const {
         return m_style;
     }
     void setStyle(psd_bevel_style value) {
         m_style = value;
     }
 
     psd_technique_type technique() const {
         return m_technique;
     }
     void setTechnique(psd_technique_type value) {
         m_technique = value;
     }
 
     int depth() const {
         return m_depth;
     }
     void setDepth(int value) {
         m_depth = value;
     }
 
     psd_direction direction() const {
         return m_direction;
     }
     void setDirection(psd_direction value) {
         m_direction = value;
     }
 
     int soften() const {
         return m_soften;
     }
     void setSoften(int value) {
         m_soften = value;
     }
 
 
     int altitude() const {
         return m_altitude;
     }
     void setAltitude(int value) {
         m_altitude = value;
     }
 
 
     const quint8* glossContourLookupTable() const {
         return m_glossContourLookupTable;
     }
 
     void setGlossContourLookupTable(const quint8 *value) {
         memcpy(m_glossContourLookupTable, value, PSD_LOOKUP_TABLE_SIZE * sizeof(quint8));
     }
 
     bool glossAntiAliased() const {
         return m_glossAntiAliased;
     }
     void setGlossAntiAliased(bool value) {
         m_glossAntiAliased = value;
     }
 
 
     QString highlightBlendMode() const {
         return m_highlightBlendMode;
     }
     void setHighlightBlendMode(QString value) {
         m_highlightBlendMode = value;
     }
 
     QColor highlightColor() const {
         return m_highlightColor;
     }
     void setHighlightColor(QColor value) {
         m_highlightColor = value;
     }
 
     qint32 highlightOpacity() const {
         return m_highlightOpacity;
     }
     void setHighlightOpacity(qint32 value) {
         m_highlightOpacity = value;
     }
 
 
     QString shadowBlendMode() const {
         return m_shadowBlendMode;
     }
     void setShadowBlendMode(QString value) {
         m_shadowBlendMode = value;
     }
 
     QColor shadowColor() const {
         return m_shadowColor;
     }
     void setShadowColor(QColor value) {
         m_shadowColor = value;
     }
 
     qint32 shadowOpacity() const {
         return m_shadowOpacity;
     }
     void setShadowOpacity(qint32 value) {
         m_shadowOpacity = value;
     }
 
 
     bool contourEnabled() const {
         return m_contourEnabled;
     }
     void setContourEnabled(bool value) {
         m_contourEnabled = value;
     }
 
     int contourRange() const {
         return m_contourRange;
     }
     void setContourRange(int value) {
         m_contourRange = value;
     }
 
 
     bool textureEnabled() const {
         return m_textureEnabled;
     }
     void setTextureEnabled(bool value) {
         m_textureEnabled = value;
     }
 
     KoPattern* texturePattern() const {
         return m_texturePattern;
     }
     void setTexturePattern(KoPattern *value) {
         m_texturePattern = value;
     }
 
     int textureScale() const {
         return m_textureScale;
     }
     void setTextureScale(int value) {
         m_textureScale = value;
     }
 
     int textureDepth() const {
         return m_textureDepth;
     }
     void setTextureDepth(int value) {
         m_textureDepth = value;
     }
 
     bool textureInvert() const {
         return m_textureInvert;
     }
     void setTextureInvert(bool value) {
         m_textureInvert = value;
     }
 
 
     bool textureAlignWithLayer() const {
         return m_textureAlignWithLayer;
     }
     void setTextureAlignWithLayer(bool value) {
         m_textureAlignWithLayer = value;
     }
 
     void setTexturePhase(const QPointF &phase) {
         m_textureHorizontalPhase = phase.x();
         m_textureVerticalPhase = phase.y();
     }
 
     QPointF texturePhase() const {
         return QPointF(m_textureHorizontalPhase, m_textureVerticalPhase);
     }
 
     int textureHorizontalPhase() const {
         return m_textureHorizontalPhase;
     }
     void setTextureHorizontalPhase(int value) {
         m_textureHorizontalPhase = value;
     }
 
     int textureVerticalPhase() const {
         return m_textureVerticalPhase;
     }
     void setTextureVerticalPhase(int value) {
         m_textureVerticalPhase = value;
     }
 
     void scaleLinearSizes(qreal scale) override {
         psd_layer_effects_shadow_base::scaleLinearSizes(scale);
         m_soften *= scale;
         m_textureScale *= scale;
     }
 
 private:
     psd_bevel_style m_style;
     psd_technique_type m_technique;
     int m_depth;
     psd_direction m_direction; // Up or down
     int m_soften; // Blur value in pixels.
 
     int m_altitude;
 
     quint8 m_glossContourLookupTable[256];
     bool m_glossAntiAliased;
 
     QString m_highlightBlendMode; // already in Krita format
     QColor m_highlightColor;
     qint32 m_highlightOpacity; // Highlight opacity as a percent
 
     QString m_shadowBlendMode; // already in Krita format
     QColor m_shadowColor;
     qint32 m_shadowOpacity; // Shadow opacity as a percent
 
     bool m_contourEnabled;
     int m_contourRange;
 
     bool m_textureEnabled;
     KoPattern *m_texturePattern;
     int m_textureScale;
     int m_textureDepth;
     bool m_textureInvert;
 
     bool m_textureAlignWithLayer;
     int m_textureHorizontalPhase; // 0..100%
     int m_textureVerticalPhase; // 0..100%
 };
 
 struct psd_layer_effects_overlay_base : public psd_layer_effects_shadow_base
 {
     psd_layer_effects_overlay_base()
         : m_scale(100),
           m_alignWithLayer(true),
           m_reverse(false),
           m_style(psd_gradient_style_linear),
           m_gradientXOffset(0),
           m_gradientYOffset(0),
           m_pattern(0),
           m_horizontalPhase(0),
           m_verticalPhase(0)
     {
         setUseGlobalLight(false);
     }
 
     /// FIXME: 'using' is not supported by MSVC, so please refactor in
     ///        some other way to ensure that the setters are not used
     ///        in the classes we don't want
 
     // using psd_layer_effects_shadow_base::setBlendMode;
     // using psd_layer_effects_shadow_base::setOpacity;
 
     int scale() const {
         return m_scale;
     }
 
     bool alignWithLayer() const {
         return m_alignWithLayer;
     }
 
     bool reverse() const {
         return m_reverse;
     }
 
     psd_gradient_style style() const {
         return m_style;
     }
 
     int gradientXOffset() const {
         return m_gradientXOffset;
     }
 
     int gradientYOffset() const {
         return m_gradientYOffset;
     }
 
     KoPattern* pattern() const {
         return m_pattern;
     }
 
     int horizontalPhase() const {
         return m_horizontalPhase;
     }
 
     int verticalPhase() const {
         return m_verticalPhase;
     }
 
 // refactor that
 public:
 
     void setScale(int value) {
         m_scale = value;
     }
 
     void setAlignWithLayer(bool value) {
         m_alignWithLayer = value;
     }
 
     void setReverse(bool value) {
         m_reverse = value;
     }
 
     void setStyle(psd_gradient_style value) {
         m_style = value;
     }
 
     void setGradientOffset(const QPointF &pt) {
         m_gradientXOffset = qRound(pt.x());
         m_gradientYOffset = qRound(pt.y());
     }
 
     QPointF gradientOffset() const {
         return QPointF(m_gradientXOffset, m_gradientYOffset);
     }
 
     void setPattern(KoPattern *value) {
         m_pattern = value;
     }
 
     void setPatternPhase(const QPointF &phase) {
         m_horizontalPhase = phase.x();
         m_verticalPhase = phase.y();
     }
 
     QPointF patternPhase() const {
         return QPointF(m_horizontalPhase, m_verticalPhase);
     }
 
     void scaleLinearSizes(qreal scale) override {
         psd_layer_effects_shadow_base::scaleLinearSizes(scale);
         m_scale *= scale;
     }
 
 private:
 
     // Gradient+Pattern
     int m_scale;
     bool m_alignWithLayer;
 
     // Gradient
     bool m_reverse;
     psd_gradient_style m_style;
     int m_gradientXOffset; // 0..100%
     int m_gradientYOffset; // 0..100%
 
     // Pattern
     KoPattern *m_pattern;
     int m_horizontalPhase; // 0..100%
     int m_verticalPhase; // 0..100%
 
 protected:
     /// FIXME: 'using' is not supported by MSVC, so please refactor in
     ///        some other way to ensure that the setters are not used
     ///        in the classes we don't want
 
     // must be called in the derived classes' c-tor
     // using psd_layer_effects_shadow_base::setFillType;
 };
 
 // sofi: http://www.adobe.com/devnet-apps/photoshop/fileformatashtml/PhotoshopFileFormats.htm#50577409_70055
 struct psd_layer_effects_color_overlay : public psd_layer_effects_overlay_base
 {
     psd_layer_effects_color_overlay() {
         setFillType(psd_fill_solid_color);
         setColor(Qt::white);
 
     }
 
     /// FIXME: 'using' is not supported by MSVC, so please refactor in
     ///        some other way to ensure that the setters are not used
     ///        in the classes we don't want
 
     // using psd_layer_effects_shadow_base::setColor;
 };
 
 struct psd_layer_effects_gradient_overlay : public psd_layer_effects_overlay_base
 {
     psd_layer_effects_gradient_overlay()
     {
         setFillType(psd_fill_gradient);
         setAngle(90);
         setReverse(false);
         setScale(100);
         setAlignWithLayer(true);
         setStyle(psd_gradient_style_linear);
 
     }
 public:
     /// FIXME: 'using' is not supported by MSVC, so please refactor in
     ///        some other way to ensure that the setters are not used
     ///        in the classes we don't want
 
     // using psd_layer_effects_shadow_base::setGradient;
     // using psd_layer_effects_shadow_base::setAngle;
 
     // using psd_layer_effects_overlay_base::setReverse;
     // using psd_layer_effects_overlay_base::setScale;
     // using psd_layer_effects_overlay_base::setAlignWithLayer;
     // using psd_layer_effects_overlay_base::setStyle;
 
     // using psd_layer_effects_overlay_base::setGradientOffset;
     // using psd_layer_effects_overlay_base::gradientOffset;
 };
 
 struct psd_layer_effects_pattern_overlay : public psd_layer_effects_overlay_base
 {
     psd_layer_effects_pattern_overlay()
     {
         setFillType(psd_fill_pattern);
         setScale(100);
         setAlignWithLayer(true);
     }
 
     /// FIXME: 'using' is not supported by MSVC, so please refactor in
     ///        some other way to ensure that the setters are not used
     ///        in the classes we don't want
 
     // using psd_layer_effects_overlay_base::setScale;
     // using psd_layer_effects_overlay_base::setAlignWithLayer;
 
     // using psd_layer_effects_overlay_base::setPattern;
 
     // using psd_layer_effects_overlay_base::setPatternPhase;
     // using psd_layer_effects_overlay_base::patternPhase;
 
 private:
     // These are unused
     /*int m_scale;
     bool m_alignWithLayer;
     KoPattern *m_pattern;
 
     int m_horizontalPhase;
     int m_verticalPhase;*/
 };
 
 struct psd_layer_effects_stroke : public psd_layer_effects_overlay_base
 {
     psd_layer_effects_stroke()
         : m_position(psd_stroke_outside)
     {
         setFillType(psd_fill_solid_color);
         setColor(Qt::black);
 
         setAngle(90);
         setReverse(false);
         setScale(100);
         setAlignWithLayer(true);
         setStyle(psd_gradient_style_linear);
 
         setScale(100);
         setAlignWithLayer(true);
     }
 
     /// FIXME: 'using' is not supported by MSVC, so please refactor in
     ///        some other way to ensure that the setters are not used
     ///        in the classes we don't want
 
     // using psd_layer_effects_shadow_base::setFillType;
     // using psd_layer_effects_shadow_base::setSize;
 
     // using psd_layer_effects_shadow_base::setColor;
 
     // using psd_layer_effects_shadow_base::setGradient;
     // using psd_layer_effects_shadow_base::setAngle;
     // using psd_layer_effects_overlay_base::setReverse;
     // using psd_layer_effects_overlay_base::setScale;
     // using psd_layer_effects_overlay_base::setAlignWithLayer;
     // using psd_layer_effects_overlay_base::setStyle;
 
     // using psd_layer_effects_overlay_base::setGradientOffset;
     // using psd_layer_effects_overlay_base::gradientOffset;
 
     // using psd_layer_effects_overlay_base::setPattern;
 
     // using psd_layer_effects_overlay_base::setPatternPhase;
     // using psd_layer_effects_overlay_base::patternPhase;
 
     psd_stroke_position position() const {
         return m_position;
     }
     void setPosition(psd_stroke_position value) {
         m_position = value;
     }
 
 private:
     psd_stroke_position m_position;
 };
 
 /**
  * Convert PsdColorMode to pigment colormodelid and colordepthid.
  * @see KoColorModelStandardIds
  *
  * @return a QPair containing ColorModelId and ColorDepthID
  */
 QPair<QString, QString> KRITAPSD_EXPORT psd_colormode_to_colormodelid(psd_color_mode colormode, quint16 channelDepth);
 
 
 /**
  * Convert the Photoshop blend mode strings to Pigment compositeop id's
  */
 QString KRITAPSD_EXPORT psd_blendmode_to_composite_op(const QString& blendmode);
 QString KRITAPSD_EXPORT composite_op_to_psd_blendmode(const QString& compositeOp);
 
 #endif // PSD_H
diff --git a/libs/ui/kis_composite_ops_model.cc b/libs/ui/kis_composite_ops_model.cc
index bccf5534af..49798d091d 100644
--- a/libs/ui/kis_composite_ops_model.cc
+++ b/libs/ui/kis_composite_ops_model.cc
@@ -1,153 +1,168 @@
 /*
  *  Copyright (c) 2009 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2011 Silvio Heinrich <plassy@web.de>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_composite_ops_model.h"
 
 #include <KoCompositeOp.h>
 #include <KoCompositeOpRegistry.h>
 #include <kis_icon.h>
 
 #include "kis_debug.h"
 #include "kis_config.h"
 
 KoID KisCompositeOpListModel::favoriteCategory() {
     static KoID category("favorites", ki18n("Favorites"));
     return category;
 }
 
 void KisCompositeOpListModel::initialize()
 {
     QMap<KoID, KoID> ops = KoCompositeOpRegistry::instance().getCompositeOps();
     QMapIterator<KoID, KoID> it(ops);
 
     while (it.hasNext()) {
         KoID op = *it.next();
         KoID category = it.key();
         BaseKoIDCategorizedListModel::DataItem *item = categoriesMapper()->addEntry(category.name(), op);
         item->setCheckable(true);
     }
 
     BaseKoIDCategorizedListModel::DataItem *item = categoriesMapper()->addCategory(favoriteCategory().name());
     item->setExpanded(true);
 
     readFavoriteCompositeOpsFromConfig();
 }
 
+void KisCompositeOpListModel::initializeForLayerStyles()
+{
+    QMap<KoID, KoID> ops = KoCompositeOpRegistry::instance().getLayerStylesCompositeOps();
+    QMapIterator<KoID, KoID> it(ops);
+
+    while (it.hasNext()) {
+        KoID op = *it.next();
+        KoID category = it.key();
+        BaseKoIDCategorizedListModel::DataItem *item = categoriesMapper()->addEntry(category.name(), op);
+        item->setCheckable(false);
+    }
+
+   categoriesMapper()->expandAllCategories();
+}
+
 KisCompositeOpListModel* KisCompositeOpListModel::sharedInstance()
 {
     static KisCompositeOpListModel *model = 0;
 
     if (!model) {
         model = new KisCompositeOpListModel();
         model->initialize();
     }
 
     return model;
 }
 
 void KisCompositeOpListModel::validate(const KoColorSpace *cs)
 {
     for (int i = 0, size = categoriesMapper()->rowCount(); i < size; i++) {
         DataItem *item = categoriesMapper()->itemFromRow(i);
 
         if (!item->isCategory()) {
             bool value = KoCompositeOpRegistry::instance().colorSpaceHasCompositeOp(cs, *item->data());
             item->setEnabled(value);
         }
     }
 }
 
 bool KisCompositeOpListModel::setData(const QModelIndex& idx, const QVariant& value, int role)
 {
     if (!idx.isValid()) return false;
 
     bool result = BaseKoIDCategorizedListModel::setData(idx, value, role);
 
     DataItem *item = categoriesMapper()->itemFromRow(idx.row());
     Q_ASSERT(item);
 
 
     if(role == Qt::CheckStateRole) {
         if (item->isChecked()) {
             addFavoriteEntry(*item->data());
         } else {
             removeFavoriteEntry(*item->data());
         }
 
         writeFavoriteCompositeOpsToConfig();
     }
 
     return result;
 }
 
 QVariant KisCompositeOpListModel::data(const QModelIndex& idx, int role) const
 {
     if (!idx.isValid()) return QVariant();
 
     if(role == Qt::DecorationRole) {
         DataItem *item = categoriesMapper()->itemFromRow(idx.row());
         Q_ASSERT(item);
 
         if (!item->isCategory() && !item->isEnabled()) {
             return KisIconUtils::loadIcon("dialog-warning");
         }
     }
 
     return BaseKoIDCategorizedListModel::data(idx, role);
 }
 
 void KisCompositeOpListModel::addFavoriteEntry(const KoID &entry)
 {
     DataItem *item = categoriesMapper()->addEntry(favoriteCategory().name(), entry);
     item->setCheckable(false);
 }
 
 void KisCompositeOpListModel::removeFavoriteEntry(const KoID &entry)
 {
     categoriesMapper()->removeEntry(favoriteCategory().name(), entry);
 }
 
 void KisCompositeOpListModel::readFavoriteCompositeOpsFromConfig()
 {
     KisConfig config(true);
     Q_FOREACH (const QString &op, config.favoriteCompositeOps()) {
         KoID entry = KoCompositeOpRegistry::instance().getKoID(op);
 
         DataItem *item = categoriesMapper()->fetchOneEntry(entry);
         if (item) {
             item->setChecked(true);
         }
 
         addFavoriteEntry(entry);
     }
 }
 
 void KisCompositeOpListModel::writeFavoriteCompositeOpsToConfig() const
 {
     QStringList list;
     QVector<DataItem*> filteredItems =
         categoriesMapper()->itemsForCategory(favoriteCategory().name());
 
     Q_FOREACH (DataItem *item, filteredItems) {
         list.append(item->data()->id());
     }
 
     KisConfig config(false);
     config.setFavoriteCompositeOps(list);
 }
diff --git a/libs/ui/kis_composite_ops_model.h b/libs/ui/kis_composite_ops_model.h
index 09a8106d26..d1df4cdb8e 100644
--- a/libs/ui/kis_composite_ops_model.h
+++ b/libs/ui/kis_composite_ops_model.h
@@ -1,87 +1,93 @@
 /*
  *  Copyright (c) 2009 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2011 Silvio Heinrich <plassy@web.de>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef _KIS_COMPOSITE_OPS_MODEL_H_
 #define _KIS_COMPOSITE_OPS_MODEL_H_
 
 #include <KoID.h>
 #include "kis_categorized_list_model.h"
 
 class KoColorSpace;
 
 struct KoIDToQStringConverter {
     QString operator() (const KoID &id) {
         return id.name();
     }
 };
 
 typedef KisCategorizedListModel<KoID,KoIDToQStringConverter> BaseKoIDCategorizedListModel;
 
 class KRITAUI_EXPORT KisCompositeOpListModel: public BaseKoIDCategorizedListModel
 {
 public:
     static KisCompositeOpListModel* sharedInstance();
 
     virtual QString  categoryToString(const KoID& val) const { return val.name(); }
     virtual QString  entryToString   (const KoID& val) const { return val.name(); }
     bool     setData         (const QModelIndex& idx, const QVariant& value, int role=Qt::EditRole) override;
     QVariant data            (const QModelIndex& idx, int role=Qt::DisplayRole) const override;
 
     void validate(const KoColorSpace *cs);
     void readFavoriteCompositeOpsFromConfig();
     void writeFavoriteCompositeOpsToConfig() const;
 
     static KoID favoriteCategory();
 
     void initialize();
+    void initializeForLayerStyles();
 
 private:
     void addFavoriteEntry(const KoID &entry);
     void removeFavoriteEntry(const KoID &entry);
 };
 
 /**
  * @brief The KisSortedCompositeOpListModel class provides a model for the composite op combobox.
  *
  * It intentionally does NOT use the shared instance of KisCompositeOpListModel because it is
  * perfect valid for two composite comboboboxes to show a different set of valid composite ops.
  */
 class KRITAUI_EXPORT KisSortedCompositeOpListModel : public KisSortedCategorizedListModel<KisCompositeOpListModel>
 {
 public:
-    KisSortedCompositeOpListModel(QObject *parent)
+    KisSortedCompositeOpListModel(bool limitToLayerStyles, QObject *parent)
         : KisSortedCategorizedListModel<KisCompositeOpListModel>(parent)
     {
-        m_model.initialize();
+        if (limitToLayerStyles) {
+            m_model.initializeForLayerStyles();
+        } else {
+            m_model.initialize();
+        }
+
         initializeModel(&m_model);
     }
 
     void validate(const KoColorSpace *cs) {
         m_model.validate(cs);
     }
 
 protected:
     bool lessThan(const QModelIndex &left, const QModelIndex &right) const override {
         return lessThanPriority(left, right, KisCompositeOpListModel::favoriteCategory().name());
     }
 private:
     KisCompositeOpListModel m_model;
 };
 
 #endif
diff --git a/libs/ui/kis_paintop_box.cc b/libs/ui/kis_paintop_box.cc
index f47d622bed..1a6e64a9de 100644
--- a/libs/ui/kis_paintop_box.cc
+++ b/libs/ui/kis_paintop_box.cc
@@ -1,1377 +1,1377 @@
 /*
  *  kis_paintop_box.cc - part of KImageShop/Krayon/Krita
  *
  *  Copyright (c) 2004 Boudewijn Rempt (boud@valdyas.org)
  *  Copyright (c) 2009-2011 Sven Langkamp (sven.langkamp@gmail.com)
  *  Copyright (c) 2010 Lukáš Tvrdý <lukast.dev@gmail.com>
  *  Copyright (C) 2011 Silvio Heinrich <plassy@web.de>
  *  Copyright (C) 2011 Srikanth Tiyyagura <srikanth.tulasiram@gmail.com>
  *  Copyright (c) 2014 Mohit Goyal <mohit.bits2011@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_paintop_box.h"
 
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QToolButton>
 #include <QPixmap>
 #include <QWidgetAction>
 #include <QApplication>
 #include <QMenu>
 #include <QTime>
 
 #include <kis_debug.h>
 
 #include <kactioncollection.h>
 #include <kacceleratormanager.h>
 #include <QKeySequence>
 
 
 #include <kis_icon.h>
 #include <KoColorSpace.h>
 #include <KoCompositeOpRegistry.h>
 #include <KoResourceServerAdapter.h>
 #include <KoToolManager.h>
 #include <KoColorSpaceRegistry.h>
 
 #include <kis_paint_device.h>
 #include <brushengine/kis_paintop_registry.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <brushengine/kis_paintop_settings.h>
 #include <brushengine/kis_paintop_settings_update_proxy.h>
 #include <kis_config_widget.h>
 #include <kis_image.h>
 #include <kis_node.h>
 #include <brushengine/kis_paintop_config_widget.h>
 #include <kis_action.h>
 
 #include "kis_canvas2.h"
 #include "kis_node_manager.h"
 #include "KisViewManager.h"
 #include "kis_canvas_resource_provider.h"
 #include "KisResourceServerProvider.h"
 #include "kis_favorite_resource_manager.h"
 #include "kis_config.h"
 
 #include "kis_popup_button.h"
 #include "widgets/kis_iconwidget.h"
 #include "widgets/kis_tool_options_popup.h"
 #include "widgets/kis_paintop_presets_popup.h"
 #include "widgets/kis_paintop_presets_chooser_popup.h"
 #include "widgets/kis_workspace_chooser.h"
 #include "widgets/kis_paintop_list_widget.h"
 #include "widgets/kis_slider_spin_box.h"
 #include "widgets/kis_cmb_composite.h"
 #include "widgets/kis_widget_chooser.h"
 #include "tool/kis_tool.h"
 #include "kis_signals_blocker.h"
 #include "kis_action_manager.h"
 #include "KisHighlightedToolButton.h"
 
 typedef KoResourceServerSimpleConstruction<KisPaintOpPreset, SharedPointerStoragePolicy<KisPaintOpPresetSP> > KisPaintOpPresetResourceServer;
 typedef KoResourceServerAdapter<KisPaintOpPreset, SharedPointerStoragePolicy<KisPaintOpPresetSP> > KisPaintOpPresetResourceServerAdapter;
 
 KisPaintopBox::KisPaintopBox(KisViewManager *view, QWidget *parent, const char *name)
     : QWidget(parent)
     , m_resourceProvider(view->canvasResourceProvider())
     , m_optionWidget(0)
     , m_toolOptionsPopupButton(0)
     , m_brushEditorPopupButton(0)
     , m_presetSelectorPopupButton(0)
     , m_toolOptionsPopup(0)
     , m_viewManager(view)
     , m_previousNode(0)
     , m_currTabletToolID(KoInputDevice::invalid())
     , m_presetsEnabled(true)
     , m_blockUpdate(false)
     , m_dirtyPresetsEnabled(false)
     , m_eraserBrushSizeEnabled(false)
     , m_eraserBrushOpacityEnabled(false)
 {
     Q_ASSERT(view != 0);
 
 
     setObjectName(name);
     KisConfig cfg(true);
     m_dirtyPresetsEnabled = cfg.useDirtyPresets();
     m_eraserBrushSizeEnabled = cfg.useEraserBrushSize();
     m_eraserBrushOpacityEnabled = cfg.useEraserBrushOpacity();
 
     KAcceleratorManager::setNoAccel(this);
 
     setWindowTitle(i18n("Painter's Toolchest"));
 
     m_favoriteResourceManager = new KisFavoriteResourceManager(this);
 
 
     KConfigGroup grp =  KSharedConfig::openConfig()->group("krita").group("Toolbar BrushesAndStuff");
     int iconsize = grp.readEntry("IconSize", 32);
 
     if (!cfg.toolOptionsInDocker()) {
         m_toolOptionsPopupButton = new KisPopupButton(this);
         m_toolOptionsPopupButton->setIcon(KisIconUtils::loadIcon("configure"));
         m_toolOptionsPopupButton->setToolTip(i18n("Tool Settings"));
         m_toolOptionsPopupButton->setFixedSize(iconsize, iconsize);
     }
 
     m_brushEditorPopupButton = new KisIconWidget(this);
     m_brushEditorPopupButton->setIcon(KisIconUtils::loadIcon("paintop_settings_02"));
     m_brushEditorPopupButton->setToolTip(i18n("Edit brush settings"));
     m_brushEditorPopupButton->setFixedSize(iconsize, iconsize);
 
     m_presetSelectorPopupButton = new KisPopupButton(this);
     m_presetSelectorPopupButton->setIcon(KisIconUtils::loadIcon("paintop_settings_01"));
     m_presetSelectorPopupButton->setToolTip(i18n("Choose brush preset"));
     m_presetSelectorPopupButton->setFixedSize(iconsize, iconsize);
 
     m_eraseModeButton = new KisHighlightedToolButton(this);
     m_eraseModeButton->setFixedSize(iconsize, iconsize);
     m_eraseModeButton->setCheckable(true);
 
     m_eraseAction = m_viewManager->actionManager()->createAction("erase_action");
     m_eraseModeButton->setDefaultAction(m_eraseAction);
 
     m_reloadButton = new QToolButton(this);
     m_reloadButton->setFixedSize(iconsize, iconsize);
 
     m_reloadAction = m_viewManager->actionManager()->createAction("reload_preset_action");
     m_reloadButton->setDefaultAction(m_reloadAction);
 
     m_alphaLockButton = new KisHighlightedToolButton(this);
     m_alphaLockButton->setFixedSize(iconsize, iconsize);
     m_alphaLockButton->setCheckable(true);
 
     KisAction* alphaLockAction = m_viewManager->actionManager()->createAction("preserve_alpha");
     m_alphaLockButton->setDefaultAction(alphaLockAction);
 
     // horizontal and vertical mirror toolbar buttons
 
     // mirror tool options for the X Mirror
     QMenu *toolbarMenuXMirror = new QMenu();
 
     hideCanvasDecorationsX = m_viewManager->actionManager()->createAction("mirrorX-hideDecorations");
     toolbarMenuXMirror->addAction(hideCanvasDecorationsX);
 
     lockActionX = m_viewManager->actionManager()->createAction("mirrorX-lock");
     toolbarMenuXMirror->addAction(lockActionX);
 
     moveToCenterActionX = m_viewManager->actionManager()->createAction("mirrorX-moveToCenter");
     toolbarMenuXMirror->addAction(moveToCenterActionX);
 
 
     // mirror tool options for the Y Mirror
     QMenu *toolbarMenuYMirror = new QMenu();
 
     hideCanvasDecorationsY = m_viewManager->actionManager()->createAction("mirrorY-hideDecorations");
     toolbarMenuYMirror->addAction(hideCanvasDecorationsY);
 
 
     lockActionY = m_viewManager->actionManager()->createAction("mirrorY-lock");
     toolbarMenuYMirror->addAction(lockActionY);
 
     moveToCenterActionY = m_viewManager->actionManager()->createAction("mirrorY-moveToCenter");
     toolbarMenuYMirror->addAction(moveToCenterActionY);
 
 
 
     // create horizontal and vertical mirror buttons
 
     m_hMirrorButton = new KisHighlightedToolButton(this);
     int menuPadding = 10;
     m_hMirrorButton->setFixedSize(iconsize + menuPadding, iconsize);
     m_hMirrorButton->setCheckable(true);
     m_hMirrorAction = m_viewManager->actionManager()->createAction("hmirror_action");
     m_hMirrorButton->setDefaultAction(m_hMirrorAction);
     m_hMirrorButton->setMenu(toolbarMenuXMirror);
     m_hMirrorButton->setPopupMode(QToolButton::MenuButtonPopup);
 
     m_vMirrorButton = new KisHighlightedToolButton(this);
     m_vMirrorButton->setFixedSize(iconsize + menuPadding, iconsize);
     m_vMirrorButton->setCheckable(true);
     m_vMirrorAction = m_viewManager->actionManager()->createAction("vmirror_action");
     m_vMirrorButton->setDefaultAction(m_vMirrorAction);
     m_vMirrorButton->setMenu(toolbarMenuYMirror);
     m_vMirrorButton->setPopupMode(QToolButton::MenuButtonPopup);
 
 
     // add connections for horizontal and mirrror buttons
     connect(lockActionX, SIGNAL(toggled(bool)), this, SLOT(slotLockXMirrorToggle(bool)));
     connect(lockActionY, SIGNAL(toggled(bool)), this, SLOT(slotLockYMirrorToggle(bool)));
 
     connect(moveToCenterActionX, SIGNAL(triggered(bool)), this, SLOT(slotMoveToCenterMirrorX()));
     connect(moveToCenterActionY, SIGNAL(triggered(bool)), this, SLOT(slotMoveToCenterMirrorY()));
 
     connect(hideCanvasDecorationsX, SIGNAL(toggled(bool)), this, SLOT(slotHideDecorationMirrorX(bool)));
     connect(hideCanvasDecorationsY, SIGNAL(toggled(bool)), this, SLOT(slotHideDecorationMirrorY(bool)));
 
     const bool sliderLabels = cfg.sliderLabels();
     int sliderWidth;
 
     if (sliderLabels) {
         sliderWidth = 150 * logicalDpiX() / 96;
     }
     else {
         sliderWidth = 120 * logicalDpiX() / 96;
     }
 
     for (int i = 0; i < 3; ++i) {
         m_sliderChooser[i] = new KisWidgetChooser(i + 1);
 
         KisDoubleSliderSpinBox* slOpacity;
         KisDoubleSliderSpinBox* slFlow;
         KisDoubleSliderSpinBox* slSize;
         if (sliderLabels) {
             slOpacity = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("opacity");
             slFlow    = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("flow");
             slSize    = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("size");
             slOpacity->setPrefix(QString("%1 ").arg(i18n("Opacity:")));
             slFlow->setPrefix(QString("%1 ").arg(i18n("Flow:")));
             slSize->setPrefix(QString("%1 ").arg(i18n("Size:")));
         }
         else {
             slOpacity = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("opacity", i18n("Opacity:"));
             slFlow    = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("flow", i18n("Flow:"));
             slSize    = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("size", i18n("Size:"));
         }
 
         slOpacity->setRange(0, 100, 0);
         slOpacity->setValue(100);
         slOpacity->setSingleStep(5);
         slOpacity->setSuffix(i18n("%"));
         slOpacity->setMinimumWidth(qMax(sliderWidth, slOpacity->sizeHint().width()));
         slOpacity->setFixedHeight(iconsize);
         slOpacity->setBlockUpdateSignalOnDrag(true);
 
         slFlow->setRange(0, 100, 0);
         slFlow->setValue(100);
         slFlow->setSingleStep(5);
         slFlow->setSuffix(i18n("%"));
         slFlow->setMinimumWidth(qMax(sliderWidth, slFlow->sizeHint().width()));
         slFlow->setFixedHeight(iconsize);
         slFlow->setBlockUpdateSignalOnDrag(true);
 
         slSize->setRange(0.01, cfg.readEntry("maximumBrushSize", 1000), 2);
         slSize->setValue(100);
 
         slSize->setSingleStep(1);
         slSize->setExponentRatio(3.0);
         slSize->setSuffix(i18n(" px"));
         slSize->setMinimumWidth(qMax(sliderWidth, slSize->sizeHint().width()));
         slSize->setFixedHeight(iconsize);
         slSize->setBlockUpdateSignalOnDrag(true);
 
         m_sliderChooser[i]->chooseWidget(cfg.toolbarSlider(i + 1));
     }
 
     m_cmbCompositeOp = new KisCompositeOpComboBox();
     m_cmbCompositeOp->setFixedHeight(iconsize);
-    Q_FOREACH (KisAction * a, m_cmbCompositeOp->blendmodeActions()) {
+    Q_FOREACH (KisAction * a, m_cmbCompositeOp->createBlendmodeActions()) {
         m_viewManager->actionManager()->addAction(a->text(), a);
     }
 
     m_workspaceWidget = new KisPopupButton(this);
     m_workspaceWidget->setIcon(KisIconUtils::loadIcon("view-choose"));
     m_workspaceWidget->setToolTip(i18n("Choose workspace"));
     m_workspaceWidget->setFixedSize(iconsize, iconsize);
     m_workspaceWidget->setPopupWidget(new KisWorkspaceChooser(view));
 
     QHBoxLayout* baseLayout = new QHBoxLayout(this);
     m_paintopWidget = new QWidget(this);
     baseLayout->addWidget(m_paintopWidget);
     baseLayout->setSpacing(4);
     baseLayout->setContentsMargins(0, 0, 0, 0);
 
     m_layout = new QHBoxLayout(m_paintopWidget);
     if (!cfg.toolOptionsInDocker()) {
         m_layout->addWidget(m_toolOptionsPopupButton);
     }
     m_layout->addWidget(m_brushEditorPopupButton);
     m_layout->addWidget(m_presetSelectorPopupButton);
     m_layout->setSpacing(4);
     m_layout->setContentsMargins(0, 0, 0, 0);
 
     QWidget* compositeActions = new QWidget(this);
     QHBoxLayout* compositeLayout = new QHBoxLayout(compositeActions);
     compositeLayout->addWidget(m_cmbCompositeOp);
     compositeLayout->addWidget(m_eraseModeButton);
     compositeLayout->addWidget(m_alphaLockButton);
 
     compositeLayout->setSpacing(4);
     compositeLayout->setContentsMargins(0, 0, 0, 0);
 
     compositeLayout->addWidget(m_reloadButton);
 
     QWidgetAction * action;
 
     action = new QWidgetAction(this);
     view->actionCollection()->addAction("composite_actions", action);
     action->setText(i18n("Brush composite"));
     action->setDefaultWidget(compositeActions);
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("brushslider1", action);
     view->actionCollection()->addAction("brushslider1", action);
     action->setDefaultWidget(m_sliderChooser[0]);
     connect(action, SIGNAL(triggered()), m_sliderChooser[0], SLOT(showPopupWidget()));
     connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), m_sliderChooser[0], SLOT(updateThemedIcons()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("brushslider2", action);
     view->actionCollection()->addAction("brushslider2", action);
     action->setDefaultWidget(m_sliderChooser[1]);
     connect(action, SIGNAL(triggered()), m_sliderChooser[1], SLOT(showPopupWidget()));
     connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), m_sliderChooser[1], SLOT(updateThemedIcons()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("brushslider3", action);
     view->actionCollection()->addAction("brushslider3", action);
     action->setDefaultWidget(m_sliderChooser[2]);
     connect(action, SIGNAL(triggered()), m_sliderChooser[2], SLOT(showPopupWidget()));
         connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), m_sliderChooser[2], SLOT(updateThemedIcons()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("next_favorite_preset", action);
     view->actionCollection()->addAction("next_favorite_preset", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotNextFavoritePreset()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("previous_favorite_preset", action);
     view->actionCollection()->addAction("previous_favorite_preset", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotPreviousFavoritePreset()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("previous_preset", action);
     view->actionCollection()->addAction("previous_preset", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotSwitchToPreviousPreset()));
 
     if (!cfg.toolOptionsInDocker()) {
         action = new QWidgetAction(this);
         KisActionRegistry::instance()->propertizeAction("show_tool_options", action);
         view->actionCollection()->addAction("show_tool_options", action);
         connect(action, SIGNAL(triggered()), m_toolOptionsPopupButton, SLOT(showPopupWidget()));
     }
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("show_brush_editor", action);
     view->actionCollection()->addAction("show_brush_editor", action);
     connect(action, SIGNAL(triggered()), m_brushEditorPopupButton, SLOT(showPopupWidget()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("show_brush_presets", action);
     view->actionCollection()->addAction("show_brush_presets", action);
     connect(action, SIGNAL(triggered()), m_presetSelectorPopupButton, SLOT(showPopupWidget()));
 
     QWidget* mirrorActions = new QWidget(this);
     QHBoxLayout* mirrorLayout = new QHBoxLayout(mirrorActions);
     mirrorLayout->addWidget(m_hMirrorButton);
     mirrorLayout->addWidget(m_vMirrorButton);
     mirrorLayout->setSpacing(4);
     mirrorLayout->setContentsMargins(0, 0, 0, 0);
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("mirror_actions", action);
     action->setDefaultWidget(mirrorActions);
     view->actionCollection()->addAction("mirror_actions", action);
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("workspaces", action);
     view->actionCollection()->addAction("workspaces", action);
     action->setDefaultWidget(m_workspaceWidget);
 
     if (!cfg.toolOptionsInDocker()) {
         m_toolOptionsPopup = new KisToolOptionsPopup();
         m_toolOptionsPopupButton->setPopupWidget(m_toolOptionsPopup);
         m_toolOptionsPopup->switchDetached(false);
     }
 
 
     m_savePresetWidget = new KisPresetSaveWidget(this);
 
     m_presetsPopup = new KisPaintOpPresetsPopup(m_resourceProvider, m_favoriteResourceManager, m_savePresetWidget);
     m_brushEditorPopupButton->setPopupWidget(m_presetsPopup);
     m_presetsPopup->parentWidget()->setWindowTitle(i18n("Brush Editor"));
 
 
     connect(m_presetsPopup, SIGNAL(brushEditorShown()), SLOT(slotUpdateOptionsWidgetPopup()));
     connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), m_presetsPopup, SLOT(updateThemedIcons()));
 
     m_presetsChooserPopup = new KisPaintOpPresetsChooserPopup();
     m_presetsChooserPopup->setMinimumHeight(550);
     m_presetsChooserPopup->setMinimumWidth(450);
     m_presetSelectorPopupButton->setPopupWidget(m_presetsChooserPopup);
 
     m_currCompositeOpID = KoCompositeOpRegistry::instance().getDefaultCompositeOp().id();
 
     slotNodeChanged(view->activeNode());
     // Get all the paintops
     QList<QString> keys = KisPaintOpRegistry::instance()->keys();
     QList<KisPaintOpFactory*> factoryList;
 
     Q_FOREACH (const QString & paintopId, keys) {
         factoryList.append(KisPaintOpRegistry::instance()->get(paintopId));
     }
     m_presetsPopup->setPaintOpList(factoryList);
 
     connect(m_presetsPopup       , SIGNAL(paintopActivated(QString))          , SLOT(slotSetPaintop(QString)));
     connect(m_presetsPopup       , SIGNAL(defaultPresetClicked())             , SLOT(slotSetupDefaultPreset()));
     connect(m_presetsPopup       , SIGNAL(signalResourceSelected(KoResource*)), SLOT(resourceSelected(KoResource*)));
     connect(m_presetsPopup       , SIGNAL(reloadPresetClicked())              , SLOT(slotReloadPreset()));
     connect(m_presetsPopup       , SIGNAL(dirtyPresetToggled(bool))           , SLOT(slotDirtyPresetToggled(bool)));
     connect(m_presetsPopup       , SIGNAL(eraserBrushSizeToggled(bool))       , SLOT(slotEraserBrushSizeToggled(bool)));
     connect(m_presetsPopup       , SIGNAL(eraserBrushOpacityToggled(bool))       , SLOT(slotEraserBrushOpacityToggled(bool)));
 
     connect(m_presetsPopup, SIGNAL(createPresetFromScratch(QString)), this, SLOT(slotCreatePresetFromScratch(QString)));
 
     connect(m_presetsChooserPopup, SIGNAL(resourceSelected(KoResource*))      , SLOT(resourceSelected(KoResource*)));
     connect(m_presetsChooserPopup, SIGNAL(resourceClicked(KoResource*))      , SLOT(resourceSelected(KoResource*)));
 
     connect(m_resourceProvider   , SIGNAL(sigNodeChanged(KisNodeSP))    , SLOT(slotNodeChanged(KisNodeSP)));
     connect(m_cmbCompositeOp     , SIGNAL(currentIndexChanged(int))           , SLOT(slotSetCompositeMode(int)));
     connect(m_eraseAction          , SIGNAL(toggled(bool))                    , SLOT(slotToggleEraseMode(bool)));
     connect(alphaLockAction      , SIGNAL(toggled(bool))                    , SLOT(slotToggleAlphaLockMode(bool)));
 
     m_disablePressureAction = m_viewManager->actionManager()->createAction("disable_pressure");
     connect(m_disablePressureAction  , SIGNAL(toggled(bool))                    , SLOT(slotDisablePressureMode(bool)));
     m_disablePressureAction->setChecked(true);
 
     connect(m_hMirrorAction        , SIGNAL(toggled(bool))                    , SLOT(slotHorizontalMirrorChanged(bool)));
     connect(m_vMirrorAction        , SIGNAL(toggled(bool))                    , SLOT(slotVerticalMirrorChanged(bool)));
     connect(m_reloadAction         , SIGNAL(triggered())                        , SLOT(slotReloadPreset()));
 
     connect(m_sliderChooser[0]->getWidget<KisDoubleSliderSpinBox>("opacity"), SIGNAL(valueChanged(qreal)), SLOT(slotSlider1Changed()));
     connect(m_sliderChooser[0]->getWidget<KisDoubleSliderSpinBox>("flow")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider1Changed()));
     connect(m_sliderChooser[0]->getWidget<KisDoubleSliderSpinBox>("size")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider1Changed()));
     connect(m_sliderChooser[1]->getWidget<KisDoubleSliderSpinBox>("opacity"), SIGNAL(valueChanged(qreal)), SLOT(slotSlider2Changed()));
     connect(m_sliderChooser[1]->getWidget<KisDoubleSliderSpinBox>("flow")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider2Changed()));
     connect(m_sliderChooser[1]->getWidget<KisDoubleSliderSpinBox>("size")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider2Changed()));
     connect(m_sliderChooser[2]->getWidget<KisDoubleSliderSpinBox>("opacity"), SIGNAL(valueChanged(qreal)), SLOT(slotSlider3Changed()));
     connect(m_sliderChooser[2]->getWidget<KisDoubleSliderSpinBox>("flow")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider3Changed()));
     connect(m_sliderChooser[2]->getWidget<KisDoubleSliderSpinBox>("size")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider3Changed()));
 
     //Needed to connect canvas to favorite resource manager
     connect(m_viewManager->canvasResourceProvider(), SIGNAL(sigFGColorChanged(KoColor)), SLOT(slotUnsetEraseMode()));
 
 
     connect(m_resourceProvider, SIGNAL(sigFGColorUsed(KoColor)), m_favoriteResourceManager, SLOT(slotAddRecentColor(KoColor)));
 
     connect(m_resourceProvider, SIGNAL(sigFGColorChanged(KoColor)), m_favoriteResourceManager, SLOT(slotChangeFGColorSelector(KoColor)));
     connect(m_resourceProvider, SIGNAL(sigBGColorChanged(KoColor)), m_favoriteResourceManager, SLOT(slotSetBGColor(KoColor)));
     // cold initialization
     m_favoriteResourceManager->slotChangeFGColorSelector(m_resourceProvider->fgColor());
     m_favoriteResourceManager->slotSetBGColor(m_resourceProvider->bgColor());
 
     connect(m_favoriteResourceManager, SIGNAL(sigSetFGColor(KoColor)), m_resourceProvider, SLOT(slotSetFGColor(KoColor)));
     connect(m_favoriteResourceManager, SIGNAL(sigSetBGColor(KoColor)), m_resourceProvider, SLOT(slotSetBGColor(KoColor)));
     connect(m_favoriteResourceManager, SIGNAL(sigEnableChangeColor(bool)), m_resourceProvider, SLOT(slotResetEnableFGChange(bool)));
 
     connect(view->mainWindow(), SIGNAL(themeChanged()), this, SLOT(slotUpdateSelectionIcon()));
     connect(m_resourceProvider->resourceManager(), SIGNAL(canvasResourceChanged(int,QVariant)),
             this, SLOT(slotCanvasResourceChanged(int,QVariant)));
 
     slotInputDeviceChanged(KoToolManager::instance()->currentInputDevice());
 
     KisPaintOpPresetResourceServer *rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
     m_eraserName = "eraser_circle";
     m_defaultPresetName = "basic_tip_default";
     bool foundEraser = false;
     bool foundTip = false;
     for (int i=0; i<rserver->resourceCount(); i++) {
         KisPaintOpPresetSP resource = rserver->resources().at(i);
         if (resource->name().toLower().contains("eraser_circle")) {
             m_eraserName = resource->name();
             foundEraser = true;
         } else if (foundEraser == false && (resource->name().toLower().contains("eraser") ||
                                             resource->filename().toLower().contains("eraser"))) {
             m_eraserName = resource->name();
             foundEraser = true;
         }
         if (resource->name().toLower().contains("basic_tip_default")) {
             m_defaultPresetName = resource->name();
             foundTip = true;
         } else if (foundTip == false && (resource->name().toLower().contains("default") ||
                                          resource->filename().toLower().contains("default"))) {
             m_defaultPresetName = resource->name();
             foundTip = true;
         }
     }
 }
 
 KisPaintopBox::~KisPaintopBox()
 {
     KisConfig cfg(false);
     QMapIterator<TabletToolID, TabletToolData> iter(m_tabletToolMap);
     while (iter.hasNext()) {
         iter.next();
         if ((iter.key().pointer) == QTabletEvent::Eraser) {
             cfg.writeEntry(QString("LastEraser") , iter.value().preset->name());
         }
         else {
             cfg.writeEntry(QString("LastPreset"), iter.value().preset->name());
         }
     }
     // Do not delete the widget, since it is global to the application, not owned by the view
     m_presetsPopup->setPaintOpSettingsWidget(0);
     qDeleteAll(m_paintopOptionWidgets);
     delete m_favoriteResourceManager;
 
     for (int i = 0; i < 3; ++i) {
         delete m_sliderChooser[i];
     }
 }
 
 void KisPaintopBox::restoreResource(KoResource* resource)
 {
     KisPaintOpPreset* preset = dynamic_cast<KisPaintOpPreset*>(resource);
 
     if (preset) {
         setCurrentPaintop(preset);
 
         m_presetsPopup->setPresetImage(preset->image());
         m_presetsPopup->resourceSelected(resource);
     }
 }
 
 void KisPaintopBox::newOptionWidgets(const QList<QPointer<QWidget> > &optionWidgetList)
 {
     if (m_toolOptionsPopup) {
         m_toolOptionsPopup->newOptionWidgets(optionWidgetList);
     }
 }
 
 void KisPaintopBox::resourceSelected(KoResource* resource)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_optionWidget);
 
     m_presetsPopup->setCreatingBrushFromScratch(false); // show normal UI elements when we are not creating
 
     KisPaintOpPreset* preset = dynamic_cast<KisPaintOpPreset*>(resource);
     if (preset && preset != m_resourceProvider->currentPreset()) {
         if (!preset->settings()->isLoadable())
             return;
 
         if (!m_dirtyPresetsEnabled) {
             KisSignalsBlocker blocker(m_optionWidget);
             if (!preset->load()) {
                 warnKrita << "failed to load the preset.";
             }
         }
         //qDebug() << "resourceSelected" << resource->name();
         setCurrentPaintop(preset);
 
         m_presetsPopup->setPresetImage(preset->image());
         m_presetsPopup->resourceSelected(resource);
     }
 
 
 }
 
 void KisPaintopBox::setCurrentPaintop(const KoID& paintop)
 {
     KisPaintOpPresetSP preset = activePreset(paintop);
     Q_ASSERT(preset && preset->settings());
     //qDebug() << "setCurrentPaintop();" << paintop << preset;
     setCurrentPaintop(preset);
 }
 
 void KisPaintopBox::setCurrentPaintop(KisPaintOpPresetSP preset)
 {
 
     //qDebug() << "setCurrentPaintop(); " << preset->name();
 
     if (preset == m_resourceProvider->currentPreset()) {
 
         if (preset == m_tabletToolMap[m_currTabletToolID].preset) {
             return;
         }
     }
     Q_ASSERT(preset);
     const KoID& paintop = preset->paintOp();
     m_presetConnections.clear();
 
     if (m_resourceProvider->currentPreset()) {
 
         m_resourceProvider->setPreviousPaintOpPreset(m_resourceProvider->currentPreset());
 
         if (m_optionWidget) {
             m_optionWidget->hide();
         }
 
     }
 
     if (!m_paintopOptionWidgets.contains(paintop))
         m_paintopOptionWidgets[paintop] = KisPaintOpRegistry::instance()->get(paintop.id())->createConfigWidget(this);
 
     m_optionWidget = m_paintopOptionWidgets[paintop];
 
     KisSignalsBlocker b(m_optionWidget);
 
     preset->setOptionsWidget(m_optionWidget);
 
     m_optionWidget->setImage(m_viewManager->image());
     m_optionWidget->setNode(m_viewManager->activeNode());
 
     m_presetsPopup->setPaintOpSettingsWidget(m_optionWidget);
 
     m_resourceProvider->setPaintOpPreset(preset);
 
     Q_ASSERT(m_optionWidget && m_presetSelectorPopupButton);
 
     m_presetConnections.addConnection(m_optionWidget, SIGNAL(sigConfigurationUpdated()), this, SLOT(slotGuiChangedCurrentPreset()));
     m_presetConnections.addConnection(m_optionWidget, SIGNAL(sigSaveLockedConfig(KisPropertiesConfigurationSP)), this, SLOT(slotSaveLockedOptionToPreset(KisPropertiesConfigurationSP)));
     m_presetConnections.addConnection(m_optionWidget, SIGNAL(sigDropLockedConfig(KisPropertiesConfigurationSP)), this, SLOT(slotDropLockedOption(KisPropertiesConfigurationSP)));
 
 
     // load the current brush engine icon for the brush editor toolbar button
 
     m_brushEditorPopupButton->setResource(preset.data());
     m_presetsPopup->setCurrentPaintOpId(paintop.id());
 
 
     ////qDebug() << "\tsetting the new preset for" << m_currTabletToolID.uniqueID << "to" << preset->name();
     m_paintOpPresetMap[m_resourceProvider->currentPreset()->paintOp()] = preset;
     m_tabletToolMap[m_currTabletToolID].preset = preset;
     m_tabletToolMap[m_currTabletToolID].paintOpID = preset->paintOp();
 
 
     if (m_presetsPopup->currentPaintOpId() != paintop.id()) {
         // Must change the paintop as the current one is not supported
         // by the new colorspace.
         dbgKrita << "current paintop " << paintop.name() << " was not set, not supported by colorspace";
     }
 
     m_currCompositeOpID = preset->settings()->paintOpCompositeOp();
     updateCompositeOp(m_currCompositeOpID);
 }
 
 void KisPaintopBox::slotUpdateOptionsWidgetPopup()
 {
     KisPaintOpPresetSP preset = m_resourceProvider->currentPreset();
 
     // This happens when we have a new brush engine for which no default preset exists yet.
     if (!preset) return;
 
     KIS_SAFE_ASSERT_RECOVER_RETURN(preset);
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_optionWidget);
 
     m_optionWidget->setConfigurationSafe(preset->settings());
 
     m_presetsPopup->resourceSelected(preset.data());
     m_presetsPopup->updateViewSettings();
 
     // the m_viewManager->image() is set earlier, but the reference will be missing when the stamp button is pressed
     // need to later do some research on how and when we should be using weak shared pointers (WSP) that creates this situation
     m_optionWidget->setImage(m_viewManager->image());
 }
 
 KisPaintOpPresetSP KisPaintopBox::defaultPreset(const KoID& paintOp)
 {
     QString defaultName = paintOp.id() + ".kpp";
     QString path = KoResourcePaths::findResource("kis_defaultpresets", defaultName);
 
     KisPaintOpPresetSP preset = new KisPaintOpPreset(path);
 
     if (!preset->load()) {
         preset = KisPaintOpRegistry::instance()->defaultPreset(paintOp);
     }
 
     Q_ASSERT(preset);
     Q_ASSERT(preset->valid());
 
     return preset;
 }
 
 KisPaintOpPresetSP KisPaintopBox::activePreset(const KoID& paintOp)
 {
     if (m_paintOpPresetMap[paintOp] == 0) {
         m_paintOpPresetMap[paintOp] = defaultPreset(paintOp);
     }
 
     return m_paintOpPresetMap[paintOp];
 }
 
 void KisPaintopBox::updateCompositeOp(QString compositeOpID)
 {
     if (!m_optionWidget) return;
     KisSignalsBlocker blocker(m_optionWidget);
 
     KisNodeSP node = m_resourceProvider->currentNode();
 
     if (node && node->paintDevice()) {
         if (!node->paintDevice()->colorSpace()->hasCompositeOp(compositeOpID))
             compositeOpID = KoCompositeOpRegistry::instance().getDefaultCompositeOp().id();
 
         {
             KisSignalsBlocker b1(m_cmbCompositeOp);
             m_cmbCompositeOp->selectCompositeOp(KoID(compositeOpID));
         }
         if (compositeOpID != m_currCompositeOpID) {
             m_currCompositeOpID = compositeOpID;
         }
         if (compositeOpID == COMPOSITE_ERASE || m_resourceProvider->eraserMode()) {
             m_eraseModeButton->setChecked(true);
         }
         else {
             m_eraseModeButton->setChecked(false);
         }
     }
     else if (!node) {
         KisSignalsBlocker b1(m_cmbCompositeOp);
         m_cmbCompositeOp->selectCompositeOp(KoID(compositeOpID));
         m_currCompositeOpID = compositeOpID;
 
     }
 }
 
 void KisPaintopBox::setWidgetState(int flags)
 {
     if (flags & (ENABLE_COMPOSITEOP | DISABLE_COMPOSITEOP)) {
         m_cmbCompositeOp->setEnabled(flags & ENABLE_COMPOSITEOP);
         m_eraseModeButton->setEnabled(flags & ENABLE_COMPOSITEOP);
     }
 
     if (flags & (ENABLE_PRESETS | DISABLE_PRESETS)) {
         m_presetSelectorPopupButton->setEnabled(flags & ENABLE_PRESETS);
         m_brushEditorPopupButton->setEnabled(flags & ENABLE_PRESETS);
     }
 
     for (int i = 0; i < 3; ++i) {
         if (flags & (ENABLE_OPACITY | DISABLE_OPACITY))
             m_sliderChooser[i]->getWidget("opacity")->setEnabled(flags & ENABLE_OPACITY);
 
         if (flags & (ENABLE_FLOW | DISABLE_FLOW))
             m_sliderChooser[i]->getWidget("flow")->setEnabled(flags & ENABLE_FLOW);
 
         if (flags & (ENABLE_SIZE | DISABLE_SIZE))
             m_sliderChooser[i]->getWidget("size")->setEnabled(flags & ENABLE_SIZE);
     }
 }
 
 void KisPaintopBox::setSliderValue(const QString& sliderID, qreal value)
 {
     for (int i = 0; i < 3; ++i) {
         KisDoubleSliderSpinBox* slider = m_sliderChooser[i]->getWidget<KisDoubleSliderSpinBox>(sliderID);
         KisSignalsBlocker b(slider);
 
         if (sliderID == "opacity" || sliderID == "flow") { // opacity and flows UI stored at 0-100%
             slider->setValue(value*100);
         } else {
             slider->setValue(value); // brush size
         }
 
 
     }
 }
 
 void KisPaintopBox::slotSetPaintop(const QString& paintOpId)
 {
     if (KisPaintOpRegistry::instance()->get(paintOpId) != 0) {
         KoID id(paintOpId, KisPaintOpRegistry::instance()->get(paintOpId)->name());
         //qDebug() << "slotsetpaintop" << id;
         setCurrentPaintop(id);
     }
 }
 
 void KisPaintopBox::slotInputDeviceChanged(const KoInputDevice& inputDevice)
 {
     TabletToolMap::iterator toolData = m_tabletToolMap.find(inputDevice);
 
     //qDebug() << "slotInputDeviceChanged()" << inputDevice.device() << inputDevice.uniqueTabletId();
 
     m_currTabletToolID = TabletToolID(inputDevice);
 
     if (toolData == m_tabletToolMap.end()) {
         KisConfig cfg(true);
         KisPaintOpPresetResourceServer *rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
         KisPaintOpPresetSP preset;
         if (inputDevice.pointer() == QTabletEvent::Eraser) {
             preset = rserver->resourceByName(cfg.readEntry<QString>(QString("LastEraser_%1").arg(inputDevice.uniqueTabletId()), m_eraserName));
         }
         else {
             preset = rserver->resourceByName(cfg.readEntry<QString>(QString("LastPreset_%1").arg(inputDevice.uniqueTabletId()), m_defaultPresetName));
             //if (preset)
                 //qDebug() << "found stored preset " << preset->name() << "for" << inputDevice.uniqueTabletId();
             //else
                 //qDebug() << "no preset found for" << inputDevice.uniqueTabletId();
         }
         if (!preset) {
             preset = rserver->resourceByName(m_defaultPresetName);
         }
         if (preset) {
             //qDebug() << "inputdevicechanged 1" << preset;
             setCurrentPaintop(preset);
         }
     }
     else {
         if (toolData->preset) {
             //qDebug() << "inputdevicechanged 2" << toolData->preset;
             setCurrentPaintop(toolData->preset);
         }
         else {
             //qDebug() << "inputdevicechanged 3" << toolData->paintOpID;
             setCurrentPaintop(toolData->paintOpID);
         }
     }
 }
 
 void KisPaintopBox::slotCreatePresetFromScratch(QString paintop)
 {
     //First try to select an available default preset for that engine. If it doesn't exist, then
     //manually set the engine to use a new preset.
     KoID id(paintop, KisPaintOpRegistry::instance()->get(paintop)->name());
     KisPaintOpPresetSP preset = defaultPreset(id);
 
     slotSetPaintop(paintop);  // change the paintop settings area and update the UI
 
     if (!preset) {
         m_presetsPopup->setCreatingBrushFromScratch(true); // disable UI elements while creating from scratch
         preset = m_resourceProvider->currentPreset();
     } else {
         m_resourceProvider->setPaintOpPreset(preset);
         preset->setOptionsWidget(m_optionWidget);
     }
     m_presetsPopup->resourceSelected(preset.data());  // this helps update the UI on the brush editor
 }
 
 void KisPaintopBox::slotCanvasResourceChanged(int key, const QVariant &value)
 {
     if (m_viewManager) {
         sender()->blockSignals(true);
         KisPaintOpPresetSP preset = m_viewManager->canvasResourceProvider()->resourceManager()->resource(KisCanvasResourceProvider::CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
         if (preset && m_resourceProvider->currentPreset()->name() != preset->name()) {
             QString compositeOp = preset->settings()->getString("CompositeOp");
             updateCompositeOp(compositeOp);
             resourceSelected(preset.data());
         }
 
         /**
          * Update currently selected preset in both the popup widgets
          */
         m_presetsChooserPopup->canvasResourceChanged(preset);
 
         m_presetsPopup->currentPresetChanged(preset);
 
         if (key == KisCanvasResourceProvider::CurrentCompositeOp) {
             if (m_resourceProvider->currentCompositeOp() != m_currCompositeOpID) {
                 updateCompositeOp(m_resourceProvider->currentCompositeOp());
             }
         }
 
         if (key == KisCanvasResourceProvider::Size) {
             setSliderValue("size", m_resourceProvider->size());
         }
 
         if (key == KisCanvasResourceProvider::Opacity) {
             setSliderValue("opacity", m_resourceProvider->opacity());
         }
 
         if (key == KisCanvasResourceProvider::Flow) {
             setSliderValue("flow", m_resourceProvider->flow());
         }
 
         if (key == KisCanvasResourceProvider::EraserMode) {
             m_eraseAction->setChecked(value.toBool());
         }
 
         if (key == KisCanvasResourceProvider::DisablePressure) {
             m_disablePressureAction->setChecked(value.toBool());
         }
 
         if (key == KisCanvasResourceProvider::MirrorHorizontal) {
             m_hMirrorAction->setChecked(value.toBool());
         }
 
         if (key == KisCanvasResourceProvider::MirrorVertical) {
             m_vMirrorAction->setChecked(value.toBool());
         }
 
         sender()->blockSignals(false);
     }
 }
 
 void KisPaintopBox::slotSetupDefaultPreset()
 {
     KisPaintOpPresetSP preset = defaultPreset(m_resourceProvider->currentPreset()->paintOp());
     preset->setOptionsWidget(m_optionWidget);
     m_resourceProvider->setPaintOpPreset(preset);
 
     // tell the brush editor that the resource has changed
     // so it can update everything
     m_presetsPopup->resourceSelected(preset.data());
 }
 
 void KisPaintopBox::slotNodeChanged(const KisNodeSP node)
 {
     if (m_previousNode.isValid() && m_previousNode->paintDevice())
         disconnect(m_previousNode->paintDevice().data(), SIGNAL(colorSpaceChanged(const KoColorSpace*)), this, SLOT(slotColorSpaceChanged(const KoColorSpace*)));
 
     // Reconnect colorspace change of node
     if (node && node->paintDevice()) {
         connect(node->paintDevice().data(), SIGNAL(colorSpaceChanged(const KoColorSpace*)), this, SLOT(slotColorSpaceChanged(const KoColorSpace*)));
         m_resourceProvider->setCurrentCompositeOp(m_currCompositeOpID);
         m_previousNode = node;
         slotColorSpaceChanged(node->colorSpace());
     }
 
     if (m_optionWidget) {
         m_optionWidget->setNode(node);
     }
 }
 
 void KisPaintopBox::slotColorSpaceChanged(const KoColorSpace* colorSpace)
 {
     m_cmbCompositeOp->validate(colorSpace);
 }
 
 void KisPaintopBox::slotToggleEraseMode(bool checked)
 {
     const bool oldEraserMode = m_resourceProvider->eraserMode();
     m_resourceProvider->setEraserMode(checked);
 
     if (oldEraserMode != checked && m_eraserBrushSizeEnabled) {
         const qreal currentSize = m_resourceProvider->size();
 
         KisPaintOpSettingsSP settings = m_resourceProvider->currentPreset()->settings();
 
         // remember brush size. set the eraser size to the normal brush size if not set
         if (checked) {
             settings->setSavedBrushSize(currentSize);
             if (qFuzzyIsNull(settings->savedEraserSize())) {
                 settings->setSavedEraserSize(currentSize);
             }
         } else {
             settings->setSavedEraserSize(currentSize);
             if (qFuzzyIsNull(settings->savedBrushSize())) {
                 settings->setSavedBrushSize(currentSize);
             }
         }
 
         //update value in UI (this is the main place the value is 'stored' in memory)
         qreal newSize = checked ? settings->savedEraserSize() : settings->savedBrushSize();
         m_resourceProvider->setSize(newSize);
     }
    if (oldEraserMode != checked && m_eraserBrushOpacityEnabled) {
         const qreal currentOpacity = m_resourceProvider->opacity();
 
         KisPaintOpSettingsSP settings = m_resourceProvider->currentPreset()->settings();
 
         // remember brush opacity. set the eraser opacity to the normal brush opacity if not set
         if (checked) {
             settings->setSavedBrushOpacity(currentOpacity);
             if (qFuzzyIsNull(settings->savedEraserOpacity())) {
                 settings->setSavedEraserOpacity(currentOpacity);
             }
         } else {
             settings->setSavedEraserOpacity(currentOpacity);
             if (qFuzzyIsNull(settings->savedBrushOpacity())) {
                 settings->setSavedBrushOpacity(currentOpacity);
             }
         }
 
         //update value in UI (this is the main place the value is 'stored' in memory)
         qreal newOpacity = checked ? settings->savedEraserOpacity() : settings->savedBrushOpacity();
         m_resourceProvider->setOpacity(newOpacity);
     }
 }
 
 void KisPaintopBox::slotSetCompositeMode(int index)
 {
     Q_UNUSED(index);
     QString compositeOp = m_cmbCompositeOp->selectedCompositeOp().id();
     m_resourceProvider->setCurrentCompositeOp(compositeOp);
 }
 
 void KisPaintopBox::slotHorizontalMirrorChanged(bool value)
 {
     m_resourceProvider->setMirrorHorizontal(value);
 }
 
 void KisPaintopBox::slotVerticalMirrorChanged(bool value)
 {
     m_resourceProvider->setMirrorVertical(value);
 }
 
 void KisPaintopBox::sliderChanged(int n)
 {
     if (!m_optionWidget) // widget will not exist if the are no documents open
         return;
 
 
     KisSignalsBlocker blocker(m_optionWidget);
 
     // flow and opacity are shown as 0-100% on the UI, but their data is actually 0-1. Convert those two values
     // back for further work
     qreal opacity = m_sliderChooser[n]->getWidget<KisDoubleSliderSpinBox>("opacity")->value()/100;
     qreal flow    = m_sliderChooser[n]->getWidget<KisDoubleSliderSpinBox>("flow")->value()/100;
     qreal size    = m_sliderChooser[n]->getWidget<KisDoubleSliderSpinBox>("size")->value();
 
 
     setSliderValue("opacity", opacity);
     setSliderValue("flow"   , flow);
     setSliderValue("size"   , size);
 
     if (m_presetsEnabled) {
         // IMPORTANT: set the PaintOp size before setting the other properties
         //            it won't work the other way
         // TODO: why?!
 
         m_resourceProvider->setSize(size);
         m_resourceProvider->setOpacity(opacity);
         m_resourceProvider->setFlow(flow);
 
 
         KisLockedPropertiesProxySP propertiesProxy = KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(m_resourceProvider->currentPreset()->settings());
         propertiesProxy->setProperty("OpacityValue", opacity);
         propertiesProxy->setProperty("FlowValue", flow);
         m_optionWidget->setConfigurationSafe(m_resourceProvider->currentPreset()->settings().data());
     } else {
         m_resourceProvider->setOpacity(opacity);
     }
 
     m_presetsPopup->resourceSelected(m_resourceProvider->currentPreset().data());
 }
 
 void KisPaintopBox::slotSlider1Changed()
 {
     sliderChanged(0);
 }
 
 void KisPaintopBox::slotSlider2Changed()
 {
     sliderChanged(1);
 }
 
 void KisPaintopBox::slotSlider3Changed()
 {
     sliderChanged(2);
 }
 
 void KisPaintopBox::slotToolChanged(KoCanvasController* canvas, int toolId)
 {
     Q_UNUSED(canvas);
     Q_UNUSED(toolId);
 
     if (!m_viewManager->canvasBase()) return;
 
     QString  id   = KoToolManager::instance()->activeToolId();
     KisTool* tool = dynamic_cast<KisTool*>(KoToolManager::instance()->toolById(m_viewManager->canvasBase(), id));
 
     if (tool) {
         int flags = tool->flags();
 
         if (flags & KisTool::FLAG_USES_CUSTOM_COMPOSITEOP) {
             setWidgetState(ENABLE_COMPOSITEOP | ENABLE_OPACITY);
         } else                                              {
             setWidgetState(DISABLE_COMPOSITEOP | DISABLE_OPACITY);
         }
 
         if (flags & KisTool::FLAG_USES_CUSTOM_PRESET) {
             setWidgetState(ENABLE_PRESETS);
             if (!m_resourceProvider->currentPreset()) return;
 
             // block updates of avoid some over updating of the option widget
             m_blockUpdate = true;
 
             setSliderValue("size", m_resourceProvider->size());
 
             {
                 qreal opacity = m_resourceProvider->currentPreset()->settings()->paintOpOpacity();
                 m_resourceProvider->setOpacity(opacity);
                 setSliderValue("opacity", opacity);
                 setWidgetState(ENABLE_OPACITY);
             }
 
             {
                 setSliderValue("flow", m_resourceProvider->currentPreset()->settings()->paintOpFlow());
                 setWidgetState(ENABLE_FLOW);
             }
 
             {
                 updateCompositeOp(m_resourceProvider->currentPreset()->settings()->paintOpCompositeOp());
                 setWidgetState(ENABLE_COMPOSITEOP);
             }
 
             m_blockUpdate = false;
 
             m_presetsEnabled = true;
         } else {
             setWidgetState(DISABLE_PRESETS);
             m_presetsEnabled = false;
         }
 
         if (flags & KisTool::FLAG_USES_CUSTOM_SIZE) {
             setWidgetState(ENABLE_SIZE | ENABLE_FLOW);
         } else {
             setWidgetState(DISABLE_SIZE | DISABLE_FLOW);
         }
 
     } else setWidgetState(DISABLE_ALL);
 }
 
 void KisPaintopBox::slotPreviousFavoritePreset()
 {
     if (!m_favoriteResourceManager) return;
 
     QVector<KisPaintOpPresetSP> presets = m_favoriteResourceManager->favoritePresetList();
     for (int i=0; i < presets.size(); ++i) {
         if (m_resourceProvider->currentPreset() &&
                 m_resourceProvider->currentPreset()->name() == presets[i]->name()) {
             if (i > 0) {
                 m_favoriteResourceManager->slotChangeActivePaintop(i - 1);
             } else {
                 m_favoriteResourceManager->slotChangeActivePaintop(m_favoriteResourceManager->numFavoritePresets() - 1);
             }
             //floating message should have least 2 lines, otherwise
             //preset thumbnail will be too small to distinguish
             //(because size of image on floating message depends on amount of lines in msg)
             m_viewManager->showFloatingMessage(
                 i18n("%1\nselected",
                         m_resourceProvider->currentPreset()->name()),
                 QIcon(QPixmap::fromImage(m_resourceProvider->currentPreset()->image())));
 
             return;
         }
     }
 }
 
 void KisPaintopBox::slotNextFavoritePreset()
 {
     if (!m_favoriteResourceManager) return;
 
     QVector<KisPaintOpPresetSP> presets = m_favoriteResourceManager->favoritePresetList();
     for(int i = 0; i < presets.size(); ++i) {
         if (m_resourceProvider->currentPreset()->name() == presets[i]->name()) {
             if (i < m_favoriteResourceManager->numFavoritePresets() - 1) {
                 m_favoriteResourceManager->slotChangeActivePaintop(i + 1);
             } else {
                 m_favoriteResourceManager->slotChangeActivePaintop(0);
             }
             m_viewManager->showFloatingMessage(
                 i18n("%1\nselected",
                         m_resourceProvider->currentPreset()->name()),
                 QIcon(QPixmap::fromImage(m_resourceProvider->currentPreset()->image())));
 
             return;
         }
     }
 }
 
 void KisPaintopBox::slotSwitchToPreviousPreset()
 {
     if (m_resourceProvider->previousPreset()) {
         //qDebug() << "slotSwitchToPreviousPreset();" << m_resourceProvider->previousPreset();
         setCurrentPaintop(m_resourceProvider->previousPreset());
         m_viewManager->showFloatingMessage(
                 i18n("%1\nselected",
                         m_resourceProvider->currentPreset()->name()),
             QIcon(QPixmap::fromImage(m_resourceProvider->currentPreset()->image())));
     }
 }
 
 void KisPaintopBox::slotUnsetEraseMode()
 {
     m_eraseAction->setChecked(false);
 }
 
 void KisPaintopBox::slotToggleAlphaLockMode(bool checked)
 {
     if (checked) {
         m_alphaLockButton->actions()[0]->setIcon(KisIconUtils::loadIcon("transparency-locked"));
     } else {
         m_alphaLockButton->actions()[0]->setIcon(KisIconUtils::loadIcon("transparency-unlocked"));
     }
     m_resourceProvider->setGlobalAlphaLock(checked);
 }
 
 void KisPaintopBox::slotDisablePressureMode(bool checked)
 {
     if (checked) {
         m_disablePressureAction->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure"));
     } else {
         m_disablePressureAction->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure_locked"));
     }
 
     m_resourceProvider->setDisablePressure(checked);
 }
 
 void KisPaintopBox::slotReloadPreset()
 {
     KisSignalsBlocker blocker(m_optionWidget);
 
     //Here using the name and fetching the preset from the server was the only way the load was working. Otherwise it was not loading.
     KisPaintOpPresetResourceServer * rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
     KisPaintOpPresetSP preset = rserver->resourceByName(m_resourceProvider->currentPreset()->name());
     if (preset) {
         preset->load();
     }
 
     if (m_resourceProvider->currentPreset() != preset) {
         m_resourceProvider->setPaintOpPreset(preset);
     } else {
         /**
          * HACK ALERT: here we emit a private signal from the resource manager to
          * ensure that all the subscribers of resource-changed signal got the
          * notification. That is especially important for
          * KisPaintopTransformationConnector. See bug 392622.
          */
 
         emit m_resourceProvider->resourceManager()->canvasResourceChanged(
             KisCanvasResourceProvider::CurrentPaintOpPreset,
             QVariant::fromValue(preset));
     }
 }
 void KisPaintopBox::slotGuiChangedCurrentPreset() // Called only when UI is changed and not when preset is changed
 {
     KisPaintOpPresetSP preset = m_resourceProvider->currentPreset();
 
     {
         /**
          * Here we postpone all the settings updates events until the entire writing
          * operation will be finished. As soon as it is finished, the updates will be
          * emitted happily (if there were any).
          */
 
         KisPaintOpPreset::UpdatedPostponer postponer(preset.data());
 
 
         QStringList preserveProperties;
         preserveProperties << "lodUserAllowed";
         preserveProperties << "lodSizeThreshold";
 
         // clear all the properties before dumping the stuff into the preset,
         // some of the options add the values incrementally
         // (e.g. KisPaintOpUtils::RequiredBrushFilesListTag), therefore they
         // may add up if we pass the same preset multiple times
         preset->settings()->resetSettings(preserveProperties);
 
         m_optionWidget->writeConfigurationSafe(const_cast<KisPaintOpSettings*>(preset->settings().data()));
     }
 
     // we should also update the preset strip to update the status of the "dirty" mark
     m_presetsPopup->resourceSelected(m_resourceProvider->currentPreset().data());
 
     // TODO!!!!!!!!
     //m_presetsPopup->updateViewSettings();
 }
 void KisPaintopBox::slotSaveLockedOptionToPreset(KisPropertiesConfigurationSP p)
 {
 
     QMapIterator<QString, QVariant> i(p->getProperties());
     while (i.hasNext()) {
         i.next();
         m_resourceProvider->currentPreset()->settings()->setProperty(i.key(), QVariant(i.value()));
         if (m_resourceProvider->currentPreset()->settings()->hasProperty(i.key() + "_previous")) {
             m_resourceProvider->currentPreset()->settings()->removeProperty(i.key() + "_previous");
         }
 
     }
     slotGuiChangedCurrentPreset();
 
 }
 
 void KisPaintopBox::slotDropLockedOption(KisPropertiesConfigurationSP p)
 {
     KisSignalsBlocker blocker(m_optionWidget);
     KisPaintOpPresetSP preset = m_resourceProvider->currentPreset();
 
     {
         KisPaintOpPreset::DirtyStateSaver dirtySaver(preset.data());
 
         QMapIterator<QString, QVariant> i(p->getProperties());
         while (i.hasNext()) {
             i.next();
             if (preset->settings()->hasProperty(i.key() + "_previous")) {
                 preset->settings()->setProperty(i.key(), preset->settings()->getProperty(i.key() + "_previous"));
                 preset->settings()->removeProperty(i.key() + "_previous");
             }
 
         }
     }
 
 }
 void KisPaintopBox::slotDirtyPresetToggled(bool value)
 {
     if (!value) {
         slotReloadPreset();
         m_presetsPopup->resourceSelected(m_resourceProvider->currentPreset().data());
         m_presetsPopup->updateViewSettings();
     }
     m_dirtyPresetsEnabled = value;
     KisConfig cfg(false);
     cfg.setUseDirtyPresets(m_dirtyPresetsEnabled);
 
 }
 void KisPaintopBox::slotEraserBrushSizeToggled(bool value)
 {
     m_eraserBrushSizeEnabled = value;
     KisConfig cfg(false);
     cfg.setUseEraserBrushSize(m_eraserBrushSizeEnabled);
 }
 
 void KisPaintopBox::slotEraserBrushOpacityToggled(bool value)
 {
     m_eraserBrushOpacityEnabled = value;
     KisConfig cfg(false);
     cfg.setUseEraserBrushOpacity(m_eraserBrushOpacityEnabled);
 }
 
 void KisPaintopBox::slotUpdateSelectionIcon()
 {
     m_hMirrorAction->setIcon(KisIconUtils::loadIcon("symmetry-horizontal"));
     m_vMirrorAction->setIcon(KisIconUtils::loadIcon("symmetry-vertical"));
 
     KisConfig cfg(true);
     if (!cfg.toolOptionsInDocker() && m_toolOptionsPopupButton) {
         m_toolOptionsPopupButton->setIcon(KisIconUtils::loadIcon("configure"));
     }
 
     m_presetSelectorPopupButton->setIcon(KisIconUtils::loadIcon("paintop_settings_01"));
     m_brushEditorPopupButton->setIcon(KisIconUtils::loadIcon("paintop_settings_02"));
     m_workspaceWidget->setIcon(KisIconUtils::loadIcon("view-choose"));
 
     m_eraseAction->setIcon(KisIconUtils::loadIcon("draw-eraser"));
     m_reloadAction->setIcon(KisIconUtils::loadIcon("view-refresh"));
 
     if (m_disablePressureAction->isChecked()) {
         m_disablePressureAction->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure"));
     } else {
         m_disablePressureAction->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure_locked"));
     }
 }
 
 void KisPaintopBox::slotLockXMirrorToggle(bool toggleLock) {
     m_resourceProvider->setMirrorHorizontalLock(toggleLock);
 }
 
 void KisPaintopBox::slotLockYMirrorToggle(bool toggleLock) {
     m_resourceProvider->setMirrorVerticalLock(toggleLock);
 }
 
 void KisPaintopBox::slotHideDecorationMirrorX(bool toggled) {
     m_resourceProvider->setMirrorHorizontalHideDecorations(toggled);
 }
 
 void KisPaintopBox::slotHideDecorationMirrorY(bool toggled) {
     m_resourceProvider->setMirrorVerticalHideDecorations(toggled);
 }
 
 void KisPaintopBox::slotMoveToCenterMirrorX() {
   m_resourceProvider->mirrorHorizontalMoveCanvasToCenter();
 }
 
 void KisPaintopBox::slotMoveToCenterMirrorY() {
   m_resourceProvider->mirrorVerticalMoveCanvasToCenter();
 }
diff --git a/libs/ui/layerstyles/WdgColorOverlay.ui b/libs/ui/layerstyles/WdgColorOverlay.ui
index 8c71bf73a5..90aec95387 100644
--- a/libs/ui/layerstyles/WdgColorOverlay.ui
+++ b/libs/ui/layerstyles/WdgColorOverlay.ui
@@ -1,136 +1,136 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgColorOverlay</class>
  <widget class="QWidget" name="WdgColorOverlay">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>400</width>
     <height>300</height>
    </rect>
   </property>
   <layout class="QGridLayout" name="gridLayout">
    <item row="0" column="0">
     <widget class="QGroupBox" name="groupBox">
      <property name="title">
       <string>Color Overlay</string>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout">
       <item>
        <widget class="QGroupBox" name="groupBox_2">
         <property name="title">
          <string>Color</string>
         </property>
         <layout class="QFormLayout" name="formLayout">
          <property name="fieldGrowthPolicy">
           <enum>QFormLayout::AllNonFixedFieldsGrow</enum>
          </property>
          <item row="0" column="0">
           <widget class="QLabel" name="label_13">
            <property name="text">
             <string>Ble&amp;nd Mode:</string>
            </property>
            <property name="buddy">
             <cstring>cmbCompositeOp</cstring>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <layout class="QHBoxLayout" name="horizontalLayout">
            <item>
-            <widget class="KisCompositeOpComboBox" name="cmbCompositeOp">
+            <widget class="KisLayerStyleCompositeOpComboBox" name="cmbCompositeOp">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
              <property name="toolTip">
               <string>Set the blend mode for the layer</string>
              </property>
             </widget>
            </item>
            <item>
             <widget class="KisColorButton" name="bnColor">
              <property name="text">
               <string>...</string>
              </property>
             </widget>
            </item>
           </layout>
          </item>
          <item row="1" column="0">
           <widget class="QLabel" name="label_14">
            <property name="text">
             <string>&amp;Opacity:</string>
            </property>
            <property name="buddy">
             <cstring>intOpacity</cstring>
            </property>
           </widget>
          </item>
          <item row="1" column="1">
           <widget class="KisSliderSpinBox" name="intOpacity" native="true">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Minimum">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="minimumSize">
             <size>
              <width>10</width>
              <height>15</height>
             </size>
            </property>
            <property name="toolTip">
             <string>Set the master opacity for the layer</string>
            </property>
            <property name="whatsThis">
             <string>Adjust the transparency of the layer</string>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item>
        <spacer name="verticalSpacer">
         <property name="orientation">
          <enum>Qt::Vertical</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>20</width>
           <height>151</height>
          </size>
         </property>
        </spacer>
       </item>
      </layout>
     </widget>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KisColorButton</class>
    <extends>QPushButton</extends>
    <header>kis_color_button.h</header>
   </customwidget>
   <customwidget>
    <class>KisSliderSpinBox</class>
    <extends>QWidget</extends>
    <header location="global">kis_slider_spin_box.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
-   <class>KisCompositeOpComboBox</class>
+   <class>KisLayerStyleCompositeOpComboBox</class>
    <extends>QComboBox</extends>
    <header location="global">kis_cmb_composite.h</header>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/libs/ui/layerstyles/WdgGradientOverlay.ui b/libs/ui/layerstyles/WdgGradientOverlay.ui
index 0bf1218d5a..d6ee60a257 100644
--- a/libs/ui/layerstyles/WdgGradientOverlay.ui
+++ b/libs/ui/layerstyles/WdgGradientOverlay.ui
@@ -1,284 +1,284 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgGradientOverlay</class>
  <widget class="QWidget" name="WdgGradientOverlay">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>473</width>
     <height>358</height>
    </rect>
   </property>
   <layout class="QGridLayout" name="gridLayout">
    <item row="0" column="0">
     <widget class="QGroupBox" name="groupBox">
      <property name="title">
       <string>Gradient Overlay</string>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout">
       <item>
        <widget class="QGroupBox" name="groupBox_2">
         <property name="title">
          <string>Gradient</string>
         </property>
         <layout class="QFormLayout" name="formLayout">
          <item row="0" column="0">
           <widget class="QLabel" name="label_13">
            <property name="text">
             <string>Ble&amp;nd Mode:</string>
            </property>
            <property name="buddy">
             <cstring>cmbCompositeOp</cstring>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
-          <widget class="KisCompositeOpComboBox" name="cmbCompositeOp">
+          <widget class="KisLayerStyleCompositeOpComboBox" name="cmbCompositeOp">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="toolTip">
             <string>Set the blend mode for the layer</string>
            </property>
           </widget>
          </item>
          <item row="1" column="0">
           <widget class="QLabel" name="label_14">
            <property name="text">
             <string>Opac&amp;ity:</string>
            </property>
            <property name="buddy">
             <cstring>intOpacity</cstring>
            </property>
           </widget>
          </item>
          <item row="1" column="1">
           <widget class="KisSliderSpinBox" name="intOpacity" native="true">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Minimum">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="minimumSize">
             <size>
              <width>10</width>
              <height>15</height>
             </size>
            </property>
            <property name="toolTip">
             <string>Set the master opacity for the layer</string>
            </property>
            <property name="whatsThis">
             <string>Adjust the transparency of the layer</string>
            </property>
           </widget>
          </item>
          <item row="2" column="0">
           <widget class="QLabel" name="label_7">
            <property name="text">
             <string>&amp;Gradient:</string>
            </property>
            <property name="buddy">
             <cstring>cmbGradient</cstring>
            </property>
           </widget>
          </item>
          <item row="2" column="1">
           <layout class="QHBoxLayout" name="horizontalLayout_3">
            <item>
             <widget class="KisCmbGradient" name="cmbGradient">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
                <horstretch>11</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
             </widget>
            </item>
            <item>
             <widget class="QCheckBox" name="chkReverse">
              <property name="text">
               <string>&amp;Reverse</string>
              </property>
             </widget>
            </item>
           </layout>
          </item>
          <item row="3" column="0">
           <widget class="QLabel" name="label_6">
            <property name="text">
             <string>St&amp;yle:</string>
            </property>
            <property name="buddy">
             <cstring>cmbStyle</cstring>
            </property>
           </widget>
          </item>
          <item row="3" column="1">
           <layout class="QHBoxLayout" name="horizontalLayout_4">
            <item>
             <widget class="QComboBox" name="cmbStyle">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
              <item>
               <property name="text">
                <string>Linear</string>
               </property>
              </item>
              <item>
               <property name="text">
                <string>Radial</string>
               </property>
              </item>
              <item>
               <property name="text">
                <string comment="@item:inlistbox Gradient style">Angle</string>
               </property>
              </item>
              <item>
               <property name="text">
                <string>Reflected</string>
               </property>
              </item>
              <item>
               <property name="text">
                <string>Diamond</string>
               </property>
              </item>
             </widget>
            </item>
            <item>
             <widget class="QCheckBox" name="chkAlignWithLayer">
              <property name="text">
               <string>Ali&amp;gn with Layer</string>
              </property>
             </widget>
            </item>
           </layout>
          </item>
          <item row="4" column="0">
           <widget class="QLabel" name="label_9">
            <property name="text">
             <string>&amp;Angle:</string>
            </property>
            <property name="buddy">
             <cstring>angleSelector</cstring>
            </property>
           </widget>
          </item>
          <item row="6" column="0">
           <widget class="QLabel" name="label_8">
            <property name="text">
             <string>S&amp;cale:</string>
            </property>
            <property name="buddy">
             <cstring>intScale</cstring>
            </property>
           </widget>
          </item>
          <item row="6" column="1">
           <widget class="KisSliderSpinBox" name="intScale" native="true">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="toolTip">
             <string>Set size of gradation</string>
            </property>
           </widget>
          </item>
          <item row="4" column="1">
           <layout class="QHBoxLayout" name="horizontalLayout">
            <item>
             <widget class="KisLayerStyleAngleSelector" name="angleSelector" native="true">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
             </widget>
            </item>
            <item>
             <spacer name="horizontalSpacer">
              <property name="orientation">
               <enum>Qt::Horizontal</enum>
              </property>
              <property name="sizeHint" stdset="0">
               <size>
                <width>40</width>
                <height>20</height>
               </size>
              </property>
             </spacer>
            </item>
           </layout>
          </item>
         </layout>
         <zorder>label_6</zorder>
         <zorder>intScale</zorder>
         <zorder>label_9</zorder>
         <zorder>label_7</zorder>
         <zorder>label_8</zorder>
         <zorder>cmbCompositeOp</zorder>
         <zorder>intOpacity</zorder>
         <zorder>label_13</zorder>
         <zorder>label_14</zorder>
        </widget>
       </item>
       <item>
        <spacer name="verticalSpacer">
         <property name="orientation">
          <enum>Qt::Vertical</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>20</width>
           <height>40</height>
          </size>
         </property>
        </spacer>
       </item>
      </layout>
     </widget>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KisSliderSpinBox</class>
    <extends>QWidget</extends>
    <header location="global">kis_slider_spin_box.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
-   <class>KisCompositeOpComboBox</class>
+   <class>KisLayerStyleCompositeOpComboBox</class>
    <extends>QComboBox</extends>
    <header location="global">kis_cmb_composite.h</header>
   </customwidget>
   <customwidget>
    <class>KisLayerStyleAngleSelector</class>
    <extends>QWidget</extends>
    <header>KisLayerStyleAngleSelector.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>KisCmbGradient</class>
    <extends>QToolButton</extends>
    <header>kis_cmb_gradient.h</header>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/libs/ui/layerstyles/WdgPatternOverlay.ui b/libs/ui/layerstyles/WdgPatternOverlay.ui
index b8de5af6fe..51d974dcde 100644
--- a/libs/ui/layerstyles/WdgPatternOverlay.ui
+++ b/libs/ui/layerstyles/WdgPatternOverlay.ui
@@ -1,190 +1,190 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgPatternOverlay</class>
  <widget class="QWidget" name="WdgPatternOverlay">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>400</width>
-    <height>461</height>
+    <width>408</width>
+    <height>487</height>
    </rect>
   </property>
   <layout class="QGridLayout" name="gridLayout">
    <item row="0" column="0">
     <widget class="QGroupBox" name="groupBox">
      <property name="title">
       <string>Pattern Overlay</string>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_2">
       <item>
        <widget class="QGroupBox" name="groupBox_2">
         <property name="title">
          <string comment="@title:group In Layer Style">Pattern</string>
         </property>
         <layout class="QFormLayout" name="formLayout">
          <property name="fieldGrowthPolicy">
           <enum>QFormLayout::AllNonFixedFieldsGrow</enum>
          </property>
          <item row="0" column="0">
           <widget class="QLabel" name="label_13">
            <property name="text">
             <string>Ble&amp;nd Mode:</string>
            </property>
            <property name="buddy">
             <cstring>cmbCompositeOp</cstring>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
-          <widget class="KisCompositeOpComboBox" name="cmbCompositeOp">
+          <widget class="KisLayerStyleCompositeOpComboBox" name="cmbCompositeOp">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="toolTip">
             <string>Set the blend mode for the layer</string>
            </property>
           </widget>
          </item>
          <item row="1" column="0">
           <widget class="QLabel" name="label_14">
            <property name="text">
             <string>&amp;Opacity:</string>
            </property>
            <property name="buddy">
             <cstring>intOpacity</cstring>
            </property>
           </widget>
          </item>
          <item row="1" column="1">
           <widget class="KisSliderSpinBox" name="intOpacity" native="true">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Minimum">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="minimumSize">
             <size>
              <width>10</width>
              <height>15</height>
             </size>
            </property>
            <property name="toolTip">
             <string>Set the master opacity for the layer</string>
            </property>
            <property name="whatsThis">
             <string>Adjust the transparency of the layer</string>
            </property>
           </widget>
          </item>
          <item row="2" column="0">
           <widget class="QLabel" name="label">
            <property name="text">
             <string>Pattern:</string>
            </property>
           </widget>
          </item>
          <item row="2" column="1">
           <layout class="QVBoxLayout" name="verticalLayout">
            <item>
             <widget class="KisPatternChooser" name="patternChooser">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
              <property name="minimumSize">
               <size>
                <width>250</width>
                <height>250</height>
               </size>
              </property>
              <property name="frameShape">
               <enum>QFrame::StyledPanel</enum>
              </property>
              <property name="frameShadow">
               <enum>QFrame::Raised</enum>
              </property>
             </widget>
            </item>
            <item>
             <widget class="QPushButton" name="bnSnapToOrigin">
              <property name="text">
               <string>Sn&amp;ap to Origin</string>
              </property>
             </widget>
            </item>
           </layout>
          </item>
          <item row="5" column="0">
           <widget class="QLabel" name="label_8">
            <property name="text">
             <string>S&amp;cale:</string>
            </property>
            <property name="buddy">
             <cstring>intScale</cstring>
            </property>
           </widget>
          </item>
          <item row="5" column="1">
           <widget class="KisSliderSpinBox" name="intScale" native="true">
            <property name="toolTip">
             <string>Set size of gradation</string>
            </property>
           </widget>
          </item>
          <item row="4" column="1">
           <widget class="QCheckBox" name="chkLinkWithLayer">
            <property name="text">
             <string>Li&amp;nk with layer</string>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item>
        <spacer name="verticalSpacer">
         <property name="orientation">
          <enum>Qt::Vertical</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>20</width>
           <height>40</height>
          </size>
         </property>
        </spacer>
       </item>
      </layout>
     </widget>
    </item>
   </layout>
  </widget>
  <customwidgets>
-  <customwidget>
-   <class>KisCompositeOpComboBox</class>
-   <extends>QComboBox</extends>
-   <header location="global">kis_cmb_composite.h</header>
-  </customwidget>
   <customwidget>
    <class>KisSliderSpinBox</class>
    <extends>QWidget</extends>
    <header location="global">kis_slider_spin_box.h</header>
    <container>1</container>
   </customwidget>
+  <customwidget>
+   <class>KisLayerStyleCompositeOpComboBox</class>
+   <extends>QComboBox</extends>
+   <header location="global">kis_cmb_composite.h</header>
+  </customwidget>
   <customwidget>
    <class>KisPatternChooser</class>
    <extends>QFrame</extends>
    <header location="global">kis_pattern_chooser.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/libs/ui/layerstyles/WdgSatin.ui b/libs/ui/layerstyles/WdgSatin.ui
index 1f40d07151..c935ff8243 100644
--- a/libs/ui/layerstyles/WdgSatin.ui
+++ b/libs/ui/layerstyles/WdgSatin.ui
@@ -1,260 +1,260 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgSatin</class>
  <widget class="QWidget" name="WdgSatin">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>400</width>
     <height>429</height>
    </rect>
   </property>
   <layout class="QGridLayout" name="gridLayout">
    <item row="0" column="0">
     <widget class="QGroupBox" name="groupBox">
      <property name="title">
       <string>Satin</string>
      </property>
      <layout class="QGridLayout" name="gridLayout_2">
       <item row="0" column="0">
        <widget class="QGroupBox" name="groupBox_2">
         <property name="title">
          <string>Structure</string>
         </property>
         <layout class="QFormLayout" name="formLayout">
          <item row="0" column="0">
           <widget class="QLabel" name="label_13">
            <property name="text">
             <string>Ble&amp;nd Mode:</string>
            </property>
            <property name="buddy">
             <cstring>cmbCompositeOp</cstring>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <layout class="QHBoxLayout" name="horizontalLayout">
            <item>
-            <widget class="KisCompositeOpComboBox" name="cmbCompositeOp">
+            <widget class="KisLayerStyleCompositeOpComboBox" name="cmbCompositeOp">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
              <property name="toolTip">
               <string>Set the blend mode for the layer</string>
              </property>
             </widget>
            </item>
            <item>
             <widget class="KisColorButton" name="bnColor">
              <property name="text">
               <string>...</string>
              </property>
             </widget>
            </item>
           </layout>
          </item>
          <item row="1" column="0">
           <widget class="QLabel" name="label_14">
            <property name="text">
             <string>Opaci&amp;ty:</string>
            </property>
            <property name="buddy">
             <cstring>intOpacity</cstring>
            </property>
           </widget>
          </item>
          <item row="1" column="1">
           <widget class="KisSliderSpinBox" name="intOpacity" native="true">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Minimum">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="minimumSize">
             <size>
              <width>10</width>
              <height>15</height>
             </size>
            </property>
            <property name="toolTip">
             <string>Set the master opacity for the layer</string>
            </property>
            <property name="whatsThis">
             <string>Adjust the transparency of the layer</string>
            </property>
           </widget>
          </item>
          <item row="2" column="0">
           <widget class="QLabel" name="label">
            <property name="text">
             <string>An&amp;gle:</string>
            </property>
            <property name="buddy">
             <cstring>angleSelector</cstring>
            </property>
           </widget>
          </item>
          <item row="4" column="0">
           <widget class="QLabel" name="label_2">
            <property name="text">
             <string>&amp;Distance:</string>
            </property>
            <property name="buddy">
             <cstring>intDistance</cstring>
            </property>
           </widget>
          </item>
          <item row="4" column="1">
           <widget class="KisSliderSpinBox" name="intDistance" native="true">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
           </widget>
          </item>
          <item row="5" column="0">
           <widget class="QLabel" name="label_4">
            <property name="text">
             <string>S&amp;ize:</string>
            </property>
            <property name="buddy">
             <cstring>intSize</cstring>
            </property>
           </widget>
          </item>
          <item row="5" column="1">
           <widget class="KisSliderSpinBox" name="intSize" native="true">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
           </widget>
          </item>
          <item row="6" column="0">
           <widget class="QLabel" name="label_6">
            <property name="text">
             <string>Contour:</string>
            </property>
           </widget>
          </item>
          <item row="6" column="1">
           <widget class="KisCmbContour" name="cmbContour" native="true"/>
          </item>
          <item row="7" column="1">
           <widget class="QCheckBox" name="chkAntiAliased">
            <property name="toolTip">
             <string>Smooth the contour</string>
            </property>
            <property name="text">
             <string>Anti-aliased</string>
            </property>
           </widget>
          </item>
          <item row="8" column="1">
           <widget class="QCheckBox" name="chkInvert">
            <property name="text">
             <string comment="@option:check In Layer Style">&amp;Invert</string>
            </property>
           </widget>
          </item>
          <item row="2" column="1">
           <layout class="QHBoxLayout" name="horizontalLayout_2">
            <item>
             <widget class="KisLayerStyleAngleSelector" name="angleSelector" native="true">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
             </widget>
            </item>
            <item>
             <spacer name="horizontalSpacer">
              <property name="orientation">
               <enum>Qt::Horizontal</enum>
              </property>
              <property name="sizeHint" stdset="0">
               <size>
                <width>40</width>
                <height>20</height>
               </size>
              </property>
             </spacer>
            </item>
           </layout>
          </item>
         </layout>
         <zorder>cmbContour</zorder>
         <zorder>chkAntiAliased</zorder>
         <zorder>intOpacity</zorder>
         <zorder>label_13</zorder>
         <zorder>label_14</zorder>
         <zorder>label_4</zorder>
         <zorder>intDistance</zorder>
         <zorder>intSize</zorder>
         <zorder>label</zorder>
         <zorder>label_2</zorder>
         <zorder>label_6</zorder>
         <zorder>chkInvert</zorder>
        </widget>
       </item>
       <item row="1" column="0">
        <spacer name="verticalSpacer">
         <property name="orientation">
          <enum>Qt::Vertical</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>20</width>
           <height>40</height>
          </size>
         </property>
        </spacer>
       </item>
      </layout>
     </widget>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KisColorButton</class>
    <extends>QPushButton</extends>
    <header>kis_color_button.h</header>
   </customwidget>
   <customwidget>
    <class>KisSliderSpinBox</class>
    <extends>QWidget</extends>
    <header location="global">kis_slider_spin_box.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
-   <class>KisCompositeOpComboBox</class>
+   <class>KisLayerStyleCompositeOpComboBox</class>
    <extends>QComboBox</extends>
    <header location="global">kis_cmb_composite.h</header>
   </customwidget>
   <customwidget>
    <class>KisLayerStyleAngleSelector</class>
    <extends>QWidget</extends>
    <header>KisLayerStyleAngleSelector.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>KisCmbContour</class>
    <extends>QWidget</extends>
    <header>kis_cmb_contour.h</header>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/libs/ui/layerstyles/WdgStroke.ui b/libs/ui/layerstyles/WdgStroke.ui
index 761fc4d488..1bdd958021 100644
--- a/libs/ui/layerstyles/WdgStroke.ui
+++ b/libs/ui/layerstyles/WdgStroke.ui
@@ -1,451 +1,451 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgStroke</class>
  <widget class="QWidget" name="WdgStroke">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>457</width>
     <height>781</height>
    </rect>
   </property>
   <layout class="QGridLayout" name="gridLayout">
    <item row="0" column="0">
     <widget class="QGroupBox" name="groupBox">
      <property name="title">
       <string>Stroke</string>
      </property>
      <layout class="QGridLayout" name="gridLayout_2">
       <item row="0" column="0">
        <widget class="QGroupBox" name="groupBox_2">
         <property name="title">
          <string>Structure</string>
         </property>
         <layout class="QFormLayout" name="formLayout">
          <item row="0" column="0">
           <widget class="QLabel" name="label">
            <property name="text">
             <string>S&amp;ize:</string>
            </property>
            <property name="buddy">
             <cstring>intSize</cstring>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <widget class="KisSliderSpinBox" name="intSize" native="true">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
           </widget>
          </item>
          <item row="1" column="0">
           <widget class="QLabel" name="label_2">
            <property name="text">
             <string>Positio&amp;n:</string>
            </property>
            <property name="buddy">
             <cstring>cmbPosition</cstring>
            </property>
           </widget>
          </item>
          <item row="1" column="1">
           <widget class="QComboBox" name="cmbPosition">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <item>
             <property name="text">
              <string comment="@item:inlistbox Layer Style: Stroke position">Outside</string>
             </property>
            </item>
            <item>
             <property name="text">
              <string comment="@item:inlistbox Layer Style: Stroke position">Inside</string>
             </property>
            </item>
            <item>
             <property name="text">
              <string comment="@item:inlistbox Layer Style: Stroke position">Center</string>
             </property>
            </item>
           </widget>
          </item>
          <item row="2" column="0">
           <widget class="QLabel" name="label_3">
            <property name="text">
             <string>&amp;Blend Mode:</string>
            </property>
            <property name="buddy">
             <cstring>cmbCompositeOp</cstring>
            </property>
           </widget>
          </item>
          <item row="2" column="1">
-          <widget class="KisCompositeOpComboBox" name="cmbCompositeOp">
+          <widget class="KisLayerStyleCompositeOpComboBox" name="cmbCompositeOp">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
           </widget>
          </item>
          <item row="3" column="0">
           <widget class="QLabel" name="label_4">
            <property name="text">
             <string>Opacit&amp;y:</string>
            </property>
            <property name="buddy">
             <cstring>intOpacity</cstring>
            </property>
           </widget>
          </item>
          <item row="3" column="1">
           <widget class="KisSliderSpinBox" name="intOpacity" native="true">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item row="1" column="0">
        <widget class="QGroupBox" name="groupBox_3">
         <property name="title">
          <string comment="@title:group In Layer Style">Fill</string>
         </property>
         <layout class="QVBoxLayout" name="verticalLayout">
          <item>
           <widget class="QComboBox" name="cmbFillType">
            <item>
             <property name="text">
              <string>Color</string>
             </property>
            </item>
            <item>
             <property name="text">
              <string>Gradient</string>
             </property>
            </item>
            <item>
             <property name="text">
              <string comment="@title:group In Layer Style">Pattern</string>
             </property>
            </item>
           </widget>
          </item>
          <item>
           <widget class="QStackedWidget" name="fillStack">
            <property name="currentIndex">
             <number>1</number>
            </property>
            <widget class="QWidget" name="page_3">
             <layout class="QFormLayout" name="formLayout_2">
              <item row="0" column="0">
               <widget class="QLabel" name="label_5">
                <property name="text">
                 <string>Color:</string>
                </property>
               </widget>
              </item>
              <item row="0" column="1">
               <widget class="KisColorButton" name="bnColor">
                <property name="text">
                 <string>...</string>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
            <widget class="QWidget" name="page_4">
             <layout class="QFormLayout" name="formLayout_3">
              <item row="0" column="0">
               <widget class="QLabel" name="label_7">
                <property name="text">
                 <string>&amp;Gradient:</string>
                </property>
                <property name="buddy">
                 <cstring>cmbGradient</cstring>
                </property>
               </widget>
              </item>
              <item row="0" column="1">
               <layout class="QHBoxLayout" name="horizontalLayout_3">
                <item>
                 <widget class="KisCmbGradient" name="cmbGradient">
                  <property name="sizePolicy">
                   <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
                    <horstretch>0</horstretch>
                    <verstretch>0</verstretch>
                   </sizepolicy>
                  </property>
                 </widget>
                </item>
                <item>
                 <widget class="QCheckBox" name="chkReverse">
                  <property name="text">
                   <string>&amp;Reverse</string>
                  </property>
                 </widget>
                </item>
               </layout>
              </item>
              <item row="1" column="0">
               <widget class="QLabel" name="label_6">
                <property name="text">
                 <string>St&amp;yle:</string>
                </property>
                <property name="buddy">
                 <cstring>cmbStyle</cstring>
                </property>
               </widget>
              </item>
              <item row="1" column="1">
               <layout class="QHBoxLayout" name="horizontalLayout_4">
                <item>
                 <widget class="QComboBox" name="cmbStyle">
                  <property name="sizePolicy">
                   <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
                    <horstretch>0</horstretch>
                    <verstretch>0</verstretch>
                   </sizepolicy>
                  </property>
                  <item>
                   <property name="text">
                    <string>Linear</string>
                   </property>
                  </item>
                  <item>
                   <property name="text">
                    <string>Radial</string>
                   </property>
                  </item>
                  <item>
                   <property name="text">
                    <string comment="@item:inlistbox Gradient style">Angle</string>
                   </property>
                  </item>
                  <item>
                   <property name="text">
                    <string>Reflected</string>
                   </property>
                  </item>
                  <item>
                   <property name="text">
                    <string>Diamond</string>
                   </property>
                  </item>
                 </widget>
                </item>
                <item>
                 <widget class="QCheckBox" name="chkAlignWithLayer">
                  <property name="text">
                   <string>Ali&amp;gn with Layer</string>
                  </property>
                 </widget>
                </item>
               </layout>
              </item>
              <item row="2" column="0">
               <widget class="QLabel" name="label_9">
                <property name="text">
                 <string>&amp;Angle:</string>
                </property>
                <property name="buddy">
                 <cstring>angleSelector</cstring>
                </property>
               </widget>
              </item>
              <item row="4" column="0">
               <widget class="QLabel" name="label_8">
                <property name="text">
                 <string>S&amp;cale:</string>
                </property>
                <property name="buddy">
                 <cstring>intScale</cstring>
                </property>
               </widget>
              </item>
              <item row="4" column="1">
               <widget class="KisSliderSpinBox" name="intScale" native="true">
                <property name="sizePolicy">
                 <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
                  <horstretch>0</horstretch>
                  <verstretch>0</verstretch>
                 </sizepolicy>
                </property>
                <property name="toolTip">
                 <string>Set size of gradation</string>
                </property>
               </widget>
              </item>
              <item row="2" column="1">
               <layout class="QHBoxLayout" name="horizontalLayout">
                <item>
                 <widget class="KisLayerStyleAngleSelector" name="angleSelector" native="true">
                  <property name="sizePolicy">
                   <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
                    <horstretch>0</horstretch>
                    <verstretch>0</verstretch>
                   </sizepolicy>
                  </property>
                 </widget>
                </item>
                <item>
                 <spacer name="horizontalSpacer">
                  <property name="orientation">
                   <enum>Qt::Horizontal</enum>
                  </property>
                  <property name="sizeHint" stdset="0">
                   <size>
                    <width>40</width>
                    <height>20</height>
                   </size>
                  </property>
                 </spacer>
                </item>
               </layout>
              </item>
             </layout>
            </widget>
            <widget class="QWidget" name="page_2">
             <layout class="QFormLayout" name="formLayout_4">
              <item row="0" column="0">
               <widget class="QLabel" name="label_11">
                <property name="text">
                 <string>Pattern:</string>
                </property>
               </widget>
              </item>
              <item row="0" column="1">
               <layout class="QVBoxLayout" name="verticalLayout_2">
                <item>
                 <widget class="KisPatternChooser" name="patternChooser">
                  <property name="sizePolicy">
                   <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
                    <horstretch>0</horstretch>
                    <verstretch>0</verstretch>
                   </sizepolicy>
                  </property>
                  <property name="minimumSize">
                   <size>
                    <width>250</width>
                    <height>250</height>
                   </size>
                  </property>
                  <property name="frameShape">
                   <enum>QFrame::StyledPanel</enum>
                  </property>
                  <property name="frameShadow">
                   <enum>QFrame::Raised</enum>
                  </property>
                 </widget>
                </item>
                <item>
                 <widget class="QPushButton" name="bnSnapToOrigin">
                  <property name="text">
                   <string>Sn&amp;ap to Origin</string>
                  </property>
                 </widget>
                </item>
               </layout>
              </item>
              <item row="1" column="0">
               <widget class="QLabel" name="label_10">
                <property name="text">
                 <string>S&amp;cale:</string>
                </property>
                <property name="buddy">
                 <cstring>intScale</cstring>
                </property>
               </widget>
              </item>
              <item row="1" column="1">
               <widget class="KisSliderSpinBox" name="intScale_2" native="true">
                <property name="toolTip">
                 <string>Set size of gradation</string>
                </property>
               </widget>
              </item>
              <item row="2" column="1">
               <widget class="QCheckBox" name="chkLinkWithLayer">
                <property name="text">
                 <string>Lin&amp;k with Layer</string>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item row="1" column="0">
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>40</height>
       </size>
      </property>
     </spacer>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KisColorButton</class>
    <extends>QPushButton</extends>
    <header>kis_color_button.h</header>
   </customwidget>
   <customwidget>
    <class>KisSliderSpinBox</class>
    <extends>QWidget</extends>
    <header location="global">kis_slider_spin_box.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
-   <class>KisCompositeOpComboBox</class>
+   <class>KisLayerStyleCompositeOpComboBox</class>
    <extends>QComboBox</extends>
    <header location="global">kis_cmb_composite.h</header>
   </customwidget>
   <customwidget>
    <class>KisLayerStyleAngleSelector</class>
    <extends>QWidget</extends>
    <header>KisLayerStyleAngleSelector.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>KisCmbGradient</class>
    <extends>QToolButton</extends>
    <header>kis_cmb_gradient.h</header>
   </customwidget>
   <customwidget>
    <class>KisPatternChooser</class>
    <extends>QFrame</extends>
    <header location="global">kis_pattern_chooser.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/libs/ui/layerstyles/wdgBevelAndEmboss.ui b/libs/ui/layerstyles/wdgBevelAndEmboss.ui
index 39cb1071c0..4298ffa2bf 100644
--- a/libs/ui/layerstyles/wdgBevelAndEmboss.ui
+++ b/libs/ui/layerstyles/wdgBevelAndEmboss.ui
@@ -1,437 +1,437 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgBevelAndEmboss</class>
  <widget class="QWidget" name="WdgBevelAndEmboss">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>453</width>
     <height>669</height>
    </rect>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
     <widget class="QGroupBox" name="groupBox">
      <property name="title">
       <string>Bevel and Emboss</string>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_2">
       <item>
        <widget class="QGroupBox" name="groupBox_2">
         <property name="title">
          <string>Structure</string>
         </property>
         <layout class="QFormLayout" name="formLayout">
          <item row="0" column="0">
           <widget class="QLabel" name="label">
            <property name="text">
             <string>St&amp;yle:</string>
            </property>
            <property name="buddy">
             <cstring>cmbStyle</cstring>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <widget class="QComboBox" name="cmbStyle">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <item>
             <property name="text">
              <string>Outer Bevel</string>
             </property>
            </item>
            <item>
             <property name="text">
              <string>Inner Bevel</string>
             </property>
            </item>
            <item>
             <property name="text">
              <string comment="@item:inlistbox Bevel/emboss style">Emboss</string>
             </property>
            </item>
            <item>
             <property name="text">
              <string>Pillow Emboss</string>
             </property>
            </item>
            <item>
             <property name="text">
              <string>Stroke Emboss</string>
             </property>
            </item>
           </widget>
          </item>
          <item row="1" column="0">
           <widget class="QLabel" name="label_2">
            <property name="text">
             <string>&amp;Technique:</string>
            </property>
            <property name="buddy">
             <cstring>cmbTechnique</cstring>
            </property>
           </widget>
          </item>
          <item row="1" column="1">
           <widget class="QComboBox" name="cmbTechnique">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <item>
             <property name="text">
              <string>Smooth</string>
             </property>
            </item>
            <item>
             <property name="text">
              <string>Chisel Hard</string>
             </property>
            </item>
            <item>
             <property name="text">
              <string>Chisel Soft</string>
             </property>
            </item>
           </widget>
          </item>
          <item row="2" column="0">
           <widget class="QLabel" name="label_3">
            <property name="text">
             <string>&amp;Depth:</string>
            </property>
            <property name="buddy">
             <cstring>intDepth</cstring>
            </property>
           </widget>
          </item>
          <item row="2" column="1">
           <widget class="KisSliderSpinBox" name="intDepth" native="true">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
           </widget>
          </item>
          <item row="3" column="0">
           <widget class="QLabel" name="label_4">
            <property name="text">
             <string comment="@label:listbox Bevel direction">Direction:</string>
            </property>
            <property name="buddy">
             <cstring>cmbDirection</cstring>
            </property>
           </widget>
          </item>
          <item row="3" column="1">
           <widget class="QComboBox" name="cmbDirection">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <item>
             <property name="text">
              <string comment="@item:inlistbox Bevel direction">Up</string>
             </property>
            </item>
            <item>
             <property name="text">
              <string comment="@item:inlistbox Bevel direction">Down</string>
             </property>
            </item>
           </widget>
          </item>
          <item row="4" column="0">
           <widget class="QLabel" name="label_5">
            <property name="text">
             <string>Si&amp;ze:</string>
            </property>
            <property name="buddy">
             <cstring>intSize</cstring>
            </property>
           </widget>
          </item>
          <item row="4" column="1">
           <widget class="KisSliderSpinBox" name="intSize" native="true">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
           </widget>
          </item>
          <item row="5" column="0">
           <widget class="QLabel" name="label_6">
            <property name="text">
             <string>So&amp;ften:</string>
            </property>
            <property name="buddy">
             <cstring>intSoften</cstring>
            </property>
           </widget>
          </item>
          <item row="5" column="1">
           <widget class="KisSliderSpinBox" name="intSoften" native="true">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item>
        <widget class="QGroupBox" name="groupBox_3">
         <property name="title">
          <string>Shading</string>
         </property>
         <layout class="QFormLayout" name="formLayout_2">
          <item row="0" column="0">
           <widget class="QLabel" name="label_7">
            <property name="text">
             <string>&amp;Angle:</string>
            </property>
            <property name="buddy">
             <cstring>angleSelector</cstring>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <widget class="KisLayerStyleAngleSelector" name="angleSelector" native="true"/>
          </item>
          <item row="1" column="0">
           <widget class="QLabel" name="label_8">
            <property name="text">
             <string>A&amp;ltitude:</string>
            </property>
            <property name="buddy">
             <cstring>intAltitude</cstring>
            </property>
           </widget>
          </item>
          <item row="1" column="1">
           <widget class="KisIntParseSpinBox" name="intAltitude">
            <property name="alignment">
             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
            </property>
            <property name="minimum">
             <number>-179</number>
            </property>
            <property name="maximum">
             <number>180</number>
            </property>
           </widget>
          </item>
          <item row="2" column="0">
           <widget class="QLabel" name="label_9">
            <property name="text">
             <string>&amp;Gloss Contour:</string>
            </property>
            <property name="buddy">
             <cstring>cmbContour</cstring>
            </property>
           </widget>
          </item>
          <item row="2" column="1">
           <layout class="QHBoxLayout" name="horizontalLayout_2">
            <item>
             <widget class="QComboBox" name="cmbContour"/>
            </item>
            <item>
             <widget class="QCheckBox" name="chkAntiAliased">
              <property name="text">
               <string>Anti-aliased</string>
              </property>
             </widget>
            </item>
           </layout>
          </item>
          <item row="3" column="0">
           <widget class="QLabel" name="label_10">
            <property name="text">
             <string>H&amp;ighlight Mode:</string>
            </property>
            <property name="buddy">
             <cstring>cmbHighlightMode</cstring>
            </property>
           </widget>
          </item>
          <item row="3" column="1">
           <layout class="QHBoxLayout" name="horizontalLayout">
            <item>
-            <widget class="KisCompositeOpComboBox" name="cmbHighlightMode">
+            <widget class="KisLayerStyleCompositeOpComboBox" name="cmbHighlightMode">
              <property name="toolTip">
               <string>Set the blend mode for the layer</string>
              </property>
             </widget>
            </item>
            <item>
             <widget class="KisColorButton" name="bnHighlightColor">
              <property name="text">
               <string>...</string>
              </property>
             </widget>
            </item>
           </layout>
          </item>
          <item row="4" column="0">
           <widget class="QLabel" name="label_14">
            <property name="text">
             <string>&amp;Opacity:</string>
            </property>
            <property name="buddy">
             <cstring>intOpacity</cstring>
            </property>
           </widget>
          </item>
          <item row="4" column="1">
           <widget class="KisSliderSpinBox" name="intOpacity" native="true">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Minimum">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="minimumSize">
             <size>
              <width>10</width>
              <height>15</height>
             </size>
            </property>
            <property name="toolTip">
             <string>Set the master opacity for the layer</string>
            </property>
            <property name="whatsThis">
             <string>Adjust the transparency of the layer</string>
            </property>
           </widget>
          </item>
          <item row="5" column="0">
           <widget class="QLabel" name="label_11">
            <property name="text">
             <string>Sh&amp;adow Mode:</string>
            </property>
            <property name="buddy">
             <cstring>cmbShadowMode</cstring>
            </property>
           </widget>
          </item>
          <item row="5" column="1">
           <layout class="QHBoxLayout" name="horizontalLayout_3">
            <item>
-            <widget class="KisCompositeOpComboBox" name="cmbShadowMode">
+            <widget class="KisLayerStyleCompositeOpComboBox" name="cmbShadowMode">
              <property name="toolTip">
               <string>Set the blend mode for the layer</string>
              </property>
             </widget>
            </item>
            <item>
             <widget class="KisColorButton" name="bnShadowColor">
              <property name="text">
               <string>...</string>
              </property>
             </widget>
            </item>
           </layout>
          </item>
          <item row="6" column="0">
           <widget class="QLabel" name="label_15">
            <property name="text">
             <string>&amp;Opacity:</string>
            </property>
            <property name="buddy">
             <cstring>intOpacity2</cstring>
            </property>
           </widget>
          </item>
          <item row="6" column="1">
           <widget class="KisSliderSpinBox" name="intOpacity2" native="true">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Minimum">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="minimumSize">
             <size>
              <width>10</width>
              <height>15</height>
             </size>
            </property>
            <property name="toolTip">
             <string>Set the master opacity for the layer</string>
            </property>
            <property name="whatsThis">
             <string>Adjust the transparency of the layer</string>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item>
        <spacer name="verticalSpacer_2">
         <property name="orientation">
          <enum>Qt::Vertical</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>20</width>
           <height>40</height>
          </size>
         </property>
        </spacer>
       </item>
      </layout>
     </widget>
    </item>
   </layout>
  </widget>
  <customwidgets>
-  <customwidget>
-   <class>KisIntParseSpinBox</class>
-   <extends>QSpinBox</extends>
-   <header>kis_int_parse_spin_box.h</header>
-  </customwidget>
   <customwidget>
    <class>KisColorButton</class>
    <extends>QPushButton</extends>
    <header>kis_color_button.h</header>
   </customwidget>
   <customwidget>
    <class>KisSliderSpinBox</class>
    <extends>QWidget</extends>
    <header location="global">kis_slider_spin_box.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
-   <class>KisCompositeOpComboBox</class>
+   <class>KisLayerStyleCompositeOpComboBox</class>
    <extends>QComboBox</extends>
    <header location="global">kis_cmb_composite.h</header>
   </customwidget>
   <customwidget>
    <class>KisLayerStyleAngleSelector</class>
    <extends>QWidget</extends>
    <header>KisLayerStyleAngleSelector.h</header>
    <container>1</container>
   </customwidget>
+  <customwidget>
+   <class>KisIntParseSpinBox</class>
+   <extends>QSpinBox</extends>
+   <header>kis_int_parse_spin_box.h</header>
+  </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/libs/ui/layerstyles/wdgInnerGlow.ui b/libs/ui/layerstyles/wdgInnerGlow.ui
index ce23fc693f..79b7a90f04 100644
--- a/libs/ui/layerstyles/wdgInnerGlow.ui
+++ b/libs/ui/layerstyles/wdgInnerGlow.ui
@@ -1,405 +1,405 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgInnerGlow</class>
  <widget class="QWidget" name="WdgInnerGlow">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>298</width>
     <height>476</height>
    </rect>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
     <widget class="QGroupBox" name="groupBox">
      <property name="title">
       <string>Inner Glow</string>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_2">
       <item>
        <widget class="QGroupBox" name="groupBox_2">
         <property name="title">
          <string>Structure</string>
         </property>
         <layout class="QFormLayout" name="formLayout">
          <item row="0" column="0">
           <widget class="QLabel" name="label_13">
            <property name="text">
             <string>Ble&amp;nd Mode:</string>
            </property>
            <property name="buddy">
             <cstring>cmbCompositeOp</cstring>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
-          <widget class="KisCompositeOpComboBox" name="cmbCompositeOp">
+          <widget class="KisLayerStyleCompositeOpComboBox" name="cmbCompositeOp">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="toolTip">
             <string>Set the blend mode for the layer</string>
            </property>
           </widget>
          </item>
          <item row="1" column="0">
           <widget class="QLabel" name="label_14">
            <property name="text">
             <string>&amp;Opacity:</string>
            </property>
            <property name="buddy">
             <cstring>intOpacity</cstring>
            </property>
           </widget>
          </item>
          <item row="1" column="1">
           <widget class="KisSliderSpinBox" name="intOpacity" native="true">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Minimum">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="minimumSize">
             <size>
              <width>10</width>
              <height>15</height>
             </size>
            </property>
            <property name="toolTip">
             <string>Set the master opacity for the layer</string>
            </property>
            <property name="whatsThis">
             <string>Adjust the transparency of the layer</string>
            </property>
           </widget>
          </item>
          <item row="2" column="0">
           <widget class="QLabel" name="label">
            <property name="text">
             <string>&amp;Noise:</string>
            </property>
            <property name="buddy">
             <cstring>intNoise</cstring>
            </property>
           </widget>
          </item>
          <item row="2" column="1">
           <widget class="KisSliderSpinBox" name="intNoise" native="true">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Minimum">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="minimumSize">
             <size>
              <width>10</width>
              <height>15</height>
             </size>
            </property>
            <property name="toolTip">
             <string>Set the master opacity for the layer</string>
            </property>
            <property name="whatsThis">
             <string>Adjust the transparency of the layer</string>
            </property>
           </widget>
          </item>
          <item row="3" column="0" colspan="2">
           <layout class="QHBoxLayout" name="horizontalLayout">
            <item>
             <widget class="QRadioButton" name="radioColor">
              <property name="text">
               <string/>
              </property>
             </widget>
            </item>
            <item>
             <widget class="KisColorButton" name="bnColor">
              <property name="text">
               <string>...</string>
              </property>
             </widget>
            </item>
            <item>
             <widget class="QRadioButton" name="radioGradient">
              <property name="text">
               <string/>
              </property>
             </widget>
            </item>
            <item>
             <widget class="KisCmbGradient" name="cmbGradient">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
             </widget>
            </item>
           </layout>
          </item>
         </layout>
        </widget>
       </item>
       <item>
        <widget class="QGroupBox" name="groupBox_3">
         <property name="title">
          <string>Elements</string>
         </property>
         <layout class="QFormLayout" name="formLayout_3">
          <item row="0" column="0">
           <widget class="QLabel" name="label_2">
            <property name="text">
             <string>&amp;Technique:</string>
            </property>
            <property name="buddy">
             <cstring>cmbTechnique</cstring>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <widget class="QComboBox" name="cmbTechnique">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <item>
             <property name="text">
              <string>Softer</string>
             </property>
            </item>
            <item>
             <property name="text">
              <string>Precise</string>
             </property>
            </item>
           </widget>
          </item>
          <item row="1" column="0">
           <widget class="QLabel" name="lblSource">
            <property name="text">
             <string>&amp;Source:</string>
            </property>
            <property name="buddy">
             <cstring>cmbSource</cstring>
            </property>
           </widget>
          </item>
          <item row="2" column="0">
           <widget class="QLabel" name="lblChoke">
            <property name="text">
             <string>&amp;Choke:</string>
            </property>
            <property name="buddy">
             <cstring>intChoke</cstring>
            </property>
           </widget>
          </item>
          <item row="2" column="1">
           <widget class="KisSliderSpinBox" name="intChoke" native="true">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="suffix" stdset="0">
             <string>%</string>
            </property>
            <property name="maximum" stdset="0">
             <number>100</number>
            </property>
           </widget>
          </item>
          <item row="3" column="0">
           <widget class="QLabel" name="label_5">
            <property name="text">
             <string>&amp;Size:</string>
            </property>
            <property name="buddy">
             <cstring>intSize</cstring>
            </property>
           </widget>
          </item>
          <item row="3" column="1">
           <widget class="KisSliderSpinBox" name="intSize" native="true">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="suffix" stdset="0">
             <string>px</string>
            </property>
            <property name="maximum" stdset="0">
             <number>250</number>
            </property>
           </widget>
          </item>
          <item row="1" column="1">
           <widget class="QComboBox" name="cmbSource">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <item>
             <property name="text">
              <string comment="@item:inlistbox Layer Style: Source">Center</string>
             </property>
            </item>
            <item>
             <property name="text">
              <string comment="@item:inlistbox Layer Style: Source">Edge</string>
             </property>
            </item>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item>
        <widget class="QGroupBox" name="groupBox_4">
         <property name="title">
          <string>Quality</string>
         </property>
         <layout class="QFormLayout" name="formLayout_2">
          <item row="0" column="0">
           <widget class="QLabel" name="label_6">
            <property name="text">
             <string>Contour:</string>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <layout class="QHBoxLayout" name="horizontalLayout_2">
            <item>
             <widget class="KisCmbContour" name="cmbContour" native="true"/>
            </item>
            <item>
             <widget class="QCheckBox" name="chkAntiAliased">
              <property name="text">
               <string>Anti-aliased</string>
              </property>
             </widget>
            </item>
           </layout>
          </item>
          <item row="1" column="0">
           <widget class="QLabel" name="label_7">
            <property name="text">
             <string>&amp;Range:</string>
            </property>
            <property name="buddy">
             <cstring>intRange</cstring>
            </property>
           </widget>
          </item>
          <item row="1" column="1">
           <widget class="KisSliderSpinBox" name="intRange" native="true">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="suffix" stdset="0">
             <string>%</string>
            </property>
            <property name="minimum" stdset="0">
             <number>1</number>
            </property>
            <property name="maximum" stdset="0">
             <number>100</number>
            </property>
           </widget>
          </item>
          <item row="2" column="0">
           <widget class="QLabel" name="label_8">
            <property name="text">
             <string>&amp;Jitter:</string>
            </property>
            <property name="buddy">
             <cstring>intJitter</cstring>
            </property>
           </widget>
          </item>
          <item row="2" column="1">
           <widget class="KisSliderSpinBox" name="intJitter" native="true">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="suffix" stdset="0">
             <string>%</string>
            </property>
            <property name="maximum" stdset="0">
             <number>100</number>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item>
        <spacer name="verticalSpacer">
         <property name="orientation">
          <enum>Qt::Vertical</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>20</width>
           <height>40</height>
          </size>
         </property>
        </spacer>
       </item>
      </layout>
     </widget>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KisColorButton</class>
    <extends>QPushButton</extends>
    <header>kis_color_button.h</header>
   </customwidget>
   <customwidget>
    <class>KisSliderSpinBox</class>
    <extends>QWidget</extends>
    <header location="global">kis_slider_spin_box.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
-   <class>KisCompositeOpComboBox</class>
+   <class>KisLayerStyleCompositeOpComboBox</class>
    <extends>QComboBox</extends>
    <header location="global">kis_cmb_composite.h</header>
   </customwidget>
-  <customwidget>
-   <class>KisCmbContour</class>
-   <extends>QWidget</extends>
-   <header>kis_cmb_contour.h</header>
-  </customwidget>
   <customwidget>
    <class>KisCmbGradient</class>
    <extends>QToolButton</extends>
    <header>kis_cmb_gradient.h</header>
   </customwidget>
+  <customwidget>
+   <class>KisCmbContour</class>
+   <extends>QWidget</extends>
+   <header>kis_cmb_contour.h</header>
+  </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/libs/ui/layerstyles/wdgdropshadow.ui b/libs/ui/layerstyles/wdgdropshadow.ui
index 5572b503a6..b3c07dd271 100644
--- a/libs/ui/layerstyles/wdgdropshadow.ui
+++ b/libs/ui/layerstyles/wdgdropshadow.ui
@@ -1,282 +1,282 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgDropShadow</class>
  <widget class="QWidget" name="WdgDropShadow">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>491</width>
     <height>495</height>
    </rect>
   </property>
   <layout class="QGridLayout" name="gridLayout">
    <item row="0" column="0">
     <widget class="QGroupBox" name="grpMain">
      <property name="title">
       <string>Drop Shadow</string>
      </property>
      <layout class="QGridLayout" name="gridLayout_2">
       <item row="3" column="0">
        <spacer name="verticalSpacer">
         <property name="orientation">
          <enum>Qt::Vertical</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>20</width>
           <height>40</height>
          </size>
         </property>
        </spacer>
       </item>
       <item row="2" column="0">
        <widget class="QCheckBox" name="chkLayerKnocksOutDropShadow">
         <property name="toolTip">
          <string>Use to obscure the shadow when fill is transparent</string>
         </property>
         <property name="text">
          <string>Layer knocks O&amp;ut Drop Shadow</string>
         </property>
        </widget>
       </item>
       <item row="1" column="0">
        <widget class="QGroupBox" name="groupBox_2">
         <property name="title">
          <string>Quality</string>
         </property>
         <layout class="QFormLayout" name="formLayout_2">
          <item row="0" column="0">
           <widget class="QLabel" name="label_5">
            <property name="text">
             <string>Contour:</string>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <layout class="QHBoxLayout" name="horizontalLayout_2">
            <item>
             <widget class="KisCmbContour" name="cmbContour" native="true">
              <property name="sizePolicy">
               <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
             </widget>
            </item>
            <item>
             <widget class="QCheckBox" name="chkAntiAliased">
              <property name="toolTip">
               <string>Smooth the contour</string>
              </property>
              <property name="text">
               <string>Anti-aliased</string>
              </property>
             </widget>
            </item>
           </layout>
          </item>
          <item row="1" column="0">
           <widget class="QLabel" name="label_6">
            <property name="text">
             <string>&amp;Noise:</string>
            </property>
            <property name="buddy">
             <cstring>intNoise</cstring>
            </property>
           </widget>
          </item>
          <item row="1" column="1">
           <widget class="KisSliderSpinBox" name="intNoise" native="true">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="toolTip">
             <string>Add noise to shadow</string>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item row="0" column="0">
        <widget class="QGroupBox" name="groupBox_3">
         <property name="title">
          <string>Structure</string>
         </property>
         <layout class="QGridLayout" name="gridLayout_3">
          <item row="0" column="1">
-          <widget class="KisCompositeOpComboBox" name="cmbCompositeOp">
+          <widget class="KisLayerStyleCompositeOpComboBox" name="cmbCompositeOp">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="toolTip">
             <string>Set the blend mode for the layer</string>
            </property>
           </widget>
          </item>
          <item row="4" column="1" colspan="2">
           <widget class="KisSliderSpinBox" name="intDistance" native="true">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
           </widget>
          </item>
          <item row="0" column="2">
           <widget class="KisColorButton" name="bnColor"/>
          </item>
          <item row="1" column="1" colspan="2">
           <widget class="KisSliderSpinBox" name="intOpacity" native="true">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Minimum">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="minimumSize">
             <size>
              <width>10</width>
              <height>15</height>
             </size>
            </property>
            <property name="toolTip">
             <string>Set the master opacity for the layer</string>
            </property>
            <property name="whatsThis">
             <string>Adjust the transparency of the layer</string>
            </property>
           </widget>
          </item>
          <item row="4" column="0">
           <widget class="QLabel" name="label_2">
            <property name="text">
             <string>&amp;Distance:</string>
            </property>
            <property name="buddy">
             <cstring>intDistance</cstring>
            </property>
           </widget>
          </item>
          <item row="6" column="1" colspan="2">
           <widget class="KisSliderSpinBox" name="intSize" native="true">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
           </widget>
          </item>
          <item row="1" column="0">
           <widget class="QLabel" name="label_14">
            <property name="text">
             <string>Opaci&amp;ty:</string>
            </property>
            <property name="buddy">
             <cstring>intOpacity</cstring>
            </property>
           </widget>
          </item>
          <item row="3" column="0">
           <widget class="QLabel" name="label">
            <property name="text">
             <string>An&amp;gle:</string>
            </property>
            <property name="buddy">
             <cstring>angleSelector</cstring>
            </property>
           </widget>
          </item>
          <item row="5" column="0">
           <widget class="QLabel" name="lblSpread">
            <property name="text">
             <string>Sp&amp;read:</string>
            </property>
            <property name="buddy">
             <cstring>intSpread</cstring>
            </property>
           </widget>
          </item>
          <item row="5" column="1" colspan="2">
           <widget class="KisSliderSpinBox" name="intSpread" native="true">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
           </widget>
          </item>
          <item row="6" column="0">
           <widget class="QLabel" name="label_4">
            <property name="text">
             <string>S&amp;ize:</string>
            </property>
            <property name="buddy">
             <cstring>intSize</cstring>
            </property>
           </widget>
          </item>
          <item row="0" column="0">
           <widget class="QLabel" name="label_13">
            <property name="text">
             <string>&amp;Blend Mode:</string>
            </property>
            <property name="buddy">
             <cstring>cmbCompositeOp</cstring>
            </property>
           </widget>
          </item>
          <item row="3" column="1" colspan="2">
           <widget class="KisLayerStyleAngleSelector" name="angleSelector" native="true"/>
          </item>
         </layout>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KisColorButton</class>
    <extends>QPushButton</extends>
    <header>kis_color_button.h</header>
   </customwidget>
   <customwidget>
    <class>KisSliderSpinBox</class>
    <extends>QWidget</extends>
    <header location="global">kis_slider_spin_box.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
-   <class>KisCompositeOpComboBox</class>
+   <class>KisLayerStyleCompositeOpComboBox</class>
    <extends>QComboBox</extends>
    <header location="global">kis_cmb_composite.h</header>
   </customwidget>
   <customwidget>
    <class>KisLayerStyleAngleSelector</class>
    <extends>QWidget</extends>
    <header>KisLayerStyleAngleSelector.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>KisCmbContour</class>
    <extends>QWidget</extends>
    <header>kis_cmb_contour.h</header>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/libs/ui/widgets/kis_cmb_composite.cc b/libs/ui/widgets/kis_cmb_composite.cc
index 353e262533..61625d26c0 100644
--- a/libs/ui/widgets/kis_cmb_composite.cc
+++ b/libs/ui/widgets/kis_cmb_composite.cc
@@ -1,482 +1,491 @@
 /*
  *  kis_cmb_composite.cc - part of KImageShop/Krayon/Krita
  *
  *  Copyright (c) 2004 Boudewijn Rempt (boud@valdyas.org)
  *  Copyright (c) 2011 Silvio Heinrich <plassy@web.de>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_cmb_composite.h"
 
 #include <KoCompositeOp.h>
 #include <KoCompositeOpRegistry.h>
 
 #include "kis_composite_ops_model.h"
 #include "kis_categorized_item_delegate.h"
 #include <kis_action.h>
 
 //////////////////////////////////////////////////////////////////////////////////////////
 // ---- KisCompositeOpListWidget ------------------------------------------------------ //
 
 KisCompositeOpListWidget::KisCompositeOpListWidget(QWidget* parent):
     KisCategorizedListView(parent),
-    m_model(new KisSortedCompositeOpListModel(this))
+    m_model(new KisSortedCompositeOpListModel(false, this))
 {
     setModel(m_model);
     setItemDelegate(new KisCategorizedItemDelegate(this));
 }
 
 KisCompositeOpListWidget::~KisCompositeOpListWidget()
 {
 }
 
 KoID KisCompositeOpListWidget::selectedCompositeOp() const {
     KoID op;
 
     if (m_model->entryAt(op, currentIndex())) {
         return op;
     }
 
     return KoCompositeOpRegistry::instance().getDefaultCompositeOp();
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 // ---- KisCompositeOpComboBox -------------------------------------------------------- //
 
-KisCompositeOpComboBox::KisCompositeOpComboBox(QWidget* parent):
-    KisSqueezedComboBox(parent),
-    m_model(new KisSortedCompositeOpListModel(this)),
-    m_allowToHidePopup(true)
+KisCompositeOpComboBox::KisCompositeOpComboBox(QWidget* parent)
+    : KisCompositeOpComboBox(false, parent)
+{
+}
+
+KisCompositeOpComboBox::KisCompositeOpComboBox(bool limitToLayerStyles, QWidget* parent)
+    : KisSqueezedComboBox(parent),
+      m_model(new KisSortedCompositeOpListModel(limitToLayerStyles, this)),
+      m_allowToHidePopup(true)
 {
     m_view = new KisCategorizedListView();
     m_view->setCompositeBoxControl(true);
 
     setMaxVisibleItems(100);
     setSizeAdjustPolicy(AdjustToContents);
     m_view->setResizeMode(QListView::Adjust);
 
     setToolTip(i18n("Blending Mode"));
 
     setModel(m_model);
     setView(m_view);
     setItemDelegate(new KisCategorizedItemDelegate(this));
 
     connect(m_view, SIGNAL(sigCategoryToggled(QModelIndex,bool)), SLOT(slotCategoryToggled(QModelIndex,bool)));
     connect(m_view, SIGNAL(sigEntryChecked(QModelIndex)), SLOT(slotEntryChecked(QModelIndex)));
 
     selectCompositeOp(KoCompositeOpRegistry::instance().getDefaultCompositeOp());
+}
+
+KisCompositeOpComboBox::~KisCompositeOpComboBox()
+{
+    delete m_view;
+}
+
+QList<KisAction *> KisCompositeOpComboBox::createBlendmodeActions()
+{
+    QList<KisAction *> actions;
 
     KisAction *action = 0;
 //    //    Cycle through blending modes
 //    //    Shift + + (plus) or – (minus)
 //    KisAction *action = new KisAction(i18n("Next Blending Mode"), this);
 //    action->setDefaultShortcut(QKeySequence(Qt::SHIFT + Qt::ALT + Qt::Key_Plus));
 //    connect(action, SIGNAL(triggered()), SLOT(slotNextBlendingMode()));
 //    m_actions << action;
 
 //    action = new KisAction(i18n("Previous Blending Mode"), this);
 //    action->setDefaultShortcut(QKeySequence(Qt::SHIFT + Qt::ALT +  Qt::Key_Minus));
 //    connect(action, SIGNAL(triggered()), SLOT(slotPreviousBlendingMode()));
 //    m_actions << action;
 
     //    Normal
     //    Shift + Alt + N
     action = new KisAction(i18n("Select Normal Blending Mode"), this);
     action->setDefaultShortcut(QKeySequence(Qt::SHIFT + Qt::ALT + Qt::Key_N));
     connect(action, SIGNAL(triggered()), SLOT(slotNormal()));
-    m_actions << action;
+    actions << action;
 
     //    Dissolve
     //    Shift + Alt + I
     action = new KisAction(i18n("Select Dissolve Blending Mode"), this);
     action->setDefaultShortcut(QKeySequence(Qt::SHIFT + Qt::ALT + Qt::Key_I));
     connect(action, SIGNAL(triggered()), SLOT(slotDissolve()));
-    m_actions << action;
+    actions << action;
 
     //    Behind (Brush tool only)
     //    Shift + Alt + Q
     action = new KisAction(i18n("Select Behind Blending Mode"), this);
     action->setDefaultShortcut(QKeySequence(Qt::SHIFT + Qt::ALT + Qt::Key_Q));
     connect(action, SIGNAL(triggered()), SLOT(slotBehind()));
-    m_actions << action;
+    actions << action;
 
     //    Clear (Brush tool only)
     //    Shift + Alt + R
     action = new KisAction(i18n("Select Clear Blending Mode"), this);
     action->setDefaultShortcut(QKeySequence(Qt::SHIFT + Qt::ALT + Qt::Key_R));
     connect(action, SIGNAL(triggered()), SLOT(slotClear()));
-    m_actions << action;
+    actions << action;
 
     //    Darken
     //    Shift + Alt + K
     action = new KisAction(i18n("Select Darken Blending Mode"), this);
     action->setDefaultShortcut(QKeySequence(Qt::SHIFT + Qt::ALT + Qt::Key_K));
     connect(action, SIGNAL(triggered()), SLOT(slotDarken()));
-    m_actions << action;
+    actions << action;
 
     //    Multiply
     //    Shift + Alt + M
     action = new KisAction(i18n("Select Multiply Blending Mode"), this);
     action->setDefaultShortcut(QKeySequence(Qt::SHIFT + Qt::ALT + Qt::Key_M));
     connect(action, SIGNAL(triggered()), SLOT(slotMultiply()));
-    m_actions << action;
+    actions << action;
 
     //    Color Burn
     //    Shift + Alt + B
     action = new KisAction(i18n("Select Color Burn Blending Mode"), this);
     action->setDefaultShortcut(QKeySequence(Qt::SHIFT + Qt::ALT + Qt::Key_B));
     connect(action, SIGNAL(triggered()), SLOT(slotColorBurn()));
-    m_actions << action;
+    actions << action;
 
     //    Linear Burn
     //    Shift + Alt + A
     action = new KisAction(i18n("Select Linear Burn Blending Mode"), this);
     action->setDefaultShortcut(QKeySequence(Qt::SHIFT + Qt::ALT + Qt::Key_A));
     connect(action, SIGNAL(triggered()), SLOT(slotLinearBurn()));
-    m_actions << action;
+    actions << action;
 
     //    Lighten
     //    Shift + Alt + G
     action = new KisAction(i18n("Select Lighten Blending Mode"), this);
     action->setDefaultShortcut(QKeySequence(Qt::SHIFT + Qt::ALT + Qt::Key_G));
     connect(action, SIGNAL(triggered()), SLOT(slotLighten()));
-    m_actions << action;
+    actions << action;
 
     //    Screen
     //    Shift + Alt + S
     action = new KisAction(i18n("Select Screen Blending Mode"), this);
     action->setDefaultShortcut(QKeySequence(Qt::SHIFT + Qt::ALT + Qt::Key_S));
     connect(action, SIGNAL(triggered()), SLOT(slotScreen()));
-    m_actions << action;
+    actions << action;
 
     //    Color Dodge
     //    Shift + Alt + D
     action = new KisAction(i18n("Select Color Dodge Blending Mode"), this);
     action->setDefaultShortcut(QKeySequence(Qt::SHIFT + Qt::ALT + Qt::Key_D));
     connect(action, SIGNAL(triggered()), SLOT(slotColorDodge()));
-    m_actions << action;
+    actions << action;
 
     //    Linear Dodge
     //    Shift + Alt + W
     action = new KisAction(i18n("Select Linear Dodge Blending Mode"), this);
     action->setDefaultShortcut(QKeySequence(Qt::SHIFT + Qt::ALT + Qt::Key_W));
     connect(action, SIGNAL(triggered()), SLOT(slotLinearDodge()));
-    m_actions << action;
+    actions << action;
 
     //    Overlay
     //    Shift + Alt + O
     action = new KisAction(i18n("Select Overlay Blending Mode"), this);
     action->setDefaultShortcut(QKeySequence(Qt::SHIFT + Qt::ALT + Qt::Key_O));
     connect(action, SIGNAL(triggered()), SLOT(slotOverlay()));
-    m_actions << action;
+    actions << action;
 
     //    Hard Overlay
     //    Shift + Alt + P
     action = new KisAction(i18n("Select Hard Overlay Blending Mode"), this);
     action->setDefaultShortcut(QKeySequence(Qt::SHIFT + Qt::ALT + Qt::Key_P));
     connect(action, SIGNAL(triggered()), SLOT(slotHardOverlay()));
-    m_actions << action;
+    actions << action;
 
     //    Soft Light
     //    Shift + Alt + F
     action = new KisAction(i18n("Select Soft Light Blending Mode"), this);
     action->setDefaultShortcut(QKeySequence(Qt::SHIFT + Qt::ALT + Qt::Key_F));
     connect(action, SIGNAL(triggered()), SLOT(slotSoftLight()));
-    m_actions << action;
+    actions << action;
 
     //    Hard Light
     //    Shift + Alt + H
     action = new KisAction(i18n("Select Hard Light Blending Mode"), this);
     action->setDefaultShortcut(QKeySequence(Qt::SHIFT + Qt::ALT + Qt::Key_H));
     connect(action, SIGNAL(triggered()), SLOT(slotHardLight()));
-    m_actions << action;
+    actions << action;
 
     //    Vivid Light
     //    Shift + Alt + V
     action = new KisAction(i18n("Select Vivid Light Blending Mode"), this);
     action->setDefaultShortcut(QKeySequence(Qt::SHIFT + Qt::ALT + Qt::Key_V));
     connect(action, SIGNAL(triggered()), SLOT(slotVividLight()));
-    m_actions << action;
+    actions << action;
 
     //    Linear Light
     //    Shift + Alt + J
     action = new KisAction(i18n("Select Linear Light Blending Mode"), this);
     action->setDefaultShortcut(QKeySequence(Qt::SHIFT + Qt::ALT + Qt::Key_J));
     connect(action, SIGNAL(triggered()), SLOT(slotLinearLight()));
-    m_actions << action;
+    actions << action;
 
     //    Pin Light
     //    Shift + Alt + Z
     action = new KisAction(i18n("Select Pin Light Blending Mode"), this);
     action->setDefaultShortcut(QKeySequence(Qt::SHIFT + Qt::ALT + Qt::Key_Z));
     connect(action, SIGNAL(triggered()), SLOT(slotPinLight()));
-    m_actions << action;
+    actions << action;
 
     //    Hard Mix
     //    Shift + Alt + L
     action = new KisAction(i18n("Select Hard Mix Blending Mode"), this);
     action->setDefaultShortcut(QKeySequence(Qt::SHIFT + Qt::ALT + Qt::Key_L));
     connect(action, SIGNAL(triggered()), SLOT(slotHardMix()));
-    m_actions << action;
+    actions << action;
 
     //    Difference
     //    Shift + Alt + E
     action = new KisAction(i18n("Select Difference Blending Mode"), this);
     action->setDefaultShortcut(QKeySequence(Qt::SHIFT + Qt::ALT + Qt::Key_E));
     connect(action, SIGNAL(triggered()), SLOT(slotDifference()));
-    m_actions << action;
+    actions << action;
 
     //    Exclusion
     //    Shift + Alt + X
     action = new KisAction(i18n("Select Exclusion Blending Mode"), this);
     action->setDefaultShortcut(QKeySequence(Qt::SHIFT + Qt::ALT + Qt::Key_X));
     connect(action, SIGNAL(triggered()), SLOT(slotExclusion()));
-    m_actions << action;
+    actions << action;
 
     //    Hue
     //    Shift + Alt + U
     action = new KisAction(i18n("Select Hue Blending Mode"), this);
     action->setDefaultShortcut(QKeySequence(Qt::SHIFT + Qt::ALT + Qt::Key_U));
     connect(action, SIGNAL(triggered()), SLOT(slotHue()));
-    m_actions << action;
+    actions << action;
 
     //    Saturation
     //    Shift + Alt + T
     action = new KisAction(i18n("Select Saturation Blending Mode"), this);
     action->setDefaultShortcut(QKeySequence(Qt::SHIFT + Qt::ALT + Qt::Key_T));
     connect(action, SIGNAL(triggered()), SLOT(slotSaturation()));
-    m_actions << action;
+    actions << action;
 
     //    Color
     //    Shift + Alt + C
     action = new KisAction(i18n("Select Color Blending Mode"), this);
     action->setDefaultShortcut(QKeySequence(Qt::SHIFT + Qt::ALT + Qt::Key_C));
     connect(action, SIGNAL(triggered()), SLOT(slotColor()));
-    m_actions << action;
+    actions << action;
 
     //    Luminosity
     //    Shift + Alt + Y
     action = new KisAction(i18n("Select Luminosity Blending Mode"), this);
     action->setDefaultShortcut(QKeySequence(Qt::SHIFT + Qt::ALT + Qt::Key_Y));
     connect(action, SIGNAL(triggered()), SLOT(slotLuminosity()));
-    m_actions << action;
-
+    actions << action;
 
-}
-
-KisCompositeOpComboBox::~KisCompositeOpComboBox()
-{
-    delete m_view;
+    return actions;
 }
 
 void KisCompositeOpComboBox::validate(const KoColorSpace *cs) {
     m_model->validate(cs);
 }
 
 void KisCompositeOpComboBox::selectCompositeOp(const KoID &op) {
     QModelIndex index = m_model->indexOf(op);
     setCurrentIndex(index.row());
 }
 
 KoID KisCompositeOpComboBox::selectedCompositeOp() const {
     KoID op;
 
     if (m_model->entryAt(op, m_model->index(currentIndex(), 0))) {
         return op;
     }
     return KoCompositeOpRegistry::instance().getDefaultCompositeOp();
 }
 
-
-QList<KisAction *> KisCompositeOpComboBox::blendmodeActions() const
-{
-    return m_actions;
-}
-
 void KisCompositeOpComboBox::slotCategoryToggled(const QModelIndex& index, bool toggled)
 {
     Q_UNUSED(index);
     Q_UNUSED(toggled);
 
     //NOTE: this will (should) fit the size of the
     //      popup widget to the view
     //      don't know if this is expected behaviour
     //      on all supported platforms.
     //      There is nothing written about this in the docs.
     showPopup();
 }
 
 void KisCompositeOpComboBox::slotEntryChecked(const QModelIndex& index)
 {
     Q_UNUSED(index);
     m_allowToHidePopup = false;
 }
 
 void KisCompositeOpComboBox::hidePopup()
 {
     if (m_allowToHidePopup) {
         QComboBox::hidePopup();
     }
     else  {
         QComboBox::showPopup();
     }
 
     m_allowToHidePopup = true;
 }
 
 void KisCompositeOpComboBox::slotNextBlendingMode()
 {
     if (currentIndex() < count()) {
         setCurrentIndex(currentIndex() + 1);
     }
 }
 
 void KisCompositeOpComboBox::slotPreviousBlendingMode()
 {
     if (currentIndex() > 0) {
         setCurrentIndex(currentIndex() - 1);
     }
 }
 
 void KisCompositeOpComboBox::slotNormal()
 {
     selectCompositeOp(KoCompositeOpRegistry::instance().getKoID(COMPOSITE_OVER));
 }
 
 void KisCompositeOpComboBox::slotDissolve()
 {
     selectCompositeOp(KoCompositeOpRegistry::instance().getKoID(COMPOSITE_DISSOLVE));
 }
 
 void KisCompositeOpComboBox::slotBehind()
 {
     selectCompositeOp(KoCompositeOpRegistry::instance().getKoID(COMPOSITE_BEHIND));
 }
 
 void KisCompositeOpComboBox::slotClear()
 {
     selectCompositeOp(KoCompositeOpRegistry::instance().getKoID(COMPOSITE_CLEAR));
 }
 
 void KisCompositeOpComboBox::slotDarken()
 {
     selectCompositeOp(KoCompositeOpRegistry::instance().getKoID(COMPOSITE_DARKEN));
 }
 
 void KisCompositeOpComboBox::slotMultiply()
 {
     selectCompositeOp(KoCompositeOpRegistry::instance().getKoID(COMPOSITE_MULT));
 }
 
 void KisCompositeOpComboBox::slotColorBurn()
 {
     selectCompositeOp(KoCompositeOpRegistry::instance().getKoID(COMPOSITE_BURN));
 }
 
 void KisCompositeOpComboBox::slotLinearBurn()
 {
     selectCompositeOp(KoCompositeOpRegistry::instance().getKoID(COMPOSITE_LINEAR_BURN));
 }
 
 void KisCompositeOpComboBox::slotLighten()
 {
     selectCompositeOp(KoCompositeOpRegistry::instance().getKoID(COMPOSITE_LIGHTEN));
 }
 
 void KisCompositeOpComboBox::slotScreen()
 {
     selectCompositeOp(KoCompositeOpRegistry::instance().getKoID(COMPOSITE_SCREEN));
 }
 
 void KisCompositeOpComboBox::slotColorDodge()
 {
     selectCompositeOp(KoCompositeOpRegistry::instance().getKoID(COMPOSITE_DODGE));
 }
 
 void KisCompositeOpComboBox::slotLinearDodge()
 {
     selectCompositeOp(KoCompositeOpRegistry::instance().getKoID(COMPOSITE_LINEAR_DODGE));
 }
 
 void KisCompositeOpComboBox::slotOverlay()
 {
     selectCompositeOp(KoCompositeOpRegistry::instance().getKoID(COMPOSITE_OVERLAY));
 }
 
 void KisCompositeOpComboBox::slotHardOverlay()
 {
     selectCompositeOp(KoCompositeOpRegistry::instance().getKoID(COMPOSITE_HARD_OVERLAY));
 }
 
 void KisCompositeOpComboBox::slotSoftLight()
 {
     selectCompositeOp(KoCompositeOpRegistry::instance().getKoID(COMPOSITE_SOFT_LIGHT_PHOTOSHOP));
 }
 
 void KisCompositeOpComboBox::slotHardLight()
 {
     selectCompositeOp(KoCompositeOpRegistry::instance().getKoID(COMPOSITE_HARD_LIGHT));
 }
 
 void KisCompositeOpComboBox::slotVividLight()
 {
     selectCompositeOp(KoCompositeOpRegistry::instance().getKoID(COMPOSITE_VIVID_LIGHT));
 }
 
 void KisCompositeOpComboBox::slotLinearLight()
 {
     selectCompositeOp(KoCompositeOpRegistry::instance().getKoID(COMPOSITE_LINEAR_LIGHT));
 }
 
 void KisCompositeOpComboBox::slotPinLight()
 {
     selectCompositeOp(KoCompositeOpRegistry::instance().getKoID(COMPOSITE_PIN_LIGHT));
 }
 
 void KisCompositeOpComboBox::slotHardMix()
 {
     selectCompositeOp(KoCompositeOpRegistry::instance().getKoID(COMPOSITE_HARD_MIX_PHOTOSHOP));
 }
 
 void KisCompositeOpComboBox::slotDifference()
 {
     selectCompositeOp(KoCompositeOpRegistry::instance().getKoID(COMPOSITE_DIFF));
 }
 
 void KisCompositeOpComboBox::slotExclusion()
 {
     selectCompositeOp(KoCompositeOpRegistry::instance().getKoID(COMPOSITE_EXCLUSION));
 }
 
 void KisCompositeOpComboBox::slotHue()
 {
     selectCompositeOp(KoCompositeOpRegistry::instance().getKoID(COMPOSITE_HUE));
 }
 
 void KisCompositeOpComboBox::slotSaturation()
 {
     selectCompositeOp(KoCompositeOpRegistry::instance().getKoID(COMPOSITE_SATURATION));
 }
 
 void KisCompositeOpComboBox::slotColor()
 {
     selectCompositeOp(KoCompositeOpRegistry::instance().getKoID(COMPOSITE_COLOR));
 }
 
 void KisCompositeOpComboBox::slotLuminosity()
 {
     selectCompositeOp(KoCompositeOpRegistry::instance().getKoID(COMPOSITE_LUMINIZE));
 }
+
+KisLayerStyleCompositeOpComboBox::KisLayerStyleCompositeOpComboBox(QWidget* parent)
+    : KisCompositeOpComboBox(true, parent)
+{
+}
diff --git a/libs/ui/widgets/kis_cmb_composite.h b/libs/ui/widgets/kis_cmb_composite.h
index 6a23567d63..9eeb99f135 100644
--- a/libs/ui/widgets/kis_cmb_composite.h
+++ b/libs/ui/widgets/kis_cmb_composite.h
@@ -1,105 +1,111 @@
 /*
  *  widgets/kis_cmb_composite.h - part of KImageShop/Krayon/Krita
  *
  *  Copyright (c) 2004 Boudewijn Rempt (boud@valdyas.org)
  *  Copyright (c) 2011 Silvio Heinrich <plassy@web.de>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_COMPOSITEOP_WIDGETS_H_
 #define KIS_COMPOSITEOP_WIDGETS_H_
 
 #include <QComboBox>
 #include <KisSqueezedComboBox.h>
 #include <kritaui_export.h>
 #include "kis_categorized_list_view.h"
 
 class KoID;
 class KoColorSpace;
 class KisSortedCompositeOpListModel;
 class KisAction;
 
 class KRITAUI_EXPORT KisCompositeOpListWidget: public KisCategorizedListView
 {
 public:
-     KisCompositeOpListWidget(QWidget* parent=0);
-    ~KisCompositeOpListWidget() override;
+     KisCompositeOpListWidget(QWidget* parent = 0);
+     ~KisCompositeOpListWidget() override;
 
     KoID selectedCompositeOp() const;
 
 private:
     KisSortedCompositeOpListModel *m_model;
 };
 
 
 class KRITAUI_EXPORT KisCompositeOpComboBox: public KisSqueezedComboBox
 {
     Q_OBJECT
 public:
-     KisCompositeOpComboBox(QWidget* parent=0);
+     KisCompositeOpComboBox(QWidget* parent = 0);
+     KisCompositeOpComboBox(bool limitToLayerStyles, QWidget* parent = 0);
     ~KisCompositeOpComboBox() override;
 
     void hidePopup() override;
 
     void validate(const KoColorSpace *cs);
     void selectCompositeOp(const KoID &op);
     KoID selectedCompositeOp() const;
 
-    QList<KisAction *> blendmodeActions() const;
+    QList<KisAction *> createBlendmodeActions();
 
 private Q_SLOTS:
     void slotCategoryToggled(const QModelIndex& index, bool toggled);
     void slotEntryChecked(const QModelIndex& index);
 
     void slotNextBlendingMode();
     void slotPreviousBlendingMode();
     void slotNormal();
     void slotDissolve();
     void slotBehind();
     void slotClear();
     void slotDarken();
     void slotMultiply();
     void slotColorBurn();
     void slotLinearBurn();
     void slotLighten();
     void slotScreen();
     void slotColorDodge();
     void slotLinearDodge();
     void slotOverlay();
     void slotHardOverlay();
     void slotSoftLight();
     void slotHardLight();
     void slotVividLight();
     void slotLinearLight();
     void slotPinLight();
     void slotHardMix();
     void slotDifference();
     void slotExclusion();
     void slotHue();
     void slotSaturation();
     void slotColor();
     void slotLuminosity();
 
 
 
 private:
     KisSortedCompositeOpListModel *m_model;
     KisCategorizedListView *m_view;
     bool m_allowToHidePopup;
-    QList<KisAction *> m_actions;
+};
+
+class KRITAUI_EXPORT KisLayerStyleCompositeOpComboBox: public KisCompositeOpComboBox
+{
+public:
+    KisLayerStyleCompositeOpComboBox(QWidget* parent = 0);
 };
 
 #endif // KIS_COMPOSITEOP_WIDGETS_H_
diff --git a/plugins/color/lcms2engine/colorspaces/rgb_f32/RgbF32ColorSpace.cpp b/plugins/color/lcms2engine/colorspaces/rgb_f32/RgbF32ColorSpace.cpp
index e8308bbf41..623a80ffad 100644
--- a/plugins/color/lcms2engine/colorspaces/rgb_f32/RgbF32ColorSpace.cpp
+++ b/plugins/color/lcms2engine/colorspaces/rgb_f32/RgbF32ColorSpace.cpp
@@ -1,114 +1,116 @@
 /*
  *  Copyright (c) 2006 Cyrille Berger <cberger@cberger.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #include "RgbF32ColorSpace.h"
 
 #include <QDomElement>
 
 #include <klocalizedstring.h>
 
 #include "compositeops/KoCompositeOps.h"
 
 #include "compositeops/RgbCompositeOps.h"
 #include <kis_dom_utils.h>
+#include <KoColorConversions.h>
+#include <KoColorSpaceMaths.h>
 
 RgbF32ColorSpace::RgbF32ColorSpace(const QString &name, KoColorProfile *p) :
     LcmsColorSpace<KoRgbF32Traits>(colorSpaceId(), name, TYPE_RGBA_FLT, cmsSigRgbData, p)
 {
     const IccColorProfile *icc_p = dynamic_cast<const IccColorProfile *>(p);
     Q_ASSERT(icc_p);
     QVector<KoChannelInfo::DoubleRange> uiRanges(icc_p->getFloatUIMinMax());
     Q_ASSERT(uiRanges.size() == 3);
 
     addChannel(new KoChannelInfo(i18n("Red"), 0 * sizeof(float), 0, KoChannelInfo::COLOR, KoChannelInfo::FLOAT32, 4, QColor(255, 0, 0), uiRanges[0]));
     addChannel(new KoChannelInfo(i18n("Green"), 1 * sizeof(float), 1, KoChannelInfo::COLOR, KoChannelInfo::FLOAT32, 4, QColor(0, 255, 0), uiRanges[1]));
     addChannel(new KoChannelInfo(i18n("Blue"), 2 * sizeof(float), 2, KoChannelInfo::COLOR, KoChannelInfo::FLOAT32, 4, QColor(0, 0, 255), uiRanges[2]));
     addChannel(new KoChannelInfo(i18n("Alpha"), 3 * sizeof(float), 3, KoChannelInfo::ALPHA, KoChannelInfo::FLOAT32, 4));
 
     init();
 
     addStandardCompositeOps<KoRgbF32Traits>(this);
 
     addCompositeOp(new RgbCompositeOpIn<KoRgbF32Traits>(this));
     addCompositeOp(new RgbCompositeOpOut<KoRgbF32Traits>(this));
     addCompositeOp(new RgbCompositeOpBumpmap<KoRgbF32Traits>(this));
 }
 
 bool RgbF32ColorSpace::willDegrade(ColorSpaceIndependence independence) const
 {
     if (independence == TO_RGBA16) {
         return true;
     } else {
         return false;
     }
 }
 
 KoColorSpace *RgbF32ColorSpace::clone() const
 {
     return new RgbF32ColorSpace(name(), profile()->clone());
 }
 
 void RgbF32ColorSpace::colorToXML(const quint8 *pixel, QDomDocument &doc, QDomElement &colorElt) const
 {
     const KoRgbF32Traits::Pixel *p = reinterpret_cast<const KoRgbF32Traits::Pixel *>(pixel);
     QDomElement labElt = doc.createElement("RGB");
     labElt.setAttribute("r", KisDomUtils::toString(KoColorSpaceMaths< KoRgbF32Traits::channels_type, qreal>::scaleToA(p->red)));
     labElt.setAttribute("g", KisDomUtils::toString(KoColorSpaceMaths< KoRgbF32Traits::channels_type, qreal>::scaleToA(p->green)));
     labElt.setAttribute("b", KisDomUtils::toString(KoColorSpaceMaths< KoRgbF32Traits::channels_type, qreal>::scaleToA(p->blue)));
     labElt.setAttribute("space", profile()->name());
     colorElt.appendChild(labElt);
 }
 
 void RgbF32ColorSpace::colorFromXML(quint8 *pixel, const QDomElement &elt) const
 {
     KoRgbF32Traits::Pixel *p = reinterpret_cast<KoRgbF32Traits::Pixel *>(pixel);
     p->red = KoColorSpaceMaths< qreal, KoRgbF32Traits::channels_type >::scaleToA(KisDomUtils::toDouble(elt.attribute("r")));
     p->green = KoColorSpaceMaths< qreal, KoRgbF32Traits::channels_type >::scaleToA(KisDomUtils::toDouble(elt.attribute("g")));
     p->blue = KoColorSpaceMaths< qreal, KoRgbF32Traits::channels_type >::scaleToA(KisDomUtils::toDouble(elt.attribute("b")));
     p->alpha = 1.0;
 }
 
 void RgbF32ColorSpace::toHSY(const QVector<double> &channelValues, qreal *hue, qreal *sat, qreal *luma) const
 {
     RGBToHSY(channelValues[0],channelValues[1],channelValues[2], hue, sat, luma, lumaCoefficients()[0], lumaCoefficients()[1], lumaCoefficients()[2]);
 }
 
 QVector <double> RgbF32ColorSpace::fromHSY(qreal *hue, qreal *sat, qreal *luma) const
 {
     QVector <double> channelValues(4);
     HSYToRGB(*hue, *sat, *luma, &channelValues[0],&channelValues[1],&channelValues[2], lumaCoefficients()[0], lumaCoefficients()[1], lumaCoefficients()[2]);
     channelValues[3]=1.0;
     return channelValues;
 }
 
 void RgbF32ColorSpace::toYUV(const QVector<double> &channelValues, qreal *y, qreal *u, qreal *v) const
 {
 
     
     RGBToYUV(channelValues[0],channelValues[1],channelValues[2], y, u, v, lumaCoefficients()[0], lumaCoefficients()[1], lumaCoefficients()[2]);
 }
 
 QVector <double> RgbF32ColorSpace::fromYUV(qreal *y, qreal *u, qreal *v) const
 {
     QVector <double> channelValues(4);
 
     YUVToRGB(*y, *u, *v, &channelValues[0],&channelValues[1],&channelValues[2], lumaCoefficients()[0], lumaCoefficients()[1], lumaCoefficients()[2]);
     channelValues[3]=1.0;
     return channelValues;
 }
diff --git a/plugins/color/lcms2engine/colorspaces/rgb_u16/RgbU16ColorSpace.cpp b/plugins/color/lcms2engine/colorspaces/rgb_u16/RgbU16ColorSpace.cpp
index 873980caad..981910f385 100644
--- a/plugins/color/lcms2engine/colorspaces/rgb_u16/RgbU16ColorSpace.cpp
+++ b/plugins/color/lcms2engine/colorspaces/rgb_u16/RgbU16ColorSpace.cpp
@@ -1,107 +1,108 @@
 /*
  *  Copyright (c) 2006 Cyrille Berger <cberger@cberger.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #include "RgbU16ColorSpace.h"
 
 #include <QDomElement>
 
 #include <klocalizedstring.h>
 
 #include "compositeops/KoCompositeOps.h"
 #include "compositeops/RgbCompositeOps.h"
 #include "kis_dom_utils.h"
+#include <KoColorConversions.h>
 
 RgbU16ColorSpace::RgbU16ColorSpace(const QString &name, KoColorProfile *p) :
     LcmsColorSpace<KoBgrU16Traits>(colorSpaceId(), name, TYPE_BGRA_16, cmsSigRgbData, p)
 {
     addChannel(new KoChannelInfo(i18n("Blue"), 0 * sizeof(quint16), 2, KoChannelInfo::COLOR, KoChannelInfo::UINT16, 2, QColor(0, 0, 255)));
     addChannel(new KoChannelInfo(i18n("Green"), 1 * sizeof(quint16), 1, KoChannelInfo::COLOR, KoChannelInfo::UINT16, 2, QColor(0, 255, 0)));
     addChannel(new KoChannelInfo(i18n("Red"), 2 * sizeof(quint16), 0, KoChannelInfo::COLOR, KoChannelInfo::UINT16, 2, QColor(255, 0, 0)));
     addChannel(new KoChannelInfo(i18n("Alpha"), 3 * sizeof(quint16), 3, KoChannelInfo::ALPHA, KoChannelInfo::UINT16, 2));
     init();
 
     addStandardCompositeOps<KoBgrU16Traits>(this);
 
     addCompositeOp(new RgbCompositeOpIn<KoBgrU16Traits>(this));
     addCompositeOp(new RgbCompositeOpOut<KoBgrU16Traits>(this));
     addCompositeOp(new RgbCompositeOpBumpmap<KoBgrU16Traits>(this));
 }
 
 bool RgbU16ColorSpace::willDegrade(ColorSpaceIndependence independence) const
 {
     if (independence == TO_RGBA8) {
         return true;
     } else {
         return false;
     }
 }
 
 KoColorSpace *RgbU16ColorSpace::clone() const
 {
     return new RgbU16ColorSpace(name(), profile()->clone());
 }
 
 void RgbU16ColorSpace::colorToXML(const quint8 *pixel, QDomDocument &doc, QDomElement &colorElt) const
 {
     const KoBgrU16Traits::Pixel *p = reinterpret_cast<const KoBgrU16Traits::Pixel *>(pixel);
     QDomElement labElt = doc.createElement("RGB");
     labElt.setAttribute("r", KisDomUtils::toString(KoColorSpaceMaths< KoBgrU16Traits::channels_type, qreal>::scaleToA(p->red)));
     labElt.setAttribute("g", KisDomUtils::toString(KoColorSpaceMaths< KoBgrU16Traits::channels_type, qreal>::scaleToA(p->green)));
     labElt.setAttribute("b", KisDomUtils::toString(KoColorSpaceMaths< KoBgrU16Traits::channels_type, qreal>::scaleToA(p->blue)));
     labElt.setAttribute("space", profile()->name());
     colorElt.appendChild(labElt);
 }
 
 void RgbU16ColorSpace::colorFromXML(quint8 *pixel, const QDomElement &elt) const
 {
     KoBgrU16Traits::Pixel *p = reinterpret_cast<KoBgrU16Traits::Pixel *>(pixel);
     p->red = KoColorSpaceMaths< qreal, KoBgrU16Traits::channels_type >::scaleToA(KisDomUtils::toDouble(elt.attribute("r")));
     p->green = KoColorSpaceMaths< qreal, KoBgrU16Traits::channels_type >::scaleToA(KisDomUtils::toDouble(elt.attribute("g")));
     p->blue = KoColorSpaceMaths< qreal, KoBgrU16Traits::channels_type >::scaleToA(KisDomUtils::toDouble(elt.attribute("b")));
     p->alpha = KoColorSpaceMathsTraits<quint16>::max;
 }
 
 void RgbU16ColorSpace::toHSY(const QVector<double> &channelValues, qreal *hue, qreal *sat, qreal *luma) const
 {
     RGBToHSY(channelValues[0],channelValues[1],channelValues[2], hue, sat, luma, lumaCoefficients()[0], lumaCoefficients()[1], lumaCoefficients()[2]);
 }
 
 QVector <double> RgbU16ColorSpace::fromHSY(qreal *hue, qreal *sat, qreal *luma) const
 {
     QVector <double> channelValues(4);
     HSYToRGB(*hue, *sat, *luma, &channelValues[0],&channelValues[1],&channelValues[2], lumaCoefficients()[0], lumaCoefficients()[1], lumaCoefficients()[2]);
     channelValues[3]=1.0;
     return channelValues;
 }
 
 void RgbU16ColorSpace::toYUV(const QVector<double> &channelValues, qreal *y, qreal *u, qreal *v) const
 {
 
     
     RGBToYUV(channelValues[0],channelValues[1],channelValues[2], y, u, v, lumaCoefficients()[0], lumaCoefficients()[1], lumaCoefficients()[2]);
 }
 
 QVector <double> RgbU16ColorSpace::fromYUV(qreal *y, qreal *u, qreal *v) const
 {
     QVector <double> channelValues(4);
 
     YUVToRGB(*y, *u, *v, &channelValues[0],&channelValues[1],&channelValues[2], lumaCoefficients()[0], lumaCoefficients()[1], lumaCoefficients()[2]);
     channelValues[3]=1.0;
     return channelValues;
 }
diff --git a/plugins/color/lcms2engine/compositeops/RgbCompositeOpClear.h b/plugins/color/lcms2engine/compositeops/RgbCompositeOpClear.h
deleted file mode 100644
index b372013237..0000000000
--- a/plugins/color/lcms2engine/compositeops/RgbCompositeOpClear.h
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- *  Copyright (c) 2006 Boudewijn Rempt <boud@valdyas.org>
- *
- *  This library is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser General Public License as published by
- *  the Free Software Foundation, either version 2.1 of the License, or
- *  (at your option) any later version.
- *
- *  This library is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY const; 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 const; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-
-#ifndef RGBCOMPOSITEOPCLEAR_H
-#define RGBCOMPOSITEOPCLEAR_H
-
-#include <KoCompositeOp.h>
-
-template<class _CSTraits>
-class RgbCompositeOpClear : public KoCompositeOp
-{
-    typedef typename _CSTraits::channels_type channels_type;
-    typedef typename KoColorSpaceMathsTraits<typename _CSTraits::channels_type>::compositetype compositetype;
-
-public:
-
-    RgbCompositeOpClear(KoColorSpace *cs)
-        : KoCompositeOp(cs, COMPOSITE_CLEAR, i18n("Clear"), "")
-    {
-    }
-
-    using KoCompositeOp::composite;
-
-    void composite(quint8 *dstRowStart, qint32 dstRowStride,
-                   const quint8 *srcRowStart, qint32 srcRowStride,
-                   const quint8 *maskRowStart, qint32 maskRowStride,
-                   qint32 rows, qint32 numColumns,
-                   quint8 opacity,
-                   const QBitArray &channelFlags) const override
-    {
-        Q_UNUSED(opacity);
-        Q_UNUSED(srcRowStart);
-        Q_UNUSED(srcRowStride);
-        Q_UNUSED(maskRowStart);
-        Q_UNUSED(maskRowStride);
-
-        qint32 channelSize = sizeof(channels_type);
-        qint32 linesize = _CSTraits::channels_nb * channelSize * numColumns;
-
-        if (channelFlags.isEmpty()) {
-            quint8 *d = dstRowStart;
-            while (rows-- > 0) {
-                memset(d, 0, linesize);
-                d += dstRowStride;
-            }
-        } else {
-            channels_type *d = reinterpret_cast<channels_type *>(dstRowStart);
-            while (rows-- > 0) {
-                for (int channel = 0; channel < MAX_CHANNEL_RGB; channel++) {
-                    if (channelFlags.testBit(channel)) {
-                        memset(d, 0, channelSize);
-                    }
-                    d++;
-                }
-            }
-        }
-    }
-
-};
-
-#endif
diff --git a/plugins/color/lcms2engine/compositeops/RgbCompositeOpColor.h b/plugins/color/lcms2engine/compositeops/RgbCompositeOpColor.h
deleted file mode 100644
index 826680a048..0000000000
--- a/plugins/color/lcms2engine/compositeops/RgbCompositeOpColor.h
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- *  Copyright (c) 2006 Boudewijn Rempt <boud@valdyas.org>
- *
- *  This library is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser General Public License as published by
- *  the Free Software Foundation, either version 2.1 of the License, or
- *  (at your option) any later version.
- *
- *  This library is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY const; 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 const; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-
-#ifndef RGBCOMPOSITEOPCOLOR_H
-#define RGBCOMPOSITEOPCOLOR_H
-
-#include "KoColorSpaceMaths.h"
-#include "KoColorConversions.h"
-#include <KoCompositeOpAlphaBase.h>
-
-#define SCALE_TO_FLOAT( v ) KoColorSpaceMaths< channels_type, float>::scaleToA( v )
-#define SCALE_FROM_FLOAT( v ) KoColorSpaceMaths< float, channels_type>::scaleToA( v )
-
-template<class _CSTraits>
-class RgbCompositeOpColor : public KoCompositeOpAlphaBase<_CSTraits, RgbCompositeOpColor<_CSTraits>, true >
-{
-    typedef typename _CSTraits::channels_type channels_type;
-    typedef typename KoColorSpaceMathsTraits<typename _CSTraits::channels_type>::compositetype compositetype;
-
-public:
-
-    RgbCompositeOpColor(KoColorSpace *cs)
-        : KoCompositeOpAlphaBase<_CSTraits, RgbCompositeOpColor<_CSTraits>, true >(cs, COMPOSITE_COLOR, i18n("Color"), KoCompositeOp::categoryMisc())
-    {
-    }
-
-    inline static channels_type selectAlpha(channels_type srcAlpha, channels_type dstAlpha)
-    {
-        return qMin(srcAlpha, dstAlpha);
-    }
-
-    inline static void composeColorChannels(channels_type srcBlend,
-                                            const channels_type *src,
-                                            channels_type *dst,
-                                            bool allChannelFlags,
-                                            const QBitArray &channelFlags)
-    {
-
-        float dstRed = SCALE_TO_FLOAT(dst[_CSTraits::red_pos]);
-        float dstGreen = SCALE_TO_FLOAT(dst[_CSTraits::green_pos]);
-        float dstBlue = SCALE_TO_FLOAT(dst[_CSTraits::blue_pos]);
-
-        float srcHue;
-        float srcSaturation;
-        float srcLightness;
-        float dstHue;
-        float dstSaturation;
-        float dstLightness;
-
-        float srcRed = SCALE_TO_FLOAT(src[_CSTraits::red_pos]);
-        float srcGreen = SCALE_TO_FLOAT(src[_CSTraits::green_pos]);
-        float srcBlue = SCALE_TO_FLOAT(src[_CSTraits::blue_pos]);
-
-        RGBToHSL(srcRed, srcGreen, srcBlue, &srcHue, &srcSaturation, &srcLightness);
-        RGBToHSL(dstRed, dstGreen, dstBlue, &dstHue, &dstSaturation, &dstLightness);
-        HSLToRGB(srcHue, srcSaturation, dstLightness, &srcRed, &srcGreen, &srcBlue);
-
-        if (allChannelFlags || channelFlags.testBit(_CSTraits::red_pos)) {
-            dst[_CSTraits::red_pos] = KoColorSpaceMaths<channels_type>::blend(SCALE_FROM_FLOAT(srcRed), SCALE_FROM_FLOAT(dstRed), srcBlend);
-        }
-        if (allChannelFlags || channelFlags.testBit(_CSTraits::green_pos)) {
-            dst[_CSTraits::green_pos] = KoColorSpaceMaths<channels_type>::blend(SCALE_FROM_FLOAT(srcGreen), SCALE_FROM_FLOAT(dstGreen), srcBlend);
-        }
-        if (allChannelFlags || channelFlags.testBit(_CSTraits::blue_pos)) {
-            dst[_CSTraits::blue_pos] = KoColorSpaceMaths<channels_type>::blend(SCALE_FROM_FLOAT(srcBlue), SCALE_FROM_FLOAT(dstBlue), srcBlend);
-        }
-    }
-};
-
-#endif
diff --git a/plugins/color/lcms2engine/compositeops/RgbCompositeOpDarken.h b/plugins/color/lcms2engine/compositeops/RgbCompositeOpDarken.h
deleted file mode 100644
index 3487beddeb..0000000000
--- a/plugins/color/lcms2engine/compositeops/RgbCompositeOpDarken.h
+++ /dev/null
@@ -1,115 +0,0 @@
-/*
- *  Copyright (c) 2006 Boudewijn Rempt <boud@valdyas.org>
- *
- *  This library is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser General Public License as published by
- *  the Free Software Foundation, either version 2.1 of the License, or
- *  (at your option) any later version.
- *
- *  This library is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY const; 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 const; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-
-#ifndef RGBCOMPOSITEOPDARKEN_H
-#define RGBCOMPOSITEOPDARKEN_H
-
-#include <KoCompositeOp.h>
-
-template<class _CSTraits>
-class RgbCompositeOpDarken : public KoCompositeOp
-{
-    typedef typename _CSTraits::channels_type channels_type;
-    typedef typename KoColorSpaceMathsTraits<typename _CSTraits::channels_type>::compositetype compositetype;
-
-public:
-
-    RgbCompositeOpDarken(KoColorSpace *cs)
-        : KoCompositeOp(cs, COMPOSITE_DARKEN, i18n("Darken"), "")
-    {
-    }
-
-    using KoCompositeOp::composite;
-
-    void composite(quint8 *dstRowStart, qint32 dstRowStride,
-                   const quint8 *srcRowStart, qint32 srcRowStride,
-                   const quint8 *maskRowStart, qint32 maskRowStride,
-                   qint32 rows, qint32 numColumns,
-                   quint8 opacity,
-                   const QBitArray &channelFlags) const override
-    {
-        while (rows > 0) {
-            const quint8 *mask = maskRowStart;
-            const channels_type *src = reinterpret_cast<const channels_type *>(srcRowStart);
-            channels_type *dst = reinterpret_cast<channels_type *>(dstRowStart);
-
-            for (int i = numColumns; i > 0; --i) {
-                channels_type srcAlpha = src[_CSTraits::alpha_pos];
-                channels_type dstAlpha = dst[_CSTraits::alpha_pos];
-
-                srcAlpha = qMin(srcAlpha, dstAlpha);
-
-                // apply the alphamask
-                if (mask != 0) {
-                    if (*mask != OPACITY_OPAQUE_U8) {
-                        channels_type tmpOpacity = KoColorSpaceMaths<quint8, channels_type>::scaleToA(*mask);
-                        srcAlpha =  KoColorSpaceMaths<channels_type>::multiply(srcAlpha, tmpOpacity);
-                    }
-                    mask++;
-                }
-
-                if (srcAlpha != NATIVE_OPACITY_TRANSPARENT) {
-                    if (opacity != OPACITY_OPAQUE_U8) {
-                        channels_type tmpOpacity = KoColorSpaceMaths<quint8, channels_type>::scaleToA(opacity);
-                        srcAlpha = KoColorSpaceMaths<channels_type>::multiply(src[_CSTraits::alpha_pos], tmpOpacity);
-                    }
-
-                    channels_type srcBlend;
-
-                    if (dstAlpha == NATIVE_OPACITY_OPAQUE) {
-                        srcBlend = srcAlpha;
-                    } else {
-                        channels_type newAlpha = dstAlpha + KoColorSpaceMaths<channels_type>::multiply(NATIVE_OPACITY_OPAQUE - dstAlpha, srcAlpha);
-                        dst[KoBgrU8Traits::alpha_pos] = newAlpha;
-
-                        if (newAlpha != 0) {
-                            srcBlend = KoColorSpaceMaths<channels_type>::divide(srcAlpha, newAlpha);
-                        } else {
-                            srcBlend = srcAlpha;
-                        }
-                    }
-
-                    for (int channel = 0; channel < MAX_CHANNEL_RGB; channel++) {
-                        if (channelFlags.isEmpty() || channelFlags.testBit(_CSTraits::alpha_pos)) {
-                            channels_type srcColor = src[channel];
-                            channels_type dstColor = dst[channel];
-
-                            srcColor = qMin(srcColor, dstColor);
-
-                            channels_type newColor = KoColorSpaceMaths<channels_type>::blend(srcColor, dstColor, srcBlend);
-
-                            dst[channel] = newColor;
-                        }
-                    }
-                }
-
-                src += _CSTraits::channels_nb;
-                dst += _CSTraits::channels_nb;
-            }
-
-            rows--;
-            srcRowStart += srcRowStride;
-            dstRowStart += dstRowStride;
-            if (maskRowStart) {
-                maskRowStart += maskRowStride;
-            }
-        }
-    }
-};
-
-#endif
diff --git a/plugins/color/lcms2engine/compositeops/RgbCompositeOpDiff.h b/plugins/color/lcms2engine/compositeops/RgbCompositeOpDiff.h
deleted file mode 100644
index 22ba6c010a..0000000000
--- a/plugins/color/lcms2engine/compositeops/RgbCompositeOpDiff.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- *  Copyright (c) 2006 Boudewijn Rempt <boud@valdyas.org>
- *
- *  This library is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser General Public License as published by
- *  the Free Software Foundation, either version 2.1 of the License, or
- *  (at your option) any later version.
- *
- *  This library is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY const; 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 const; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-
-#ifndef RGBCOMPOSITEOPDIFF_H
-#define RGBCOMPOSITEOPDIFF_H
-
-#include <KoCompositeOpAlphaBase.h>
-
-#define AbsoluteValue(x)  ((x) < 0 ? -(x) : (x))
-
-template<class _CSTraits>
-class RgbCompositeOpDiff : public KoCompositeOpAlphaBase<_CSTraits, RgbCompositeOpDiff<_CSTraits>, true >
-{
-    typedef typename _CSTraits::channels_type channels_type;
-    typedef typename KoColorSpaceMathsTraits<typename _CSTraits::channels_type>::compositetype compositetype;
-
-public:
-
-    RgbCompositeOpDiff(KoColorSpace *cs)
-        : KoCompositeOpAlphaBase<_CSTraits, RgbCompositeOpDiff<_CSTraits>, true >(cs, COMPOSITE_DIFF, i18n("Diff"), KoCompositeOp::categoryMisc())
-    {
-    }
-
-    inline static channels_type selectAlpha(channels_type srcAlpha, channels_type dstAlpha)
-    {
-        return qMin(srcAlpha, dstAlpha);
-    }
-
-    inline static void composeColorChannels(channels_type srcBlend,
-                                            const channels_type *src,
-                                            channels_type *dst,
-                                            bool allChannelFlags,
-                                            const QBitArray &channelFlags)
-    {
-        for (uint i = 0; i < _CSTraits::channels_nb; i++) {
-            if ((int)i != _CSTraits::alpha_pos  && (allChannelFlags || channelFlags.testBit(i))) {
-
-                channels_type diff = (channels_type)
-                                     AbsoluteValue(src[i] - (compositetype) dst[i]);
-
-                dst[i] = KoColorSpaceMaths<channels_type>::blend(diff, dst[i], srcBlend);
-            }
-        }
-    }
-
-};
-
-#endif
diff --git a/plugins/color/lcms2engine/compositeops/RgbCompositeOpDissolve.h b/plugins/color/lcms2engine/compositeops/RgbCompositeOpDissolve.h
deleted file mode 100644
index f29f2475bd..0000000000
--- a/plugins/color/lcms2engine/compositeops/RgbCompositeOpDissolve.h
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- *  Copyright (c) 2006 Boudewijn Rempt <boud@valdyas.org>
- *
- *  This library is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser General Public License as published by
- *  the Free Software Foundation, either version 2.1 of the License, or
- *  (at your option) any later version.
- *
- *  This library is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY const; 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 const; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-
-#ifndef RGBCOMPOSITEOPDISSOLVE_H
-#define RGBCOMPOSITEOPDISSOLVE_H
-
-#include <KoCompositeOp.h>
-
-template<class _CSTraits>
-class RgbCompositeOpDissolve : public KoCompositeOp
-{
-    typedef typename _CSTraits::channels_type channels_type;
-    typedef typename KoColorSpaceMathsTraits<typename _CSTraits::channels_type>::compositetype compositetype;
-
-public:
-
-    RgbCompositeOpDissolve(KoColorSpace *cs)
-        : KoCompositeOp(cs, COMPOSITE_DISSOLVE, i18n("Dissolve"), "")
-    {
-    }
-
-    using KoCompositeOp::composite;
-
-    void composite(quint8 *dstRowStart, qint32 dstRowStride,
-                   const quint8 *srcRowStart, qint32 srcRowStride,
-                   const quint8 *maskRowStart, qint32 maskRowStride,
-                   qint32 rows, qint32 numColumns,
-                   quint8 opacity,
-                   const QBitArray &channelFlags) const override
-    {
-        Q_UNUSED(maskRowStart);
-        Q_UNUSED(maskRowStride);
-
-        if (opacity == OPACITY_TRANSPARENT_U8) {
-            return;
-        }
-
-        channels_type *d;
-        const channels_type *s;
-
-        qint32 i;
-
-        qreal sAlpha, dAlpha;
-
-        while (rows-- > 0) {
-            d = reinterpret_cast<channels_type *>(dstRowStart);
-            s = reinterpret_cast<const channels_type *>(srcRowStart);
-            for (i = numColumns; i > 0; i--, d += _CSTraits::channels_nb, s += _CSTraits::channels_nb) {
-                // XXX: correct?
-                if (s[_CSTraits::alpha_pos] == NATIVE_OPACITY_TRANSPARENT) {
-                    continue;
-                }
-
-                sAlpha = NATIVE_OPACITY_OPAQUE - s[_CSTraits::alpha_pos];
-                dAlpha = NATIVE_OPACITY_OPAQUE - d[_CSTraits::alpha_pos];
-
-                if (channelFlags.isEmpty() || channelFlags.testBit(_CSTraits::red_pos))
-                    d[_CSTraits::red_pos] = (channels_type)(((qreal) sAlpha * s[_CSTraits::red_pos] +
-                                                            (NATIVE_OPACITY_OPAQUE - sAlpha) * d[_CSTraits::red_pos]) / NATIVE_OPACITY_OPAQUE + 0.5);
-
-                if (channelFlags.isEmpty() || channelFlags.testBit(_CSTraits::green_pos))
-                    d[_CSTraits::green_pos] = (channels_type)(((qreal) sAlpha * s[_CSTraits::green_pos] +
-                                              (NATIVE_OPACITY_OPAQUE - sAlpha) * d[_CSTraits::green_pos]) / NATIVE_OPACITY_OPAQUE + 0.5);
-
-                if (channelFlags.isEmpty() || channelFlags.testBit(_CSTraits::blue_pos))
-                    d[_CSTraits::blue_pos] = (channels_type)(((qreal) sAlpha * s[_CSTraits::blue_pos] +
-                                             (NATIVE_OPACITY_OPAQUE - sAlpha) * d[_CSTraits::blue_pos]) / NATIVE_OPACITY_OPAQUE + 0.5);
-
-                if (channelFlags.isEmpty() || channelFlags.testBit(_CSTraits::alpha_pos)) {
-                    d[_CSTraits::alpha_pos] = NATIVE_OPACITY_OPAQUE;
-                }
-
-            }
-            dstRowStart += dstRowStride;
-            srcRowStart += srcRowStride;
-
-        }
-    }
-
-};
-
-#endif
diff --git a/plugins/color/lcms2engine/compositeops/RgbCompositeOpHue.h b/plugins/color/lcms2engine/compositeops/RgbCompositeOpHue.h
deleted file mode 100644
index 35e4f8920f..0000000000
--- a/plugins/color/lcms2engine/compositeops/RgbCompositeOpHue.h
+++ /dev/null
@@ -1,140 +0,0 @@
-/*
- *  Copyright (c) 2006 Boudewijn Rempt <boud@valdyas.org>
- *
- *  This library is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser General Public License as published by
- *  the Free Software Foundation, either version 2.1 of the License, or
- *  (at your option) any later version.
- *
- *  This library is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY const; 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 const; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-
-#ifndef RGBCOMPOSITEOPHUE_H
-#define RGBCOMPOSITEOPHUE_H
-
-#include "KoColorConversions.h"
-#include <KoCompositeOp.h>
-
-#define SCALE_TO_FLOAT( v ) KoColorSpaceMaths< channels_type, float>::scaleToA( v )
-#define SCALE_FROM_FLOAT( v ) KoColorSpaceMaths< float, channels_type>::scaleToA( v )
-
-template<class _CSTraits>
-class RgbCompositeOpHue : public KoCompositeOp
-{
-    typedef typename _CSTraits::channels_type channels_type;
-    typedef typename KoColorSpaceMathsTraits<typename _CSTraits::channels_type>::compositetype compositetype;
-
-public:
-
-    RgbCompositeOpHue(KoColorSpace *cs)
-        : KoCompositeOp(cs, COMPOSITE_HUE, i18n("Hue"), "")
-    {
-    }
-
-    using KoCompositeOp::composite;
-
-    void composite(quint8 *dstRowStart, qint32 dstRowStride,
-                   const quint8 *srcRowStart, qint32 srcRowStride,
-                   const quint8 *maskRowStart, qint32 maskRowStride,
-                   qint32 rows, qint32 numColumns,
-                   quint8 opacity,
-                   const QBitArray &channelFlags) const override
-    {
-        channels_type *dst;
-        const channels_type *src;
-
-        while (rows > 0) {
-            const quint8 *mask = maskRowStart;
-            src = reinterpret_cast<const channels_type *>(srcRowStart);
-            dst = reinterpret_cast<channels_type *>(dstRowStart);
-
-            for (int i = numColumns; i > 0; --i) {
-                channels_type srcAlpha = src[_CSTraits::alpha_pos];
-                channels_type dstAlpha = dst[_CSTraits::alpha_pos];
-
-                srcAlpha = qMin(srcAlpha, dstAlpha);
-
-                // apply the alphamask
-                if (mask != 0) {
-                    if (*mask != OPACITY_OPAQUE_U8) {
-                        channels_type tmpOpacity = KoColorSpaceMaths<quint8, channels_type>::scaleToA(*mask);
-                        srcAlpha =  KoColorSpaceMaths<channels_type>::multiply(srcAlpha, tmpOpacity);
-                    }
-                    mask++;
-                }
-
-                if (srcAlpha != NATIVE_OPACITY_TRANSPARENT) {
-
-                    if (opacity != OPACITY_OPAQUE_U8) {
-                        channels_type tmpOpacity = KoColorSpaceMaths<quint8, channels_type>::scaleToA(opacity);
-                        srcAlpha = KoColorSpaceMaths<channels_type>::multiply(src[_CSTraits::alpha_pos], tmpOpacity);
-                    }
-
-                    channels_type srcBlend;
-
-                    if (dstAlpha == NATIVE_OPACITY_OPAQUE) {
-                        srcBlend = srcAlpha;
-                    } else {
-                        channels_type newAlpha = dstAlpha + KoColorSpaceMaths<channels_type>::multiply(NATIVE_OPACITY_OPAQUE - dstAlpha, srcAlpha);
-                        dst[_CSTraits::alpha_pos] = newAlpha;
-
-                        if (newAlpha != 0) {
-                            srcBlend = KoColorSpaceMaths<channels_type>::divide(srcAlpha, newAlpha);
-                        } else {
-                            srcBlend = srcAlpha;
-                        }
-                    }
-
-                    float dstRed = SCALE_TO_FLOAT(dst[_CSTraits::red_pos]);
-                    float dstGreen = SCALE_TO_FLOAT(dst[_CSTraits::green_pos]);
-                    float dstBlue = SCALE_TO_FLOAT(dst[_CSTraits::blue_pos]);
-
-                    float srcHue;
-                    float srcSaturation;
-                    float srcValue;
-                    float dstHue;
-                    float dstSaturation;
-                    float dstValue;
-
-                    float srcRed = SCALE_TO_FLOAT(src[_CSTraits::red_pos]);
-                    float srcGreen = SCALE_TO_FLOAT(src[_CSTraits::green_pos]);
-                    float srcBlue = SCALE_TO_FLOAT(src[_CSTraits::blue_pos]);
-
-                    RGBToHSV(srcRed, srcGreen, srcBlue, &srcHue, &srcSaturation, &srcValue);
-                    RGBToHSV(dstRed, dstGreen, dstBlue, &dstHue, &dstSaturation, &dstValue);
-
-                    HSVToRGB(srcHue, dstSaturation, dstValue, &srcRed, &srcGreen, &srcBlue);
-
-                    if (channelFlags.isEmpty() || channelFlags.testBit(_CSTraits::red_pos)) {
-                        dst[_CSTraits::red_pos] = KoColorSpaceMaths<channels_type>::blend(SCALE_FROM_FLOAT(srcRed), SCALE_FROM_FLOAT(dstRed), srcBlend);
-                    }
-                    if (channelFlags.isEmpty() || channelFlags.testBit(_CSTraits::green_pos)) {
-                        dst[_CSTraits::green_pos] = KoColorSpaceMaths<channels_type>::blend(SCALE_FROM_FLOAT(srcGreen), SCALE_FROM_FLOAT(dstGreen), srcBlend);
-                    }
-                    if (channelFlags.isEmpty() || channelFlags.testBit(_CSTraits::blue_pos)) {
-                        dst[_CSTraits::blue_pos] = KoColorSpaceMaths<channels_type>::blend(SCALE_FROM_FLOAT(srcBlue), SCALE_FROM_FLOAT(dstBlue), srcBlend);
-                    }
-                }
-
-                src += _CSTraits::channels_nb;
-                dst += _CSTraits::channels_nb;
-            }
-
-            rows--;
-            srcRowStart += srcRowStride;
-            dstRowStart += dstRowStride;
-            if (maskRowStart) {
-                maskRowStart += maskRowStride;
-            }
-        }
-    }
-};
-
-#endif
diff --git a/plugins/color/lcms2engine/compositeops/RgbCompositeOpLighten.h b/plugins/color/lcms2engine/compositeops/RgbCompositeOpLighten.h
deleted file mode 100644
index 1d560241fd..0000000000
--- a/plugins/color/lcms2engine/compositeops/RgbCompositeOpLighten.h
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
- *  Copyright (c) 2006 Boudewijn Rempt <boud@valdyas.org>
- *
- *  This library is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser General Public License as published by
- *  the Free Software Foundation, either version 2.1 of the License, or
- *  (at your option) any later version.
- *
- *  This library is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY const; 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 const; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-
-#ifndef RGBCOMPOSITEOPLIGHTEN_H
-#define RGBCOMPOSITEOPLIGHTEN_H
-
-#include <KoCompositeOp.h>
-
-template<class _CSTraits>
-class RgbCompositeOpLighten : public KoCompositeOp
-{
-    typedef typename _CSTraits::channels_type channels_type;
-    typedef typename KoColorSpaceMathsTraits<typename _CSTraits::channels_type>::compositetype compositetype;
-
-public:
-
-    RgbCompositeOpLighten(KoColorSpace *cs)
-        : KoCompositeOp(cs, COMPOSITE_LIGHTEN, i18n("Lighten"), "")
-    {
-    }
-
-    using KoCompositeOp::composite;
-
-    void composite(quint8 *dstRowStart, qint32 dstRowStride,
-                   const quint8 *srcRowStart, qint32 srcRowStride,
-                   const quint8 *maskRowStart, qint32 maskRowStride,
-                   qint32 rows, qint32 numColumns,
-                   quint8 opacity,
-                   const QBitArray &channelFlags) const override
-    {
-
-        while (rows > 0) {
-            const quint8 *mask = maskRowStart;
-            const channels_type *src = reinterpret_cast<const channels_type *>(srcRowStart);
-            channels_type *dst = reinterpret_cast<channels_type *>(dstRowStart);
-
-            for (int i = numColumns; i > 0; --i) {
-                channels_type srcAlpha = src[_CSTraits::alpha_pos];
-                channels_type dstAlpha = dst[_CSTraits::alpha_pos];
-
-                srcAlpha = qMin(srcAlpha, dstAlpha);
-
-                // apply the alphamask
-                if (mask != 0) {
-                    if (*mask != OPACITY_OPAQUE_U8) {
-                        channels_type tmpOpacity = KoColorSpaceMaths<quint8, channels_type>::scaleToA(*mask);
-                        srcAlpha =  KoColorSpaceMaths<channels_type>::multiply(srcAlpha, tmpOpacity);
-                    }
-                    mask++;
-                }
-
-                if (srcAlpha != NATIVE_OPACITY_TRANSPARENT) {
-
-                    if (opacity != OPACITY_OPAQUE_U8) {
-                        channels_type tmpOpacity = KoColorSpaceMaths<quint8, channels_type>::scaleToA(opacity);
-                        srcAlpha = KoColorSpaceMaths<channels_type>::multiply(src[_CSTraits::alpha_pos], tmpOpacity);
-                    }
-
-                    channels_type srcBlend;
-
-                    if (dstAlpha == NATIVE_OPACITY_OPAQUE) {
-                        srcBlend = srcAlpha;
-                    } else {
-                        channels_type newAlpha = dstAlpha + KoColorSpaceMaths<channels_type>::multiply(NATIVE_OPACITY_OPAQUE - dstAlpha, srcAlpha);
-                        dst[_CSTraits::alpha_pos] = newAlpha;
-
-                        if (newAlpha != 0) {
-                            srcBlend = KoColorSpaceMaths<channels_type>::divide(srcAlpha, newAlpha);
-                        } else {
-                            srcBlend = srcAlpha;
-                        }
-                    }
-
-                    for (int channel = 0; channel < MAX_CHANNEL_RGB; channel++) {
-                        if (channelFlags.isEmpty() || channelFlags.testBit(_CSTraits::alpha_pos)) {
-                            channels_type srcColor = src[channel];
-                            channels_type dstColor = dst[channel];
-
-                            srcColor = qMax(srcColor, dstColor);
-
-                            channels_type newColor = KoColorSpaceMaths<channels_type>::blend(srcColor, dstColor, srcBlend);
-
-                            dst[channel] = newColor;
-                        }
-                    }
-                }
-
-                src += _CSTraits::channels_nb;
-                dst += _CSTraits::channels_nb;
-            }
-
-            rows--;
-            srcRowStart += srcRowStride;
-            dstRowStart += dstRowStride;
-            if (maskRowStart) {
-                maskRowStart += maskRowStride;
-            }
-        }
-    }
-};
-
-#endif
diff --git a/plugins/color/lcms2engine/compositeops/RgbCompositeOpSaturation.h b/plugins/color/lcms2engine/compositeops/RgbCompositeOpSaturation.h
deleted file mode 100644
index 4dba82616b..0000000000
--- a/plugins/color/lcms2engine/compositeops/RgbCompositeOpSaturation.h
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
- *  Copyright (c) 2006 Boudewijn Rempt <boud@valdyas.org>
- *
- *  This library is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser General Public License as published by
- *  the Free Software Foundation, either version 2.1 of the License, or
- *  (at your option) any later version.
- *
- *  This library is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY const; 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 const; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-
-#ifndef RGBCOMPOSITEOPSATURATION_H
-#define RGBCOMPOSITEOPSATURATION_H
-
-#include "KoColorConversions.h"
-#include <KoCompositeOp.h>
-
-#define SCALE_TO_FLOAT( v ) KoColorSpaceMaths< channels_type, float>::scaleToA( v )
-#define SCALE_FROM_FLOAT( v ) KoColorSpaceMaths< float, channels_type>::scaleToA( v )
-
-template<class _CSTraits>
-class RgbCompositeOpSaturation: public KoCompositeOp
-{
-    typedef typename _CSTraits::channels_type channels_type;
-    typedef typename KoColorSpaceMathsTraits<typename _CSTraits::channels_type>::compositetype compositetype;
-
-public:
-
-    RgbCompositeOpSaturation(KoColorSpace *cs)
-        : KoCompositeOp(cs, COMPOSITE_SATURATION, i18n("Saturation"), "")
-    {
-    }
-
-    using KoCompositeOp::composite;
-
-    void composite(quint8 *dstRowStart, qint32 dstRowStride,
-                   const quint8 *srcRowStart, qint32 srcRowStride,
-                   const quint8 *maskRowStart, qint32 maskRowStride,
-                   qint32 rows, qint32 numColumns,
-                   quint8 opacity,
-                   const QBitArray &channelFlags) const override
-    {
-
-        while (rows > 0) {
-            const quint8 *mask = maskRowStart;
-            const channels_type *src = reinterpret_cast<const channels_type *>(srcRowStart);
-            channels_type *dst = reinterpret_cast<channels_type *>(dstRowStart);
-
-            for (int i = numColumns; i > 0; --i) {
-                channels_type srcAlpha = src[_CSTraits::alpha_pos];
-                channels_type dstAlpha = dst[_CSTraits::alpha_pos];
-
-                srcAlpha = qMin(srcAlpha, dstAlpha);
-
-                // apply the alphamask
-                if (mask != 0) {
-                    if (*mask != OPACITY_OPAQUE_U8) {
-                        channels_type tmpOpacity = KoColorSpaceMaths<quint8, channels_type>::scaleToA(*mask);
-                        srcAlpha =  KoColorSpaceMaths<channels_type>::multiply(srcAlpha, tmpOpacity);
-                    }
-                    mask++;
-                }
-
-                if (srcAlpha != NATIVE_OPACITY_TRANSPARENT) {
-
-                    if (opacity != OPACITY_OPAQUE_U8) {
-                        channels_type tmpOpacity = KoColorSpaceMaths<quint8, channels_type>::scaleToA(opacity);
-                        srcAlpha = KoColorSpaceMaths<channels_type>::multiply(src[_CSTraits::alpha_pos], tmpOpacity);
-                    }
-
-                    channels_type srcBlend;
-
-                    if (dstAlpha == NATIVE_OPACITY_OPAQUE) {
-                        srcBlend = srcAlpha;
-                    } else {
-                        channels_type newAlpha = dstAlpha + KoColorSpaceMaths<channels_type>::multiply(NATIVE_OPACITY_OPAQUE - dstAlpha, srcAlpha);
-                        dst[_CSTraits::alpha_pos] = newAlpha;
-
-                        if (newAlpha != 0) {
-                            srcBlend = KoColorSpaceMaths<channels_type>::divide(srcAlpha, newAlpha);
-                        } else {
-                            srcBlend = srcAlpha;
-                        }
-                    }
-
-                    float dstRed = SCALE_TO_FLOAT(dst[_CSTraits::red_pos]);
-                    float dstGreen = SCALE_TO_FLOAT(dst[_CSTraits::green_pos]);
-                    float dstBlue = SCALE_TO_FLOAT(dst[_CSTraits::blue_pos]);
-
-                    float srcHue;
-                    float srcSaturation;
-                    float srcValue;
-                    float dstHue;
-                    float dstSaturation;
-                    float dstValue;
-
-                    float srcRed = SCALE_TO_FLOAT(src[_CSTraits::red_pos]);
-                    float srcGreen = SCALE_TO_FLOAT(src[_CSTraits::green_pos]);
-                    float srcBlue = SCALE_TO_FLOAT(src[_CSTraits::blue_pos]);
-
-                    RGBToHSV(srcRed, srcGreen, srcBlue, &srcHue, &srcSaturation, &srcValue);
-                    RGBToHSV(dstRed, dstGreen, dstBlue, &dstHue, &dstSaturation, &dstValue);
-
-                    HSVToRGB(dstHue, srcSaturation, dstValue, &srcRed, &srcGreen, &srcBlue);
-
-                    if (channelFlags.isEmpty() || channelFlags.testBit(_CSTraits::red_pos)) {
-                        dst[_CSTraits::red_pos] = KoColorSpaceMaths<channels_type>::blend(SCALE_FROM_FLOAT(srcRed), SCALE_FROM_FLOAT(dstRed), srcBlend);
-                    }
-                    if (channelFlags.isEmpty() || channelFlags.testBit(_CSTraits::green_pos)) {
-                        dst[_CSTraits::green_pos] = KoColorSpaceMaths<channels_type>::blend(SCALE_FROM_FLOAT(srcGreen), SCALE_FROM_FLOAT(dstGreen), srcBlend);
-                    }
-                    if (channelFlags.isEmpty() || channelFlags.testBit(_CSTraits::blue_pos)) {
-                        dst[_CSTraits::blue_pos] = KoColorSpaceMaths<channels_type>::blend(SCALE_FROM_FLOAT(srcBlue), SCALE_FROM_FLOAT(dstBlue), srcBlend);
-                    }
-                }
-
-                src += _CSTraits::channels_nb;
-                dst += _CSTraits::channels_nb;
-            }
-
-            rows--;
-            srcRowStart += srcRowStride;
-            dstRowStart += dstRowStride;
-            if (maskRowStart) {
-                maskRowStart += maskRowStride;
-            }
-        }
-    }
-};
-
-#endif
diff --git a/plugins/color/lcms2engine/compositeops/RgbCompositeOpValue.h b/plugins/color/lcms2engine/compositeops/RgbCompositeOpValue.h
deleted file mode 100644
index fc1426ad9d..0000000000
--- a/plugins/color/lcms2engine/compositeops/RgbCompositeOpValue.h
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
- *  Copyright (c) 2006 Boudewijn Rempt <boud@valdyas.org>
- *
- *  This library is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser General Public License as published by
- *  the Free Software Foundation, either version 2.1 of the License, or
- *  (at your option) any later version.
- *
- *  This library is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY const; 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 const; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-
-#ifndef RGBCOMPOSITEOPVALUE_H
-#define RGBCOMPOSITEOPVALUE_H
-
-#include "KoColorConversions.h"
-#include <KoCompositeOp.h>
-
-#define SCALE_TO_FLOAT( v ) KoColorSpaceMaths< channels_type, float>::scaleToA( v )
-#define SCALE_FROM_FLOAT( v ) KoColorSpaceMaths< float, channels_type>::scaleToA( v )
-
-template<class _CSTraits>
-class RgbCompositeOpValue: public KoCompositeOp
-{
-    typedef typename _CSTraits::channels_type channels_type;
-    typedef typename KoColorSpaceMathsTraits<typename _CSTraits::channels_type>::compositetype compositetype;
-
-public:
-
-    RgbCompositeOpValue(KoColorSpace *cs)
-        : KoCompositeOp(cs, COMPOSITE_VALUE, i18nc("HSV Value","Value"), "")
-    {
-    }
-
-    using KoCompositeOp::composite;
-
-    void composite(quint8 *dstRowStart, qint32 dstRowStride,
-                   const quint8 *srcRowStart, qint32 srcRowStride,
-                   const quint8 *maskRowStart, qint32 maskRowStride,
-                   qint32 rows, qint32 numColumns,
-                   quint8 opacity,
-                   const QBitArray &channelFlags) const override
-    {
-
-        while (rows > 0) {
-            const quint8 *mask = maskRowStart;
-            const channels_type *src = reinterpret_cast<const channels_type *>(srcRowStart);
-            channels_type *dst = reinterpret_cast<channels_type *>(dstRowStart);
-
-            for (int i = numColumns; i > 0; --i) {
-                channels_type srcAlpha = src[_CSTraits::alpha_pos];
-                channels_type dstAlpha = dst[_CSTraits::alpha_pos];
-
-                srcAlpha = qMin(srcAlpha, dstAlpha);
-
-                // apply the alphamask
-                if (mask != 0) {
-                    if (*mask != OPACITY_OPAQUE_U8) {
-                        channels_type tmpOpacity = KoColorSpaceMaths<quint8, channels_type>::scaleToA(*mask);
-                        srcAlpha =  KoColorSpaceMaths<channels_type>::multiply(srcAlpha, tmpOpacity);
-                    }
-                    mask++;
-                }
-
-                if (srcAlpha != NATIVE_OPACITY_TRANSPARENT) {
-
-                    if (opacity != OPACITY_OPAQUE_U8) {
-                        channels_type tmpOpacity = KoColorSpaceMaths<quint8, channels_type>::scaleToA(opacity);
-                        srcAlpha = KoColorSpaceMaths<channels_type>::multiply(src[_CSTraits::alpha_pos], tmpOpacity);
-                    }
-
-                    channels_type srcBlend;
-
-                    if (dstAlpha == NATIVE_OPACITY_OPAQUE) {
-                        srcBlend = srcAlpha;
-                    } else {
-                        channels_type newAlpha = dstAlpha + KoColorSpaceMaths<channels_type>::multiply(NATIVE_OPACITY_OPAQUE - dstAlpha, srcAlpha);
-                        dst[_CSTraits::alpha_pos] = newAlpha;
-
-                        if (newAlpha != 0) {
-                            srcBlend = KoColorSpaceMaths<channels_type>::divide(srcAlpha, newAlpha);
-                        } else {
-                            srcBlend = srcAlpha;
-                        }
-                    }
-
-                    float dstRed = SCALE_TO_FLOAT(dst[_CSTraits::red_pos]);
-                    float dstGreen = SCALE_TO_FLOAT(dst[_CSTraits::green_pos]);
-                    float dstBlue = SCALE_TO_FLOAT(dst[_CSTraits::blue_pos]);
-
-                    float srcHue;
-                    float srcSaturation;
-                    float srcValue;
-                    float dstHue;
-                    float dstSaturation;
-                    float dstValue;
-
-                    float srcRed = SCALE_TO_FLOAT(src[_CSTraits::red_pos]);
-                    float srcGreen = SCALE_TO_FLOAT(src[_CSTraits::green_pos]);
-                    float srcBlue = SCALE_TO_FLOAT(src[_CSTraits::blue_pos]);
-
-                    RGBToHSV(srcRed, srcGreen, srcBlue, &srcHue, &srcSaturation, &srcValue);
-                    RGBToHSV(dstRed, dstGreen, dstBlue, &dstHue, &dstSaturation, &dstValue);
-
-                    HSVToRGB(dstHue, dstSaturation, srcValue, &srcRed, &srcGreen, &srcBlue);
-
-                    if (channelFlags.isEmpty() || channelFlags.testBit(_CSTraits::red_pos)) {
-                        dst[_CSTraits::red_pos] = KoColorSpaceMaths<channels_type>::blend(SCALE_FROM_FLOAT(srcRed), SCALE_FROM_FLOAT(dstRed), srcBlend);
-                    }
-                    if (channelFlags.isEmpty() || channelFlags.testBit(_CSTraits::green_pos)) {
-                        dst[_CSTraits::green_pos] = KoColorSpaceMaths<channels_type>::blend(SCALE_FROM_FLOAT(srcGreen), SCALE_FROM_FLOAT(dstGreen), srcBlend);
-                    }
-                    if (channelFlags.isEmpty() || channelFlags.testBit(_CSTraits::blue_pos)) {
-                        dst[_CSTraits::blue_pos] = KoColorSpaceMaths<channels_type>::blend(SCALE_FROM_FLOAT(srcBlue), SCALE_FROM_FLOAT(dstBlue), srcBlend);
-                    }
-                }
-
-                src += _CSTraits::channels_nb;
-                dst += _CSTraits::channels_nb;
-            }
-
-            rows--;
-            srcRowStart += srcRowStride;
-            dstRowStart += dstRowStride;
-            if (maskRowStart) {
-                maskRowStart += maskRowStride;
-            }
-        }
-    }
-};
-
-#endif
diff --git a/plugins/color/lcms2engine/compositeops/RgbCompositeOps.h b/plugins/color/lcms2engine/compositeops/RgbCompositeOps.h
index c4ac1b266a..c1b801029d 100644
--- a/plugins/color/lcms2engine/compositeops/RgbCompositeOps.h
+++ b/plugins/color/lcms2engine/compositeops/RgbCompositeOps.h
@@ -1,77 +1,68 @@
 /*
  *  Copyright (c) 2006 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation, either version 2.1 of the License, or
  *  (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY const; 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 const; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 
  Some code is derived from GraphicsMagick/magick/composite.c and is
  subject to the following license and copyright:
 
   Copyright (C) 2002 GraphicsMagick Group, an organization dedicated
   to making software imaging solutions freely available.
 
   Permission is hereby granted, free of charge, to any person obtaining
   a copy of this software and associated documentation files
   ("GraphicsMagick"), to deal in GraphicsMagick without restriction,
   including without limitation the rights to use, copy, modify, merge,
   publish, distribute, sublicense, and/or sell copies of GraphicsMagick,
   and to permit persons to whom GraphicsMagick is furnished to do so,
   subject to the following conditions:
 
   The above copyright notice and this permission notice shall be included
   in all copies or substantial portions of GraphicsMagick.
 
   The software is provided "as is", without warranty of any kind, express
   or implied, including but not limited to the warranties of
   merchantability, fitness for a particular purpose and noninfringement.
   In no event shall GraphicsMagick Group be liable for any claim,
   damages or other liability, whether in an action of contract, tort or
   otherwise, arising from, out of or in connection with GraphicsMagick
   or the use or other dealings in GraphicsMagick.
 
   Except as contained in this notice, the name of the GraphicsMagick
   Group shall not be used in advertising or otherwise to promote the
   sale, use or other dealings in GraphicsMagick without prior written
   authorization from the GraphicsMagick Group.
 
    Other code is derived from gwenview/src/qxcfi.* - this is released under
   the terms of the LGPL
 
  */
 
 #ifndef RGBCOMPOSITEOPS_H
 #define RGBCOMPOSITEOPS_H
 
 #include "KoColorSpaceConstants.h"
 
 #define NATIVE_OPACITY_OPAQUE KoColorSpaceMathsTraits<channels_type>::unitValue
 #define NATIVE_OPACITY_TRANSPARENT KoColorSpaceMathsTraits<channels_type>::zeroValue
 
 const qint32 MAX_CHANNEL_RGB = 3;
 
 #include "RgbCompositeOpIn.h"
 #include "RgbCompositeOpOut.h"
-#include "RgbCompositeOpDiff.h"
 #include "RgbCompositeOpBumpmap.h"
-#include "RgbCompositeOpClear.h"
-#include "RgbCompositeOpDissolve.h"
-#include "RgbCompositeOpDarken.h"
-#include "RgbCompositeOpLighten.h"
-#include "RgbCompositeOpHue.h"
-#include "RgbCompositeOpSaturation.h"
-#include "RgbCompositeOpValue.h"
-#include "RgbCompositeOpColor.h"
 
 #endif
 
diff --git a/plugins/filters/gaussianhighpass/gaussianhighpass_filter.cpp b/plugins/filters/gaussianhighpass/gaussianhighpass_filter.cpp
index d92d48fb18..07a004bd62 100644
--- a/plugins/filters/gaussianhighpass/gaussianhighpass_filter.cpp
+++ b/plugins/filters/gaussianhighpass/gaussianhighpass_filter.cpp
@@ -1,125 +1,124 @@
 /*
  * This file is part of Krita
  *
  * Copyright (c) 2019 Miguel Lopez <reptillia39@live.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include <compositeops/KoVcMultiArchBuildSupport.h> //MSVC requires that Vc come first
 #include "gaussianhighpass_filter.h"
 #include <QBitArray>
 
 #include <KoColorSpace.h>
 #include <KoChannelInfo.h>
 #include <KoColor.h>
 #include <kis_painter.h>
 #include <kis_paint_device.h>
 #include <kis_paint_layer.h>
 #include <kis_group_layer.h>
 
 #include <kis_mask_generator.h>
 #include <kis_gaussian_kernel.h>
 #include <filter/kis_filter_category_ids.h>
 #include <filter/kis_filter_configuration.h>
 #include <kis_processing_information.h>
 #include <KoProgressUpdater.h>
 #include <KoUpdater.h>
 #include <KoMixColorsOp.h>
 #include "kis_lod_transform.h"
 #include <KoCompositeOpRegistry.h>
 
 #include "wdg_gaussianhighpass.h"
 #include "ui_wdggaussianhighpass.h"
 #include "KoColorSpaceTraits.h"
 #include <KisSequentialIteratorProgress.h>
 
 
 KisGaussianHighPassFilter::KisGaussianHighPassFilter() : KisFilter(id(), FiltersCategoryEdgeDetectionId, i18n("&Gaussian High Pass..."))
 {
     setSupportsPainting(true);
     setSupportsAdjustmentLayers(true);
     setSupportsThreading(true);
     setSupportsLevelOfDetail(true);
     setColorSpaceIndependence(FULLY_INDEPENDENT);
 }
 
 KisConfigWidget * KisGaussianHighPassFilter::createConfigurationWidget(QWidget* parent, const KisPaintDeviceSP, bool /* useForMasks */) const
 {
     return new KisWdgGaussianHighPass(parent);
 }
 
 KisFilterConfigurationSP KisGaussianHighPassFilter::factoryConfiguration() const
 {
     KisFilterConfigurationSP config = new KisFilterConfiguration(id().id(), 1);
     config->setProperty("blurAmount", 1);
     return config;
 }
 
 void KisGaussianHighPassFilter::processImpl(KisPaintDeviceSP device,
                                    const QRect& applyRect,
                                    const KisFilterConfigurationSP _config,
                                    KoUpdater *
                                    ) const
 {
     QPointer<KoUpdater> convolutionUpdater = 0;
 
     KisFilterConfigurationSP config = _config ? _config : new KisFilterConfiguration(id().id(), 1);
     
     QVariant value;
     KisLodTransformScalar t(device);
     const qreal blurAmount = t.scale(config->getProperty("blurAmount", value) ? value.toDouble() : 1.0);
     QBitArray channelFlags = config->channelFlags();
 
     const QRect gaussNeedRect = this->neededRect(applyRect, config, device->defaultBounds()->currentLevelOfDetail());
 
-    KisPaintDeviceSP blur = m_cachedPaintDevice.getDevice(device);
+    KisCachedPaintDevice::Guard d1(device, m_cachedPaintDevice);
+    KisPaintDeviceSP blur = d1.device();
     KisPainter::copyAreaOptimizedOldData(gaussNeedRect.topLeft(), device, blur, gaussNeedRect);
     KisGaussianKernel::applyGaussian(blur, applyRect,
                                      blurAmount, blurAmount,
                                      channelFlags,
                                      convolutionUpdater,
                                      true); // make sure we cerate an internal transaction on temp device
     
     KisPainter painter(device);
     painter.setCompositeOp(blur->colorSpace()->compositeOp(COMPOSITE_GRAIN_EXTRACT));
     painter.bitBlt(applyRect.topLeft(), blur, applyRect);
     painter.end();
-
-    m_cachedPaintDevice.putDevice(blur);
 }
 
 
 QRect KisGaussianHighPassFilter::neededRect(const QRect & rect, const KisFilterConfigurationSP config, int lod) const
 {
     KisLodTransformScalar t(lod);
 
     QVariant value;
 
     const int halfSize = config->getProperty("blurAmount", value) ? KisGaussianKernel::kernelSizeFromRadius(t.scale(value.toFloat())) / 2 : 5;
 
     return rect.adjusted( -halfSize * 2, -halfSize * 2, halfSize * 2, halfSize * 2);
 }
 
 QRect KisGaussianHighPassFilter::changedRect(const QRect & rect, const KisFilterConfigurationSP config, int lod) const
 {
     KisLodTransformScalar t(lod);
 
     QVariant value;
 
     const int halfSize = config->getProperty("blurAmount", value) ? KisGaussianKernel::kernelSizeFromRadius(t.scale(value.toFloat())) / 2 : 5;
 
     return rect.adjusted( -halfSize, -halfSize, halfSize, halfSize);
 }