diff --git a/libs/global/kis_pointer_utils.h b/libs/global/kis_pointer_utils.h
index e5d2350fb7..ae1c14b9ff 100644
--- a/libs/global/kis_pointer_utils.h
+++ b/libs/global/kis_pointer_utils.h
@@ -1,103 +1,103 @@
 /*
  *  Copyright (c) 2016 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_POINTER_UTILS_H
 #define KIS_POINTER_UTILS_H
 
 #include <QSharedPointer>
 
 /**
  * Convert a raw pointer into a shared pointer
  */
 template <class T>
 inline QSharedPointer<T> toQShared(T* ptr) {
     return QSharedPointer<T>(ptr);
 }
 
 /**
  * Convert a list of raw pointers into a list of shared pointers
  */
 template <class A, template <class C> class List>
 List<QSharedPointer<A>> listToQShared(const List<A*> list) {
     List<QSharedPointer<A>> newList;
     Q_FOREACH(A* value, list) {
         newList.append(toQShared(value));
     }
     return newList;
 }
 
 
 /**
  * Convert a list of strong pointers into a list of weak pointers
  */
 template <template <class> class Container, class T>
 Container<QWeakPointer<T>> listStrongToWeak(const Container<QSharedPointer<T>> &containter)
 {
     Container<QWeakPointer<T> > result;
     Q_FOREACH (QSharedPointer<T> v, containter) {
         result << v;
     }
     return result;
 }
 
 /**
  * Convert a list of weak pointers into a list of strong pointers
  *
  * WARNING: By default, uses "all or nothing" rule. If at least one of
  *          the weak pointers is invalid, returns an *empty* list!
  *          Even though some other pointer can still be converted
  *          correctly.
  */
 template <template <class> class Container, class T>
     Container<QSharedPointer<T> > listWeakToStrong(const Container<QWeakPointer<T>> &containter,
                                                    bool allOrNothing = true)
 {
     Container<QSharedPointer<T> > result;
     Q_FOREACH (QWeakPointer<T> v, containter) {
         QSharedPointer<T> strong(v);
         if (!strong && allOrNothing) {
             result.clear();
             return result;
         }
 
         if (strong) {
             result << strong;
         }
     }
     return result;
 }
 
 /**
  * Converts a list of objects with type T into a list of objects of type R.
  * The conversion is done implicitly, therefore the c-tor of type R should
  * support it. The main usage case is conversion of pointers in "descendant-
  * to-parent" way.
  */
-template <typename R, typename T>
-inline QList<R> implicitCastList(const QList<T> &list)
+template <typename R, typename T, template <typename U> class Container>
+inline Container<R> implicitCastList(const Container<T> &list)
 {
-    QList<R> result;
+    Container<R> result;
 
     Q_FOREACH(const T &item, list) {
         result.append(item);
     }
     return result;
 }
 
 #endif // KIS_POINTER_UTILS_H
 
diff --git a/libs/image/CMakeLists.txt b/libs/image/CMakeLists.txt
index 7927c0daa5..88c40f8a48 100644
--- a/libs/image/CMakeLists.txt
+++ b/libs/image/CMakeLists.txt
@@ -1,375 +1,376 @@
 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
    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/KisFakeRunnableStrokeJobsExecutor.cpp b/libs/image/KisFakeRunnableStrokeJobsExecutor.cpp
index 38ef1c4b59..f3174fc2be 100644
--- a/libs/image/KisFakeRunnableStrokeJobsExecutor.cpp
+++ b/libs/image/KisFakeRunnableStrokeJobsExecutor.cpp
@@ -1,36 +1,36 @@
 /*
  *  Copyright (c) 2017 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 "KisFakeRunnableStrokeJobsExecutor.h"
 
 #include <KisRunnableStrokeJobData.h>
 #include <kis_assert.h>
 
 #include <QVector>
 
-void KisFakeRunnableStrokeJobsExecutor::addRunnableJobs(const QVector<KisRunnableStrokeJobData *> &list)
+void KisFakeRunnableStrokeJobsExecutor::addRunnableJobs(const QVector<KisRunnableStrokeJobDataBase *> &list)
 {
-    Q_FOREACH (KisRunnableStrokeJobData *data, list) {
+    Q_FOREACH (KisRunnableStrokeJobDataBase *data, list) {
         KIS_SAFE_ASSERT_RECOVER_NOOP(data->sequentiality() != KisStrokeJobData::BARRIER && "barrier jobs are not supported on the fake executor");
         KIS_SAFE_ASSERT_RECOVER_NOOP(data->exclusivity() != KisStrokeJobData::EXCLUSIVE && "exclusive jobs are not supported on the fake executor");
 
         data->run();
     }
 
     qDeleteAll(list);
 }
diff --git a/libs/image/KisFakeRunnableStrokeJobsExecutor.h b/libs/image/KisFakeRunnableStrokeJobsExecutor.h
index 5a7fd07af9..9e27dd5320 100644
--- a/libs/image/KisFakeRunnableStrokeJobsExecutor.h
+++ b/libs/image/KisFakeRunnableStrokeJobsExecutor.h
@@ -1,31 +1,31 @@
 /*
  *  Copyright (c) 2017 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 KISFAKERUNNABLESTROKEJOBSEXECUTOR_H
 #define KISFAKERUNNABLESTROKEJOBSEXECUTOR_H
 
 #include "KisRunnableStrokeJobsInterface.h"
 
 
 class KRITAIMAGE_EXPORT KisFakeRunnableStrokeJobsExecutor : public KisRunnableStrokeJobsInterface
 {
 public:
-    void addRunnableJobs(const QVector<KisRunnableStrokeJobData*> &list);
+    void addRunnableJobs(const QVector<KisRunnableStrokeJobDataBase*> &list);
 };
 
 #endif // KISFAKERUNNABLESTROKEJOBSEXECUTOR_H
diff --git a/libs/image/KisRunnableBasedStrokeStrategy.cpp b/libs/image/KisRunnableBasedStrokeStrategy.cpp
index 45829d73c6..42e9f9b26d 100644
--- a/libs/image/KisRunnableBasedStrokeStrategy.cpp
+++ b/libs/image/KisRunnableBasedStrokeStrategy.cpp
@@ -1,79 +1,79 @@
 /*
  *  Copyright (c) 2017 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 "KisRunnableBasedStrokeStrategy.h"
 
 #include <QRunnable>
 #include <functional>
 
 #include "KisRunnableStrokeJobData.h"
 #include "KisRunnableStrokeJobsInterface.h"
 
 struct KisRunnableBasedStrokeStrategy::JobsInterface : public KisRunnableStrokeJobsInterface
 {
     JobsInterface(KisRunnableBasedStrokeStrategy *q)
         : m_q(q)
     {
     }
 
 
-    void addRunnableJobs(const QVector<KisRunnableStrokeJobData*> &list) {
+    void addRunnableJobs(const QVector<KisRunnableStrokeJobDataBase*> &list) {
         QVector<KisStrokeJobData*> newList;
 
-        Q_FOREACH (KisRunnableStrokeJobData *item, list) {
+        Q_FOREACH (KisRunnableStrokeJobDataBase *item, list) {
             newList.append(item);
         }
 
         m_q->addMutatedJobs(newList);
     }
 
 private:
     KisRunnableBasedStrokeStrategy *m_q;
 };
 
 
 KisRunnableBasedStrokeStrategy::KisRunnableBasedStrokeStrategy(QString id, const KUndo2MagicString &name)
     : KisSimpleStrokeStrategy(id, name),
       m_jobsInterface(new JobsInterface(this))
 {
 }
 
 KisRunnableBasedStrokeStrategy::KisRunnableBasedStrokeStrategy(const KisRunnableBasedStrokeStrategy &rhs)
     : KisSimpleStrokeStrategy(rhs),
       m_jobsInterface(new JobsInterface(this))
 {
 }
 
 KisRunnableBasedStrokeStrategy::~KisRunnableBasedStrokeStrategy()
 {
 }
 
 void KisRunnableBasedStrokeStrategy::doStrokeCallback(KisStrokeJobData *data)
 {
     if (!data) return;
 
-    KisRunnableStrokeJobData *runnable = dynamic_cast<KisRunnableStrokeJobData*>(data);
+    KisRunnableStrokeJobDataBase *runnable = dynamic_cast<KisRunnableStrokeJobDataBase*>(data);
     if (!runnable) return;
 
     runnable->run();
 }
 
 KisRunnableStrokeJobsInterface *KisRunnableBasedStrokeStrategy::runnableJobsInterface() const
 {
     return m_jobsInterface.data();
 }
diff --git a/libs/image/KisRunnableBasedStrokeStrategy.h b/libs/image/KisRunnableBasedStrokeStrategy.h
index 6346ecafe0..46cd031ae0 100644
--- a/libs/image/KisRunnableBasedStrokeStrategy.h
+++ b/libs/image/KisRunnableBasedStrokeStrategy.h
@@ -1,44 +1,44 @@
 /*
  *  Copyright (c) 2017 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 KISRUNNABLEBASEDSTROKESTRATEGY_H
 #define KISRUNNABLEBASEDSTROKESTRATEGY_H
 
 #include "kis_simple_stroke_strategy.h"
 
 class KisRunnableStrokeJobsInterface;
 
 class KRITAIMAGE_EXPORT KisRunnableBasedStrokeStrategy : public KisSimpleStrokeStrategy
 {
 private:
     struct JobsInterface;
 
 public:
-    KisRunnableBasedStrokeStrategy(QString id, const KUndo2MagicString &name);
+    KisRunnableBasedStrokeStrategy(QString id, const KUndo2MagicString &name = KUndo2MagicString());
     KisRunnableBasedStrokeStrategy(const KisRunnableBasedStrokeStrategy &rhs);
     ~KisRunnableBasedStrokeStrategy();
 
     void doStrokeCallback(KisStrokeJobData *data) override;
 
     KisRunnableStrokeJobsInterface *runnableJobsInterface() const;
 
 private:
     const QScopedPointer<KisRunnableStrokeJobsInterface> m_jobsInterface;
 };
 
 #endif // KISRUNNABLEBASEDSTROKESTRATEGY_H
diff --git a/libs/image/KisRunnableStrokeJobData.cpp b/libs/image/KisRunnableStrokeJobData.cpp
index a79fd504a0..a55b6be59c 100644
--- a/libs/image/KisRunnableStrokeJobData.cpp
+++ b/libs/image/KisRunnableStrokeJobData.cpp
@@ -1,48 +1,48 @@
 /*
  *  Copyright (c) 2017 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 "KisRunnableStrokeJobData.h"
 
 #include <QRunnable>
 #include <kis_assert.h>
 
 KisRunnableStrokeJobData::KisRunnableStrokeJobData(QRunnable *runnable, KisStrokeJobData::Sequentiality sequentiality, KisStrokeJobData::Exclusivity exclusivity)
-    : KisStrokeJobData(sequentiality, exclusivity),
+    : KisRunnableStrokeJobDataBase(sequentiality, exclusivity),
       m_runnable(runnable)
 {
 }
 
 KisRunnableStrokeJobData::KisRunnableStrokeJobData(std::function<void ()> func, KisStrokeJobData::Sequentiality sequentiality, KisStrokeJobData::Exclusivity exclusivity)
-    : KisStrokeJobData(sequentiality, exclusivity),
+    : KisRunnableStrokeJobDataBase(sequentiality, exclusivity),
       m_func(func)
 {
 }
 
 KisRunnableStrokeJobData::~KisRunnableStrokeJobData() {
     if (m_runnable && m_runnable->autoDelete()) {
         delete m_runnable;
     }
 }
 
 void KisRunnableStrokeJobData::run() {
     if (m_runnable) {
         m_runnable->run();
     } else if (m_func) {
         m_func();
     }
 }
diff --git a/libs/image/KisRunnableStrokeJobData.h b/libs/image/KisRunnableStrokeJobData.h
index 1afbffed40..738aa6e524 100644
--- a/libs/image/KisRunnableStrokeJobData.h
+++ b/libs/image/KisRunnableStrokeJobData.h
@@ -1,45 +1,45 @@
 /*
  *  Copyright (c) 2017 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 KISRUNNABLESTROKEJOBDATA_H
 #define KISRUNNABLESTROKEJOBDATA_H
 
 #include "kritaimage_export.h"
-#include "kis_stroke_job_strategy.h"
+#include "KisRunnableStrokeJobDataBase.h"
 #include <functional>
 
 class QRunnable;
 
-class KRITAIMAGE_EXPORT KisRunnableStrokeJobData : public KisStrokeJobData {
+class KRITAIMAGE_EXPORT KisRunnableStrokeJobData : public KisRunnableStrokeJobDataBase {
 public:
     KisRunnableStrokeJobData(QRunnable *runnable, KisStrokeJobData::Sequentiality sequentiality = KisStrokeJobData::SEQUENTIAL,
                              KisStrokeJobData::Exclusivity exclusivity = KisStrokeJobData::NORMAL);
 
     KisRunnableStrokeJobData(std::function<void()> func, KisStrokeJobData::Sequentiality sequentiality = KisStrokeJobData::SEQUENTIAL,
                              KisStrokeJobData::Exclusivity exclusivity = KisStrokeJobData::NORMAL);
 
     ~KisRunnableStrokeJobData();
 
-    void run();
+    void run() override;
 
 private:
     QRunnable *m_runnable = 0;
     std::function<void()> m_func;
 };
 
 #endif // KISRUNNABLESTROKEJOBDATA_H
diff --git a/libs/image/KisRunnableStrokeJobsInterface.cpp b/libs/image/KisRunnableStrokeJobDataBase.cpp
similarity index 70%
copy from libs/image/KisRunnableStrokeJobsInterface.cpp
copy to libs/image/KisRunnableStrokeJobDataBase.cpp
index 76c667c89d..81f9f50c34 100644
--- a/libs/image/KisRunnableStrokeJobsInterface.cpp
+++ b/libs/image/KisRunnableStrokeJobDataBase.cpp
@@ -1,31 +1,24 @@
 /*
- *  Copyright (c) 2017 Dmitry Kazakov <dimula73@gmail.com>
+ *  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 "KisRunnableStrokeJobsInterface.h"
+#include "KisRunnableStrokeJobDataBase.h"
 
-#include <QVector>
-
-KisRunnableStrokeJobsInterface::~KisRunnableStrokeJobsInterface()
-{
-
-}
-
-void KisRunnableStrokeJobsInterface::addRunnableJob(KisRunnableStrokeJobData *data)
+KisRunnableStrokeJobDataBase::KisRunnableStrokeJobDataBase(KisStrokeJobData::Sequentiality sequentiality, KisStrokeJobData::Exclusivity exclusivity)
+    : KisStrokeJobData(sequentiality, exclusivity)
 {
-    addRunnableJobs({data});
 }
diff --git a/libs/image/KisRunnableStrokeJobsInterface.h b/libs/image/KisRunnableStrokeJobDataBase.h
similarity index 58%
copy from libs/image/KisRunnableStrokeJobsInterface.h
copy to libs/image/KisRunnableStrokeJobDataBase.h
index 6f522f3690..35d54d70bf 100644
--- a/libs/image/KisRunnableStrokeJobsInterface.h
+++ b/libs/image/KisRunnableStrokeJobDataBase.h
@@ -1,37 +1,34 @@
 /*
- *  Copyright (c) 2017 Dmitry Kazakov <dimula73@gmail.com>
+ *  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 KISRUNNABLESTROKEJOBSINTERFACE_H
-#define KISRUNNABLESTROKEJOBSINTERFACE_H
+#ifndef KISRUNNABLESTROKEJOBDATABASE_H
+#define KISRUNNABLESTROKEJOBDATABASE_H
 
-#include "kritaimage_export.h"
-#include <QtGlobal>
-
-class KisRunnableStrokeJobData;
 
+#include "kritaimage_export.h"
+#include "kis_stroke_job_strategy.h"
+#include "kis_runnable.h"
 
-class KRITAIMAGE_EXPORT KisRunnableStrokeJobsInterface
+class KRITAIMAGE_EXPORT KisRunnableStrokeJobDataBase : public KisStrokeJobData, public KisRunnable
 {
 public:
-    virtual ~KisRunnableStrokeJobsInterface();
-
-    void addRunnableJob(KisRunnableStrokeJobData *data);
-    virtual void addRunnableJobs(const QVector<KisRunnableStrokeJobData*> &list) = 0;
+    KisRunnableStrokeJobDataBase(KisStrokeJobData::Sequentiality sequentiality = KisStrokeJobData::SEQUENTIAL,
+                                 KisStrokeJobData::Exclusivity exclusivity = KisStrokeJobData::NORMAL);
 };
 
-#endif // KISRUNNABLESTROKEJOBSINTERFACE_H
+#endif // KISRUNNABLESTROKEJOBDATABASE_H
diff --git a/libs/image/KisRunnableStrokeJobUtils.h b/libs/image/KisRunnableStrokeJobUtils.h
index f47a75d2fe..bc1dc0722b 100644
--- a/libs/image/KisRunnableStrokeJobUtils.h
+++ b/libs/image/KisRunnableStrokeJobUtils.h
@@ -1,52 +1,52 @@
 /*
  *  Copyright (c) 2017 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 KISRUNNABLESTROKEJOBUTILS_H
 #define KISRUNNABLESTROKEJOBUTILS_H
 
 #include <QVector>
 
 #include "kis_stroke_job_strategy.h"
 #include "KisRunnableStrokeJobData.h"
 
 namespace KritaUtils
 {
 
-template <typename Func>
-void addJobSequential(QVector<KisRunnableStrokeJobData*> &jobs, Func func) {
+template <typename Func, typename Job>
+void addJobSequential(QVector<Job*> &jobs, Func func) {
     jobs.append(new KisRunnableStrokeJobData(func, KisStrokeJobData::SEQUENTIAL));
 }
 
-template <typename Func>
-void addJobConcurrent(QVector<KisRunnableStrokeJobData*> &jobs, Func func) {
+template <typename Func, typename Job>
+void addJobConcurrent(QVector<Job*> &jobs, Func func) {
     jobs.append(new KisRunnableStrokeJobData(func, KisStrokeJobData::CONCURRENT));
 }
 
-template <typename Func>
-void addJobBarrier(QVector<KisRunnableStrokeJobData*> &jobs, Func func) {
+template <typename Func, typename Job>
+void addJobBarrier(QVector<Job*> &jobs, Func func) {
     jobs.append(new KisRunnableStrokeJobData(func, KisStrokeJobData::BARRIER));
 }
 
-template <typename Func>
-void addJobUniquelyCuncurrent(QVector<KisRunnableStrokeJobData*> &jobs, Func func) {
+template <typename Func, typename Job>
+void addJobUniquelyCuncurrent(QVector<Job*> &jobs, Func func) {
     jobs.append(new KisRunnableStrokeJobData(func, KisStrokeJobData::UNIQUELY_CONCURRENT));
 }
 
 }
 
 #endif // KISRUNNABLESTROKEJOBUTILS_H
diff --git a/libs/image/KisRunnableStrokeJobsInterface.cpp b/libs/image/KisRunnableStrokeJobsInterface.cpp
index 76c667c89d..db8b382bc9 100644
--- a/libs/image/KisRunnableStrokeJobsInterface.cpp
+++ b/libs/image/KisRunnableStrokeJobsInterface.cpp
@@ -1,31 +1,31 @@
 /*
  *  Copyright (c) 2017 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 "KisRunnableStrokeJobsInterface.h"
 
 #include <QVector>
 
 KisRunnableStrokeJobsInterface::~KisRunnableStrokeJobsInterface()
 {
 
 }
 
-void KisRunnableStrokeJobsInterface::addRunnableJob(KisRunnableStrokeJobData *data)
+void KisRunnableStrokeJobsInterface::addRunnableJob(KisRunnableStrokeJobDataBase *data)
 {
     addRunnableJobs({data});
 }
diff --git a/libs/image/KisRunnableStrokeJobsInterface.h b/libs/image/KisRunnableStrokeJobsInterface.h
index 6f522f3690..b5bf353591 100644
--- a/libs/image/KisRunnableStrokeJobsInterface.h
+++ b/libs/image/KisRunnableStrokeJobsInterface.h
@@ -1,37 +1,43 @@
 /*
  *  Copyright (c) 2017 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 KISRUNNABLESTROKEJOBSINTERFACE_H
 #define KISRUNNABLESTROKEJOBSINTERFACE_H
 
 #include "kritaimage_export.h"
 #include <QtGlobal>
+#include "kis_pointer_utils.h"
 
-class KisRunnableStrokeJobData;
+class KisRunnableStrokeJobDataBase;
 
 
 class KRITAIMAGE_EXPORT KisRunnableStrokeJobsInterface
 {
 public:
     virtual ~KisRunnableStrokeJobsInterface();
 
-    void addRunnableJob(KisRunnableStrokeJobData *data);
-    virtual void addRunnableJobs(const QVector<KisRunnableStrokeJobData*> &list) = 0;
+    void addRunnableJob(KisRunnableStrokeJobDataBase *data);
+    virtual void addRunnableJobs(const QVector<KisRunnableStrokeJobDataBase*> &list) = 0;
+
+    template <typename T>
+    void addRunnableJobs(const QVector<T*> &list) {
+        this->addRunnableJobs(implicitCastList<KisRunnableStrokeJobDataBase*>(list));
+    }
 };
 
 #endif // KISRUNNABLESTROKEJOBSINTERFACE_H
diff --git a/libs/image/kis_image.cc b/libs/image/kis_image.cc
index 02968618e1..3ff72e994c 100644
--- a/libs/image/kis_image.cc
+++ b/libs/image/kis_image.cc
@@ -1,1768 +1,1782 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2007 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_image.h"
 
 #include <KoConfig.h> // WORDS_BIGENDIAN
 
 #include <stdlib.h>
 #include <math.h>
 
 #include <QImage>
 #include <QPainter>
 #include <QSize>
 #include <QDateTime>
 #include <QRect>
 #include <QRegion>
 #include <QtConcurrent>
 
 #include <klocalizedstring.h>
 
 #include "KoColorSpaceRegistry.h"
 #include "KoColor.h"
 #include "KoColorProfile.h"
 #include <KoCompositeOpRegistry.h>
 #include "KisProofingConfiguration.h"
 
 #include "kis_adjustment_layer.h"
 #include "kis_annotation.h"
 #include "kis_change_profile_visitor.h"
 #include "kis_colorspace_convert_visitor.h"
 #include "kis_count_visitor.h"
 #include "kis_filter_strategy.h"
 #include "kis_group_layer.h"
 #include "commands/kis_image_commands.h"
 #include "kis_layer.h"
 #include "kis_meta_data_merge_strategy_registry.h"
 #include "kis_name_server.h"
 #include "kis_paint_layer.h"
 #include "kis_projection_leaf.h"
 #include "kis_painter.h"
 #include "kis_selection.h"
 #include "kis_transaction.h"
 #include "kis_meta_data_merge_strategy.h"
 #include "kis_memory_statistics_server.h"
 
 #include "kis_image_config.h"
 #include "kis_update_scheduler.h"
 #include "kis_image_signal_router.h"
 #include "kis_image_animation_interface.h"
 #include "kis_stroke_strategy.h"
 #include "kis_simple_stroke_strategy.h"
 #include "kis_image_barrier_locker.h"
 
 
 #include "kis_undo_stores.h"
 #include "kis_legacy_undo_adapter.h"
 #include "kis_post_execution_undo_adapter.h"
 
 #include "kis_transform_worker.h"
 #include "kis_processing_applicator.h"
 #include "processing/kis_crop_processing_visitor.h"
 #include "processing/kis_crop_selections_processing_visitor.h"
 #include "processing/kis_transform_processing_visitor.h"
 #include "commands_new/kis_image_resize_command.h"
 #include "commands_new/kis_image_set_resolution_command.h"
 #include "commands_new/kis_activate_selection_mask_command.h"
 #include "kis_composite_progress_proxy.h"
 #include "kis_layer_composition.h"
 #include "kis_wrapped_rect.h"
 #include "kis_crop_saved_extra_data.h"
 #include "kis_layer_utils.h"
 
 #include "kis_lod_transform.h"
 
 #include "kis_suspend_projection_updates_stroke_strategy.h"
 #include "kis_sync_lod_cache_stroke_strategy.h"
 
 #include "kis_projection_updates_filter.h"
 
 #include "kis_layer_projection_plane.h"
 
 #include "kis_update_time_monitor.h"
+#include "tiles3/kis_lockless_stack.h"
 
 #include <QtCore>
 
 #include <functional>
 
 #include "kis_time_range.h"
 
 // #define SANITY_CHECKS
 
 #ifdef SANITY_CHECKS
 #define SANITY_CHECK_LOCKED(name)                                       \
     if (!locked()) warnKrita() << "Locking policy failed:" << name          \
                                << "has been called without the image"       \
                                   "being locked";
 #else
 #define SANITY_CHECK_LOCKED(name)
 #endif
 
 
 struct KisImageSPStaticRegistrar {
     KisImageSPStaticRegistrar() {
         qRegisterMetaType<KisImageSP>("KisImageSP");
     }
 };
 static KisImageSPStaticRegistrar __registrar;
 
 class KisImage::KisImagePrivate
 {
 public:
     KisImagePrivate(KisImage *_q, qint32 w, qint32 h,
                     const KoColorSpace *c,
                     KisUndoStore *undo,
                     KisImageAnimationInterface *_animationInterface)
         : q(_q)
         , lockedForReadOnly(false)
         , width(w)
         , height(h)
         , colorSpace(c ? c : KoColorSpaceRegistry::instance()->rgb8())
         , nserver(1)
         , undoStore(undo ? undo : new KisDumbUndoStore())
         , legacyUndoAdapter(undoStore.data(), _q)
         , postExecutionUndoAdapter(undoStore.data(), _q)
         , signalRouter(_q)
         , animationInterface(_animationInterface)
         , scheduler(_q, _q)
         , axesCenter(QPointF(0.5, 0.5))
     {
         {
             KisImageConfig cfg;
             if (cfg.enableProgressReporting()) {
                 scheduler.setProgressProxy(&compositeProgressProxy);
             }
 
             // Each of these lambdas defines a new factory function.
             scheduler.setLod0ToNStrokeStrategyFactory(
                 [=](bool forgettable) {
                     return KisLodSyncPair(
                         new KisSyncLodCacheStrokeStrategy(KisImageWSP(q), forgettable),
                         KisSyncLodCacheStrokeStrategy::createJobsData(KisImageWSP(q)));
                 });
 
             scheduler.setSuspendUpdatesStrokeStrategyFactory(
                 [=]() {
                     return KisSuspendResumePair(
                         new KisSuspendProjectionUpdatesStrokeStrategy(KisImageWSP(q), true),
                         KisSuspendProjectionUpdatesStrokeStrategy::createSuspendJobsData(KisImageWSP(q)));
                 });
 
             scheduler.setResumeUpdatesStrokeStrategyFactory(
                 [=]() {
                     return KisSuspendResumePair(
                         new KisSuspendProjectionUpdatesStrokeStrategy(KisImageWSP(q), false),
                         KisSuspendProjectionUpdatesStrokeStrategy::createResumeJobsData(KisImageWSP(q)));
                 });
         }
 
         connect(q, SIGNAL(sigImageModified()), KisMemoryStatisticsServer::instance(), SLOT(notifyImageChanged()));
     }
 
     ~KisImagePrivate() {
         /**
          * Stop animation interface. It may use the rootLayer.
          */
         delete animationInterface;
 
         /**
          * First delete the nodes, while strokes
          * and undo are still alive
          */
         rootLayer.clear();
     }
 
     KisImage *q;
 
     quint32 lockCount = 0;
     bool lockedForReadOnly;
 
     qint32 width;
     qint32 height;
 
     double xres = 1.0;
     double yres = 1.0;
 
     const KoColorSpace * colorSpace;
     KisProofingConfigurationSP proofingConfig;
 
     KisSelectionSP deselectedGlobalSelection;
     KisGroupLayerSP rootLayer; // The layers are contained in here
     QList<KisLayerCompositionSP> compositions;
     KisNodeSP isolatedRootNode;
     bool wrapAroundModePermitted = false;
 
     KisNameServer nserver;
 
     QScopedPointer<KisUndoStore> undoStore;
     KisLegacyUndoAdapter legacyUndoAdapter;
     KisPostExecutionUndoAdapter postExecutionUndoAdapter;
 
     vKisAnnotationSP annotations;
 
     QAtomicInt disableUIUpdateSignals;
+    KisLocklessStack<QRect> savedDisabledUIUpdates;
+
     KisProjectionUpdatesFilterSP projectionUpdatesFilter;
     KisImageSignalRouter signalRouter;
     KisImageAnimationInterface *animationInterface;
     KisUpdateScheduler scheduler;
     QAtomicInt disableDirtyRequests;
 
 
     KisCompositeProgressProxy compositeProgressProxy;
 
     bool blockLevelOfDetail = false;
 
     QPointF axesCenter;
 
     bool tryCancelCurrentStrokeAsync();
 
     void notifyProjectionUpdatedInPatches(const QRect &rc);
 };
 
 KisImage::KisImage(KisUndoStore *undoStore, qint32 width, qint32 height, const KoColorSpace * colorSpace, const QString& name)
         : QObject(0)
         , KisShared()
         , m_d(new KisImagePrivate(this, width, height,
                                   colorSpace, undoStore,
                                   new KisImageAnimationInterface(this)))
 {
     // make sure KisImage belongs to the GUI thread
     moveToThread(qApp->thread());
     connect(this, SIGNAL(sigInternalStopIsolatedModeRequested()), SLOT(stopIsolatedMode()));
 
     setObjectName(name);
     setRootLayer(new KisGroupLayer(this, "root", OPACITY_OPAQUE_U8));
 }
 
 KisImage::~KisImage()
 {
     dbgImage << "deleting kisimage" << objectName();
 
     /**
      * Request the tools to end currently running strokes
      */
     waitForDone();
 
     delete m_d;
     disconnect(); // in case Qt gets confused
 }
 
 KisImage *KisImage::clone(bool exactCopy)
 {
     return new KisImage(*this, 0, exactCopy);
 }
 
 KisImage::KisImage(const KisImage& rhs, KisUndoStore *undoStore, bool exactCopy)
     : KisNodeFacade(),
       KisNodeGraphListener(),
       KisShared(),
       m_d(new KisImagePrivate(this,
                               rhs.width(), rhs.height(),
                               rhs.colorSpace(),
                               undoStore ? undoStore : new KisDumbUndoStore(),
                               new KisImageAnimationInterface(*rhs.animationInterface(), this)))
 {
     // make sure KisImage belongs to the GUI thread
     moveToThread(qApp->thread());
     connect(this, SIGNAL(sigInternalStopIsolatedModeRequested()), SLOT(stopIsolatedMode()));
 
     setObjectName(rhs.objectName());
 
     m_d->xres = rhs.m_d->xres;
     m_d->yres = rhs.m_d->yres;
 
 
     if (rhs.m_d->proofingConfig) {
         m_d->proofingConfig = toQShared(new KisProofingConfiguration(*rhs.m_d->proofingConfig));
     }
 
     KisNodeSP newRoot = rhs.root()->clone();
     newRoot->setGraphListener(this);
     newRoot->setImage(this);
     m_d->rootLayer = dynamic_cast<KisGroupLayer*>(newRoot.data());
     setRoot(newRoot);
 
     if (exactCopy || rhs.m_d->isolatedRootNode) {
         QQueue<KisNodeSP> linearizedNodes;
         KisLayerUtils::recursiveApplyNodes(rhs.root(),
             [&linearizedNodes](KisNodeSP node) {
                 linearizedNodes.enqueue(node);
             });
         KisLayerUtils::recursiveApplyNodes(newRoot,
             [&linearizedNodes, exactCopy, &rhs, this](KisNodeSP node) {
                 KisNodeSP refNode = linearizedNodes.dequeue();
 
                 if (exactCopy) {
                     node->setUuid(refNode->uuid());
                 }
 
                 if (rhs.m_d->isolatedRootNode &&
                     rhs.m_d->isolatedRootNode == refNode) {
 
                     m_d->isolatedRootNode = node;
                 }
             });
     }
 
     Q_FOREACH (KisLayerCompositionSP comp, rhs.m_d->compositions) {
         m_d->compositions << toQShared(new KisLayerComposition(*comp, this));
     }
 
     rhs.m_d->nserver = KisNameServer(rhs.m_d->nserver);
 
     vKisAnnotationSP newAnnotations;
     Q_FOREACH (KisAnnotationSP annotation, rhs.m_d->annotations) {
         newAnnotations << annotation->clone();
     }
     m_d->annotations = newAnnotations;
 
     KIS_ASSERT_RECOVER_NOOP(!rhs.m_d->projectionUpdatesFilter);
     KIS_ASSERT_RECOVER_NOOP(!rhs.m_d->disableUIUpdateSignals);
     KIS_ASSERT_RECOVER_NOOP(!rhs.m_d->disableDirtyRequests);
 
     m_d->blockLevelOfDetail = rhs.m_d->blockLevelOfDetail;
 }
 
 void KisImage::aboutToAddANode(KisNode *parent, int index)
 {
     KisNodeGraphListener::aboutToAddANode(parent, index);
     SANITY_CHECK_LOCKED("aboutToAddANode");
 }
 
 void KisImage::nodeHasBeenAdded(KisNode *parent, int index)
 {
     KisNodeGraphListener::nodeHasBeenAdded(parent, index);
 
     SANITY_CHECK_LOCKED("nodeHasBeenAdded");
     m_d->signalRouter.emitNodeHasBeenAdded(parent, index);
 
     KisNodeSP newNode = parent->at(index);
     if (!dynamic_cast<KisSelectionMask*>(newNode.data())) {
         emit sigInternalStopIsolatedModeRequested();
     }
 }
 
 void KisImage::aboutToRemoveANode(KisNode *parent, int index)
 {
     KisNodeSP deletedNode = parent->at(index);
     if (!dynamic_cast<KisSelectionMask*>(deletedNode.data())) {
         emit sigInternalStopIsolatedModeRequested();
     }
 
     KisNodeGraphListener::aboutToRemoveANode(parent, index);
 
     SANITY_CHECK_LOCKED("aboutToRemoveANode");
     m_d->signalRouter.emitAboutToRemoveANode(parent, index);
 }
 
 void KisImage::nodeChanged(KisNode* node)
 {
     KisNodeGraphListener::nodeChanged(node);
     requestStrokeEnd();
     m_d->signalRouter.emitNodeChanged(node);
 }
 
 void KisImage::invalidateAllFrames()
 {
     invalidateFrames(KisTimeRange::infinite(0), QRect());
 }
 
 KisSelectionSP KisImage::globalSelection() const
 {
     KisSelectionMaskSP selectionMask = m_d->rootLayer->selectionMask();
     if (selectionMask) {
         return selectionMask->selection();
     } else {
         return 0;
     }
 }
 
 void KisImage::setGlobalSelection(KisSelectionSP globalSelection)
 {
     KisSelectionMaskSP selectionMask = m_d->rootLayer->selectionMask();
 
     if (!globalSelection) {
         if (selectionMask) {
             removeNode(selectionMask);
         }
     }
     else {
         if (!selectionMask) {
             selectionMask = new KisSelectionMask(this);
             selectionMask->initSelection(m_d->rootLayer);
             addNode(selectionMask);
             // If we do not set the selection now, the setActive call coming next
             // can be very, very expensive, depending on the size of the image.
             selectionMask->setSelection(globalSelection);
             selectionMask->setActive(true);
         }
         else {
             selectionMask->setSelection(globalSelection);
         }
 
         Q_ASSERT(m_d->rootLayer->childCount() > 0);
         Q_ASSERT(m_d->rootLayer->selectionMask());
     }
 
     m_d->deselectedGlobalSelection = 0;
     m_d->legacyUndoAdapter.emitSelectionChanged();
 }
 
 void KisImage::deselectGlobalSelection()
 {
     KisSelectionSP savedSelection = globalSelection();
     setGlobalSelection(0);
     m_d->deselectedGlobalSelection = savedSelection;
 }
 
 bool KisImage::canReselectGlobalSelection()
 {
     return m_d->deselectedGlobalSelection;
 }
 
 void KisImage::reselectGlobalSelection()
 {
     if(m_d->deselectedGlobalSelection) {
         setGlobalSelection(m_d->deselectedGlobalSelection);
     }
 }
 
 QString KisImage::nextLayerName(const QString &_baseName) const
 {
     QString baseName = _baseName;
 
     if (m_d->nserver.currentSeed() == 0) {
         m_d->nserver.number();
         return i18n("background");
     }
 
     if (baseName.isEmpty()) {
         baseName = i18n("Layer");
     }
 
     return QString("%1 %2").arg(baseName).arg(m_d->nserver.number());
 }
 
 void KisImage::rollBackLayerName()
 {
     m_d->nserver.rollback();
 }
 
 KisCompositeProgressProxy* KisImage::compositeProgressProxy()
 {
     return &m_d->compositeProgressProxy;
 }
 
 bool KisImage::locked() const
 {
     return m_d->lockCount != 0;
 }
 
 void KisImage::barrierLock(bool readOnly)
 {
     if (!locked()) {
         requestStrokeEnd();
         m_d->scheduler.barrierLock();
         m_d->lockedForReadOnly = readOnly;
     } else {
         m_d->lockedForReadOnly &= readOnly;
     }
 
     m_d->lockCount++;
 }
 
 bool KisImage::tryBarrierLock(bool readOnly)
 {
     bool result = true;
 
     if (!locked()) {
         result = m_d->scheduler.tryBarrierLock();
         m_d->lockedForReadOnly = readOnly;
     }
 
     if (result) {
         m_d->lockCount++;
         m_d->lockedForReadOnly &= readOnly;
     }
 
     return result;
 }
 
 bool KisImage::isIdle(bool allowLocked)
 {
     return (allowLocked || !locked()) && m_d->scheduler.isIdle();
 }
 
 void KisImage::lock()
 {
     if (!locked()) {
         requestStrokeEnd();
         m_d->scheduler.lock();
     }
     m_d->lockCount++;
     m_d->lockedForReadOnly = false;
 }
 
 void KisImage::unlock()
 {
     Q_ASSERT(locked());
 
     if (locked()) {
         m_d->lockCount--;
 
         if (m_d->lockCount == 0) {
             m_d->scheduler.unlock(!m_d->lockedForReadOnly);
         }
     }
 }
 
 void KisImage::blockUpdates()
 {
     m_d->scheduler.blockUpdates();
 }
 
 void KisImage::unblockUpdates()
 {
     m_d->scheduler.unblockUpdates();
 }
 
 void KisImage::setSize(const QSize& size)
 {
     m_d->width = size.width();
     m_d->height = size.height();
 }
 
 void KisImage::resizeImageImpl(const QRect& newRect, bool cropLayers)
 {
     if (newRect == bounds() && !cropLayers) return;
 
     KUndo2MagicString actionName = cropLayers ?
         kundo2_i18n("Crop Image") :
         kundo2_i18n("Resize Image");
 
     KisImageSignalVector emitSignals;
     emitSignals << ComplexSizeChangedSignal(newRect, newRect.size());
     emitSignals << ModifiedSignal;
 
     KisCropSavedExtraData *extraData =
         new KisCropSavedExtraData(cropLayers ?
                                   KisCropSavedExtraData::CROP_IMAGE :
                                   KisCropSavedExtraData::RESIZE_IMAGE,
                                   newRect);
 
     KisProcessingApplicator applicator(this, m_d->rootLayer,
                                        KisProcessingApplicator::RECURSIVE |
                                        KisProcessingApplicator::NO_UI_UPDATES,
                                        emitSignals, actionName, extraData);
 
     if (cropLayers || !newRect.topLeft().isNull()) {
         KisProcessingVisitorSP visitor =
             new KisCropProcessingVisitor(newRect, cropLayers, true);
         applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
     }
     applicator.applyCommand(new KisImageResizeCommand(this, newRect.size()));
     applicator.end();
 }
 
 void KisImage::resizeImage(const QRect& newRect)
 {
     resizeImageImpl(newRect, false);
 }
 
 void KisImage::cropImage(const QRect& newRect)
 {
     resizeImageImpl(newRect, true);
 }
 
 
 void KisImage::cropNode(KisNodeSP node, const QRect& newRect)
 {
     bool isLayer = qobject_cast<KisLayer*>(node.data());
     KUndo2MagicString actionName = isLayer ?
         kundo2_i18n("Crop Layer") :
         kundo2_i18n("Crop Mask");
 
     KisImageSignalVector emitSignals;
     emitSignals << ModifiedSignal;
 
     KisCropSavedExtraData *extraData =
         new KisCropSavedExtraData(KisCropSavedExtraData::CROP_LAYER,
                                   newRect, node);
 
     KisProcessingApplicator applicator(this, node,
                                        KisProcessingApplicator::RECURSIVE,
                                        emitSignals, actionName, extraData);
 
     KisProcessingVisitorSP visitor =
         new KisCropProcessingVisitor(newRect, true, false);
     applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
     applicator.end();
 }
 
 void KisImage::scaleImage(const QSize &size, qreal xres, qreal yres, KisFilterStrategy *filterStrategy)
 {
     bool resolutionChanged = xres != xRes() && yres != yRes();
     bool sizeChanged = size != this->size();
 
     if (!resolutionChanged && !sizeChanged) return;
 
     KisImageSignalVector emitSignals;
     if (resolutionChanged) emitSignals << ResolutionChangedSignal;
     if (sizeChanged) emitSignals << ComplexSizeChangedSignal(bounds(), size);
     emitSignals << ModifiedSignal;
 
     KUndo2MagicString actionName = sizeChanged ?
         kundo2_i18n("Scale Image") :
         kundo2_i18n("Change Image Resolution");
 
     KisProcessingApplicator::ProcessingFlags signalFlags =
         (resolutionChanged || sizeChanged) ?
                 KisProcessingApplicator::NO_UI_UPDATES :
                 KisProcessingApplicator::NONE;
 
     KisProcessingApplicator applicator(this, m_d->rootLayer,
                                        KisProcessingApplicator::RECURSIVE | signalFlags,
                                        emitSignals, actionName);
 
     qreal sx = qreal(size.width()) / this->size().width();
     qreal sy = qreal(size.height()) / this->size().height();
 
     QTransform shapesCorrection;
 
     if (resolutionChanged) {
         shapesCorrection = QTransform::fromScale(xRes() / xres, yRes() / yres);
     }
 
     KisProcessingVisitorSP visitor =
         new KisTransformProcessingVisitor(sx, sy,
                                           0, 0,
                                           QPointF(),
                                           0,
                                           0, 0,
                                           filterStrategy,
                                           shapesCorrection);
 
     applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
 
     if (resolutionChanged) {
         KUndo2Command *parent =
             new KisResetShapesCommand(m_d->rootLayer);
         new KisImageSetResolutionCommand(this, xres, yres, parent);
         applicator.applyCommand(parent);
     }
 
     if (sizeChanged) {
         applicator.applyCommand(new KisImageResizeCommand(this, size));
     }
 
     applicator.end();
 }
 
 void KisImage::scaleNode(KisNodeSP node, qreal scaleX, qreal scaleY, KisFilterStrategy *filterStrategy)
 {
     KUndo2MagicString actionName(kundo2_i18n("Scale Layer"));
     KisImageSignalVector emitSignals;
     emitSignals << ModifiedSignal;
 
     KisProcessingApplicator applicator(this, node,
                                        KisProcessingApplicator::RECURSIVE,
                                        emitSignals, actionName);
 
     KisProcessingVisitorSP visitor =
         new KisTransformProcessingVisitor(scaleX, scaleY,
                                           0, 0,
                                           QPointF(),
                                           0,
                                           0, 0,
                                           filterStrategy);
 
     applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
     applicator.end();
 }
 
 void KisImage::rotateImpl(const KUndo2MagicString &actionName,
                           KisNodeSP rootNode,
                           bool resizeImage,
                           double radians)
 {
     QPointF offset;
     QSize newSize;
 
     {
         KisTransformWorker worker(0,
                                   1.0, 1.0,
                                   0, 0, 0, 0,
                                   radians,
                                   0, 0, 0, 0);
         QTransform transform = worker.transform();
 
         if (resizeImage) {
             QRect newRect = transform.mapRect(bounds());
             newSize = newRect.size();
             offset = -newRect.topLeft();
         }
         else {
             QPointF origin = QRectF(rootNode->exactBounds()).center();
 
             newSize = size();
             offset = -(transform.map(origin) - origin);
         }
     }
 
     bool sizeChanged = resizeImage &&
         (newSize.width() != width() || newSize.height() != height());
 
     // These signals will be emitted after processing is done
     KisImageSignalVector emitSignals;
     if (sizeChanged) emitSignals << ComplexSizeChangedSignal(bounds(), newSize);
     emitSignals << ModifiedSignal;
 
     // These flags determine whether updates are transferred to the UI during processing
     KisProcessingApplicator::ProcessingFlags signalFlags =
         sizeChanged ?
         KisProcessingApplicator::NO_UI_UPDATES :
         KisProcessingApplicator::NONE;
 
 
     KisProcessingApplicator applicator(this, rootNode,
                                        KisProcessingApplicator::RECURSIVE | signalFlags,
                                        emitSignals, actionName);
 
     KisFilterStrategy *filter = KisFilterStrategyRegistry::instance()->value("Bicubic");
 
     KisProcessingVisitorSP visitor =
             new KisTransformProcessingVisitor(1.0, 1.0, 0.0, 0.0,
                                               QPointF(),
                                               radians,
                                               offset.x(), offset.y(),
                                               filter);
 
     applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
 
     if (sizeChanged) {
         applicator.applyCommand(new KisImageResizeCommand(this, newSize));
     }
     applicator.end();
 }
 
 
 void KisImage::rotateImage(double radians)
 {
     rotateImpl(kundo2_i18n("Rotate Image"), root(), true, radians);
 }
 
 void KisImage::rotateNode(KisNodeSP node, double radians)
 {
     if (node->inherits("KisMask")) {
         rotateImpl(kundo2_i18n("Rotate Mask"), node, false, radians);
     } else {
         rotateImpl(kundo2_i18n("Rotate Layer"), node, false, radians);
     }
 }
 
 void KisImage::shearImpl(const KUndo2MagicString &actionName,
                          KisNodeSP rootNode,
                          bool resizeImage,
                          double angleX, double angleY,
                          const QPointF &origin)
 {
     //angleX, angleY are in degrees
     const qreal pi = 3.1415926535897932385;
     const qreal deg2rad = pi / 180.0;
 
     qreal tanX = tan(angleX * deg2rad);
     qreal tanY = tan(angleY * deg2rad);
 
     QPointF offset;
     QSize newSize;
 
     {
         KisTransformWorker worker(0,
                                   1.0, 1.0,
                                   tanX, tanY, origin.x(), origin.y(),
                                   0,
                                   0, 0, 0, 0);
 
         QRect newRect = worker.transform().mapRect(bounds());
         newSize = newRect.size();
         if (resizeImage) offset = -newRect.topLeft();
     }
 
     if (newSize == size()) return;
 
     KisImageSignalVector emitSignals;
     if (resizeImage) emitSignals << ComplexSizeChangedSignal(bounds(), newSize);
     emitSignals << ModifiedSignal;
 
     KisProcessingApplicator::ProcessingFlags signalFlags =
         KisProcessingApplicator::RECURSIVE;
     if (resizeImage) signalFlags |= KisProcessingApplicator::NO_UI_UPDATES;
 
     KisProcessingApplicator applicator(this, rootNode,
                                        signalFlags,
                                        emitSignals, actionName);
 
     KisFilterStrategy *filter = KisFilterStrategyRegistry::instance()->value("Bilinear");
 
     KisProcessingVisitorSP visitor =
             new KisTransformProcessingVisitor(1.0, 1.0,
                                               tanX, tanY, origin,
                                               0,
                                               offset.x(), offset.y(),
                                               filter);
 
     applicator.applyVisitorAllFrames(visitor, KisStrokeJobData::CONCURRENT);
 
     if (resizeImage) {
         applicator.applyCommand(new KisImageResizeCommand(this, newSize));
     }
 
     applicator.end();
 }
 
 void KisImage::shearNode(KisNodeSP node, double angleX, double angleY)
 {
     QPointF shearOrigin = QRectF(bounds()).center();
 
     if (node->inherits("KisMask")) {
         shearImpl(kundo2_i18n("Shear Mask"), node, false,
                   angleX, angleY, shearOrigin);
     } else {
         shearImpl(kundo2_i18n("Shear Layer"), node, false,
                   angleX, angleY, shearOrigin);
     }
 }
 
 void KisImage::shear(double angleX, double angleY)
 {
     shearImpl(kundo2_i18n("Shear Image"), m_d->rootLayer, true,
               angleX, angleY, QPointF());
 }
 
 void KisImage::convertImageColorSpace(const KoColorSpace *dstColorSpace,
                                       KoColorConversionTransformation::Intent renderingIntent,
                                       KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     if (!dstColorSpace) return;
 
     const KoColorSpace *srcColorSpace = m_d->colorSpace;
 
     undoAdapter()->beginMacro(kundo2_i18n("Convert Image Color Space"));
     undoAdapter()->addCommand(new KisImageLockCommand(KisImageWSP(this), true));
     undoAdapter()->addCommand(new KisImageSetProjectionColorSpaceCommand(KisImageWSP(this), dstColorSpace));
 
     KisColorSpaceConvertVisitor visitor(this, srcColorSpace, dstColorSpace, renderingIntent, conversionFlags);
     m_d->rootLayer->accept(visitor);
 
     undoAdapter()->addCommand(new KisImageLockCommand(KisImageWSP(this), false));
     undoAdapter()->endMacro();
 
     setModified();
 }
 
 bool KisImage::assignImageProfile(const KoColorProfile *profile)
 {
     if (!profile) return false;
 
     const KoColorSpace *dstCs = KoColorSpaceRegistry::instance()->colorSpace(colorSpace()->colorModelId().id(), colorSpace()->colorDepthId().id(), profile);
     const KoColorSpace *srcCs = colorSpace();
 
     if (!dstCs) return false;
 
     m_d->colorSpace = dstCs;
 
     KisChangeProfileVisitor visitor(srcCs, dstCs);
     bool retval = m_d->rootLayer->accept(visitor);
     m_d->signalRouter.emitNotification(ProfileChangedSignal);
     return retval;
 
 }
 
 void KisImage::convertProjectionColorSpace(const KoColorSpace *dstColorSpace)
 {
     if (*m_d->colorSpace == *dstColorSpace) return;
 
     undoAdapter()->beginMacro(kundo2_i18n("Convert Projection Color Space"));
     undoAdapter()->addCommand(new KisImageLockCommand(KisImageWSP(this), true));
     undoAdapter()->addCommand(new KisImageSetProjectionColorSpaceCommand(KisImageWSP(this), dstColorSpace));
     undoAdapter()->addCommand(new KisImageLockCommand(KisImageWSP(this), false));
     undoAdapter()->endMacro();
 
     setModified();
 }
 
 void KisImage::setProjectionColorSpace(const KoColorSpace * colorSpace)
 {
     m_d->colorSpace = colorSpace;
     m_d->rootLayer->resetCache();
     m_d->signalRouter.emitNotification(ColorSpaceChangedSignal);
 }
 
 const KoColorSpace * KisImage::colorSpace() const
 {
     return m_d->colorSpace;
 }
 
 const KoColorProfile * KisImage::profile() const
 {
     return colorSpace()->profile();
 }
 
 double KisImage::xRes() const
 {
     return m_d->xres;
 }
 
 double KisImage::yRes() const
 {
     return m_d->yres;
 }
 
 void KisImage::setResolution(double xres, double yres)
 {
     m_d->xres = xres;
     m_d->yres = yres;
     m_d->signalRouter.emitNotification(ResolutionChangedSignal);
 }
 
 QPointF KisImage::documentToPixel(const QPointF &documentCoord) const
 {
     return QPointF(documentCoord.x() * xRes(), documentCoord.y() * yRes());
 }
 
 QPoint KisImage::documentToImagePixelFloored(const QPointF &documentCoord) const
 {
     QPointF pixelCoord = documentToPixel(documentCoord);
     return QPoint(qFloor(pixelCoord.x()), qFloor(pixelCoord.y()));
 }
 
 QRectF KisImage::documentToPixel(const QRectF &documentRect) const
 {
     return QRectF(documentToPixel(documentRect.topLeft()), documentToPixel(documentRect.bottomRight()));
 }
 
 QPointF KisImage::pixelToDocument(const QPointF &pixelCoord) const
 {
     return QPointF(pixelCoord.x() / xRes(), pixelCoord.y() / yRes());
 }
 
 QPointF KisImage::pixelToDocument(const QPoint &pixelCoord) const
 {
     return QPointF((pixelCoord.x() + 0.5) / xRes(), (pixelCoord.y() + 0.5) / yRes());
 }
 
 QRectF KisImage::pixelToDocument(const QRectF &pixelCoord) const
 {
     return QRectF(pixelToDocument(pixelCoord.topLeft()), pixelToDocument(pixelCoord.bottomRight()));
 }
 
 qint32 KisImage::width() const
 {
     return m_d->width;
 }
 
 qint32 KisImage::height() const
 {
     return m_d->height;
 }
 
 KisGroupLayerSP KisImage::rootLayer() const
 {
     Q_ASSERT(m_d->rootLayer);
     return m_d->rootLayer;
 }
 
 KisPaintDeviceSP KisImage::projection() const
 {
     if (m_d->isolatedRootNode) {
         return m_d->isolatedRootNode->projection();
     }
 
 
     Q_ASSERT(m_d->rootLayer);
     KisPaintDeviceSP projection = m_d->rootLayer->projection();
     Q_ASSERT(projection);
     return projection;
 }
 
 qint32 KisImage::nlayers() const
 {
     QStringList list;
     list << "KisLayer";
 
     KisCountVisitor visitor(list, KoProperties());
     m_d->rootLayer->accept(visitor);
     return visitor.count();
 }
 
 qint32 KisImage::nHiddenLayers() const
 {
     QStringList list;
     list << "KisLayer";
     KoProperties properties;
     properties.setProperty("visible", false);
     KisCountVisitor visitor(list, properties);
     m_d->rootLayer->accept(visitor);
 
     return visitor.count();
 }
 
 void KisImage::flatten(KisNodeSP activeNode)
 {
     KisLayerUtils::flattenImage(this, activeNode);
 }
 
 void KisImage::mergeMultipleLayers(QList<KisNodeSP> mergedNodes, KisNodeSP putAfter)
 {
     if (!KisLayerUtils::tryMergeSelectionMasks(this, mergedNodes, putAfter)) {
         KisLayerUtils::mergeMultipleLayers(this, mergedNodes, putAfter);
     }
 }
 
 void KisImage::mergeDown(KisLayerSP layer, const KisMetaData::MergeStrategy* strategy)
 {
     KisLayerUtils::mergeDown(this, layer, strategy);
 }
 
 void KisImage::flattenLayer(KisLayerSP layer)
 {
     KisLayerUtils::flattenLayer(this, layer);
 }
 
 
 void KisImage::setModified()
 {
     m_d->signalRouter.emitNotification(ModifiedSignal);
 }
 
 QImage KisImage::convertToQImage(QRect imageRect,
                                  const KoColorProfile * profile)
 {
     qint32 x;
     qint32 y;
     qint32 w;
     qint32 h;
     imageRect.getRect(&x, &y, &w, &h);
     return convertToQImage(x, y, w, h, profile);
 }
 
 QImage KisImage::convertToQImage(qint32 x,
                                  qint32 y,
                                  qint32 w,
                                  qint32 h,
                                  const KoColorProfile * profile)
 {
     KisPaintDeviceSP dev = projection();
     if (!dev) return QImage();
     QImage image = dev->convertToQImage(const_cast<KoColorProfile*>(profile), x, y, w, h,
                                         KoColorConversionTransformation::internalRenderingIntent(),
                                         KoColorConversionTransformation::internalConversionFlags());
 
     return image;
 }
 
 
 
 QImage KisImage::convertToQImage(const QSize& scaledImageSize, const KoColorProfile *profile)
 {
     if (scaledImageSize.isEmpty()) {
         return QImage();
     }
 
     KisPaintDeviceSP dev = new KisPaintDevice(colorSpace());
     KisPainter gc;
     gc.copyAreaOptimized(QPoint(0, 0), projection(), dev, bounds());
     gc.end();
     double scaleX = qreal(scaledImageSize.width()) / width();
     double scaleY = qreal(scaledImageSize.height()) / height();
 
     QPointer<KoUpdater> updater = new KoDummyUpdater();
 
     KisTransformWorker worker(dev, scaleX, scaleY, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, updater, KisFilterStrategyRegistry::instance()->value("Bicubic"));
     worker.run();
 
     delete updater;
 
     return dev->convertToQImage(profile);
 }
 void KisImage::notifyLayersChanged()
 {
     m_d->signalRouter.emitNotification(LayersChangedSignal);
 }
 
 QRect KisImage::bounds() const
 {
     return QRect(0, 0, width(), height());
 }
 
 QRect KisImage::effectiveLodBounds() const
 {
     QRect boundRect = bounds();
 
     const int lod = currentLevelOfDetail();
     if (lod > 0) {
         KisLodTransform t(lod);
         boundRect = t.map(boundRect);
     }
 
     return boundRect;
 }
 
 KisPostExecutionUndoAdapter* KisImage::postExecutionUndoAdapter() const
 {
     const int lod = currentLevelOfDetail();
     return lod > 0 ?
         m_d->scheduler.lodNPostExecutionUndoAdapter() :
         &m_d->postExecutionUndoAdapter;
 }
 
 void KisImage::setUndoStore(KisUndoStore *undoStore)
 {
 
     m_d->legacyUndoAdapter.setUndoStore(undoStore);
     m_d->postExecutionUndoAdapter.setUndoStore(undoStore);
     m_d->undoStore.reset(undoStore);
 }
 
 KisUndoStore* KisImage::undoStore()
 {
     return m_d->undoStore.data();
 }
 
 KisUndoAdapter* KisImage::undoAdapter() const
 {
     return &m_d->legacyUndoAdapter;
 }
 
 void KisImage::setDefaultProjectionColor(const KoColor &color)
 {
     KIS_ASSERT_RECOVER_RETURN(m_d->rootLayer);
     m_d->rootLayer->setDefaultProjectionColor(color);
 }
 
 KoColor KisImage::defaultProjectionColor() const
 {
     KIS_ASSERT_RECOVER(m_d->rootLayer) {
         return KoColor(Qt::transparent, m_d->colorSpace);
     }
 
     return m_d->rootLayer->defaultProjectionColor();
 }
 
 void KisImage::setRootLayer(KisGroupLayerSP rootLayer)
 {
     emit sigInternalStopIsolatedModeRequested();
 
     KoColor defaultProjectionColor(Qt::transparent, m_d->colorSpace);
 
     if (m_d->rootLayer) {
         m_d->rootLayer->setGraphListener(0);
         m_d->rootLayer->disconnect();
 
         KisPaintDeviceSP original = m_d->rootLayer->original();
         defaultProjectionColor = original->defaultPixel();
     }
 
     m_d->rootLayer = rootLayer;
     m_d->rootLayer->disconnect();
     m_d->rootLayer->setGraphListener(this);
     m_d->rootLayer->setImage(this);
 
     KisPaintDeviceSP newOriginal = m_d->rootLayer->original();
     newOriginal->setDefaultPixel(defaultProjectionColor);
 
     setRoot(m_d->rootLayer.data());
 }
 
 void KisImage::addAnnotation(KisAnnotationSP annotation)
 {
     // Find the icc annotation, if there is one
     vKisAnnotationSP_it it = m_d->annotations.begin();
     while (it != m_d->annotations.end()) {
         if ((*it)->type() == annotation->type()) {
             *it = annotation;
             return;
         }
         ++it;
     }
     m_d->annotations.push_back(annotation);
 }
 
 KisAnnotationSP KisImage::annotation(const QString& type)
 {
     vKisAnnotationSP_it it = m_d->annotations.begin();
     while (it != m_d->annotations.end()) {
         if ((*it)->type() == type) {
             return *it;
         }
         ++it;
     }
     return KisAnnotationSP(0);
 }
 
 void KisImage::removeAnnotation(const QString& type)
 {
     vKisAnnotationSP_it it = m_d->annotations.begin();
     while (it != m_d->annotations.end()) {
         if ((*it)->type() == type) {
             m_d->annotations.erase(it);
             return;
         }
         ++it;
     }
 }
 
 vKisAnnotationSP_it KisImage::beginAnnotations()
 {
     return m_d->annotations.begin();
 }
 
 vKisAnnotationSP_it KisImage::endAnnotations()
 {
     return m_d->annotations.end();
 }
 
 void KisImage::notifyAboutToBeDeleted()
 {
     emit sigAboutToBeDeleted();
 }
 
 KisImageSignalRouter* KisImage::signalRouter()
 {
     return &m_d->signalRouter;
 }
 
 void KisImage::waitForDone()
 {
     requestStrokeEnd();
     m_d->scheduler.waitForDone();
 }
 
 KisStrokeId KisImage::startStroke(KisStrokeStrategy *strokeStrategy)
 {
     /**
      * Ask open strokes to end gracefully. All the strokes clients
      * (including the one calling this method right now) will get
      * a notification that they should probably end their strokes.
      * However this is purely their choice whether to end a stroke
      * or not.
      */
     if (strokeStrategy->requestsOtherStrokesToEnd()) {
         requestStrokeEnd();
     }
 
     /**
      * Some of the strokes can cancel their work with undoing all the
      * changes they did to the paint devices. The problem is that undo
      * stack will know nothing about it. Therefore, just notify it
      * explicitly
      */
     if (strokeStrategy->clearsRedoOnStart()) {
         m_d->undoStore->purgeRedoState();
     }
 
     return m_d->scheduler.startStroke(strokeStrategy);
 }
 
 void KisImage::KisImagePrivate::notifyProjectionUpdatedInPatches(const QRect &rc)
 {
     KisImageConfig imageConfig;
     int patchWidth = imageConfig.updatePatchWidth();
     int patchHeight = imageConfig.updatePatchHeight();
 
     for (int y = 0; y < rc.height(); y += patchHeight) {
         for (int x = 0; x < rc.width(); x += patchWidth) {
             QRect patchRect(x, y, patchWidth, patchHeight);
             patchRect &= rc;
 
             QtConcurrent::run(std::bind(&KisImage::notifyProjectionUpdated, q, patchRect));
         }
     }
 }
 
 bool KisImage::startIsolatedMode(KisNodeSP node)
 {
     struct StartIsolatedModeStroke : public KisSimpleStrokeStrategy {
         StartIsolatedModeStroke(KisNodeSP node, KisImageSP image)
             : KisSimpleStrokeStrategy("start-isolated-mode", kundo2_noi18n("start-isolated-mode")),
               m_node(node),
               m_image(image)
         {
             this->enableJob(JOB_INIT, true, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
             setClearsRedoOnStart(false);
         }
 
         void initStrokeCallback() {
             // pass-though node don't have any projection prepared, so we should
             // explicitly regenerate it before activating isolated mode.
             m_node->projectionLeaf()->explicitlyRegeneratePassThroughProjection();
 
             m_image->m_d->isolatedRootNode = m_node;
             emit m_image->sigIsolatedModeChanged();
 
             // the GUI uses our thread to do the color space conversion so we
             // need to emit this signal in multiple threads
             m_image->m_d->notifyProjectionUpdatedInPatches(m_image->bounds());
 
             m_image->invalidateAllFrames();
         }
 
     private:
         KisNodeSP m_node;
         KisImageSP m_image;
     };
 
     KisStrokeId id = startStroke(new StartIsolatedModeStroke(node, this));
     endStroke(id);
 
     return true;
 }
 
 void KisImage::stopIsolatedMode()
 {
     if (!m_d->isolatedRootNode)  return;
 
     struct StopIsolatedModeStroke : public KisSimpleStrokeStrategy {
         StopIsolatedModeStroke(KisImageSP image)
             : KisSimpleStrokeStrategy("stop-isolated-mode", kundo2_noi18n("stop-isolated-mode")),
               m_image(image)
         {
             this->enableJob(JOB_INIT);
             setClearsRedoOnStart(false);
         }
 
         void initStrokeCallback() {
             if (!m_image->m_d->isolatedRootNode)  return;
 
             //KisNodeSP oldRootNode = m_image->m_d->isolatedRootNode;
             m_image->m_d->isolatedRootNode = 0;
 
             emit m_image->sigIsolatedModeChanged();
 
             // the GUI uses our thread to do the color space conversion so we
             // need to emit this signal in multiple threads
             m_image->m_d->notifyProjectionUpdatedInPatches(m_image->bounds());
             m_image->invalidateAllFrames();
 
             // TODO: Substitute notifyProjectionUpdated() with this code
             // when update optimization is implemented
             //
             // QRect updateRect = bounds() | oldRootNode->extent();
             // oldRootNode->setDirty(updateRect);
         }
 
     private:
         KisImageSP m_image;
     };
 
     KisStrokeId id = startStroke(new StopIsolatedModeStroke(this));
     endStroke(id);
 }
 
 KisNodeSP KisImage::isolatedModeRoot() const
 {
     return m_d->isolatedRootNode;
 }
 
 void KisImage::addJob(KisStrokeId id, KisStrokeJobData *data)
 {
     KisUpdateTimeMonitor::instance()->reportJobStarted(data);
     m_d->scheduler.addJob(id, data);
 }
 
 void KisImage::endStroke(KisStrokeId id)
 {
     m_d->scheduler.endStroke(id);
 }
 
 bool KisImage::cancelStroke(KisStrokeId id)
 {
     return m_d->scheduler.cancelStroke(id);
 }
 
 bool KisImage::KisImagePrivate::tryCancelCurrentStrokeAsync()
 {
     return scheduler.tryCancelCurrentStrokeAsync();
 }
 
 void KisImage::requestUndoDuringStroke()
 {
     emit sigUndoDuringStrokeRequested();
 }
 
 void KisImage::requestStrokeCancellation()
 {
     if (!m_d->tryCancelCurrentStrokeAsync()) {
         emit sigStrokeCancellationRequested();
     }
 }
 
 UndoResult KisImage::tryUndoUnfinishedLod0Stroke()
 {
     return m_d->scheduler.tryUndoLastStrokeAsync();
 }
 
 void KisImage::requestStrokeEnd()
 {
     emit sigStrokeEndRequested();
     emit sigStrokeEndRequestedActiveNodeFiltered();
 }
 
 void KisImage::requestStrokeEndActiveNode()
 {
     emit sigStrokeEndRequested();
 }
 
 void KisImage::refreshGraph(KisNodeSP root)
 {
     refreshGraph(root, bounds(), bounds());
 }
 
 void KisImage::refreshGraph(KisNodeSP root, const QRect &rc, const QRect &cropRect)
 {
     if (!root) root = m_d->rootLayer;
 
     m_d->animationInterface->notifyNodeChanged(root.data(), rc, true);
     m_d->scheduler.fullRefresh(root, rc, cropRect);
 }
 
 void KisImage::initialRefreshGraph()
 {
     /**
      * NOTE: Tricky part. We set crop rect to null, so the clones
      * will not rely on precalculated projections of their sources
      */
 
     refreshGraphAsync(0, bounds(), QRect());
     waitForDone();
 }
 
 void KisImage::refreshGraphAsync(KisNodeSP root)
 {
     refreshGraphAsync(root, bounds(), bounds());
 }
 
 void KisImage::refreshGraphAsync(KisNodeSP root, const QRect &rc)
 {
     refreshGraphAsync(root, rc, bounds());
 }
 
 void KisImage::refreshGraphAsync(KisNodeSP root, const QRect &rc, const QRect &cropRect)
 {
     if (!root) root = m_d->rootLayer;
 
     m_d->animationInterface->notifyNodeChanged(root.data(), rc, true);
     m_d->scheduler.fullRefreshAsync(root, rc, cropRect);
 }
 
 void KisImage::requestProjectionUpdateNoFilthy(KisNodeSP pseudoFilthy, const QRect &rc, const QRect &cropRect)
 {
     KIS_ASSERT_RECOVER_RETURN(pseudoFilthy);
 
     m_d->animationInterface->notifyNodeChanged(pseudoFilthy.data(), rc, false);
     m_d->scheduler.updateProjectionNoFilthy(pseudoFilthy, rc, cropRect);
 }
 
 void KisImage::addSpontaneousJob(KisSpontaneousJob *spontaneousJob)
 {
     m_d->scheduler.addSpontaneousJob(spontaneousJob);
 }
 
 void KisImage::setProjectionUpdatesFilter(KisProjectionUpdatesFilterSP filter)
 {
     // update filters are *not* recursive!
     KIS_ASSERT_RECOVER_NOOP(!filter || !m_d->projectionUpdatesFilter);
 
     m_d->projectionUpdatesFilter = filter;
 }
 
 KisProjectionUpdatesFilterSP KisImage::projectionUpdatesFilter() const
 {
     return m_d->projectionUpdatesFilter;
 }
 
 void KisImage::disableDirtyRequests()
 {
     setProjectionUpdatesFilter(KisProjectionUpdatesFilterSP(new KisDropAllProjectionUpdatesFilter()));
 }
 
 void KisImage::enableDirtyRequests()
 {
     setProjectionUpdatesFilter(KisProjectionUpdatesFilterSP());
 }
 
 void KisImage::disableUIUpdates()
 {
     m_d->disableUIUpdateSignals.ref();
 }
 
-void KisImage::enableUIUpdates()
+QVector<QRect> KisImage::enableUIUpdates()
 {
     m_d->disableUIUpdateSignals.deref();
+
+    QRect rect;
+    QVector<QRect> postponedUpdates;
+
+    while (m_d->savedDisabledUIUpdates.pop(rect)) {
+        postponedUpdates.append(rect);
+    }
+
+    return postponedUpdates;
 }
 
 void KisImage::notifyProjectionUpdated(const QRect &rc)
 {
     KisUpdateTimeMonitor::instance()->reportUpdateFinished(rc);
 
     if (!m_d->disableUIUpdateSignals) {
         int lod = currentLevelOfDetail();
         QRect dirtyRect = !lod ? rc : KisLodTransform::upscaledRect(rc, lod);
 
         if (dirtyRect.isEmpty()) return;
 
         emit sigImageUpdated(dirtyRect);
+    } else {
+        m_d->savedDisabledUIUpdates.push(rc);
     }
 }
 
 void KisImage::setWorkingThreadsLimit(int value)
 {
     m_d->scheduler.setThreadsLimit(value);
 }
 
 int KisImage::workingThreadsLimit() const
 {
     return m_d->scheduler.threadsLimit();
 }
 
 void KisImage::notifySelectionChanged()
 {
     /**
      * The selection is calculated asynchromously, so it is not
      * handled by disableUIUpdates() and other special signals of
      * KisImageSignalRouter
      */
     m_d->legacyUndoAdapter.emitSelectionChanged();
 
     /**
      * Editing of selection masks doesn't necessary produce a
      * setDirty() call, so in the end of the stroke we need to request
      * direct update of the UI's cache.
      */
     if (m_d->isolatedRootNode &&
         dynamic_cast<KisSelectionMask*>(m_d->isolatedRootNode.data())) {
 
         notifyProjectionUpdated(bounds());
     }
 }
 
 void KisImage::requestProjectionUpdateImpl(KisNode *node,
                                            const QVector<QRect> &rects,
                                            const QRect &cropRect)
 {
     if (rects.isEmpty()) return;
 
     m_d->scheduler.updateProjection(node, rects, cropRect);
 }
 
 void KisImage::requestProjectionUpdate(KisNode *node, const QVector<QRect> &rects, bool resetAnimationCache)
 {
     if (m_d->projectionUpdatesFilter
         && m_d->projectionUpdatesFilter->filter(this, node, rects, resetAnimationCache)) {
 
         return;
     }
 
     if (resetAnimationCache) {
         m_d->animationInterface->notifyNodeChanged(node, rects, false);
     }
 
     /**
      * Here we use 'permitted' instead of 'active' intentively,
      * because the updates may come after the actual stroke has been
      * finished. And having some more updates for the stroke not
      * supporting the wrap-around mode will not make much harm.
      */
     if (m_d->wrapAroundModePermitted) {
         QVector<QRect> allSplitRects;
 
         const QRect boundRect = effectiveLodBounds();
         Q_FOREACH (const QRect &rc, rects) {
             KisWrappedRect splitRect(rc, boundRect);
             allSplitRects.append(splitRect);
         }
 
         requestProjectionUpdateImpl(node, allSplitRects, boundRect);
 
     } else {
         requestProjectionUpdateImpl(node, rects, bounds());
     }
 
     KisNodeGraphListener::requestProjectionUpdate(node, rects, resetAnimationCache);
 }
 
 void KisImage::invalidateFrames(const KisTimeRange &range, const QRect &rect)
 {
     m_d->animationInterface->invalidateFrames(range, rect);
 }
 
 void KisImage::requestTimeSwitch(int time)
 {
     m_d->animationInterface->requestTimeSwitchNonGUI(time);
 }
 
 QList<KisLayerCompositionSP> KisImage::compositions()
 {
     return m_d->compositions;
 }
 
 void KisImage::addComposition(KisLayerCompositionSP composition)
 {
     m_d->compositions.append(composition);
 }
 
 void KisImage::removeComposition(KisLayerCompositionSP composition)
 {
     m_d->compositions.removeAll(composition);
 }
 
 bool checkMasksNeedConversion(KisNodeSP root, const QRect &bounds)
 {
     KisSelectionMask *mask = dynamic_cast<KisSelectionMask*>(root.data());
     if (mask &&
         (!bounds.contains(mask->paintDevice()->exactBounds()) ||
          mask->selection()->hasShapeSelection())) {
 
         return true;
     }
 
     KisNodeSP node = root->firstChild();
 
     while (node) {
         if (checkMasksNeedConversion(node, bounds)) {
             return true;
         }
 
         node = node->nextSibling();
     }
 
     return false;
 }
 
 void KisImage::setWrapAroundModePermitted(bool value)
 {
     if (m_d->wrapAroundModePermitted != value) {
         requestStrokeEnd();
     }
 
     m_d->wrapAroundModePermitted = value;
 
     if (m_d->wrapAroundModePermitted &&
         checkMasksNeedConversion(root(), bounds())) {
 
         KisProcessingApplicator applicator(this, root(),
                                            KisProcessingApplicator::RECURSIVE,
                                            KisImageSignalVector() << ModifiedSignal,
                                            kundo2_i18n("Crop Selections"));
 
         KisProcessingVisitorSP visitor =
             new KisCropSelectionsProcessingVisitor(bounds());
 
         applicator.applyVisitor(visitor, KisStrokeJobData::CONCURRENT);
         applicator.end();
     }
 }
 
 bool KisImage::wrapAroundModePermitted() const
 {
     return m_d->wrapAroundModePermitted;
 }
 
 bool KisImage::wrapAroundModeActive() const
 {
     return m_d->wrapAroundModePermitted &&
         m_d->scheduler.wrapAroundModeSupported();
 }
 
 void KisImage::setDesiredLevelOfDetail(int lod)
 {
     if (m_d->blockLevelOfDetail) {
         qWarning() << "WARNING: KisImage::setDesiredLevelOfDetail()"
                    << "was called while LoD functionality was being blocked!";
         return;
     }
 
     m_d->scheduler.setDesiredLevelOfDetail(lod);
 }
 
 int KisImage::currentLevelOfDetail() const
 {
     if (m_d->blockLevelOfDetail) {
         return 0;
     }
 
     return m_d->scheduler.currentLevelOfDetail();
 }
 
 void KisImage::setLevelOfDetailBlocked(bool value)
 {
     KisImageBarrierLockerRaw l(this);
 
     if (value && !m_d->blockLevelOfDetail) {
         m_d->scheduler.setDesiredLevelOfDetail(0);
     }
 
     m_d->blockLevelOfDetail = value;
 }
 
 void KisImage::explicitRegenerateLevelOfDetail()
 {
     if (!m_d->blockLevelOfDetail) {
         m_d->scheduler.explicitRegenerateLevelOfDetail();
     }
 }
 
 bool KisImage::levelOfDetailBlocked() const
 {
     return m_d->blockLevelOfDetail;
 }
 
 void KisImage::notifyNodeCollpasedChanged()
 {
     emit sigNodeCollapsedChanged();
 }
 
 KisImageAnimationInterface* KisImage::animationInterface() const
 {
     return m_d->animationInterface;
 }
 
 void KisImage::setProofingConfiguration(KisProofingConfigurationSP proofingConfig)
 {
     m_d->proofingConfig = proofingConfig;
     emit sigProofingConfigChanged();
 }
 
 KisProofingConfigurationSP KisImage::proofingConfiguration() const
 {
     if (m_d->proofingConfig) {
         return m_d->proofingConfig;
     }
     return KisProofingConfigurationSP();
 }
 
 QPointF KisImage::mirrorAxesCenter() const
 {
     return m_d->axesCenter;
 }
 
 void KisImage::setMirrorAxesCenter(const QPointF &value) const
 {
     m_d->axesCenter = value;
 }
diff --git a/libs/image/kis_image.h b/libs/image/kis_image.h
index ed5072437d..f9dad6055e 100644
--- a/libs/image/kis_image.h
+++ b/libs/image/kis_image.h
@@ -1,1123 +1,1106 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2007 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef KIS_IMAGE_H_
 #define KIS_IMAGE_H_
 
 #include <QObject>
 #include <QString>
 #include <QPainter>
 #include <QRect>
 #include <QRegion>
 #include <QBitArray>
 
 #include <KoColorConversionTransformation.h>
 
 #include "kis_paint_device.h" // msvc cannot handle forward declarations, so include kis_paint_device here
 #include "kis_types.h"
 #include "kis_shared.h"
 #include "kis_node_graph_listener.h"
 #include "kis_node_facade.h"
 #include "kis_image_interfaces.h"
 #include "kis_strokes_queue_undo_result.h"
 
 #include <kritaimage_export.h>
 
 class KisDocument;
 class KoColorSpace;
 class KoColor;
 
 class KisCompositeProgressProxy;
 class KisUndoStore;
 class KisUndoAdapter;
 class KisImageSignalRouter;
 class KisPostExecutionUndoAdapter;
 class KisFilterStrategy;
 class KoColorProfile;
 class KisLayerComposition;
 class KisSpontaneousJob;
 class KisImageAnimationInterface;
 class KUndo2MagicString;
 class KisProofingConfiguration;
 
 namespace KisMetaData
 {
 class MergeStrategy;
 }
 
 /**
  * This is the image class, it contains a tree of KisLayer stack and
  * meta information about the image. And it also provides some
  * functions to manipulate the whole image.
  */
 class KRITAIMAGE_EXPORT KisImage : public QObject,
         public KisStrokesFacade,
         public KisStrokeUndoFacade,
         public KisUpdatesFacade,
         public KisProjectionUpdateListener,
         public KisNodeFacade,
         public KisNodeGraphListener,
         public KisShared
 {
 
     Q_OBJECT
 
 public:
 
     /// @param colorSpace can be null. in that case it will be initialised to a default color space.
     KisImage(KisUndoStore *undoStore, qint32 width, qint32 height, const KoColorSpace *colorSpace, const QString& name);
     ~KisImage() override;
 
 public: // KisNodeGraphListener implementation
 
     void aboutToAddANode(KisNode *parent, int index) override;
     void nodeHasBeenAdded(KisNode *parent, int index) override;
     void aboutToRemoveANode(KisNode *parent, int index) override;
     void nodeChanged(KisNode * node) override;
     void invalidateAllFrames() override;
     void notifySelectionChanged() override;
     void requestProjectionUpdate(KisNode *node, const QVector<QRect> &rects, bool resetAnimationCache) override;
     void invalidateFrames(const KisTimeRange &range, const QRect &rect) override;
     void requestTimeSwitch(int time) override;
 
 public: // KisProjectionUpdateListener implementation
     void notifyProjectionUpdated(const QRect &rc) override;
 
 public:
 
     /**
      * Set the number of threads used by the image's working threads
      */
     void setWorkingThreadsLimit(int value);
 
     /**
      * Return the number of threads available to the image's working threads
      */
     int workingThreadsLimit() const;
 
     /**
      * Makes a copy of the image with all the layers. If possible, shallow
      * copies of the layers are made.
      *
      * \p exactCopy shows if the copied image should look *exactly* the same as
      * the other one (according to it's .kra xml representation). It means that
      * the layers will have the same UUID keys and, therefore, you are not
      * expected to use the copied image anywhere except for saving. Don't use
      * this option if you plan to work with the copied image later.
      */
     KisImage *clone(bool exactCopy = false);
 
     /**
      * Render the projection onto a QImage.
      */
     QImage convertToQImage(qint32 x1,
                            qint32 y1,
                            qint32 width,
                            qint32 height,
                            const KoColorProfile * profile);
 
     /**
      * Render the projection onto a QImage.
      * (this is an overloaded function)
      */
     QImage convertToQImage(QRect imageRect,
                            const KoColorProfile * profile);
 
 
     /**
      * Render a thumbnail of the projection onto a QImage.
      */
     QImage convertToQImage(const QSize& scaledImageSize, const KoColorProfile *profile);
 
     /**
      * [low-level] Lock the image without waiting for all the internal job queues are processed
      *
      * WARNING: Don't use it unless you really know what you are doing! Use barrierLock() instead!
      *
      * Waits for all the **currently running** internal jobs to complete and locks the image
      * for writing. Please note that this function does **not** wait for all the internal
      * queues to process, so there might be some non-finished actions pending. It means that
      * you just postpone these actions until you unlock() the image back. Until then, then image
      * might easily be frozen in some inconsistent state.
      *
      * The only sane usage for this function is to lock the image for **emergency**
      * processing, when some internal action or scheduler got hung up, and you just want
      * to fetch some data from the image without races.
      *
      * In all other cases, please use barrierLock() instead!
      */
     void lock();
 
     /**
      * Unlocks the image and starts/resumes all the pending internal jobs. If the image
      * has been locked for a non-readOnly access, then all the internal caches of the image
      * (e.g. lod-planes) are reset and regeneration jobs are scheduled.
      */
     void unlock();
 
     /**
      * @return return true if the image is in a locked state, i.e. all the internal
      *         jobs are blocked from execution by calling wither lock() or barrierLock().
      *
      *         When the image is locked, the user can do some modifications to the image
      *         contents safely without a perspective having race conditions with internal
      *         image jobs.
      */
     bool locked() const;
 
     /**
      * @return the global selection object or 0 if there is none. The
      * global selection is always read-write.
      */
     KisSelectionSP globalSelection() const;
 
     /**
      * Retrieve the next automatic layername (XXX: fix to add option to return Mask X)
      */
     QString nextLayerName(const QString &baseName = "") const;
 
     /**
      * Set the automatic layer name counter one back.
      */
     void rollBackLayerName();
 
     /**
      * @brief start asynchronous operation on resizing the image
      *
      * The method will resize the image to fit the new size without
      * dropping any pixel data. The GUI will get correct
      * notification with old and new sizes, so it adjust canvas origin
      * accordingly and avoid jumping of the canvas on screen
      *
      * @param newRect the rectangle of the image which will be visible
      *        after operation is completed
      *
      * Please note that the actual operation starts asynchronously in
      * a background, so you cannot expect the image having new size
      * right after ths call.
      */
     void resizeImage(const QRect& newRect);
 
     /**
      * @brief start asynchronous operation on cropping the image
      *
      * The method will **drop** all the image data outside \p newRect
      * and resize the image to fit the new size. The GUI will get correct
      * notification with old and new sizes, so it adjust canvas origin
      * accordingly and avoid jumping of the canvas on screen
      *
      * @param newRect the rectangle of the image which will be cut-out
      *
      * Please note that the actual operation starts asynchronously in
      * a background, so you cannot expect the image having new size
      * right after ths call.
      */
     void cropImage(const QRect& newRect);
 
 
     /**
      * @brief start asynchronous operation on cropping a subtree of nodes starting at \p node
      *
      * The method will **drop** all the layer data outside \p newRect. Neither
      * image nor a layer will be moved anywhere
      *
      * @param newRect the rectangle of the layer which will be cut-out
      *
      * Please note that the actual operation starts asynchronously in
      * a background, so you cannot expect the image having new size
      * right after ths call.
      */
     void cropNode(KisNodeSP node, const QRect& newRect);
 
     /**
      * @brief start asynchronous operation on scaling the image
      * @param size new image size in pixels
      * @param xres new image x-resolution pixels-per-pt
      * @param yres new image y-resolution pixels-per-pt
      * @param filterStrategy filtering strategy
      *
      * Please note that the actual operation starts asynchronously in
      * a background, so you cannot expect the image having new size
      * right after ths call.
      */
     void scaleImage(const QSize &size, qreal xres, qreal yres, KisFilterStrategy *filterStrategy);
 
     /**
      * @brief start asynchronous operation on scaling a subtree of nodes starting at \p node
      * @param node node to scale
      * @param scaleX, @param scaleY scale coefficient to be applied to the node
      * @param filterStrategy filtering strategy
      *
      * Please note that the actual operation starts asynchronously in
      * a background, so you cannot expect the image having new size
      * right after ths call.
      */
     void scaleNode(KisNodeSP node, qreal scaleX, qreal scaleY, KisFilterStrategy *filterStrategy);
 
     /**
      * @brief start asynchronous operation on rotating the image
      *
      * The image is resized to fit the rotated rectangle
      *
      * @param radians rotation angle in radians
      *
      * Please note that the actual operation starts asynchronously in
      * a background, so you cannot expect the operation being completed
      * right after the call
      */
     void rotateImage(double radians);
 
     /**
      * @brief start asynchronous operation on rotating a subtree of nodes starting at \p node
      *
      * The image is not resized!
      *
      * @param node the root of the subtree to rotate
      * @param radians rotation angle in radians
      *
      * Please note that the actual operation starts asynchronously in
      * a background, so you cannot expect the operation being completed
      * right after the call
      */
     void rotateNode(KisNodeSP node, double radians);
 
     /**
      * @brief start asynchronous operation on shearing the image
      *
      * The image is resized to fit the sheared polygon
      *
      * @param angleX, @param angleY are given in degrees.
      *
      * Please note that the actual operation starts asynchronously in
      * a background, so you cannot expect the operation being completed
      * right after the call
      */
     void shear(double angleX, double angleY);
 
     /**
      * @brief start asynchronous operation on shearing a subtree of nodes starting at \p node
      *
      * The image is not resized!
      *
      * @param node the root of the subtree to rotate
      * @param angleX, @param angleY are given in degrees.
      *
      * Please note that the actual operation starts asynchronously in
      * a background, so you cannot expect the operation being completed
      * right after the call
      */
     void shearNode(KisNodeSP node, double angleX, double angleY);
 
     /**
      * Convert the image and all its layers to the dstColorSpace
      */
     void convertImageColorSpace(const KoColorSpace *dstColorSpace,
                                 KoColorConversionTransformation::Intent renderingIntent,
                                 KoColorConversionTransformation::ConversionFlags conversionFlags);
 
     /**
      * Set the color space of  the projection (and the root layer)
      * to dstColorSpace. No conversion is done for other layers,
      * their colorspace can differ.
      * NOTE: Note conversion is done, only regeneration, so no rendering
      * intent needed
      */
     void convertProjectionColorSpace(const KoColorSpace *dstColorSpace);
 
     // Get the profile associated with this image
     const KoColorProfile *  profile() const;
 
     /**
      * Set the profile of the image to the new profile and do the same for
      * all layers that have the same colorspace and profile of the image.
      * It doesn't do any pixel conversion.
      *
      * This is essential if you have loaded an image that didn't
      * have an embedded profile to which you want to attach the right profile.
      *
      * This does not create an undo action; only call it when creating or
      * loading an image.
      *
      * @returns false if the profile could not be assigned
      */
     bool assignImageProfile(const KoColorProfile *profile);
 
     /**
      * Returns the current undo adapter. You can add new commands to the
      * undo stack using the adapter. This adapter is used for a backward
      * compatibility for old commands created before strokes. It blocks
      * all the porcessing at the scheduler, waits until it's finished
      * and executes commands exclusively.
      */
     KisUndoAdapter* undoAdapter() const;
 
     /**
      * This adapter is used by the strokes system. The commands are added
      * to it *after* redo() is done (in the scheduler context). They are
      * wrapped into a special command and added to the undo stack. redo()
      * in not called.
      */
     KisPostExecutionUndoAdapter* postExecutionUndoAdapter() const override;
 
     /**
      * Replace current undo store with the new one. The old store
      * will be deleted.
      * This method is used by KisDocument for dropping all the commands
      * during file loading.
      */
     void setUndoStore(KisUndoStore *undoStore);
 
     /**
      * Return current undo store of the image
      */
     KisUndoStore* undoStore();
 
     /**
      * Tell the image it's modified; this emits the sigImageModified
      * signal. This happens when the image needs to be saved
      */
     void setModified();
 
     /**
      * The default colorspace of this image: new layers will have this
      * colorspace and the projection will have this colorspace.
      */
     const KoColorSpace * colorSpace() const;
 
     /**
      * X resolution in pixels per pt
      */
     double xRes() const;
 
     /**
      * Y resolution in pixels per pt
      */
     double yRes() const;
 
     /**
      * Set the resolution in pixels per pt.
      */
     void setResolution(double xres, double yres);
 
     /**
      * Convert a document coordinate to a pixel coordinate.
      *
      * @param documentCoord PostScript Pt coordinate to convert.
      */
     QPointF documentToPixel(const QPointF &documentCoord) const;
 
     /**
      * Convert a document coordinate to an integer pixel coordinate rounded down.
      *
      * @param documentCoord PostScript Pt coordinate to convert.
      */
     QPoint documentToImagePixelFloored(const QPointF &documentCoord) const;
 
     /**
      * Convert a document rectangle to a pixel rectangle.
      *
      * @param documentRect PostScript Pt rectangle to convert.
      */
     QRectF documentToPixel(const QRectF &documentRect) const;
 
     /**
      * Convert a pixel coordinate to a document coordinate.
      *
      * @param pixelCoord pixel coordinate to convert.
      */
     QPointF pixelToDocument(const QPointF &pixelCoord) const;
 
     /**
      * Convert an integer pixel coordinate to a document coordinate.
      * The document coordinate is at the centre of the pixel.
      *
      * @param pixelCoord pixel coordinate to convert.
      */
     QPointF pixelToDocument(const QPoint &pixelCoord) const;
 
     /**
      * Convert a document rectangle to an integer pixel rectangle.
      *
      * @param pixelCoord pixel coordinate to convert.
      */
     QRectF pixelToDocument(const QRectF &pixelCoord) const;
 
     /**
      * Return the width of the image
      */
     qint32 width() const;
 
     /**
      * Return the height of the image
      */
     qint32 height() const;
 
     /**
      * Return the size of the image
      */
     QSize size() const {
         return QSize(width(), height());
     }
 
     /**
      * @return the root node of the image node graph
      */
     KisGroupLayerSP rootLayer() const;
 
     /**
      * Return the projection; that is, the complete, composited
      * representation of this image.
      */
     KisPaintDeviceSP projection() const;
 
     /**
      * Return the number of layers (not other nodes) that are in this
      * image.
      */
     qint32 nlayers() const;
 
     /**
      * Return the number of layers (not other node types) that are in
      * this image and that are hidden.
      */
     qint32 nHiddenLayers() const;
 
     /**
      * Merge all visible layers and discard hidden ones.
      */
     void flatten(KisNodeSP activeNode);
 
     /**
      * Merge the specified layer with the layer
      * below this layer, remove the specified layer.
      */
     void mergeDown(KisLayerSP l, const KisMetaData::MergeStrategy* strategy);
 
     /**
      * flatten the layer: that is, the projection becomes the layer
      * and all subnodes are removed. If this is not a paint layer, it will morph
      * into a paint layer.
      */
     void flattenLayer(KisLayerSP layer);
 
     /**
      * Merges layers in \p mergedLayers and creates a new layer above
      * \p putAfter
      */
     void mergeMultipleLayers(QList<KisNodeSP> mergedLayers, KisNodeSP putAfter);
 
     /// @return the exact bounds of the image in pixel coordinates.
     QRect bounds() const;
 
     /**
      * Returns the actual bounds of the image, taking LevelOfDetail
      * into account.  This value is used as a bounds() value of
      * KisDefaultBounds object.
      */
     QRect effectiveLodBounds() const;
 
     /// use if the layers have changed _completely_ (eg. when flattening)
     void notifyLayersChanged();
 
     /**
      * Sets the default color of the root layer projection. All the layers
      * will be merged on top of this very color
      */
     void setDefaultProjectionColor(const KoColor &color);
 
     /**
      * \see setDefaultProjectionColor()
      */
     KoColor defaultProjectionColor() const;
 
     void setRootLayer(KisGroupLayerSP rootLayer);
 
     /**
      * Add an annotation for this image. This can be anything: Gamma, EXIF, etc.
      * Note that the "icc" annotation is reserved for the color strategies.
      * If the annotation already exists, overwrite it with this one.
      */
     void addAnnotation(KisAnnotationSP annotation);
 
     /** get the annotation with the given type, can return 0 */
     KisAnnotationSP annotation(const QString& type);
 
     /** delete the annotation, if the image contains it */
     void removeAnnotation(const QString& type);
 
     /**
      * Start of an iteration over the annotations of this image (including the ICC Profile)
      */
     vKisAnnotationSP_it beginAnnotations();
 
     /** end of an iteration over the annotations of this image */
     vKisAnnotationSP_it endAnnotations();
 
     /**
      * Called before the image is delted and sends the sigAboutToBeDeleted signal
      */
     void notifyAboutToBeDeleted();
 
     KisImageSignalRouter* signalRouter();
 
     /**
      * Returns whether we can reselect current global selection
      *
      * \see reselectGlobalSelection()
      */
     bool canReselectGlobalSelection();
 
     /**
      * Returns the layer compositions for the image
      */
     QList<KisLayerCompositionSP> compositions();
 
     /**
      * Adds a new layer composition, will be saved with the image
      */
     void addComposition(KisLayerCompositionSP composition);
 
     /**
      * Remove the layer compostion
      */
     void removeComposition(KisLayerCompositionSP composition);
 
     /**
      * Permit or deny the wrap-around mode for all the paint devices
      * of the image. Note that permitting the wraparound mode will not
      * necessarily activate it right now. To be activated the wrap
      * around mode should be 1) permitted; 2) supported by the
      * currently running stroke.
      */
     void setWrapAroundModePermitted(bool value);
 
     /**
      * \return whether the wrap-around mode is permitted for this
      *         image. If the wrap around mode is permitted and the
      *         currently running stroke supports it, the mode will be
      *         activated for all paint devices of the image.
      *
      * \see setWrapAroundMode
      */
     bool wrapAroundModePermitted() const;
 
 
     /**
      * \return whether the wraparound mode is activated for all the
      *         devices of the image. The mode is activated when both
      *         factors are true: the user permitted it and the stroke
      *         supports it
      */
     bool wrapAroundModeActive() const;
 
     /**
      * \return current level of detail which is used when processing the image.
      * Current working zoom = 2 ^ (- currentLevelOfDetail()). Default value is
      * null, which means we work on the original image.
      */
     int currentLevelOfDetail() const;
 
     /**
      * Notify KisImage which level of detail should be used in the
      * lod-mode. Setting the mode does not guarantee the LOD to be
      * used. It will be activated only when the stokes supports it.
      */
     void setDesiredLevelOfDetail(int lod);
 
     /**
      * Relative position of the mirror axis center
      *     0,0 - topleft corner of the image
      *     1,1 - bottomright corner of the image
      */
     QPointF mirrorAxesCenter() const;
 
     /**
      * Sets the relative position of the axes center
      * \see mirrorAxesCenter() for details
      */
     void setMirrorAxesCenter(const QPointF &value) const;
 
 public Q_SLOTS:
 
     /**
      * Explicitly start regeneration of LoD planes of all the devices
      * in the image. This call should be performed when the user is idle,
      * just to make the quality of image updates better.
      */
     void explicitRegenerateLevelOfDetail();
 
 public:
 
     /**
      * Blocks usage of level of detail functionality. After this method
      * has been called, no new strokes will use LoD.
      */
     void setLevelOfDetailBlocked(bool value);
 
     /**
      * \see setLevelOfDetailBlocked()
      */
     bool levelOfDetailBlocked() const;
 
     /**
      * Notifies that the node collapsed state has changed
      */
     void notifyNodeCollpasedChanged();
 
     KisImageAnimationInterface *animationInterface() const;
 
     /**
      * @brief setProofingConfiguration, this sets the image's proofing configuration, and signals
      * the proofingConfiguration has changed.
      * @param proofingConfig - the kis proofing config that will be used instead.
      */
     void setProofingConfiguration(KisProofingConfigurationSP proofingConfig);
     /**
      * @brief proofingConfiguration
      * @return the proofing configuration of the image.
      */
     KisProofingConfigurationSP proofingConfiguration() const;
 
 public Q_SLOTS:
     bool startIsolatedMode(KisNodeSP node);
     void stopIsolatedMode();
 
 public:
     KisNodeSP isolatedModeRoot() const;
 
 Q_SIGNALS:
 
     /**
      *  Emitted whenever an action has caused the image to be
      *  recomposited.
      *
      * @param rc The rect that has been recomposited.
      */
     void sigImageUpdated(const QRect &);
 
-    /**
-     * Emitted whenever the image is going to reset load planes from lodN to
-     * lod0. All the signals emitted with sigImageUpdated() between the calls
-     * to sigBeginLodResetUpdatesBatch() and sigEndLodResetUpdatesBatch() will be
-     * considered as belonging to the same "batch". During processing a "batch"
-     * GUI is not permitted to change lod level of the tile textures. It should
-     * just update internal caches. The call to sigEndLodResetUpdatesBatch()
-     * will start rerendering of the canvas.
-     *
-     * 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 sigBeginLodResetUpdatesBatch();
-
-    /**
-     * @see sigBeginLodResetUpdatesBatch()
-     */
-    void sigEndLodResetUpdatesBatch();
-
     /**
        Emitted whenever the image has been modified, so that it
        doesn't match with the version saved on disk.
      */
     void sigImageModified();
 
     /**
      * The signal is emitted when the size of the image is changed.
      * \p oldStillPoint and \p newStillPoint give the receiver the
      * hint about how the new and old rect of the image correspond to
      * each other. They specify the point of the image around which
      * the conversion was done. This point will stay still on the
      * user's screen. That is the \p newStillPoint of the new image
      * will be painted at the same screen position, where \p
      * oldStillPoint of the old image was painted.
      *
      * \param oldStillPoint is a still point represented in *old*
      *                      image coordinates
      *
      * \param newStillPoint is a still point represented in *new*
      *                      image coordinates
      */
     void sigSizeChanged(const QPointF &oldStillPoint, const QPointF &newStillPoint);
 
     void sigProfileChanged(const KoColorProfile *  profile);
     void sigColorSpaceChanged(const KoColorSpace*  cs);
     void sigResolutionChanged(double xRes, double yRes);
     void sigRequestNodeReselection(KisNodeSP activeNode, const KisNodeList &selectedNodes);
 
     /**
      * Inform the model that a node was changed
      */
     void sigNodeChanged(KisNodeSP node);
 
     /**
      * Inform that the image is going to be deleted
      */
     void sigAboutToBeDeleted();
 
     /**
      * The signal is emitted right after a node has been connected
      * to the graph of the nodes.
      *
      * WARNING: you must not request any graph-related information
      * about the node being run in a not-scheduler thread. If you need
      * information about the parent/siblings of the node connect
      * with Qt::DirectConnection, get needed information and then
      * emit another Qt::AutoConnection signal to pass this information
      * to your thread. See details of the implementation
      * in KisDummiesfacadeBase.
      */
     void sigNodeAddedAsync(KisNodeSP node);
 
     /**
      * This signal is emitted right before a node is going to removed
      * from the graph of the nodes.
      *
      * WARNING: you must not request any graph-related information
      * about the node being run in a not-scheduler thread.
      *
      * \see comment in sigNodeAddedAsync()
      */
     void sigRemoveNodeAsync(KisNodeSP node);
 
     /**
      * Emitted when the root node of the image has changed.
      * It happens, e.g. when we flatten the image. When
      * this happens the receiver should reload information
      * about the image
      */
     void sigLayersChangedAsync();
 
     /**
      * Emitted when the UI has requested the undo of the last stroke's
      * operation. The point is, we cannot deal with the internals of
      * the stroke without its creator knowing about it (which most
      * probably cause a crash), so we just forward this request from
      * the UI to the creator of the stroke.
      *
      * If your tool supports undoing part of its work, just listen to
      * this signal and undo when it comes
      */
     void sigUndoDuringStrokeRequested();
 
     /**
      * Emitted when the UI has requested the cancellation of
      * the stroke. The point is, we cannot cancel the stroke
      * without its creator knowing about it (which most probably
      * cause a crash), so we just forward this request from the UI
      * to the creator of the stroke.
      *
      * If your tool supports cancelling of its work in the middle
      * of operation, just listen to this signal and cancel
      * the stroke when it comes
      */
     void sigStrokeCancellationRequested();
 
     /**
      * Emitted when the image decides that the stroke should better
      * be ended. The point is, we cannot just end the stroke
      * without its creator knowing about it (which most probably
      * cause a crash), so we just forward this request from the UI
      * to the creator of the stroke.
      *
      * If your tool supports long  strokes that may involve multiple
      * mouse actions in one stroke, just listen to this signal and
      * end the stroke when it comes.
      */
     void sigStrokeEndRequested();
 
     /**
      * Same as sigStrokeEndRequested() but is not emitted when the active node
      * is changed.
      */
     void sigStrokeEndRequestedActiveNodeFiltered();
 
     /**
      * Emitted when the isolated mode status has changed.
      *
      * Can be used by the receivers to catch a fact of forcefully
      * stopping the isolated mode by the image when some complex
      * action was requested
      */
     void sigIsolatedModeChanged();
 
     /**
      * Emitted when one or more nodes changed the collapsed state
      *
      */
     void sigNodeCollapsedChanged();
 
     /**
      * Emitted when the proofing configuration of the image is being changed.
      *
      */
     void sigProofingConfigChanged();
 
     /**
      * Internal signal for asynchronously requesting isolated mode to stop. Don't use it
      * outside KisImage, use sigIsolatedModeChanged() instead.
      */
     void sigInternalStopIsolatedModeRequested();
 
 public Q_SLOTS:
     KisCompositeProgressProxy* compositeProgressProxy();
 
     bool isIdle(bool allowLocked = false);
 
     /**
      * @brief Wait until all the queued background jobs are completed and lock the image.
      *
      * KisImage object has a local scheduler that executes long-running image
      * rendering/modifying jobs (we call them "strokes") in a background. Basically,
      * one should either access the image from the scope of such jobs (strokes) or
      * just lock the image before using.
      *
      * Calling barrierLock() will wait until all the queued operations are finished
      * and lock the image, so you can start accessing it in a safe way.
      *
      * @p readOnly tells the image if the caller is going to modify the image during
      *             holding the lock. Locking with non-readOnly  access will reset all
      *             the internal caches of the image (lod-planes) when the lock status
      *             will be lifted.
      */
     void barrierLock(bool readOnly = false);
 
     /**
      * @brief Tries to lock the image without waiting for the jobs to finish
      *
      * Same as barrierLock(), but doesn't block execution of the calling thread
      * until all the background jobs are finished. Instead, in case of presence of
      * unfinished jobs in the queue, it just returns false
      *
      * @return whether the lock has been acquired
      * @see barrierLock
      */
     bool tryBarrierLock(bool readOnly = false);
 
     /**
      * Wait for all the internal image jobs to complete and return without locking
      * the image. This function is handly for tests or other synchronous actions,
      * when one needs to wait for the result of his actions.
      */
     void waitForDone();
 
     KisStrokeId startStroke(KisStrokeStrategy *strokeStrategy) override;
     void addJob(KisStrokeId id, KisStrokeJobData *data) override;
     void endStroke(KisStrokeId id) override;
     bool cancelStroke(KisStrokeId id) override;
 
     /**
      * @brief blockUpdates block updating the image projection
      */
     void blockUpdates() override;
 
     /**
      * @brief unblockUpdates unblock updating the image project. This
      * only restarts the scheduler and does not schedule a full refresh.
      */
     void unblockUpdates() override;
 
     /**
      * Disables notification of the UI about the changes in the image.
      * This feature is used by KisProcessingApplicator. It is needed
      * when we change the size of the image. In this case, the whole
      * image will be reloaded into UI by sigSizeChanged(), so there is
      * no need to inform the UI about individual dirty rects.
+     *
+     * The last call to enableUIUpdates() will return the list of udpates
+     * that were requested while they were blocked.
      */
     void disableUIUpdates() override;
 
     /**
      * \see disableUIUpdates
      */
-    void enableUIUpdates() override;
+    QVector<QRect> enableUIUpdates() override;
 
     /**
      * Disables the processing of all the setDirty() requests that
      * come to the image. The incoming requests are effectively
      * *dropped*.
      *
      * This feature is used by KisProcessingApplicator. For many cases
      * it provides its own updates interface, which recalculates the
      * whole subtree of nodes. But while we change any particular
      * node, it can ask for an update itself. This method is a way of
      * blocking such intermediate (and excessive) requests.
      *
      * NOTE: this is a convenience function for setProjectionUpdatesFilter()
      *       that installs a predefined filter that eats everything. Please
      *       note that these calls are *not* recursive
      */
     void disableDirtyRequests() override;
 
     /**
      * \see disableDirtyRequests()
      */
     void enableDirtyRequests() override;
 
     /**
      * Installs a filter object that will filter all the incoming projection update
      * requests. If the filter return true, the incoming update is dropped.
      *
      * NOTE: you cannot set filters recursively!
      */
     void setProjectionUpdatesFilter(KisProjectionUpdatesFilterSP filter) override;
 
     /**
      * \see setProjectionUpdatesFilter()
      */
     KisProjectionUpdatesFilterSP projectionUpdatesFilter() const override;
 
     void refreshGraphAsync(KisNodeSP root = KisNodeSP()) override;
     void refreshGraphAsync(KisNodeSP root, const QRect &rc) override;
     void refreshGraphAsync(KisNodeSP root, const QRect &rc, const QRect &cropRect) override;
 
     /**
      * Triggers synchronous recomposition of the projection
      */
     void refreshGraph(KisNodeSP root = KisNodeSP());
     void refreshGraph(KisNodeSP root, const QRect& rc, const QRect &cropRect);
     void initialRefreshGraph();
 
     /**
      * Initiate a stack regeneration skipping the recalculation of the
      * filthy node's projection.
      *
      * Works exactly as pseudoFilthy->setDirty() with the only
      * exception that pseudoFilthy::updateProjection() will not be
      * called. That is used by KisRecalculateTransformMaskJob to avoid
      * cyclic dependencies.
      */
     void requestProjectionUpdateNoFilthy(KisNodeSP pseudoFilthy, const QRect &rc, const QRect &cropRect);
 
     /**
      * Adds a spontaneous job to the updates queue.
      *
      * A spontaneous job may do some trivial tasks in the background,
      * like updating the outline of selection or purging unused tiles
      * from the existing paint devices.
      */
     void addSpontaneousJob(KisSpontaneousJob *spontaneousJob);
 
     /**
      * This method is called by the UI (*not* by the creator of the
      * stroke) when it thinks the current stroke should undo its last
      * action, for example, when the user presses Ctrl+Z while some
      * stroke is active.
      *
      * If the creator of the stroke supports undoing of intermediate
      * actions, it will be notified about this request and can undo
      * its last action.
      */
     void requestUndoDuringStroke();
 
     /**
      * This method is called by the UI (*not* by the creator of the
      * stroke) when it thinks current stroke should be cancelled. If
      * there is a running stroke that has already been detached from
      * its creator (ended or cancelled), it will be forcefully
      * cancelled and reverted. If there is an open stroke present, and
      * if its creator supports cancelling, it will be notified about
      * the request and the stroke will be cancelled
      */
     void requestStrokeCancellation();
 
     /**
      * This method requests the last stroke executed on the image to become undone.
      * If the stroke is not ended, or if all the Lod0 strokes are completed, the method
      * returns UNDO_FAIL. If the last Lod0 is going to be finished soon, then UNDO_WAIT
      * is returned and the caller should just wait for its completion and call global undo
      * instead. UNDO_OK means one unfinished stroke has been undone.
      */
     UndoResult tryUndoUnfinishedLod0Stroke();
 
     /**
      * This method is called when image or some other part of Krita
      * (*not* the creator of the stroke) decides that the stroke
      * should be ended. If the creator of the stroke supports it, it
      * will be notified and the stroke will be cancelled
      */
     void requestStrokeEnd();
 
     /**
      * Same as requestStrokeEnd() but is called by view manager when
      * the current node is changed. Use to dintinguish
      * sigStrokeEndRequested() and
      * sigStrokeEndRequestedActiveNodeFiltered() which are used by
      * KisNodeJugglerCompressed
      */
     void requestStrokeEndActiveNode();
 
 private:
 
     KisImage(const KisImage& rhs, KisUndoStore *undoStore, bool exactCopy);
     KisImage& operator=(const KisImage& rhs);
 
     void emitSizeChanged();
 
     void resizeImageImpl(const QRect& newRect, bool cropLayers);
     void rotateImpl(const KUndo2MagicString &actionName, KisNodeSP rootNode,
                     bool resizeImage, double radians);
     void shearImpl(const KUndo2MagicString &actionName, KisNodeSP rootNode,
                    bool resizeImage, double angleX, double angleY,
                    const QPointF &origin);
 
     void safeRemoveTwoNodes(KisNodeSP node1, KisNodeSP node2);
 
     void refreshHiddenArea(KisNodeSP rootNode, const QRect &preparedArea);
 
     void requestProjectionUpdateImpl(KisNode *node,
                                      const QVector<QRect> &rects,
                                      const QRect &cropRect);
 
     friend class KisImageResizeCommand;
     void setSize(const QSize& size);
 
     friend class KisImageSetProjectionColorSpaceCommand;
     void setProjectionColorSpace(const KoColorSpace * colorSpace);
 
 
     friend class KisDeselectGlobalSelectionCommand;
     friend class KisReselectGlobalSelectionCommand;
     friend class KisSetGlobalSelectionCommand;
     friend class KisImageTest;
     friend class Document; // For libkis
 
     /**
      * Replaces the current global selection with globalSelection. If
      * \p globalSelection is empty, removes the selection object, so that
      * \ref globalSelection() will return 0 after that.
      */
     void setGlobalSelection(KisSelectionSP globalSelection);
 
     /**
      * Deselects current global selection.
      * \ref globalSelection() will return 0 after that.
      */
     void deselectGlobalSelection();
 
     /**
      * Reselects current deselected selection
      *
      * \see deselectGlobalSelection()
      */
     void reselectGlobalSelection();
 
 private:
     class KisImagePrivate;
     KisImagePrivate * m_d;
 };
 
 #endif // KIS_IMAGE_H_
diff --git a/libs/image/kis_image_interfaces.h b/libs/image/kis_image_interfaces.h
index 5635a88da7..79c59d9819 100644
--- a/libs/image/kis_image_interfaces.h
+++ b/libs/image/kis_image_interfaces.h
@@ -1,77 +1,77 @@
 /*
  *  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_INTERFACES_H
 #define __KIS_IMAGE_INTERFACES_H
 
 #include "kis_types.h"
 #include <kritaimage_export.h>
 
 class QRect;
 class KisStrokeStrategy;
 class KisStrokeJobData;
 class KisPostExecutionUndoAdapter;
 
 
 class KRITAIMAGE_EXPORT KisStrokesFacade
 {
 public:
     virtual ~KisStrokesFacade();
     virtual KisStrokeId startStroke(KisStrokeStrategy *strokeStrategy) = 0;
     virtual void addJob(KisStrokeId id, KisStrokeJobData *data) = 0;
     virtual void endStroke(KisStrokeId id) = 0;
     virtual bool cancelStroke(KisStrokeId id) = 0;
 };
 
 class KRITAIMAGE_EXPORT KisUpdatesFacade
 {
 public:
     virtual ~KisUpdatesFacade();
 
     virtual void blockUpdates() = 0;
     virtual void unblockUpdates() = 0;
 
     virtual void disableUIUpdates() = 0;
-    virtual void enableUIUpdates() = 0;
+    virtual QVector<QRect> enableUIUpdates() = 0;
 
     virtual void disableDirtyRequests() = 0;
     virtual void enableDirtyRequests() = 0;
 
     virtual void refreshGraphAsync(KisNodeSP root) = 0;
     virtual void refreshGraphAsync(KisNodeSP root, const QRect &rc) = 0;
     virtual void refreshGraphAsync(KisNodeSP root, const QRect &rc, const QRect &cropRect) = 0;
 
     virtual void setProjectionUpdatesFilter(KisProjectionUpdatesFilterSP filter) = 0;
     virtual KisProjectionUpdatesFilterSP projectionUpdatesFilter() const = 0;
 };
 
 class KRITAIMAGE_EXPORT KisProjectionUpdateListener
 {
 public:
     virtual ~KisProjectionUpdateListener();
     virtual void notifyProjectionUpdated(const QRect &rc) = 0;
 };
 
 class KRITAIMAGE_EXPORT KisStrokeUndoFacade
 {
 public:
     virtual ~KisStrokeUndoFacade();
     virtual KisPostExecutionUndoAdapter* postExecutionUndoAdapter() const = 0;
 };
 
 #endif /* __KIS_IMAGE_INTERFACES_H */
diff --git a/libs/image/kis_image_signal_router.cpp b/libs/image/kis_image_signal_router.cpp
index 0145ad87c9..f1826a6093 100644
--- a/libs/image/kis_image_signal_router.cpp
+++ b/libs/image/kis_image_signal_router.cpp
@@ -1,174 +1,172 @@
 /*
  *  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_image_signal_router.h"
 
 #include <QThread>
 
 #include "kis_image.h"
 
 
 #define CONNECT_TO_IMAGE(signal)                                        \
     connect(this, SIGNAL(signal), m_image, SIGNAL(signal), Qt::DirectConnection)
 
 struct ImageSignalsStaticRegistrar {
     ImageSignalsStaticRegistrar() {
         qRegisterMetaType<KisImageSignalType>("KisImageSignalType");
     }
 };
 static ImageSignalsStaticRegistrar __registrar;
 
 
 KisImageSignalRouter::KisImageSignalRouter(KisImageWSP image)
     : QObject(image.data()),
       m_image(image)
 {
     connect(this, SIGNAL(sigNotification(KisImageSignalType)),
             SLOT(slotNotification(KisImageSignalType)));
 
     CONNECT_TO_IMAGE(sigImageModified());
     CONNECT_TO_IMAGE(sigSizeChanged(const QPointF&, const QPointF&));
     CONNECT_TO_IMAGE(sigProfileChanged(const KoColorProfile*));
     CONNECT_TO_IMAGE(sigColorSpaceChanged(const KoColorSpace*));
     CONNECT_TO_IMAGE(sigResolutionChanged(double, double));
     CONNECT_TO_IMAGE(sigRequestNodeReselection(KisNodeSP, const KisNodeList&));
 
     CONNECT_TO_IMAGE(sigNodeChanged(KisNodeSP));
     CONNECT_TO_IMAGE(sigNodeAddedAsync(KisNodeSP));
     CONNECT_TO_IMAGE(sigRemoveNodeAsync(KisNodeSP));
     CONNECT_TO_IMAGE(sigLayersChangedAsync());
 }
 
 KisImageSignalRouter::~KisImageSignalRouter()
 {
 }
 
 void KisImageSignalRouter::emitNotifications(KisImageSignalVector notifications)
 {
     Q_FOREACH (const KisImageSignalType &type, notifications) {
         emitNotification(type);
     }
 }
 
 void KisImageSignalRouter::emitNotification(KisImageSignalType type)
 {
     /**
      * All the notifications except LayersChangedSignal should go in a
      * queued way. And LayersChangedSignal should be delivered to the
      * recipients in a non-reordered way
      */
 
     if (type.id == LayersChangedSignal) {
         slotNotification(type);
     } else {
         emit sigNotification(type);
     }
 }
 
 void KisImageSignalRouter::emitNodeChanged(KisNodeSP node)
 {
     emit sigNodeChanged(node);
 }
 
 void KisImageSignalRouter::emitNodeHasBeenAdded(KisNode *parent, int index)
 {
     KisNodeSP newNode = parent->at(index);
 
     if (!newNode->inherits("KisSelectionMask")) {
         KisImageSP image = m_image.toStrongRef();
         if (image) {
             image->invalidateAllFrames();
         }
     }
 
     emit sigNodeAddedAsync(newNode);
 }
 
 void KisImageSignalRouter::emitAboutToRemoveANode(KisNode *parent, int index)
 {
     KisNodeSP removedNode = parent->at(index);
 
     if (!removedNode->inherits("KisSelectionMask")) {
         KisImageSP image = m_image.toStrongRef();
         if (image) {
             image->invalidateAllFrames();
         }
     }
 
     emit sigRemoveNodeAsync(removedNode);
 }
 
-void KisImageSignalRouter::emitBeginLodResetUpdatesBatch()
+void KisImageSignalRouter::emitRequestLodPlanesSyncBlocked(bool value)
 {
-    KisImageSP image = m_image.toStrongRef();
-    KIS_SAFE_ASSERT_RECOVER_RETURN(image);
-
-    emit image->sigBeginLodResetUpdatesBatch();
+    emit sigRequestLodPlanesSyncBlocked(value);
 }
 
-void KisImageSignalRouter::emitEndLodResetUpdatesBatch()
+void KisImageSignalRouter::emitNotifyBatchUpdateStarted()
 {
-    KisImageSP image = m_image.toStrongRef();
-    KIS_SAFE_ASSERT_RECOVER_RETURN(image);
-
-    emit image->sigEndLodResetUpdatesBatch();
+    emit sigNotifyBatchUpdateStarted();
 }
 
+void KisImageSignalRouter::emitNotifyBatchUpdateEnded()
+{
+    emit sigNotifyBatchUpdateEnded();
+}
 
 void KisImageSignalRouter::slotNotification(KisImageSignalType type)
 {
     KisImageSP image = m_image.toStrongRef();
     if (!image) {
         return;
     }
 
     switch(type.id) {
     case LayersChangedSignal:
         image->invalidateAllFrames();
         emit sigLayersChangedAsync();
         break;
     case ModifiedSignal:
         emit sigImageModified();
         break;
     case SizeChangedSignal:
         image->invalidateAllFrames();
         emit sigSizeChanged(type.sizeChangedSignal.oldStillPoint,
                             type.sizeChangedSignal.newStillPoint);
         break;
     case ProfileChangedSignal:
         image->invalidateAllFrames();
         emit sigProfileChanged(image->profile());
         break;
     case ColorSpaceChangedSignal:
         image->invalidateAllFrames();
         emit sigColorSpaceChanged(image->colorSpace());
         break;
     case ResolutionChangedSignal:
         image->invalidateAllFrames();
         emit sigResolutionChanged(image->xRes(), image->yRes());
         break;
     case NodeReselectionRequestSignal:
         if (type.nodeReselectionSignal.newActiveNode ||
             !type.nodeReselectionSignal.newSelectedNodes.isEmpty()) {
 
             emit sigRequestNodeReselection(type.nodeReselectionSignal.newActiveNode,
                                            type.nodeReselectionSignal.newSelectedNodes);
         }
         break;
     }
 }
diff --git a/libs/image/kis_image_signal_router.h b/libs/image/kis_image_signal_router.h
index 10701deab8..2e196bf4f6 100644
--- a/libs/image/kis_image_signal_router.h
+++ b/libs/image/kis_image_signal_router.h
@@ -1,181 +1,213 @@
 /*
  *  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"
 
 
 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 emitBeginLodResetUpdatesBatch();
-    void emitEndLodResetUpdatesBatch();
+    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_strokes_queue.cpp b/libs/image/kis_strokes_queue.cpp
index 23520f0104..f7e08484ff 100644
--- a/libs/image/kis_strokes_queue.cpp
+++ b/libs/image/kis_strokes_queue.cpp
@@ -1,834 +1,814 @@
 /*
  *  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_strokes_queue.h"
 
 #include <QQueue>
 #include <QMutex>
 #include <QMutexLocker>
 #include "kis_stroke.h"
 #include "kis_updater_context.h"
 #include "kis_stroke_job_strategy.h"
 #include "kis_stroke_strategy.h"
 #include "kis_undo_stores.h"
 #include "kis_post_execution_undo_adapter.h"
 
 typedef QQueue<KisStrokeSP> StrokesQueue;
 typedef QQueue<KisStrokeSP>::iterator StrokesQueueIterator;
 
 #include "kis_image_interfaces.h"
 class KisStrokesQueue::LodNUndoStrokesFacade : public KisStrokesFacade
 {
 public:
     LodNUndoStrokesFacade(KisStrokesQueue *_q) : q(_q) {}
 
     KisStrokeId startStroke(KisStrokeStrategy *strokeStrategy) override {
         return q->startLodNUndoStroke(strokeStrategy);
     }
 
     void addJob(KisStrokeId id, KisStrokeJobData *data) override {
         KisStrokeSP stroke = id.toStrongRef();
         KIS_SAFE_ASSERT_RECOVER_NOOP(stroke);
         KIS_SAFE_ASSERT_RECOVER_NOOP(!stroke->lodBuddy());
         KIS_SAFE_ASSERT_RECOVER_NOOP(stroke->type() == KisStroke::LODN);
 
         q->addJob(id, data);
     }
 
     void endStroke(KisStrokeId id) override {
         KisStrokeSP stroke = id.toStrongRef();
         KIS_SAFE_ASSERT_RECOVER_NOOP(stroke);
         KIS_SAFE_ASSERT_RECOVER_NOOP(!stroke->lodBuddy());
         KIS_SAFE_ASSERT_RECOVER_NOOP(stroke->type() == KisStroke::LODN);
 
         q->endStroke(id);
     }
 
     bool cancelStroke(KisStrokeId id) override {
         Q_UNUSED(id);
         qFatal("Not implemented");
         return false;
     }
 
 private:
     KisStrokesQueue *q;
 };
 
 
 struct Q_DECL_HIDDEN KisStrokesQueue::Private {
     Private(KisStrokesQueue *_q)
         : q(_q),
           openedStrokesCounter(0),
           needsExclusiveAccess(false),
           wrapAroundModeSupported(false),
           balancingRatioOverride(-1.0),
           currentStrokeLoaded(false),
           lodNNeedsSynchronization(true),
           desiredLevelOfDetail(0),
           nextDesiredLevelOfDetail(0),
           lodNStrokesFacade(_q),
           lodNPostExecutionUndoAdapter(&lodNUndoStore, &lodNStrokesFacade) {}
 
     KisStrokesQueue *q;
     StrokesQueue strokesQueue;
     int openedStrokesCounter;
     bool needsExclusiveAccess;
     bool wrapAroundModeSupported;
     qreal balancingRatioOverride;
     bool currentStrokeLoaded;
 
     bool lodNNeedsSynchronization;
     int desiredLevelOfDetail;
     int nextDesiredLevelOfDetail;
     QMutex mutex;
     KisLodSyncStrokeStrategyFactory lod0ToNStrokeStrategyFactory;
     KisSuspendResumeStrategyFactory suspendUpdatesStrokeStrategyFactory;
     KisSuspendResumeStrategyFactory resumeUpdatesStrokeStrategyFactory;
     KisSurrogateUndoStore lodNUndoStore;
     LodNUndoStrokesFacade lodNStrokesFacade;
     KisPostExecutionUndoAdapter lodNPostExecutionUndoAdapter;
 
     void cancelForgettableStrokes();
     void startLod0ToNStroke(int levelOfDetail, bool forgettable);
 
     bool canUseLodN() const;
     StrokesQueueIterator findNewLod0Pos();
     StrokesQueueIterator findNewLodNPos(KisStrokeSP lodN);
     bool shouldWrapInSuspendUpdatesStroke() const;
 
     void switchDesiredLevelOfDetail(bool forced);
     bool hasUnfinishedStrokes() const;
     void tryClearUndoOnStrokeCompletion(KisStrokeSP finishingStroke);
 };
 
 
 KisStrokesQueue::KisStrokesQueue()
   : m_d(new Private(this))
 {
 }
 
 KisStrokesQueue::~KisStrokesQueue()
 {
     Q_FOREACH (KisStrokeSP stroke, m_d->strokesQueue) {
         stroke->cancelStroke();
     }
 
     delete m_d;
 }
 
 template <class StrokePair, class StrokesQueue>
 typename StrokesQueue::iterator
 executeStrokePair(const StrokePair &pair, StrokesQueue &queue, typename StrokesQueue::iterator it, KisStroke::Type type, int levelOfDetail, KisStrokesQueueMutatedJobInterface *mutatedJobsInterface) {
     KisStrokeStrategy *strategy = pair.first;
     QList<KisStrokeJobData*> jobsData = pair.second;
 
     KisStrokeSP stroke(new KisStroke(strategy, type, levelOfDetail));
     strategy->setCancelStrokeId(stroke);
     strategy->setMutatedJobsInterface(mutatedJobsInterface);
     it = queue.insert(it, stroke);
     Q_FOREACH (KisStrokeJobData *jobData, jobsData) {
         stroke->addJob(jobData);
     }
     stroke->endStroke();
 
     return it;
 }
 
 void KisStrokesQueue::Private::startLod0ToNStroke(int levelOfDetail, bool forgettable)
 {
     // precondition: lock held!
     // precondition: lod > 0
     KIS_ASSERT_RECOVER_RETURN(levelOfDetail);
 
     if (!this->lod0ToNStrokeStrategyFactory) return;
 
     KisLodSyncPair syncPair = this->lod0ToNStrokeStrategyFactory(forgettable);
     executeStrokePair(syncPair, this->strokesQueue, this->strokesQueue.end(),  KisStroke::LODN, levelOfDetail, q);
 
     this->lodNNeedsSynchronization = false;
 }
 
 void KisStrokesQueue::Private::cancelForgettableStrokes()
 {
     if (!strokesQueue.isEmpty() && !hasUnfinishedStrokes()) {
         Q_FOREACH (KisStrokeSP stroke, strokesQueue) {
             KIS_ASSERT_RECOVER_NOOP(stroke->isEnded());
 
             if (stroke->canForgetAboutMe()) {
                 stroke->cancelStroke();
             }
         }
     }
 }
 
 bool KisStrokesQueue::Private::canUseLodN() const
 {
     Q_FOREACH (KisStrokeSP stroke, strokesQueue) {
         if (stroke->type() == KisStroke::LEGACY) {
             return false;
         }
     }
 
     return true;
 }
 
 bool KisStrokesQueue::Private::shouldWrapInSuspendUpdatesStroke() const
 {
     Q_FOREACH (KisStrokeSP stroke, strokesQueue) {
         if (stroke->isCancelled()) continue;
 
         if (stroke->type() == KisStroke::RESUME) {
-
-            /**
-             * Resuming process is long-running and consists of
-             * multiple actions, therefore, if it has already started,
-             * we cannot use it to guard our new stroke, so just skip it.
-             * see https://phabricator.kde.org/T2542
-             */
-            if (stroke->isInitialized()) continue;
-
             return false;
         }
     }
 
     return true;
 }
 
 StrokesQueueIterator KisStrokesQueue::Private::findNewLod0Pos()
 {
     StrokesQueueIterator it = strokesQueue.begin();
     StrokesQueueIterator end = strokesQueue.end();
 
     for (; it != end; ++it) {
         if ((*it)->isCancelled()) continue;
 
         if ((*it)->type() == KisStroke::RESUME) {
-            // \see a comment in shouldWrapInSuspendUpdatesStroke()
-            if ((*it)->isInitialized()) continue;
-
             return it;
         }
     }
 
     return it;
 }
 
 StrokesQueueIterator KisStrokesQueue::Private::findNewLodNPos(KisStrokeSP lodN)
 {
     StrokesQueueIterator it = strokesQueue.begin();
     StrokesQueueIterator end = strokesQueue.end();
 
     for (; it != end; ++it) {
         if ((*it)->isCancelled()) continue;
 
-        if (((*it)->type() == KisStroke::SUSPEND ||
-             (*it)->type() == KisStroke::RESUME) &&
-            (*it)->isInitialized()) {
-
-            // \see a comment in shouldWrapInSuspendUpdatesStroke()
-            continue;
-        }
-
         if ((*it)->type() == KisStroke::LOD0 ||
             (*it)->type() == KisStroke::SUSPEND ||
             (*it)->type() == KisStroke::RESUME) {
 
             if (it != end && it == strokesQueue.begin()) {
                 KisStrokeSP head = *it;
 
                 if (head->supportsSuspension()) {
                     head->suspendStroke(lodN);
                 }
             }
 
             return it;
         }
     }
 
     return it;
 }
 
 KisStrokeId KisStrokesQueue::startLodNUndoStroke(KisStrokeStrategy *strokeStrategy)
 {
     QMutexLocker locker(&m_d->mutex);
 
     KIS_SAFE_ASSERT_RECOVER_NOOP(!m_d->lodNNeedsSynchronization);
     KIS_SAFE_ASSERT_RECOVER_NOOP(m_d->desiredLevelOfDetail > 0);
 
     KisStrokeSP buddy(new KisStroke(strokeStrategy, KisStroke::LODN, m_d->desiredLevelOfDetail));
     strokeStrategy->setCancelStrokeId(buddy);
     strokeStrategy->setMutatedJobsInterface(this);
     m_d->strokesQueue.insert(m_d->findNewLodNPos(buddy), buddy);
 
     KisStrokeId id(buddy);
     m_d->openedStrokesCounter++;
 
     return id;
 }
 
 KisStrokeId KisStrokesQueue::startStroke(KisStrokeStrategy *strokeStrategy)
 {
     QMutexLocker locker(&m_d->mutex);
 
     KisStrokeSP stroke;
     KisStrokeStrategy* lodBuddyStrategy;
 
     m_d->cancelForgettableStrokes();
 
     if (m_d->desiredLevelOfDetail &&
         m_d->canUseLodN() &&
         (lodBuddyStrategy =
          strokeStrategy->createLodClone(m_d->desiredLevelOfDetail))) {
 
         if (m_d->lodNNeedsSynchronization) {
             m_d->startLod0ToNStroke(m_d->desiredLevelOfDetail, false);
         }
 
         stroke = KisStrokeSP(new KisStroke(strokeStrategy, KisStroke::LOD0, 0));
 
         KisStrokeSP buddy(new KisStroke(lodBuddyStrategy, KisStroke::LODN, m_d->desiredLevelOfDetail));
         lodBuddyStrategy->setCancelStrokeId(buddy);
         lodBuddyStrategy->setMutatedJobsInterface(this);
         stroke->setLodBuddy(buddy);
         m_d->strokesQueue.insert(m_d->findNewLodNPos(buddy), buddy);
 
         if (m_d->shouldWrapInSuspendUpdatesStroke()) {
 
             KisSuspendResumePair suspendPair = m_d->suspendUpdatesStrokeStrategyFactory();
             KisSuspendResumePair resumePair = m_d->resumeUpdatesStrokeStrategyFactory();
 
             StrokesQueueIterator it = m_d->findNewLod0Pos();
 
             it = executeStrokePair(resumePair, m_d->strokesQueue, it, KisStroke::RESUME, 0, this);
             it = m_d->strokesQueue.insert(it, stroke);
             it = executeStrokePair(suspendPair, m_d->strokesQueue, it, KisStroke::SUSPEND, 0, this);
 
         } else {
             m_d->strokesQueue.insert(m_d->findNewLod0Pos(), stroke);
         }
 
     } else {
         stroke = KisStrokeSP(new KisStroke(strokeStrategy, KisStroke::LEGACY, 0));
         m_d->strokesQueue.enqueue(stroke);
     }
 
     KisStrokeId id(stroke);
     strokeStrategy->setCancelStrokeId(id);
     strokeStrategy->setMutatedJobsInterface(this);
 
     m_d->openedStrokesCounter++;
 
     if (stroke->type() == KisStroke::LEGACY) {
         m_d->lodNNeedsSynchronization = true;
     }
 
     return id;
 }
 
 void KisStrokesQueue::addJob(KisStrokeId id, KisStrokeJobData *data)
 {
     QMutexLocker locker(&m_d->mutex);
 
     KisStrokeSP stroke = id.toStrongRef();
     KIS_SAFE_ASSERT_RECOVER_RETURN(stroke);
 
     KisStrokeSP buddy = stroke->lodBuddy();
     if (buddy) {
         KisStrokeJobData *clonedData =
             data->createLodClone(buddy->worksOnLevelOfDetail());
         KIS_ASSERT_RECOVER_RETURN(clonedData);
 
         buddy->addJob(clonedData);
     }
 
     stroke->addJob(data);
 }
 
 void KisStrokesQueue::addMutatedJobs(KisStrokeId id, const QVector<KisStrokeJobData *> list)
 {
     QMutexLocker locker(&m_d->mutex);
 
     KisStrokeSP stroke = id.toStrongRef();
     KIS_SAFE_ASSERT_RECOVER_RETURN(stroke);
 
     stroke->addMutatedJobs(list);
 }
 
 void KisStrokesQueue::endStroke(KisStrokeId id)
 {
     QMutexLocker locker(&m_d->mutex);
 
     KisStrokeSP stroke = id.toStrongRef();
     KIS_SAFE_ASSERT_RECOVER_RETURN(stroke);
     stroke->endStroke();
     m_d->openedStrokesCounter--;
 
     KisStrokeSP buddy = stroke->lodBuddy();
     if (buddy) {
         buddy->endStroke();
     }
 }
 
 bool KisStrokesQueue::cancelStroke(KisStrokeId id)
 {
     QMutexLocker locker(&m_d->mutex);
 
     KisStrokeSP stroke = id.toStrongRef();
     if(stroke) {
         stroke->cancelStroke();
         m_d->openedStrokesCounter--;
 
         KisStrokeSP buddy = stroke->lodBuddy();
         if (buddy) {
             buddy->cancelStroke();
         }
     }
     return stroke;
 }
 
 bool KisStrokesQueue::Private::hasUnfinishedStrokes() const
 {
     Q_FOREACH (KisStrokeSP stroke, strokesQueue) {
         if (!stroke->isEnded()) {
             return true;
         }
     }
 
     return false;
 }
 
 bool KisStrokesQueue::tryCancelCurrentStrokeAsync()
 {
     bool anythingCanceled = false;
 
     QMutexLocker locker(&m_d->mutex);
 
     /**
      * We cancel only ended strokes. This is done to avoid
      * handling dangling pointers problem (KisStrokeId). The owner
      * of a stroke will cancel the stroke itself if needed.
      */
     if (!m_d->strokesQueue.isEmpty() &&
         !m_d->hasUnfinishedStrokes()) {
 
         anythingCanceled = true;
 
         Q_FOREACH (KisStrokeSP currentStroke, m_d->strokesQueue) {
             KIS_ASSERT_RECOVER_NOOP(currentStroke->isEnded());
 
             currentStroke->cancelStroke();
 
             // we shouldn't cancel buddies...
             if (currentStroke->type() == KisStroke::LOD0) {
                 /**
                  * If the buddy has already finished, we cannot undo it because
                  * it doesn't store any undo data. Therefore we just regenerate
                  * the LOD caches.
                  */
                 m_d->lodNNeedsSynchronization = true;
             }
 
         }
     }
 
     /**
      * NOTE: We do not touch the openedStrokesCounter here since
      *       we work with closed id's only here
      */
 
     return anythingCanceled;
 }
 
 UndoResult KisStrokesQueue::tryUndoLastStrokeAsync()
 {
     UndoResult result = UNDO_FAIL;
 
     QMutexLocker locker(&m_d->mutex);
 
     std::reverse_iterator<StrokesQueue::ConstIterator> it(m_d->strokesQueue.constEnd());
     std::reverse_iterator<StrokesQueue::ConstIterator> end(m_d->strokesQueue.constBegin());
 
     KisStrokeSP lastStroke;
     KisStrokeSP lastBuddy;
     bool buddyFound = false;
 
     for (; it != end; ++it) {
         if ((*it)->type() == KisStroke::LEGACY) {
             break;
         }
 
         if (!lastStroke && (*it)->type() == KisStroke::LOD0 && !(*it)->isCancelled()) {
             lastStroke = *it;
             lastBuddy = lastStroke->lodBuddy();
 
             KIS_SAFE_ASSERT_RECOVER(lastBuddy) {
                 lastStroke.clear();
                 lastBuddy.clear();
                 break;
             }
         }
 
         KIS_SAFE_ASSERT_RECOVER(!lastStroke || *it == lastBuddy || (*it)->type() != KisStroke::LODN) {
             lastStroke.clear();
             lastBuddy.clear();
             break;
         }
 
         if (lastStroke && *it == lastBuddy) {
             KIS_SAFE_ASSERT_RECOVER(lastBuddy->type() == KisStroke::LODN) {
                 lastStroke.clear();
                 lastBuddy.clear();
                 break;
             }
             buddyFound = true;
             break;
         }
     }
 
     if (!lastStroke) return UNDO_FAIL;
     if (!lastStroke->isEnded()) return UNDO_FAIL;
     if (lastStroke->isCancelled()) return UNDO_FAIL;
 
     KIS_SAFE_ASSERT_RECOVER_NOOP(!buddyFound ||
                                  lastStroke->isCancelled() == lastBuddy->isCancelled());
     KIS_SAFE_ASSERT_RECOVER_NOOP(lastBuddy->isEnded());
 
     if (!lastStroke->canCancel()) {
         return UNDO_WAIT;
     }
     lastStroke->cancelStroke();
 
     if (buddyFound && lastBuddy->canCancel()) {
         lastBuddy->cancelStroke();
     } else {
         // TODO: assert that checks that there is no other lodn strokes
         locker.unlock();
         m_d->lodNUndoStore.undo();
         m_d->lodNUndoStore.purgeRedoState();
         locker.relock();
     }
 
     result = UNDO_OK;
 
     return result;
 }
 
 void KisStrokesQueue::Private::tryClearUndoOnStrokeCompletion(KisStrokeSP finishingStroke)
 {
     if (finishingStroke->type() != KisStroke::RESUME) return;
 
     bool hasResumeStrokes = false;
     bool hasLod0Strokes = false;
 
     Q_FOREACH (KisStrokeSP stroke, strokesQueue) {
         if (stroke == finishingStroke) continue;
 
         hasLod0Strokes |= stroke->type() == KisStroke::LOD0;
         hasResumeStrokes |= stroke->type() == KisStroke::RESUME;
     }
 
     KIS_SAFE_ASSERT_RECOVER_NOOP(!hasLod0Strokes || hasResumeStrokes);
 
     if (!hasResumeStrokes && !hasLod0Strokes) {
         lodNUndoStore.clear();
     }
 }
 
 void KisStrokesQueue::processQueue(KisUpdaterContext &updaterContext,
                                    bool externalJobsPending)
 {
     updaterContext.lock();
     m_d->mutex.lock();
 
     while(updaterContext.hasSpareThread() &&
           processOneJob(updaterContext,
                         externalJobsPending));
 
     m_d->mutex.unlock();
     updaterContext.unlock();
 }
 
 bool KisStrokesQueue::needsExclusiveAccess() const
 {
     return m_d->needsExclusiveAccess;
 }
 
 bool KisStrokesQueue::wrapAroundModeSupported() const
 {
     return m_d->wrapAroundModeSupported;
 }
 
 qreal KisStrokesQueue::balancingRatioOverride() const
 {
     return m_d->balancingRatioOverride;
 }
 
 bool KisStrokesQueue::isEmpty() const
 {
     QMutexLocker locker(&m_d->mutex);
     return m_d->strokesQueue.isEmpty();
 }
 
 qint32 KisStrokesQueue::sizeMetric() const
 {
     QMutexLocker locker(&m_d->mutex);
     if(m_d->strokesQueue.isEmpty()) return 0;
 
     // just a rough approximation
     return qMax(1, m_d->strokesQueue.head()->numJobs()) * m_d->strokesQueue.size();
 }
 
 void KisStrokesQueue::Private::switchDesiredLevelOfDetail(bool forced)
 {
     if (forced || nextDesiredLevelOfDetail != desiredLevelOfDetail) {
         Q_FOREACH (KisStrokeSP stroke, strokesQueue) {
             if (stroke->type() != KisStroke::LEGACY)
                 return;
         }
 
         const bool forgettable =
             forced && !lodNNeedsSynchronization &&
             desiredLevelOfDetail == nextDesiredLevelOfDetail;
 
         desiredLevelOfDetail = nextDesiredLevelOfDetail;
         lodNNeedsSynchronization |= !forgettable;
 
         if (desiredLevelOfDetail) {
             startLod0ToNStroke(desiredLevelOfDetail, forgettable);
         }
     }
 }
 
 void KisStrokesQueue::explicitRegenerateLevelOfDetail()
 {
     QMutexLocker locker(&m_d->mutex);
     m_d->switchDesiredLevelOfDetail(true);
 }
 
 void KisStrokesQueue::setDesiredLevelOfDetail(int lod)
 {
     QMutexLocker locker(&m_d->mutex);
 
     if (lod == m_d->nextDesiredLevelOfDetail) return;
 
     m_d->nextDesiredLevelOfDetail = lod;
     m_d->switchDesiredLevelOfDetail(false);
 }
 
 void KisStrokesQueue::notifyUFOChangedImage()
 {
     QMutexLocker locker(&m_d->mutex);
 
     m_d->lodNNeedsSynchronization = true;
 }
 
 void KisStrokesQueue::debugDumpAllStrokes()
 {
     QMutexLocker locker(&m_d->mutex);
 
     qDebug() <<"===";
     Q_FOREACH (KisStrokeSP stroke, m_d->strokesQueue) {
         qDebug() << ppVar(stroke->name()) << ppVar(stroke->type()) << ppVar(stroke->numJobs()) << ppVar(stroke->isInitialized()) << ppVar(stroke->isCancelled());
     }
     qDebug() <<"===";
 }
 
 void KisStrokesQueue::setLod0ToNStrokeStrategyFactory(const KisLodSyncStrokeStrategyFactory &factory)
 {
     m_d->lod0ToNStrokeStrategyFactory = factory;
 }
 
 void KisStrokesQueue::setSuspendUpdatesStrokeStrategyFactory(const KisSuspendResumeStrategyFactory &factory)
 {
     m_d->suspendUpdatesStrokeStrategyFactory = factory;
 }
 
 void KisStrokesQueue::setResumeUpdatesStrokeStrategyFactory(const KisSuspendResumeStrategyFactory &factory)
 {
     m_d->resumeUpdatesStrokeStrategyFactory = factory;
 }
 
 KisPostExecutionUndoAdapter *KisStrokesQueue::lodNPostExecutionUndoAdapter() const
 {
     return &m_d->lodNPostExecutionUndoAdapter;
 }
 
 KUndo2MagicString KisStrokesQueue::currentStrokeName() const
 {
     QMutexLocker locker(&m_d->mutex);
     if(m_d->strokesQueue.isEmpty()) return KUndo2MagicString();
 
     return m_d->strokesQueue.head()->name();
 }
 
 bool KisStrokesQueue::hasOpenedStrokes() const
 {
     QMutexLocker locker(&m_d->mutex);
     return m_d->openedStrokesCounter;
 }
 
 bool KisStrokesQueue::processOneJob(KisUpdaterContext &updaterContext,
                                     bool externalJobsPending)
 {
     if(m_d->strokesQueue.isEmpty()) return false;
     bool result = false;
 
     const int levelOfDetail = updaterContext.currentLevelOfDetail();
 
     const KisUpdaterContextSnapshotEx snapshot = updaterContext.getContextSnapshotEx();
 
     const bool hasStrokeJobs = !(snapshot == ContextEmpty ||
                                  snapshot == HasMergeJob);
     const bool hasMergeJobs = snapshot & HasMergeJob;
 
     if(checkStrokeState(hasStrokeJobs, levelOfDetail) &&
        checkExclusiveProperty(hasMergeJobs, hasStrokeJobs) &&
        checkSequentialProperty(snapshot, externalJobsPending)) {
 
         KisStrokeSP stroke = m_d->strokesQueue.head();
         updaterContext.addStrokeJob(stroke->popOneJob());
         result = true;
     }
 
     return result;
 }
 
 bool KisStrokesQueue::checkStrokeState(bool hasStrokeJobsRunning,
                                        int runningLevelOfDetail)
 {
     KisStrokeSP stroke = m_d->strokesQueue.head();
     bool result = false;
 
     /**
      * We cannot start/continue a stroke if its LOD differs from
      * the one that is running on CPU
      */
     bool hasLodCompatibility = checkLevelOfDetailProperty(runningLevelOfDetail);
     bool hasJobs = stroke->hasJobs();
 
     /**
      * The stroke may be cancelled very fast. In this case it will
      * end up in the state:
      *
      * !stroke->isInitialized() && stroke->isEnded() && !stroke->hasJobs()
      *
      * This means that !isInitialised() doesn't imply there are any
      * jobs present.
      */
     if(!stroke->isInitialized() && hasJobs && hasLodCompatibility) {
         /**
          * It might happen that the stroke got initialized, but its job was not
          * started due to some other reasons like exclusivity. Therefore the
          * stroke might end up in loaded, but uninitialized state.
          */
         if (!m_d->currentStrokeLoaded) {
             m_d->needsExclusiveAccess = stroke->isExclusive();
             m_d->wrapAroundModeSupported = stroke->supportsWrapAroundMode();
             m_d->balancingRatioOverride = stroke->balancingRatioOverride();
             m_d->currentStrokeLoaded = true;
         }
 
         result = true;
     }
     else if(hasJobs && hasLodCompatibility) {
         /**
          * If the stroke has no initialization phase, then it can
          * arrive here unloaded.
          */
         if (!m_d->currentStrokeLoaded) {
             m_d->needsExclusiveAccess = stroke->isExclusive();
             m_d->wrapAroundModeSupported = stroke->supportsWrapAroundMode();
             m_d->balancingRatioOverride = stroke->balancingRatioOverride();
             m_d->currentStrokeLoaded = true;
         }
 
         result = true;
     }
     else if(stroke->isEnded() && !hasJobs && !hasStrokeJobsRunning) {
         m_d->tryClearUndoOnStrokeCompletion(stroke);
 
         m_d->strokesQueue.dequeue(); // deleted by shared pointer
         m_d->needsExclusiveAccess = false;
         m_d->wrapAroundModeSupported = false;
         m_d->balancingRatioOverride = -1.0;
         m_d->currentStrokeLoaded = false;
 
         m_d->switchDesiredLevelOfDetail(false);
 
         if(!m_d->strokesQueue.isEmpty()) {
             result = checkStrokeState(false, runningLevelOfDetail);
         }
     }
 
     return result;
 }
 
 bool KisStrokesQueue::checkExclusiveProperty(bool hasMergeJobs,
                                              bool hasStrokeJobs)
 {
     Q_UNUSED(hasStrokeJobs);
 
     if(!m_d->strokesQueue.head()->isExclusive()) return true;
     return hasMergeJobs == 0;
 }
 
 bool KisStrokesQueue::checkSequentialProperty(KisUpdaterContextSnapshotEx snapshot,
                                               bool externalJobsPending)
 {
     KisStrokeSP stroke = m_d->strokesQueue.head();
 
     if (snapshot & HasSequentialJob ||
         snapshot & HasBarrierJob) {
         return false;
     }
 
     KisStrokeJobData::Sequentiality nextSequentiality =
         stroke->nextJobSequentiality();
 
     if (nextSequentiality == KisStrokeJobData::UNIQUELY_CONCURRENT &&
         snapshot & HasUniquelyConcurrentJob) {
 
         return false;
     }
 
     if (nextSequentiality == KisStrokeJobData::SEQUENTIAL &&
         (snapshot & HasUniquelyConcurrentJob ||
          snapshot & HasConcurrentJob)) {
 
         return false;
     }
 
     if (nextSequentiality == KisStrokeJobData::BARRIER &&
         (snapshot & HasUniquelyConcurrentJob ||
          snapshot & HasConcurrentJob ||
          snapshot & HasMergeJob ||
          externalJobsPending)) {
 
         return false;
     }
 
     return true;
 }
 
 bool KisStrokesQueue::checkLevelOfDetailProperty(int runningLevelOfDetail)
 {
     KisStrokeSP stroke = m_d->strokesQueue.head();
 
     return runningLevelOfDetail < 0 ||
         stroke->worksOnLevelOfDetail() == runningLevelOfDetail;
 }
diff --git a/libs/image/kis_suspend_projection_updates_stroke_strategy.cpp b/libs/image/kis_suspend_projection_updates_stroke_strategy.cpp
index bf6b36bbf9..4f65953cb3 100644
--- a/libs/image/kis_suspend_projection_updates_stroke_strategy.cpp
+++ b/libs/image/kis_suspend_projection_updates_stroke_strategy.cpp
@@ -1,323 +1,529 @@
 /*
  *  Copyright (c) 2014 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_suspend_projection_updates_stroke_strategy.h"
 
 #include <kis_image.h>
 #include <krita_utils.h>
 #include <kis_projection_updates_filter.h>
 #include "kis_image_signal_router.h"
 
+#include "kundo2command.h"
+#include "KisRunnableStrokeJobDataBase.h"
+#include "KisRunnableStrokeJobsInterface.h"
+#include "kis_paintop_utils.h"
+
 
 inline uint qHash(const QRect &rc) {
     return rc.x() +
         (rc.y() << 16) +
         (rc.width() << 8) +
         (rc.height() << 24);
 }
 
 struct KisSuspendProjectionUpdatesStrokeStrategy::Private
 {
     KisImageWSP image;
     bool suspend;
+    QVector<QRect> accumulatedDirtyRects;
+    bool sanityResumingFinished = false;
+    int updatesEpoch = 0;
+    bool haveDisabledGUILodSync = false;
+
+    void tryFetchUsedUpdatesFilter(KisImageSP image);
+    void tryIssueRecordedDirtyRequests(KisImageSP image);
 
     class SuspendLod0Updates : public KisProjectionUpdatesFilter
     {
 
         struct Request {
             Request() : resetAnimationCache(false) {}
             Request(const QRect &_rect, bool _resetAnimationCache)
                 : rect(_rect), resetAnimationCache(_resetAnimationCache)
             {
             }
 
             QRect rect;
             bool resetAnimationCache;
         };
 
         typedef QHash<KisNodeSP, QVector<Request> > RectsHash;
     public:
         SuspendLod0Updates()
         {
         }
 
         bool filter(KisImage *image, KisNode *node, const QVector<QRect> &rects,  bool resetAnimationCache) override {
             if (image->currentLevelOfDetail() > 0) return false;
 
             QMutexLocker l(&m_mutex);
 
             Q_FOREACH(const QRect &rc, rects) {
                 m_requestsHash[KisNodeSP(node)].append(Request(rc, resetAnimationCache));
             }
 
             return true;
         }
 
         static inline QRect alignRect(const QRect &rc, const int step) {
             static const int decstep = step - 1;
             static const int invstep = ~decstep;
 
             int x0, y0, x1, y1;
             rc.getCoords(&x0, &y0, &x1, &y1);
 
             x0 &= invstep;
             y0 &= invstep;
             x1 |= decstep;
             y1 |= decstep;
 
             QRect result;
             result.setCoords(x0, y0, x1, y1);
             return result;
         }
 
         void notifyUpdates(KisNodeGraphListener *listener) {
             RectsHash::const_iterator it = m_requestsHash.constBegin();
             RectsHash::const_iterator end = m_requestsHash.constEnd();
 
             const int step = 64;
 
             for (; it != end; ++it) {
                 KisNodeSP node = it.key();
 
                 QRegion region;
 
                 bool resetAnimationCache = false;
                 Q_FOREACH (const Request &req, it.value()) {
                     region += alignRect(req.rect, step);
                     resetAnimationCache |= req.resetAnimationCache;
                 }
 
                 // FIXME: constness: port rPU to SP
                 listener->requestProjectionUpdate(const_cast<KisNode*>(node.data()), region.rects(), resetAnimationCache);
             }
         }
 
     private:
         RectsHash m_requestsHash;
         QMutex m_mutex;
     };
 
+    QVector<QSharedPointer<SuspendLod0Updates>> usedFilters;
+
+
+    struct StrokeJobCommand : public KUndo2Command
+    {
+        StrokeJobCommand(KisStrokeJobData::Sequentiality sequentiality = KisStrokeJobData::SEQUENTIAL,
+                         KisStrokeJobData::Exclusivity exclusivity = KisStrokeJobData::NORMAL)
+            : m_sequentiality(sequentiality),
+              m_exclusivity(exclusivity)
+        {}
+
+        KisStrokeJobData::Sequentiality m_sequentiality;
+        KisStrokeJobData::Exclusivity m_exclusivity;
+    };
+
+    struct UndoableData : public KisRunnableStrokeJobDataBase
+    {
+        UndoableData(StrokeJobCommand *command)
+            : KisRunnableStrokeJobDataBase(command->m_sequentiality, command->m_exclusivity),
+              m_command(command)
+        {
+        }
+
+        void run() override {
+            KIS_SAFE_ASSERT_RECOVER_RETURN(m_command);
+            m_command->redo();
+        }
+
+        QScopedPointer<StrokeJobCommand> m_command;
+    };
+
     // Suspend job should be a barrier to ensure all
     // previous lodN strokes reach the GUI. Otherwise,
     // they will be blocked in
     // KisImage::notifyProjectionUpdated()
-    class SuspendData : public KisStrokeJobData {
-    public:
-        SuspendData()
-            : KisStrokeJobData(BARRIER)
-            {}
+    struct SuspendUpdatesCommand : public StrokeJobCommand
+    {
+        SuspendUpdatesCommand(Private *d)
+            : StrokeJobCommand(KisStrokeJobData::BARRIER),
+              m_d(d) {}
+
+        void redo() override {
+            KisImageSP image = m_d->image.toStrongRef();
+            KIS_SAFE_ASSERT_RECOVER_RETURN(image);
+            KIS_SAFE_ASSERT_RECOVER_RETURN(!image->projectionUpdatesFilter());
+
+            image->setProjectionUpdatesFilter(
+                KisProjectionUpdatesFilterSP(new Private::SuspendLod0Updates()));
+        }
+
+
+        void undo() override {
+            KisImageSP image = m_d->image.toStrongRef();
+            KIS_SAFE_ASSERT_RECOVER_RETURN(image);
+            KIS_SAFE_ASSERT_RECOVER_RETURN(image->projectionUpdatesFilter());
+
+            m_d->tryFetchUsedUpdatesFilter(image);
+        }
+
+        Private *m_d;
     };
 
-    class ResumeAndIssueGraphUpdatesData : public KisStrokeJobData {
-    public:
-        ResumeAndIssueGraphUpdatesData()
-            : KisStrokeJobData(SEQUENTIAL)
-            {}
+
+    struct ResumeAndIssueGraphUpdatesCommand : public StrokeJobCommand
+    {
+        ResumeAndIssueGraphUpdatesCommand(Private *d)
+            : StrokeJobCommand(KisStrokeJobData::BARRIER),
+              m_d(d) {}
+
+        void redo() override {
+            KisImageSP image = m_d->image.toStrongRef();
+            KIS_SAFE_ASSERT_RECOVER_RETURN(image);
+            KIS_SAFE_ASSERT_RECOVER_RETURN(image->projectionUpdatesFilter());
+
+            image->disableUIUpdates();
+            m_d->tryFetchUsedUpdatesFilter(image);
+            m_d->tryIssueRecordedDirtyRequests(image);
+        }
+
+        void undo() override {
+            KisImageSP image = m_d->image.toStrongRef();
+            KIS_SAFE_ASSERT_RECOVER_RETURN(image);
+            KIS_SAFE_ASSERT_RECOVER_RETURN(!image->projectionUpdatesFilter());
+
+            image->setProjectionUpdatesFilter(
+                KisProjectionUpdatesFilterSP(new Private::SuspendLod0Updates()));
+            image->enableUIUpdates();
+        }
+
+        Private *m_d;
     };
 
-    class StartBatchUpdate : public KisStrokeJobData {
-    public:
-        StartBatchUpdate()
-            : KisStrokeJobData(BARRIER)
-            {}
+    struct UploadDataToUIData : public KisRunnableStrokeJobDataBase
+    {
+        UploadDataToUIData(const QRect &rc, int updateEpoch, KisSuspendProjectionUpdatesStrokeStrategy *strategy)
+            : KisRunnableStrokeJobDataBase(KisStrokeJobData::CONCURRENT),
+              m_strategy(strategy),
+              m_rc(rc),
+              m_updateEpoch(updateEpoch)
+        {
+        }
+
+        void run() override {
+            // check if we've already started stinking...
+            if (m_strategy->m_d->updatesEpoch > m_updateEpoch) {
+                return;
+            }
+
+            KisImageSP image = m_strategy->m_d->image.toStrongRef();
+            KIS_SAFE_ASSERT_RECOVER_RETURN(image);
+
+            image->notifyProjectionUpdated(m_rc);
+        }
+
+        KisSuspendProjectionUpdatesStrokeStrategy *m_strategy;
+        QRect m_rc;
+        int m_updateEpoch;
     };
 
-    class EndBatchUpdate : public KisStrokeJobData {
-    public:
-        EndBatchUpdate()
-            : KisStrokeJobData(BARRIER)
-            {}
+    struct BlockUILodSync : public KisRunnableStrokeJobDataBase
+    {
+        BlockUILodSync(bool block, KisSuspendProjectionUpdatesStrokeStrategy *strategy)
+            : KisRunnableStrokeJobDataBase(KisStrokeJobData::BARRIER),
+              m_strategy(strategy),
+              m_block(block)
+        {}
+
+        void run() override {
+            KisImageSP image = m_strategy->m_d->image.toStrongRef();
+            KIS_SAFE_ASSERT_RECOVER_RETURN(image);
+
+            image->signalRouter()->emitRequestLodPlanesSyncBlocked(m_block);
+            m_strategy->m_d->haveDisabledGUILodSync = m_block;
+        }
+
+        KisSuspendProjectionUpdatesStrokeStrategy *m_strategy;
+        bool m_block;
     };
 
-    class IssueCanvasUpdatesData : public KisStrokeJobData {
-    public:
-        IssueCanvasUpdatesData(QRect _updateRect)
-            : KisStrokeJobData(CONCURRENT),
-              updateRect(_updateRect)
-            {}
-        QRect updateRect;
+    struct StartBatchUIUpdatesCommand : public StrokeJobCommand
+    {
+        StartBatchUIUpdatesCommand(KisSuspendProjectionUpdatesStrokeStrategy *strategy)
+            : StrokeJobCommand(KisStrokeJobData::BARRIER),
+              m_strategy(strategy) {}
+
+        void redo() override {
+            KisImageSP image = m_strategy->m_d->image.toStrongRef();
+            KIS_SAFE_ASSERT_RECOVER_RETURN(image);
+
+            /**
+             * We accumulate dirty rects from all(!) epochs, because some updates of the
+             * previous epochs might have been cancelled without doing any real work.
+             */
+            const QVector<QRect> totalDirtyRects =
+                image->enableUIUpdates() + m_strategy->m_d->accumulatedDirtyRects;
+
+            const QRect totalRect =
+                image->bounds() &
+                std::accumulate(totalDirtyRects.begin(), totalDirtyRects.end(), QRect(), std::bit_or<QRect>());
+
+            m_strategy->m_d->accumulatedDirtyRects =
+                KisPaintOpUtils::splitAndFilterDabRect(totalRect,
+                                                       totalDirtyRects,
+                                                       KritaUtils::optimalPatchSize().width());
+
+            image->signalRouter()->emitNotifyBatchUpdateStarted();
+
+            QVector<KisRunnableStrokeJobDataBase*> jobsData;
+            Q_FOREACH (const QRect &rc, m_strategy->m_d->accumulatedDirtyRects) {
+                jobsData << new Private::UploadDataToUIData(rc, m_strategy->m_d->updatesEpoch, m_strategy);
+            }
+
+            m_strategy->runnableJobsInterface()->addRunnableJobs(jobsData);
+
+        }
+
+        void undo() override {
+            KisImageSP image = m_strategy->m_d->image.toStrongRef();
+            KIS_SAFE_ASSERT_RECOVER_RETURN(image);
+
+            image->signalRouter()->emitNotifyBatchUpdateEnded();
+            image->disableUIUpdates();
+        }
+
+        KisSuspendProjectionUpdatesStrokeStrategy *m_strategy;
     };
+
+    struct EndBatchUIUpdatesCommand : public StrokeJobCommand
+    {
+        EndBatchUIUpdatesCommand(KisSuspendProjectionUpdatesStrokeStrategy *strategy)
+            : StrokeJobCommand(KisStrokeJobData::BARRIER),
+              m_strategy(strategy) {}
+
+        void redo() override {
+            KisImageSP image = m_strategy->m_d->image.toStrongRef();
+            KIS_SAFE_ASSERT_RECOVER_RETURN(image);
+
+            image->signalRouter()->emitNotifyBatchUpdateEnded();
+            m_strategy->m_d->sanityResumingFinished = true;
+        }
+
+        void undo() override {
+            KIS_SAFE_ASSERT_RECOVER_NOOP(0 && "why the heck we are undoing the last job of the stroke?!");
+
+            m_strategy->m_d->sanityResumingFinished = false;
+
+            KisImageSP image = m_strategy->m_d->image.toStrongRef();
+            KIS_SAFE_ASSERT_RECOVER_RETURN(image);
+
+            image->signalRouter()->emitNotifyBatchUpdateStarted();
+        }
+
+        KisSuspendProjectionUpdatesStrokeStrategy *m_strategy;
+    };
+
+
+    QVector<StrokeJobCommand*> executedCommands;
 };
 
 KisSuspendProjectionUpdatesStrokeStrategy::KisSuspendProjectionUpdatesStrokeStrategy(KisImageWSP image, bool suspend)
-    : KisSimpleStrokeStrategy(suspend ? "suspend_stroke_strategy" : "resume_stroke_strategy"),
+    : KisRunnableBasedStrokeStrategy(suspend ? "suspend_stroke_strategy" : "resume_stroke_strategy"),
       m_d(new Private)
 {
     m_d->image = image;
     m_d->suspend = suspend;
 
 
     /**
      * Here we add a dumb INIT job so that KisStrokesQueue would know that the
      * stroke has already started or not. When the queue reaches the resume
      * stroke and starts its execution, no Lod0 can execute anymore. So all the
      * new Lod0 strokes should go to the end of the queue and wrapped into
      * their own Suspend/Resume pair.
      */
     enableJob(JOB_INIT, true);
 
     enableJob(JOB_DOSTROKE, true);
     enableJob(JOB_CANCEL, true);
 
+    enableJob(JOB_SUSPEND, true, KisStrokeJobData::BARRIER);
+    enableJob(JOB_RESUME, true, KisStrokeJobData::BARRIER);
+
     setNeedsExplicitCancel(true);
 }
 
 KisSuspendProjectionUpdatesStrokeStrategy::~KisSuspendProjectionUpdatesStrokeStrategy()
 {
+    qDeleteAll(m_d->executedCommands);
+}
+
+void KisSuspendProjectionUpdatesStrokeStrategy::initStrokeCallback()
+{
+    QVector<KisRunnableStrokeJobDataBase*> jobs;
+
+    if (m_d->suspend) {
+        jobs << new Private::UndoableData(new Private::SuspendUpdatesCommand(m_d.data()));
+    } else {
+        jobs << new Private::UndoableData(new Private::ResumeAndIssueGraphUpdatesCommand(m_d.data()));
+        jobs << new Private::BlockUILodSync(true, this);
+        jobs << new Private::UndoableData(new Private::StartBatchUIUpdatesCommand(this));
+        jobs << new Private::UndoableData(new Private::EndBatchUIUpdatesCommand(this));
+        jobs << new Private::BlockUILodSync(false, this);
+    }
+
+    runnableJobsInterface()->addRunnableJobs(jobs);
 }
 
 /**
  * When the Lod0 stroke is being recalculated in the background we
  * should block all the updates it issues to avoid user distraction.
  * The result of the final stroke should be shown to the user in the
  * very end when everything is fully ready. Ideally the use should not
  * notice that the image has changed :)
  *
  * (Don't mix this process with suspend/resume capabilities of a
  * single stroke. That is a different system!)
  *
  * The process of the Lod0 regeneration consists of the following:
  *
  * 1) Suspend stroke executes. It sets a special updates filter on the
  *    image. The filter blocks all the updates and saves them in an
  *    internal structure to be emitted in the future.
  *
  * 2) Lod0 strokes are being recalculated. All their updates are
  *    blocked and saved in the filter.
  *
  * 3) Resume stroke starts:
  *
  *     3.1) First it disables emitting of sigImageUpdated() so the gui
  *          will not get any update notifications.
  *
  *     3.2) Then it enables updates themselves.
  *
  *     3.3) Initiates all the updates that were requested by the Lod0
  *          stroke. The node graph is regenerated, but the GUI does
  *          not get this change.
  *
  *     3.4) Special barrier job waits for all the updates to finish
  *          and, when they are done, enables GUI notifications again.
  *
  *     3.5) In a multithreaded way emits the GUI notifications for the
  *          entire image. Multithreaded way is used to conform the
  *          double-stage update principle of KisCanvas2.
  */
-
 void KisSuspendProjectionUpdatesStrokeStrategy::doStrokeCallback(KisStrokeJobData *data)
 {
-    Private::SuspendData *suspendData = dynamic_cast<Private::SuspendData*>(data);
-    Private::ResumeAndIssueGraphUpdatesData *resumeData = dynamic_cast<Private::ResumeAndIssueGraphUpdatesData*>(data);
-    Private::StartBatchUpdate *startBatchData = dynamic_cast<Private::StartBatchUpdate*>(data);
-    Private::EndBatchUpdate *endBatchData = dynamic_cast<Private::EndBatchUpdate*>(data);
-    Private::IssueCanvasUpdatesData *canvasUpdates = dynamic_cast<Private::IssueCanvasUpdatesData*>(data);
-
-    KisImageSP image = m_d->image.toStrongRef();
-    if (!image) {
-        return;
-    }
+    KisRunnableStrokeJobDataBase *runnable = dynamic_cast<KisRunnableStrokeJobDataBase*>(data);
+    if (runnable) {
+        runnable->run();
 
-    if (suspendData) {
-        image->setProjectionUpdatesFilter(
-            KisProjectionUpdatesFilterSP(new Private::SuspendLod0Updates()));
-    } else if (resumeData) {
-        image->disableUIUpdates();
-        resumeAndIssueUpdates(false);
-    } else if (startBatchData) {
-        image->enableUIUpdates();
-        image->signalRouter()->emitBeginLodResetUpdatesBatch();
-    } else if (canvasUpdates) {
-        image->notifyProjectionUpdated(canvasUpdates->updateRect);
-    } else if (endBatchData) {
-        image->signalRouter()->emitEndLodResetUpdatesBatch();
+        if (Private::UndoableData *undoable = dynamic_cast<Private::UndoableData*>(data)) {
+            Private::StrokeJobCommand *command =  undoable->m_command.take();
+            m_d->executedCommands.append(command);
+        }
     }
 }
 
 QList<KisStrokeJobData*> KisSuspendProjectionUpdatesStrokeStrategy::createSuspendJobsData(KisImageWSP /*image*/)
 {
-    QList<KisStrokeJobData*> jobsData;
-    jobsData << new Private::SuspendData();
-    return jobsData;
+    return QList<KisStrokeJobData*>();
 }
 
-QList<KisStrokeJobData*> KisSuspendProjectionUpdatesStrokeStrategy::createResumeJobsData(KisImageWSP _image)
+QList<KisStrokeJobData*> KisSuspendProjectionUpdatesStrokeStrategy::createResumeJobsData(KisImageWSP /*_image*/)
 {
-    QList<KisStrokeJobData*> jobsData;
-
-    jobsData << new Private::ResumeAndIssueGraphUpdatesData();
-    jobsData << new Private::StartBatchUpdate();
-
-    using KritaUtils::splitRectIntoPatches;
-    using KritaUtils::optimalPatchSize;
-    KisImageSP image = _image;
-
-    QVector<QRect> rects = splitRectIntoPatches(image->bounds(), optimalPatchSize());
-    Q_FOREACH (const QRect &rc, rects) {
-        jobsData << new Private::IssueCanvasUpdatesData(rc);
-    }
-
-    jobsData << new Private::EndBatchUpdate();
-
-    return jobsData;
+    return QList<KisStrokeJobData*>();
 }
 
-void KisSuspendProjectionUpdatesStrokeStrategy::resumeAndIssueUpdates(bool dropUpdates)
+void KisSuspendProjectionUpdatesStrokeStrategy::Private::tryFetchUsedUpdatesFilter(KisImageSP image)
 {
-    KisImageSP image = m_d->image.toStrongRef();
-    if (!image) {
-        return;
-    }
-
     KisProjectionUpdatesFilterSP filter =
         image->projectionUpdatesFilter();
 
     if (!filter) return;
 
-    Private::SuspendLod0Updates *localFilter =
-        dynamic_cast<Private::SuspendLod0Updates*>(filter.data());
+    QSharedPointer<Private::SuspendLod0Updates> localFilter =
+        filter.dynamicCast<Private::SuspendLod0Updates>();
 
     if (localFilter) {
         image->setProjectionUpdatesFilter(KisProjectionUpdatesFilterSP());
+        this->usedFilters.append(localFilter);
+    }
+}
 
-        if (!dropUpdates) {
-            localFilter->notifyUpdates(image.data());
-        }
+void KisSuspendProjectionUpdatesStrokeStrategy::Private::tryIssueRecordedDirtyRequests(KisImageSP image)
+{
+    Q_FOREACH (QSharedPointer<Private::SuspendLod0Updates> filter, usedFilters) {
+        filter->notifyUpdates(image.data());
     }
 }
 
 void KisSuspendProjectionUpdatesStrokeStrategy::cancelStrokeCallback()
 {
     KisImageSP image = m_d->image.toStrongRef();
     if (!image) {
         return;
     }
 
+    for (auto it = m_d->executedCommands.rbegin(); it != m_d->executedCommands.rend(); ++it) {
+        (*it)->undo();
+    }
+
+    m_d->tryFetchUsedUpdatesFilter(image);
+
+    if (m_d->haveDisabledGUILodSync) {
+        image->signalRouter()->emitRequestLodPlanesSyncBlocked(false);
+    }
+
     /**
      * We shouldn't emit any ad-hoc updates when cancelling the
      * stroke.  It generates weird temporary holes on the canvas,
      * making the user feel awful, thinking his image got
      * corrupted. We will just emit a common refreshGraphAsync() that
      * will do all the work in a beautiful way
      */
-    resumeAndIssueUpdates(true);
-
     if (!m_d->suspend) {
         // FIXME: optimize
         image->refreshGraphAsync();
     }
 }
+
+void KisSuspendProjectionUpdatesStrokeStrategy::suspendStrokeCallback()
+{
+    KIS_SAFE_ASSERT_RECOVER_NOOP(m_d->suspend || !m_d->sanityResumingFinished);
+
+    for (auto it = m_d->executedCommands.rbegin(); it != m_d->executedCommands.rend(); ++it) {
+        (*it)->undo();
+    }
+
+    // reset all the issued updates
+    m_d->updatesEpoch++;
+}
+
+void KisSuspendProjectionUpdatesStrokeStrategy::resumeStrokeCallback()
+{
+    QVector<KisRunnableStrokeJobDataBase*> jobs;
+
+    Q_FOREACH (Private::StrokeJobCommand *command, m_d->executedCommands) {
+        jobs << new Private::UndoableData(command);
+    }
+    m_d->executedCommands.clear();
+
+    runnableJobsInterface()->addRunnableJobs(jobs);
+}
diff --git a/libs/image/kis_suspend_projection_updates_stroke_strategy.h b/libs/image/kis_suspend_projection_updates_stroke_strategy.h
index 1cc30bc0b3..be82a2a5eb 100644
--- a/libs/image/kis_suspend_projection_updates_stroke_strategy.h
+++ b/libs/image/kis_suspend_projection_updates_stroke_strategy.h
@@ -1,46 +1,51 @@
 /*
  *  Copyright (c) 2014 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KIS_SUSPEND_PROJECTION_UPDATES_STROKE_STRATEGY_H
 #define __KIS_SUSPEND_PROJECTION_UPDATES_STROKE_STRATEGY_H
 
-#include <kis_simple_stroke_strategy.h>
+#include <KisRunnableBasedStrokeStrategy.h>
 
 #include <QScopedPointer>
 
-class KisSuspendProjectionUpdatesStrokeStrategy : public KisSimpleStrokeStrategy
+class KisSuspendProjectionUpdatesStrokeStrategy : public KisRunnableBasedStrokeStrategy
 {
 public:
     KisSuspendProjectionUpdatesStrokeStrategy(KisImageWSP image, bool suspend);
     ~KisSuspendProjectionUpdatesStrokeStrategy() override;
 
     static QList<KisStrokeJobData*> createSuspendJobsData(KisImageWSP image);
     static QList<KisStrokeJobData*> createResumeJobsData(KisImageWSP image);
 
 private:
+    void initStrokeCallback() override;
     void doStrokeCallback(KisStrokeJobData *data) override;
     void cancelStrokeCallback() override;
 
+    void suspendStrokeCallback() override;
+    void resumeStrokeCallback() override;
+
+
     void resumeAndIssueUpdates(bool dropUpdates);
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 #endif /* __KIS_SUSPEND_PROJECTION_UPDATES_STROKE_STRATEGY_H */
diff --git a/libs/ui/canvas/kis_canvas2.cpp b/libs/ui/canvas/kis_canvas2.cpp
index 568a5a1c03..27549e442e 100644
--- a/libs/ui/canvas/kis_canvas2.cpp
+++ b/libs/ui/canvas/kis_canvas2.cpp
@@ -1,1201 +1,1221 @@
 /* This file is part of the KDE project
  *
  * Copyright (C) 2006, 2010 Boudewijn Rempt <boud@valdyas.org>
  * Copyright (C) Lukáš Tvrdý <lukast.dev@gmail.com>, (C) 2010
  * Copyright (C) 2011 Silvio Heinrich <plassy@web.de>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA..
  */
 
 #include "kis_canvas2.h"
 
 #include <functional>
 #include <numeric>
 
 #include <QApplication>
 #include <QWidget>
 #include <QVBoxLayout>
 #include <QTime>
 #include <QLabel>
 #include <QMouseEvent>
 #include <QDesktopWidget>
 
 #include <kis_debug.h>
 
 #include <KoUnit.h>
 #include <KoShapeManager.h>
 #include <KisSelectedShapesProxy.h>
 #include <KoColorProfile.h>
 #include <KoCanvasControllerWidget.h>
 #include <KisDocument.h>
 #include <KoSelection.h>
 #include <KoShapeController.h>
 
 #include <kis_lod_transform.h>
 #include "kis_tool_proxy.h"
 #include "kis_coordinates_converter.h"
 #include "kis_prescaled_projection.h"
 #include "kis_image.h"
 #include "kis_image_barrier_locker.h"
 #include "kis_undo_adapter.h"
 #include "flake/kis_shape_layer.h"
 #include "kis_canvas_resource_provider.h"
 #include "KisViewManager.h"
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_abstract_canvas_widget.h"
 #include "kis_qpainter_canvas.h"
 #include "kis_group_layer.h"
 #include "flake/kis_shape_controller.h"
 #include "kis_node_manager.h"
 #include "kis_selection.h"
 #include "kis_selection_component.h"
 #include "flake/kis_shape_selection.h"
 #include "kis_image_config.h"
 #include "kis_infinity_manager.h"
 #include "kis_signal_compressor.h"
 #include "kis_display_color_converter.h"
 #include "kis_exposure_gamma_correction_interface.h"
 #include "KisView.h"
 #include "kis_canvas_controller.h"
 #include "kis_grid_config.h"
 
 #include "kis_animation_player.h"
 #include "kis_animation_frame_cache.h"
 #include "opengl/kis_opengl_canvas2.h"
 #include "opengl/kis_opengl.h"
 #include "kis_fps_decoration.h"
 
 #include "KoColorConversionTransformation.h"
 #include "KisProofingConfiguration.h"
 
 #include <kis_favorite_resource_manager.h>
 #include <kis_popup_palette.h>
 
 #include "input/kis_input_manager.h"
 #include "kis_painting_assistants_decoration.h"
 
 #include "kis_canvas_updates_compressor.h"
 #include "KoZoomController.h"
 
 #include <KisStrokeSpeedMonitor.h>
 #include "opengl/kis_opengl_canvas_debugger.h"
 
 #include "kis_algebra_2d.h"
+#include "kis_image_signal_router.h"
+
 
 class Q_DECL_HIDDEN KisCanvas2::KisCanvas2Private
 {
 
 public:
 
     KisCanvas2Private(KoCanvasBase *parent, KisCoordinatesConverter* coordConverter, QPointer<KisView> view, KoCanvasResourceManager* resourceManager)
         : coordinatesConverter(coordConverter)
         , view(view)
         , shapeManager(parent)
         , selectedShapesProxy(&shapeManager)
         , toolProxy(parent)
         , displayColorConverter(resourceManager, view)
         , regionOfInterestUpdateCompressor(100, KisSignalCompressor::FIRST_INACTIVE)
     {
     }
 
     KisCoordinatesConverter *coordinatesConverter;
     QPointer<KisView>view;
     KisAbstractCanvasWidget *canvasWidget = 0;
     KoShapeManager shapeManager;
     KisSelectedShapesProxy selectedShapesProxy;
     bool currentCanvasIsOpenGL;
     int openGLFilterMode;
     KisToolProxy toolProxy;
     KisPrescaledProjectionSP prescaledProjection;
     bool vastScrolling;
 
     KisSignalCompressor canvasUpdateCompressor;
     QRect savedUpdateRect;
 
     QBitArray channelFlags;
     KisProofingConfigurationSP proofingConfig;
     bool softProofing = false;
     bool gamutCheck = false;
     bool proofingConfigUpdated = false;
 
     KisPopupPalette *popupPalette = 0;
     KisDisplayColorConverter displayColorConverter;
 
     KisCanvasUpdatesCompressor projectionUpdatesCompressor;
     KisAnimationPlayer *animationPlayer;
     KisAnimationFrameCacheSP frameCache;
     bool lodAllowedInImage = false;
     bool bootstrapLodBlocked;
     QPointer<KoShapeManager> currentlyActiveShapeManager;
     KisInputActionGroupsMask inputActionGroupsMask = AllActionGroup;
 
     KisSignalCompressor frameRenderStartCompressor;
 
     KisSignalCompressor regionOfInterestUpdateCompressor;
     QRect regionOfInterest;
 
     QRect renderingLimit;
-    int lodResetBatchActive = 0;
+    int isBatchUpdateActive = 0;
 
     bool effectiveLodAllowedInImage() {
         return lodAllowedInImage && !bootstrapLodBlocked;
     }
 
     void setActiveShapeManager(KoShapeManager *shapeManager);
 };
 
 namespace {
 KoShapeManager* fetchShapeManagerFromNode(KisNodeSP node)
 {
     KoShapeManager *shapeManager = 0;
 
     KisLayer *layer = dynamic_cast<KisLayer*>(node.data());
 
     if (layer) {
         KisShapeLayer *shapeLayer = dynamic_cast<KisShapeLayer*>(layer);
         if (shapeLayer) {
             shapeManager = shapeLayer->shapeManager();
 
         } else {
             KisSelectionSP selection = layer->selection();
             if (selection && selection->hasShapeSelection()) {
                 KisShapeSelection *shapeSelection = dynamic_cast<KisShapeSelection*>(selection->shapeSelection());
                 KIS_ASSERT_RECOVER_RETURN_VALUE(shapeSelection, 0);
 
                 shapeManager = shapeSelection->shapeManager();
             }
         }
     }
 
     return shapeManager;
 }
 }
 
 KisCanvas2::KisCanvas2(KisCoordinatesConverter *coordConverter, KoCanvasResourceManager *resourceManager, KisView *view, KoShapeControllerBase *sc)
     : KoCanvasBase(sc, resourceManager)
     , m_d(new KisCanvas2Private(this, coordConverter, view, resourceManager))
 {
     /**
      * While loading LoD should be blocked. Only when GUI has finished
      * loading and zoom level settled down, LoD is given a green
      * light.
      */
     m_d->bootstrapLodBlocked = true;
     connect(view->mainWindow(), SIGNAL(guiLoadingFinished()), SLOT(bootstrapFinished()));
 
     KisImageConfig config;
 
     m_d->canvasUpdateCompressor.setDelay(1000 / config.fpsLimit());
     m_d->canvasUpdateCompressor.setMode(KisSignalCompressor::FIRST_ACTIVE);
 
     m_d->frameRenderStartCompressor.setDelay(1000 / config.fpsLimit());
     m_d->frameRenderStartCompressor.setMode(KisSignalCompressor::FIRST_ACTIVE);
 }
 
 void KisCanvas2::setup()
 {
     // a bit of duplication from slotConfigChanged()
     KisConfig cfg;
     m_d->vastScrolling = cfg.vastScrolling();
     m_d->lodAllowedInImage = cfg.levelOfDetailEnabled();
 
     createCanvas(cfg.useOpenGL());
 
     setLodAllowedInCanvas(m_d->lodAllowedInImage);
     m_d->animationPlayer = new KisAnimationPlayer(this);
     connect(m_d->view->canvasController()->proxyObject, SIGNAL(moveDocumentOffset(QPoint)), SLOT(documentOffsetMoved(QPoint)));
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
 
     /**
      * We switch the shape manager every time vector layer or
      * shape selection is activated. Flake does not expect this
      * and connects all the signals of the global shape manager
      * to the clients in the constructor. To workaround this we
      * forward the signals of local shape managers stored in the
      * vector layers to the signals of global shape manager. So the
      * sequence of signal deliveries is the following:
      *
      * shapeLayer.m_d.canvas.m_shapeManager.selection() ->
      * shapeLayer ->
      * shapeController ->
      * globalShapeManager.selection()
      */
 
     KisShapeController *kritaShapeController = static_cast<KisShapeController*>(shapeController()->documentBase());
     connect(kritaShapeController, SIGNAL(selectionChanged()),
             this, SLOT(slotSelectionChanged()));
     connect(kritaShapeController, SIGNAL(selectionContentChanged()),
             globalShapeManager(), SIGNAL(selectionContentChanged()));
     connect(kritaShapeController, SIGNAL(currentLayerChanged(const KoShapeLayer*)),
             globalShapeManager()->selection(), SIGNAL(currentLayerChanged(const KoShapeLayer*)));
 
     connect(&m_d->canvasUpdateCompressor, SIGNAL(timeout()), SLOT(slotDoCanvasUpdate()));
 
     connect(this, SIGNAL(sigCanvasCacheUpdated()), &m_d->frameRenderStartCompressor, SLOT(start()));
     connect(&m_d->frameRenderStartCompressor, SIGNAL(timeout()), SLOT(updateCanvasProjection()));
 
     connect(this, SIGNAL(sigContinueResizeImage(qint32,qint32)), SLOT(finishResizingImage(qint32,qint32)));
 
     connect(&m_d->regionOfInterestUpdateCompressor, SIGNAL(timeout()), SLOT(slotUpdateRegionOfInterest()));
 
     connect(m_d->view->document(), SIGNAL(sigReferenceImagesChanged()), this, SLOT(slotReferenceImagesChanged()));
 
     initializeFpsDecoration();
 }
 
 void KisCanvas2::initializeFpsDecoration()
 {
     KisConfig cfg;
 
     const bool shouldShowDebugOverlay =
         (canvasIsOpenGL() && cfg.enableOpenGLFramerateLogging()) ||
         cfg.enableBrushSpeedLogging();
 
     if (shouldShowDebugOverlay && !decoration(KisFpsDecoration::idTag)) {
         addDecoration(new KisFpsDecoration(imageView()));
 
         if (cfg.enableBrushSpeedLogging()) {
             connect(KisStrokeSpeedMonitor::instance(), SIGNAL(sigStatsUpdated()), this, SLOT(updateCanvas()));
         }
     } else if (!shouldShowDebugOverlay && decoration(KisFpsDecoration::idTag)) {
         m_d->canvasWidget->removeDecoration(KisFpsDecoration::idTag);
         disconnect(KisStrokeSpeedMonitor::instance(), SIGNAL(sigStatsUpdated()), this, SLOT(updateCanvas()));
     }
 }
 
 KisCanvas2::~KisCanvas2()
 {
     if (m_d->animationPlayer->isPlaying()) {
         m_d->animationPlayer->forcedStopOnExit();
     }
     delete m_d;
 }
 
 void KisCanvas2::setCanvasWidget(KisAbstractCanvasWidget *widget)
 {
     if (m_d->popupPalette) {
         m_d->popupPalette->setParent(widget->widget());
     }
 
     if (m_d->canvasWidget != 0) {
         widget->setDecorations(m_d->canvasWidget->decorations());
 
         // Redundant check for the constructor case, see below
         if(viewManager() != 0)
             viewManager()->inputManager()->removeTrackedCanvas(this);
     }
 
     m_d->canvasWidget = widget;
 
     // Either tmp was null or we are being called by KisCanvas2 constructor that is called by KisView
     // constructor, so the view manager still doesn't exists.
     if(m_d->canvasWidget != 0 && viewManager() != 0)
         viewManager()->inputManager()->addTrackedCanvas(this);
 
     if (!m_d->canvasWidget->decoration(INFINITY_DECORATION_ID)) {
         KisInfinityManager *manager = new KisInfinityManager(m_d->view, this);
         manager->setVisible(true);
         m_d->canvasWidget->addDecoration(manager);
     }
 
     widget->widget()->setAutoFillBackground(false);
     widget->widget()->setAttribute(Qt::WA_OpaquePaintEvent);
     widget->widget()->setMouseTracking(true);
     widget->widget()->setAcceptDrops(true);
 
     KoCanvasControllerWidget *controller = dynamic_cast<KoCanvasControllerWidget*>(canvasController());
     if (controller && controller->canvas() == this) {
         controller->changeCanvasWidget(widget->widget());
     }
 }
 
 bool KisCanvas2::canvasIsOpenGL() const
 {
     return m_d->currentCanvasIsOpenGL;
 }
 
 KisOpenGL::FilterMode KisCanvas2::openGLFilterMode() const
 {
     return KisOpenGL::FilterMode(m_d->openGLFilterMode);
 }
 
 void KisCanvas2::gridSize(QPointF *offset, QSizeF *spacing) const
 {
     QTransform transform = coordinatesConverter()->imageToDocumentTransform();
 
     const QPoint intSpacing = m_d->view->document()->gridConfig().spacing();
     const QPoint intOffset = m_d->view->document()->gridConfig().offset();
 
     QPointF size = transform.map(QPointF(intSpacing));
     spacing->rwidth() = size.x();
     spacing->rheight() = size.y();
 
     *offset = transform.map(QPointF(intOffset));
 }
 
 bool KisCanvas2::snapToGrid() const
 {
     return m_d->view->document()->gridConfig().snapToGrid();
 }
 
 qreal KisCanvas2::rotationAngle() const
 {
     return m_d->coordinatesConverter->rotationAngle();
 }
 
 bool KisCanvas2::xAxisMirrored() const
 {
     return m_d->coordinatesConverter->xAxisMirrored();
 }
 
 bool KisCanvas2::yAxisMirrored() const
 {
     return m_d->coordinatesConverter->yAxisMirrored();
 }
 
 void KisCanvas2::channelSelectionChanged()
 {
     KisImageSP image = this->image();
     m_d->channelFlags = image->rootLayer()->channelFlags();
 
     m_d->view->viewManager()->blockUntilOperationsFinishedForced(image);
 
     image->barrierLock();
     m_d->canvasWidget->channelSelectionChanged(m_d->channelFlags);
     startUpdateInPatches(image->bounds());
     image->unlock();
 }
 
 void KisCanvas2::addCommand(KUndo2Command *command)
 {
     // This method exists to support flake-related operations
     m_d->view->document()->addCommand(command);
 }
 
 void KisCanvas2::KisCanvas2Private::setActiveShapeManager(KoShapeManager *shapeManager)
 {
     if (shapeManager != currentlyActiveShapeManager) {
         currentlyActiveShapeManager = shapeManager;
         selectedShapesProxy.setShapeManager(shapeManager);
     }
 }
 
 KoShapeManager* KisCanvas2::shapeManager() const
 {
     KisNodeSP node = m_d->view->currentNode();
     KoShapeManager *localShapeManager = fetchShapeManagerFromNode(node);
 
     if (localShapeManager != m_d->currentlyActiveShapeManager) {
         m_d->setActiveShapeManager(localShapeManager);
     }
 
     // sanity check for consistency of the local shape manager
     KIS_SAFE_ASSERT_RECOVER (localShapeManager == m_d->currentlyActiveShapeManager) {
         localShapeManager = globalShapeManager();
     }
 
     return localShapeManager ? localShapeManager : globalShapeManager();
 }
 
 KoSelectedShapesProxy* KisCanvas2::selectedShapesProxy() const
 {
     return &m_d->selectedShapesProxy;
 }
 
 KoShapeManager* KisCanvas2::globalShapeManager() const
 {
     return &m_d->shapeManager;
 }
 
 void KisCanvas2::updateInputMethodInfo()
 {
     // TODO call (the protected) QWidget::updateMicroFocus() on the proper canvas widget...
 }
 
 const KisCoordinatesConverter* KisCanvas2::coordinatesConverter() const
 {
     return m_d->coordinatesConverter;
 }
 
 KoViewConverter* KisCanvas2::viewConverter() const
 {
     return m_d->coordinatesConverter;
 }
 
 KisInputManager* KisCanvas2::globalInputManager() const
 {
     return m_d->view->globalInputManager();
 }
 
 KisInputActionGroupsMask KisCanvas2::inputActionGroupsMask() const
 {
     return m_d->inputActionGroupsMask;
 }
 
 void KisCanvas2::setInputActionGroupsMask(KisInputActionGroupsMask mask)
 {
     m_d->inputActionGroupsMask = mask;
 }
 
 QWidget* KisCanvas2::canvasWidget()
 {
     return m_d->canvasWidget->widget();
 }
 
 const QWidget* KisCanvas2::canvasWidget() const
 {
     return m_d->canvasWidget->widget();
 }
 
 
 KoUnit KisCanvas2::unit() const
 {
     KoUnit unit(KoUnit::Pixel);
 
     KisImageWSP image = m_d->view->image();
     if (image) {
         if (!qFuzzyCompare(image->xRes(), image->yRes())) {
             warnKrita << "WARNING: resolution of the image is anisotropic"
                        << ppVar(image->xRes())
                        << ppVar(image->yRes());
         }
 
         const qreal resolution = image->xRes();
         unit.setFactor(resolution);
     }
 
     return unit;
 }
 
 KoToolProxy * KisCanvas2::toolProxy() const
 {
     return &m_d->toolProxy;
 }
 
 void KisCanvas2::createQPainterCanvas()
 {
     m_d->currentCanvasIsOpenGL = false;
 
     KisQPainterCanvas * canvasWidget = new KisQPainterCanvas(this, m_d->coordinatesConverter, m_d->view);
     m_d->prescaledProjection = new KisPrescaledProjection();
     m_d->prescaledProjection->setCoordinatesConverter(m_d->coordinatesConverter);
     m_d->prescaledProjection->setMonitorProfile(m_d->displayColorConverter.monitorProfile(),
                                                 m_d->displayColorConverter.renderingIntent(),
                                                 m_d->displayColorConverter.conversionFlags());
     m_d->prescaledProjection->setDisplayFilter(m_d->displayColorConverter.displayFilter());
     canvasWidget->setPrescaledProjection(m_d->prescaledProjection);
     setCanvasWidget(canvasWidget);
 }
 
 void KisCanvas2::createOpenGLCanvas()
 {
     KisConfig cfg;
     m_d->openGLFilterMode = cfg.openGLFilteringMode();
     m_d->currentCanvasIsOpenGL = true;
 
     KisOpenGLCanvas2 *canvasWidget = new KisOpenGLCanvas2(this, m_d->coordinatesConverter, 0, m_d->view->image(), &m_d->displayColorConverter);
     m_d->frameCache = KisAnimationFrameCache::getFrameCache(canvasWidget->openGLImageTextures());
 
     setCanvasWidget(canvasWidget);
 }
 
 void KisCanvas2::createCanvas(bool useOpenGL)
 {
     // deinitialize previous canvas structures
     m_d->prescaledProjection = 0;
     m_d->frameCache = 0;
 
     KisConfig cfg;
     QDesktopWidget dw;
     const KoColorProfile *profile = cfg.displayProfile(dw.screenNumber(imageView()));
     m_d->displayColorConverter.setMonitorProfile(profile);
 
     if (useOpenGL) {
         if (KisOpenGL::hasOpenGL()) {
             createOpenGLCanvas();
             if (cfg.canvasState() == "OPENGL_FAILED") {
                 // Creating the opengl canvas failed, fall back
                 warnKrita << "OpenGL Canvas initialization returned OPENGL_FAILED. Falling back to QPainter.";
                 createQPainterCanvas();
             }
         } else {
             warnKrita << "Tried to create OpenGL widget when system doesn't have OpenGL\n";
             createQPainterCanvas();
         }
     }
     else {
         createQPainterCanvas();
     }
 
     if (m_d->popupPalette) {
         m_d->popupPalette->setParent(m_d->canvasWidget->widget());
     }
 
 }
 
 void KisCanvas2::initializeImage()
 {
     KisImageSP image = m_d->view->image();
 
     m_d->coordinatesConverter->setImage(image);
     m_d->toolProxy.initializeImage(image);
 
     connect(image, SIGNAL(sigImageUpdated(QRect)), SLOT(startUpdateCanvasProjection(QRect)), Qt::DirectConnection);
-    connect(image, SIGNAL(sigBeginLodResetUpdatesBatch()), SLOT(slotBeginLodResetUpdatesBatch()), Qt::DirectConnection);
-    connect(image, SIGNAL(sigEndLodResetUpdatesBatch()), SLOT(slotEndLodResetUpdatesBatch()), Qt::DirectConnection);
+    connect(image->signalRouter(), SIGNAL(sigNotifyBatchUpdateStarted()), SLOT(slotBeginUpdatesBatch()), Qt::DirectConnection);
+    connect(image->signalRouter(), SIGNAL(sigNotifyBatchUpdateEnded()), SLOT(slotEndUpdatesBatch()), Qt::DirectConnection);
+    connect(image->signalRouter(), SIGNAL(sigRequestLodPlanesSyncBlocked(bool)), SLOT(slotSetLodUpdatesBlocked(bool)), Qt::DirectConnection);
 
     connect(image, SIGNAL(sigProofingConfigChanged()), SLOT(slotChangeProofingConfig()));
     connect(image, SIGNAL(sigSizeChanged(const QPointF&, const QPointF&)), SLOT(startResizingImage()), Qt::DirectConnection);
     connect(image->undoAdapter(), SIGNAL(selectionChanged()), SLOT(slotTrySwitchShapeManager()));
 
     connectCurrentCanvas();
 }
 
 void KisCanvas2::connectCurrentCanvas()
 {
     KisImageWSP image = m_d->view->image();
 
     if (!m_d->currentCanvasIsOpenGL) {
         Q_ASSERT(m_d->prescaledProjection);
         m_d->prescaledProjection->setImage(image);
     }
 
     startResizingImage();
     setLodAllowedInCanvas(m_d->lodAllowedInImage);
 
     emit sigCanvasEngineChanged();
 }
 
 void KisCanvas2::resetCanvas(bool useOpenGL)
 {
     // we cannot reset the canvas before it's created, but this method might be called,
     // for instance when setting the monitor profile.
     if (!m_d->canvasWidget) {
         return;
     }
     KisConfig cfg;
     bool needReset = (m_d->currentCanvasIsOpenGL != useOpenGL) ||
         (m_d->currentCanvasIsOpenGL &&
          m_d->openGLFilterMode != cfg.openGLFilteringMode());
 
     if (needReset) {
         createCanvas(useOpenGL);
         connectCurrentCanvas();
         notifyZoomChanged();
     }
     updateCanvasWidgetImpl();
 }
 
 void KisCanvas2::startUpdateInPatches(const QRect &imageRect)
 {
     if (m_d->currentCanvasIsOpenGL) {
         startUpdateCanvasProjection(imageRect);
     } else {
         KisImageConfig imageConfig;
         int patchWidth = imageConfig.updatePatchWidth();
         int patchHeight = imageConfig.updatePatchHeight();
 
         for (int y = 0; y < imageRect.height(); y += patchHeight) {
             for (int x = 0; x < imageRect.width(); x += patchWidth) {
                 QRect patchRect(x, y, patchWidth, patchHeight);
                 startUpdateCanvasProjection(patchRect);
             }
         }
     }
 }
 
 void KisCanvas2::setDisplayFilter(QSharedPointer<KisDisplayFilter> displayFilter)
 {
     m_d->displayColorConverter.setDisplayFilter(displayFilter);
     KisImageSP image = this->image();
 
     m_d->view->viewManager()->blockUntilOperationsFinishedForced(image);
 
     image->barrierLock();
     m_d->canvasWidget->setDisplayFilter(displayFilter);
     image->unlock();
 }
 
 QSharedPointer<KisDisplayFilter> KisCanvas2::displayFilter() const
 {
     return m_d->displayColorConverter.displayFilter();
 }
 
 KisDisplayColorConverter* KisCanvas2::displayColorConverter() const
 {
     return &m_d->displayColorConverter;
 }
 
 KisExposureGammaCorrectionInterface* KisCanvas2::exposureGammaCorrectionInterface() const
 {
     QSharedPointer<KisDisplayFilter> displayFilter = m_d->displayColorConverter.displayFilter();
 
     return displayFilter ?
         displayFilter->correctionInterface() :
         KisDumbExposureGammaCorrectionInterface::instance();
 }
 
 void KisCanvas2::setProofingOptions(bool softProof, bool gamutCheck)
 {
     m_d->proofingConfig = this->image()->proofingConfiguration();
     if (!m_d->proofingConfig) {
         qDebug()<<"Canvas: No proofing config found, generating one.";
         KisImageConfig cfg;
         m_d->proofingConfig = cfg.defaultProofingconfiguration();
     }
     KoColorConversionTransformation::ConversionFlags conversionFlags = m_d->proofingConfig->conversionFlags;
 #if QT_VERSION >= 0x050700
 
     if (this->image()->colorSpace()->colorDepthId().id().contains("U")) {
         conversionFlags.setFlag(KoColorConversionTransformation::SoftProofing, softProof);
         if (softProof) {
             conversionFlags.setFlag(KoColorConversionTransformation::GamutCheck, gamutCheck);
         }
     }
 #else
     if (this->image()->colorSpace()->colorDepthId().id().contains("U")) {
         conversionFlags |= KoColorConversionTransformation::SoftProofing;
     } else {
         conversionFlags = conversionFlags & ~KoColorConversionTransformation::SoftProofing;
     }
     if (gamutCheck && softProof && this->image()->colorSpace()->colorDepthId().id().contains("U")) {
         conversionFlags |= KoColorConversionTransformation::GamutCheck;
     } else {
         conversionFlags = conversionFlags & ~KoColorConversionTransformation::GamutCheck;
     }
 #endif
     m_d->proofingConfig->conversionFlags = conversionFlags;
 
     m_d->proofingConfigUpdated = true;
     startUpdateInPatches(this->image()->bounds());
 
 }
 
 void KisCanvas2::slotSoftProofing(bool softProofing)
 {
     m_d->softProofing = softProofing;
     setProofingOptions(m_d->softProofing, m_d->gamutCheck);
 }
 
 void KisCanvas2::slotGamutCheck(bool gamutCheck)
 {
     m_d->gamutCheck = gamutCheck;
     setProofingOptions(m_d->softProofing, m_d->gamutCheck);
 }
 
 void KisCanvas2::slotChangeProofingConfig()
 {
     setProofingOptions(m_d->softProofing, m_d->gamutCheck);
 }
 
 void KisCanvas2::setProofingConfigUpdated(bool updated)
 {
     m_d->proofingConfigUpdated = updated;
 }
 
 bool KisCanvas2::proofingConfigUpdated()
 {
     return m_d->proofingConfigUpdated;
 }
 
 KisProofingConfigurationSP KisCanvas2::proofingConfiguration() const
 {
     if (!m_d->proofingConfig) {
         m_d->proofingConfig = this->image()->proofingConfiguration();
         if (!m_d->proofingConfig) {
             m_d->proofingConfig = KisImageConfig().defaultProofingconfiguration();
         }
     }
     return m_d->proofingConfig;
 }
 
 void KisCanvas2::startResizingImage()
 {
     KisImageWSP image = this->image();
     qint32 w = image->width();
     qint32 h = image->height();
 
     emit sigContinueResizeImage(w, h);
 
     QRect imageBounds(0, 0, w, h);
     startUpdateInPatches(imageBounds);
 }
 
 void KisCanvas2::finishResizingImage(qint32 w, qint32 h)
 {
     m_d->canvasWidget->finishResizingImage(w, h);
 }
 
 void KisCanvas2::startUpdateCanvasProjection(const QRect & rc)
 {
     KisUpdateInfoSP info = m_d->canvasWidget->startUpdateCanvasProjection(rc, m_d->channelFlags);
     if (m_d->projectionUpdatesCompressor.putUpdateInfo(info)) {
         emit sigCanvasCacheUpdated();
     }
 }
 
 void KisCanvas2::updateCanvasProjection()
 {
     auto tryIssueCanvasUpdates = [this](const QRect &vRect) {
-        if (!m_d->lodResetBatchActive) {
+        if (!m_d->isBatchUpdateActive) {
             // TODO: Implement info->dirtyViewportRect() for KisOpenGLCanvas2 to avoid updating whole canvas
             if (m_d->currentCanvasIsOpenGL) {
                 m_d->savedUpdateRect = QRect();
 
                 // we already had a compression in frameRenderStartCompressor, so force the update directly
                 slotDoCanvasUpdate();
             } else if (/* !m_d->currentCanvasIsOpenGL && */ !vRect.isEmpty()) {
                 m_d->savedUpdateRect = m_d->coordinatesConverter->viewportToWidget(vRect).toAlignedRect();
 
                 // we already had a compression in frameRenderStartCompressor, so force the update directly
                 slotDoCanvasUpdate();
             }
         }
     };
 
     auto uploadData = [this, tryIssueCanvasUpdates](const QVector<KisUpdateInfoSP> &infoObjects) {
         QVector<QRect> viewportRects = m_d->canvasWidget->updateCanvasProjection(infoObjects);
         const QRect vRect = std::accumulate(viewportRects.constBegin(), viewportRects.constEnd(),
                                             QRect(), std::bit_or<QRect>());
 
         tryIssueCanvasUpdates(vRect);
     };
 
+    bool shouldExplicitlyIssueUpdates = false;
 
     QVector<KisUpdateInfoSP> infoObjects;
     while (KisUpdateInfoSP info = m_d->projectionUpdatesCompressor.takeUpdateInfo()) {
-        const KisBatchControlUpdateInfo *batchInfo = dynamic_cast<const KisBatchControlUpdateInfo*>(info.data());
+        const KisMarkerUpdateInfo *batchInfo = dynamic_cast<const KisMarkerUpdateInfo*>(info.data());
         if (batchInfo) {
             if (!infoObjects.isEmpty()) {
                 uploadData(infoObjects);
                 infoObjects.clear();
             }
 
-            if (batchInfo->type() == KisBatchControlUpdateInfo::StartBatch) {
-                m_d->lodResetBatchActive++;
+            if (batchInfo->type() == KisMarkerUpdateInfo::StartBatch) {
+                m_d->isBatchUpdateActive++;
+            } else if (batchInfo->type() == KisMarkerUpdateInfo::EndBatch) {
+                m_d->isBatchUpdateActive--;
+                KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->isBatchUpdateActive >= 0);
+                if (m_d->isBatchUpdateActive == 0) {
+                    shouldExplicitlyIssueUpdates = true;
+                }
+            } else if (batchInfo->type() == KisMarkerUpdateInfo::BlockLodUpdates) {
                 m_d->canvasWidget->setLodResetInProgress(true);
-            } else if (batchInfo->type() == KisBatchControlUpdateInfo::EndBatch) {
+            } else if (batchInfo->type() == KisMarkerUpdateInfo::UnblockLodUpdates) {
                 m_d->canvasWidget->setLodResetInProgress(false);
-                m_d->lodResetBatchActive--;
-                KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->lodResetBatchActive >= 0);
-                if (m_d->lodResetBatchActive == 0) {
-                    tryIssueCanvasUpdates(m_d->coordinatesConverter->imageRectInImagePixels());
-                }
+                shouldExplicitlyIssueUpdates = true;
             }
         } else {
             infoObjects << info;
         }
     }
 
     if (!infoObjects.isEmpty()) {
         uploadData(infoObjects);
+    } else if (shouldExplicitlyIssueUpdates) {
+        tryIssueCanvasUpdates(m_d->coordinatesConverter->imageRectInImagePixels());
     }
 }
 
-void KisCanvas2::slotBeginLodResetUpdatesBatch()
+void KisCanvas2::slotBeginUpdatesBatch()
 {
     KisUpdateInfoSP info =
-        new KisBatchControlUpdateInfo(KisBatchControlUpdateInfo::StartBatch,
+        new KisMarkerUpdateInfo(KisMarkerUpdateInfo::StartBatch,
                                       m_d->coordinatesConverter->imageRectInImagePixels());
     m_d->projectionUpdatesCompressor.putUpdateInfo(info);
     emit sigCanvasCacheUpdated();
 }
 
-void KisCanvas2::slotEndLodResetUpdatesBatch()
+void KisCanvas2::slotEndUpdatesBatch()
 {
     KisUpdateInfoSP info =
-        new KisBatchControlUpdateInfo(KisBatchControlUpdateInfo::EndBatch,
+        new KisMarkerUpdateInfo(KisMarkerUpdateInfo::EndBatch,
                                       m_d->coordinatesConverter->imageRectInImagePixels());
     m_d->projectionUpdatesCompressor.putUpdateInfo(info);
     emit sigCanvasCacheUpdated();
 }
 
+void KisCanvas2::slotSetLodUpdatesBlocked(bool value)
+{
+    KisUpdateInfoSP info =
+        new KisMarkerUpdateInfo(value ?
+                                KisMarkerUpdateInfo::BlockLodUpdates :
+                                KisMarkerUpdateInfo::UnblockLodUpdates,
+                                m_d->coordinatesConverter->imageRectInImagePixels());
+    m_d->projectionUpdatesCompressor.putUpdateInfo(info);
+    emit sigCanvasCacheUpdated();
+}
+
 void KisCanvas2::slotDoCanvasUpdate()
 {
     /**
      * WARNING: in isBusy() we access openGL functions without making the painting
      * context current. We hope that currently active context will be Qt's one,
      * which is shared with our own.
      */
     if (m_d->canvasWidget->isBusy()) {
         // just restarting the timer
         updateCanvasWidgetImpl(m_d->savedUpdateRect);
         return;
     }
 
     if (m_d->savedUpdateRect.isEmpty()) {
         m_d->canvasWidget->widget()->update();
         emit updateCanvasRequested(m_d->canvasWidget->widget()->rect());
     } else {
         emit updateCanvasRequested(m_d->savedUpdateRect);
         m_d->canvasWidget->widget()->update(m_d->savedUpdateRect);
     }
 
     m_d->savedUpdateRect = QRect();
 }
 
 void KisCanvas2::updateCanvasWidgetImpl(const QRect &rc)
 {
     if (!m_d->canvasUpdateCompressor.isActive() ||
         !m_d->savedUpdateRect.isEmpty()) {
         m_d->savedUpdateRect |= rc;
     }
     m_d->canvasUpdateCompressor.start();
 }
 
 void KisCanvas2::updateCanvas()
 {
     updateCanvasWidgetImpl();
 }
 
 void KisCanvas2::updateCanvas(const QRectF& documentRect)
 {
     if (m_d->currentCanvasIsOpenGL && m_d->canvasWidget->decorations().size() > 0) {
         updateCanvasWidgetImpl();
     }
     else {
         // updateCanvas is called from tools, never from the projection
         // updates, so no need to prescale!
         QRect widgetRect = m_d->coordinatesConverter->documentToWidget(documentRect).toAlignedRect();
         widgetRect.adjust(-2, -2, 2, 2);
         if (!widgetRect.isEmpty()) {
             updateCanvasWidgetImpl(widgetRect);
         }
     }
 }
 
 void KisCanvas2::disconnectCanvasObserver(QObject *object)
 {
     KoCanvasBase::disconnectCanvasObserver(object);
     m_d->view->disconnect(object);
 }
 
 void KisCanvas2::notifyZoomChanged()
 {
     if (!m_d->currentCanvasIsOpenGL) {
         Q_ASSERT(m_d->prescaledProjection);
         m_d->prescaledProjection->notifyZoomChanged();
     }
 
     notifyLevelOfDetailChange();
     updateCanvas(); // update the canvas, because that isn't done when zooming using KoZoomAction
 
     m_d->regionOfInterestUpdateCompressor.start();
 }
 
 QRect KisCanvas2::regionOfInterest() const
 {
     return m_d->regionOfInterest;
 }
 
 void KisCanvas2::slotUpdateRegionOfInterest()
 {
     const QRect oldRegionOfInterest = m_d->regionOfInterest;
 
     const qreal ratio = 0.25;
     const QRect proposedRoi = KisAlgebra2D::blowRect(m_d->coordinatesConverter->widgetRectInImagePixels(), ratio).toAlignedRect();
 
     const QRect imageRect = m_d->coordinatesConverter->imageRectInImagePixels();
 
     m_d->regionOfInterest = imageRect.contains(proposedRoi) ? proposedRoi : imageRect;
 
     if (m_d->regionOfInterest != oldRegionOfInterest) {
         emit sigRegionOfInterestChanged(m_d->regionOfInterest);
     }
 }
 
 void KisCanvas2::slotReferenceImagesChanged()
 {
     canvasController()->resetScrollBars();
 }
 
 void KisCanvas2::setRenderingLimit(const QRect &rc)
 {
     m_d->renderingLimit = rc;
 }
 
 QRect KisCanvas2::renderingLimit() const
 {
     return m_d->renderingLimit;
 }
 
 void KisCanvas2::slotTrySwitchShapeManager()
 {
     KisNodeSP node = m_d->view->currentNode();
 
     QPointer<KoShapeManager> newManager;
     newManager = fetchShapeManagerFromNode(node);
 
     m_d->setActiveShapeManager(newManager);
 }
 
 void KisCanvas2::notifyLevelOfDetailChange()
 {
     if (!m_d->effectiveLodAllowedInImage()) return;
 
     const qreal effectiveZoom = m_d->coordinatesConverter->effectiveZoom();
 
     KisConfig cfg;
     const int maxLod = cfg.numMipmapLevels();
 
     const int lod = KisLodTransform::scaleToLod(effectiveZoom, maxLod);
 
     if (m_d->effectiveLodAllowedInImage()) {
         KisImageSP image = this->image();
         image->setDesiredLevelOfDetail(lod);
     }
 }
 
 const KoColorProfile *  KisCanvas2::monitorProfile()
 {
     return m_d->displayColorConverter.monitorProfile();
 }
 
 KisViewManager* KisCanvas2::viewManager() const
 {
     if (m_d->view) {
         return m_d->view->viewManager();
     }
     return 0;
 }
 
 QPointer<KisView>KisCanvas2::imageView() const
 {
     return m_d->view;
 }
 
 KisImageWSP KisCanvas2::image() const
 {
     return m_d->view->image();
 
 }
 
 KisImageWSP KisCanvas2::currentImage() const
 {
     return m_d->view->image();
 }
 
 void KisCanvas2::documentOffsetMoved(const QPoint &documentOffset)
 {
     QPointF offsetBefore = m_d->coordinatesConverter->imageRectInViewportPixels().topLeft();
     m_d->coordinatesConverter->setDocumentOffset(documentOffset);
     QPointF offsetAfter = m_d->coordinatesConverter->imageRectInViewportPixels().topLeft();
 
     QPointF moveOffset = offsetAfter - offsetBefore;
 
     if (!m_d->currentCanvasIsOpenGL)
         m_d->prescaledProjection->viewportMoved(moveOffset);
 
     emit documentOffsetUpdateFinished();
 
     updateCanvas();
 
     m_d->regionOfInterestUpdateCompressor.start();
 }
 
 void KisCanvas2::slotConfigChanged()
 {
     KisConfig cfg;
     m_d->vastScrolling = cfg.vastScrolling();
 
     resetCanvas(cfg.useOpenGL());
     slotSetDisplayProfile(cfg.displayProfile(QApplication::desktop()->screenNumber(this->canvasWidget())));
 
     initializeFpsDecoration();
 }
 
 void KisCanvas2::refetchDataFromImage()
 {
     KisImageSP image = this->image();
     KisImageBarrierLocker l(image);
     startUpdateInPatches(image->bounds());
 }
 
 void KisCanvas2::slotSetDisplayProfile(const KoColorProfile *monitorProfile)
 {
     if (m_d->displayColorConverter.monitorProfile() == monitorProfile) return;
 
     m_d->displayColorConverter.setMonitorProfile(monitorProfile);
 
     {
         KisImageSP image = this->image();
         KisImageBarrierLocker l(image);
         m_d->canvasWidget->setDisplayProfile(&m_d->displayColorConverter);
     }
 
     refetchDataFromImage();
 }
 
 void KisCanvas2::addDecoration(KisCanvasDecorationSP deco)
 {
     m_d->canvasWidget->addDecoration(deco);
 }
 
 KisCanvasDecorationSP KisCanvas2::decoration(const QString& id) const
 {
     return m_d->canvasWidget->decoration(id);
 }
 
 
 QPoint KisCanvas2::documentOrigin() const
 {
     /**
      * In Krita we don't use document origin anymore.
      * All the centering when needed (vastScrolling < 0.5) is done
      * automatically by the KisCoordinatesConverter.
      */
 
     return QPoint();
 }
 
 QPoint KisCanvas2::documentOffset() const
 {
     return m_d->coordinatesConverter->documentOffset();
 }
 
 void KisCanvas2::setFavoriteResourceManager(KisFavoriteResourceManager* favoriteResourceManager)
 {
     m_d->popupPalette = new KisPopupPalette(viewManager(), m_d->coordinatesConverter, favoriteResourceManager, displayColorConverter()->displayRendererInterface(),
                                             m_d->view->resourceProvider(), m_d->canvasWidget->widget());
     connect(m_d->popupPalette, SIGNAL(zoomLevelChanged(int)), this, SLOT(slotPopupPaletteRequestedZoomChange(int)));
     connect(m_d->popupPalette, SIGNAL(sigUpdateCanvas()), this, SLOT(updateCanvas()));
     connect(m_d->view->mainWindow(), SIGNAL(themeChanged()), m_d->popupPalette, SLOT(slotUpdateIcons()));
 
     m_d->popupPalette->showPopupPalette(false);
 }
 
 void KisCanvas2::slotPopupPaletteRequestedZoomChange(int zoom ) {
     m_d->view->viewManager()->zoomController()->setZoom(KoZoomMode::ZOOM_CONSTANT, (qreal)(zoom/100.0)); // 1.0 is 100% zoom
     notifyZoomChanged();
 }
 
 void KisCanvas2::setCursor(const QCursor &cursor)
 {
     canvasWidget()->setCursor(cursor);
 }
 
 KisAnimationFrameCacheSP KisCanvas2::frameCache() const
 {
     return m_d->frameCache;
 }
 
 KisAnimationPlayer *KisCanvas2::animationPlayer() const
 {
     return m_d->animationPlayer;
 }
 
 void KisCanvas2::slotSelectionChanged()
 {
     KisShapeLayer* shapeLayer = dynamic_cast<KisShapeLayer*>(viewManager()->activeLayer().data());
     if (!shapeLayer) {
         return;
     }
     m_d->shapeManager.selection()->deselectAll();
     Q_FOREACH (KoShape* shape, shapeLayer->shapeManager()->selection()->selectedShapes()) {
         m_d->shapeManager.selection()->select(shape);
     }
 }
 
 bool KisCanvas2::isPopupPaletteVisible() const
 {
     if (!m_d->popupPalette) {
         return false;
     }
     return m_d->popupPalette->isVisible();
 }
 
 
 void KisCanvas2::setWrapAroundViewingMode(bool value)
 {
     KisCanvasDecorationSP infinityDecoration =
         m_d->canvasWidget->decoration(INFINITY_DECORATION_ID);
 
     if (infinityDecoration) {
         infinityDecoration->setVisible(!value);
     }
 
     m_d->canvasWidget->setWrapAroundViewingMode(value);
 }
 
 bool KisCanvas2::wrapAroundViewingMode() const
 {
     KisCanvasDecorationSP infinityDecoration =
         m_d->canvasWidget->decoration(INFINITY_DECORATION_ID);
 
     if (infinityDecoration) {
         return !(infinityDecoration->visible());
     }
     return false;
 }
 
 void KisCanvas2::bootstrapFinished()
 {
     if (!m_d->bootstrapLodBlocked) return;
 
     m_d->bootstrapLodBlocked = false;
     setLodAllowedInCanvas(m_d->lodAllowedInImage);
 }
 
 void KisCanvas2::setLodAllowedInCanvas(bool value)
 {
     if (!KisOpenGL::supportsLoD()) {
         qWarning() << "WARNING: Level of Detail functionality is available only with openGL + GLSL 1.3 support";
     }
 
     m_d->lodAllowedInImage =
         value &&
         m_d->currentCanvasIsOpenGL &&
         KisOpenGL::supportsLoD() &&
         (m_d->openGLFilterMode == KisOpenGL::TrilinearFilterMode ||
          m_d->openGLFilterMode == KisOpenGL::HighQualityFiltering);
 
     KisImageSP image = this->image();
 
     if (m_d->effectiveLodAllowedInImage() != !image->levelOfDetailBlocked()) {
         image->setLevelOfDetailBlocked(!m_d->effectiveLodAllowedInImage());
     }
 
     notifyLevelOfDetailChange();
 
     KisConfig cfg;
     cfg.setLevelOfDetailEnabled(m_d->lodAllowedInImage);
 }
 
 bool KisCanvas2::lodAllowedInCanvas() const
 {
     return m_d->lodAllowedInImage;
 }
 
 void KisCanvas2::slotShowPopupPalette(const QPoint &p)
 {
     if (!m_d->popupPalette) {
         return;
     }
 
     m_d->popupPalette->showPopupPalette(p);
 }
 
 KisPaintingAssistantsDecorationSP KisCanvas2::paintingAssistantsDecoration() const
 {
     KisCanvasDecorationSP deco = decoration("paintingAssistantsDecoration");
     return qobject_cast<KisPaintingAssistantsDecoration*>(deco.data());
 }
 
 KisReferenceImagesDecorationSP KisCanvas2::referenceImagesDecoration() const
 {
     KisCanvasDecorationSP deco = decoration("referenceImagesDecoration");
     return qobject_cast<KisReferenceImagesDecoration*>(deco.data());
 }
diff --git a/libs/ui/canvas/kis_canvas2.h b/libs/ui/canvas/kis_canvas2.h
index 2ee4296d02..fb725b3806 100644
--- a/libs/ui/canvas/kis_canvas2.h
+++ b/libs/ui/canvas/kis_canvas2.h
@@ -1,346 +1,347 @@
 /* This file is part of the KDE project
  * Copyright (C) 2006, 2010 Boudewijn Rempt <boud@valdyas.org>
  * Copyright (C) 2011       Silvio Heinrich <plassy@web.de>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_CANVAS_H
 #define KIS_CANVAS_H
 
 #include <QObject>
 #include <QWidget>
 #include <QSize>
 #include <QString>
 
 #include <KoConfig.h>
 #include <KoColorConversionTransformation.h>
 #include <KoCanvasBase.h>
 #include <kritaui_export.h>
 #include <kis_types.h>
 #include <KoPointerEvent.h>
 
 #include "opengl/kis_opengl.h"
 
 #include "kis_ui_types.h"
 #include "kis_coordinates_converter.h"
 #include "kis_canvas_decoration.h"
 #include "kis_painting_assistants_decoration.h"
 #include "input/KisInputActionGroup.h"
 #include "KisReferenceImagesDecoration.h"
 
 class KoToolProxy;
 class KoColorProfile;
 
 
 class KisViewManager;
 class KisFavoriteResourceManager;
 class KisDisplayFilter;
 class KisDisplayColorConverter;
 struct KisExposureGammaCorrectionInterface;
 class KisView;
 class KisInputManager;
 class KisAnimationPlayer;
 class KisShapeController;
 class KisCoordinatesConverter;
 class KoViewConverter;
 class KisAbstractCanvasWidget;
 
 /**
  * KisCanvas2 is not an actual widget class, but rather an adapter for
  * the widget it contains, which may be either a QPainter based
  * canvas, or an OpenGL based canvas: that are the real widgets.
  */
 class KRITAUI_EXPORT KisCanvas2 : public KoCanvasBase, public KisInputActionGroupsMaskInterface
 {
 
     Q_OBJECT
 
 public:
 
     /**
      * Create a new canvas. The canvas manages a widget that will do
      * the actual painting: the canvas itself is not a widget.
      *
      * @param viewConverter the viewconverter for converting between
      *                       window and document coordinates.
      */
     KisCanvas2(KisCoordinatesConverter *coordConverter, KoCanvasResourceManager *resourceManager, KisView *view, KoShapeControllerBase *sc);
 
     ~KisCanvas2() override;
 
     void notifyZoomChanged();
 
     void disconnectCanvasObserver(QObject *object) override;
 
 public: // KoCanvasBase implementation
 
     bool canvasIsOpenGL() const override;
 
     KisOpenGL::FilterMode openGLFilterMode() const;
 
     void gridSize(QPointF *offset, QSizeF *spacing) const override;
 
     bool snapToGrid() const override;
 
     // This method only exists to support flake-related operations
     void addCommand(KUndo2Command *command) override;
 
     QPoint documentOrigin() const override;
     QPoint documentOffset() const;
 
     /**
      * Return the right shape manager for the current layer. That is
      * to say, if the current layer is a vector layer, return the shape
      * layer's canvas' shapemanager, else the shapemanager associated
      * with the global krita canvas.
      */
     KoShapeManager * shapeManager() const override;
 
     /**
      * Since shapeManager() may change, we need a persistent object where we can
      * connect to and thack the selection. See more comments in KoCanvasBase.
      */
     KoSelectedShapesProxy *selectedShapesProxy() const override;
 
     /**
      * Return the shape manager associated with this canvas
      */
     KoShapeManager *globalShapeManager() const;
 
     void updateCanvas(const QRectF& rc) override;
 
     void updateInputMethodInfo() override;
 
     const KisCoordinatesConverter* coordinatesConverter() const;
     KoViewConverter *viewConverter() const override;
 
     QWidget* canvasWidget() override;
 
     const QWidget* canvasWidget() const override;
 
     KoUnit unit() const override;
 
     KoToolProxy* toolProxy() const override;
 
     const KoColorProfile* monitorProfile();
 
     // FIXME:
     // Temporary! Either get the current layer and image from the
     // resource provider, or use this, which gets them from the
     // current shape selection.
     KisImageWSP currentImage() const;
 
     /**
      * Filters events and sends them to canvas actions. Shared
      * among all the views/canvases
      *
      * NOTE: May be null while initialization!
      */
     KisInputManager* globalInputManager() const;
 
     /**
      * Return the mask of currently available input action groups
      * Note: Override from KisInputActionGroupsMaskInterface
      */
     KisInputActionGroupsMask inputActionGroupsMask() const override;
 
     /**
      * Set the mask of currently available action groups
      * Note: Override from KisInputActionGroupsMaskInterface
      */
     void setInputActionGroupsMask(KisInputActionGroupsMask mask) override;
 
     KisPaintingAssistantsDecorationSP paintingAssistantsDecoration() const;
     KisReferenceImagesDecorationSP referenceImagesDecoration() const;
 
 public: // KisCanvas2 methods
 
     KisImageWSP image() const;
     KisViewManager* viewManager() const;
     QPointer<KisView> imageView() const;
 
     /// @return true if the canvas image should be displayed in vertically mirrored mode
     void addDecoration(KisCanvasDecorationSP deco);
     KisCanvasDecorationSP decoration(const QString& id) const;
 
     void setDisplayFilter(QSharedPointer<KisDisplayFilter> displayFilter);
     QSharedPointer<KisDisplayFilter> displayFilter() const;
 
     KisDisplayColorConverter *displayColorConverter() const;
     KisExposureGammaCorrectionInterface* exposureGammaCorrectionInterface() const;
 
     /**
      * @brief setProofingOptions
      * set the options for softproofing, without affecting the proofing options as stored inside the image.
      */
     void setProofingOptions(bool softProof, bool gamutCheck);
     KisProofingConfigurationSP proofingConfiguration() const;
 
     /**
      * @brief setProofingConfigUpdated This function is to set whether the proofing config is updated,
      * this is needed for determining whether or not to generate a new proofing transform.
      * @param updated whether it's updated. Just set it to false in normal usage.
      */
     void setProofingConfigUpdated(bool updated);
 
     /**
      * @brief proofingConfigUpdated ask the canvas whether or not it updated the proofing config.
      * @return whether or not the proofing config is updated, if so, a new proofing transform needs to be made
      * in KisOpenGL canvas.
      */
     bool proofingConfigUpdated();
 
     void setCursor(const QCursor &cursor) override;
     KisAnimationFrameCacheSP frameCache() const;
     KisAnimationPlayer *animationPlayer() const;
     void refetchDataFromImage();
 
     /**
      * @return area of the image (in image coordinates) that is visible on the canvas
      * with a small margin selected by the user
      */
     QRect regionOfInterest() const;
 
     /**
      * Set aftificial limit outside which the image will not be rendered
      * \p rc is measured in image pixels
      */
     void setRenderingLimit(const QRect &rc);
 
     /**
      * @return aftificial limit outside which the image will not be rendered
      */
     QRect renderingLimit() const;
 
 Q_SIGNALS:
     void sigCanvasEngineChanged();
 
     void sigCanvasCacheUpdated();
     void sigContinueResizeImage(qint32 w, qint32 h);
 
     void documentOffsetUpdateFinished();
 
     // emitted whenever the canvas widget thinks sketch should update
     void updateCanvasRequested(const QRect &rc);
 
     void sigRegionOfInterestChanged(const QRect &roi);
 
 public Q_SLOTS:
 
     /// Update the entire canvas area
     void updateCanvas();
 
     void startResizingImage();
     void finishResizingImage(qint32 w, qint32 h);
 
     /// canvas rotation in degrees
     qreal rotationAngle() const;
     /// Bools indicating canvasmirroring.
     bool xAxisMirrored() const;
     bool yAxisMirrored() const;
     void slotSoftProofing(bool softProofing);
     void slotGamutCheck(bool gamutCheck);
     void slotChangeProofingConfig();
     void slotPopupPaletteRequestedZoomChange(int zoom);
 
     void channelSelectionChanged();
 
     /**
      * Called whenever the display monitor profile resource changes
      */
     void slotSetDisplayProfile(const KoColorProfile *profile);
     void startUpdateInPatches(const QRect &imageRect);
 
     void slotTrySwitchShapeManager();
 
     /**
      * Called whenever the configuration settings change.
      */
     void slotConfigChanged();
 
 
 private Q_SLOTS:
 
     /// The image projection has changed, now start an update
     /// of the canvas representation.
     void startUpdateCanvasProjection(const QRect & rc);
     void updateCanvasProjection();
 
-    void slotBeginLodResetUpdatesBatch();
-    void slotEndLodResetUpdatesBatch();
+    void slotBeginUpdatesBatch();
+    void slotEndUpdatesBatch();
+    void slotSetLodUpdatesBlocked(bool value);
 
     /**
      * Called whenever the view widget needs to show a different part of
      * the document
      *
      * @param documentOffset the offset in widget pixels
      */
     void documentOffsetMoved(const QPoint &documentOffset);
 
     void slotSelectionChanged();
 
     void slotDoCanvasUpdate();
 
     void bootstrapFinished();
 
     void slotUpdateRegionOfInterest();
 
     void slotReferenceImagesChanged();
 
 public:
 
     bool isPopupPaletteVisible() const;
     void slotShowPopupPalette(const QPoint& = QPoint(0,0));
 
     // interface for KisCanvasController only
     void setWrapAroundViewingMode(bool value);
     bool wrapAroundViewingMode() const;
 
     void setLodAllowedInCanvas(bool value);
     bool lodAllowedInCanvas() const;
 
     void initializeImage();
 
     void setFavoriteResourceManager(KisFavoriteResourceManager* favoriteResourceManager);
 
 private:
     Q_DISABLE_COPY(KisCanvas2)
 
     void connectCurrentCanvas();
     void createCanvas(bool useOpenGL);
     void createQPainterCanvas();
     void createOpenGLCanvas();
     void updateCanvasWidgetImpl(const QRect &rc = QRect());
     void setCanvasWidget(KisAbstractCanvasWidget *widget);
     void resetCanvas(bool useOpenGL);
 
     void notifyLevelOfDetailChange();
 
     // Completes construction of canvas.
     // To be called by KisView in its constructor, once it has been setup enough
     // (to be defined what that means) for things KisCanvas2 expects from KisView
     // TODO: see to avoid that
     void setup();
 
     void initializeFpsDecoration();
 
 private:
     friend class KisView; // calls setup()
     class KisCanvas2Private;
     KisCanvas2Private * const m_d;
 };
 
 #endif
diff --git a/libs/ui/canvas/kis_update_info.cpp b/libs/ui/canvas/kis_update_info.cpp
index 9330a4c2b5..11a23b0669 100644
--- a/libs/ui/canvas/kis_update_info.cpp
+++ b/libs/ui/canvas/kis_update_info.cpp
@@ -1,121 +1,121 @@
 /*
  *  Copyright (c) 2010, Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "kis_update_info.h"
 
 /**
  * The connection in KisCanvas2 uses queued signals
  * with an argument of KisNodeSP type, so we should
  * register it beforehand
  */
 struct KisUpdateInfoSPStaticRegistrar {
     KisUpdateInfoSPStaticRegistrar() {
         qRegisterMetaType<KisUpdateInfoSP>("KisUpdateInfoSP");
     }
 };
 static KisUpdateInfoSPStaticRegistrar __registrar;
 
 KisUpdateInfo::KisUpdateInfo()
 {
 }
 
 KisUpdateInfo::~KisUpdateInfo()
 {
 }
 
 QRect KisUpdateInfo::dirtyViewportRect()
 {
     return QRect();
 }
 
 QRect KisPPUpdateInfo::dirtyViewportRect() {
     return viewportRect.toAlignedRect();
 }
 
 QRect KisPPUpdateInfo::dirtyImageRect() const {
     return dirtyImageRectVar;
 }
 
 int KisPPUpdateInfo::levelOfDetail() const
 {
     return 0;
 }
 
 KisOpenGLUpdateInfo::KisOpenGLUpdateInfo()
     : m_levelOfDetail(0)
 {
 }
 
 QRect KisOpenGLUpdateInfo::dirtyViewportRect() {
     qFatal("Not implemented yet!");
     return QRect();
 }
 
 void KisOpenGLUpdateInfo::assignDirtyImageRect(const QRect &rect)
 {
     m_dirtyImageRect = rect;
 }
 
 void KisOpenGLUpdateInfo::assignLevelOfDetail(int lod)
 {
     m_levelOfDetail = lod;
 }
 
 QRect KisOpenGLUpdateInfo::dirtyImageRect() const
 {
     return m_dirtyImageRect;
 }
 
 int KisOpenGLUpdateInfo::levelOfDetail() const
 {
     return m_levelOfDetail;
 }
 
 bool KisOpenGLUpdateInfo::tryMergeWith(const KisOpenGLUpdateInfo &rhs)
 {
     if (m_levelOfDetail != rhs.m_levelOfDetail) return false;
 
     // TODO: that makes the algorithm of updates compressor incorrect!
     m_dirtyImageRect |= rhs.m_dirtyImageRect;
 
     tileList.append(rhs.tileList);
 
     return true;
 }
 
-KisBatchControlUpdateInfo::KisBatchControlUpdateInfo(KisBatchControlUpdateInfo::Type type, const QRect &dirtyImageRect)
+KisMarkerUpdateInfo::KisMarkerUpdateInfo(KisMarkerUpdateInfo::Type type, const QRect &dirtyImageRect)
     : m_type(type),
       m_dirtyImageRect(dirtyImageRect)
 {
 }
 
-KisBatchControlUpdateInfo::Type KisBatchControlUpdateInfo::type() const
+KisMarkerUpdateInfo::Type KisMarkerUpdateInfo::type() const
 {
     return m_type;
 }
 
-QRect KisBatchControlUpdateInfo::dirtyImageRect() const
+QRect KisMarkerUpdateInfo::dirtyImageRect() const
 {
     return m_dirtyImageRect;
 }
 
-int KisBatchControlUpdateInfo::levelOfDetail() const
+int KisMarkerUpdateInfo::levelOfDetail() const
 {
     // return invalid level of detail to avoid merging the update info
     // with other updates
-    return m_type == StartBatch ? -1 : -2;
+    return -1 - (int)m_type;
 }
diff --git a/libs/ui/canvas/kis_update_info.h b/libs/ui/canvas/kis_update_info.h
index 76ecb7e19e..69dcd03fe8 100644
--- a/libs/ui/canvas/kis_update_info.h
+++ b/libs/ui/canvas/kis_update_info.h
@@ -1,166 +1,168 @@
 /*
  *  Copyright (c) 2010, Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_UPDATE_INFO_H_
 #define KIS_UPDATE_INFO_H_
 
 #include <QPainter>
 
 #include "kis_image_patch.h"
 #include "kis_shared.h"
 #include "kritaui_export.h"
 #include "opengl/kis_texture_tile_update_info.h"
 
 #include "kis_ui_types.h"
 
 class KRITAUI_EXPORT KisUpdateInfo : public KisShared
 {
 public:
     KisUpdateInfo();
     virtual ~KisUpdateInfo();
 
     virtual QRect dirtyViewportRect();
     virtual QRect dirtyImageRect() const = 0;
     virtual int levelOfDetail() const = 0;
 };
 
 Q_DECLARE_METATYPE(KisUpdateInfoSP)
 
 
 struct ConversionOptions {
     ConversionOptions() : m_needsConversion(false) {}
     ConversionOptions(const KoColorSpace *destinationColorSpace,
                       KoColorConversionTransformation::Intent renderingIntent,
                       KoColorConversionTransformation::ConversionFlags conversionFlags)
         : m_needsConversion(true),
           m_destinationColorSpace(destinationColorSpace),
           m_renderingIntent(renderingIntent),
           m_conversionFlags(conversionFlags)
     {
     }
 
 
     bool m_needsConversion;
     const KoColorSpace *m_destinationColorSpace;
     KoColorConversionTransformation::Intent m_renderingIntent;
     KoColorConversionTransformation::ConversionFlags m_conversionFlags;
 };
 
 class KisOpenGLUpdateInfo;
 typedef KisSharedPtr<KisOpenGLUpdateInfo> KisOpenGLUpdateInfoSP;
 
 class KisOpenGLUpdateInfo : public KisUpdateInfo
 {
 public:
     KisOpenGLUpdateInfo();
 
     KisTextureTileUpdateInfoSPList tileList;
 
     QRect dirtyViewportRect() override;
     QRect dirtyImageRect() const override;
 
     void assignDirtyImageRect(const QRect &rect);
     void assignLevelOfDetail(int lod);
 
     int levelOfDetail() const override;
 
     bool tryMergeWith(const KisOpenGLUpdateInfo& rhs);
 
 private:
     QRect m_dirtyImageRect;
     int m_levelOfDetail;
 };
 
 
 class KisPPUpdateInfo : public KisUpdateInfo
 {
 public:
     enum TransferType {
         DIRECT,
         PATCH
     };
 
     QRect dirtyViewportRect() override;
     QRect dirtyImageRect() const override;
     int levelOfDetail() const override;
 
     /**
      * The rect that was reported by KisImage as dirty
      */
     QRect dirtyImageRectVar;
 
     /**
      * Rect of KisImage corresponding to @viewportRect.
      * It is cropped and aligned corresponding to the canvas.
      */
     QRect imageRect;
 
     /**
      * Rect of canvas widget corresponding to @imageRect
      */
     QRectF viewportRect;
 
     qreal scaleX;
     qreal scaleY;
 
     /**
      * Defines the way the source image is painted onto
      * prescaled QImage
      */
     TransferType transfer;
 
     /**
      * Render hints for painting the direct painting/patch painting
      */
     QPainter::RenderHints renderHints;
 
     /**
      * The number of additional pixels those should be added
      * to the patch
      */
     qint32 borderWidth;
 
     /**
      * Used for temporary sorage of KisImage's data
      * by KisProjectionCache
      */
     KisImagePatch patch;
 };
 
-class KisBatchControlUpdateInfo : public KisUpdateInfo
+class KisMarkerUpdateInfo : public KisUpdateInfo
 {
 public:
     enum Type {
-        StartBatch,
-        EndBatch
+        StartBatch = 0,
+        EndBatch,
+        BlockLodUpdates,
+        UnblockLodUpdates,
     };
 
 public:
-    KisBatchControlUpdateInfo(Type type, const QRect &dirtyImageRect);
+    KisMarkerUpdateInfo(Type type, const QRect &dirtyImageRect);
 
     Type type() const;
 
     QRect dirtyImageRect() const override;
     int levelOfDetail() const override;
 
 private:
     Type m_type;
     QRect m_dirtyImageRect;
 };
 
 #endif /* KIS_UPDATE_INFO_H_ */
diff --git a/libs/ui/kis_animation_frame_cache.cpp b/libs/ui/kis_animation_frame_cache.cpp
index 456bcc42a3..0f07cbdec5 100644
--- a/libs/ui/kis_animation_frame_cache.cpp
+++ b/libs/ui/kis_animation_frame_cache.cpp
@@ -1,414 +1,414 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_animation_frame_cache.h"
 
 #include <QMap>
 
 #include "kis_debug.h"
 
 #include "kis_image.h"
 #include "kis_image_animation_interface.h"
 #include "kis_time_range.h"
 #include "KisPart.h"
 #include "kis_animation_cache_populator.h"
 
 #include <KisAbstractFrameCacheSwapper.h>
 #include "KisFrameCacheSwapper.h"
 #include "KisInMemoryFrameCacheSwapper.h"
 
 #include "kis_image_config.h"
 #include "kis_config_notifier.h"
 
 #include "opengl/kis_opengl_image_textures.h"
 
 #include <kis_algebra_2d.h>
 #include <cmath>
 
 
 struct KisAnimationFrameCache::Private
 {
     Private(KisOpenGLImageTexturesSP _textures)
         : textures(_textures)
     {
         image = textures->image();
     }
 
     ~Private()
     {
     }
 
     KisOpenGLImageTexturesSP textures;
     KisImageWSP image;
 
     QScopedPointer<KisAbstractFrameCacheSwapper> swapper;
     int frameSizeLimit = 777;
 
     KisOpenGLUpdateInfoSP fetchFrameDataImpl(KisImageSP image, const QRect &requestedRect, int lod);
 
     struct Frame
     {
         KisOpenGLUpdateInfoSP openGlFrame;
         int length;
 
         Frame(KisOpenGLUpdateInfoSP info, int length)
             : openGlFrame(info), length(length)
         {}
     };
 
     QMap<int, int> newFrames;
 
     int getFrameIdAtTime(int time) const
     {
         if (newFrames.isEmpty()) return -1;
 
         auto it = newFrames.upperBound(time);
 
         if (it != newFrames.constBegin()) it--;
 
         KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(it != newFrames.constEnd(), 0);
         const int start = it.key();
         const int length = it.value();
 
         bool foundFrameValid = false;
 
         if (length == -1) {
             if (start <= time) {
                 foundFrameValid = true;
             }
         } else {
             int end = start + length - 1;
             if (start <= time && time <= end) {
                 foundFrameValid = true;
             }
         }
 
         return foundFrameValid ? start : -1;
     }
 
     bool hasFrame(int time) const {
         return getFrameIdAtTime(time) >= 0;
     }
 
     KisOpenGLUpdateInfoSP getFrame(int time)
     {
         const int frameId = getFrameIdAtTime(time);
         return frameId >= 0 ? swapper->loadFrame(frameId) : 0;
     }
 
     void addFrame(KisOpenGLUpdateInfoSP info, const KisTimeRange& range)
     {
         invalidate(range);
 
         const int length = range.isInfinite() ? -1 : range.end() - range.start() + 1;
         newFrames.insert(range.start(), length);
         swapper->saveFrame(range.start(), info, image->bounds());
     }
 
     /**
      * Invalidate any cached frames within the given time range.
      * @param range
      * @return true if frames were invalidated, false if nothing was changed
      */
     bool invalidate(const KisTimeRange& range)
     {
         if (newFrames.isEmpty()) return false;
 
         bool cacheChanged = false;
 
         auto it = newFrames.lowerBound(range.start());
         if (it.key() != range.start() && it != newFrames.begin()) it--;
 
         while (it != newFrames.end()) {
             const int start = it.key();
             const int length = it.value();
             const bool frameIsInfinite = (length == -1);
             const int end = start + length - 1;
 
             if (start >= range.start()) {
                 if (!range.isInfinite() && start > range.end()) {
                     break;
                 }
 
                 if (!range.isInfinite() && (frameIsInfinite || end > range.end())) {
                     // Reinsert with a later start
                     int newStart = range.end() + 1;
                     int newLength = frameIsInfinite ? -1 : (end - newStart + 1);
 
                     newFrames.insert(newStart, newLength);
                     swapper->moveFrame(start, newStart);
                 } else {
                     swapper->forgetFrame(start);
                 }
 
                 it = newFrames.erase(it);
 
                 cacheChanged = true;
                 continue;
 
             } else if (frameIsInfinite || end >= range.start()) {
                 const int newEnd = range.start() - 1;
                 *it = newEnd - start + 1;
 
                 cacheChanged = true;
             }
 
             it++;
         }
 
         return cacheChanged;
     }
 
     int effectiveLevelOfDetail(const QRect &rc) const {
         if (!frameSizeLimit) return 0;
 
         const int maxDimension = KisAlgebra2D::maxDimension(rc);
 
         const qreal minLod = -std::log2(qreal(frameSizeLimit) / maxDimension);
         const int lodLimit = qMax(0, qCeil(minLod));
         return lodLimit;
     }
 
 
     // TODO: verify that we don't have any leak here!
     typedef QMap<KisOpenGLImageTexturesSP, KisAnimationFrameCache*> CachesMap;
     static CachesMap caches;
 };
 
 KisAnimationFrameCache::Private::CachesMap KisAnimationFrameCache::Private::caches;
 
 KisAnimationFrameCacheSP KisAnimationFrameCache::getFrameCache(KisOpenGLImageTexturesSP textures)
 {
     KisAnimationFrameCache *cache;
 
     Private::CachesMap::iterator it = Private::caches.find(textures);
     if (it == Private::caches.end()) {
         cache = new KisAnimationFrameCache(textures);
         Private::caches.insert(textures, cache);
     } else {
         cache = it.value();
     }
 
     return cache;
 }
 
 const QList<KisAnimationFrameCache *> KisAnimationFrameCache::caches()
 {
     return Private::caches.values();
 }
 
 KisAnimationFrameCache::KisAnimationFrameCache(KisOpenGLImageTexturesSP textures)
     : m_d(new Private(textures))
 {
     // create swapping backend
     slotConfigChanged();
 
     connect(m_d->image->animationInterface(), SIGNAL(sigFramesChanged(KisTimeRange,QRect)), this, SLOT(framesChanged(KisTimeRange,QRect)));
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
 }
 
 KisAnimationFrameCache::~KisAnimationFrameCache()
 {
     Private::caches.remove(m_d->textures);
 }
 
 bool KisAnimationFrameCache::uploadFrame(int time)
 {
     KisOpenGLUpdateInfoSP info = m_d->getFrame(time);
 
     if (!info) {
         // Do nothing!
         //
         // Previously we were trying to start cache regeneration in this point,
         // but it caused even bigger slowdowns when scrubbing
     } else {
-        m_d->textures->recalculateCache(info);
+        m_d->textures->recalculateCache(info, false);
     }
 
     return bool(info);
 }
 
 bool KisAnimationFrameCache::shouldUploadNewFrame(int newTime, int oldTime) const
 {
     if (oldTime < 0) return true;
 
     const int oldKeyframeStart = m_d->getFrameIdAtTime(oldTime);
     if (oldKeyframeStart < 0) return true;
 
     const int oldKeyFrameLength = m_d->newFrames[oldKeyframeStart];
     return !(newTime >= oldKeyframeStart && (newTime < oldKeyframeStart + oldKeyFrameLength || oldKeyFrameLength == -1));
 }
 
 KisAnimationFrameCache::CacheStatus KisAnimationFrameCache::frameStatus(int time) const
 {
     return m_d->hasFrame(time) ? Cached : Uncached;
 }
 
 KisImageWSP KisAnimationFrameCache::image()
 {
     return m_d->image;
 }
 
 void KisAnimationFrameCache::framesChanged(const KisTimeRange &range, const QRect &rect)
 {
     Q_UNUSED(rect);
 
     if (!range.isValid()) return;
 
     bool cacheChanged = m_d->invalidate(range);
 
     if (cacheChanged) {
         emit changed();
     }
 }
 
 void KisAnimationFrameCache::slotConfigChanged()
 {
     m_d->newFrames.clear();
 
     KisImageConfig cfg;
 
     if (cfg.useOnDiskAnimationCacheSwapping()) {
         m_d->swapper.reset(new KisFrameCacheSwapper(m_d->textures->updateInfoBuilder(), cfg.swapDir()));
     } else {
         m_d->swapper.reset(new KisInMemoryFrameCacheSwapper());
     }
 
     m_d->frameSizeLimit = cfg.useAnimationCacheFrameSizeLimit() ? cfg.animationCacheFrameSizeLimit() : 0;
     emit changed();
 }
 
 KisOpenGLUpdateInfoSP KisAnimationFrameCache::Private::fetchFrameDataImpl(KisImageSP image, const QRect &requestedRect, int lod)
 {
     if (lod > 0) {
         KisPaintDeviceSP tempDevice = new KisPaintDevice(image->projection()->colorSpace());
         tempDevice->prepareClone(image->projection());
         image->projection()->generateLodCloneDevice(tempDevice, image->projection()->extent(), lod);
 
         const QRect fetchRect = KisLodTransform::alignedRect(requestedRect, lod);
         return textures->updateInfoBuilder().buildUpdateInfo(fetchRect, tempDevice, image->bounds(), lod, true);
     } else {
         return textures->updateCache(requestedRect, image);
     }
 }
 
 KisOpenGLUpdateInfoSP KisAnimationFrameCache::fetchFrameData(int time, KisImageSP image, const QRegion &requestedRegion) const
 {
     if (time != image->animationInterface()->currentTime()) {
         qWarning() << "WARNING: KisAnimationFrameCache::frameReady image's time doesn't coincide with the requested time!";
         qWarning() << "    "  << ppVar(image->animationInterface()->currentTime()) << ppVar(time);
     }
 
     // the frames are always generated at full scale
     KIS_SAFE_ASSERT_RECOVER_NOOP(image->currentLevelOfDetail() == 0);
 
     const int lod = m_d->effectiveLevelOfDetail(requestedRegion.boundingRect());
 
     KisOpenGLUpdateInfoSP totalInfo;
 
     Q_FOREACH (const QRect &rc, requestedRegion.rects()) {
         KisOpenGLUpdateInfoSP info = m_d->fetchFrameDataImpl(image, rc, lod);
         if (!totalInfo) {
             totalInfo = info;
         } else {
             const bool result = totalInfo->tryMergeWith(*info);
             KIS_SAFE_ASSERT_RECOVER_NOOP(result);
         }
     }
 
     return totalInfo;
 }
 
 void KisAnimationFrameCache::addConvertedFrameData(KisOpenGLUpdateInfoSP info, int time)
 {
     const KisTimeRange identicalRange =
         KisTimeRange::calculateIdenticalFramesRecursive(m_d->image->root(), time);
 
     m_d->addFrame(info, identicalRange);
 
     emit changed();
 }
 
 void KisAnimationFrameCache::dropLowQualityFrames(const KisTimeRange &range, const QRect &regionOfInterest, const QRect &minimalRect)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(!range.isInfinite());
     if (m_d->newFrames.isEmpty()) return;
 
     auto it = m_d->newFrames.upperBound(range.start());
 
     // the vector is guaranteed to be non-empty,
     // so decrementing iterator is safe
     if (it != m_d->newFrames.begin()) it--;
 
     while (it != m_d->newFrames.end() && it.key() <= range.end()) {
         const int frameId = it.key();
         const int frameLength = it.value();
 
         if (frameId + frameLength - 1 < range.start()) {
             ++it;
             continue;
         }
 
         const QRect frameRect = m_d->swapper->frameDirtyRect(frameId);
         const int frameLod = m_d->swapper->frameLevelOfDetail(frameId);
 
         if (frameLod > m_d->effectiveLevelOfDetail(regionOfInterest) || !frameRect.contains(minimalRect)) {
             m_d->swapper->forgetFrame(frameId);
             it = m_d->newFrames.erase(it);
         } else {
             ++it;
         }
     }
 }
 
 bool KisAnimationFrameCache::framesHaveValidRoi(const KisTimeRange &range, const QRect &regionOfInterest)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!range.isInfinite(), false);
     if (m_d->newFrames.isEmpty()) return false;
 
     auto it = m_d->newFrames.upperBound(range.start());
 
     if (it != m_d->newFrames.begin()) it--;
 
     int expectedNextFrameStart = it.key();
 
     while (it.key() <= range.end()) {
         const int frameId = it.key();
         const int frameLength = it.value();
 
         if (frameId + frameLength - 1 < range.start()) {
             expectedNextFrameStart = frameId + frameLength;
             ++it;
             continue;
         }
 
         if (expectedNextFrameStart != frameId) {
             KIS_SAFE_ASSERT_RECOVER_NOOP(expectedNextFrameStart < frameId);
             return false;
         }
 
         if (!m_d->swapper->frameDirtyRect(frameId).contains(regionOfInterest)) {
             return false;
         }
 
         expectedNextFrameStart = frameId + frameLength;
         ++it;
     }
 
     return true;
 }
diff --git a/libs/ui/opengl/kis_opengl_canvas2.cpp b/libs/ui/opengl/kis_opengl_canvas2.cpp
index 0b874fec92..9cf4f12787 100644
--- a/libs/ui/opengl/kis_opengl_canvas2.cpp
+++ b/libs/ui/opengl/kis_opengl_canvas2.cpp
@@ -1,959 +1,959 @@
 /* This file is part of the KDE project
  * Copyright (C) Boudewijn Rempt <boud@valdyas.org>, (C) 2006-2013
  * Copyright (C) 2015 Michael Abrahams <miabraha@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.
  */
 
 #define GL_GLEXT_PROTOTYPES
 
 #include "opengl/kis_opengl_canvas2.h"
 #include "opengl/kis_opengl_canvas2_p.h"
 
 #include "opengl/kis_opengl_shader_loader.h"
 #include "opengl/kis_opengl_canvas_debugger.h"
 #include "canvas/kis_canvas2.h"
 #include "canvas/kis_coordinates_converter.h"
 #include "canvas/kis_display_filter.h"
 #include "canvas/kis_display_color_converter.h"
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_debug.h"
 
 #include <QPainter>
 #include <QPainterPath>
 #include <QPointF>
 #include <QMatrix>
 #include <QTransform>
 #include <QThread>
 #include <QFile>
 #include <QOpenGLShaderProgram>
 #include <QOpenGLVertexArrayObject>
 #include <QOpenGLBuffer>
 #include <QMessageBox>
 
 #ifndef Q_OS_OSX
 #include <QOpenGLFunctions_2_1>
 #endif
 
 #define NEAR_VAL -1000.0
 #define FAR_VAL 1000.0
 
 #ifndef GL_CLAMP_TO_EDGE
 #define GL_CLAMP_TO_EDGE 0x812F
 #endif
 
 #define PROGRAM_VERTEX_ATTRIBUTE 0
 #define PROGRAM_TEXCOORD_ATTRIBUTE 1
 
 static bool OPENGL_SUCCESS = false;
 
 struct KisOpenGLCanvas2::Private
 {
 public:
     ~Private() {
         delete displayShader;
         delete checkerShader;
         delete solidColorShader;
         Sync::deleteSync(glSyncObject);
     }
 
     bool canvasInitialized{false};
 
     KisOpenGLImageTexturesSP openGLImageTextures;
 
     KisOpenGLShaderLoader shaderLoader;
     KisShaderProgram *displayShader{0};
     KisShaderProgram *checkerShader{0};
     KisShaderProgram *solidColorShader{0};
     bool displayShaderCompiledWithDisplayFilterSupport{false};
 
     GLfloat checkSizeScale;
     bool scrollCheckers;
 
     QSharedPointer<KisDisplayFilter> displayFilter;
     KisOpenGL::FilterMode filterMode;
     bool proofingConfigIsUpdated=false;
 
     GLsync glSyncObject{0};
 
     bool wrapAroundMode{false};
 
     // Stores a quad for drawing the canvas
     QOpenGLVertexArrayObject quadVAO;
     QOpenGLBuffer quadBuffers[2];
 
     // Stores data for drawing tool outlines
     QOpenGLVertexArrayObject outlineVAO;
     QOpenGLBuffer lineBuffer;
 
     QVector3D vertices[6];
     QVector2D texCoords[6];
 
 #ifndef Q_OS_OSX
     QOpenGLFunctions_2_1 *glFn201;
 #endif
 
     qreal pixelGridDrawingThreshold;
     bool pixelGridEnabled;
     QColor gridColor;
     QColor cursorColor;
 
     bool lodSwitchInProgress = false;
 
     int xToColWithWrapCompensation(int x, const QRect &imageRect) {
         int firstImageColumn = openGLImageTextures->xToCol(imageRect.left());
         int lastImageColumn = openGLImageTextures->xToCol(imageRect.right());
 
         int colsPerImage = lastImageColumn - firstImageColumn + 1;
         int numWraps = floor(qreal(x) / imageRect.width());
         int remainder = x - imageRect.width() * numWraps;
 
         return colsPerImage * numWraps + openGLImageTextures->xToCol(remainder);
     }
 
     int yToRowWithWrapCompensation(int y, const QRect &imageRect) {
         int firstImageRow = openGLImageTextures->yToRow(imageRect.top());
         int lastImageRow = openGLImageTextures->yToRow(imageRect.bottom());
 
         int rowsPerImage = lastImageRow - firstImageRow + 1;
         int numWraps = floor(qreal(y) / imageRect.height());
         int remainder = y - imageRect.height() * numWraps;
 
         return rowsPerImage * numWraps + openGLImageTextures->yToRow(remainder);
     }
 
 };
 
 KisOpenGLCanvas2::KisOpenGLCanvas2(KisCanvas2 *canvas,
                                    KisCoordinatesConverter *coordinatesConverter,
                                    QWidget *parent,
                                    KisImageWSP image,
                                    KisDisplayColorConverter *colorConverter)
     : QOpenGLWidget(parent)
     , KisCanvasWidgetBase(canvas, coordinatesConverter)
     , d(new Private())
 {
     KisConfig cfg;
     cfg.setCanvasState("OPENGL_STARTED");
 
     d->openGLImageTextures =
             KisOpenGLImageTextures::getImageTextures(image,
                                                      colorConverter->monitorProfile(),
                                                      colorConverter->renderingIntent(),
                                                      colorConverter->conversionFlags());
 
     setAcceptDrops(true);
     setAutoFillBackground(false);
 
     setFocusPolicy(Qt::StrongFocus);
     setAttribute(Qt::WA_NoSystemBackground, true);
 #ifdef Q_OS_OSX
     setAttribute(Qt::WA_AcceptTouchEvents, false);
 #else
     setAttribute(Qt::WA_AcceptTouchEvents, true);
 #endif
     setAttribute(Qt::WA_InputMethodEnabled, false);
     setAttribute(Qt::WA_DontCreateNativeAncestors, true);
 
     setDisplayFilterImpl(colorConverter->displayFilter(), true);
 
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
     connect(KisConfigNotifier::instance(), SIGNAL(pixelGridModeChanged()), SLOT(slotPixelGridModeChanged()));
     slotConfigChanged();
     slotPixelGridModeChanged();
     cfg.writeEntry("canvasState", "OPENGL_SUCCESS");
 }
 
 KisOpenGLCanvas2::~KisOpenGLCanvas2()
 {
     delete d;
 }
 
 void KisOpenGLCanvas2::setDisplayFilter(QSharedPointer<KisDisplayFilter> displayFilter)
 {
     setDisplayFilterImpl(displayFilter, false);
 }
 
 void KisOpenGLCanvas2::setDisplayFilterImpl(QSharedPointer<KisDisplayFilter> displayFilter, bool initializing)
 {
     bool needsInternalColorManagement =
             !displayFilter || displayFilter->useInternalColorManagement();
 
     bool needsFullRefresh = d->openGLImageTextures->setInternalColorManagementActive(needsInternalColorManagement);
 
     d->displayFilter = displayFilter;
 
     if (!initializing && needsFullRefresh) {
         canvas()->startUpdateInPatches(canvas()->image()->bounds());
     }
     else if (!initializing)  {
         canvas()->updateCanvas();
     }
 }
 
 void KisOpenGLCanvas2::setWrapAroundViewingMode(bool value)
 {
     d->wrapAroundMode = value;
     update();
 }
 
 inline void rectToVertices(QVector3D* vertices, const QRectF &rc)
 {
     vertices[0] = QVector3D(rc.left(),  rc.bottom(), 0.f);
     vertices[1] = QVector3D(rc.left(),  rc.top(),    0.f);
     vertices[2] = QVector3D(rc.right(), rc.bottom(), 0.f);
     vertices[3] = QVector3D(rc.left(),  rc.top(), 0.f);
     vertices[4] = QVector3D(rc.right(), rc.top(), 0.f);
     vertices[5] = QVector3D(rc.right(), rc.bottom(),    0.f);
 }
 
 inline void rectToTexCoords(QVector2D* texCoords, const QRectF &rc)
 {
     texCoords[0] = QVector2D(rc.left(), rc.bottom());
     texCoords[1] = QVector2D(rc.left(), rc.top());
     texCoords[2] = QVector2D(rc.right(), rc.bottom());
     texCoords[3] = QVector2D(rc.left(), rc.top());
     texCoords[4] = QVector2D(rc.right(), rc.top());
     texCoords[5] = QVector2D(rc.right(), rc.bottom());
 }
 
 void KisOpenGLCanvas2::initializeGL()
 {
     KisOpenGL::initializeContext(context());
     initializeOpenGLFunctions();
 #ifndef Q_OS_OSX
     if (!KisOpenGL::hasOpenGLES()) {
         d->glFn201 = context()->versionFunctions<QOpenGLFunctions_2_1>();
         if (!d->glFn201) {
             warnUI << "Cannot obtain QOpenGLFunctions_2_1, glLogicOp cannot be used";
         }
     } else {
         d->glFn201 = nullptr;
     }
 #endif
 
     KisConfig cfg;
     d->openGLImageTextures->setProofingConfig(canvas()->proofingConfiguration());
     d->openGLImageTextures->initGL(context()->functions());
     d->openGLImageTextures->generateCheckerTexture(createCheckersImage(cfg.checkSize()));
 
     initializeShaders();
 
     // If we support OpenGL 3.2, then prepare our VAOs and VBOs for drawing
     if (KisOpenGL::hasOpenGL3()) {
         d->quadVAO.create();
         d->quadVAO.bind();
 
         glEnableVertexAttribArray(PROGRAM_VERTEX_ATTRIBUTE);
         glEnableVertexAttribArray(PROGRAM_TEXCOORD_ATTRIBUTE);
 
         // Create the vertex buffer object, it has 6 vertices with 3 components
         d->quadBuffers[0].create();
         d->quadBuffers[0].setUsagePattern(QOpenGLBuffer::StaticDraw);
         d->quadBuffers[0].bind();
         d->quadBuffers[0].allocate(d->vertices, 6 * 3 * sizeof(float));
         glVertexAttribPointer(PROGRAM_VERTEX_ATTRIBUTE, 3, GL_FLOAT, GL_FALSE, 0, 0);
 
         // Create the texture buffer object, it has 6 texture coordinates with 2 components
         d->quadBuffers[1].create();
         d->quadBuffers[1].setUsagePattern(QOpenGLBuffer::StaticDraw);
         d->quadBuffers[1].bind();
         d->quadBuffers[1].allocate(d->texCoords, 6 * 2 * sizeof(float));
         glVertexAttribPointer(PROGRAM_TEXCOORD_ATTRIBUTE, 2, GL_FLOAT, GL_FALSE, 0, 0);
 
         // Create the outline buffer, this buffer will store the outlines of
         // tools and will frequently change data
         d->outlineVAO.create();
         d->outlineVAO.bind();
 
         glEnableVertexAttribArray(PROGRAM_VERTEX_ATTRIBUTE);
 
         // The outline buffer has a StreamDraw usage pattern, because it changes constantly
         d->lineBuffer.create();
         d->lineBuffer.setUsagePattern(QOpenGLBuffer::StreamDraw);
         d->lineBuffer.bind();
         glVertexAttribPointer(PROGRAM_VERTEX_ATTRIBUTE, 3, GL_FLOAT, GL_FALSE, 0, 0);
     }
 
     Sync::init(context());
 
     d->canvasInitialized = true;
 }
 
 /**
  * Loads all shaders and reports compilation problems
  */
 void KisOpenGLCanvas2::initializeShaders()
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(!d->canvasInitialized);
 
     delete d->checkerShader;
     delete d->solidColorShader;
     d->checkerShader = 0;
     d->solidColorShader = 0;
 
     try {
         d->checkerShader = d->shaderLoader.loadCheckerShader();
         d->solidColorShader = d->shaderLoader.loadSolidColorShader();
     } catch (const ShaderLoaderException &e) {
         reportFailedShaderCompilation(e.what());
     }
 
     initializeDisplayShader();
 }
 
 void KisOpenGLCanvas2::initializeDisplayShader()
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(!d->canvasInitialized);
 
     bool useHiQualityFiltering = d->filterMode == KisOpenGL::HighQualityFiltering;
 
     delete d->displayShader;
     d->displayShader = 0;
 
     try {
         d->displayShader = d->shaderLoader.loadDisplayShader(d->displayFilter, useHiQualityFiltering);
         d->displayShaderCompiledWithDisplayFilterSupport = d->displayFilter;
     } catch (const ShaderLoaderException &e) {
         reportFailedShaderCompilation(e.what());
     }
 }
 
 /**
  * Displays a message box telling the user that
  * shader compilation failed and turns off OpenGL.
  */
 void KisOpenGLCanvas2::reportFailedShaderCompilation(const QString &context)
 {
     KisConfig cfg;
 
     qDebug() << "Shader Compilation Failure: " << context;
     QMessageBox::critical(this, i18nc("@title:window", "Krita"),
                           i18n("Krita could not initialize the OpenGL canvas:\n\n%1\n\n Krita will disable OpenGL and close now.", context),
                           QMessageBox::Close);
 
     cfg.setUseOpenGL(false);
     cfg.setCanvasState("OPENGL_FAILED");
 }
 
 void KisOpenGLCanvas2::resizeGL(int width, int height)
 {
     coordinatesConverter()->setCanvasWidgetSize(QSize(width, height));
     paintGL();
 }
 
 void KisOpenGLCanvas2::paintGL()
 {
     if (!OPENGL_SUCCESS) {
         KisConfig cfg;
         cfg.writeEntry("canvasState", "OPENGL_PAINT_STARTED");
     }
 
     KisOpenglCanvasDebugger::instance()->nofityPaintRequested();
 
     renderCanvasGL();
 
     if (d->glSyncObject) {
         Sync::deleteSync(d->glSyncObject);
     }
     d->glSyncObject = Sync::getSync();
 
     QPainter gc(this);
     renderDecorations(&gc);
     gc.end();
 
     if (!OPENGL_SUCCESS) {
         KisConfig cfg;
         cfg.writeEntry("canvasState", "OPENGL_SUCCESS");
         OPENGL_SUCCESS = true;
     }
 }
 
 void KisOpenGLCanvas2::paintToolOutline(const QPainterPath &path)
 {
     if (!d->solidColorShader->bind()) {
         return;
     }
 
     // setup the mvp transformation
     QMatrix4x4 projectionMatrix;
     projectionMatrix.setToIdentity();
     projectionMatrix.ortho(0, width(), height(), 0, NEAR_VAL, FAR_VAL);
 
     // Set view/projection matrices
     QMatrix4x4 modelMatrix(coordinatesConverter()->flakeToWidgetTransform());
     modelMatrix.optimize();
     modelMatrix = projectionMatrix * modelMatrix;
     d->solidColorShader->setUniformValue(d->solidColorShader->location(Uniform::ModelViewProjection), modelMatrix);
 
     if (!KisOpenGL::hasOpenGLES()) {
         glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
 
         glEnable(GL_COLOR_LOGIC_OP);
 #ifndef Q_OS_OSX
         if (d->glFn201) {
             d->glFn201->glLogicOp(GL_XOR);
         }
 #else
         glLogicOp(GL_XOR);
 #endif
     } else {
         glEnable(GL_BLEND);
         glBlendFuncSeparate(GL_ONE_MINUS_DST_COLOR, GL_ZERO, GL_ONE, GL_ONE);
     }
 
     d->solidColorShader->setUniformValue(
                 d->solidColorShader->location(Uniform::FragmentColor),
                 QVector4D(d->cursorColor.redF(), d->cursorColor.greenF(), d->cursorColor.blueF(), 1.0f));
 
     // Paint the tool outline
     if (KisOpenGL::hasOpenGL3()) {
         d->outlineVAO.bind();
         d->lineBuffer.bind();
     }
 
     // Convert every disjointed subpath to a polygon and draw that polygon
     QList<QPolygonF> subPathPolygons = path.toSubpathPolygons();
     for (int i = 0; i < subPathPolygons.size(); i++) {
         const QPolygonF& polygon = subPathPolygons.at(i);
 
         QVector<QVector3D> vertices;
         vertices.resize(polygon.count());
 
         for (int j = 0; j < polygon.count(); j++) {
             QPointF p = polygon.at(j);
             vertices[j].setX(p.x());
             vertices[j].setY(p.y());
         }
         if (KisOpenGL::hasOpenGL3()) {
             d->lineBuffer.allocate(vertices.constData(), 3 * vertices.size() * sizeof(float));
         }
         else {
             d->solidColorShader->enableAttributeArray(PROGRAM_VERTEX_ATTRIBUTE);
             d->solidColorShader->setAttributeArray(PROGRAM_VERTEX_ATTRIBUTE, vertices.constData());
         }
 
         glDrawArrays(GL_LINE_STRIP, 0, vertices.size());
     }
 
     if (KisOpenGL::hasOpenGL3()) {
         d->lineBuffer.release();
         d->outlineVAO.release();
     }
 
     if (!KisOpenGL::hasOpenGLES()) {
         glDisable(GL_COLOR_LOGIC_OP);
     } else {
         glDisable(GL_BLEND);
     }
 
     d->solidColorShader->release();
 }
 
 bool KisOpenGLCanvas2::isBusy() const
 {
     const bool isBusyStatus = Sync::syncStatus(d->glSyncObject) == Sync::Unsignaled;
     KisOpenglCanvasDebugger::instance()->nofitySyncStatus(isBusyStatus);
 
     return isBusyStatus;
 }
 
 void KisOpenGLCanvas2::setLodResetInProgress(bool value)
 {
     d->lodSwitchInProgress = value;
 }
 
 void KisOpenGLCanvas2::drawCheckers()
 {
     if (!d->checkerShader) {
         return;
     }
 
     KisCoordinatesConverter *converter = coordinatesConverter();
     QTransform textureTransform;
     QTransform modelTransform;
     QRectF textureRect;
     QRectF modelRect;
 
     QRectF viewportRect = !d->wrapAroundMode ?
                 converter->imageRectInViewportPixels() :
                 converter->widgetToViewport(this->rect());
 
     if (!canvas()->renderingLimit().isEmpty()) {
         const QRect vrect = converter->imageToViewport(canvas()->renderingLimit()).toAlignedRect();
         viewportRect &= vrect;
     }
 
     converter->getOpenGLCheckersInfo(viewportRect,
                                      &textureTransform, &modelTransform, &textureRect, &modelRect, d->scrollCheckers);
 
     textureTransform *= QTransform::fromScale(d->checkSizeScale / KisOpenGLImageTextures::BACKGROUND_TEXTURE_SIZE,
                                               d->checkSizeScale / KisOpenGLImageTextures::BACKGROUND_TEXTURE_SIZE);
 
     if (!d->checkerShader->bind()) {
         qWarning() << "Could not bind checker shader";
         return;
     }
 
     QMatrix4x4 projectionMatrix;
     projectionMatrix.setToIdentity();
     projectionMatrix.ortho(0, width(), height(), 0, NEAR_VAL, FAR_VAL);
 
     // Set view/projection matrices
     QMatrix4x4 modelMatrix(modelTransform);
     modelMatrix.optimize();
     modelMatrix = projectionMatrix * modelMatrix;
     d->checkerShader->setUniformValue(d->checkerShader->location(Uniform::ModelViewProjection), modelMatrix);
 
     QMatrix4x4 textureMatrix(textureTransform);
     d->checkerShader->setUniformValue(d->checkerShader->location(Uniform::TextureMatrix), textureMatrix);
 
     //Setup the geometry for rendering
     if (KisOpenGL::hasOpenGL3()) {
         rectToVertices(d->vertices, modelRect);
         d->quadBuffers[0].bind();
         d->quadBuffers[0].write(0, d->vertices, 3 * 6 * sizeof(float));
 
         rectToTexCoords(d->texCoords, textureRect);
         d->quadBuffers[1].bind();
         d->quadBuffers[1].write(0, d->texCoords, 2 * 6 * sizeof(float));
     }
     else {
         rectToVertices(d->vertices, modelRect);
         d->checkerShader->enableAttributeArray(PROGRAM_VERTEX_ATTRIBUTE);
         d->checkerShader->setAttributeArray(PROGRAM_VERTEX_ATTRIBUTE, d->vertices);
 
         rectToTexCoords(d->texCoords, textureRect);
         d->checkerShader->enableAttributeArray(PROGRAM_TEXCOORD_ATTRIBUTE);
         d->checkerShader->setAttributeArray(PROGRAM_TEXCOORD_ATTRIBUTE, d->texCoords);
     }
 
     // render checkers
     glActiveTexture(GL_TEXTURE0);
     glBindTexture(GL_TEXTURE_2D, d->openGLImageTextures->checkerTexture());
 
     glDrawArrays(GL_TRIANGLES, 0, 6);
 
     glBindTexture(GL_TEXTURE_2D, 0);
     d->checkerShader->release();
     glBindBuffer(GL_ARRAY_BUFFER, 0);
 }
 
 void KisOpenGLCanvas2::drawGrid()
 {
     if (!d->solidColorShader->bind()) {
         return;
     }
 
     QMatrix4x4 projectionMatrix;
     projectionMatrix.setToIdentity();
     projectionMatrix.ortho(0, width(), height(), 0, NEAR_VAL, FAR_VAL);
 
     // Set view/projection matrices
     QMatrix4x4 modelMatrix(coordinatesConverter()->imageToWidgetTransform());
     modelMatrix.optimize();
     modelMatrix = projectionMatrix * modelMatrix;
     d->solidColorShader->setUniformValue(d->solidColorShader->location(Uniform::ModelViewProjection), modelMatrix);
 
     glEnable(GL_BLEND);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
     d->solidColorShader->setUniformValue(
                 d->solidColorShader->location(Uniform::FragmentColor),
                 QVector4D(d->gridColor.redF(), d->gridColor.greenF(), d->gridColor.blueF(), 0.5f));
 
     if (KisOpenGL::hasOpenGL3()) {
         d->outlineVAO.bind();
         d->lineBuffer.bind();
     }
 
     QRectF widgetRect(0,0, width(), height());
     QRectF widgetRectInImagePixels = coordinatesConverter()->documentToImage(coordinatesConverter()->widgetToDocument(widgetRect));
     QRect wr = widgetRectInImagePixels.toAlignedRect();
 
     if (!d->wrapAroundMode) {
         wr &= d->openGLImageTextures->storedImageBounds();
     }
 
     QPoint topLeftCorner = wr.topLeft();
     QPoint bottomRightCorner = wr.bottomRight() + QPoint(1, 1);
     QVector<QVector3D> grid;
 
     for (int i = topLeftCorner.x(); i <= bottomRightCorner.x(); ++i) {
         grid.append(QVector3D(i, topLeftCorner.y(), 0));
         grid.append(QVector3D(i, bottomRightCorner.y(), 0));
     }
     for (int i = topLeftCorner.y(); i <= bottomRightCorner.y(); ++i) {
         grid.append(QVector3D(topLeftCorner.x(), i, 0));
         grid.append(QVector3D(bottomRightCorner.x(), i, 0));
     }
 
     if (KisOpenGL::hasOpenGL3()) {
         d->lineBuffer.allocate(grid.constData(), 3 * grid.size() * sizeof(float));
     }
     else {
         d->solidColorShader->enableAttributeArray(PROGRAM_VERTEX_ATTRIBUTE);
         d->solidColorShader->setAttributeArray(PROGRAM_VERTEX_ATTRIBUTE, grid.constData());
     }
 
     glDrawArrays(GL_LINES, 0, grid.size());
 
     if (KisOpenGL::hasOpenGL3()) {
         d->lineBuffer.release();
         d->outlineVAO.release();
     }
 
     d->solidColorShader->release();
     glDisable(GL_BLEND);
 }
 
 void KisOpenGLCanvas2::drawImage()
 {
     if (!d->displayShader) {
         return;
     }
 
     glEnable(GL_BLEND);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
     KisCoordinatesConverter *converter = coordinatesConverter();
 
     d->displayShader->bind();
 
     QMatrix4x4 projectionMatrix;
     projectionMatrix.setToIdentity();
     projectionMatrix.ortho(0, width(), height(), 0, NEAR_VAL, FAR_VAL);
 
     // Set view/projection matrices
     QMatrix4x4 modelMatrix(converter->imageToWidgetTransform());
     modelMatrix.optimize();
     modelMatrix = projectionMatrix * modelMatrix;
     d->displayShader->setUniformValue(d->displayShader->location(Uniform::ModelViewProjection), modelMatrix);
 
     QMatrix4x4 textureMatrix;
     textureMatrix.setToIdentity();
     d->displayShader->setUniformValue(d->displayShader->location(Uniform::TextureMatrix), textureMatrix);
 
     QRectF widgetRect(0,0, width(), height());
     QRectF widgetRectInImagePixels = converter->documentToImage(converter->widgetToDocument(widgetRect));
 
     const QRect renderingLimit = canvas()->renderingLimit();
 
     if (!renderingLimit.isEmpty()) {
         widgetRectInImagePixels &= renderingLimit;
     }
 
     qreal scaleX, scaleY;
     converter->imageScale(&scaleX, &scaleY);
     d->displayShader->setUniformValue(d->displayShader->location(Uniform::ViewportScale), (GLfloat) scaleX);
     d->displayShader->setUniformValue(d->displayShader->location(Uniform::TexelSize), (GLfloat) d->openGLImageTextures->texelSize());
 
     QRect ir = d->openGLImageTextures->storedImageBounds();
     QRect wr = widgetRectInImagePixels.toAlignedRect();
 
     if (!d->wrapAroundMode) {
         // if we don't want to paint wrapping images, just limit the
         // processing area, and the code will handle all the rest
         wr &= ir;
     }
 
     int firstColumn = d->xToColWithWrapCompensation(wr.left(), ir);
     int lastColumn = d->xToColWithWrapCompensation(wr.right(), ir);
     int firstRow = d->yToRowWithWrapCompensation(wr.top(), ir);
     int lastRow = d->yToRowWithWrapCompensation(wr.bottom(), ir);
 
     int minColumn = d->openGLImageTextures->xToCol(ir.left());
     int maxColumn = d->openGLImageTextures->xToCol(ir.right());
     int minRow = d->openGLImageTextures->yToRow(ir.top());
     int maxRow = d->openGLImageTextures->yToRow(ir.bottom());
 
     int imageColumns = maxColumn - minColumn + 1;
     int imageRows = maxRow - minRow + 1;
 
     for (int col = firstColumn; col <= lastColumn; col++) {
         for (int row = firstRow; row <= lastRow; row++) {
 
             int effectiveCol = col;
             int effectiveRow = row;
             QPointF tileWrappingTranslation;
 
             if (effectiveCol > maxColumn || effectiveCol < minColumn) {
                 int translationStep = floor(qreal(col) / imageColumns);
                 int originCol = translationStep * imageColumns;
                 effectiveCol = col - originCol;
                 tileWrappingTranslation.rx() = translationStep * ir.width();
             }
 
             if (effectiveRow > maxRow || effectiveRow < minRow) {
                 int translationStep = floor(qreal(row) / imageRows);
                 int originRow = translationStep * imageRows;
                 effectiveRow = row - originRow;
                 tileWrappingTranslation.ry() = translationStep * ir.height();
             }
 
             KisTextureTile *tile =
                     d->openGLImageTextures->getTextureTileCR(effectiveCol, effectiveRow);
 
             if (!tile) {
                 warnUI << "OpenGL: Trying to paint texture tile but it has not been created yet.";
                 continue;
             }
 
             /*
              * We create a float rect here to workaround Qt's
              * "history reasons" in calculation of right()
              * and bottom() coordinates of integer rects.
              */
 
             QRectF textureRect;
             QRectF modelRect;
 
             if (renderingLimit.isEmpty()) {
                 textureRect = tile->tileRectInTexturePixels();
                 modelRect = tile->tileRectInImagePixels().translated(tileWrappingTranslation.x(), tileWrappingTranslation.y());
             } else {
                 const QRect limitedTileRect = tile->tileRectInImagePixels() & renderingLimit;
                 textureRect = tile->imageRectInTexturePixels(limitedTileRect);
                 modelRect = limitedTileRect.translated(tileWrappingTranslation.x(), tileWrappingTranslation.y());
             }
 
             //Setup the geometry for rendering
             if (KisOpenGL::hasOpenGL3()) {
                 rectToVertices(d->vertices, modelRect);
                 d->quadBuffers[0].bind();
                 d->quadBuffers[0].write(0, d->vertices, 3 * 6 * sizeof(float));
 
                 rectToTexCoords(d->texCoords, textureRect);
                 d->quadBuffers[1].bind();
                 d->quadBuffers[1].write(0, d->texCoords, 2 * 6 * sizeof(float));
             }
             else {
                 rectToVertices(d->vertices, modelRect);
                 d->displayShader->enableAttributeArray(PROGRAM_VERTEX_ATTRIBUTE);
                 d->displayShader->setAttributeArray(PROGRAM_VERTEX_ATTRIBUTE, d->vertices);
 
                 rectToTexCoords(d->texCoords, textureRect);
                 d->displayShader->enableAttributeArray(PROGRAM_TEXCOORD_ATTRIBUTE);
                 d->displayShader->setAttributeArray(PROGRAM_TEXCOORD_ATTRIBUTE, d->texCoords);
             }
 
             if (d->displayFilter) {
                 glActiveTexture(GL_TEXTURE0 + 1);
                 glBindTexture(GL_TEXTURE_3D, d->displayFilter->lutTexture());
                 d->displayShader->setUniformValue(d->displayShader->location(Uniform::Texture1), 1);
             }
 
             glActiveTexture(GL_TEXTURE0);
 
             const int currentLodPlane = tile->bindToActiveTexture(d->lodSwitchInProgress);
 
             if (d->displayShader->location(Uniform::FixedLodLevel) >= 0) {
                 d->displayShader->setUniformValue(d->displayShader->location(Uniform::FixedLodLevel),
                                                   (GLfloat) currentLodPlane);
             }
 
             if (currentLodPlane > 0) {
                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
             } else if (SCALE_MORE_OR_EQUAL_TO(scaleX, scaleY, 2.0)) {
                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
             } else {
                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 
                 switch(d->filterMode) {
                 case KisOpenGL::NearestFilterMode:
                     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
                     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
                     break;
                 case KisOpenGL::BilinearFilterMode:
                     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
                     break;
                 case KisOpenGL::TrilinearFilterMode:
                     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
                     break;
                 case KisOpenGL::HighQualityFiltering:
                     if (SCALE_LESS_THAN(scaleX, scaleY, 0.5)) {
                         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
                     } else {
                         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
                     }
                     break;
                 }
             }
 
             glDrawArrays(GL_TRIANGLES, 0, 6);
         }
     }
 
     glBindTexture(GL_TEXTURE_2D, 0);
     d->displayShader->release();
     glBindBuffer(GL_ARRAY_BUFFER, 0);
     glDisable(GL_BLEND);
 }
 
 void KisOpenGLCanvas2::slotConfigChanged()
 {
     KisConfig cfg;
     d->checkSizeScale = KisOpenGLImageTextures::BACKGROUND_TEXTURE_CHECK_SIZE / static_cast<GLfloat>(cfg.checkSize());
     d->scrollCheckers = cfg.scrollCheckers();
 
     d->openGLImageTextures->generateCheckerTexture(createCheckersImage(cfg.checkSize()));
     d->openGLImageTextures->updateConfig(cfg.useOpenGLTextureBuffer(), cfg.numMipmapLevels());
     d->filterMode = (KisOpenGL::FilterMode) cfg.openGLFilteringMode();
 
     d->cursorColor = cfg.getCursorMainColor();
 
     notifyConfigChanged();
 }
 
 void KisOpenGLCanvas2::slotPixelGridModeChanged()
 {
     KisConfig cfg;
 
     d->pixelGridDrawingThreshold = cfg.getPixelGridDrawingThreshold();
     d->pixelGridEnabled = cfg.pixelGridEnabled();
     d->gridColor = cfg.getPixelGridColor();
 
     update();
 }
 
 QVariant KisOpenGLCanvas2::inputMethodQuery(Qt::InputMethodQuery query) const
 {
     return processInputMethodQuery(query);
 }
 
 void KisOpenGLCanvas2::inputMethodEvent(QInputMethodEvent *event)
 {
     processInputMethodEvent(event);
 }
 
 void KisOpenGLCanvas2::renderCanvasGL()
 {
     // Draw the border (that is, clear the whole widget to the border color)
     QColor widgetBackgroundColor = borderColor();
     glClearColor(widgetBackgroundColor.redF(), widgetBackgroundColor.greenF(), widgetBackgroundColor.blueF(), 1.0);
     glClear(GL_COLOR_BUFFER_BIT);
 
     if ((d->displayFilter && d->displayFilter->updateShader()) ||
         (bool(d->displayFilter) != d->displayShaderCompiledWithDisplayFilterSupport)) {
 
         KIS_SAFE_ASSERT_RECOVER_NOOP(d->canvasInitialized);
 
         d->canvasInitialized = false; // TODO: check if actually needed?
         initializeDisplayShader();
         d->canvasInitialized = true;
     }
 
     if (KisOpenGL::hasOpenGL3()) {
         d->quadVAO.bind();
     }
 
     drawCheckers();
     drawImage();
     if ((coordinatesConverter()->effectiveZoom() > d->pixelGridDrawingThreshold - 0.00001) && d->pixelGridEnabled) {
         drawGrid();
     }
     if (KisOpenGL::hasOpenGL3()) {
         d->quadVAO.release();
     }
 }
 
 void KisOpenGLCanvas2::renderDecorations(QPainter *painter)
 {
     QRect boundingRect = coordinatesConverter()->imageRectInWidgetPixels().toAlignedRect();
     drawDecorations(*painter, boundingRect);
 }
 
 
 void KisOpenGLCanvas2::setDisplayProfile(KisDisplayColorConverter *colorConverter)
 {
     d->openGLImageTextures->setMonitorProfile(colorConverter->monitorProfile(),
                                               colorConverter->renderingIntent(),
                                               colorConverter->conversionFlags());
 }
 
 void KisOpenGLCanvas2::channelSelectionChanged(const QBitArray &channelFlags)
 {
     d->openGLImageTextures->setChannelFlags(channelFlags);
 }
 
 
 void KisOpenGLCanvas2::finishResizingImage(qint32 w, qint32 h)
 {
     if (d->canvasInitialized) {
         d->openGLImageTextures->slotImageSizeChanged(w, h);
     }
 }
 
 KisUpdateInfoSP KisOpenGLCanvas2::startUpdateCanvasProjection(const QRect & rc, const QBitArray &channelFlags)
 {
     d->openGLImageTextures->setChannelFlags(channelFlags);
     if (canvas()->proofingConfigUpdated()) {
         d->openGLImageTextures->setProofingConfig(canvas()->proofingConfiguration());
         canvas()->setProofingConfigUpdated(false);
     }
     return d->openGLImageTextures->updateCache(rc, d->openGLImageTextures->image());
 }
 
 
 QRect KisOpenGLCanvas2::updateCanvasProjection(KisUpdateInfoSP info)
 {
     // See KisQPainterCanvas::updateCanvasProjection for more info
     bool isOpenGLUpdateInfo = dynamic_cast<KisOpenGLUpdateInfo*>(info.data());
     if (isOpenGLUpdateInfo) {
-        d->openGLImageTextures->recalculateCache(info);
+        d->openGLImageTextures->recalculateCache(info, d->lodSwitchInProgress);
     }
     return QRect(); // FIXME: Implement dirty rect for OpenGL
 }
 
 QVector<QRect> KisOpenGLCanvas2::updateCanvasProjection(const QVector<KisUpdateInfoSP> &infoObjects)
 {
 #ifdef Q_OS_OSX
     /**
      * On OSX openGL defferent (shared) contexts have different execution queues.
      * It means that the textures uploading and their painting can be easily reordered.
      * To overcome the issue, we should ensure that the textures are uploaded in the
      * same openGL context as the painting is done.
      */
 
     QOpenGLContext *oldContext = QOpenGLContext::currentContext();
     QSurface *oldSurface = oldContext ? oldContext->surface() : 0;
 
     this->makeCurrent();
 #endif
 
     QVector<QRect> result = KisCanvasWidgetBase::updateCanvasProjection(infoObjects);
 
 #ifdef Q_OS_OSX
     if (oldContext) {
         oldContext->makeCurrent(oldSurface);
     } else {
         this->doneCurrent();
     }
 #endif
 
     return result;
 }
 
 bool KisOpenGLCanvas2::callFocusNextPrevChild(bool next)
 {
     return focusNextPrevChild(next);
 }
 
 KisOpenGLImageTexturesSP KisOpenGLCanvas2::openGLImageTextures() const
 {
     return d->openGLImageTextures;
 }
diff --git a/libs/ui/opengl/kis_opengl_image_textures.cpp b/libs/ui/opengl/kis_opengl_image_textures.cpp
index 37eb946e5c..5c121545b4 100644
--- a/libs/ui/opengl/kis_opengl_image_textures.cpp
+++ b/libs/ui/opengl/kis_opengl_image_textures.cpp
@@ -1,597 +1,597 @@
 /*
  *  Copyright (c) 2005-2007 Adrian Page <adrian@pagenet.plus.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "opengl/kis_opengl_image_textures.h"
 
 #include <QOpenGLFunctions>
 #include <QOpenGLContext>
 
 #include <QMessageBox>
 #include <QApplication>
 #include <QDesktopWidget>
 
 #include <KoColorSpaceRegistry.h>
 #include <KoColorProfile.h>
 #include <KoColorModelStandardIds.h>
 
 #include "kis_image.h"
 #include "kis_config.h"
 #include "KisPart.h"
 
 #ifdef HAVE_OPENEXR
 #include <half.h>
 #endif
 
 #ifndef GL_CLAMP_TO_EDGE
 #define GL_CLAMP_TO_EDGE 0x812F
 #endif
 
 #ifndef GL_BGRA
 #define GL_BGRA 0x80E1
 #endif
 
 // GL_EXT_texture_format_BGRA8888
 #ifndef GL_BGRA_EXT
 #define GL_BGRA_EXT 0x80E1
 #endif
 #ifndef GL_BGRA8_EXT
 #define GL_BGRA8_EXT 0x93A1
 #endif
 
 
 KisOpenGLImageTextures::ImageTexturesMap KisOpenGLImageTextures::imageTexturesMap;
 
 KisOpenGLImageTextures::KisOpenGLImageTextures()
     : m_image(0)
     , m_monitorProfile(0)
     , m_tilesDestinationColorSpace(0)
     , m_internalColorManagementActive(true)
     , m_checkerTexture(0)
     , m_glFuncs(0)
     , m_useOcio(false)
     , m_initialized(false)
 {
     KisConfig cfg;
     m_renderingIntent = (KoColorConversionTransformation::Intent)cfg.monitorRenderIntent();
 
     m_conversionFlags = KoColorConversionTransformation::HighQuality;
     if (cfg.useBlackPointCompensation()) m_conversionFlags |= KoColorConversionTransformation::BlackpointCompensation;
     if (!cfg.allowLCMSOptimization()) m_conversionFlags |= KoColorConversionTransformation::NoOptimization;
     m_useOcio = cfg.useOcio();
 }
 
 KisOpenGLImageTextures::KisOpenGLImageTextures(KisImageWSP image,
                                                const KoColorProfile *monitorProfile,
                                                KoColorConversionTransformation::Intent renderingIntent,
                                                KoColorConversionTransformation::ConversionFlags conversionFlags)
     : m_image(image)
     , m_monitorProfile(monitorProfile)
     , m_renderingIntent(renderingIntent)
     , m_conversionFlags(conversionFlags)
     , m_tilesDestinationColorSpace(0)
     , m_internalColorManagementActive(true)
     , m_checkerTexture(0)
     , m_glFuncs(0)
     , m_useOcio(false)
     , m_initialized(false)
 {
     Q_ASSERT(renderingIntent < 4);
 }
 
 void KisOpenGLImageTextures::initGL(QOpenGLFunctions *f)
 {
     if (f) {
         m_glFuncs = f;
     } else {
         errUI << "Tried to create OpenGLImageTextures with uninitialized QOpenGLFunctions";
     }
 
     getTextureSize(&m_texturesInfo);
 
     // we use local static object for creating pools shared among
     // different images
     static KisTextureTileInfoPoolRegistry s_poolRegistry;
     m_updateInfoBuilder.setTextureInfoPool(s_poolRegistry.getPool(m_texturesInfo.width, m_texturesInfo.height));
 
     m_glFuncs->glGenTextures(1, &m_checkerTexture);
     createImageTextureTiles();
 
     KisOpenGLUpdateInfoSP info = updateCache(m_image->bounds(), m_image);
-    recalculateCache(info);
+    recalculateCache(info, false);
 }
 
 KisOpenGLImageTextures::~KisOpenGLImageTextures()
 {
     ImageTexturesMap::iterator it = imageTexturesMap.find(m_image);
     if (it != imageTexturesMap.end()) {
         KisOpenGLImageTextures *textures = it.value();
         if (textures == this) {
             dbgUI << "Removing shared image context from map";
             imageTexturesMap.erase(it);
         }
     }
 
     destroyImageTextureTiles();
     m_glFuncs->glDeleteTextures(1, &m_checkerTexture);
 }
 
 KisImageSP KisOpenGLImageTextures::image() const
 {
     return m_image;
 }
 
 bool KisOpenGLImageTextures::imageCanShareTextures()
 {
     KisConfig cfg;
     if (cfg.useOcio()) return false;
     if (KisPart::instance()->mainwindowCount() == 1) return true;
     if (qApp->desktop()->screenCount() == 1) return true;
     for (int i = 1; i < qApp->desktop()->screenCount(); i++) {
         if (cfg.displayProfile(i) != cfg.displayProfile(i - 1)) {
             return false;
         }
     }
     return true;
 }
 
 KisOpenGLImageTexturesSP KisOpenGLImageTextures::getImageTextures(KisImageWSP image,
                                                                   const KoColorProfile *monitorProfile,
                                                                   KoColorConversionTransformation::Intent renderingIntent,
                                                                   KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     // Disabled until we figure out why we're deleting the shared textures on closing the second view on a single image
     if (false && imageCanShareTextures()) {
         ImageTexturesMap::iterator it = imageTexturesMap.find(image);
 
         if (it != imageTexturesMap.end()) {
             KisOpenGLImageTexturesSP textures = it.value();
             textures->setMonitorProfile(monitorProfile, renderingIntent, conversionFlags);
 
             return textures;
         } else {
             KisOpenGLImageTextures *imageTextures = new KisOpenGLImageTextures(image, monitorProfile, renderingIntent, conversionFlags);
             imageTexturesMap[image] = imageTextures;
             dbgUI << "Added shareable textures to map";
 
             return imageTextures;
         }
     } else {
         return new KisOpenGLImageTextures(image, monitorProfile, renderingIntent, conversionFlags);
     }
 }
 
 void KisOpenGLImageTextures::createImageTextureTiles()
 {
 
     destroyImageTextureTiles();
     updateTextureFormat();
 
     if (!m_tilesDestinationColorSpace) {
         qDebug() << "No destination colorspace!!!!";
         return;
     }
 
 
     m_storedImageBounds = m_image->bounds();
     const int lastCol = xToCol(m_image->width());
     const int lastRow = yToRow(m_image->height());
 
     m_numCols = lastCol + 1;
 
     // Default color is transparent black
     const int pixelSize = m_tilesDestinationColorSpace->pixelSize();
     QByteArray emptyTileData((m_texturesInfo.width) * (m_texturesInfo.height) * pixelSize, 0);
 
     KisConfig config;
     KisOpenGL::FilterMode mode = (KisOpenGL::FilterMode)config.openGLFilteringMode();
 
     QOpenGLContext *ctx = QOpenGLContext::currentContext();
     if (ctx) {
         QOpenGLFunctions *f = ctx->functions();
 
         m_initialized = true;
         dbgUI  << "OpenGL: creating texture tiles of size" << m_texturesInfo.height << "x" << m_texturesInfo.width;
 
         m_textureTiles.reserve((lastRow+1)*m_numCols);
         for (int row = 0; row <= lastRow; row++) {
             for (int col = 0; col <= lastCol; col++) {
                 QRect tileRect = m_updateInfoBuilder.calculateEffectiveTileRect(col, row, m_image->bounds());
 
                 KisTextureTile *tile = new KisTextureTile(tileRect,
                                                           &m_texturesInfo,
                                                           emptyTileData,
                                                           mode,
                                                           config.useOpenGLTextureBuffer(),
                                                           config.numMipmapLevels(),
                                                           f);
                 m_textureTiles.append(tile);
             }
         }
     }
     else {
         dbgUI << "Tried to init texture tiles without a current OpenGL Context.";
     }
 }
 
 void KisOpenGLImageTextures::destroyImageTextureTiles()
 {
     if (m_textureTiles.isEmpty()) return;
 
     Q_FOREACH (KisTextureTile *tile, m_textureTiles) {
         delete tile;
     }
     m_textureTiles.clear();
     m_storedImageBounds = QRect();
 }
 
 KisOpenGLUpdateInfoSP KisOpenGLImageTextures::updateCache(const QRect& rect, KisImageSP srcImage)
 {
     return updateCacheImpl(rect, srcImage, true);
 }
 
 KisOpenGLUpdateInfoSP KisOpenGLImageTextures::updateCacheNoConversion(const QRect& rect)
 {
     return updateCacheImpl(rect, m_image, false);
 }
 
 // TODO: add sanity checks about the conformance of the passed srcImage!
 KisOpenGLUpdateInfoSP KisOpenGLImageTextures::updateCacheImpl(const QRect& rect, KisImageSP srcImage, bool convertColorSpace)
 {
     if (!m_initialized) return new KisOpenGLUpdateInfo();
     return m_updateInfoBuilder.buildUpdateInfo(rect, srcImage, convertColorSpace);
 }
 
-void KisOpenGLImageTextures::recalculateCache(KisUpdateInfoSP info)
+void KisOpenGLImageTextures::recalculateCache(KisUpdateInfoSP info, bool blockMipmapRegeneration)
 {
     if (!m_initialized) {
         dbgUI << "OpenGL: Tried to edit image texture cache before it was initialized.";
         return;
     }
 
     KisOpenGLUpdateInfoSP glInfo = dynamic_cast<KisOpenGLUpdateInfo*>(info.data());
     if(!glInfo) return;
 
     KisTextureTileUpdateInfoSP tileInfo;
     Q_FOREACH (tileInfo, glInfo->tileList) {
         KisTextureTile *tile = getTextureTileCR(tileInfo->tileCol(), tileInfo->tileRow());
         KIS_ASSERT_RECOVER_RETURN(tile);
 
-        tile->update(*tileInfo);
+        tile->update(*tileInfo, blockMipmapRegeneration);
     }
 }
 
 void KisOpenGLImageTextures::generateCheckerTexture(const QImage &checkImage)
 {
 
     QOpenGLContext *ctx = QOpenGLContext::currentContext();
     if (ctx) {
         QOpenGLFunctions *f = ctx->functions();
         dbgUI << "Attaching checker texture" << checkerTexture();
         f->glBindTexture(GL_TEXTURE_2D, checkerTexture());
 
         f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
         f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
         f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
         f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 
         f->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 
         QImage img = checkImage;
         if (checkImage.width() != BACKGROUND_TEXTURE_SIZE || checkImage.height() != BACKGROUND_TEXTURE_SIZE) {
             img = checkImage.scaled(BACKGROUND_TEXTURE_SIZE, BACKGROUND_TEXTURE_SIZE);
         }
         GLint format = GL_BGRA, internalFormat = GL_RGBA8;
         if (KisOpenGL::hasOpenGLES()) {
             if (ctx->hasExtension(QByteArrayLiteral("GL_EXT_texture_format_BGRA8888"))) {
                 format = GL_BGRA_EXT;
                 internalFormat = GL_BGRA8_EXT;
             } else {
                 format = GL_RGBA;
             }
         }
         f->glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, BACKGROUND_TEXTURE_SIZE, BACKGROUND_TEXTURE_SIZE,
                         0, format, GL_UNSIGNED_BYTE, img.constBits());
     }
     else {
         dbgUI << "OpenGL: Tried to generate checker texture before OpenGL was initialized.";
     }
 
 }
 
 GLuint KisOpenGLImageTextures::checkerTexture()
 {
     if (m_glFuncs) {
         if (m_checkerTexture == 0) {
             m_glFuncs->glGenTextures(1, &m_checkerTexture);
         }
         return m_checkerTexture;
     }
     else {
         dbgUI << "Tried to access checker texture before OpenGL was initialized";
         return 0;
     }
 }
 
 void KisOpenGLImageTextures::updateConfig(bool useBuffer, int NumMipmapLevels)
 {
     if(m_textureTiles.isEmpty()) return;
 
     Q_FOREACH (KisTextureTile *tile, m_textureTiles) {
         tile->setUseBuffer(useBuffer);
         tile->setNumMipmapLevels(NumMipmapLevels);
     }
 }
 
 void KisOpenGLImageTextures::slotImageSizeChanged(qint32 /*w*/, qint32 /*h*/)
 {
     createImageTextureTiles();
 }
 
 KisOpenGLUpdateInfoBuilder &KisOpenGLImageTextures::updateInfoBuilder()
 {
     return m_updateInfoBuilder;
 }
 
 void KisOpenGLImageTextures::setMonitorProfile(const KoColorProfile *monitorProfile, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     //dbgUI << "Setting monitor profile to" << monitorProfile->name() << renderingIntent << conversionFlags;
     m_monitorProfile = monitorProfile;
     m_renderingIntent = renderingIntent;
     m_conversionFlags = conversionFlags;
 
     m_updateInfoBuilder.setConversionOptions(
         ConversionOptions(m_tilesDestinationColorSpace,
                           m_renderingIntent,
                           m_conversionFlags));
 
     createImageTextureTiles();
 }
 
 void KisOpenGLImageTextures::setChannelFlags(const QBitArray &channelFlags)
 {
     QBitArray targetChannelFlags = channelFlags;
     int selectedChannels = 0;
     const KoColorSpace *projectionCs = m_image->projection()->colorSpace();
     QList<KoChannelInfo*> channelInfo = projectionCs->channels();
 
     if (targetChannelFlags.size() != channelInfo.size()) {
         targetChannelFlags = QBitArray();
     }
 
     int selectedChannelIndex = -1;
 
     for (int i = 0; i < targetChannelFlags.size(); ++i) {
         if (targetChannelFlags.testBit(i) && channelInfo[i]->channelType() == KoChannelInfo::COLOR) {
             selectedChannels++;
             selectedChannelIndex = i;
         }
     }
     const bool allChannelsSelected = (selectedChannels == targetChannelFlags.size());
     const bool onlyOneChannelSelected = (selectedChannels == 1);
 
     // OCIO has its own channel swizzling
     if (allChannelsSelected || m_useOcio) {
         m_updateInfoBuilder.setChannelFlags(QBitArray(), false, -1);
     } else {
         m_updateInfoBuilder.setChannelFlags(targetChannelFlags, onlyOneChannelSelected, selectedChannelIndex);
     }
 }
 
 void KisOpenGLImageTextures::setProofingConfig(KisProofingConfigurationSP proofingConfig)
 {
     m_updateInfoBuilder.setProofingConfig(proofingConfig);
 }
 
 void KisOpenGLImageTextures::getTextureSize(KisGLTexturesInfo *texturesInfo)
 {
     KisConfig cfg;
 
     const GLint preferredTextureSize = cfg.openGLTextureSize();
 
     GLint maxTextureSize;
     if (m_glFuncs) {
         m_glFuncs->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);
     }
     else {
         dbgUI << "OpenGL: Tried to read texture size before OpenGL was initialized.";
         maxTextureSize = GL_MAX_TEXTURE_SIZE;
     }
 
     texturesInfo->width = qMin(preferredTextureSize, maxTextureSize);
     texturesInfo->height = qMin(preferredTextureSize, maxTextureSize);
 
     texturesInfo->border = cfg.textureOverlapBorder();
 
     texturesInfo->effectiveWidth = texturesInfo->width - 2 * texturesInfo->border;
     texturesInfo->effectiveHeight = texturesInfo->height - 2 * texturesInfo->border;
 
     m_updateInfoBuilder.setTextureBorder(texturesInfo->border);
     m_updateInfoBuilder.setEffectiveTextureSize(
         QSize(texturesInfo->effectiveWidth, texturesInfo->effectiveHeight));
 }
 
 bool KisOpenGLImageTextures::internalColorManagementActive() const
 {
     return m_internalColorManagementActive;
 }
 
 bool KisOpenGLImageTextures::setInternalColorManagementActive(bool value)
 {
     bool needsFinalRegeneration = m_internalColorManagementActive != value;
 
     if (needsFinalRegeneration) {
         m_internalColorManagementActive = value;
         createImageTextureTiles();
 
         // at this point the value of m_internalColorManagementActive might
         // have been forcely reverted to 'false' in case of some problems
     }
 
     return needsFinalRegeneration;
 }
 
 void KisOpenGLImageTextures::updateTextureFormat()
 {
     QOpenGLContext *ctx = QOpenGLContext::currentContext();
     if (!(m_image && ctx)) return;
 
     if (!KisOpenGL::hasOpenGLES()) {
         m_texturesInfo.internalFormat = GL_RGBA8;
         m_texturesInfo.type = GL_UNSIGNED_BYTE;
         m_texturesInfo.format = GL_BGRA;
     } else {
         m_texturesInfo.internalFormat = GL_BGRA8_EXT;
         m_texturesInfo.type = GL_UNSIGNED_BYTE;
         m_texturesInfo.format = GL_BGRA_EXT;
         if(!ctx->hasExtension(QByteArrayLiteral("GL_EXT_texture_format_BGRA8888"))) {
             // The red and blue channels are swapped, but it will be re-swapped
             // by texture swizzle mask set in KisTextureTile::setTextureParameters
             m_texturesInfo.internalFormat = GL_RGBA8;
             m_texturesInfo.type = GL_UNSIGNED_BYTE;
             m_texturesInfo.format = GL_RGBA;
         }
     }
 
     KoID colorModelId = m_image->colorSpace()->colorModelId();
     KoID colorDepthId = m_image->colorSpace()->colorDepthId();
 
     KoID destinationColorModelId = RGBAColorModelID;
     KoID destinationColorDepthId = Integer8BitsColorDepthID;
 
     dbgUI << "Choosing texture format:";
 
     if (colorModelId == RGBAColorModelID) {
         if (colorDepthId == Float16BitsColorDepthID) {
 
             if (KisOpenGL::hasOpenGLES() || KisOpenGL::hasOpenGL3()) {
                 m_texturesInfo.internalFormat = GL_RGBA16F;
                 dbgUI << "Using half (GLES or GL3)";
             } else if (ctx->hasExtension("GL_ARB_texture_float")) {
                 m_texturesInfo.internalFormat = GL_RGBA16F_ARB;
                 dbgUI << "Using ARB half";
             }
             else if (ctx->hasExtension("GL_ATI_texture_float")) {
                 m_texturesInfo.internalFormat = GL_RGBA_FLOAT16_ATI;
                 dbgUI << "Using ATI half";
             }
 
             bool haveBuiltInOpenExr = false;
 #ifdef HAVE_OPENEXR
             haveBuiltInOpenExr = true;
 #endif
 
             if (haveBuiltInOpenExr && (KisOpenGL::hasOpenGLES() || KisOpenGL::hasOpenGL3())) {
                 m_texturesInfo.type = GL_HALF_FLOAT;
                 destinationColorDepthId = Float16BitsColorDepthID;
                 dbgUI << "Pixel type half (GLES or GL3)";
             } else if (haveBuiltInOpenExr && ctx->hasExtension("GL_ARB_half_float_pixel")) {
                 m_texturesInfo.type = GL_HALF_FLOAT_ARB;
                 destinationColorDepthId = Float16BitsColorDepthID;
                 dbgUI << "Pixel type half";
             } else {
                 m_texturesInfo.type = GL_FLOAT;
                 destinationColorDepthId = Float32BitsColorDepthID;
                 dbgUI << "Pixel type float";
             }
             m_texturesInfo.format = GL_RGBA;
         }
         else if (colorDepthId == Float32BitsColorDepthID) {
             if (KisOpenGL::hasOpenGLES() || KisOpenGL::hasOpenGL3()) {
                 m_texturesInfo.internalFormat = GL_RGBA32F;
                 dbgUI << "Using float (GLES or GL3)";
             } else if (ctx->hasExtension("GL_ARB_texture_float")) {
                 m_texturesInfo.internalFormat = GL_RGBA32F_ARB;
                 dbgUI << "Using ARB float";
             } else if (ctx->hasExtension("GL_ATI_texture_float")) {
                 m_texturesInfo.internalFormat = GL_RGBA_FLOAT32_ATI;
                 dbgUI << "Using ATI float";
             }
 
             m_texturesInfo.type = GL_FLOAT;
             m_texturesInfo.format = GL_RGBA;
             destinationColorDepthId = Float32BitsColorDepthID;
         }
         else if (colorDepthId == Integer16BitsColorDepthID) {
             if (!KisOpenGL::hasOpenGLES()) {
                 m_texturesInfo.internalFormat = GL_RGBA16;
                 m_texturesInfo.type = GL_UNSIGNED_SHORT;
                 m_texturesInfo.format = GL_BGRA;
                 destinationColorDepthId = Integer16BitsColorDepthID;
                 dbgUI << "Using 16 bits rgba";
             }
             // TODO: for ANGLE, see if we can convert to 16f to support 10-bit display
         }
     }
     else {
         // We will convert the colorspace to 16 bits rgba, instead of 8 bits
         if (colorDepthId == Integer16BitsColorDepthID && !KisOpenGL::hasOpenGLES()) {
             m_texturesInfo.internalFormat = GL_RGBA16;
             m_texturesInfo.type = GL_UNSIGNED_SHORT;
             m_texturesInfo.format = GL_BGRA;
             destinationColorDepthId = Integer16BitsColorDepthID;
             dbgUI << "Using conversion to 16 bits rgba";
         }
         // TODO: for ANGLE, see if we can convert to 16f to support 10-bit display
     }
 
     if (!m_internalColorManagementActive &&
             colorModelId != destinationColorModelId) {
 
         KisConfig cfg;
         KisConfig::OcioColorManagementMode cm = cfg.ocioColorManagementMode();
 
         if (cm != KisConfig::INTERNAL) {
             QMessageBox::critical(0,
                                   i18nc("@title:window", "Krita"),
                                   i18n("You enabled OpenColorIO based color management, but your image is not an RGB image.\n"
                                        "OpenColorIO-based color management only works with RGB images.\n"
                                        "Please check the settings in the LUT docker.\n"
                                        "OpenColorIO will now be deactivated."));
         }
 
         warnUI << "WARNING: Internal color management was forcibly enabled";
         warnUI << "Color Management Mode: " << cm;
         warnUI << ppVar(m_image->colorSpace());
         warnUI << ppVar(destinationColorModelId);
         warnUI << ppVar(destinationColorDepthId);
 
         cfg.setOcioColorManagementMode(KisConfig::INTERNAL);
         m_internalColorManagementActive = true;
     }
 
     const KoColorProfile *profile =
             m_internalColorManagementActive ||
             colorModelId != destinationColorModelId ?
                 m_monitorProfile : m_image->colorSpace()->profile();
 
     /**
      * TODO: add an optimization so that the tile->convertTo() method
      *       would not be called when not needed (DK)
      */
 
     m_tilesDestinationColorSpace =
             KoColorSpaceRegistry::instance()->colorSpace(destinationColorModelId.id(),
                                                          destinationColorDepthId.id(),
                                                          profile);
 
     m_updateInfoBuilder.setConversionOptions(
         ConversionOptions(m_tilesDestinationColorSpace,
                           m_renderingIntent,
                           m_conversionFlags));
 }
 
diff --git a/libs/ui/opengl/kis_opengl_image_textures.h b/libs/ui/opengl/kis_opengl_image_textures.h
index 83032e6c1b..32a915536e 100644
--- a/libs/ui/opengl/kis_opengl_image_textures.h
+++ b/libs/ui/opengl/kis_opengl_image_textures.h
@@ -1,204 +1,204 @@
 /*
  *  Copyright (c) 2005-2007 Adrian Page <adrian@pagenet.plus.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef KIS_OPENGL_IMAGE_TEXTURES_H_
 #define KIS_OPENGL_IMAGE_TEXTURES_H_
 
 #include <QVector>
 #include <QMap>
 #include <QOpenGLFunctions>
 
 #include "kritaui_export.h"
 
 #include "kis_shared.h"
 
 #include "canvas/kis_update_info.h"
 #include "opengl/kis_texture_tile.h"
 #include "KisOpenGLUpdateInfoBuilder.h"
 
 class KisOpenGLImageTextures;
 typedef KisSharedPtr<KisOpenGLImageTextures> KisOpenGLImageTexturesSP;
 
 class KoColorProfile;
 class KisTextureTileUpdateInfoPoolCollection;
 typedef QSharedPointer<KisTextureTileInfoPool> KisTextureTileInfoPoolSP;
 
 class KisProofingConfiguration;
 typedef QSharedPointer<KisProofingConfiguration> KisProofingConfigurationSP;
 
 /**
  * A set of OpenGL textures that contains the projection of a KisImage.
  */
 class KRITAUI_EXPORT KisOpenGLImageTextures : public KisShared
 {
 public:
     /**
      * Obtain a KisOpenGLImageTextures object for the given image.
      * @param image The image
      * @param monitorProfile The profile of the display device
      */
     static KisOpenGLImageTexturesSP getImageTextures(KisImageWSP image,
                                                      const KoColorProfile *monitorProfile, KoColorConversionTransformation::Intent renderingIntent,
                                                      KoColorConversionTransformation::ConversionFlags conversionFlags);
 
     /**
      * Default constructor.
      */
     KisOpenGLImageTextures();
 
     /**
      * Destructor.
      */
     virtual ~KisOpenGLImageTextures();
 
     /**
      * \return the image associated with the textures
      */
     KisImageSP image() const;
 
     /**
      * Set the color profile of the display device.
      * @param profile The color profile of the display device
      */
     void setMonitorProfile(const KoColorProfile *monitorProfile,
                            KoColorConversionTransformation::Intent renderingIntent,
                            KoColorConversionTransformation::ConversionFlags conversionFlags);
 
     /**
      * Complete initialization can only happen once an OpenGL context has been created.
      * @param f Pointer to OpenGL functions. They must already be ininitialized.
      */
     void initGL(QOpenGLFunctions *f);
 
     void setChannelFlags(const QBitArray &channelFlags);
     void setProofingConfig(KisProofingConfigurationSP);
 
     bool internalColorManagementActive() const;
     bool setInternalColorManagementActive(bool value);
 
     /**
      * The background checkers texture.
      */
     static const int BACKGROUND_TEXTURE_CHECK_SIZE = 32;
     static const int BACKGROUND_TEXTURE_SIZE = BACKGROUND_TEXTURE_CHECK_SIZE * 2;
 
     /**
      * Generate a background texture from the given QImage. This is used for the checker
      * pattern on which the image is rendered.
      */
     void generateCheckerTexture(const QImage & checkImage);
     GLuint checkerTexture();
 
     void updateConfig(bool useBuffer, int NumMipmapLevels);
 
 public:
     inline QRect storedImageBounds() {
         return m_storedImageBounds;
     }
 
     inline int xToCol(int x) {
         return x / m_texturesInfo.effectiveWidth;
     }
 
     inline int yToRow(int y) {
         return y / m_texturesInfo.effectiveHeight;
     }
 
     inline KisTextureTile* getTextureTileCR(int col, int row) {
         if (m_initialized) {
             int tile = row * m_numCols + col;
             KIS_ASSERT_RECOVER_RETURN_VALUE(m_textureTiles.size() > tile, 0);
             return m_textureTiles[tile];
         }
         return 0;
     }
 
     inline qreal texelSize() const {
         Q_ASSERT(m_texturesInfo.width == m_texturesInfo.height);
         return 1.0 / m_texturesInfo.width;
     }
 
     KisOpenGLUpdateInfoSP updateCache(const QRect& rect, KisImageSP srcImage);
     KisOpenGLUpdateInfoSP updateCacheNoConversion(const QRect& rect);
 
-    void recalculateCache(KisUpdateInfoSP info);
+    void recalculateCache(KisUpdateInfoSP info, bool blockMipmapRegeneration);
 
     void slotImageSizeChanged(qint32 w, qint32 h);
 
     KisOpenGLUpdateInfoBuilder& updateInfoBuilder();
 
 protected:
 
     KisOpenGLImageTextures(KisImageWSP image, const KoColorProfile *monitorProfile,
                            KoColorConversionTransformation::Intent renderingIntent,
                            KoColorConversionTransformation::ConversionFlags conversionFlags);
 
     void createImageTextureTiles();
 
     void destroyImageTextureTiles();
 
     static bool imageCanShareTextures();
 
 private:
 
     void getTextureSize(KisGLTexturesInfo *texturesInfo);
 
     void updateTextureFormat();
     KisOpenGLUpdateInfoSP updateCacheImpl(const QRect& rect, KisImageSP srcImage, bool convertColorSpace);
 
 private:
     KisImageWSP m_image;
     QRect m_storedImageBounds;
     const KoColorProfile *m_monitorProfile;
     KoColorConversionTransformation::Intent m_renderingIntent;
     KoColorConversionTransformation::ConversionFlags m_conversionFlags;
 
     /**
      * If the destination color space coincides with the one of the image,
      * then effectively, there is no conversion happens. That is used
      * for working with OCIO.
      */
     const KoColorSpace *m_tilesDestinationColorSpace;
 
     /**
      * Shows whether the internal color management should be enabled or not.
      * Please note that if you disable color management, *but* your image color
      * space will not be supported (non-RGB), then it will be enabled anyway.
      * And this valiable will hold the real state of affairs!
      */
     bool m_internalColorManagementActive;
 
     GLuint m_checkerTexture;
 
     KisGLTexturesInfo m_texturesInfo;
     int m_numCols;
     QVector<KisTextureTile*> m_textureTiles;
 
     QOpenGLFunctions *m_glFuncs;
 
     bool m_useOcio;
     bool m_initialized;
 
     KisOpenGLUpdateInfoBuilder m_updateInfoBuilder;
 
 private:
     typedef QMap<KisImageWSP, KisOpenGLImageTextures*> ImageTexturesMap;
     static ImageTexturesMap imageTexturesMap;
 };
 
 #endif // KIS_OPENGL_IMAGE_TEXTURES_H_
 
diff --git a/libs/ui/opengl/kis_texture_tile.cpp b/libs/ui/opengl/kis_texture_tile.cpp
index bc7e896088..99fa080d6e 100644
--- a/libs/ui/opengl/kis_texture_tile.cpp
+++ b/libs/ui/opengl/kis_texture_tile.cpp
@@ -1,401 +1,402 @@
 /*
  *  Copyright (c) 2010 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #define GL_GLEXT_PROTOTYPES
 #include "kis_texture_tile.h"
 #include "kis_texture_tile_update_info.h"
 
 #include <kis_debug.h>
 #if !defined(QT_OPENGL_ES)
 #include <QOpenGLBuffer>
 #endif
 
 #ifndef GL_BGRA
 #define GL_BGRA 0x814F
 #endif
 
 void KisTextureTile::setTextureParameters()
 {
 
     f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_LOD, 0);
     f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LOD, m_numMipmapLevels);
     f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
     f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, m_numMipmapLevels);
 
     if (m_texturesInfo->internalFormat == GL_RGBA8 && m_texturesInfo->format == GL_RGBA) {
         // If image format is RGBA8, swap the red and blue channels for the proper colour
         // This is for OpenGL ES support and only used if lacking GL_EXT_texture_format_BGRA8888
         f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_BLUE);
         f->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_RED);
     }
 
     f->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 }
 
 inline QRectF relativeRect(const QRect &br /* baseRect */,
                            const QRect &cr /* childRect */,
                            const KisGLTexturesInfo *texturesInfo)
 {
     const qreal x = qreal(cr.x() - br.x()) / texturesInfo->width;
     const qreal y = qreal(cr.y() - br.y()) / texturesInfo->height;
     const qreal w = qreal(cr.width()) / texturesInfo->width;
     const qreal h = qreal(cr.height()) / texturesInfo->height;
 
     return QRectF(x, y, w, h);
 }
 
 
 KisTextureTile::KisTextureTile(const QRect &imageRect, const KisGLTexturesInfo *texturesInfo,
                                const QByteArray &fillData, KisOpenGL::FilterMode filter,
                                bool useBuffer, int numMipmapLevels, QOpenGLFunctions *fcn)
 
     : m_textureId(0)
 #ifdef USE_PIXEL_BUFFERS
     , m_glBuffer(0)
 #endif
     , m_tileRectInImagePixels(imageRect)
     , m_filter(filter)
     , m_texturesInfo(texturesInfo)
     , m_needsMipmapRegeneration(false)
     , m_preparedLodPlane(0)
     , m_useBuffer(useBuffer)
     , m_numMipmapLevels(numMipmapLevels)
     , f(fcn)
 {
     const GLvoid *fd = fillData.constData();
 
     m_textureRectInImagePixels =
             kisGrowRect(m_tileRectInImagePixels, texturesInfo->border);
 
     m_tileRectInTexturePixels = relativeRect(m_textureRectInImagePixels,
                                              m_tileRectInImagePixels,
                                              m_texturesInfo);
 
     f->glGenTextures(1, &m_textureId);
     f->glBindTexture(GL_TEXTURE_2D, m_textureId);
 
     setTextureParameters();
 
 #ifdef USE_PIXEL_BUFFERS
     createTextureBuffer(fillData.constData(), fillData.size());
     // we set fill data to 0 so the next glTexImage2D call uses our buffer
     fd = 0;
 #endif
 
     f->glTexImage2D(GL_TEXTURE_2D, 0,
                  m_texturesInfo->internalFormat,
                  m_texturesInfo->width,
                  m_texturesInfo->height, 0,
                  m_texturesInfo->format,
                  m_texturesInfo->type, fd);
 
 #ifdef USE_PIXEL_BUFFERS
     if (m_useBuffer && m_glBuffer) {
         m_glBuffer->release();
     }
 #endif
 
     setNeedsMipmapRegeneration();
 }
 
 KisTextureTile::~KisTextureTile()
 {
 #ifdef USE_PIXEL_BUFFERS
     delete m_glBuffer;
 #endif
     f->glDeleteTextures(1, &m_textureId);
 }
 
 int KisTextureTile::bindToActiveTexture(bool blockMipmapRegeneration)
 {
     f->glBindTexture(GL_TEXTURE_2D, m_textureId);
 
     if (m_needsMipmapRegeneration && !blockMipmapRegeneration) {
         f->glGenerateMipmap(GL_TEXTURE_2D);
         setPreparedLodPlane(0);
     }
 
     return m_preparedLodPlane;
 }
 
 void KisTextureTile::setNeedsMipmapRegeneration()
 {
     if (m_filter == KisOpenGL::TrilinearFilterMode ||
         m_filter == KisOpenGL::HighQualityFiltering) {
 
         m_needsMipmapRegeneration = true;
     }
 }
 
 void KisTextureTile::setPreparedLodPlane(int lod)
 {
     m_preparedLodPlane = lod;
     m_needsMipmapRegeneration = false;
 }
 
-void KisTextureTile::update(const KisTextureTileUpdateInfo &updateInfo)
+void KisTextureTile::update(const KisTextureTileUpdateInfo &updateInfo, bool blockMipmapRegeneration)
 {
     f->initializeOpenGLFunctions();
     f->glBindTexture(GL_TEXTURE_2D, m_textureId);
 
     setTextureParameters();
 
     const int patchLevelOfDetail = updateInfo.patchLevelOfDetail();
     const QSize patchSize = updateInfo.realPatchSize();
     const QPoint patchOffset = updateInfo.realPatchOffset();
 
     const GLvoid *fd = updateInfo.data();
 #ifdef USE_PIXEL_BUFFERS
     if (!m_glBuffer) {
         createTextureBuffer((const char*)updateInfo.data(), updateInfo.patchPixelsLength());
     }
 #endif
 
     /**
      * In some special case, when the Lod0 stroke is cancelled the
      * following situation is possible:
      *
      * 1)  The stroke  is  cancelled,  Lod0 update  is  issued by  the
      *     image. LodN level of the openGL times is still dirty.
      *
      * 2) [here, ideally, the canvas should be re-rendered, so that
      *     the mipmap would be regenerated in bindToActiveTexture()
      *     call, by in some cases (if you cancel and paint to quickly),
      *     that doesn't have time to happen]
      *
      * 3) The new LodN stroke issues a *partial* update of a LodN
      *    plane of the tile. But the plane is still *dirty*! We update
      *    a part of it, but we cannot regenerate the mipmap anymore,
      *    because the Lod0 level is not known yet!
      *
      * To avoid this issue, we should regenerate the dirty mipmap
      * *before* doing anything with the low-resolution plane.
      */
-    if (patchLevelOfDetail > 0 &&
+    if (!blockMipmapRegeneration &&
+        patchLevelOfDetail > 0 &&
         m_needsMipmapRegeneration &&
         !updateInfo.isEntireTileUpdated()) {
 
         f->glGenerateMipmap(GL_TEXTURE_2D);
         m_needsMipmapRegeneration = false;
     }
 
 
     if (updateInfo.isEntireTileUpdated()) {
 
 #ifdef USE_PIXEL_BUFFERS
         if (m_useBuffer) {
 
             m_glBuffer->bind();
             m_glBuffer->allocate(updateInfo.patchPixelsLength());
 
             void *vid = m_glBuffer->map(QOpenGLBuffer::WriteOnly);
             memcpy(vid, fd, updateInfo.patchPixelsLength());
             m_glBuffer->unmap();
 
             // we set fill data to 0 so the next glTexImage2D call uses our buffer
             fd = 0;
         }
 #endif
 
         f->glTexImage2D(GL_TEXTURE_2D, patchLevelOfDetail,
                      m_texturesInfo->internalFormat,
                      patchSize.width(),
                      patchSize.height(), 0,
                      m_texturesInfo->format,
                      m_texturesInfo->type,
                      fd);
 
 #ifdef USE_PIXEL_BUFFERS
         if (m_useBuffer) {
             m_glBuffer->release();
         }
 #endif
 
     }
     else {
 #ifdef USE_PIXEL_BUFFERS
         if (m_useBuffer) {
             m_glBuffer->bind();
             int size = patchSize.width() * patchSize.height() * updateInfo.pixelSize();
             m_glBuffer->allocate(size);
 
             void *vid = m_glBuffer->map(QOpenGLBuffer::WriteOnly);
             memcpy(vid, fd, size);
             m_glBuffer->unmap();
 
             // we set fill data to 0 so the next glTexImage2D call uses our buffer
             fd = 0;
         }
 #endif
 
         f->glTexSubImage2D(GL_TEXTURE_2D, patchLevelOfDetail,
                         patchOffset.x(), patchOffset.y(),
                         patchSize.width(), patchSize.height(),
                         m_texturesInfo->format,
                         m_texturesInfo->type,
                         fd);
 
 #ifdef USE_PIXEL_BUFFERS
         if (m_useBuffer) {
             m_glBuffer->release();
         }
 #endif
 
     }
 
     /**
      * On the boundaries of KisImage, there is a border-effect as well.
      * So we just repeat the bounding pixels of the image to make
      * bilinear interpolator happy.
      */
 
     /**
      * WARN: The width of the stripes will be equal to the broder
      *       width of the tiles.
      */
 
     const int pixelSize = updateInfo.pixelSize();
     const QSize tileSize = updateInfo.realTileSize();
 
     if(updateInfo.isTopmost()) {
         int start = 0;
         int end = patchOffset.y() - 1;
         for (int i = start; i <= end; i++) {
             f->glTexSubImage2D(GL_TEXTURE_2D, patchLevelOfDetail,
                             patchOffset.x(), i,
                             patchSize.width(), 1,
                             m_texturesInfo->format,
                             m_texturesInfo->type,
                             updateInfo.data());
         }
     }
 
     if (updateInfo.isBottommost()) {
         int shift = patchSize.width() * (patchSize.height() - 1) *
                 pixelSize;
 
         int start = patchOffset.y() + patchSize.height();
         int end = tileSize.height() - 1;
         for (int i = start; i < end; i++) {
             f->glTexSubImage2D(GL_TEXTURE_2D, patchLevelOfDetail,
                             patchOffset.x(), i,
                             patchSize.width(), 1,
                             m_texturesInfo->format,
                             m_texturesInfo->type,
                             updateInfo.data() + shift);
         }
     }
 
     if (updateInfo.isLeftmost()) {
 
         QByteArray columnBuffer(patchSize.height() * pixelSize, 0);
 
         quint8 *srcPtr = updateInfo.data();
         quint8 *dstPtr = (quint8*) columnBuffer.data();
         for(int i = 0; i < patchSize.height(); i++) {
             memcpy(dstPtr, srcPtr, pixelSize);
 
             srcPtr += patchSize.width() * pixelSize;
             dstPtr += pixelSize;
         }
 
         int start = 0;
         int end = patchOffset.x() - 1;
         for (int i = start; i <= end; i++) {
             f->glTexSubImage2D(GL_TEXTURE_2D, patchLevelOfDetail,
                             i, patchOffset.y(),
                             1, patchSize.height(),
                             m_texturesInfo->format,
                             m_texturesInfo->type,
                             columnBuffer.constData());
         }
     }
 
     if (updateInfo.isRightmost()) {
 
         QByteArray columnBuffer(patchSize.height() * pixelSize, 0);
 
         quint8 *srcPtr = updateInfo.data() + (patchSize.width() - 1) * pixelSize;
         quint8 *dstPtr = (quint8*) columnBuffer.data();
         for(int i = 0; i < patchSize.height(); i++) {
             memcpy(dstPtr, srcPtr, pixelSize);
 
             srcPtr += patchSize.width() * pixelSize;
             dstPtr += pixelSize;
         }
 
         int start = patchOffset.x() + patchSize.width();
         int end = tileSize.width() - 1;
         for (int i = start; i <= end; i++) {
             f->glTexSubImage2D(GL_TEXTURE_2D, patchLevelOfDetail,
                             i, patchOffset.y(),
                             1, patchSize.height(),
                             m_texturesInfo->format,
                             m_texturesInfo->type,
                             columnBuffer.constData());
         }
     }
 
     //// Uncomment this warning if you see any weird flickering when
     //// Instant Preview updates
     // if (!updateInfo.isEntireTileUpdated() &&
     //     !(!patchLevelOfDetail || !m_preparedLodPlane || patchLevelOfDetail == m_preparedLodPlane)) {
     //     qDebug() << "WARNING: LodN switch is requested for the partial tile update!. Flickering is possible..." << ppVar(patchSize);
     //     qDebug() << "    " << ppVar(m_preparedLodPlane);
     //     qDebug() << "    " << ppVar(patchLevelOfDetail);
     // }
 
     if (!patchLevelOfDetail) {
         setNeedsMipmapRegeneration();
     } else {
         setPreparedLodPlane(patchLevelOfDetail);
     }
 }
 
 QRectF KisTextureTile::imageRectInTexturePixels(const QRect &imageRect) const
 {
     return relativeRect(m_textureRectInImagePixels,
                         imageRect,
                         m_texturesInfo);
 
 }
 
 #ifdef USE_PIXEL_BUFFERS
 void KisTextureTile::createTextureBuffer(const char *data, int size)
 {
     if (m_useBuffer) {
         if (!m_glBuffer) {
             m_glBuffer = new QOpenGLBuffer(QOpenGLBuffer::PixelUnpackBuffer);
             m_glBuffer->setUsagePattern(QOpenGLBuffer::DynamicDraw);
             m_glBuffer->create();
             m_glBuffer->bind();
             m_glBuffer->allocate(size);
         }
         void *vid = m_glBuffer->map(QOpenGLBuffer::WriteOnly);
         memcpy(vid, data, size);
         m_glBuffer->unmap();
 
     }
     else {
         delete m_glBuffer;
         m_glBuffer = 0;
     }
 }
 #endif
diff --git a/libs/ui/opengl/kis_texture_tile.h b/libs/ui/opengl/kis_texture_tile.h
index 2fd77d52db..9229add068 100644
--- a/libs/ui/opengl/kis_texture_tile.h
+++ b/libs/ui/opengl/kis_texture_tile.h
@@ -1,128 +1,128 @@
 /*
  *  Copyright (c) 2010 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef KIS_TEXTURE_TILE_H_
 #define KIS_TEXTURE_TILE_H_
 
 #include <QRect>
 #include <QRectF>
 // no forward-declaration, used to get GL* primitive types defined
 #include <QOpenGLFunctions>
 
 #include "kis_opengl.h"
 
 #if !defined(QT_OPENGL_ES)
 #define USE_PIXEL_BUFFERS
 #endif
 
 class KisTextureTileUpdateInfo;
 class QOpenGLBuffer;
 
 
 struct KisGLTexturesInfo {
 
     KisGLTexturesInfo()
         : width(0)
         , height(0)
         , effectiveWidth(1)
         , effectiveHeight(1)
         , border(0)
     {}
 
     // real width and height
     int width;
     int height;
 
     // width and height minus border padding?
     int effectiveWidth;
     int effectiveHeight;
 
     // size of the border padding
     int border;
 
     GLint internalFormat;
     GLint format;
     GLint type;
 };
 
 class KisTextureTile
 {
 public:
     KisTextureTile(const QRect &imageRect, const KisGLTexturesInfo *texturesInfo,
                    const QByteArray &fillData, KisOpenGL::FilterMode mode,
                    bool useBuffer, int numMipmapLevels, QOpenGLFunctions *f);
     ~KisTextureTile();
 
     void setUseBuffer(bool useBuffer) {
         m_useBuffer = useBuffer;
     }
 
     void setNumMipmapLevels(int num) {
         m_numMipmapLevels = num;
     }
 
-    void update(const KisTextureTileUpdateInfo &updateInfo);
+    void update(const KisTextureTileUpdateInfo &updateInfo, bool blockMipmapRegeneration);
 
     inline QRect tileRectInImagePixels() {
         return m_tileRectInImagePixels;
     }
 
     inline QRect textureRectInImagePixels() {
         return m_textureRectInImagePixels;
     }
 
     inline QRectF tileRectInTexturePixels() {
         return m_tileRectInTexturePixels;
     }
 
     QRectF imageRectInTexturePixels(const QRect &imageRect) const;
 
     /**
      * Binds the tile's testure to the current GL_TEXTURE_2D binding point,
      * regenerates the mipmap if needed and returns the levelOfDetail that
      * should be used for painting
      */
     int bindToActiveTexture(bool blockMipmapRegeneration);
 
 private:
     inline void setTextureParameters();
 
     void setNeedsMipmapRegeneration();
     void setPreparedLodPlane(int lod);
 
     GLuint m_textureId;
 
 #ifdef USE_PIXEL_BUFFERS
     void createTextureBuffer(const char*data, int size);
     QOpenGLBuffer *m_glBuffer;
 #endif
 
     QRect m_tileRectInImagePixels;
     QRectF m_tileRectInTexturePixels;
     QRect m_textureRectInImagePixels;
     KisOpenGL::FilterMode m_filter;
     const KisGLTexturesInfo *m_texturesInfo;
     bool m_needsMipmapRegeneration;
     int m_preparedLodPlane;
     bool m_useBuffer;
     int m_numMipmapLevels;
     QOpenGLFunctions *f;
     Q_DISABLE_COPY(KisTextureTile)
 };
 
 #endif /* KIS_TEXTURE_TILE_H_ */