diff --git a/libs/image/CMakeLists.txt b/libs/image/CMakeLists.txt
index 88c40f8a48..b49d07a36e 100644
--- a/libs/image/CMakeLists.txt
+++ b/libs/image/CMakeLists.txt
@@ -1,376 +1,377 @@
 add_subdirectory( tests )
 
 add_subdirectory( tiles3 )
 
 include_directories(
     ${CMAKE_CURRENT_BINARY_DIR}
     ${CMAKE_CURRENT_SOURCE_DIR}/metadata
     ${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/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/kis_set_global_selection_command.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
    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
    filter/kis_filter.cc
    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
    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
    KisUpdateSchedulerConfigNotifier.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
    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
    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
    metadata/kis_meta_data_entry.cc
    metadata/kis_meta_data_filter.cc
    metadata/kis_meta_data_filter_p.cc
    metadata/kis_meta_data_filter_registry.cc
    metadata/kis_meta_data_filter_registry_model.cc
    metadata/kis_meta_data_io_backend.cc
    metadata/kis_meta_data_merge_strategy.cc
    metadata/kis_meta_data_merge_strategy_p.cc
    metadata/kis_meta_data_merge_strategy_registry.cc
    metadata/kis_meta_data_parser.cc
    metadata/kis_meta_data_schema.cc
    metadata/kis_meta_data_schema_registry.cc
    metadata/kis_meta_data_store.cc
    metadata/kis_meta_data_type_info.cc
    metadata/kis_meta_data_validator.cc
    metadata/kis_meta_data_value.cc
 
    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
 
    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 
         Qt5::Concurrent
 )
 
 target_link_libraries(kritaimage PUBLIC ${Boost_SYSTEM_LIBRARY})
 
 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}/metadata>
     $<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/KisImageSignals.cpp b/libs/image/KisImageSignals.cpp
new file mode 100644
index 0000000000..9965e314f3
--- /dev/null
+++ b/libs/image/KisImageSignals.cpp
@@ -0,0 +1,94 @@
+/*
+ *  Copyright (c) 2018 Dmitry Kazakov <dimula73@gmail.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include "KisImageSignals.h"
+
+#include "kis_node.h"
+
+/*******************************************************************************/
+/*                       ComplexSizeChangedSignal                              */
+/*******************************************************************************/
+
+ComplexSizeChangedSignal::ComplexSizeChangedSignal() {}
+
+ComplexSizeChangedSignal::ComplexSizeChangedSignal(QPointF _oldStillPoint, QPointF _newStillPoint)
+    : oldStillPoint(_oldStillPoint),
+      newStillPoint(_newStillPoint)
+{
+}
+
+ComplexSizeChangedSignal::ComplexSizeChangedSignal(const QRect &portionOfOldImage, const QSize &transformedIntoImageOfSize)
+{
+    oldStillPoint = QRectF(portionOfOldImage).center();
+    newStillPoint = QRectF(QPointF(), QSizeF(transformedIntoImageOfSize)).center();
+}
+
+ComplexSizeChangedSignal ComplexSizeChangedSignal::inverted() const {
+    return ComplexSizeChangedSignal(newStillPoint, oldStillPoint);
+}
+
+
+/*******************************************************************************/
+/*                       ComplexNodeReselectionSignal                          */
+/*******************************************************************************/
+
+ComplexNodeReselectionSignal::ComplexNodeReselectionSignal() {}
+
+ComplexNodeReselectionSignal::ComplexNodeReselectionSignal(KisNodeSP _newActiveNode, KisNodeList _newSelectedNodes, KisNodeSP _oldActiveNode, KisNodeList _oldSelectedNodes)
+    : newActiveNode(_newActiveNode),
+      newSelectedNodes(_newSelectedNodes),
+      oldActiveNode(_oldActiveNode),
+      oldSelectedNodes(_oldSelectedNodes)
+{
+}
+
+ComplexNodeReselectionSignal ComplexNodeReselectionSignal::inverted() const {
+    return ComplexNodeReselectionSignal(oldActiveNode, oldSelectedNodes, newActiveNode, newSelectedNodes);
+}
+
+
+/*******************************************************************************/
+/*                       KisImageSignalType                                    */
+/*******************************************************************************/
+
+KisImageSignalType::KisImageSignalType() {}
+
+KisImageSignalType::KisImageSignalType(KisImageSignalTypeEnum _id)
+    : id(_id)
+{
+}
+
+KisImageSignalType::KisImageSignalType(ComplexSizeChangedSignal signal)
+    : id(SizeChangedSignal),
+      sizeChangedSignal(signal)
+{
+}
+
+KisImageSignalType::KisImageSignalType(ComplexNodeReselectionSignal signal)
+    : id(NodeReselectionRequestSignal),
+      nodeReselectionSignal(signal)
+{
+}
+
+KisImageSignalType KisImageSignalType::inverted() const {
+    KisImageSignalType t;
+    t.id = id;
+    t.sizeChangedSignal = sizeChangedSignal.inverted();
+    t.nodeReselectionSignal = nodeReselectionSignal.inverted();
+    return t;
+}
diff --git a/libs/image/KisImageSignals.h b/libs/image/KisImageSignals.h
new file mode 100644
index 0000000000..6156dc8f11
--- /dev/null
+++ b/libs/image/KisImageSignals.h
@@ -0,0 +1,95 @@
+/*
+ *  Copyright (c) 2018 Dmitry Kazakov <dimula73@gmail.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#ifndef KISIMAGESIGNALS_H
+#define KISIMAGESIGNALS_H
+
+#include <QVector>
+#include <QRectF>
+#include "kritaimage_export.h"
+#include "kis_types.h"
+
+enum KisImageSignalTypeEnum {
+    LayersChangedSignal,
+    ModifiedSignal,
+    SizeChangedSignal,
+    ProfileChangedSignal,
+    ColorSpaceChangedSignal,
+    ResolutionChangedSignal,
+    NodeReselectionRequestSignal
+};
+
+/**
+ * A special signal which handles stillPoint capabilities of the image
+ *
+ * \see KisImage::sigSizeChanged()
+ */
+struct ComplexSizeChangedSignal {
+    ComplexSizeChangedSignal();
+    ComplexSizeChangedSignal(QPointF _oldStillPoint, QPointF _newStillPoint);
+
+    /**
+     * A helper method calculating the still points from image areas
+     * we process. It works as if the source image was "cropped" by \p
+     * portionOfOldImage, and this portion formed the new image of size
+     * \p transformedIntoImageOfSize.
+     *
+     * Note, that \p portionOfTheImage may be equal to the image bounds().
+     */
+    ComplexSizeChangedSignal(const QRect &portionOfOldImage, const QSize &transformedIntoImageOfSize);
+
+    ComplexSizeChangedSignal inverted() const;
+
+    QPointF oldStillPoint;
+    QPointF newStillPoint;
+};
+
+/**
+ * A special signal which handles emitting signals for node reselection
+ *
+ * \see KisImage::sigRequestNodeReselection()
+ */
+struct ComplexNodeReselectionSignal {
+    ComplexNodeReselectionSignal();
+    ComplexNodeReselectionSignal(KisNodeSP _newActiveNode, KisNodeList _newSelectedNodes,
+                                 KisNodeSP _oldActiveNode = KisNodeSP(), KisNodeList _oldSelectedNodes = KisNodeList());
+
+    ComplexNodeReselectionSignal inverted() const;
+
+    KisNodeSP newActiveNode;
+    KisNodeList newSelectedNodes;
+    KisNodeSP oldActiveNode;
+    KisNodeList oldSelectedNodes;
+};
+
+struct KisImageSignalType {
+    KisImageSignalType();
+    KisImageSignalType(KisImageSignalTypeEnum _id);
+    KisImageSignalType(ComplexSizeChangedSignal signal);
+    KisImageSignalType(ComplexNodeReselectionSignal signal);
+
+    KisImageSignalType inverted() const;
+
+    KisImageSignalTypeEnum id;
+    ComplexSizeChangedSignal sizeChangedSignal;
+    ComplexNodeReselectionSignal nodeReselectionSignal;
+};
+
+typedef QVector<KisImageSignalType> KisImageSignalVector;
+
+#endif // KISIMAGESIGNALS_H
diff --git a/libs/image/kis_image_signal_router.h b/libs/image/kis_image_signal_router.h
index 2e196bf4f6..169d14360e 100644
--- a/libs/image/kis_image_signal_router.h
+++ b/libs/image/kis_image_signal_router.h
@@ -1,213 +1,105 @@
 /*
  *  Copyright (c) 2011 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KIS_IMAGE_SIGNAL_ROUTER_H
 #define __KIS_IMAGE_SIGNAL_ROUTER_H
 
 #include <QObject>
-#include <QVector>
-#include <QRectF>
-#include "kritaimage_export.h"
-#include "kis_types.h"
-
+#include "KisImageSignals.h"
 
 class KoColorSpace;
 class KoColorProfile;
 
-enum KisImageSignalTypeEnum {
-    LayersChangedSignal,
-    ModifiedSignal,
-    SizeChangedSignal,
-    ProfileChangedSignal,
-    ColorSpaceChangedSignal,
-    ResolutionChangedSignal,
-    NodeReselectionRequestSignal
-};
-
-/**
- * A special signal which handles stillPoint capabilities of the image
- *
- * \see KisImage::sigSizeChanged()
- */
-struct ComplexSizeChangedSignal {
-    ComplexSizeChangedSignal() {}
-    ComplexSizeChangedSignal(QPointF _oldStillPoint, QPointF _newStillPoint)
-        : oldStillPoint(_oldStillPoint),
-          newStillPoint(_newStillPoint)
-    {
-    }
-
-    /**
-     * A helper method calculating the still points from image areas
-     * we process. It works as if the source image was "cropped" by \p
-     * portionOfOldImage, and this portion formed the new image of size
-     * \p transformedIntoImageOfSize.
-     *
-     * Note, that \p portionOfTheImage may be equal to the image bounds().
-     */
-    ComplexSizeChangedSignal(const QRect &portionOfOldImage, const QSize &transformedIntoImageOfSize)
-    {
-        oldStillPoint = QRectF(portionOfOldImage).center();
-        newStillPoint = QRectF(QPointF(), QSizeF(transformedIntoImageOfSize)).center();
-    }
-
-    ComplexSizeChangedSignal inverted() const {
-        return ComplexSizeChangedSignal(newStillPoint, oldStillPoint);
-    }
-
-    QPointF oldStillPoint;
-    QPointF newStillPoint;
-};
-
-/**
- * A special signal which handles emitting signals for node reselection
- *
- * \see KisImage::sigRequestNodeReselection()
- */
-struct ComplexNodeReselectionSignal {
-    ComplexNodeReselectionSignal() {}
-    ComplexNodeReselectionSignal(KisNodeSP _newActiveNode, KisNodeList _newSelectedNodes,
-                                 KisNodeSP _oldActiveNode = KisNodeSP(), KisNodeList _oldSelectedNodes = KisNodeList())
-        : newActiveNode(_newActiveNode),
-          newSelectedNodes(_newSelectedNodes),
-          oldActiveNode(_oldActiveNode),
-          oldSelectedNodes(_oldSelectedNodes)
-    {
-    }
-
-    ComplexNodeReselectionSignal inverted() const {
-        return ComplexNodeReselectionSignal(oldActiveNode, oldSelectedNodes, newActiveNode, newSelectedNodes);
-    }
-
-    KisNodeSP newActiveNode;
-    KisNodeList newSelectedNodes;
-    KisNodeSP oldActiveNode;
-    KisNodeList oldSelectedNodes;
-};
-
-struct KisImageSignalType {
-    KisImageSignalType() {}
-    KisImageSignalType(KisImageSignalTypeEnum _id)
-    : id(_id)
-    {
-    }
-
-    KisImageSignalType(ComplexSizeChangedSignal signal)
-        : id(SizeChangedSignal),
-          sizeChangedSignal(signal)
-    {
-    }
-
-    KisImageSignalType(ComplexNodeReselectionSignal signal)
-        : id(NodeReselectionRequestSignal),
-          nodeReselectionSignal(signal)
-    {
-    }
-
-    KisImageSignalType inverted() const {
-        KisImageSignalType t;
-        t.id = id;
-        t.sizeChangedSignal = sizeChangedSignal.inverted();
-        t.nodeReselectionSignal = nodeReselectionSignal.inverted();
-        return t;
-    }
-
-    KisImageSignalTypeEnum id;
-    ComplexSizeChangedSignal sizeChangedSignal;
-    ComplexNodeReselectionSignal nodeReselectionSignal;
-};
-
-typedef QVector<KisImageSignalType> KisImageSignalVector;
 
 class KRITAIMAGE_EXPORT KisImageSignalRouter : public QObject
 {
     Q_OBJECT
 
 public:
     KisImageSignalRouter(KisImageWSP image);
     ~KisImageSignalRouter() override;
 
     void emitNotification(KisImageSignalType type);
     void emitNotifications(KisImageSignalVector notifications);
 
     void emitNodeChanged(KisNodeSP node);
     void emitNodeHasBeenAdded(KisNode *parent, int index);
     void emitAboutToRemoveANode(KisNode *parent, int index);
 
     void emitRequestLodPlanesSyncBlocked(bool value);
     void emitNotifyBatchUpdateStarted();
     void emitNotifyBatchUpdateEnded();
 
 private Q_SLOTS:
     void slotNotification(KisImageSignalType type);
 
 Q_SIGNALS:
 
     void sigNotification(KisImageSignalType type);
 
     /**
      * Emitted whenever the image wants to update Lod0 plane of the canvas. Blocking
      * synching effectively means that the canvas will not try to read from these planes
      * until the **all** the data is loaded. Otherwise the user will see weird flickering
      * because of partially loaded lod0 tiles.
      *
      * NOTE: while the sync is blockes, the canvas is considered to use LodN planes
      *       that are expected to contain valid data.
      */
     void sigRequestLodPlanesSyncBlocked(bool value);
 
     /**
      * Emitted whenever the image is going to issue a lot of canvas update signals and
      * it it a good idea to group then and rerender the canvas in one go. The canvas
      * should initiate new rerenders while the batch is in progress.
      *
      * NOTE: even though the batched updates will not initiate a rerender, it does
      *       **not** guarantee that there will be processed during the batch. The
      *       updates may come from other sources, e.g. from mouse moves.
      *
      * NOTE: this feature is used to avoid flickering when switching
      *       back from lodN plane back to lod0. All the texture tiles should
      *       be loaded with new information before mipmaps can be regenerated.
      */
     void sigNotifyBatchUpdateStarted();
 
     /**
      * \see sigNotifyBatchUpdateStarted()
      */
     void sigNotifyBatchUpdateEnded();
 
     // Notifications
     void sigImageModified();
 
     void sigSizeChanged(const QPointF &oldStillPoint, const QPointF &newStillPoint);
     void sigProfileChanged(const KoColorProfile *  profile);
     void sigColorSpaceChanged(const KoColorSpace*  cs);
     void sigResolutionChanged(double xRes, double yRes);
     void sigRequestNodeReselection(KisNodeSP activeNode, const KisNodeList &selectedNodes);
 
     // Graph change signals
     void sigNodeChanged(KisNodeSP node);
     void sigNodeAddedAsync(KisNodeSP node);
     void sigRemoveNodeAsync(KisNodeSP node);
     void sigLayersChangedAsync();
 
 private:
     KisImageWSP m_image;
 };
 
 #endif /* __KIS_IMAGE_SIGNAL_ROUTER_H */
diff --git a/libs/image/kis_layer_utils.cpp b/libs/image/kis_layer_utils.cpp
index 1fa877ed26..6569a94e1e 100644
--- a/libs/image/kis_layer_utils.cpp
+++ b/libs/image/kis_layer_utils.cpp
@@ -1,1463 +1,1464 @@
 /*
  *  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_utils.h"
 
 #include <algorithm>
 
 #include <QUuid>
 #include <KoColorSpaceConstants.h>
 #include <KoProperties.h>
 
 #include "kis_painter.h"
 #include "kis_image.h"
 #include "kis_node.h"
 #include "kis_layer.h"
 #include "kis_paint_layer.h"
 #include "kis_clone_layer.h"
 #include "kis_group_layer.h"
 #include "kis_selection.h"
 #include "kis_selection_mask.h"
 #include "kis_meta_data_merge_strategy.h"
 #include <kundo2command.h>
 #include "commands/kis_image_layer_add_command.h"
 #include "commands/kis_image_layer_remove_command.h"
 #include "commands/kis_image_layer_move_command.h"
 #include "commands/kis_image_change_layers_command.h"
 #include "commands_new/kis_activate_selection_mask_command.h"
 #include "commands/kis_image_change_visibility_command.h"
 #include "kis_abstract_projection_plane.h"
 #include "kis_processing_applicator.h"
 #include "kis_image_animation_interface.h"
 #include "kis_keyframe_channel.h"
 #include "kis_command_utils.h"
 #include "commands_new/kis_change_projection_color_command.h"
 #include "kis_layer_properties_icons.h"
 #include "lazybrush/kis_colorize_mask.h"
 #include "commands/kis_node_property_list_command.h"
 #include "commands/kis_node_compositeop_command.h"
 #include <KisDelayedUpdateNodeInterface.h>
 #include "krita_utils.h"
+#include "kis_image_signal_router.h"
 
 
 namespace KisLayerUtils {
 
     void fetchSelectionMasks(KisNodeList mergedNodes, QVector<KisSelectionMaskSP> &selectionMasks)
     {
         foreach (KisNodeSP node, mergedNodes) {
             KisLayerSP layer = qobject_cast<KisLayer*>(node.data());
 
             KisSelectionMaskSP mask;
 
             if (layer && (mask = layer->selectionMask())) {
                 selectionMasks.append(mask);
             }
         }
     }
 
     struct MergeDownInfoBase {
         MergeDownInfoBase(KisImageSP _image)
             : image(_image),
               storage(new SwitchFrameCommand::SharedStorage())
         {
         }
         virtual ~MergeDownInfoBase() {}
 
         KisImageWSP image;
 
         QVector<KisSelectionMaskSP> selectionMasks;
 
         KisNodeSP dstNode;
 
         SwitchFrameCommand::SharedStorageSP storage;
         QSet<int> frames;
         bool useInTimeline = false;
         bool enableOnionSkins = false;
 
         virtual KisNodeList allSrcNodes() = 0;
 
         KisLayerSP dstLayer() {
             return qobject_cast<KisLayer*>(dstNode.data());
         }
     };
 
     struct MergeDownInfo : public MergeDownInfoBase {
         MergeDownInfo(KisImageSP _image,
                       KisLayerSP _prevLayer,
                       KisLayerSP _currLayer)
             : MergeDownInfoBase(_image),
               prevLayer(_prevLayer),
               currLayer(_currLayer)
         {
             frames =
                 fetchLayerFramesRecursive(prevLayer) |
                 fetchLayerFramesRecursive(currLayer);
 
             useInTimeline = prevLayer->useInTimeline() || currLayer->useInTimeline();
 
             const KisPaintLayer *paintLayer = qobject_cast<KisPaintLayer*>(currLayer.data());
             if (paintLayer) enableOnionSkins |= paintLayer->onionSkinEnabled();
 
             paintLayer = qobject_cast<KisPaintLayer*>(prevLayer.data());
             if (paintLayer) enableOnionSkins |= paintLayer->onionSkinEnabled();
         }
 
         KisLayerSP prevLayer;
         KisLayerSP currLayer;
 
         KisNodeList allSrcNodes() override {
             KisNodeList mergedNodes;
             mergedNodes << currLayer;
             mergedNodes << prevLayer;
             return mergedNodes;
         }
     };
 
     struct MergeMultipleInfo : public MergeDownInfoBase {
         MergeMultipleInfo(KisImageSP _image,
                           KisNodeList _mergedNodes)
             : MergeDownInfoBase(_image),
               mergedNodes(_mergedNodes)
         {
             foreach (KisNodeSP node, mergedNodes) {
                 frames |= fetchLayerFramesRecursive(node);
                 useInTimeline |= node->useInTimeline();
 
                 const KisPaintLayer *paintLayer = qobject_cast<KisPaintLayer*>(node.data());
                 if (paintLayer) {
                     enableOnionSkins |= paintLayer->onionSkinEnabled();
                 }
             }
         }
 
         KisNodeList mergedNodes;
         bool nodesCompositingVaries = false;
 
         KisNodeList allSrcNodes() override {
             return mergedNodes;
         }
     };
 
     typedef QSharedPointer<MergeDownInfoBase> MergeDownInfoBaseSP;
     typedef QSharedPointer<MergeDownInfo> MergeDownInfoSP;
     typedef QSharedPointer<MergeMultipleInfo> MergeMultipleInfoSP;
 
     struct FillSelectionMasks : public KUndo2Command {
         FillSelectionMasks(MergeDownInfoBaseSP info) : m_info(info) {}
 
         void redo() override {
             fetchSelectionMasks(m_info->allSrcNodes(), m_info->selectionMasks);
         }
 
     private:
         MergeDownInfoBaseSP m_info;
     };
 
     struct DisableColorizeKeyStrokes : public KisCommandUtils::AggregateCommand {
         DisableColorizeKeyStrokes(MergeDownInfoBaseSP info) : m_info(info) {}
 
         void populateChildCommands() override {
             Q_FOREACH (KisNodeSP node, m_info->allSrcNodes()) {
                 recursiveApplyNodes(node,
                                     [this] (KisNodeSP node) {
                                         if (dynamic_cast<KisColorizeMask*>(node.data()) &&
                                             KisLayerPropertiesIcons::nodeProperty(node, KisLayerPropertiesIcons::colorizeEditKeyStrokes, true).toBool()) {
 
                                             KisBaseNode::PropertyList props = node->sectionModelProperties();
                                             KisLayerPropertiesIcons::setNodeProperty(&props,
                                                                                      KisLayerPropertiesIcons::colorizeEditKeyStrokes,
                                                                                      false);
 
                                             addCommand(new KisNodePropertyListCommand(node, props));
                                         }
                                     });
             }
         }
 
     private:
         MergeDownInfoBaseSP m_info;
     };
 
     struct DisableOnionSkins : public KisCommandUtils::AggregateCommand {
         DisableOnionSkins(MergeDownInfoBaseSP info) : m_info(info) {}
 
         void populateChildCommands() override {
             Q_FOREACH (KisNodeSP node, m_info->allSrcNodes()) {
                 recursiveApplyNodes(node,
                                     [this] (KisNodeSP node) {
                                         if (KisLayerPropertiesIcons::nodeProperty(node, KisLayerPropertiesIcons::onionSkins, false).toBool()) {
 
                                             KisBaseNode::PropertyList props = node->sectionModelProperties();
                                             KisLayerPropertiesIcons::setNodeProperty(&props,
                                                                                      KisLayerPropertiesIcons::onionSkins,
                                                                                      false);
 
                                             addCommand(new KisNodePropertyListCommand(node, props));
                                         }
                                     });
             }
         }
 
     private:
         MergeDownInfoBaseSP m_info;
     };
 
     struct DisableExtraCompositing : public KisCommandUtils::AggregateCommand {
         DisableExtraCompositing(MergeMultipleInfoSP info) : m_info(info) {}
 
         void populateChildCommands() override {
             /**
              * We disable extra compositing only in case all the layers have
              * the same compositing properties, therefore, we can just sum them using
              * Normal blend mode
              */
             if (m_info->nodesCompositingVaries) return;
 
             // we should disable dirty requests on **redo only**, otherwise
             // the state of the layers will not be recovered on undo
             m_info->image->disableDirtyRequests();
 
             Q_FOREACH (KisNodeSP node, m_info->allSrcNodes()) {
                 if (node->compositeOpId() != COMPOSITE_OVER) {
                     addCommand(new KisNodeCompositeOpCommand(node, node->compositeOpId(), COMPOSITE_OVER));
                 }
 
                 if (KisLayerPropertiesIcons::nodeProperty(node, KisLayerPropertiesIcons::inheritAlpha, false).toBool()) {
 
                     KisBaseNode::PropertyList props = node->sectionModelProperties();
                     KisLayerPropertiesIcons::setNodeProperty(&props,
                                                              KisLayerPropertiesIcons::inheritAlpha,
                                                              false);
 
                     addCommand(new KisNodePropertyListCommand(node, props));
                 }
             }
 
             m_info->image->enableDirtyRequests();
         }
 
     private:
         MergeMultipleInfoSP m_info;
     };
 
     struct DisablePassThroughForHeadsOnly : public KisCommandUtils::AggregateCommand {
         DisablePassThroughForHeadsOnly(MergeDownInfoBaseSP info, bool skipIfDstIsGroup = false)
             : m_info(info),
               m_skipIfDstIsGroup(skipIfDstIsGroup)
         {
         }
 
         void populateChildCommands() override {
             if (m_skipIfDstIsGroup &&
                 m_info->dstLayer() &&
                 m_info->dstLayer()->inherits("KisGroupLayer")) {
 
                 return;
             }
 
 
             Q_FOREACH (KisNodeSP node, m_info->allSrcNodes()) {
                 if (KisLayerPropertiesIcons::nodeProperty(node, KisLayerPropertiesIcons::passThrough, false).toBool()) {
 
                     KisBaseNode::PropertyList props = node->sectionModelProperties();
                     KisLayerPropertiesIcons::setNodeProperty(&props,
                                                              KisLayerPropertiesIcons::passThrough,
                                                              false);
 
                     addCommand(new KisNodePropertyListCommand(node, props));
                 }
             }
         }
 
     private:
         MergeDownInfoBaseSP m_info;
         bool m_skipIfDstIsGroup;
     };
 
     struct RefreshHiddenAreas : public KUndo2Command {
         RefreshHiddenAreas(MergeDownInfoBaseSP info) : m_info(info) {}
 
         void redo() override {
             KisImageAnimationInterface *interface = m_info->image->animationInterface();
             const QRect preparedRect = !interface->externalFrameActive() ?
                 m_info->image->bounds() : QRect();
 
             foreach (KisNodeSP node, m_info->allSrcNodes()) {
                 refreshHiddenAreaAsync(node, preparedRect);
             }
         }
 
     private:
         QRect realNodeExactBounds(KisNodeSP rootNode, QRect currentRect = QRect()) {
             KisNodeSP node = rootNode->firstChild();
 
             while(node) {
                 currentRect |= realNodeExactBounds(node, currentRect);
                 node = node->nextSibling();
             }
 
             // TODO: it would be better to count up changeRect inside
             // node's extent() method
             currentRect |= rootNode->projectionPlane()->changeRect(rootNode->exactBounds());
 
             return currentRect;
         }
 
         void refreshHiddenAreaAsync(KisNodeSP rootNode, const QRect &preparedArea) {
             QRect realNodeRect = realNodeExactBounds(rootNode);
             if (!preparedArea.contains(realNodeRect)) {
 
                 QRegion dirtyRegion = realNodeRect;
                 dirtyRegion -= preparedArea;
 
                 foreach(const QRect &rc, dirtyRegion.rects()) {
                     m_info->image->refreshGraphAsync(rootNode, rc, realNodeRect);
                 }
             }
         }
     private:
         MergeDownInfoBaseSP m_info;
     };
 
     struct RefreshDelayedUpdateLayers : public KUndo2Command {
         RefreshDelayedUpdateLayers(MergeDownInfoBaseSP info) : m_info(info) {}
 
         void redo() override {
             foreach (KisNodeSP node, m_info->allSrcNodes()) {
                 forceAllDelayedNodesUpdate(node);
             }
         }
 
     private:
         MergeDownInfoBaseSP m_info;
     };
 
     struct KeepMergedNodesSelected : public KisCommandUtils::AggregateCommand {
         KeepMergedNodesSelected(MergeDownInfoSP info, bool finalizing)
             : m_singleInfo(info),
               m_finalizing(finalizing) {}
 
         KeepMergedNodesSelected(MergeMultipleInfoSP info, KisNodeSP putAfter, bool finalizing)
             : m_multipleInfo(info),
               m_finalizing(finalizing),
               m_putAfter(putAfter) {}
 
         void populateChildCommands() override {
             KisNodeSP prevNode;
             KisNodeSP nextNode;
             KisNodeList prevSelection;
             KisNodeList nextSelection;
             KisImageSP image;
 
             if (m_singleInfo) {
                 prevNode = m_singleInfo->currLayer;
                 nextNode = m_singleInfo->dstNode;
                 image = m_singleInfo->image;
             } else if (m_multipleInfo) {
                 prevNode = m_putAfter;
                 nextNode = m_multipleInfo->dstNode;
                 prevSelection = m_multipleInfo->allSrcNodes();
                 image = m_multipleInfo->image;
             }
 
             if (!m_finalizing) {
                 addCommand(new KeepNodesSelectedCommand(prevSelection, KisNodeList(),
                                                         prevNode, KisNodeSP(),
                                                         image, false));
             } else {
                 addCommand(new KeepNodesSelectedCommand(KisNodeList(), nextSelection,
                                                         KisNodeSP(), nextNode,
                                                         image, true));
             }
         }
 
     private:
         MergeDownInfoSP m_singleInfo;
         MergeMultipleInfoSP m_multipleInfo;
         bool m_finalizing;
         KisNodeSP m_putAfter;
     };
 
     struct CreateMergedLayer : public KisCommandUtils::AggregateCommand {
         CreateMergedLayer(MergeDownInfoSP info) : m_info(info) {}
 
         void populateChildCommands() override {
             // actual merging done by KisLayer::createMergedLayer (or specialized descendant)
             m_info->dstNode = m_info->currLayer->createMergedLayerTemplate(m_info->prevLayer);
 
             if (m_info->frames.size() > 0) {
                 m_info->dstNode->enableAnimation();
                 m_info->dstNode->getKeyframeChannel(KisKeyframeChannel::Content.id(), true);
             }
 
             m_info->dstNode->setUseInTimeline(m_info->useInTimeline);
 
             KisPaintLayer *dstPaintLayer = qobject_cast<KisPaintLayer*>(m_info->dstNode.data());
             if (dstPaintLayer) {
                 dstPaintLayer->setOnionSkinEnabled(m_info->enableOnionSkins);
             }
         }
 
     private:
         MergeDownInfoSP m_info;
     };
 
     struct CreateMergedLayerMultiple : public KisCommandUtils::AggregateCommand {
         CreateMergedLayerMultiple(MergeMultipleInfoSP info, const QString name = QString() )
             : m_info(info),
               m_name(name) {}
 
         void populateChildCommands() override {
             QString mergedLayerName;
 
             if (m_name.isEmpty()){
                 const QString mergedLayerSuffix = i18n("Merged");
                 mergedLayerName = m_info->mergedNodes.first()->name();
 
                 if (!mergedLayerName.endsWith(mergedLayerSuffix)) {
                     mergedLayerName = QString("%1 %2")
                         .arg(mergedLayerName).arg(mergedLayerSuffix);
                 }
             } else {
                 mergedLayerName = m_name;
             }
 
             KisPaintLayer *dstPaintLayer = new KisPaintLayer(m_info->image, mergedLayerName, OPACITY_OPAQUE_U8);
             m_info->dstNode = dstPaintLayer;
 
             if (m_info->frames.size() > 0) {
                 m_info->dstNode->enableAnimation();
                 m_info->dstNode->getKeyframeChannel(KisKeyframeChannel::Content.id(), true);
             }
 
 
             auto channelFlagsLazy = [](KisNodeSP node) {
                 KisLayer *layer = dynamic_cast<KisLayer*>(node.data());
                 return layer ? layer->channelFlags() : QBitArray();
             };
 
             QString compositeOpId;
             QBitArray channelFlags;
             bool compositionVaries = false;
             bool isFirstCycle = true;
 
             foreach (KisNodeSP node, m_info->allSrcNodes()) {
                 if (isFirstCycle) {
                     compositeOpId = node->compositeOpId();
                     channelFlags = channelFlagsLazy(node);
                     isFirstCycle = false;
                 } else if (compositeOpId != node->compositeOpId() ||
                            channelFlags != channelFlagsLazy(node)) {
                     compositionVaries = true;
                     break;
                 }
 
                 KisLayerSP layer = qobject_cast<KisLayer*>(node.data());
                 if (layer && layer->layerStyle()) {
                     compositionVaries = true;
                     break;
                 }
             }
 
             if (!compositionVaries) {
                 if (!compositeOpId.isEmpty()) {
                     m_info->dstNode->setCompositeOpId(compositeOpId);
                 }
                 if (m_info->dstLayer() && !channelFlags.isEmpty()) {
                     m_info->dstLayer()->setChannelFlags(channelFlags);
                 }
             }
 
             m_info->nodesCompositingVaries = compositionVaries;
 
             m_info->dstNode->setUseInTimeline(m_info->useInTimeline);
             dstPaintLayer->setOnionSkinEnabled(m_info->enableOnionSkins);
         }
 
     private:
         MergeMultipleInfoSP m_info;
         QString m_name;
     };
 
     struct MergeLayers : public KisCommandUtils::AggregateCommand {
         MergeLayers(MergeDownInfoSP info) : m_info(info) {}
 
         void populateChildCommands() override {
             // actual merging done by KisLayer::createMergedLayer (or specialized descendant)
             m_info->currLayer->fillMergedLayerTemplate(m_info->dstLayer(), m_info->prevLayer);
         }
 
     private:
         MergeDownInfoSP m_info;
     };
 
     struct MergeLayersMultiple : public KisCommandUtils::AggregateCommand {
         MergeLayersMultiple(MergeMultipleInfoSP info) : m_info(info) {}
 
         void populateChildCommands() override {
             KisPainter gc(m_info->dstNode->paintDevice());
 
             foreach (KisNodeSP node, m_info->allSrcNodes()) {
                 QRect rc = node->exactBounds() | m_info->image->bounds();
                 node->projectionPlane()->apply(&gc, rc);
             }
         }
 
     private:
         MergeMultipleInfoSP m_info;
     };
 
     struct MergeMetaData : public KUndo2Command {
         MergeMetaData(MergeDownInfoSP info, const KisMetaData::MergeStrategy* strategy)
             : m_info(info),
               m_strategy(strategy) {}
 
         void redo() override {
             QRect layerProjectionExtent = m_info->currLayer->projection()->extent();
             QRect prevLayerProjectionExtent = m_info->prevLayer->projection()->extent();
             int prevLayerArea = prevLayerProjectionExtent.width() * prevLayerProjectionExtent.height();
             int layerArea = layerProjectionExtent.width() * layerProjectionExtent.height();
 
             QList<double> scores;
             double norm = qMax(prevLayerArea, layerArea);
             scores.append(prevLayerArea / norm);
             scores.append(layerArea / norm);
 
             QList<const KisMetaData::Store*> srcs;
             srcs.append(m_info->prevLayer->metaData());
             srcs.append(m_info->currLayer->metaData());
             m_strategy->merge(m_info->dstLayer()->metaData(), srcs, scores);
         }
 
     private:
         MergeDownInfoSP m_info;
         const KisMetaData::MergeStrategy *m_strategy;
     };
 
     KeepNodesSelectedCommand::KeepNodesSelectedCommand(const KisNodeList &selectedBefore,
                                                        const KisNodeList &selectedAfter,
                                                        KisNodeSP activeBefore,
                                                        KisNodeSP activeAfter,
                                                        KisImageSP image,
                                                        bool finalize, KUndo2Command *parent)
         : FlipFlopCommand(finalize, parent),
           m_selectedBefore(selectedBefore),
           m_selectedAfter(selectedAfter),
           m_activeBefore(activeBefore),
           m_activeAfter(activeAfter),
           m_image(image)
     {
     }
 
     void KeepNodesSelectedCommand::end() {
         KisImageSignalType type;
         if (isFinalizing()) {
             type = ComplexNodeReselectionSignal(m_activeAfter, m_selectedAfter);
         } else {
             type = ComplexNodeReselectionSignal(m_activeBefore, m_selectedBefore);
         }
         m_image->signalRouter()->emitNotification(type);
     }
 
     KisLayerSP constructDefaultLayer(KisImageSP image) {
         return new KisPaintLayer(image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8, image->colorSpace());
     }
 
     RemoveNodeHelper::~RemoveNodeHelper()
     {
     }
 
     /**
      * The removal of two nodes in one go may be a bit tricky, because one
      * of them may be the clone of another. If we remove the source of a
      * clone layer, it will reincarnate into a paint layer. In this case
      * the pointer to the second layer will be lost.
      *
      * That's why we need to care about the order of the nodes removal:
      * the clone --- first, the source --- last.
      */
     void RemoveNodeHelper::safeRemoveMultipleNodes(KisNodeList nodes, KisImageSP image) {
         const bool lastLayer = scanForLastLayer(image, nodes);
 
         while (!nodes.isEmpty()) {
             KisNodeList::iterator it = nodes.begin();
 
             while (it != nodes.end()) {
                 if (!checkIsSourceForClone(*it, nodes)) {
                     KisNodeSP node = *it;
                     addCommandImpl(new KisImageLayerRemoveCommand(image, node, false, true));
                     it = nodes.erase(it);
                 } else {
                     ++it;
                 }
             }
         }
 
         if (lastLayer) {
             KisLayerSP newLayer = constructDefaultLayer(image);
             addCommandImpl(new KisImageLayerAddCommand(image, newLayer,
                                                        image->root(),
                                                        KisNodeSP(),
                                                        false, false));
         }
     }
 
     bool RemoveNodeHelper::checkIsSourceForClone(KisNodeSP src, const KisNodeList &nodes) {
         foreach (KisNodeSP node, nodes) {
             if (node == src) continue;
 
             KisCloneLayer *clone = dynamic_cast<KisCloneLayer*>(node.data());
 
             if (clone && KisNodeSP(clone->copyFrom()) == src) {
                 return true;
             }
         }
 
         return false;
     }
 
     bool RemoveNodeHelper::scanForLastLayer(KisImageWSP image, KisNodeList nodesToRemove) {
         bool removeLayers = false;
         Q_FOREACH(KisNodeSP nodeToRemove, nodesToRemove) {
             if (qobject_cast<KisLayer*>(nodeToRemove.data())) {
                 removeLayers = true;
                 break;
             }
         }
         if (!removeLayers) return false;
 
         bool lastLayer = true;
         KisNodeSP node = image->root()->firstChild();
         while (node) {
             if (!nodesToRemove.contains(node) &&
                 qobject_cast<KisLayer*>(node.data())) {
 
                 lastLayer = false;
                 break;
             }
             node = node->nextSibling();
         }
 
         return lastLayer;
     }
 
     SimpleRemoveLayers::SimpleRemoveLayers(const KisNodeList &nodes,
                                            KisImageSP image)
         : m_nodes(nodes),
           m_image(image)
     {
     }
 
     void SimpleRemoveLayers::populateChildCommands() {
         if (m_nodes.isEmpty()) return;
         safeRemoveMultipleNodes(m_nodes, m_image);
     }
 
     void SimpleRemoveLayers::addCommandImpl(KUndo2Command *cmd) {
         addCommand(cmd);
     }
 
     struct InsertNode : public KisCommandUtils::AggregateCommand {
         InsertNode(MergeDownInfoBaseSP info, KisNodeSP putAfter)
             : m_info(info), m_putAfter(putAfter) {}
 
         void populateChildCommands() override {
             addCommand(new KisImageLayerAddCommand(m_info->image,
                                                            m_info->dstNode,
                                                            m_putAfter->parent(),
                                                            m_putAfter,
                                                            true, false));
 
         }
 
     private:
         virtual void addCommandImpl(KUndo2Command *cmd) {
             addCommand(cmd);
         }
 
     private:
         MergeDownInfoBaseSP m_info;
         KisNodeSP m_putAfter;
     };
 
 
     struct CleanUpNodes : private RemoveNodeHelper, public KisCommandUtils::AggregateCommand {
         CleanUpNodes(MergeDownInfoBaseSP info, KisNodeSP putAfter)
             : m_info(info), m_putAfter(putAfter) {}
 
         static void findPerfectParent(KisNodeList nodesToDelete, KisNodeSP &putAfter, KisNodeSP &parent) {
             if (!putAfter) {
                 putAfter = nodesToDelete.last();
             }
 
             // Add the new merged node on top of the active node -- checking
             // whether the parent is going to be deleted
             parent = putAfter->parent();
             while (parent && nodesToDelete.contains(parent)) {
                 parent = parent->parent();
             }
         }
 
         void populateChildCommands() override {
             KisNodeList nodesToDelete = m_info->allSrcNodes();
 
             KisNodeSP parent;
             findPerfectParent(nodesToDelete, m_putAfter, parent);
 
             if (!parent) {
                 KisNodeSP oldRoot = m_info->image->root();
                 KisNodeSP newRoot(new KisGroupLayer(m_info->image, "root", OPACITY_OPAQUE_U8));
 
                 addCommand(new KisImageLayerAddCommand(m_info->image,
                                                        m_info->dstNode,
                                                        newRoot,
                                                        KisNodeSP(),
                                                        true, false));
                 addCommand(new KisImageChangeLayersCommand(m_info->image, oldRoot, newRoot));
 
             }
             else {
                 if (parent == m_putAfter->parent()) {
                     addCommand(new KisImageLayerAddCommand(m_info->image,
                                                            m_info->dstNode,
                                                            parent,
                                                            m_putAfter,
                                                            true, false));
                 }
                 else {
                     addCommand(new KisImageLayerAddCommand(m_info->image,
                                                            m_info->dstNode,
                                                            parent,
                                                            parent->lastChild(),
                                                            true, false));
                 }
 
                 /**
                  * We can merge selection masks, in this case dstLayer is not defined!
                  */
                 if (m_info->dstLayer()) {
                     reparentSelectionMasks(m_info->image,
                                            m_info->dstLayer(),
                                            m_info->selectionMasks);
                 }
 
                 KisNodeList safeNodesToDelete = m_info->allSrcNodes();
                 for (KisNodeList::iterator it = safeNodesToDelete.begin(); it != safeNodesToDelete.end(); ++it) {
                     KisNodeSP node = *it;
                     if (node->userLocked() && node->visible()) {
                         addCommand(new KisImageChangeVisibilityCommand(false, node));
                     }
                 }
 
                 KritaUtils::filterContainer<KisNodeList>(safeNodesToDelete, [this](KisNodeSP node) {
                   return !node->userLocked();
                 });
                 safeRemoveMultipleNodes(safeNodesToDelete, m_info->image);
             }
 
 
         }
 
     private:
         void addCommandImpl(KUndo2Command *cmd) override {
             addCommand(cmd);
         }
 
         void reparentSelectionMasks(KisImageSP image,
                                     KisLayerSP newLayer,
                                     const QVector<KisSelectionMaskSP> &selectionMasks) {
 
             KIS_SAFE_ASSERT_RECOVER_RETURN(newLayer);
 
             foreach (KisSelectionMaskSP mask, selectionMasks) {
                 addCommand(new KisImageLayerMoveCommand(image, mask, newLayer, newLayer->lastChild()));
                 addCommand(new KisActivateSelectionMaskCommand(mask, false));
             }
         }
     private:
         MergeDownInfoBaseSP m_info;
         KisNodeSP m_putAfter;
     };
 
     SwitchFrameCommand::SharedStorage::~SharedStorage() {
     }
 
     SwitchFrameCommand::SwitchFrameCommand(KisImageSP image, int time, bool finalize, SharedStorageSP storage)
         : FlipFlopCommand(finalize),
           m_image(image),
           m_newTime(time),
           m_storage(storage) {}
 
     SwitchFrameCommand::~SwitchFrameCommand() {}
 
     void SwitchFrameCommand::init() {
         KisImageAnimationInterface *interface = m_image->animationInterface();
         const int currentTime = interface->currentTime();
         if (currentTime == m_newTime) {
             m_storage->value = m_newTime;
             return;
         }
 
         interface->image()->disableUIUpdates();
         interface->saveAndResetCurrentTime(m_newTime, &m_storage->value);
     }
 
     void SwitchFrameCommand::end() {
         KisImageAnimationInterface *interface = m_image->animationInterface();
         const int currentTime = interface->currentTime();
         if (currentTime == m_storage->value) {
             return;
         }
 
         interface->restoreCurrentTime(&m_storage->value);
         interface->image()->enableUIUpdates();
     }
 
     struct AddNewFrame : public KisCommandUtils::AggregateCommand {
         AddNewFrame(MergeDownInfoBaseSP info, int frame) : m_info(info), m_frame(frame) {}
 
         void populateChildCommands() override {
             KUndo2Command *cmd = new KisCommandUtils::SkipFirstRedoWrapper();
             KisKeyframeChannel *channel = m_info->dstNode->getKeyframeChannel(KisKeyframeChannel::Content.id());
             KisKeyframeSP keyframe = channel->addKeyframe(m_frame, cmd);
 
             applyKeyframeColorLabel(keyframe);
 
             addCommand(cmd);
         }
 
         void applyKeyframeColorLabel(KisKeyframeSP dstKeyframe) {
             Q_FOREACH(KisNodeSP srcNode, m_info->allSrcNodes()) {
                 Q_FOREACH(KisKeyframeChannel *channel, srcNode->keyframeChannels().values()) {
                     KisKeyframeSP keyframe = channel->keyframeAt(m_frame);
                     if (!keyframe.isNull() && keyframe->colorLabel() != 0) {
                         dstKeyframe->setColorLabel(keyframe->colorLabel());
                         return;
                     }
                 }
             }
 
             dstKeyframe->setColorLabel(0);
         }
 
     private:
         MergeDownInfoBaseSP m_info;
         int m_frame;
     };
 
     QSet<int> fetchLayerFrames(KisNodeSP node) {
         KisKeyframeChannel *channel = node->getKeyframeChannel(KisKeyframeChannel::Content.id());
         if (!channel) return QSet<int>();
 
         return channel->allKeyframeIds();
     }
 
     QSet<int> fetchLayerFramesRecursive(KisNodeSP rootNode) {
         QSet<int> frames = fetchLayerFrames(rootNode);
 
         KisNodeSP node = rootNode->firstChild();
         while(node) {
             frames |= fetchLayerFramesRecursive(node);
             node = node->nextSibling();
         }
 
         return frames;
     }
 
     void updateFrameJobs(FrameJobs *jobs, KisNodeSP node) {
         QSet<int> frames = fetchLayerFrames(node);
 
         if (frames.isEmpty()) {
             (*jobs)[0].insert(node);
         } else {
             foreach (int frame, frames) {
                 (*jobs)[frame].insert(node);
             }
         }
     }
 
     void updateFrameJobsRecursive(FrameJobs *jobs, KisNodeSP rootNode) {
         updateFrameJobs(jobs, rootNode);
 
         KisNodeSP node = rootNode->firstChild();
         while(node) {
             updateFrameJobsRecursive(jobs, node);
             node = node->nextSibling();
         }
     }
 
     void mergeDown(KisImageSP image, KisLayerSP layer, const KisMetaData::MergeStrategy* strategy)
     {
         if (!layer->prevSibling()) return;
 
         // XXX: this breaks if we allow free mixing of masks and layers
         KisLayerSP prevLayer = qobject_cast<KisLayer*>(layer->prevSibling().data());
         if (!prevLayer) return;
 
         if (!layer->visible() && !prevLayer->visible()) {
             return;
         }
 
         KisImageSignalVector emitSignals;
         emitSignals << ModifiedSignal;
 
         KisProcessingApplicator applicator(image, 0,
                                            KisProcessingApplicator::NONE,
                                            emitSignals,
                                            kundo2_i18n("Merge Down"));
 
         if (layer->visible() && prevLayer->visible()) {
             MergeDownInfoSP info(new MergeDownInfo(image, prevLayer, layer));
 
             // disable key strokes on all colorize masks, all onion skins on
             // paint layers and wait until update is finished with a barrier
             applicator.applyCommand(new DisableColorizeKeyStrokes(info));
             applicator.applyCommand(new DisableOnionSkins(info));
             applicator.applyCommand(new KUndo2Command(), KisStrokeJobData::BARRIER);
 
             applicator.applyCommand(new KeepMergedNodesSelected(info, false));
             applicator.applyCommand(new FillSelectionMasks(info));
             applicator.applyCommand(new CreateMergedLayer(info), KisStrokeJobData::BARRIER);
 
             // NOTE: shape layer may have emitted spontaneous jobs during layer creation,
             //       wait for them to complete!
             applicator.applyCommand(new RefreshDelayedUpdateLayers(info), KisStrokeJobData::BARRIER);
             applicator.applyCommand(new KUndo2Command(), KisStrokeJobData::BARRIER);
 
             // in two-layer mode we disable pass trhough only when the destination layer
             // is not a group layer
             applicator.applyCommand(new DisablePassThroughForHeadsOnly(info, true));
             applicator.applyCommand(new KUndo2Command(), KisStrokeJobData::BARRIER);
 
             if (info->frames.size() > 0) {
                 foreach (int frame, info->frames) {
                     applicator.applyCommand(new SwitchFrameCommand(info->image, frame, false, info->storage));
 
                     applicator.applyCommand(new AddNewFrame(info, frame));
                     applicator.applyCommand(new RefreshHiddenAreas(info));
                     applicator.applyCommand(new RefreshDelayedUpdateLayers(info), KisStrokeJobData::BARRIER);
                     applicator.applyCommand(new MergeLayers(info), KisStrokeJobData::BARRIER);
 
                     applicator.applyCommand(new SwitchFrameCommand(info->image, frame, true, info->storage));
                 }
             } else {
                 applicator.applyCommand(new RefreshHiddenAreas(info));
                 applicator.applyCommand(new RefreshDelayedUpdateLayers(info), KisStrokeJobData::BARRIER);
                 applicator.applyCommand(new MergeLayers(info), KisStrokeJobData::BARRIER);
             }
 
             applicator.applyCommand(new MergeMetaData(info, strategy), KisStrokeJobData::BARRIER);
             applicator.applyCommand(new CleanUpNodes(info, layer),
                                     KisStrokeJobData::SEQUENTIAL,
                                     KisStrokeJobData::EXCLUSIVE);
             applicator.applyCommand(new KeepMergedNodesSelected(info, true));
         } else if (layer->visible()) {
             applicator.applyCommand(new KeepNodesSelectedCommand(KisNodeList(), KisNodeList(),
                                                                  layer, KisNodeSP(),
                                                                  image, false));
 
             applicator.applyCommand(
                 new SimpleRemoveLayers(KisNodeList() << prevLayer,
                                        image),
                 KisStrokeJobData::SEQUENTIAL,
                 KisStrokeJobData::EXCLUSIVE);
 
             applicator.applyCommand(new KeepNodesSelectedCommand(KisNodeList(), KisNodeList(),
                                                                  KisNodeSP(), layer,
                                                                  image, true));
         } else if (prevLayer->visible()) {
             applicator.applyCommand(new KeepNodesSelectedCommand(KisNodeList(), KisNodeList(),
                                                                  layer, KisNodeSP(),
                                                                  image, false));
 
             applicator.applyCommand(
                 new SimpleRemoveLayers(KisNodeList() << layer,
                                        image),
                 KisStrokeJobData::SEQUENTIAL,
                 KisStrokeJobData::EXCLUSIVE);
 
             applicator.applyCommand(new KeepNodesSelectedCommand(KisNodeList(), KisNodeList(),
                                                                  KisNodeSP(), prevLayer,
                                                                  image, true));
         }
 
         applicator.end();
     }
 
     bool checkIsChildOf(KisNodeSP node, const KisNodeList &parents)
     {
         KisNodeList nodeParents;
 
         KisNodeSP parent = node->parent();
         while (parent) {
             nodeParents << parent;
             parent = parent->parent();
         }
 
         foreach(KisNodeSP perspectiveParent, parents) {
             if (nodeParents.contains(perspectiveParent)) {
                 return true;
             }
         }
 
         return false;
     }
 
     bool checkIsCloneOf(KisNodeSP node, const KisNodeList &nodes)
     {
         bool result = false;
 
         KisCloneLayer *clone = dynamic_cast<KisCloneLayer*>(node.data());
         if (clone) {
             KisNodeSP cloneSource = KisNodeSP(clone->copyFrom());
 
             Q_FOREACH(KisNodeSP subtree, nodes) {
                 result =
                     recursiveFindNode(subtree,
                                       [cloneSource](KisNodeSP node) -> bool
                                       {
                                           return node == cloneSource;
                                       });
 
                 if (!result) {
                     result = checkIsCloneOf(cloneSource, nodes);
                 }
 
                 if (result) {
                     break;
                 }
             }
         }
 
         return result;
     }
 
     void filterMergableNodes(KisNodeList &nodes, bool allowMasks)
     {
         KisNodeList::iterator it = nodes.begin();
 
         while (it != nodes.end()) {
             if ((!allowMasks && !qobject_cast<KisLayer*>(it->data())) ||
                 checkIsChildOf(*it, nodes)) {
                 //qDebug() << "Skipping node" << ppVar((*it)->name());
                 it = nodes.erase(it);
             } else {
                 ++it;
             }
         }
     }
 
     void sortMergableNodes(KisNodeSP root, KisNodeList &inputNodes, KisNodeList &outputNodes)
     {
         KisNodeList::iterator it = std::find(inputNodes.begin(), inputNodes.end(), root);
 
         if (it != inputNodes.end()) {
             outputNodes << *it;
             inputNodes.erase(it);
         }
 
         if (inputNodes.isEmpty()) {
             return;
         }
 
         KisNodeSP child = root->firstChild();
         while (child) {
             sortMergableNodes(child, inputNodes, outputNodes);
             child = child->nextSibling();
         }
 
         /**
          * By the end of recursion \p inputNodes must be empty
          */
         KIS_ASSERT_RECOVER_NOOP(root->parent() || inputNodes.isEmpty());
     }
 
     KisNodeList sortMergableNodes(KisNodeSP root, KisNodeList nodes)
     {
         KisNodeList result;
         sortMergableNodes(root, nodes, result);
         return result;
     }
 
     KisNodeList sortAndFilterMergableInternalNodes(KisNodeList nodes, bool allowMasks)
     {
         KIS_ASSERT_RECOVER(!nodes.isEmpty()) { return nodes; }
 
         KisNodeSP root;
         Q_FOREACH(KisNodeSP node, nodes) {
             KisNodeSP localRoot = node;
             while (localRoot->parent()) {
                 localRoot = localRoot->parent();
             }
 
             if (!root) {
                 root = localRoot;
             }
             KIS_ASSERT_RECOVER(root == localRoot) { return nodes; }
         }
 
         KisNodeList result;
         sortMergableNodes(root, nodes, result);
         filterMergableNodes(result, allowMasks);
         return result;
     }
 
     void addCopyOfNameTag(KisNodeSP node)
     {
         const QString prefix = i18n("Copy of");
         QString newName = node->name();
         if (!newName.startsWith(prefix)) {
             newName = QString("%1 %2").arg(prefix).arg(newName);
             node->setName(newName);
         }
     }
 
     KisNodeList findNodesWithProps(KisNodeSP root, const KoProperties &props, bool excludeRoot)
     {
         KisNodeList nodes;
 
         if ((!excludeRoot || root->parent()) && root->check(props)) {
             nodes << root;
         }
 
         KisNodeSP node = root->firstChild();
         while (node) {
             nodes += findNodesWithProps(node, props, excludeRoot);
             node = node->nextSibling();
         }
 
         return nodes;
     }
 
     KisNodeList filterInvisibleNodes(const KisNodeList &nodes, KisNodeList *invisibleNodes, KisNodeSP *putAfter)
     {
         KIS_ASSERT_RECOVER(invisibleNodes) { return nodes; }
         KIS_ASSERT_RECOVER(putAfter) { return nodes; }
 
         KisNodeList visibleNodes;
         int putAfterIndex = -1;
 
         Q_FOREACH(KisNodeSP node, nodes) {
             if (node->visible() || node->userLocked()) {
                 visibleNodes << node;
             } else {
                 *invisibleNodes << node;
 
                 if (node == *putAfter) {
                     putAfterIndex = visibleNodes.size() - 1;
                 }
             }
         }
 
         if (!visibleNodes.isEmpty() && putAfterIndex >= 0) {
             putAfterIndex = qBound(0, putAfterIndex, visibleNodes.size() - 1);
             *putAfter = visibleNodes[putAfterIndex];
         }
 
         return visibleNodes;
     }
 
     void changeImageDefaultProjectionColor(KisImageSP image, const KoColor &color)
     {
         KisImageSignalVector emitSignals;
         emitSignals << ModifiedSignal;
 
         KisProcessingApplicator applicator(image,
                                            image->root(),
                                            KisProcessingApplicator::RECURSIVE,
                                            emitSignals,
                                            kundo2_i18n("Change projection color"),
                                            0,
                                            142857 + 1);
         applicator.applyCommand(new KisChangeProjectionColorCommand(image, color), KisStrokeJobData::BARRIER, KisStrokeJobData::EXCLUSIVE);
         applicator.end();
     }
 
     void mergeMultipleLayersImpl(KisImageSP image, KisNodeList mergedNodes, KisNodeSP putAfter,
                                            bool flattenSingleLayer, const KUndo2MagicString &actionName,
                                            bool cleanupNodes = true, const QString layerName = QString())
     {
         if (!putAfter) {
             putAfter = mergedNodes.first();
         }
 
         filterMergableNodes(mergedNodes);
         {
             KisNodeList tempNodes;
             std::swap(mergedNodes, tempNodes);
             sortMergableNodes(image->root(), tempNodes, mergedNodes);
         }
 
         if (mergedNodes.size() <= 1 &&
             (!flattenSingleLayer && mergedNodes.size() == 1)) return;
 
         KisImageSignalVector emitSignals;
         emitSignals << ModifiedSignal;
         emitSignals << ComplexNodeReselectionSignal(KisNodeSP(), KisNodeList(), KisNodeSP(), mergedNodes);
 
         KisProcessingApplicator applicator(image, 0,
                                            KisProcessingApplicator::NONE,
                                            emitSignals,
                                            actionName);
 
 
         KisNodeList originalNodes = mergedNodes;
         KisNodeList invisibleNodes;
         mergedNodes = filterInvisibleNodes(originalNodes, &invisibleNodes, &putAfter);
 
         if (!invisibleNodes.isEmpty()) {
             applicator.applyCommand(
                 new SimpleRemoveLayers(invisibleNodes,
                                        image),
                 KisStrokeJobData::SEQUENTIAL,
                 KisStrokeJobData::EXCLUSIVE);
         }
 
         if (mergedNodes.size() > 1 || invisibleNodes.isEmpty()) {
             MergeMultipleInfoSP info(new MergeMultipleInfo(image, mergedNodes));
 
             // disable key strokes on all colorize masks, all onion skins on
             // paint layers and wait until update is finished with a barrier
             applicator.applyCommand(new DisableColorizeKeyStrokes(info));
             applicator.applyCommand(new DisableOnionSkins(info));
             applicator.applyCommand(new DisablePassThroughForHeadsOnly(info));
             applicator.applyCommand(new KUndo2Command(), KisStrokeJobData::BARRIER);
 
             applicator.applyCommand(new KeepMergedNodesSelected(info, putAfter, false));
             applicator.applyCommand(new FillSelectionMasks(info));
             applicator.applyCommand(new CreateMergedLayerMultiple(info, layerName), KisStrokeJobData::BARRIER);
             applicator.applyCommand(new DisableExtraCompositing(info));
             applicator.applyCommand(new KUndo2Command(), KisStrokeJobData::BARRIER);
 
             if (info->frames.size() > 0) {
                 foreach (int frame, info->frames) {
                     applicator.applyCommand(new SwitchFrameCommand(info->image, frame, false, info->storage));
 
                     applicator.applyCommand(new AddNewFrame(info, frame));
                     applicator.applyCommand(new RefreshHiddenAreas(info));
                     applicator.applyCommand(new RefreshDelayedUpdateLayers(info), KisStrokeJobData::BARRIER);
                     applicator.applyCommand(new MergeLayersMultiple(info), KisStrokeJobData::BARRIER);
 
                     applicator.applyCommand(new SwitchFrameCommand(info->image, frame, true, info->storage));
                 }
             } else {
                 applicator.applyCommand(new RefreshHiddenAreas(info));
                 applicator.applyCommand(new RefreshDelayedUpdateLayers(info), KisStrokeJobData::BARRIER);
                 applicator.applyCommand(new MergeLayersMultiple(info), KisStrokeJobData::BARRIER);
             }
 
             //applicator.applyCommand(new MergeMetaData(info, strategy), KisStrokeJobData::BARRIER);
             if (cleanupNodes){
                 applicator.applyCommand(new CleanUpNodes(info, putAfter),
                                             KisStrokeJobData::SEQUENTIAL,
                                         KisStrokeJobData::EXCLUSIVE);
             } else {
                 applicator.applyCommand(new InsertNode(info, putAfter),
                                             KisStrokeJobData::SEQUENTIAL,
                                         KisStrokeJobData::EXCLUSIVE);
             }
             applicator.applyCommand(new KeepMergedNodesSelected(info, putAfter, true));
         }
 
         applicator.end();
 
     }
 
     void mergeMultipleLayers(KisImageSP image, KisNodeList mergedNodes, KisNodeSP putAfter)
     {
         mergeMultipleLayersImpl(image, mergedNodes, putAfter, false, kundo2_i18n("Merge Selected Nodes"));
     }
 
     void newLayerFromVisible(KisImageSP image, KisNodeSP putAfter)
     {
         KisNodeList mergedNodes;
         mergedNodes << image->root();
 
         mergeMultipleLayersImpl(image, mergedNodes, putAfter, true, kundo2_i18n("New From Visible"), false, i18nc("New layer created from all the visible layers", "Visible"));
     }
 
     struct MergeSelectionMasks : public KisCommandUtils::AggregateCommand {
         MergeSelectionMasks(MergeDownInfoBaseSP info, KisNodeSP putAfter)
             : m_info(info),
               m_putAfter(putAfter){}
 
         void populateChildCommands() override {
             KisNodeSP parent;
             CleanUpNodes::findPerfectParent(m_info->allSrcNodes(), m_putAfter, parent);
 
             KisLayerSP parentLayer;
             do {
                 parentLayer = qobject_cast<KisLayer*>(parent.data());
 
                 parent = parent->parent();
             } while(!parentLayer && parent);
 
             KisSelectionSP selection = new KisSelection();
 
             foreach (KisNodeSP node, m_info->allSrcNodes()) {
                 KisMaskSP mask = dynamic_cast<KisMask*>(node.data());
                 if (!mask) continue;
 
                 selection->pixelSelection()->applySelection(
                     mask->selection()->pixelSelection(), SELECTION_ADD);
             }
 
             KisSelectionMaskSP mergedMask = new KisSelectionMask(m_info->image);
             mergedMask->initSelection(parentLayer);
             mergedMask->setSelection(selection);
 
             m_info->dstNode = mergedMask;
         }
 
     private:
         MergeDownInfoBaseSP m_info;
         KisNodeSP m_putAfter;
     };
 
     struct ActivateSelectionMask : public KisCommandUtils::AggregateCommand {
         ActivateSelectionMask(MergeDownInfoBaseSP info)
             : m_info(info) {}
 
         void populateChildCommands() override {
             KisSelectionMaskSP mergedMask = dynamic_cast<KisSelectionMask*>(m_info->dstNode.data());
             addCommand(new KisActivateSelectionMaskCommand(mergedMask, true));
         }
 
     private:
         MergeDownInfoBaseSP m_info;
     };
 
     bool tryMergeSelectionMasks(KisImageSP image, KisNodeList mergedNodes, KisNodeSP putAfter)
     {
         QList<KisSelectionMaskSP> selectionMasks;
 
         for (auto it = mergedNodes.begin(); it != mergedNodes.end(); /*noop*/) {
             KisSelectionMaskSP mask = dynamic_cast<KisSelectionMask*>(it->data());
             if (!mask) {
                 it = mergedNodes.erase(it);
             } else {
                 selectionMasks.append(mask);
                 ++it;
             }
         }
 
         if (mergedNodes.isEmpty()) return false;
 
         KisLayerSP parentLayer = qobject_cast<KisLayer*>(selectionMasks.first()->parent().data());
         KIS_ASSERT_RECOVER(parentLayer) { return 0; }
 
         KisImageSignalVector emitSignals;
         emitSignals << ModifiedSignal;
 
         KisProcessingApplicator applicator(image, 0,
                                            KisProcessingApplicator::NONE,
                                            emitSignals,
                                            kundo2_i18n("Merge Selection Masks"));
 
         MergeMultipleInfoSP info(new MergeMultipleInfo(image, mergedNodes));
 
 
         applicator.applyCommand(new MergeSelectionMasks(info, putAfter));
         applicator.applyCommand(new CleanUpNodes(info, putAfter),
                                 KisStrokeJobData::SEQUENTIAL,
                                 KisStrokeJobData::EXCLUSIVE);
         applicator.applyCommand(new ActivateSelectionMask(info));
         applicator.end();
 
         return true;
     }
 
     void flattenLayer(KisImageSP image, KisLayerSP layer)
     {
         if (!layer->childCount() && !layer->layerStyle())
             return;
 
         KisNodeList mergedNodes;
         mergedNodes << layer;
 
         mergeMultipleLayersImpl(image, mergedNodes, layer, true, kundo2_i18n("Flatten Layer"));
     }
 
     void flattenImage(KisImageSP image, KisNodeSP activeNode)
     {
         if (!activeNode) {
             activeNode = image->root()->lastChild();
         }
 
 
         KisNodeList mergedNodes;
         mergedNodes << image->root();
 
         mergeMultipleLayersImpl(image, mergedNodes, activeNode, true, kundo2_i18n("Flatten Image"));
     }
 
     KisSimpleUpdateCommand::KisSimpleUpdateCommand(KisNodeList nodes, bool finalize, KUndo2Command *parent)
         : FlipFlopCommand(finalize, parent),
           m_nodes(nodes)
     {
     }
     void KisSimpleUpdateCommand::end()
     {
         updateNodes(m_nodes);
     }
     void KisSimpleUpdateCommand::updateNodes(const KisNodeList &nodes)
     {
         Q_FOREACH(KisNodeSP node, nodes) {
             node->setDirty(node->extent());
         }
     }
 
     KisNodeSP recursiveFindNode(KisNodeSP node, std::function<bool(KisNodeSP)> func)
     {
         if (func(node)) {
             return node;
         }
 
         node = node->firstChild();
         while (node) {
             KisNodeSP resultNode = recursiveFindNode(node, func);
             if (resultNode) {
                 return resultNode;
             }
             node = node->nextSibling();
         }
 
         return 0;
     }
 
     KisNodeSP findNodeByUuid(KisNodeSP root, const QUuid &uuid)
     {
         return recursiveFindNode(root,
             [uuid] (KisNodeSP node) {
                 return node->uuid() == uuid;
         });
     }
 
     void forceAllDelayedNodesUpdate(KisNodeSP root)
     {
         KisLayerUtils::recursiveApplyNodes(root,
         [] (KisNodeSP node) {
             KisDelayedUpdateNodeInterface *delayedUpdate =
                     dynamic_cast<KisDelayedUpdateNodeInterface*>(node.data());
             if (delayedUpdate) {
                 delayedUpdate->forceUpdateTimedNode();
             }
         });
     }
 
 }
diff --git a/libs/image/kis_processing_applicator.cpp b/libs/image/kis_processing_applicator.cpp
index f8d101b198..52e8680841 100644
--- a/libs/image/kis_processing_applicator.cpp
+++ b/libs/image/kis_processing_applicator.cpp
@@ -1,333 +1,334 @@
 /*
  *  Copyright (c) 2011 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_processing_applicator.h"
 
 #include "kis_image.h"
 #include "kis_node.h"
 #include "kis_clone_layer.h"
 #include "kis_processing_visitor.h"
 #include "commands_new/kis_processing_command.h"
 #include "kis_stroke_strategy_undo_command_based.h"
 #include "kis_layer_utils.h"
 #include "kis_command_utils.h"
+#include "kis_image_signal_router.h"
 
 class DisableUIUpdatesCommand : public KisCommandUtils::FlipFlopCommand
 {
 public:
     DisableUIUpdatesCommand(KisImageWSP image,
                             bool finalUpdate)
         : FlipFlopCommand(finalUpdate),
           m_image(image)
     {
     }
 
     void init() override {
         m_image->disableUIUpdates();
     }
 
     void end() override {
         m_image->enableUIUpdates();
     }
 
 private:
     KisImageWSP m_image;
 };
 
 
 class UpdateCommand : public KisCommandUtils::FlipFlopCommand
 {
 public:
     UpdateCommand(KisImageWSP image, KisNodeSP node,
                   KisProcessingApplicator::ProcessingFlags flags,
                   bool finalUpdate)
         : FlipFlopCommand(finalUpdate),
           m_image(image),
           m_node(node),
           m_flags(flags)
     {
     }
 
 private:
     void init() override {
         /**
          * We disable all non-centralized updates here. Everything
          * should be done by this command's explicit updates.
          *
          * If you still need third-party updates work, please add a
          * flag to the applicator.
          */
 
         m_image->disableDirtyRequests();
     }
 
     void end() override {
         m_image->enableDirtyRequests();
 
         if(m_flags.testFlag(KisProcessingApplicator::RECURSIVE)) {
             m_image->refreshGraphAsync(m_node);
         }
 
         m_node->setDirty(m_image->bounds());
 
         updateClones(m_node);
     }
 
     void updateClones(KisNodeSP node) {
         // simple tail-recursive iteration
 
         KisNodeSP prevNode = node->lastChild();
         while(prevNode) {
             updateClones(prevNode);
             prevNode = prevNode->prevSibling();
         }
 
         KisLayer *layer = qobject_cast<KisLayer*>(m_node.data());
         if(layer && layer->hasClones()) {
             Q_FOREACH (KisCloneLayerSP clone, layer->registeredClones()) {
                 if(!clone) continue;
 
                 QPoint offset(clone->x(), clone->y());
                 QRegion dirtyRegion(m_image->bounds());
                 dirtyRegion -= m_image->bounds().translated(offset);
 
                 clone->setDirty(dirtyRegion);
             }
         }
     }
 
 private:
     KisImageWSP m_image;
     KisNodeSP m_node;
     KisProcessingApplicator::ProcessingFlags m_flags;
 };
 
 class EmitImageSignalsCommand : public KisCommandUtils::FlipFlopCommand
 {
 public:
     EmitImageSignalsCommand(KisImageWSP image,
                             KisImageSignalVector emitSignals,
                             bool finalUpdate)
         : FlipFlopCommand(finalUpdate),
           m_image(image),
           m_emitSignals(emitSignals)
     {
     }
 
     void end() override {
         if (isFinalizing()) {
             doUpdate(m_emitSignals);
         } else {
             KisImageSignalVector reverseSignals;
 
             KisImageSignalVector::iterator i = m_emitSignals.end();
             while (i != m_emitSignals.begin()) {
                 --i;
                 reverseSignals.append(i->inverted());
             }
 
             doUpdate(reverseSignals);
         }
     }
 
 private:
     void doUpdate(KisImageSignalVector emitSignals) {
         Q_FOREACH (KisImageSignalType type, emitSignals) {
             m_image->signalRouter()->emitNotification(type);
         }
     }
 
 private:
     KisImageWSP m_image;
     KisImageSignalVector m_emitSignals;
 };
 
 
 KisProcessingApplicator::KisProcessingApplicator(KisImageWSP image,
                                                  KisNodeSP node,
                                                  ProcessingFlags flags,
                                                  KisImageSignalVector emitSignals,
                                                  const KUndo2MagicString &name,
                                                  KUndo2CommandExtraData *extraData,
                                                  int macroId)
     : m_image(image),
       m_node(node),
       m_flags(flags),
       m_emitSignals(emitSignals),
       m_finalSignalsEmitted(false)
 {
     KisStrokeStrategyUndoCommandBased *strategy =
             new KisStrokeStrategyUndoCommandBased(name, false, m_image.data());
 
     if (m_flags.testFlag(SUPPORTS_WRAPAROUND_MODE)) {
         strategy->setSupportsWrapAroundMode(true);
     }
 
     if (extraData) {
         strategy->setCommandExtraData(extraData);
     }
 
     strategy->setMacroId(macroId);
 
     m_strokeId = m_image->startStroke(strategy);
     if(!m_emitSignals.isEmpty()) {
         applyCommand(new EmitImageSignalsCommand(m_image, m_emitSignals, false), KisStrokeJobData::BARRIER);
     }
 
     if(m_flags.testFlag(NO_UI_UPDATES)) {
         applyCommand(new DisableUIUpdatesCommand(m_image, false), KisStrokeJobData::BARRIER);
     }
 
     if (m_node) {
         applyCommand(new UpdateCommand(m_image, m_node, m_flags, false));
     }
 }
 
 KisProcessingApplicator::~KisProcessingApplicator()
 {
 }
 
 
 void KisProcessingApplicator::applyVisitor(KisProcessingVisitorSP visitor,
                                            KisStrokeJobData::Sequentiality sequentiality,
                                            KisStrokeJobData::Exclusivity exclusivity)
 {
     if(!m_flags.testFlag(RECURSIVE)) {
         applyCommand(new KisProcessingCommand(visitor, m_node),
                      sequentiality, exclusivity);
     }
     else {
         visitRecursively(m_node, visitor, sequentiality, exclusivity);
     }
 }
 
 void KisProcessingApplicator::applyVisitorAllFrames(KisProcessingVisitorSP visitor,
                                                     KisStrokeJobData::Sequentiality sequentiality,
                                                     KisStrokeJobData::Exclusivity exclusivity)
 {
     KisLayerUtils::FrameJobs jobs;
 
     // TODO: implement a nonrecursive case when !m_flags.testFlag(RECURSIVE)
     //       (such case is not yet used anywhere)
     KIS_SAFE_ASSERT_RECOVER_NOOP(m_flags.testFlag(RECURSIVE));
 
     KisLayerUtils::updateFrameJobsRecursive(&jobs, m_node);
 
     if (jobs.isEmpty()) {
         applyVisitor(visitor, sequentiality, exclusivity);
         return;
     }
 
     KisLayerUtils::FrameJobs::const_iterator it = jobs.constBegin();
     KisLayerUtils::FrameJobs::const_iterator end = jobs.constEnd();
 
     KisLayerUtils::SwitchFrameCommand::SharedStorageSP switchFrameStorage(
         new KisLayerUtils::SwitchFrameCommand::SharedStorage());
 
     for (; it != end; ++it) {
         const int frame = it.key();
         const QSet<KisNodeSP> &nodes = it.value();
 
         applyCommand(new KisLayerUtils::SwitchFrameCommand(m_image, frame, false, switchFrameStorage), KisStrokeJobData::BARRIER, KisStrokeJobData::EXCLUSIVE);
 
         foreach (KisNodeSP node, nodes) {
             applyCommand(new KisProcessingCommand(visitor, node),
                          sequentiality, exclusivity);
         }
 
         applyCommand(new KisLayerUtils::SwitchFrameCommand(m_image, frame, true, switchFrameStorage), KisStrokeJobData::BARRIER, KisStrokeJobData::EXCLUSIVE);
     }
 }
 
 void KisProcessingApplicator::visitRecursively(KisNodeSP node,
                                                KisProcessingVisitorSP visitor,
                                                KisStrokeJobData::Sequentiality sequentiality,
                                                KisStrokeJobData::Exclusivity exclusivity)
 {
     // simple tail-recursive iteration
 
     KisNodeSP prevNode = node->lastChild();
     while(prevNode) {
         visitRecursively(prevNode, visitor, sequentiality, exclusivity);
         prevNode = prevNode->prevSibling();
     }
 
     applyCommand(new KisProcessingCommand(visitor, node),
                  sequentiality, exclusivity);
 }
 
 void KisProcessingApplicator::applyCommand(KUndo2Command *command,
                                            KisStrokeJobData::Sequentiality sequentiality,
                                            KisStrokeJobData::Exclusivity exclusivity)
 {
     /*
      * One should not add commands after the final signals have been
      * emitted, only end or cancel the stroke
      */
     KIS_ASSERT_RECOVER_RETURN(!m_finalSignalsEmitted);
 
     m_image->addJob(m_strokeId,
                     new KisStrokeStrategyUndoCommandBased::Data(KUndo2CommandSP(command),
                                                                 false,
                                                                 sequentiality,
                                                                 exclusivity));
 }
 
 void KisProcessingApplicator::explicitlyEmitFinalSignals()
 {
     KIS_ASSERT_RECOVER_RETURN(!m_finalSignalsEmitted);
 
     if (m_node) {
         applyCommand(new UpdateCommand(m_image, m_node, m_flags, true));
     }
 
     if(m_flags.testFlag(NO_UI_UPDATES)) {
         applyCommand(new DisableUIUpdatesCommand(m_image, true), KisStrokeJobData::BARRIER);
     }
 
     if(!m_emitSignals.isEmpty()) {
         applyCommand(new EmitImageSignalsCommand(m_image, m_emitSignals, true), KisStrokeJobData::BARRIER);
     }
 
     // simple consistency check
     m_finalSignalsEmitted = true;
 }
 
 void KisProcessingApplicator::end()
 {
     if (!m_finalSignalsEmitted) {
         explicitlyEmitFinalSignals();
     }
 
     m_image->endStroke(m_strokeId);
 }
 
 void KisProcessingApplicator::cancel()
 {
     m_image->cancelStroke(m_strokeId);
 }
 
 void KisProcessingApplicator::runSingleCommandStroke(KisImageSP image, KUndo2Command *cmd, KisStrokeJobData::Sequentiality sequentiality, KisStrokeJobData::Exclusivity exclusivity)
 {
     KisProcessingApplicator applicator(image, 0,
                                        KisProcessingApplicator::NONE,
                                        KisImageSignalVector() << ModifiedSignal,
                                        cmd->text());
     applicator.applyCommand(cmd, sequentiality, exclusivity);
     applicator.end();
 }
diff --git a/libs/image/kis_processing_applicator.h b/libs/image/kis_processing_applicator.h
index 49a30ea14f..586ad7013f 100644
--- a/libs/image/kis_processing_applicator.h
+++ b/libs/image/kis_processing_applicator.h
@@ -1,112 +1,112 @@
 /*
  *  Copyright (c) 2011 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KIS_PROCESSING_APPLICATOR_H
 #define __KIS_PROCESSING_APPLICATOR_H
 
 #include "kritaimage_export.h"
 #include "kis_types.h"
 
 #include "kis_stroke_job_strategy.h"
-#include "kis_image_signal_router.h"
+#include "KisImageSignals.h"
 #include "kundo2magicstring.h"
 #include "kundo2commandextradata.h"
 
 
 class KRITAIMAGE_EXPORT KisProcessingApplicator
 {
 public:
     enum ProcessingFlag {
         NONE = 0x0,
         RECURSIVE = 0x1,
         NO_UI_UPDATES = 0x2,
         SUPPORTS_WRAPAROUND_MODE = 0x4
     };
 
     Q_DECLARE_FLAGS(ProcessingFlags, ProcessingFlag)
 
 public:
     KisProcessingApplicator(KisImageWSP image,
                             KisNodeSP node,
                             ProcessingFlags flags = NONE,
                             KisImageSignalVector emitSignals = KisImageSignalVector(),
                             const KUndo2MagicString &name = KUndo2MagicString(),
                             KUndo2CommandExtraData *extraData = 0,
                             int macroId = -1);
 
     ~KisProcessingApplicator();
 
     void applyVisitor(KisProcessingVisitorSP visitor,
                       KisStrokeJobData::Sequentiality sequentiality = KisStrokeJobData::SEQUENTIAL,
                       KisStrokeJobData::Exclusivity exclusivity = KisStrokeJobData::NORMAL);
 
     void applyCommand(KUndo2Command *command,
                       KisStrokeJobData::Sequentiality sequentiality = KisStrokeJobData::SEQUENTIAL,
                       KisStrokeJobData::Exclusivity exclusivity = KisStrokeJobData::NORMAL);
 
     void applyVisitorAllFrames(KisProcessingVisitorSP visitor,
                                KisStrokeJobData::Sequentiality sequentiality = KisStrokeJobData::SEQUENTIAL,
                                KisStrokeJobData::Exclusivity exclusivity = KisStrokeJobData::NORMAL);
 
     /**
      * This method emits all the final update signals of the stroke
      * without actually ending the stroke. This can be used for
      * long-running strokes which are kept open to implement preview
      * of the actions.
      *
      * WARNING: you cannot add new commands/processings after the
      * final signals has been emitted. You should either call end() or
      * cancel().
      */
     void explicitlyEmitFinalSignals();
 
     void end();
     void cancel();
 
     /**
      * @brief runSingleCommandStroke creates a stroke and runs \p cmd in it.
      *        The text() field fo \p cmd is used as a title of the stroke.
      * @param image the image to run the stroke on
      * @param cmd the command to be executed
      * @param sequentiality sequentiality property of the command being executed (see strokes documentation)
      * @param exclusivity sequentiality property of the command being executed (see strokes documentation)
      */
     static void runSingleCommandStroke(KisImageSP image,
                                        KUndo2Command *cmd,
                                        KisStrokeJobData::Sequentiality sequentiality = KisStrokeJobData::SEQUENTIAL,
                                        KisStrokeJobData::Exclusivity exclusivity = KisStrokeJobData::NORMAL);
 
 private:
     void visitRecursively(KisNodeSP node,
                           KisProcessingVisitorSP visitor,
                           KisStrokeJobData::Sequentiality sequentiality,
                           KisStrokeJobData::Exclusivity exclusivity);
 
 private:
     KisImageWSP m_image;
     KisNodeSP m_node;
     ProcessingFlags m_flags;
     KisImageSignalVector m_emitSignals;
     KisStrokeId m_strokeId;
     bool m_finalSignalsEmitted;
 };
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(KisProcessingApplicator::ProcessingFlags)
 
 
 #endif /* __KIS_PROCESSING_APPLICATOR_H */