diff --git a/krita/krita4.xmlgui b/krita/krita4.xmlgui
index 62ae044a0e..38ec8d069d 100644
--- a/krita/krita4.xmlgui
+++ b/krita/krita4.xmlgui
@@ -1,390 +1,390 @@
 <?xml version="1.0"?>
 <kpartgui xmlns="http://www.kde.org/standards/kxmlgui/1.0"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 name="Krita"
 version="401"
 xsi:schemaLocation="http://www.kde.org/standards/kxmlgui/1.0  http://www.kde.org/standards/kxmlgui/1.0/kxmlgui.xsd">
   <MenuBar>
     <Menu name="file">
       <text>&amp;File</text>
       <Action name="file_new"/>
       <Action name="file_open"/>
       <Action name="file_open_recent"/>
       <Separator/>
       <Action name="file_save"/>
       <Action name="file_save_as"/>
       <Action name="file_reload_file"/>
       <Separator/>
       <Action name="file_sessions"/>
       <Separator/>
       <Action name="file_import_file"/>
       <Action name="file_export_file"/>
       <Separator/>
       <Action name="file_export_pdf"/>
       <Separator/>
       <Action name="file_import_animation"/>
       <Action name="render_animation"/>
       <Separator/>
       <Action name="save_incremental_version"/>
       <Action name="save_incremental_backup"/>
       <Separator/>
       <Action name="create_template"/>
       <Action name="create_copy"/>
       <!--Separator/>
       <Action name="file_print"/>
       <Action name="file_print_preview"/-->
       <Separator/>
       <Action name="file_documentinfo"/>
       <Separator/>
       <Action name="file_close"/>
       <Action name="file_close_all"/>
       <Action name="file_quit"/>
     </Menu>
     <Menu name="edit">
       <text>&amp;Edit</text>
       <Action name="edit_undo"/>
       <Action name="edit_redo"/>
       <Separator/>
       <Action name="edit_cut"/>
       <Action name="edit_copy"/>
       <Action name="cut_sharp"/>
       <Action name="copy_sharp"/>
       <Action name="copy_merged"/>
       <Action name="edit_paste"/>
       <Action name="paste_at"/>
       <Action name="paste_new"/>
       <Action name="clear"/>
       <Action name="fill_selection_foreground_color"/>
       <Action name="fill_selection_background_color"/>
       <Action name="fill_selection_pattern"/>
       <Menu name="fill_special">
         <text>Fill Special</text>
         <Action name="fill_selection_foreground_color_opacity"/>
         <Action name="fill_selection_background_color_opacity"/>
         <Action name="fill_selection_pattern_opacity"/>
       </Menu>
       <Action name="stroke_shapes"/>
       <Action name="stroke_selection"/>
       <Action name="delete"/>
       <Separator/>
       <Action name="revert"/>
     </Menu>
     <Menu name="view">
       <text>&amp;View</text>
       <Action name="view_show_canvas_only"/>
       <Action name="fullscreen"/>
       <Action name="wrap_around_mode"/>
       <Action name="level_of_detail_mode"/>
       <Action name="softProof"/>
       <Action name="gamutCheck"/>
       <Separator/>
       <Menu name="Canvas">
           <text>&amp;Canvas</text>
           <Action name="mirror_canvas"/>
           <Separator/>
           <Action name="zoom_to_100pct" />
           <Action name="rotate_canvas_right" />
           <Action name="rotate_canvas_left" />
           <Action name="reset_canvas_rotation" />
           <!-- TODO: Something is not right with the way zoom actions are hooked up. These are in the KoZoomController.
                It seems they are not being properly placed in the view manager since the MDI changes were implemented
           -->
           <Action name="view_zoom_in"/>
           <Action name="view_zoom_out"/>
       </Menu>
       <!-- TODO: None of these actions are showing. There names must have been changed to something with the MDI changes?...
       <Action name="actual_pixels"/>
       <Action name="actual_size"/>
       <Action name="fit_to_canvas"/>
       -->
 
       <Separator/>
       <Action name="view_ruler"/>
       <Action name="rulers_track_mouse"/>
       <Action name="view_show_guides"/>
       <Action name="view_lock_guides"/>
       <Action name="showStatusBar" />
       <Separator/>
       <Action name="view_grid"/>
       <Action name="view_pixel_grid"/>
 
 
       <Separator/>
       <Menu name="SnapTo">
         <text>&amp;Snap To</text>
         <Action name="view_snap_to_guides"/>
             <Action name="view_snap_to_grid"/>
           <Action name="view_snap_orthogonal" />
             <Action name="view_snap_node" />
             <Action name="view_snap_extension" />
             <Action name="view_snap_intersection" />
             <Action name="view_snap_bounding_box" />
             <Action name="view_snap_image_bounds" />
              <Action name="view_snap_image_center" />
       </Menu>
       <Separator/>
 
       <Action name="view_toggle_painting_assistants"/>
       <Action name="view_toggle_assistant_previews"/>
       <Action name="view_toggle_reference_images"/>
       <Separator/>
       <Action name="view_palette_action_menu"/>
       <Separator/>
       <Action name="refresh_canvas"/>
     </Menu>
     <Menu name="Image">
       <text>&amp;Image</text>
       <Action name="image_properties"/>
       <Action name="image_color"/>
       <Action name="imagecolorspaceconversion"/>
       <Action name="duplicate_image"/>
       <Separator/>
       <Action name="trim_to_image"/>
       <Action name="resizeimagetolayer"/>
       <Action name="resizeimagetoselection"/>
       <Separator/>
       <Menu name="Rotate">
         <text>&amp;Rotate</text>
         <Action name="rotateimage"/>
         <Separator/>
         <Action name="rotateImageCW90"/>
         <Action name="rotateImageCCW90"/>
         <Action name="rotateImage180"/>
       </Menu>
       <Action name="shearimage"/>
       <Separator/>
       <Action name="mirrorImageHorizontal"/>
       <Action name="mirrorImageVertical"/>
       <Separator/>
       <Action name="imagesize"/>
       <Action name="offsetimage"/>
       <Action name="imageresolution"/>
       <Action name="canvassize"/>
       <Separator/>
       <Action name="imagesplit"/>
       <Action name="waveletdecompose"/>
       <Action name="separate"/>
     </Menu>
     <Menu name="Layer">
       <text>&amp;Layer</text>
       <Action name="cut_layer_clipboard"/>
       <Action name="copy_layer_clipboard"/>
       <Action name="paste_layer_from_clipboard"/>
       <Separator/>
       <Menu name="LayerNew">
         <text>New</text>
         <Action name="add_new_paint_layer"/>
         <Action name="new_from_visible"/>
         <Action name="duplicatelayer"/>
         <Separator/>
         <Action name="cut_selection_to_new_layer"/>
         <Action name="copy_selection_to_new_layer"/>
       </Menu>
       <Menu name="LayerImportExport">
         <text>&amp;Import/Export</text>
         <Action name="save_node_as_image"/>
         <Action name="save_vector_node_to_svg"/>
         <Action name="save_groups_as_images"/>
         <Separator/>
         <Action name="import_layer_from_file"/>
         <Menu name="LayerImportAs">
           <text>Import</text>
           <Action name="import_layer_as_paint_layer"/>
           <Action name="import_layer_as_transparency_mask"/>
           <Action name="import_layer_as_filter_mask"/>
           <Action name="import_layer_as_selection_mask"/>
         </Menu>
       </Menu>
       <Menu name="LayerConvert">
         <text>&amp;Convert</text>
         <Action name="convert_to_paint_layer"/>
         <Action name="convert_to_transparency_mask"/>
         <Action name="convert_to_filter_mask"/>
         <Action name="convert_to_selection_mask"/>
         <Action name="convert_layer_to_file_layer"/>
         <Action name="convert_group_to_animated"/>
         <Action name="layercolorspaceconversion"/>
       </Menu>
       <Separator/>
       <Menu name="LayerSelect">
         <text>&amp;Select</text>
         <Action name="select_all_layers"/>
         <Action name="select_visible_layers"/>
         <Action name="select_invisible_layers"/>
         <Action name="select_locked_layers"/>
         <Action name="select_unlocked_layers"/>
       </Menu>
       <Menu name="LayerGroup">
          <text>&amp;Group</text>
          <Action name="create_quick_group"/>
          <Action name="create_quick_clipping_group"/>
          <Action name="quick_ungroup"/>
       </Menu>
       <Menu name="LayerTransform">
          <text>&amp;Transform</text>
          <Action name="mirrorNodeX"/>
          <Action name="mirrorNodeY"/>
          <Action name="layersize"/>
          <Menu name="Rotate">
              <text>&amp;Rotate</text>
              <Action name="rotatelayer"/>
              <Separator/>
              <Action name="rotateLayerCW90"/>
              <Action name="rotateLayerCCW90"/>
              <Action name="rotateLayer180"/>
          </Menu>
          <Action name="shearlayer"/>
          <Action name="offsetlayer"/>
       </Menu>
       <Menu name="LayerSplitAlpha">
          <text>S&amp;plit</text>
          <Menu name="LayerSplitAlpha">
              <text>S&amp;plit Alpha</text>
              <Action name="split_alpha_into_mask"/>
              <Action name="split_alpha_write"/>
              <Action name="split_alpha_save_merged"/>
          </Menu>
          <Action name="layersplit"/>
          <Action name="clones_array"/>
       </Menu>
 
       <Separator/>
       <Action name="EditLayerMetaData"/>
       <Action name="histogram"/>
       <Separator/>
       <Action name="merge_layer"/>
       <Action name="flatten_layer"/>
       <Action name="rasterize_layer"/>
       <Action name="merge_all_shape_layers"/>
       <Action name="flatten_image"/>
       <Action name="merge_selected_layers"/>
       <Separator/>
       <Action name="layer_style"/>
 
     </Menu>
     <Menu name="Select">
       <text>&amp;Select</text>
       <Action name="select_all"/>
       <Action name="deselect"/>
       <Action name="reselect"/>
       <Action name="invert"/>
       <Action name="convert_to_vector_selection"/>
       <Action name="convert_shapes_to_vector_selection"/>
       <Action name="convert_selection_to_shape"/>
       <Separator/>
       <Action name="feather"/>
       <Action name="similar"/>
       <Separator/>
       <Action name="toggle_display_selection"/>
       <Action name="show-global-selection-mask"/>
       <Action name="selectionscale"/>
       <Separator/>
       <Action name="colorrange"/>
       <Action name="selectopaque"/>
       <Separator/>
       <Action name="featherselection"/>
       <Action name="growselection"/>
       <Action name="shrinkselection"/>
       <Action name="borderselection"/>
       <Action name="smoothselection"/>
     </Menu>
     <Menu name="Filter">
       <text>Filte&amp;r</text>
       <Action name="filter_apply_again"/>
       <Action name="filter_gallery"/>
       <Separator/>
       <Action name="adjust_filters"/>
       <Action name="artistic_filters"/>
       <Action name="blur_filters"/>
       <Action name="color_filters"/>
       <Action name="decor_filters"/>
       <Action name="edge_filters"/>
       <Action name="enhance_filters"/>
       <Action name="emboss_filters"/>
       <Action name="map_filters"/>
       <Action name="nonphotorealistic_filters"/>
       <Action name="other_filters"/>
       <Separator/>
       <Action name="QMic"/>
       <Action name="QMicAgain"/>
     </Menu>
     <Menu name="tools">
       <text>&amp;Tools</text>
-      <Action name="scripts"/>
+      <Menu name="scripts"><text>Scripting</text></Menu>
       <Menu name="Recording">
         <text>Recording</text>
         <Action name="Recording_Start_Recording_Macro"/>
         <Action name="Recording_Stop_Recording_Macro"/>
       </Menu>
       <Menu name="Macros">
         <text>Macros</text>
         <Action name="Macro_Open_Play"/>
         <Action name="Macro_Open_Edit"/>
       </Menu>
     </Menu>
     <Menu name="settings">
       <text>Setti&amp;ngs</text>
       <Action name="options_configure"/>
       <Action name="manage_bundles"/>
       <Separator/>
       <Action name="options_configure_toolbars"/>
       <Merge name="StandardToolBarMenuHandler" />
       <Separator/>
       <Action name="view_toggledockers"/>
       <Action name="view_toggledockertitlebars"/>
       <Action name="settings_dockers_menu"/>
       <Separator/>
       <Action name="theme_menu"/>
       <Separator/>
       <!-- `Configure Shortcuts` was moved into main configuration menu -->
       <!-- <Action name="options_configure_keybinding"/> -->
       <Separator/>
       <Action name="switch_application_language"/>
       <Action name="settings_active_author"/>
       <Separator/>
     </Menu>
     <Action name="window"/>
     <Separator/>
     <Menu name="help">
       <text>&amp;Help</text>
       <Action name="help_contents"/>
       <Action name="help_whats_this"/>
       <Separator/>
       <MergeLocal/>
       <Action name="help_show_tip"/>
       <Separator/>
       <Action name="help_report_bug"/>
       <Action name="buginfo"/>
       <Separator/>
       <Action name="help_about_app"/>
       <Action name="help_about_kde"/>
     </Menu>
   </MenuBar>
   <ToolBar name="mainToolBar" fullWidth="false" noMerge="1">
     <Text>File</Text>
     <Action name="file_new"/>
     <Action name="file_open"/>
     <Action name="file_save"/>
     <Separator/>
     <Action name="edit_undo"/>
     <Action name="edit_redo"/>
   </ToolBar>
   <ToolBar name="BrushesAndStuff" position="top">
     <Text>Brushes and Stuff</Text>
     <Action name="gradients"/>
     <Action name="patterns"/>
     <Separator/>
     <Action name="dual"/>
     <Separator/>
     <Action name="paintops"/>
     <Action name="paintop_options"/>
     <Action name="composite_actions"/>
     <Action name="brushslider1"/>
     <Action name="brushslider2"/>
     <Separator/>
     <Action name="mirror_actions"/>
     <Action name="expanding_spacer_1"/>
     <Action name="select_layout"/>
     <Action name="workspaces"/>
   </ToolBar>
 </kpartgui>
diff --git a/libs/image/brushengine/kis_paintop_settings.cpp b/libs/image/brushengine/kis_paintop_settings.cpp
index 776eacafab..ce465f7f8c 100644
--- a/libs/image/brushengine/kis_paintop_settings.cpp
+++ b/libs/image/brushengine/kis_paintop_settings.cpp
@@ -1,512 +1,524 @@
 /*
  *  Copyright (c) 2007 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2008 Lukáš Tvrdý <lukast.dev@gmail.com>
  *  Copyright (c) 2014 Mohit Goyal <mohit.bits2011@gmail.com>
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include <brushengine/kis_paintop_settings.h>
 
 #include <QImage>
 #include <QColor>
 #include <QPointer>
 
 #include <KoPointerEvent.h>
 #include <KoColor.h>
 #include <KoCompositeOpRegistry.h>
 #include <KoViewConverter.h>
 
 #include "kis_paint_layer.h"
 #include "kis_image.h"
 #include "kis_painter.h"
 #include "kis_paint_device.h"
 #include "kis_paintop_registry.h"
 #include "kis_timing_information.h"
 #include <brushengine/kis_paint_information.h>
 #include "kis_paintop_config_widget.h"
 #include <brushengine/kis_paintop_preset.h>
 #include "kis_paintop_settings_update_proxy.h"
 #include <time.h>
 #include <kis_types.h>
 #include <kis_signals_blocker.h>
 
 #include <brushengine/kis_locked_properties_server.h>
 #include <brushengine/kis_locked_properties_proxy.h>
 
 #include "KisPaintopSettingsIds.h"
 
 
 struct Q_DECL_HIDDEN KisPaintOpSettings::Private {
     Private()
         : disableDirtyNotifications(false)
     {}
 
     QPointer<KisPaintOpConfigWidget> settingsWidget;
     QString modelName;
     KisPaintOpPresetWSP preset;
     QList<KisUniformPaintOpPropertyWSP> uniformProperties;
 
     bool disableDirtyNotifications;
 
     class DirtyNotificationsLocker {
     public:
         DirtyNotificationsLocker(KisPaintOpSettings::Private *d)
             : m_d(d),
               m_oldNotificationsState(d->disableDirtyNotifications)
         {
             m_d->disableDirtyNotifications = true;
         }
 
         ~DirtyNotificationsLocker() {
             m_d->disableDirtyNotifications = m_oldNotificationsState;
         }
 
     private:
         KisPaintOpSettings::Private *m_d;
         bool m_oldNotificationsState;
         Q_DISABLE_COPY(DirtyNotificationsLocker)
     };
 
     KisPaintopSettingsUpdateProxy* updateProxyNoCreate() const {
         auto presetSP = preset.toStrongRef();
         return presetSP ? presetSP->updateProxyNoCreate() : 0;
     }
 
     KisPaintopSettingsUpdateProxy* updateProxyCreate() const {
         auto presetSP = preset.toStrongRef();
         return presetSP ? presetSP->updateProxy() : 0;
     }
 };
 
 
 KisPaintOpSettings::KisPaintOpSettings()
     : d(new Private)
 {
     d->preset = 0;
 }
 
 KisPaintOpSettings::~KisPaintOpSettings()
 {
 }
 
 KisPaintOpSettings::KisPaintOpSettings(const KisPaintOpSettings &rhs)
     : KisPropertiesConfiguration(rhs)
     , d(new Private)
 {
     d->settingsWidget = 0;
     d->preset = rhs.preset();
     d->modelName = rhs.modelName();
 }
 
 void KisPaintOpSettings::setOptionsWidget(KisPaintOpConfigWidget* widget)
 {
     d->settingsWidget = widget;
 }
 void KisPaintOpSettings::setPreset(KisPaintOpPresetWSP preset)
 {
     d->preset = preset;
 }
 KisPaintOpPresetWSP KisPaintOpSettings::preset() const
 {
     return d->preset;
 }
 
 bool KisPaintOpSettings::mousePressEvent(const KisPaintInformation &paintInformation, Qt::KeyboardModifiers modifiers, KisNodeWSP currentNode)
 {
     Q_UNUSED(modifiers);
     Q_UNUSED(currentNode);
     setRandomOffset(paintInformation);
     return true; // ignore the event by default
 }
 
 void KisPaintOpSettings::setRandomOffset(const KisPaintInformation &paintInformation)
 {
     if (getBool("Texture/Pattern/Enabled")) {
         if (getBool("Texture/Pattern/isRandomOffsetX")) {
             setProperty("Texture/Pattern/OffsetX",
                         paintInformation.randomSource()->generate(0, KisPropertiesConfiguration::getInt("Texture/Pattern/MaximumOffsetX")));
         }
         if (getBool("Texture/Pattern/isRandomOffsetY")) {
             setProperty("Texture/Pattern/OffsetY",
                         paintInformation.randomSource()->generate(0, KisPropertiesConfiguration::getInt("Texture/Pattern/MaximumOffsetY")));
 
         }
     }
 
 }
 
 bool KisPaintOpSettings::hasMaskingSettings() const
 {
     return getBool(KisPaintOpUtils::MaskingBrushEnabledTag, false);
 }
 
 KisPaintOpSettingsSP KisPaintOpSettings::createMaskingSettings() const
 {
     if (!hasMaskingSettings()) return KisPaintOpSettingsSP();
 
     const KoID pixelBrushId(KisPaintOpUtils::MaskingBrushPaintOpId, QString());
 
     KisPaintOpSettingsSP maskingSettings = KisPaintOpRegistry::instance()->settings(pixelBrushId);
     this->getPrefixedProperties(KisPaintOpUtils::MaskingBrushPresetPrefix, maskingSettings);
 
     const bool useMasterSize = this->getBool(KisPaintOpUtils::MaskingBrushUseMasterSizeTag, true);
     if (useMasterSize) {
         const qreal masterSizeCoeff = getDouble(KisPaintOpUtils::MaskingBrushMasterSizeCoeffTag, 1.0);
         maskingSettings->setPaintOpSize(masterSizeCoeff * paintOpSize());
     }
 
     return maskingSettings;
 }
 
 QString KisPaintOpSettings::maskingBrushCompositeOp() const
 {
     return getString(KisPaintOpUtils::MaskingBrushCompositeOpTag, COMPOSITE_MULT);
 }
 
 KisPaintOpSettingsSP KisPaintOpSettings::clone() const
 {
     QString paintopID = getString("paintop");
     if (paintopID.isEmpty())
         return 0;
 
     KisPaintOpSettingsSP settings = KisPaintOpRegistry::instance()->settings(KoID(paintopID, ""));
     QMapIterator<QString, QVariant> i(getProperties());
     while (i.hasNext()) {
         i.next();
         settings->setProperty(i.key(), QVariant(i.value()));
     }
     settings->setPreset(this->preset());
     return settings;
 }
 
-void KisPaintOpSettings::resetSettings()
+void KisPaintOpSettings::resetSettings(const QStringList &preserveProperties)
 {
-    const QString paintopID = getString("paintop");
+    QStringList allKeys = preserveProperties;
+    allKeys << "paintop";
+
+    QHash<QString, QVariant> preserved;
+    Q_FOREACH (const QString &key, allKeys) {
+        if (hasProperty(key)) {
+            preserved[key] = getProperty(key);
+        }
+    }
+
     clearProperties();
-    setProperty("paintop", paintopID);
+
+    for (auto it = preserved.constBegin(); it != preserved.constEnd(); ++it) {
+        setProperty(it.key(), it.value());
+    }
 }
 
 void KisPaintOpSettings::activate()
 {
 }
 
 void KisPaintOpSettings::setPaintOpOpacity(qreal value)
 {
     KisLockedPropertiesProxySP proxy(
                 KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(this));
 
     proxy->setProperty("OpacityValue", value);
 }
 
 void KisPaintOpSettings::setPaintOpFlow(qreal value)
 {
     KisLockedPropertiesProxySP proxy(
                 KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(this));
 
     proxy->setProperty("FlowValue", value);
 }
 
 void KisPaintOpSettings::setPaintOpCompositeOp(const QString &value)
 {
     KisLockedPropertiesProxySP proxy(
                 KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(this));
 
     proxy->setProperty("CompositeOp", value);
 }
 
 qreal KisPaintOpSettings::paintOpOpacity()
 {
     KisLockedPropertiesProxySP proxy = KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(this);
 
     return proxy->getDouble("OpacityValue", 1.0);
 }
 
 qreal KisPaintOpSettings::paintOpFlow()
 {
     KisLockedPropertiesProxySP proxy(
                 KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(this));
 
     return proxy->getDouble("FlowValue", 1.0);
 }
 
 QString KisPaintOpSettings::paintOpCompositeOp()
 {
     KisLockedPropertiesProxySP proxy(
                 KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(this));
 
     return proxy->getString("CompositeOp", COMPOSITE_OVER);
 }
 
 void KisPaintOpSettings::setEraserMode(bool value)
 {
     KisLockedPropertiesProxySP proxy(
                 KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(this));
 
     proxy->setProperty("EraserMode", value);
 }
 
 bool KisPaintOpSettings::eraserMode()
 {
     KisLockedPropertiesProxySP proxy(
                 KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(this));
 
     return proxy->getBool("EraserMode", false);
 }
 
 QString KisPaintOpSettings::effectivePaintOpCompositeOp()
 {
     return !eraserMode() ? paintOpCompositeOp() : COMPOSITE_ERASE;
 }
 
 qreal KisPaintOpSettings::savedEraserSize() const
 {
     return getDouble("SavedEraserSize", 0.0);
 }
 
 void KisPaintOpSettings::setSavedEraserSize(qreal value)
 {
     setProperty("SavedEraserSize", value);
     setPropertyNotSaved("SavedEraserSize");
 }
 
 qreal KisPaintOpSettings::savedBrushSize() const
 {
     return getDouble("SavedBrushSize", 0.0);
 }
 
 void KisPaintOpSettings::setSavedBrushSize(qreal value)
 {
     setProperty("SavedBrushSize", value);
     setPropertyNotSaved("SavedBrushSize");
 }
 
 qreal KisPaintOpSettings::savedEraserOpacity() const
 {
     return getDouble("SavedEraserOpacity", 0.0);
 }
 
 void KisPaintOpSettings::setSavedEraserOpacity(qreal value)
 {
     setProperty("SavedEraserOpacity", value);
     setPropertyNotSaved("SavedEraserOpacity");
 }
 
 qreal KisPaintOpSettings::savedBrushOpacity() const
 {
     return getDouble("SavedBrushOpacity", 0.0);
 }
 
 void KisPaintOpSettings::setSavedBrushOpacity(qreal value)
 {
     setProperty("SavedBrushOpacity", value);
     setPropertyNotSaved("SavedBrushOpacity");
 }
 
 QString KisPaintOpSettings::modelName() const
 {
     return d->modelName;
 }
 
 void KisPaintOpSettings::setModelName(const QString & modelName)
 {
     d->modelName = modelName;
 }
 
 KisPaintOpConfigWidget* KisPaintOpSettings::optionsWidget() const
 {
     if (d->settingsWidget.isNull())
         return 0;
 
     return d->settingsWidget.data();
 }
 
 bool KisPaintOpSettings::isValid() const
 {
     return true;
 }
 
 bool KisPaintOpSettings::isLoadable()
 {
     return isValid();
 }
 
 QString KisPaintOpSettings::indirectPaintingCompositeOp() const
 {
     return COMPOSITE_ALPHA_DARKEN;
 }
 
 bool KisPaintOpSettings::isAirbrushing() const
 {
     return getBool(AIRBRUSH_ENABLED, false);
 }
 
 qreal KisPaintOpSettings::airbrushInterval() const
 {
     qreal rate = getDouble(AIRBRUSH_RATE, 1.0);
     if (rate == 0.0) {
         return LONG_TIME;
     }
     else {
         return 1000.0 / rate;
     }
 }
 
 bool KisPaintOpSettings::useSpacingUpdates() const
 {
     return getBool(SPACING_USE_UPDATES, false);
 }
 
 bool KisPaintOpSettings::needsAsynchronousUpdates() const
 {
     return false;
 }
 
 QPainterPath KisPaintOpSettings::brushOutline(const KisPaintInformation &info, OutlineMode mode)
 {
     QPainterPath path;
     if (mode == CursorIsOutline || mode == CursorIsCircleOutline || mode == CursorTiltOutline) {
         path = ellipseOutline(10, 10, 1.0, 0);
 
         if (mode == CursorTiltOutline) {
             path.addPath(makeTiltIndicator(info, QPointF(0.0, 0.0), 0.0, 2.0));
         }
 
         path.translate(info.pos());
     }
 
     return path;
 }
 
 QPainterPath KisPaintOpSettings::ellipseOutline(qreal width, qreal height, qreal scale, qreal rotation)
 {
     QPainterPath path;
     QRectF ellipse(0, 0, width * scale, height * scale);
     ellipse.translate(-ellipse.center());
     path.addEllipse(ellipse);
 
     QTransform m;
     m.reset();
     m.rotate(rotation);
     path = m.map(path);
     return path;
 }
 
 QPainterPath KisPaintOpSettings::makeTiltIndicator(KisPaintInformation const& info,
                                                    QPointF const& start, qreal maxLength, qreal angle)
 {
     if (maxLength == 0.0) maxLength = 50.0;
     maxLength = qMax(maxLength, 50.0);
     qreal const length = maxLength * (1 - info.tiltElevation(info, 60.0, 60.0, true));
     qreal const baseAngle = 360.0 - fmod(KisPaintInformation::tiltDirection(info, true) * 360.0 + 270.0, 360.0);
 
     QLineF guideLine = QLineF::fromPolar(length, baseAngle + angle);
     guideLine.translate(start);
     QPainterPath ret;
     ret.moveTo(guideLine.p1());
     ret.lineTo(guideLine.p2());
     guideLine.setAngle(baseAngle - angle);
     ret.lineTo(guideLine.p2());
     ret.lineTo(guideLine.p1());
     return ret;
 }
 
 void KisPaintOpSettings::setCanvasRotation(qreal angle)
 {
     Private::DirtyNotificationsLocker locker(d.data());
 
     setProperty("runtimeCanvasRotation", angle);
     setPropertyNotSaved("runtimeCanvasRotation");
 }
 
 void KisPaintOpSettings::setCanvasMirroring(bool xAxisMirrored, bool yAxisMirrored)
 {
     Private::DirtyNotificationsLocker locker(d.data());
 
     setProperty("runtimeCanvasMirroredX", xAxisMirrored);
     setPropertyNotSaved("runtimeCanvasMirroredX");
 
     setProperty("runtimeCanvasMirroredY", yAxisMirrored);
     setPropertyNotSaved("runtimeCanvasMirroredY");
 }
 
 void KisPaintOpSettings::setProperty(const QString & name, const QVariant & value)
 {
     if (value != KisPropertiesConfiguration::getProperty(name) &&
             !d->disableDirtyNotifications) {
         KisPaintOpPresetSP presetSP = preset().toStrongRef();
         if (presetSP) {
             presetSP->setPresetDirty(true);
         }
     }
 
     KisPropertiesConfiguration::setProperty(name, value);
     onPropertyChanged();
 }
 
 
 void KisPaintOpSettings::onPropertyChanged()
 {
     KisPaintopSettingsUpdateProxy *proxy = d->updateProxyNoCreate();
 
     if (proxy) {
         proxy->notifySettingsChanged();
     }
 }
 
 bool KisPaintOpSettings::isLodUserAllowed(const KisPropertiesConfigurationSP config)
 {
     return config->getBool("lodUserAllowed", true);
 }
 
 void KisPaintOpSettings::setLodUserAllowed(KisPropertiesConfigurationSP config, bool value)
 {
     config->setProperty("lodUserAllowed", value);
 }
 
 bool KisPaintOpSettings::lodSizeThresholdSupported() const
 {
     return true;
 }
 
 qreal KisPaintOpSettings::lodSizeThreshold() const
 {
     return getDouble("lodSizeThreshold", 100.0);
 }
 
 void KisPaintOpSettings::setLodSizeThreshold(qreal value)
 {
     setProperty("lodSizeThreshold", value);
 }
 
 #include "kis_standard_uniform_properties_factory.h"
 
 QList<KisUniformPaintOpPropertySP> KisPaintOpSettings::uniformProperties(KisPaintOpSettingsSP settings)
 {
     QList<KisUniformPaintOpPropertySP> props =
             listWeakToStrong(d->uniformProperties);
 
 
     if (props.isEmpty()) {
         using namespace KisStandardUniformPropertiesFactory;
 
         props.append(createProperty(opacity, settings, d->updateProxyCreate()));
         props.append(createProperty(size, settings, d->updateProxyCreate()));
         props.append(createProperty(flow, settings, d->updateProxyCreate()));
 
         d->uniformProperties = listStrongToWeak(props);
     }
 
     return props;
 }
diff --git a/libs/image/brushengine/kis_paintop_settings.h b/libs/image/brushengine/kis_paintop_settings.h
index 6afbe4bedb..6efd7fe4f8 100644
--- a/libs/image/brushengine/kis_paintop_settings.h
+++ b/libs/image/brushengine/kis_paintop_settings.h
@@ -1,352 +1,352 @@
 /*
  *  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_PAINTOP_SETTINGS_H_
 #define KIS_PAINTOP_SETTINGS_H_
 
 #include "kis_types.h"
 #include "kritaimage_export.h"
 
 #include <QImage>
 #include <QScopedPointer>
 
 #include "kis_properties_configuration.h"
 #include <brushengine/kis_paint_information.h>
 #include <brushengine/kis_uniform_paintop_property.h>
 
 
 
 class KisPaintOpConfigWidget;
 class KisPaintopSettingsUpdateProxy;
 
 /**
  * Configuration property used to control whether airbrushing is enabled.
  */
 const QString AIRBRUSH_ENABLED = "PaintOpSettings/isAirbrushing";
 
 /**
  * Configuration property used to control airbrushing rate. The value should be in dabs per second.
  */
 const QString AIRBRUSH_RATE = "PaintOpSettings/rate";
 
 /**
  * Configuration property used to control whether airbrushing is configured to ignore distance-based
  * spacing.
  */
 const QString AIRBRUSH_IGNORE_SPACING = "PaintOpSettings/ignoreSpacing";
 
 /**
  * Configuration property used to control whether the spacing settings can be updated between
  * painted dabs.
  */
 const QString SPACING_USE_UPDATES = "PaintOpSettings/updateSpacingBetweenDabs";
 
 /**
  * This class is used to cache the settings for a paintop
  * between two creations. There is one KisPaintOpSettings per input device (mouse, tablet,
  * etc...).
  *
  * The settings may be stored in a preset or a recorded brush stroke. Note that if your
  * paintop's settings subclass has data that is not stored as a property, that data is not
  * saved and restored.
  *
  * The object also contains a pointer to its parent KisPaintOpPreset object.This is to control the DirtyPreset
  * property of KisPaintOpPreset. Whenever the settings are changed/modified from the original -- the preset is
  * set to dirty.
  */
 class KRITAIMAGE_EXPORT KisPaintOpSettings : public KisPropertiesConfiguration
 {
 
 public:
 
     KisPaintOpSettings();
     ~KisPaintOpSettings() override;
     KisPaintOpSettings(const KisPaintOpSettings &rhs);
 
     /**
      *
      */
     void setOptionsWidget(KisPaintOpConfigWidget* widget);
 
     /**
      * This function is called by a tool when the mouse is pressed. It's useful if
      * the paintop needs mouse interaction for instance in the case of the clone op.
      * If the tool is supposed to ignore the event, the paint op should return false
      * and if the tool is supposed to use the event, return true.
      */
     virtual bool mousePressEvent(const KisPaintInformation &paintInformation, Qt::KeyboardModifiers modifiers, KisNodeWSP currentNode);
 
     /**
      * Clone the current settings object. Override this if your settings instance doesn't
      * store everything as properties.
      */
     virtual KisPaintOpSettingsSP clone() const;
 
     /**
      * Removes all the settings from the object while keeping the paintop id,
      * which is loaded to the object by the factory
      */
-    void resetSettings();
+    void resetSettings(const QStringList &preserveProperties = QStringList());
 
     /**
      * @return the node the paintop is working on.
      */
     KisNodeSP node() const;
 
     /**
      * Call this function when the paint op is selected or the tool is activated
      */
     virtual void activate();
 
     /**
      * XXX: Remove this after 2.0, when the paint operation (incremental/non incremental) will
      *      be completely handled in the paintop, not in the tool. This is a filthy hack to move
      *      the option to the right place, at least.
      * @return true if we paint incrementally, false if we paint like Photoshop. By default, paintops
      *      do not support non-incremental.
      */
     virtual bool paintIncremental() {
         return true;
     }
 
     /**
      * @return the composite op it to which the indirect painting device
      * should be initialized to. This is used by clone op to reset
      * the composite op to COMPOSITE_COPY
      */
     virtual QString indirectPaintingCompositeOp() const;
 
     /**
      * Whether this paintop wants to deposit paint even when not moving, i.e. the tool needs to
      * activate its timer. If this is true, painting updates need to be generated at regular
      * intervals even in the absence of input device events, e.g. when the cursor is not moving.
      *
      * The default implementation checks the property AIRBRUSH_ENABLED, defaulting to false if the
      * property is not found. This should be suitable for most paintops.
      */
     virtual bool isAirbrushing() const;
 
     /**
      * Indicates the minimum time interval that might be needed between airbrush dabs, in
      * milliseconds. A lower value means painting updates need to happen more frequently. This value
      * should be ignored if isAirbrushing() is false.
      *
      * The default implementation uses the property AIRBRUSH_RATE, defaulting to an interval of
      * one second if the property is not found. This should be suitable for most paintops.
      */
     virtual qreal airbrushInterval() const;
 
     /**
      * Indicates whether this configuration allows spacing information to be updated between painted
      * dabs during a stroke.
      */
     virtual bool useSpacingUpdates() const;
 
     /**
      * Indicates if the tool should call paintOp->doAsynchronousUpdate() inbetween
      * paintAt() calls to do the asynchronous rendering
      */
     virtual bool needsAsynchronousUpdates() const;
 
     /**
      * This enum defines the current mode for painting an outline.
      */
     enum OutlineMode {
         CursorIsOutline = 1, ///< When this mode is set, an outline is painted around the cursor
         CursorIsCircleOutline,
         CursorNoOutline,
         CursorTiltOutline,
         CursorColorOutline
     };
 
     /**
      * Returns the brush outline in pixel coordinates. Tool is responsible for conversion into view coordinates.
      * Outline mode has to be passed to the paintop which builds the outline as some paintops have to paint outline
      * always like clone paintop indicating the duplicate position
      */
     virtual QPainterPath brushOutline(const KisPaintInformation &info, OutlineMode mode);
 
     /**
     * Helpers for drawing the brush outline
     */
     static QPainterPath ellipseOutline(qreal width, qreal height, qreal scale, qreal rotation);
 
     /**
      * Helper for drawing a triangle representing the tilt of the stylus.
      *
      * @param start is the offset from the brush's outline's bounding box
      * @param lengthScale is used for deciding the size of the triangle.
      * Brush diameter or width are common choices for this.
      * @param angle is the angle between the two sides of the triangle.
      */
     static QPainterPath makeTiltIndicator(KisPaintInformation const& info,
         QPointF const& start, qreal lengthScale, qreal angle);
 
     /**
      * Set paintop opacity directly in the properties
      */
     void setPaintOpOpacity(qreal value);
 
     /**
      * Set paintop flow directly in the properties
      */
     void setPaintOpFlow(qreal value);
 
     /**
      * Set paintop composite mode directly in the properties
      */
     void setPaintOpCompositeOp(const QString &value);
 
     /**
      * @return opacity saved in the properties
      */
     qreal paintOpOpacity();
 
     /**
      * @return flow saved in the properties
      */
     qreal paintOpFlow();
 
     /**
      * @return composite mode saved in the properties
      */
     QString paintOpCompositeOp();
 
     /**
      * Set paintop size directly in the properties
      */
     virtual void setPaintOpSize(qreal value) = 0;
 
     /**
      * @return size saved in the properties
      */
     virtual qreal paintOpSize() const = 0;
 
     void setEraserMode(bool value);
     bool eraserMode();
 
     qreal savedEraserSize() const;
     void setSavedEraserSize(qreal value);
     qreal savedBrushSize() const;
     void setSavedBrushSize(qreal value);
 
     qreal savedEraserOpacity() const;
     void setSavedEraserOpacity(qreal value);
     qreal savedBrushOpacity() const;
     void setSavedBrushOpacity(qreal value);
 
     QString effectivePaintOpCompositeOp();
 
     void setPreset(KisPaintOpPresetWSP preset);
 
     KisPaintOpPresetWSP preset() const;
 
     /**
      * @return filename of the 3D brush model, empty if no brush is set
      */
     virtual QString modelName() const;
 
     /**
     * Set filename of 3D brush model. By default no brush is set
     */
     void setModelName(const QString & modelName);
 
     /// Check if the settings are valid, setting might be invalid through missing brushes etc
     /// Overwrite if the settings of a paintop can be invalid
     /// @return state of the settings, default implementation is true
     virtual bool isValid() const;
 
     /// Check if the settings are loadable, that might the case if we can fallback to something
     /// Overwrite if the settings can do some kind of fallback
     /// @return loadable state of the settings, by default implementation return the same as isValid()
     virtual bool isLoadable();
 
     /**
      * These methods are populating properties with runtime
      * information about canvas rotation/mirroring. This information
      * is set directly by KisToolFreehand. Later the data is accessed
      * by the pressure options to make a final decision.
      */
     void setCanvasRotation(qreal angle);
     void setCanvasMirroring(bool xAxisMirrored, bool yAxisMirrored);
 
     /**
      * Overrides the method in KisPropertiesCofiguration to allow
      * onPropertyChanged() callback
      */
     void setProperty(const QString & name, const QVariant & value) override;
 
     virtual QList<KisUniformPaintOpPropertySP> uniformProperties(KisPaintOpSettingsSP settings);
 
     static bool isLodUserAllowed(const KisPropertiesConfigurationSP config);
     static void setLodUserAllowed(KisPropertiesConfigurationSP config, bool value);
 
     virtual bool lodSizeThresholdSupported() const;
 
     qreal lodSizeThreshold() const;
     void setLodSizeThreshold(qreal value);
 
     /**
     * @return the option widget of the paintop (can be 0 is no option widgets is set)
     */
     KisPaintOpConfigWidget* optionsWidget() const;
 
 
     /**
      * This function is called to set random offsets to the brush whenever the mouse is clicked. It is
      * specific to when the pattern option is set.
      *
      */
     virtual void setRandomOffset(const KisPaintInformation &paintInformation);
 
     /**
      * @return true if this preset demands a secondary masked brush running
      *         alongside it
      */
     bool hasMaskingSettings() const;
 
     /**
      * @return a newly created settings object representing a preset of the masking
      *         brush that should be run alongside the current brush
      */
     KisPaintOpSettingsSP createMaskingSettings() const;
 
     /**
      * @return a composite op id of the masked brush rendering algorithm.
      *
      * Please take into account that the brush itself always paints in alpha-
      * darken mode, but the final result is combined with this composite op.
      */
     QString maskingBrushCompositeOp() const;
 
 protected:
 
     /**
      * The callback is called every time when a property changes
      */
     virtual void onPropertyChanged();
 
 private:
 
 
 
     struct Private;
     const QScopedPointer<Private> d;
 };
 
 #endif
diff --git a/libs/image/floodfill/kis_scanline_fill.cpp b/libs/image/floodfill/kis_scanline_fill.cpp
index 39f7249817..e524d0a3d4 100644
--- a/libs/image/floodfill/kis_scanline_fill.cpp
+++ b/libs/image/floodfill/kis_scanline_fill.cpp
@@ -1,717 +1,728 @@
 /*
  *  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_scanline_fill.h"
 
 #include <KoAlwaysInline.h>
 
 #include <QStack>
 #include <KoColor.h>
 #include <KoColorSpace.h>
 #include <KoCompositeOpRegistry.h>
 #include "kis_image.h"
 #include "kis_fill_interval_map.h"
 #include "kis_pixel_selection.h"
 #include "kis_random_accessor_ng.h"
 #include "kis_fill_sanity_checks.h"
 
 
 template <class BaseClass>
 class CopyToSelection : public BaseClass
 {
 public:
     typedef KisRandomConstAccessorSP SourceAccessorType;
 
     SourceAccessorType createSourceDeviceAccessor(KisPaintDeviceSP device) {
         return device->createRandomConstAccessorNG(0, 0);
     }
 
 public:
     void setDestinationSelection(KisPaintDeviceSP pixelSelection) {
         m_pixelSelection = pixelSelection;
         m_it = m_pixelSelection->createRandomAccessorNG(0,0);
     }
 
     ALWAYS_INLINE void fillPixel(quint8 *dstPtr, quint8 opacity, int x, int y) {
         Q_UNUSED(dstPtr);
         m_it->moveTo(x, y);
         *m_it->rawData() = opacity;
     }
 
 private:
     KisPaintDeviceSP m_pixelSelection;
     KisRandomAccessorSP m_it;
 };
 
 template <class BaseClass>
 class FillWithColor : public BaseClass
 {
 public:
     typedef KisRandomAccessorSP SourceAccessorType;
 
     SourceAccessorType createSourceDeviceAccessor(KisPaintDeviceSP device) {
         return device->createRandomAccessorNG(0, 0);
     }
 
 public:
     FillWithColor() : m_pixelSize(0) {}
 
     void setFillColor(const KoColor &sourceColor) {
         m_sourceColor = sourceColor;
         m_pixelSize = sourceColor.colorSpace()->pixelSize();
         m_data = m_sourceColor.data();
     }
 
     ALWAYS_INLINE void fillPixel(quint8 *dstPtr, quint8 opacity, int x, int y) {
         Q_UNUSED(x);
         Q_UNUSED(y);
 
         if (opacity == MAX_SELECTED) {
             memcpy(dstPtr, m_data, m_pixelSize);
         }
     }
 
 private:
     KoColor m_sourceColor;
     const quint8 *m_data;
     int m_pixelSize;
 };
 
 template <class BaseClass>
 class FillWithColorExternal : public BaseClass
 {
 public:
     typedef KisRandomConstAccessorSP SourceAccessorType;
 
     SourceAccessorType createSourceDeviceAccessor(KisPaintDeviceSP device) {
         return device->createRandomConstAccessorNG(0, 0);
     }
 
 public:
     void setDestinationDevice(KisPaintDeviceSP device) {
         m_externalDevice = device;
         m_it = m_externalDevice->createRandomAccessorNG(0,0);
     }
 
     void setFillColor(const KoColor &sourceColor) {
         m_sourceColor = sourceColor;
         m_pixelSize = sourceColor.colorSpace()->pixelSize();
         m_data = m_sourceColor.data();
     }
 
     ALWAYS_INLINE void fillPixel(quint8 *dstPtr, quint8 opacity, int x, int y) {
         Q_UNUSED(dstPtr);
 
         m_it->moveTo(x, y);
         if (opacity == MAX_SELECTED) {
             memcpy(m_it->rawData(), m_data, m_pixelSize);
         }
     }
 
 private:
     KisPaintDeviceSP m_externalDevice;
     KisRandomAccessorSP m_it;
 
     KoColor m_sourceColor;
     const quint8 *m_data;
     int m_pixelSize;
 };
 
 class DifferencePolicySlow
 {
 public:
     ALWAYS_INLINE void initDifferences(KisPaintDeviceSP device, const KoColor &srcPixel, int threshold) {
         m_colorSpace = device->colorSpace();
         m_srcPixel = srcPixel;
         m_srcPixelPtr = m_srcPixel.data();
         m_threshold = threshold;
     }
 
     ALWAYS_INLINE quint8 calculateDifference(quint8* pixelPtr) {
         if (m_threshold == 1) {
-            return memcmp(m_srcPixelPtr, pixelPtr, m_colorSpace->pixelSize());
+            if (memcmp(m_srcPixelPtr, pixelPtr, m_colorSpace->pixelSize()) == 0) {
+                return 0;
+            }
+            return quint8_MAX;
         }
         else {
             return m_colorSpace->difference(m_srcPixelPtr, pixelPtr);
         }
     }
 
 private:
     const KoColorSpace *m_colorSpace;
     KoColor m_srcPixel;
     const quint8 *m_srcPixelPtr;
     int m_threshold;
 };
 
 template <typename SrcPixelType>
 class DifferencePolicyOptimized
 {
     typedef SrcPixelType HashKeyType;
     typedef QHash<HashKeyType, quint8> HashType;
 
 public:
     ALWAYS_INLINE void initDifferences(KisPaintDeviceSP device, const KoColor &srcPixel, int threshold) {
         m_colorSpace = device->colorSpace();
         m_srcPixel = srcPixel;
         m_srcPixelPtr = m_srcPixel.data();
         m_threshold = threshold;
     }
 
     ALWAYS_INLINE quint8 calculateDifference(quint8* pixelPtr) {
         HashKeyType key = *reinterpret_cast<HashKeyType*>(pixelPtr);
 
         quint8 result;
 
         typename HashType::iterator it = m_differences.find(key);
 
         if (it != m_differences.end()) {
             result = *it;
         } else {
             if (m_threshold == 1) {
-                result = memcmp(m_srcPixelPtr, pixelPtr, m_colorSpace->pixelSize());
+                if (memcmp(m_srcPixelPtr, pixelPtr, m_colorSpace->pixelSize()) == 0) {
+                    result = 0;
+                }
+                else {
+                    result = quint8_MAX;
+                }
             }
             else {
                 result = m_colorSpace->difference(m_srcPixelPtr, pixelPtr);
             }
             m_differences.insert(key, result);
         }
 
         return result;
     }
 
 private:
     HashType m_differences;
 
     const KoColorSpace *m_colorSpace;
     KoColor m_srcPixel;
     const quint8 *m_srcPixelPtr;
     int m_threshold;
 };
 
 template <bool useSmoothSelection,
           class DifferencePolicy,
           template <class> class PixelFiller>
 class SelectionPolicy : public PixelFiller<DifferencePolicy>
 {
 public:
     typename PixelFiller<DifferencePolicy>::SourceAccessorType m_srcIt;
 
 public:
     SelectionPolicy(KisPaintDeviceSP device, const KoColor &srcPixel, int threshold)
         : m_threshold(threshold)
     {
         this->initDifferences(device, srcPixel, threshold);
         m_srcIt = this->createSourceDeviceAccessor(device);
     }
 
     ALWAYS_INLINE quint8 calculateOpacity(quint8* pixelPtr) {
         quint8 diff = this->calculateDifference(pixelPtr);
 
         if (!useSmoothSelection) {
             return diff <= m_threshold ? MAX_SELECTED : MIN_SELECTED;
         } else {
             quint8 selectionValue = qMax(0, m_threshold - diff);
 
             quint8 result = MIN_SELECTED;
 
             if (selectionValue > 0) {
                 qreal selectionNorm = qreal(selectionValue) / m_threshold;
                 result = MAX_SELECTED * selectionNorm;
             }
 
             return result;
         }
     }
 
 private:
     int m_threshold;
 };
 
 class IsNonNullPolicySlow
 {
 public:
     ALWAYS_INLINE void initDifferences(KisPaintDeviceSP device, const KoColor &srcPixel, int /*threshold*/) {
         Q_UNUSED(srcPixel);
 
         m_pixelSize = device->pixelSize();
         m_testPixel.resize(m_pixelSize);
     }
 
     ALWAYS_INLINE quint8 calculateDifference(quint8* pixelPtr) {
-        return memcmp(m_testPixel.data(), pixelPtr, m_pixelSize);
+        if (memcmp(m_testPixel.data(), pixelPtr, m_pixelSize) == 0) {
+            return 0;
+        }
+        return quint8_MAX;
     }
 
 private:
     int m_pixelSize;
     QByteArray m_testPixel;
 };
 
 template <typename SrcPixelType>
 class IsNonNullPolicyOptimized
 {
 public:
     ALWAYS_INLINE void initDifferences(KisPaintDeviceSP device, const KoColor &srcPixel, int /*threshold*/) {
         Q_UNUSED(device);
         Q_UNUSED(srcPixel);
     }
 
     ALWAYS_INLINE quint8 calculateDifference(quint8* pixelPtr) {
         SrcPixelType *pixel = reinterpret_cast<SrcPixelType*>(pixelPtr);
         return *pixel == 0;
     }
 };
 
 class GroupSplitPolicy
 {
 public:
     typedef KisRandomAccessorSP SourceAccessorType;
     SourceAccessorType m_srcIt;
 
 public:
     GroupSplitPolicy(KisPaintDeviceSP scribbleDevice,
                      KisPaintDeviceSP groupMapDevice,
                      qint32 groupIndex,
                      quint8 referenceValue, int threshold)
         : m_threshold(threshold),
           m_groupIndex(groupIndex),
           m_referenceValue(referenceValue)
     {
         KIS_SAFE_ASSERT_RECOVER_NOOP(m_groupIndex > 0);
 
         m_srcIt = scribbleDevice->createRandomAccessorNG(0,0);
         m_groupMapIt = groupMapDevice->createRandomAccessorNG(0,0);
     }
 
     ALWAYS_INLINE quint8 calculateOpacity(quint8* pixelPtr) {
         // TODO: either threshold should always be null, or there should be a special
         //       case for *pixelPtr == 0, which is different from all the other groups,
         //       whatever the threshold is
 
         int diff = qAbs(int(*pixelPtr) - m_referenceValue);
         return diff <= m_threshold ? MAX_SELECTED : MIN_SELECTED;
     }
 
     ALWAYS_INLINE void fillPixel(quint8 *dstPtr, quint8 opacity, int x, int y) {
         Q_UNUSED(opacity);
 
         // erase the scribble
         *dstPtr = 0;
 
         // write group index into the map
         m_groupMapIt->moveTo(x, y);
         qint32 *groupMapPtr = reinterpret_cast<qint32*>(m_groupMapIt->rawData());
 
         if (*groupMapPtr != 0) {
             qDebug() << ppVar(*groupMapPtr) << ppVar(m_groupIndex);
         }
 
         KIS_SAFE_ASSERT_RECOVER_NOOP(*groupMapPtr == 0);
 
         *groupMapPtr = m_groupIndex;
     }
 
 private:
     int m_threshold;
     qint32 m_groupIndex;
     quint8 m_referenceValue;
     KisRandomAccessorSP m_groupMapIt;
 };
 
 
 
 struct Q_DECL_HIDDEN KisScanlineFill::Private
 {
     KisPaintDeviceSP device;
     KisRandomAccessorSP it;
     QPoint startPoint;
     QRect boundingRect;
     int threshold;
 
     int rowIncrement;
     KisFillIntervalMap backwardMap;
     QStack<KisFillInterval> forwardStack;
 
 
     inline void swapDirection() {
         rowIncrement *= -1;
         SANITY_ASSERT_MSG(forwardStack.isEmpty(),
                           "FATAL: the forward stack must be empty "
                           "on a direction swap");
 
         forwardStack = QStack<KisFillInterval>(backwardMap.fetchAllIntervals(rowIncrement));
         backwardMap.clear();
     }
 };
 
 
 KisScanlineFill::KisScanlineFill(KisPaintDeviceSP device, const QPoint &startPoint, const QRect &boundingRect)
     : m_d(new Private)
 {
     m_d->device = device;
     m_d->it = device->createRandomAccessorNG(startPoint.x(), startPoint.y());
     m_d->startPoint = startPoint;
     m_d->boundingRect = boundingRect;
 
     m_d->rowIncrement = 1;
 
     m_d->threshold = 0;
 }
 
 KisScanlineFill::~KisScanlineFill()
 {
 }
 
 void KisScanlineFill::setThreshold(int threshold)
 {
     m_d->threshold = threshold;
 }
 
 template <class T>
 void KisScanlineFill::extendedPass(KisFillInterval *currentInterval, int srcRow, bool extendRight, T &pixelPolicy)
 {
     int x;
     int endX;
     int columnIncrement;
     int *intervalBorder;
     int *backwardIntervalBorder;
     KisFillInterval backwardInterval(currentInterval->start, currentInterval->end, srcRow);
 
     if (extendRight) {
         x = currentInterval->end;
         endX = m_d->boundingRect.right();
         if (x >= endX) return;
         columnIncrement = 1;
         intervalBorder = &currentInterval->end;
 
         backwardInterval.start = currentInterval->end + 1;
         backwardIntervalBorder = &backwardInterval.end;
     } else {
         x = currentInterval->start;
         endX = m_d->boundingRect.left();
         if (x <= endX) return;
         columnIncrement = -1;
         intervalBorder = &currentInterval->start;
 
         backwardInterval.end = currentInterval->start - 1;
         backwardIntervalBorder = &backwardInterval.start;
     }
 
     do {
         x += columnIncrement;
 
         pixelPolicy.m_srcIt->moveTo(x, srcRow);
         quint8 *pixelPtr = const_cast<quint8*>(pixelPolicy.m_srcIt->rawDataConst()); // TODO: avoid doing const_cast
         quint8 opacity = pixelPolicy.calculateOpacity(pixelPtr);
 
         if (opacity) {
             *intervalBorder = x;
             *backwardIntervalBorder = x;
             pixelPolicy.fillPixel(pixelPtr, opacity, x, srcRow);
         } else {
             break;
         }
     } while (x != endX);
 
     if (backwardInterval.isValid()) {
         m_d->backwardMap.insertInterval(backwardInterval);
     }
 }
 
 template <class T>
 void KisScanlineFill::processLine(KisFillInterval interval, const int rowIncrement, T &pixelPolicy)
 {
     m_d->backwardMap.cropInterval(&interval);
 
     if (!interval.isValid()) return;
 
     int firstX = interval.start;
     int lastX = interval.end;
     int x = firstX;
     int row = interval.row;
     int nextRow = row + rowIncrement;
 
     KisFillInterval currentForwardInterval;
 
     int numPixelsLeft = 0;
     quint8 *dataPtr = 0;
     const int pixelSize = m_d->device->pixelSize();
 
     while(x <= lastX) {
         // a bit of optimzation for not calling slow random accessor
         // methods too often
         if (numPixelsLeft <= 0) {
             pixelPolicy.m_srcIt->moveTo(x, row);
             numPixelsLeft = pixelPolicy.m_srcIt->numContiguousColumns(x) - 1;
             dataPtr = const_cast<quint8*>(pixelPolicy.m_srcIt->rawDataConst());
         } else {
             numPixelsLeft--;
             dataPtr += pixelSize;
         }
 
         quint8 *pixelPtr = dataPtr;
         quint8 opacity = pixelPolicy.calculateOpacity(pixelPtr);
 
         if (opacity) {
             if (!currentForwardInterval.isValid()) {
                 currentForwardInterval.start = x;
                 currentForwardInterval.end = x;
                 currentForwardInterval.row = nextRow;
             } else {
                 currentForwardInterval.end = x;
             }
 
             pixelPolicy.fillPixel(pixelPtr, opacity, x, row);
 
             if (x == firstX) {
                 extendedPass(&currentForwardInterval, row, false, pixelPolicy);
             }
 
             if (x == lastX) {
                 extendedPass(&currentForwardInterval, row, true, pixelPolicy);
             }
 
         } else {
             if (currentForwardInterval.isValid()) {
                 m_d->forwardStack.push(currentForwardInterval);
                 currentForwardInterval.invalidate();
             }
         }
 
         x++;
     }
 
     if (currentForwardInterval.isValid()) {
         m_d->forwardStack.push(currentForwardInterval);
     }
 }
 
 template <class T>
 void KisScanlineFill::runImpl(T &pixelPolicy)
 {
     KIS_ASSERT_RECOVER_RETURN(m_d->forwardStack.isEmpty());
 
     KisFillInterval startInterval(m_d->startPoint.x(), m_d->startPoint.x(), m_d->startPoint.y());
     m_d->forwardStack.push(startInterval);
 
     /**
      * In the end of the first pass we should add an interval
      * containing the starting pixel, but directed into the opposite
      * direction. We cannot do it in the very beginning because the
      * intervals are offset by 1 pixel during every swap operation.
      */
     bool firstPass = true;
 
     while (!m_d->forwardStack.isEmpty()) {
         while (!m_d->forwardStack.isEmpty()) {
             KisFillInterval interval = m_d->forwardStack.pop();
 
             if (interval.row > m_d->boundingRect.bottom() ||
                 interval.row < m_d->boundingRect.top()) {
 
                 continue;
             }
 
             processLine(interval, m_d->rowIncrement, pixelPolicy);
         }
         m_d->swapDirection();
 
         if (firstPass) {
             startInterval.row--;
             m_d->forwardStack.push(startInterval);
             firstPass = false;
         }
     }
 }
 
 void KisScanlineFill::fillColor(const KoColor &fillColor)
 {
     KisRandomConstAccessorSP it = m_d->device->createRandomConstAccessorNG(m_d->startPoint.x(), m_d->startPoint.y());
     KoColor srcColor(it->rawDataConst(), m_d->device->colorSpace());
 
     const int pixelSize = m_d->device->pixelSize();
 
     if (pixelSize == 1) {
         SelectionPolicy<false, DifferencePolicyOptimized<quint8>, FillWithColor>
             policy(m_d->device, srcColor, m_d->threshold);
         policy.setFillColor(fillColor);
         runImpl(policy);
     } else if (pixelSize == 2) {
         SelectionPolicy<false, DifferencePolicyOptimized<quint16>, FillWithColor>
             policy(m_d->device, srcColor, m_d->threshold);
         policy.setFillColor(fillColor);
         runImpl(policy);
     } else if (pixelSize == 4) {
         SelectionPolicy<false, DifferencePolicyOptimized<quint32>, FillWithColor>
             policy(m_d->device, srcColor, m_d->threshold);
         policy.setFillColor(fillColor);
         runImpl(policy);
     } else if (pixelSize == 8) {
         SelectionPolicy<false, DifferencePolicyOptimized<quint64>, FillWithColor>
               policy(m_d->device, srcColor, m_d->threshold);
         policy.setFillColor(fillColor);
         runImpl(policy);
     } else {
         SelectionPolicy<false, DifferencePolicySlow, FillWithColor>
               policy(m_d->device, srcColor, m_d->threshold);
         policy.setFillColor(fillColor);
         runImpl(policy);
     }
 }
 
 void KisScanlineFill::fillColor(const KoColor &fillColor, KisPaintDeviceSP externalDevice)
 {
     KisRandomConstAccessorSP it = m_d->device->createRandomConstAccessorNG(m_d->startPoint.x(), m_d->startPoint.y());
     KoColor srcColor(it->rawDataConst(), m_d->device->colorSpace());
 
     const int pixelSize = m_d->device->pixelSize();
 
     if (pixelSize == 1) {
         SelectionPolicy<false, DifferencePolicyOptimized<quint8>, FillWithColorExternal>
             policy(m_d->device, srcColor, m_d->threshold);
         policy.setDestinationDevice(externalDevice);
         policy.setFillColor(fillColor);
         runImpl(policy);
     } else if (pixelSize == 2) {
         SelectionPolicy<false, DifferencePolicyOptimized<quint16>, FillWithColorExternal>
             policy(m_d->device, srcColor, m_d->threshold);
         policy.setDestinationDevice(externalDevice);
         policy.setFillColor(fillColor);
         runImpl(policy);
     } else if (pixelSize == 4) {
         SelectionPolicy<false, DifferencePolicyOptimized<quint32>, FillWithColorExternal>
             policy(m_d->device, srcColor, m_d->threshold);
         policy.setDestinationDevice(externalDevice);
         policy.setFillColor(fillColor);
         runImpl(policy);
     } else if (pixelSize == 8) {
         SelectionPolicy<false, DifferencePolicyOptimized<quint64>, FillWithColorExternal>
             policy(m_d->device, srcColor, m_d->threshold);
         policy.setDestinationDevice(externalDevice);
         policy.setFillColor(fillColor);
         runImpl(policy);
     } else {
         SelectionPolicy<false, DifferencePolicySlow, FillWithColorExternal>
             policy(m_d->device, srcColor, m_d->threshold);
         policy.setDestinationDevice(externalDevice);
         policy.setFillColor(fillColor);
         runImpl(policy);
     }
 }
 
 void KisScanlineFill::fillSelection(KisPixelSelectionSP pixelSelection)
 {
     KisRandomConstAccessorSP it = m_d->device->createRandomConstAccessorNG(m_d->startPoint.x(), m_d->startPoint.y());
     KoColor srcColor(it->rawDataConst(), m_d->device->colorSpace());
 
     const int pixelSize = m_d->device->pixelSize();
 
     if (pixelSize == 1) {
         SelectionPolicy<true, DifferencePolicyOptimized<quint8>, CopyToSelection>
             policy(m_d->device, srcColor, m_d->threshold);
         policy.setDestinationSelection(pixelSelection);
         runImpl(policy);
     } else if (pixelSize == 2) {
         SelectionPolicy<true, DifferencePolicyOptimized<quint16>, CopyToSelection>
             policy(m_d->device, srcColor, m_d->threshold);
         policy.setDestinationSelection(pixelSelection);
         runImpl(policy);
     } else if (pixelSize == 4) {
         SelectionPolicy<true, DifferencePolicyOptimized<quint32>, CopyToSelection>
             policy(m_d->device, srcColor, m_d->threshold);
         policy.setDestinationSelection(pixelSelection);
         runImpl(policy);
     } else if (pixelSize == 8) {
         SelectionPolicy<true, DifferencePolicyOptimized<quint64>, CopyToSelection>
               policy(m_d->device, srcColor, m_d->threshold);
         policy.setDestinationSelection(pixelSelection);
         runImpl(policy);
     } else {
         SelectionPolicy<true, DifferencePolicySlow, CopyToSelection>
               policy(m_d->device, srcColor, m_d->threshold);
         policy.setDestinationSelection(pixelSelection);
         runImpl(policy);
     }
 }
 
 void KisScanlineFill::clearNonZeroComponent()
 {
     const int pixelSize = m_d->device->pixelSize();
     KoColor srcColor(Qt::transparent, m_d->device->colorSpace());
 
     if (pixelSize == 1) {
         SelectionPolicy<false, IsNonNullPolicyOptimized<quint8>, FillWithColor>
             policy(m_d->device, srcColor, m_d->threshold);
         policy.setFillColor(srcColor);
         runImpl(policy);
     } else if (pixelSize == 2) {
         SelectionPolicy<false, IsNonNullPolicyOptimized<quint16>, FillWithColor>
             policy(m_d->device, srcColor, m_d->threshold);
         policy.setFillColor(srcColor);
         runImpl(policy);
     } else if (pixelSize == 4) {
         SelectionPolicy<false, IsNonNullPolicyOptimized<quint32>, FillWithColor>
             policy(m_d->device, srcColor, m_d->threshold);
         policy.setFillColor(srcColor);
         runImpl(policy);
     } else if (pixelSize == 8) {
         SelectionPolicy<false, IsNonNullPolicyOptimized<quint64>, FillWithColor>
               policy(m_d->device, srcColor, m_d->threshold);
         policy.setFillColor(srcColor);
         runImpl(policy);
     } else {
         SelectionPolicy<false, IsNonNullPolicySlow, FillWithColor>
               policy(m_d->device, srcColor, m_d->threshold);
         policy.setFillColor(srcColor);
         runImpl(policy);
     }
 }
 
 void KisScanlineFill::fillContiguousGroup(KisPaintDeviceSP groupMapDevice, qint32 groupIndex)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->device->pixelSize() == 1);
     KIS_SAFE_ASSERT_RECOVER_RETURN(groupMapDevice->pixelSize() == 4);
 
     KisRandomConstAccessorSP it = m_d->device->createRandomConstAccessorNG(m_d->startPoint.x(), m_d->startPoint.y());
     const quint8 referenceValue = *it->rawDataConst();
 
     GroupSplitPolicy policy(m_d->device, groupMapDevice, groupIndex, referenceValue, m_d->threshold);
     runImpl(policy);
 }
 
 void KisScanlineFill::testingProcessLine(const KisFillInterval &processInterval)
 {
     KoColor srcColor(QColor(0,0,0,0), m_d->device->colorSpace());
     KoColor fillColor(QColor(200,200,200,200), m_d->device->colorSpace());
 
     SelectionPolicy<false, DifferencePolicyOptimized<quint32>, FillWithColor>
         policy(m_d->device, srcColor, m_d->threshold);
 
     policy.setFillColor(fillColor);
 
     processLine(processInterval, 1, policy);
 }
 
 QVector<KisFillInterval> KisScanlineFill::testingGetForwardIntervals() const
 {
     return QVector<KisFillInterval>(m_d->forwardStack);
 }
 
 KisFillIntervalMap* KisScanlineFill::testingGetBackwardIntervals() const
 {
     return &m_d->backwardMap;
 }
diff --git a/libs/image/kis_merge_walker.cc b/libs/image/kis_merge_walker.cc
index c0cff455d8..84df00b1c2 100644
--- a/libs/image/kis_merge_walker.cc
+++ b/libs/image/kis_merge_walker.cc
@@ -1,115 +1,121 @@
 /*
  *  Copyright (c) 2009 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_merge_walker.h"
 #include "kis_projection_leaf.h"
 
 
 
 KisMergeWalker::KisMergeWalker(QRect cropRect,  Flags flags)
     : m_flags(flags)
 {
     setCropRect(cropRect);
 }
 
 KisMergeWalker::~KisMergeWalker()
 {
 }
 
 KisBaseRectsWalker::UpdateType KisMergeWalker::type() const
 {
     return m_flags == DEFAULT ? KisBaseRectsWalker::UPDATE : KisBaseRectsWalker::UPDATE_NO_FILTHY;
 }
 
-void KisMergeWalker::startTrip(KisProjectionLeafSP startLeaf)
+void KisMergeWalker::startTripImpl(KisProjectionLeafSP startLeaf, KisMergeWalker::Flags flags)
 {
     if(startLeaf->isMask()) {
-        startTripWithMask(startLeaf);
+        startTripWithMask(startLeaf, flags);
         return;
     }
 
     visitHigherNode(startLeaf,
-                    m_flags == DEFAULT ? N_FILTHY : N_ABOVE_FILTHY);
+                    flags == DEFAULT ? N_FILTHY : N_ABOVE_FILTHY);
 
     KisProjectionLeafSP prevLeaf = startLeaf->prevSibling();
     if(prevLeaf)
         visitLowerNode(prevLeaf);
 }
 
-void KisMergeWalker::startTripWithMask(KisProjectionLeafSP filthyMask)
+
+void KisMergeWalker::startTrip(KisProjectionLeafSP startLeaf)
+{
+    startTripImpl(startLeaf, m_flags);
+}
+
+void KisMergeWalker::startTripWithMask(KisProjectionLeafSP filthyMask, KisMergeWalker::Flags flags)
 {
     /**
      * Under very rare circumstances it may happen that the update
      * queue will contain a job pointing to a node that has
      * already been deleted from the image (direclty or by undo
      * command). If it happens to a layer then the walker will
      * handle it as usual by building a trivial graph pointing to
      * nowhere, but when it happens to a mask... not. Because the
      * mask is always expected to have a parent layer to process.
      *
      * So just handle it here separately.
      */
     KisProjectionLeafSP parentLayer = filthyMask->parent();
     if (!parentLayer) {
         return;
     }
 
     adjustMasksChangeRect(filthyMask);
 
     KisProjectionLeafSP nextLeaf = parentLayer->nextSibling();
     KisProjectionLeafSP prevLeaf = parentLayer->prevSibling();
 
     if (nextLeaf)
         visitHigherNode(nextLeaf, N_ABOVE_FILTHY);
     else if (parentLayer->parent())
-        startTrip(parentLayer->parent());
+        startTripImpl(parentLayer->parent(), DEFAULT);
 
     NodePosition positionToFilthy =
-        (m_flags == DEFAULT ? N_FILTHY_PROJECTION : N_ABOVE_FILTHY) |
+        (flags == DEFAULT ? N_FILTHY_PROJECTION : N_ABOVE_FILTHY) |
         calculateNodePosition(parentLayer);
     registerNeedRect(parentLayer, positionToFilthy);
 
     if(prevLeaf)
         visitLowerNode(prevLeaf);
 }
 
 void KisMergeWalker::visitHigherNode(KisProjectionLeafSP leaf, NodePosition positionToFilthy)
 {
     positionToFilthy |= calculateNodePosition(leaf);
 
     registerChangeRect(leaf, positionToFilthy);
 
     KisProjectionLeafSP nextLeaf = leaf->nextSibling();
     if (nextLeaf)
         visitHigherNode(nextLeaf, N_ABOVE_FILTHY);
     else if (leaf->parent())
-        startTrip(leaf->parent());
+        startTripImpl(leaf->parent(), DEFAULT);
 
     registerNeedRect(leaf, positionToFilthy);
 }
 
 void KisMergeWalker::visitLowerNode(KisProjectionLeafSP leaf)
 {
     NodePosition position =
         N_BELOW_FILTHY | calculateNodePosition(leaf);
     registerNeedRect(leaf, position);
 
     KisProjectionLeafSP prevLeaf = leaf->prevSibling();
     if (prevLeaf)
         visitLowerNode(prevLeaf);
 }
diff --git a/libs/image/kis_merge_walker.h b/libs/image/kis_merge_walker.h
index b582ca66a3..7a6cb842fc 100644
--- a/libs/image/kis_merge_walker.h
+++ b/libs/image/kis_merge_walker.h
@@ -1,89 +1,92 @@
 /*
  *  Copyright (c) 2009 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KIS_MERGE_WALKER_H
 #define __KIS_MERGE_WALKER_H
 
 #include "kis_types.h"
 #include "kis_base_rects_walker.h"
 
 class KisMergeWalker;
 typedef KisSharedPtr<KisMergeWalker> KisMergeWalkerSP;
 
 class KRITAIMAGE_EXPORT KisMergeWalker : public virtual KisBaseRectsWalker
 {
 
 public:
     /**
      * NO_FILTHY flag notifies the walker that there should be no (!)
      * filthy node in the update. It means that the projection() of
      * the node is already guaranteed to be ready, we just need to
      * update all the higher-level nodes. Used by KisTransformMask
      * regeneration code.
      */
     enum Flags {
         DEFAULT = 0,
         NO_FILTHY
     };
 
     KisMergeWalker(QRect cropRect, Flags flags = DEFAULT);
 
     ~KisMergeWalker() override;
 
     UpdateType type() const override;
 
 protected:
     KisMergeWalker() : m_flags(DEFAULT) {}
     KisMergeWalker(Flags flags) : m_flags(flags) {}
 
     /**
      * Begins visiting nodes starting with @startWith.
      * First it climbs to the top of the graph, collecting
      * changeRects (it calls @registerChangeRect for every node).
      * Then it goes down to the bottom collecting needRects
      * for every branch.
      */
     void startTrip(KisProjectionLeafSP startWith) override;
 
     using KisBaseRectsWalker::startTrip;
 
-    void startTripWithMask(KisProjectionLeafSP filthyMask);
+    void startTripWithMask(KisProjectionLeafSP filthyMask, KisMergeWalker::Flags flags);
+
+private:
+    void startTripImpl(KisProjectionLeafSP startLeaf, Flags flags);
 
 private:
     /**
      * Visits a node @leaf and goes on crowling
      * towards the top of the graph, caling visitHigherNode() or
      * startTrip() one more time. After the top is reached
      * returns back to the @leaf.
      */
     void visitHigherNode(KisProjectionLeafSP leaf, NodePosition positionToFilthy);
 
     /**
      * Visits a node @leaf and goes on crowling
      * towards the bottom of the graph, caling visitLowerNode() or
      * startTrip() one more time.
      */
     void visitLowerNode(KisProjectionLeafSP leaf);
 
 private:
     const Flags m_flags;
 };
 
 
 #endif /* __KIS_MERGE_WALKER_H */
 
diff --git a/libs/image/kis_paint_device.cc b/libs/image/kis_paint_device.cc
index ae852177b9..d8b1684e4e 100644
--- a/libs/image/kis_paint_device.cc
+++ b/libs/image/kis_paint_device.cc
@@ -1,2170 +1,2166 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2004 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_paint_device.h"
 
 #include <QRect>
 #include <QTransform>
 #include <QImage>
 #include <QList>
 #include <QHash>
 #include <QIODevice>
 #include <qmath.h>
 
 #include <klocalizedstring.h>
 
 #include <KoChannelInfo.h>
 #include <KoColorProfile.h>
 #include <KoColor.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorModelStandardIds.h>
 #include <KoIntegerMaths.h>
 #include <KoMixColorsOp.h>
 #include <KoUpdater.h>
 
 #include "kis_image.h"
 #include "kis_random_sub_accessor.h"
 #include "kis_selection.h"
 #include "kis_node.h"
 #include "kis_datamanager.h"
 #include "kis_paint_device_writer.h"
 #include "kis_selection_component.h"
 #include "kis_pixel_selection.h"
 #include "kis_repeat_iterators_pixel.h"
 #include "kis_fixed_paint_device.h"
 
 #include "tiles3/kis_hline_iterator.h"
 #include "tiles3/kis_vline_iterator.h"
 #include "tiles3/kis_random_accessor.h"
 
 #include "kis_default_bounds.h"
 
 #include "kis_lod_transform.h"
 
 #include "kis_raster_keyframe_channel.h"
 
 #include "kis_paint_device_cache.h"
 #include "kis_paint_device_data.h"
 #include "kis_paint_device_frames_interface.h"
 
 #include "kis_transform_worker.h"
 #include "kis_filter_strategy.h"
 #include "krita_utils.h"
 
 
 struct KisPaintDeviceSPStaticRegistrar {
     KisPaintDeviceSPStaticRegistrar() {
         qRegisterMetaType<KisPaintDeviceSP>("KisPaintDeviceSP");
     }
 };
 static KisPaintDeviceSPStaticRegistrar __registrar;
 
 
 
 struct KisPaintDevice::Private
 {
     /**
      * Used when the paint device is loading to ensure no lod/animation
      * interferes the process.
      */
     static const KisDefaultBoundsSP transitionalDefaultBounds;
 
 public:
 
     class KisPaintDeviceStrategy;
     class KisPaintDeviceWrappedStrategy;
 
     Private(KisPaintDevice *paintDevice);
     ~Private();
 
     KisPaintDevice *q;
     KisNodeWSP parent;
     QScopedPointer<KisRasterKeyframeChannel> contentChannel;
     KisDefaultBoundsBaseSP defaultBounds;
     QScopedPointer<KisPaintDeviceStrategy> basicStrategy;
     QScopedPointer<KisPaintDeviceWrappedStrategy> wrappedStrategy;
     QMutex m_wrappedStrategyMutex;
 
     QScopedPointer<KisPaintDeviceFramesInterface> framesInterface;
     bool isProjectionDevice;
 
     KisPaintDeviceStrategy* currentStrategy();
 
     void init(const KoColorSpace *cs, const quint8 *defaultPixel);
     KUndo2Command* convertColorSpace(const KoColorSpace * dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags);
     bool assignProfile(const KoColorProfile * profile);
 
     inline const KoColorSpace* colorSpace() const
     {
         return currentData()->colorSpace();
     }
     inline KisDataManagerSP dataManager() const
     {
         return currentData()->dataManager();
     }
 
     inline qint32 x() const
     {
         return currentData()->x();
     }
     inline qint32 y() const
     {
         return currentData()->y();
     }
     inline void setX(qint32 x)
     {
         currentData()->setX(x);
     }
     inline void setY(qint32 y)
     {
         currentData()->setY(y);
     }
 
     inline KisPaintDeviceCache* cache()
     {
         return currentData()->cache();
     }
 
     inline KisIteratorCompleteListener* cacheInvalidator() {
         return currentData()->cacheInvalidator();
     }
 
 
     void cloneAllDataObjects(Private *rhs, bool copyFrames)
     {
 
         m_lodData.reset();
         m_externalFrameData.reset();
 
         if (!m_frames.isEmpty()) {
             m_frames.clear();
         }
 
         if (!copyFrames) {
             if (m_data) {
                 m_data->prepareClone(rhs->currentNonLodData(), true);
             } else {
                 m_data = toQShared(new KisPaintDeviceData(rhs->currentNonLodData(), true));
             }
         } else {
             if (m_data && !rhs->m_data) {
                 m_data.clear();
             } else if (!m_data && rhs->m_data) {
                 m_data = toQShared(new KisPaintDeviceData(rhs->m_data.data(), true));
             } else if (m_data && rhs->m_data) {
                 m_data->prepareClone(rhs->m_data.data(), true);
             }
 
             if (!rhs->m_frames.isEmpty()) {
                 FramesHash::const_iterator it = rhs->m_frames.constBegin();
                 FramesHash::const_iterator end = rhs->m_frames.constEnd();
 
                 for (; it != end; ++it) {
                     DataSP data = toQShared(new KisPaintDeviceData(it.value().data(), true));
                     m_frames.insert(it.key(), data);
                 }
             }
             m_nextFreeFrameId = rhs->m_nextFreeFrameId;
         }
 
         if (rhs->m_lodData) {
             m_lodData.reset(new KisPaintDeviceData(rhs->m_lodData.data(), true));
         }
     }
 
     void prepareClone(KisPaintDeviceSP src)
     {
         prepareCloneImpl(src, src->m_d->currentData());
         Q_ASSERT(fastBitBltPossible(src));
     }
 
     bool fastBitBltPossible(KisPaintDeviceSP src)
     {
         return fastBitBltPossibleImpl(src->m_d->currentData());
     }
 
     int currentFrameId() const
     {
         KIS_ASSERT_RECOVER(contentChannel) {
             return -1;
         }
         return !defaultBounds->currentLevelOfDetail() ?
                contentChannel->frameIdAt(defaultBounds->currentTime()) :
                -1;
     }
 
     KisDataManagerSP frameDataManager(int frameId) const
     {
         DataSP data = m_frames[frameId];
         return data->dataManager();
     }
 
     void invalidateFrameCache(int frameId)
     {
         DataSP data = m_frames[frameId];
         return data->cache()->invalidate();
     }
 
 private:
     typedef KisPaintDeviceData Data;
     typedef QSharedPointer<Data> DataSP;
     typedef QHash<int, DataSP> FramesHash;
 
     class FrameInsertionCommand : public KUndo2Command
     {
     public:
 
         FrameInsertionCommand(FramesHash *hash, DataSP data, int frameId, bool insert, KUndo2Command *parentCommand)
             : KUndo2Command(parentCommand),
               m_hash(hash),
               m_data(data),
               m_frameId(frameId),
               m_insert(insert)
         {
         }
 
         void redo() override
         {
             doSwap(m_insert);
         }
 
         void undo() override
         {
             doSwap(!m_insert);
         }
 
     private:
         void doSwap(bool insert)
         {
             if (insert) {
                 m_hash->insert(m_frameId, m_data);
             } else {
                 DataSP deletedData = m_hash->take(m_frameId);
             }
         }
 
     private:
         FramesHash *m_hash;
         DataSP m_data;
         int m_frameId;
         bool m_insert;
     };
 
 public:
 
     int getNextFrameId() {
         int frameId = 0;
         while (m_frames.contains(frameId = m_nextFreeFrameId++));
         KIS_SAFE_ASSERT_RECOVER_NOOP(!m_frames.contains(frameId));
 
         return frameId;
     }
 
     int createFrame(bool copy, int copySrc, const QPoint &offset, KUndo2Command *parentCommand)
     {
         KIS_ASSERT_RECOVER(parentCommand) {
             return -1;
         }
 
         DataSP data;
         bool initialFrame = false;
 
         if (m_frames.isEmpty()) {
             /**
              * Here we move the contents of the paint device to the
              * new frame and clear m_data to make the "background" for
              * the areas where there is no frame at all.
              */
             data = toQShared(new Data(m_data.data(), true));
             m_data->dataManager()->clear();
             m_data->cache()->invalidate();
             initialFrame = true;
 
         } else if (copy) {
             DataSP srcData = m_frames[copySrc];
             data = toQShared(new Data(srcData.data(), true));
         } else {
             DataSP srcData = m_frames.begin().value();
             data = toQShared(new Data(srcData.data(), false));
         }
 
         if (!initialFrame && !copy) {
             data->setX(offset.x());
             data->setY(offset.y());
         }
 
         int frameId = getNextFrameId();
 
         KUndo2Command *cmd =
             new FrameInsertionCommand(&m_frames,
                                       data,
                                       frameId, true,
                                       parentCommand);
 
         cmd->redo();
 
         return frameId;
     }
 
     void deleteFrame(int frame, KUndo2Command *parentCommand)
     {
         KIS_ASSERT_RECOVER_RETURN(m_frames.contains(frame));
         KIS_ASSERT_RECOVER_RETURN(parentCommand);
 
         DataSP deletedData = m_frames[frame];
 
         KUndo2Command *cmd =
             new FrameInsertionCommand(&m_frames,
                                       deletedData,
                                       frame, false,
                                       parentCommand);
         cmd->redo();
     }
 
     QRect frameBounds(int frameId)
     {
         DataSP data = m_frames[frameId];
 
         QRect extent = data->dataManager()->extent();
         extent.translate(data->x(), data->y());
 
         return extent;
     }
 
     QPoint frameOffset(int frameId) const
     {
         DataSP data = m_frames[frameId];
         return QPoint(data->x(), data->y());
     }
 
     void setFrameOffset(int frameId, const QPoint &offset)
     {
         DataSP data = m_frames[frameId];
         data->setX(offset.x());
         data->setY(offset.y());
     }
 
     const QList<int> frameIds() const
     {
         return m_frames.keys();
     }
 
     bool readFrame(QIODevice *stream, int frameId)
     {
         bool retval = false;
         DataSP data = m_frames[frameId];
         retval = data->dataManager()->read(stream);
         data->cache()->invalidate();
         return retval;
     }
 
     bool writeFrame(KisPaintDeviceWriter &store, int frameId)
     {
         DataSP data = m_frames[frameId];
         return data->dataManager()->write(store);
     }
 
     void setFrameDefaultPixel(const KoColor &defPixel, int frameId)
     {
         DataSP data = m_frames[frameId];
         KoColor color(defPixel);
         color.convertTo(data->colorSpace());
         data->dataManager()->setDefaultPixel(color.data());
     }
 
     KoColor frameDefaultPixel(int frameId) const
     {
         DataSP data = m_frames[frameId];
         return KoColor(data->dataManager()->defaultPixel(),
                        data->colorSpace());
     }
 
     void fetchFrame(int frameId, KisPaintDeviceSP targetDevice);
     void uploadFrame(int srcFrameId, int dstFrameId, KisPaintDeviceSP srcDevice);
     void uploadFrame(int dstFrameId, KisPaintDeviceSP srcDevice);
     void uploadFrameData(DataSP srcData, DataSP dstData);
 
     struct LodDataStructImpl;
     LodDataStruct* createLodDataStruct(int lod);
     void updateLodDataStruct(LodDataStruct *dst, const QRect &srcRect);
     void uploadLodDataStruct(LodDataStruct *dst);
     QRegion regionForLodSyncing() const;
 
     void tesingFetchLodDevice(KisPaintDeviceSP targetDevice);
 
 
 private:
     qint64 estimateDataSize(Data *data) const {
         const QRect &rc = data->dataManager()->extent();
         return rc.width() * rc.height() * data->colorSpace()->pixelSize();
     }
 
 public:
 
     void estimateMemoryStats(qint64 &imageData, qint64 &temporaryData, qint64 &lodData) const {
         imageData = 0;
         temporaryData = 0;
         lodData = 0;
 
         if (m_data) {
             imageData += estimateDataSize(m_data.data());
-
-            if (!m_frames.isEmpty()) {
-                qWarning() << "WARNING: Extra data object:" << estimateDataSize(m_data.data());
-            }
         }
 
         if (m_lodData) {
             lodData += estimateDataSize(m_lodData.data());
         }
 
         if (m_externalFrameData) {
             temporaryData += estimateDataSize(m_externalFrameData.data());
         }
 
         Q_FOREACH (DataSP value, m_frames.values()) {
             imageData += estimateDataSize(value.data());
         }
     }
 
 
 private:
 
     QRegion syncWholeDevice(Data *srcData);
 
     inline DataSP currentFrameData() const
     {
         DataSP data;
 
         const int numberOfFrames = contentChannel->keyframeCount();
 
         if (numberOfFrames > 1) {
             int frameId = contentChannel->frameIdAt(defaultBounds->currentTime());
 
             if (frameId == -1) {
                 data = m_data;
             } else {
                 KIS_ASSERT_RECOVER(m_frames.contains(frameId)) {
                     return m_frames.begin().value();
                 }
                 data = m_frames[frameId];
             }
         } else if (numberOfFrames == 1) {
             data = m_frames.begin().value();
         } else {
             data = m_data;
         }
 
         return data;
     }
 
     inline Data* currentNonLodData() const
     {
         Data *data = m_data.data();
 
         if (contentChannel) {
             data = currentFrameData().data();
         } else if (isProjectionDevice && defaultBounds->externalFrameActive()) {
             if (!m_externalFrameData) {
                 QMutexLocker l(&m_dataSwitchLock);
                 if (!m_externalFrameData) {
                     m_externalFrameData.reset(new Data(m_data.data(), false));
                 }
             }
             data = m_externalFrameData.data();
         }
 
         return data;
     }
 
     inline void ensureLodDataPresent() const
     {
         if (!m_lodData) {
             Data *srcData = currentNonLodData();
 
             QMutexLocker l(&m_dataSwitchLock);
             if (!m_lodData) {
                 m_lodData.reset(new Data(srcData, false));
             }
         }
     }
 
     inline Data* currentData() const
     {
         Data *data;
 
         if (defaultBounds->currentLevelOfDetail()) {
             ensureLodDataPresent();
             data = m_lodData.data();
         } else {
             data = currentNonLodData();
         }
 
         return data;
     }
 
     void prepareCloneImpl(KisPaintDeviceSP src, Data *srcData)
     {
         currentData()->prepareClone(srcData);
 
         q->setDefaultPixel(KoColor(srcData->dataManager()->defaultPixel(), colorSpace()));
         q->setDefaultBounds(src->defaultBounds());
     }
 
     bool fastBitBltPossibleImpl(Data *srcData)
     {
         return x() == srcData->x() && y() == srcData->y() &&
                *colorSpace() == *srcData->colorSpace();
     }
 
     QList<Data*> allDataObjects() const
     {
         QList<Data*> dataObjects;
 
         if (m_frames.isEmpty()) {
             dataObjects << m_data.data();
         }
         dataObjects << m_lodData.data();
         dataObjects << m_externalFrameData.data();
 
         Q_FOREACH (DataSP value, m_frames.values()) {
             dataObjects << value.data();
         }
 
         return dataObjects;
     }
 
     void transferFromData(Data *data, KisPaintDeviceSP targetDevice);
 
     struct Q_DECL_HIDDEN StrategyPolicy;
     typedef KisSequentialIteratorBase<ReadOnlyIteratorPolicy<StrategyPolicy>, StrategyPolicy> InternalSequentialConstIterator;
     typedef KisSequentialIteratorBase<WritableIteratorPolicy<StrategyPolicy>, StrategyPolicy> InternalSequentialIterator;
 
 private:
     friend class KisPaintDeviceFramesInterface;
 
 private:
     DataSP m_data;
     mutable QScopedPointer<Data> m_lodData;
     mutable QScopedPointer<Data> m_externalFrameData;
     mutable QMutex m_dataSwitchLock;
 
     FramesHash m_frames;
     int m_nextFreeFrameId;
 };
 
 const KisDefaultBoundsSP KisPaintDevice::Private::transitionalDefaultBounds = new KisDefaultBounds();
 
 #include "kis_paint_device_strategies.h"
 
 KisPaintDevice::Private::Private(KisPaintDevice *paintDevice)
     : q(paintDevice),
       basicStrategy(new KisPaintDeviceStrategy(paintDevice, this)),
       isProjectionDevice(false),
       m_data(new Data(paintDevice)),
       m_nextFreeFrameId(0)
 {
 }
 
 KisPaintDevice::Private::~Private()
 {
     m_frames.clear();
 }
 
 KisPaintDevice::Private::KisPaintDeviceStrategy* KisPaintDevice::Private::currentStrategy()
 {
     if (!defaultBounds->wrapAroundMode()) {
         return basicStrategy.data();
     }
 
     const QRect wrapRect = defaultBounds->bounds();
 
     if (!wrappedStrategy || wrappedStrategy->wrapRect() != wrapRect) {
         QMutexLocker locker(&m_wrappedStrategyMutex);
 
         if (!wrappedStrategy) {
             wrappedStrategy.reset(new KisPaintDeviceWrappedStrategy(wrapRect, q, this));
         }  else if (wrappedStrategy->wrapRect() != wrapRect) {
             wrappedStrategy->setWrapRect(wrapRect);
         }
     }
 
     return wrappedStrategy.data();
 }
 
 struct KisPaintDevice::Private::StrategyPolicy {
     StrategyPolicy(KisPaintDevice::Private::KisPaintDeviceStrategy *strategy,
                    KisDataManager *dataManager, qint32 offsetX, qint32 offsetY)
         : m_strategy(strategy),
           m_dataManager(dataManager),
           m_offsetX(offsetX),
           m_offsetY(offsetY)
     {
     }
 
     KisHLineConstIteratorSP createConstIterator(const QRect &rect)
     {
         return m_strategy->createHLineConstIteratorNG(m_dataManager, rect.x(), rect.y(), rect.width(), m_offsetX, m_offsetY);
     }
 
     KisHLineIteratorSP createIterator(const QRect &rect)
     {
         return m_strategy->createHLineIteratorNG(m_dataManager, rect.x(), rect.y(), rect.width(), m_offsetX, m_offsetY);
     }
 
     int pixelSize() const
     {
         return m_dataManager->pixelSize();
     }
 
 
     KisPaintDeviceStrategy *m_strategy;
     KisDataManager *m_dataManager;
     int m_offsetX;
     int m_offsetY;
 };
 
 struct KisPaintDevice::Private::LodDataStructImpl : public KisPaintDevice::LodDataStruct {
     LodDataStructImpl(Data *_lodData) : lodData(_lodData) {}
     QScopedPointer<Data> lodData;
 };
 
 QRegion KisPaintDevice::Private::regionForLodSyncing() const
 {
     Data *srcData = currentNonLodData();
     return srcData->dataManager()->region().translated(srcData->x(), srcData->y());
 }
 
 KisPaintDevice::LodDataStruct* KisPaintDevice::Private::createLodDataStruct(int newLod)
 {
     Data *srcData = currentNonLodData();
 
     Data *lodData = new Data(srcData, false);
     LodDataStruct *lodStruct = new LodDataStructImpl(lodData);
 
     int expectedX = KisLodTransform::coordToLodCoord(srcData->x(), newLod);
     int expectedY = KisLodTransform::coordToLodCoord(srcData->y(), newLod);
 
     /**
      * We compare color spaces as pure pointers, because they must be
      * exactly the same, since they come from the common source.
      */
     if (lodData->levelOfDetail() != newLod ||
         lodData->colorSpace() != srcData->colorSpace() ||
         lodData->x() != expectedX ||
         lodData->y() != expectedY) {
 
 
         lodData->prepareClone(srcData);
 
         lodData->setLevelOfDetail(newLod);
         lodData->setX(expectedX);
         lodData->setY(expectedY);
 
         // FIXME: different kind of synchronization
     }
 
     //QRegion dirtyRegion = syncWholeDevice(srcData);
     lodData->cache()->invalidate();
 
     return lodStruct;
 }
 
 void KisPaintDevice::Private::updateLodDataStruct(LodDataStruct *_dst, const QRect &originalRect)
 {
     LodDataStructImpl *dst = dynamic_cast<LodDataStructImpl*>(_dst);
     KIS_SAFE_ASSERT_RECOVER_RETURN(dst);
 
     Data *lodData = dst->lodData.data();
     Data *srcData = currentNonLodData();
 
     const int lod = lodData->levelOfDetail();
     const int srcStepSize = 1 << lod;
 
     KIS_ASSERT_RECOVER_RETURN(lod > 0);
 
     const QRect srcRect = KisLodTransform::alignedRect(originalRect, lod);
     const QRect dstRect = KisLodTransform::scaledRect(srcRect, lod);
     if (!srcRect.isValid() || !dstRect.isValid()) return;
 
     KIS_ASSERT_RECOVER_NOOP(srcRect.width() / srcStepSize == dstRect.width());
 
     const int pixelSize = srcData->dataManager()->pixelSize();
 
     int rowsAccumulated = 0;
     int columnsAccumulated = 0;
 
     KoMixColorsOp *mixOp = colorSpace()->mixColorsOp();
 
     QScopedArrayPointer<quint8> blendData(new quint8[srcStepSize * srcRect.width() * pixelSize]);
     quint8 *blendDataPtr = blendData.data();
     int blendDataOffset = 0;
 
     const int srcCellSize = srcStepSize * srcStepSize;
     const int srcCellStride = srcCellSize * pixelSize;
     const int srcStepStride = srcStepSize * pixelSize;
     const int srcColumnStride = (srcStepSize - 1) * srcStepStride;
 
     QScopedArrayPointer<qint16> weights(new qint16[srcCellSize]);
 
     {
         const qint16 averageWeight = qCeil(255.0 / srcCellSize);
         const qint16 extraWeight = averageWeight * srcCellSize - 255;
         KIS_ASSERT_RECOVER_NOOP(extraWeight == 1);
 
         for (int i = 0; i < srcCellSize - 1; i++) {
             weights[i] = averageWeight;
         }
         weights[srcCellSize - 1] = averageWeight - extraWeight;
     }
 
     InternalSequentialConstIterator srcIntIt(StrategyPolicy(currentStrategy(), srcData->dataManager().data(), srcData->x(), srcData->y()), srcRect);
     InternalSequentialIterator dstIntIt(StrategyPolicy(currentStrategy(), lodData->dataManager().data(), lodData->x(), lodData->y()), dstRect);
 
     int rowsRemaining = srcRect.height();
     while (rowsRemaining > 0) {
 
         int colsRemaining = srcRect.width();
         while (colsRemaining > 0 && srcIntIt.nextPixel()) {
 
             memcpy(blendDataPtr, srcIntIt.rawDataConst(), pixelSize);
             blendDataPtr += pixelSize;
             columnsAccumulated++;
 
             if (columnsAccumulated >= srcStepSize) {
                 blendDataPtr += srcColumnStride;
                 columnsAccumulated = 0;
             }
 
             colsRemaining--;
         }
 
         rowsAccumulated++;
 
         if (rowsAccumulated >= srcStepSize) {
 
             // blend and write the final data
             blendDataPtr = blendData.data();
 
             int colsRemaining = dstRect.width();
             while (colsRemaining > 0 && dstIntIt.nextPixel()) {
                 mixOp->mixColors(blendDataPtr, weights.data(), srcCellSize, dstIntIt.rawData());
                 blendDataPtr += srcCellStride;
 
                 colsRemaining--;
             }
 
             // reset counters
             rowsAccumulated = 0;
             blendDataPtr = blendData.data();
             blendDataOffset = 0;
         } else {
             blendDataOffset += srcStepStride;
             blendDataPtr = blendData.data() + blendDataOffset;
         }
 
         rowsRemaining--;
     }
 }
 
 void KisPaintDevice::Private::uploadLodDataStruct(LodDataStruct *_dst)
 {
     LodDataStructImpl *dst = dynamic_cast<LodDataStructImpl*>(_dst);
     KIS_SAFE_ASSERT_RECOVER_RETURN(dst);
 
     KIS_SAFE_ASSERT_RECOVER_RETURN(
         dst->lodData->levelOfDetail() == defaultBounds->currentLevelOfDetail());
 
     ensureLodDataPresent();
 
     m_lodData->prepareClone(dst->lodData.data());
     m_lodData->dataManager()->bitBltRough(dst->lodData->dataManager(), dst->lodData->dataManager()->extent());
 }
 
 void KisPaintDevice::Private::transferFromData(Data *data, KisPaintDeviceSP targetDevice)
 {
     QRect extent = data->dataManager()->extent();
     extent.translate(data->x(), data->y());
 
     targetDevice->m_d->prepareCloneImpl(q, data);
     targetDevice->m_d->currentStrategy()->fastBitBltRough(data->dataManager(), extent);
 }
 
 void KisPaintDevice::Private::fetchFrame(int frameId, KisPaintDeviceSP targetDevice)
 {
     DataSP data = m_frames[frameId];
     transferFromData(data.data(), targetDevice);
 }
 
 void KisPaintDevice::Private::uploadFrame(int srcFrameId, int dstFrameId, KisPaintDeviceSP srcDevice)
 {
     DataSP dstData = m_frames[dstFrameId];
     KIS_ASSERT_RECOVER_RETURN(dstData);
 
     DataSP srcData = srcDevice->m_d->m_frames[srcFrameId];
     KIS_ASSERT_RECOVER_RETURN(srcData);
 
     uploadFrameData(srcData, dstData);
 }
 
 void KisPaintDevice::Private::uploadFrame(int dstFrameId, KisPaintDeviceSP srcDevice)
 {
     DataSP dstData = m_frames[dstFrameId];
     KIS_ASSERT_RECOVER_RETURN(dstData);
 
     DataSP srcData = srcDevice->m_d->m_data;
     KIS_ASSERT_RECOVER_RETURN(srcData);
 
     uploadFrameData(srcData, dstData);
 }
 
 void KisPaintDevice::Private::uploadFrameData(DataSP srcData, DataSP dstData)
 {
     if (srcData->colorSpace() != dstData->colorSpace() &&
         *srcData->colorSpace() != *dstData->colorSpace()) {
 
         KUndo2Command tempCommand;
 
         srcData = toQShared(new Data(srcData.data(), true));
         srcData->convertDataColorSpace(dstData->colorSpace(),
                                        KoColorConversionTransformation::internalRenderingIntent(),
                                        KoColorConversionTransformation::internalConversionFlags(),
                                        &tempCommand);
     }
 
     dstData->dataManager()->clear();
     dstData->cache()->invalidate();
 
     const QRect rect = srcData->dataManager()->extent();
     dstData->dataManager()->bitBltRough(srcData->dataManager(), rect);
     dstData->setX(srcData->x());
     dstData->setY(srcData->y());
 }
 
 void KisPaintDevice::Private::tesingFetchLodDevice(KisPaintDeviceSP targetDevice)
 {
     Data *data = m_lodData.data();
     Q_ASSERT(data);
 
     transferFromData(data, targetDevice);
 }
 
 KUndo2Command* KisPaintDevice::Private::convertColorSpace(const KoColorSpace * dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
 
     class DeviceChangeColorSpaceCommand : public KUndo2Command
     {
     public:
         DeviceChangeColorSpaceCommand(KisPaintDeviceSP device)
             : m_firstRun(true),
               m_device(device)
         {
         }
 
         void emitNotifications()
         {
             m_device->emitColorSpaceChanged();
             m_device->setDirty();
         }
 
         void redo() override
         {
             KUndo2Command::redo();
 
             if (!m_firstRun) {
                 m_firstRun = false;
                 return;
             }
 
             emitNotifications();
         }
 
         void undo() override
         {
             KUndo2Command::undo();
             emitNotifications();
         }
 
     private:
         bool m_firstRun;
         KisPaintDeviceSP m_device;
     };
 
 
     KUndo2Command *parentCommand = new DeviceChangeColorSpaceCommand(q);
 
     QList<Data*> dataObjects = allDataObjects();;
 
     Q_FOREACH (Data *data, dataObjects) {
         if (!data) continue;
 
         data->convertDataColorSpace(dstColorSpace, renderingIntent, conversionFlags, parentCommand);
     }
 
     if (!parentCommand->childCount()) {
         delete parentCommand;
         parentCommand = 0;
     } else {
         q->emitColorSpaceChanged();
     }
 
     return parentCommand;
 
 }
 
 bool KisPaintDevice::Private::assignProfile(const KoColorProfile * profile)
 {
     if (!profile) return false;
 
     const KoColorSpace *dstColorSpace =
         KoColorSpaceRegistry::instance()->colorSpace(colorSpace()->colorModelId().id(), colorSpace()->colorDepthId().id(), profile);
     if (!dstColorSpace) return false;
 
     QList<Data*> dataObjects = allDataObjects();;
     Q_FOREACH (Data *data, dataObjects) {
         if (!data) continue;
         data->assignColorSpace(dstColorSpace);
     }
     q->emitProfileChanged();
 
     // no undo information is provided here
     return true;
 }
 
 void KisPaintDevice::Private::init(const KoColorSpace *cs, const quint8 *defaultPixel)
 {
     QList<Data*> dataObjects = allDataObjects();;
     Q_FOREACH (Data *data, dataObjects) {
         if (!data) continue;
 
         KisDataManagerSP dataManager = new KisDataManager(cs->pixelSize(), defaultPixel);
         data->init(cs, dataManager);
     }
 }
 
 KisPaintDevice::KisPaintDevice(const KoColorSpace * colorSpace, const QString& name)
     : QObject(0)
     , m_d(new Private(this))
 {
     init(colorSpace, new KisDefaultBounds(), 0, name);
 }
 
 KisPaintDevice::KisPaintDevice(KisNodeWSP parent, const KoColorSpace * colorSpace, KisDefaultBoundsBaseSP defaultBounds, const QString& name)
     : QObject(0)
     , m_d(new Private(this))
 {
     init(colorSpace, defaultBounds, parent, name);
 }
 
 void KisPaintDevice::init(const KoColorSpace *colorSpace,
                           KisDefaultBoundsBaseSP defaultBounds,
                           KisNodeWSP parent, const QString& name)
 {
     Q_ASSERT(colorSpace);
     setObjectName(name);
 
     // temporary def. bounds object for the initialization phase only
     m_d->defaultBounds = m_d->transitionalDefaultBounds;
 
     if (!defaultBounds) {
         // Reuse transitionalDefaultBounds here. Change if you change
         // semantics of transitionalDefaultBounds
         defaultBounds = m_d->transitionalDefaultBounds;
     }
 
     QScopedArrayPointer<quint8> defaultPixel(new quint8[colorSpace->pixelSize()]);
     colorSpace->fromQColor(Qt::transparent, defaultPixel.data());
     m_d->init(colorSpace, defaultPixel.data());
 
     Q_ASSERT(m_d->colorSpace());
 
     setDefaultBounds(defaultBounds);
     setParentNode(parent);
 }
 
 KisPaintDevice::KisPaintDevice(const KisPaintDevice& rhs, bool copyFrames, KisNode *newParentNode)
     : QObject()
     , KisShared()
     , m_d(new Private(this))
 {
     if (this != &rhs) {
         // temporary def. bounds object for the initialization phase only
         m_d->defaultBounds = m_d->transitionalDefaultBounds;
 
         // copy data objects with or without frames
         m_d->cloneAllDataObjects(rhs.m_d, copyFrames);
 
         if (copyFrames) {
             KIS_ASSERT_RECOVER_RETURN(rhs.m_d->framesInterface);
             KIS_ASSERT_RECOVER_RETURN(rhs.m_d->contentChannel);
             m_d->framesInterface.reset(new KisPaintDeviceFramesInterface(this));
             m_d->contentChannel.reset(new KisRasterKeyframeChannel(*rhs.m_d->contentChannel.data(), newParentNode, this));
         }
 
         setDefaultBounds(rhs.m_d->defaultBounds);
         setParentNode(0);
     }
 }
 
 KisPaintDevice::~KisPaintDevice()
 {
     delete m_d;
 }
 
 void KisPaintDevice::setProjectionDevice(bool value)
 {
     m_d->isProjectionDevice = value;
 }
 
 void KisPaintDevice::prepareClone(KisPaintDeviceSP src)
 {
     m_d->prepareClone(src);
     Q_ASSERT(fastBitBltPossible(src));
 }
 
 void KisPaintDevice::makeCloneFrom(KisPaintDeviceSP src, const QRect &rect)
 {
     prepareClone(src);
 
     // we guarantee that *this is totally empty, so copy pixels that
     // are areally present on the source image only
     const QRect optimizedRect = rect & src->extent();
 
     fastBitBlt(src, optimizedRect);
 }
 
 void KisPaintDevice::makeCloneFromRough(KisPaintDeviceSP src, const QRect &minimalRect)
 {
     prepareClone(src);
 
     // we guarantee that *this is totally empty, so copy pixels that
     // are areally present on the source image only
     const QRect optimizedRect = minimalRect & src->extent();
 
     fastBitBltRough(src, optimizedRect);
 }
 
 void KisPaintDevice::setDirty()
 {
     m_d->cache()->invalidate();
     if (m_d->parent.isValid())
         m_d->parent->setDirty();
 }
 
 void KisPaintDevice::setDirty(const QRect & rc)
 {
     m_d->cache()->invalidate();
     if (m_d->parent.isValid())
         m_d->parent->setDirty(rc);
 }
 
 void KisPaintDevice::setDirty(const QRegion & region)
 {
     m_d->cache()->invalidate();
     if (m_d->parent.isValid())
         m_d->parent->setDirty(region);
 }
 
 void KisPaintDevice::setDirty(const QVector<QRect> rects)
 {
     m_d->cache()->invalidate();
     if (m_d->parent.isValid())
         m_d->parent->setDirty(rects);
 }
 
 void KisPaintDevice::requestTimeSwitch(int time)
 {
     if (m_d->parent.isValid()) {
         m_d->parent->requestTimeSwitch(time);
     }
 }
 
 int KisPaintDevice::sequenceNumber() const
 {
     return m_d->cache()->sequenceNumber();
 }
 
 void KisPaintDevice::estimateMemoryStats(qint64 &imageData, qint64 &temporaryData, qint64 &lodData) const
 {
     m_d->estimateMemoryStats(imageData, temporaryData, lodData);
 }
 
 void KisPaintDevice::setParentNode(KisNodeWSP parent)
 {
     m_d->parent = parent;
 }
 
 // for testing purposes only
 KisNodeWSP KisPaintDevice::parentNode() const
 {
     return m_d->parent;
 }
 
 void KisPaintDevice::setDefaultBounds(KisDefaultBoundsBaseSP defaultBounds)
 {
     m_d->defaultBounds = defaultBounds;
     m_d->cache()->invalidate();
 }
 
 KisDefaultBoundsBaseSP KisPaintDevice::defaultBounds() const
 {
     return m_d->defaultBounds;
 }
 
 void KisPaintDevice::moveTo(const QPoint &pt)
 {
     m_d->currentStrategy()->move(pt);
     m_d->cache()->invalidate();
 }
 
 QPoint KisPaintDevice::offset() const
 {
     return QPoint(x(), y());
 }
 
 void KisPaintDevice::moveTo(qint32 x, qint32 y)
 {
     moveTo(QPoint(x, y));
 }
 
 void KisPaintDevice::setX(qint32 x)
 {
     moveTo(QPoint(x, m_d->y()));
 }
 
 void KisPaintDevice::setY(qint32 y)
 {
     moveTo(QPoint(m_d->x(), y));
 }
 
 qint32 KisPaintDevice::x() const
 {
     return m_d->x();
 }
 
 qint32 KisPaintDevice::y() const
 {
     return m_d->y();
 }
 
 void KisPaintDevice::extent(qint32 &x, qint32 &y, qint32 &w, qint32 &h) const
 {
     QRect rc = extent();
     x = rc.x();
     y = rc.y();
     w = rc.width();
     h = rc.height();
 }
 
 QRect KisPaintDevice::extent() const
 {
     return m_d->currentStrategy()->extent();
 }
 
 QRegion KisPaintDevice::region() const
 {
     return m_d->currentStrategy()->region();
 }
 
 QRect KisPaintDevice::nonDefaultPixelArea() const
 {
     return m_d->cache()->nonDefaultPixelArea();
 }
 
 QRect KisPaintDevice::exactBounds() const
 {
     return m_d->cache()->exactBounds();
 }
 
 QRect KisPaintDevice::exactBoundsAmortized() const
 {
     return m_d->cache()->exactBoundsAmortized();
 }
 
 namespace Impl
 {
 
 struct CheckFullyTransparent {
     CheckFullyTransparent(const KoColorSpace *colorSpace)
         : m_colorSpace(colorSpace)
     {
     }
 
     bool isPixelEmpty(const quint8 *pixelData)
     {
         return m_colorSpace->opacityU8(pixelData) == OPACITY_TRANSPARENT_U8;
     }
 
 private:
     const KoColorSpace *m_colorSpace;
 };
 
 struct CheckNonDefault {
     CheckNonDefault(int pixelSize, const quint8 *defaultPixel)
         : m_pixelSize(pixelSize),
           m_defaultPixel(defaultPixel)
     {
     }
 
     bool isPixelEmpty(const quint8 *pixelData)
     {
         return memcmp(m_defaultPixel, pixelData, m_pixelSize) == 0;
     }
 
 private:
     int m_pixelSize;
     const quint8 *m_defaultPixel;
 };
 
 template <class ComparePixelOp>
 QRect calculateExactBoundsImpl(const KisPaintDevice *device, const QRect &startRect, const QRect &endRect, ComparePixelOp compareOp)
 {
     if (startRect == endRect) return startRect;
 
     // Solution n°2
     int  x, y, w, h;
     int boundLeft, boundTop, boundRight, boundBottom;
     int endDirN, endDirE, endDirS, endDirW;
 
     startRect.getRect(&x, &y, &w, &h);
 
     if (endRect.isEmpty()) {
         endDirS = startRect.bottom();
         endDirN = startRect.top();
         endDirE = startRect.right();
         endDirW = startRect.left();
         startRect.getCoords(&boundLeft, &boundTop, &boundRight, &boundBottom);
     } else {
         endDirS = endRect.top() - 1;
         endDirN = endRect.bottom() + 1;
         endDirE = endRect.left() - 1;
         endDirW = endRect.right() + 1;
         endRect.getCoords(&boundLeft, &boundTop, &boundRight, &boundBottom);
     }
 
     // XXX: a small optimization is possible by using H/V line iterators in the first
     //      and third cases, at the cost of making the code a bit more complex
 
     KisRandomConstAccessorSP accessor = device->createRandomConstAccessorNG(x, y);
 
     bool found = false;
     {
         for (qint32 y2 = y; y2 <= endDirS; ++y2) {
             for (qint32 x2 = x; x2 < x + w || found; ++ x2) {
                 accessor->moveTo(x2, y2);
                 if (!compareOp.isPixelEmpty(accessor->rawDataConst())) {
                     boundTop = y2;
                     found = true;
                     break;
                 }
             }
             if (found) break;
         }
     }
 
     /**
      * If the first pass hasn't found any opaque pixel, there is no
      * reason to check that 3 more times. They will not appear in the
      * meantime. Just return an empty bounding rect.
      */
     if (!found && endRect.isEmpty()) {
         return QRect();
     }
 
     found = false;
 
     for (qint32 y2 = y + h - 1; y2 >= endDirN ; --y2) {
         for (qint32 x2 = x + w - 1; x2 >= x || found; --x2) {
             accessor->moveTo(x2, y2);
             if (!compareOp.isPixelEmpty(accessor->rawDataConst())) {
                 boundBottom = y2;
                 found = true;
                 break;
             }
         }
         if (found) break;
     }
     found = false;
 
     {
         for (qint32 x2 = x; x2 <= endDirE ; ++x2) {
             for (qint32 y2 = y; y2 < y + h || found; ++y2) {
                 accessor->moveTo(x2, y2);
                 if (!compareOp.isPixelEmpty(accessor->rawDataConst())) {
                     boundLeft = x2;
                     found = true;
                     break;
                 }
             }
             if (found) break;
         }
     }
 
     found = false;
 
     // Look for right edge )
     {
 
         for (qint32 x2 = x + w - 1; x2 >= endDirW; --x2) {
             for (qint32 y2 = y + h - 1; y2 >= y || found; --y2) {
                 accessor->moveTo(x2, y2);
                 if (!compareOp.isPixelEmpty(accessor->rawDataConst())) {
                     boundRight = x2;
                     found = true;
                     break;
                 }
             }
             if (found) break;
         }
     }
 
     return QRect(boundLeft, boundTop,
                  boundRight - boundLeft + 1,
                  boundBottom - boundTop + 1);
 }
 
 }
 
 QRect KisPaintDevice::calculateExactBounds(bool nonDefaultOnly) const
 {
     QRect startRect = extent();
     QRect endRect;
 
     quint8 defaultOpacity = defaultPixel().opacityU8();
     if (defaultOpacity != OPACITY_TRANSPARENT_U8) {
         if (!nonDefaultOnly) {
             /**
              * We will calculate exact bounds only outside of the
              * image bounds, and that'll be nondefault area only.
              */
 
             endRect = defaultBounds()->bounds();
             nonDefaultOnly = true;
 
         } else {
             startRect = region().boundingRect();
         }
     }
 
     if (nonDefaultOnly) {
         const KoColor defaultPixel = this->defaultPixel();
         Impl::CheckNonDefault compareOp(pixelSize(), defaultPixel.data());
         endRect = Impl::calculateExactBoundsImpl(this, startRect, endRect, compareOp);
     } else {
         Impl::CheckFullyTransparent compareOp(m_d->colorSpace());
         endRect = Impl::calculateExactBoundsImpl(this, startRect, endRect, compareOp);
     }
 
     return endRect;
 }
 
 QRegion KisPaintDevice::regionExact() const
 {
     QRegion resultRegion;
     QVector<QRect> rects = region().rects();
 
     const KoColor defaultPixel = this->defaultPixel();
     Impl::CheckNonDefault compareOp(pixelSize(), defaultPixel.data());
 
     Q_FOREACH (const QRect &rc1, rects) {
         const int patchSize = 64;
         QVector<QRect> smallerRects = KritaUtils::splitRectIntoPatches(rc1, QSize(patchSize, patchSize));
         Q_FOREACH (const QRect &rc2, smallerRects) {
 
             const QRect result =
                 Impl::calculateExactBoundsImpl(this, rc2, QRect(), compareOp);
 
             if (!result.isEmpty()) {
                 resultRegion += result;
             }
         }
     }
     return resultRegion;
 }
 
 void KisPaintDevice::crop(qint32 x, qint32 y, qint32 w, qint32 h)
 {
     crop(QRect(x, y, w, h));
 }
 
 
 void KisPaintDevice::crop(const QRect &rect)
 {
     m_d->currentStrategy()->crop(rect);
 }
 
 void KisPaintDevice::purgeDefaultPixels()
 {
     KisDataManagerSP dm = m_d->dataManager();
     dm->purge(dm->extent());
 }
 
 void KisPaintDevice::setDefaultPixel(const KoColor &defPixel)
 {
     KoColor color(defPixel);
     color.convertTo(colorSpace());
 
     m_d->dataManager()->setDefaultPixel(color.data());
     m_d->cache()->invalidate();
 }
 
 KoColor KisPaintDevice::defaultPixel() const
 {
     return KoColor(m_d->dataManager()->defaultPixel(), colorSpace());
 }
 
 void KisPaintDevice::clear()
 {
     m_d->dataManager()->clear();
     m_d->cache()->invalidate();
 }
 
 void KisPaintDevice::clear(const QRect & rc)
 {
     m_d->currentStrategy()->clear(rc);
 }
 
 void KisPaintDevice::fill(const QRect & rc, const KoColor &color)
 {
     KIS_ASSERT_RECOVER_RETURN(*color.colorSpace() == *colorSpace());
     m_d->currentStrategy()->fill(rc, color.data());
 }
 
 void KisPaintDevice::fill(qint32 x, qint32 y, qint32 w, qint32 h, const quint8 *fillPixel)
 {
     m_d->currentStrategy()->fill(QRect(x, y, w, h), fillPixel);
 }
 
 
 bool KisPaintDevice::write(KisPaintDeviceWriter &store)
 {
     return m_d->dataManager()->write(store);
 }
 
 bool KisPaintDevice::read(QIODevice *stream)
 {
     bool retval;
 
     retval = m_d->dataManager()->read(stream);
     m_d->cache()->invalidate();
 
     return retval;
 }
 
 void KisPaintDevice::emitColorSpaceChanged()
 {
     emit colorSpaceChanged(m_d->colorSpace());
 }
 
 void KisPaintDevice::emitProfileChanged()
 {
     emit profileChanged(m_d->colorSpace()->profile());
 }
 
 KUndo2Command* KisPaintDevice::convertTo(const KoColorSpace * dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     KUndo2Command *command = m_d->convertColorSpace(dstColorSpace, renderingIntent, conversionFlags);
     return command;
 }
 
 bool KisPaintDevice::setProfile(const KoColorProfile * profile)
 {
     return m_d->assignProfile(profile);
 }
 
 KisDataManagerSP KisPaintDevice::dataManager() const
 {
     return m_d->dataManager();
 }
 
 void KisPaintDevice::convertFromQImage(const QImage& _image, const KoColorProfile *profile,
                                        qint32 offsetX, qint32 offsetY)
 {
     QImage image = _image;
 
     if (image.format() != QImage::Format_ARGB32) {
         image = image.convertToFormat(QImage::Format_ARGB32);
     }
     // Don't convert if not no profile is given and both paint dev and qimage are rgba.
     if (!profile && colorSpace()->id() == "RGBA") {
         writeBytes(image.constBits(), offsetX, offsetY, image.width(), image.height());
     } else {
         try {
             quint8 * dstData = new quint8[image.width() * image.height() * pixelSize()];
             KoColorSpaceRegistry::instance()
             ->colorSpace(RGBAColorModelID.id(), Integer8BitsColorDepthID.id(), profile)
             ->convertPixelsTo(image.constBits(), dstData, colorSpace(), image.width() * image.height(),
                               KoColorConversionTransformation::internalRenderingIntent(),
                               KoColorConversionTransformation::internalConversionFlags());
 
             writeBytes(dstData, offsetX, offsetY, image.width(), image.height());
             delete[] dstData;
         } catch (std::bad_alloc) {
             warnKrita << "KisPaintDevice::convertFromQImage: Could not allocate" << image.width() * image.height() * pixelSize() << "bytes";
             return;
         }
     }
     m_d->cache()->invalidate();
 }
 
 QImage KisPaintDevice::convertToQImage(const KoColorProfile *dstProfile, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags) const
 {
     qint32 x1;
     qint32 y1;
     qint32 w;
     qint32 h;
 
     QRect rc = exactBounds();
     x1 = rc.x();
     y1 = rc.y();
     w = rc.width();
     h = rc.height();
 
     return convertToQImage(dstProfile, x1, y1, w, h, renderingIntent, conversionFlags);
 }
 
 QImage KisPaintDevice::convertToQImage(const KoColorProfile *dstProfile,
                                        const QRect &rc,
                                        KoColorConversionTransformation::Intent renderingIntent,
                                        KoColorConversionTransformation::ConversionFlags conversionFlags) const
 {
     return convertToQImage(dstProfile,
                            rc.x(), rc.y(), rc.width(), rc.height(),
                            renderingIntent, conversionFlags);
 }
 
 QImage KisPaintDevice::convertToQImage(const KoColorProfile *dstProfile, qint32 x1, qint32 y1, qint32 w, qint32 h, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags) const
 {
 
     if (w < 0)
         return QImage();
 
     if (h < 0)
         return QImage();
 
     quint8 *data = 0;
     try {
         data = new quint8 [w * h * pixelSize()];
     } catch (std::bad_alloc) {
         warnKrita << "KisPaintDevice::convertToQImage std::bad_alloc for " << w << " * " << h << " * " << pixelSize();
         //delete[] data; // data is not allocated, so don't free it
         return QImage();
     }
     Q_CHECK_PTR(data);
 
     // XXX: Is this really faster than converting line by line and building the QImage directly?
     //      This copies potentially a lot of data.
     readBytes(data, x1, y1, w, h);
     QImage image = colorSpace()->convertToQImage(data, w, h, dstProfile, renderingIntent, conversionFlags);
     delete[] data;
 
     return image;
 }
 
 inline bool moveBy(KisSequentialConstIterator& iter, int numPixels)
 {
     int pos = 0;
     while (pos < numPixels) {
         int step = std::min(iter.nConseqPixels(), numPixels - pos);
         if (!iter.nextPixels(step))
             return false;
         pos += step;
     }
     return true;
 }
 
 static KisPaintDeviceSP createThumbnailDeviceInternal(const KisPaintDevice* srcDev, qint32 srcX0, qint32 srcY0, qint32 srcWidth, qint32 srcHeight, qint32 w, qint32 h, QRect outputRect)
 {
     KisPaintDeviceSP thumbnail = new KisPaintDevice(srcDev->colorSpace());
     qint32 pixelSize = srcDev->pixelSize();
 
     KisRandomConstAccessorSP srcIter = srcDev->createRandomConstAccessorNG(0, 0);
     KisRandomAccessorSP dstIter = thumbnail->createRandomAccessorNG(0, 0);
 
     for (qint32 y = outputRect.y(); y < outputRect.y() + outputRect.height(); ++y) {
         qint32 iY = srcY0 + (y * srcHeight) / h;
         for (qint32 x = outputRect.x(); x < outputRect.x() + outputRect.width(); ++x) {
             qint32 iX = srcX0 + (x * srcWidth) / w;
             srcIter->moveTo(iX, iY);
             dstIter->moveTo(x,  y);
             memcpy(dstIter->rawData(), srcIter->rawDataConst(), pixelSize);
         }
     }
     return thumbnail;
 }
 
 QSize fixThumbnailSize(QSize size)
 {
     if (!size.width() && size.height()) {
         size.setWidth(1);
     }
 
     if (size.width() && !size.height()) {
         size.setHeight(1);
     }
 
     return size;
 }
 
 KisPaintDeviceSP KisPaintDevice::createThumbnailDevice(qint32 w, qint32 h, QRect rect, QRect outputRect) const
 {
     QSize thumbnailSize(w, h);
 
     QRect imageRect = rect.isValid() ? rect : extent();
 
     if ((thumbnailSize.width() > imageRect.width()) || (thumbnailSize.height() > imageRect.height())) {
         thumbnailSize.scale(imageRect.size(), Qt::KeepAspectRatio);
     }
 
     thumbnailSize = fixThumbnailSize(thumbnailSize);
 
     //can't create thumbnail for an empty device, e.g. layer thumbnail for empty image
     if (imageRect.isEmpty() || thumbnailSize.isEmpty()) {
         return new KisPaintDevice(colorSpace());
     }
 
     int srcWidth, srcHeight;
     int srcX0, srcY0;
     imageRect.getRect(&srcX0, &srcY0, &srcWidth, &srcHeight);
 
     if (!outputRect.isValid()) {
         outputRect = QRect(0, 0, w, h);
     }
 
     KisPaintDeviceSP thumbnail = createThumbnailDeviceInternal(this, imageRect.x(), imageRect.y(), imageRect.width(), imageRect.height(),
                                  thumbnailSize.width(), thumbnailSize.height(), outputRect);
 
     return thumbnail;
 }
 
 KisPaintDeviceSP KisPaintDevice::createThumbnailDeviceOversampled(qint32 w, qint32 h, qreal oversample, QRect rect,  QRect outputTileRect) const
 {
     QSize thumbnailSize(w, h);
     qreal oversampleAdjusted = qMax(oversample, 1.);
     QSize thumbnailOversampledSize = oversampleAdjusted * thumbnailSize;
 
     QRect outputRect;
     QRect imageRect = rect.isValid() ? rect : extent();
 
     qint32 hstart = thumbnailOversampledSize.height();
 
     if ((thumbnailOversampledSize.width() > imageRect.width()) || (thumbnailOversampledSize.height() > imageRect.height())) {
         thumbnailOversampledSize.scale(imageRect.size(), Qt::KeepAspectRatio);
     }
 
     thumbnailOversampledSize = fixThumbnailSize(thumbnailOversampledSize);
 
     //can't create thumbnail for an empty device, e.g. layer thumbnail for empty image
     if (imageRect.isEmpty() || thumbnailSize.isEmpty() || thumbnailOversampledSize.isEmpty()) {
         return new KisPaintDevice(colorSpace());
     }
 
     oversampleAdjusted *= (hstart > 0) ? ((qreal)thumbnailOversampledSize.height() / hstart) : 1.; //readjusting oversample ratio, given that we had to adjust thumbnail size
 
     outputRect = QRect(0, 0, thumbnailOversampledSize.width(), thumbnailOversampledSize.height());
 
     if (outputTileRect.isValid()) {
         //compensating output rectangle for oversampling
         outputTileRect = QRect(oversampleAdjusted * outputTileRect.topLeft(), oversampleAdjusted * outputTileRect.bottomRight());
         outputRect = outputRect.intersected(outputTileRect);
     }
 
     KisPaintDeviceSP thumbnail = createThumbnailDeviceInternal(this, imageRect.x(), imageRect.y(), imageRect.width(), imageRect.height(),
                                  thumbnailOversampledSize.width(), thumbnailOversampledSize.height(), outputRect);
 
     if (oversample != 1. && oversampleAdjusted != 1.) {
         KoDummyUpdater updater;
         KisTransformWorker worker(thumbnail, 1 / oversampleAdjusted, 1 / oversampleAdjusted, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
                                   &updater, KisFilterStrategyRegistry::instance()->value("Bilinear"));
         worker.run();
     }
     return thumbnail;
 }
 
 QImage KisPaintDevice::createThumbnail(qint32 w, qint32 h, QRect rect, qreal oversample, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     QSize size = fixThumbnailSize(QSize(w, h));
 
     KisPaintDeviceSP dev = createThumbnailDeviceOversampled(size.width(), size.height(), oversample, rect);
     QImage thumbnail = dev->convertToQImage(KoColorSpaceRegistry::instance()->rgb8()->profile(), 0, 0, w, h, renderingIntent, conversionFlags);
     return thumbnail;
 }
 
 QImage KisPaintDevice::createThumbnail(qint32 w, qint32 h, qreal oversample, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)
 {
     QSize size = fixThumbnailSize(QSize(w, h));
 
     return m_d->cache()->createThumbnail(size.width(), size.height(), oversample, renderingIntent, conversionFlags);
 }
 
 KisHLineIteratorSP KisPaintDevice::createHLineIteratorNG(qint32 x, qint32 y, qint32 w)
 {
     m_d->cache()->invalidate();
     return m_d->currentStrategy()->createHLineIteratorNG(m_d->dataManager().data(), x, y, w, m_d->x(), m_d->y());
 }
 
 KisHLineConstIteratorSP KisPaintDevice::createHLineConstIteratorNG(qint32 x, qint32 y, qint32 w) const
 {
     return m_d->currentStrategy()->createHLineConstIteratorNG(m_d->dataManager().data(), x, y, w, m_d->x(), m_d->y());
 }
 
 KisVLineIteratorSP KisPaintDevice::createVLineIteratorNG(qint32 x, qint32 y, qint32 w)
 {
     m_d->cache()->invalidate();
     return m_d->currentStrategy()->createVLineIteratorNG(x, y, w);
 }
 
 KisVLineConstIteratorSP KisPaintDevice::createVLineConstIteratorNG(qint32 x, qint32 y, qint32 w) const
 {
     return m_d->currentStrategy()->createVLineConstIteratorNG(x, y, w);
 }
 
 KisRepeatHLineConstIteratorSP KisPaintDevice::createRepeatHLineConstIterator(qint32 x, qint32 y, qint32 w, const QRect& _dataWidth) const
 {
     return new KisRepeatHLineConstIteratorNG(m_d->dataManager().data(), x, y, w, m_d->x(), m_d->y(), _dataWidth, m_d->cacheInvalidator());
 }
 
 KisRepeatVLineConstIteratorSP KisPaintDevice::createRepeatVLineConstIterator(qint32 x, qint32 y, qint32 h, const QRect& _dataWidth) const
 {
     return new KisRepeatVLineConstIteratorNG(m_d->dataManager().data(), x, y, h, m_d->x(), m_d->y(), _dataWidth, m_d->cacheInvalidator());
 }
 
 KisRandomAccessorSP KisPaintDevice::createRandomAccessorNG(qint32 x, qint32 y)
 {
     m_d->cache()->invalidate();
     return m_d->currentStrategy()->createRandomAccessorNG(x, y);
 }
 
 KisRandomConstAccessorSP KisPaintDevice::createRandomConstAccessorNG(qint32 x, qint32 y) const
 {
     return m_d->currentStrategy()->createRandomConstAccessorNG(x, y);
 }
 
 KisRandomSubAccessorSP KisPaintDevice::createRandomSubAccessor() const
 {
     KisPaintDevice* pd = const_cast<KisPaintDevice*>(this);
     return new KisRandomSubAccessor(pd);
 }
 
 void KisPaintDevice::clearSelection(KisSelectionSP selection)
 {
     const KoColorSpace *colorSpace = m_d->colorSpace();
     QRect r = selection->selectedExactRect() & m_d->defaultBounds->bounds();
 
     if (r.isValid()) {
 
         KisHLineIteratorSP devIt = createHLineIteratorNG(r.x(), r.y(), r.width());
         KisHLineConstIteratorSP selectionIt = selection->projection()->createHLineConstIteratorNG(r.x(), r.y(), r.width());
 
         const KoColor defaultPixel = this->defaultPixel();
         bool transparentDefault = (defaultPixel.opacityU8() == OPACITY_TRANSPARENT_U8);
         for (qint32 y = 0; y < r.height(); y++) {
 
             do {
                 // XXX: Optimize by using stretches
                 colorSpace->applyInverseAlphaU8Mask(devIt->rawData(), selectionIt->rawDataConst(), 1);
                 if (transparentDefault && colorSpace->opacityU8(devIt->rawData()) == OPACITY_TRANSPARENT_U8) {
                     memcpy(devIt->rawData(), defaultPixel.data(), colorSpace->pixelSize());
                 }
             } while (devIt->nextPixel() && selectionIt->nextPixel());
             devIt->nextRow();
             selectionIt->nextRow();
         }
         m_d->dataManager()->purge(r.translated(-m_d->x(), -m_d->y()));
         setDirty(r);
     }
 }
 
 bool KisPaintDevice::pixel(qint32 x, qint32 y, QColor *c) const
 {
     KisHLineConstIteratorSP iter = createHLineConstIteratorNG(x, y, 1);
 
     const quint8 *pix = iter->rawDataConst();
 
     if (!pix) return false;
 
     colorSpace()->toQColor(pix, c);
 
     return true;
 }
 
 
 bool KisPaintDevice::pixel(qint32 x, qint32 y, KoColor * kc) const
 {
     KisHLineConstIteratorSP iter = createHLineConstIteratorNG(x, y, 1);
 
     const quint8 *pix = iter->rawDataConst();
 
     if (!pix) return false;
 
     kc->setColor(pix, m_d->colorSpace());
 
     return true;
 }
 
 bool KisPaintDevice::setPixel(qint32 x, qint32 y, const QColor& c)
 {
     KisHLineIteratorSP iter = createHLineIteratorNG(x, y, 1);
 
     colorSpace()->fromQColor(c, iter->rawData());
     m_d->cache()->invalidate();
     return true;
 }
 
 bool KisPaintDevice::setPixel(qint32 x, qint32 y, const KoColor& kc)
 {
     const quint8 * pix;
     KisHLineIteratorSP iter = createHLineIteratorNG(x, y, 1);
     if (kc.colorSpace() != m_d->colorSpace()) {
         KoColor kc2(kc, m_d->colorSpace());
         pix = kc2.data();
         memcpy(iter->rawData(), pix, m_d->colorSpace()->pixelSize());
     } else {
         pix = kc.data();
         memcpy(iter->rawData(), pix, m_d->colorSpace()->pixelSize());
     }
     m_d->cache()->invalidate();
     return true;
 }
 
 bool KisPaintDevice::fastBitBltPossible(KisPaintDeviceSP src)
 {
     return m_d->fastBitBltPossible(src);
 }
 
 void KisPaintDevice::fastBitBlt(KisPaintDeviceSP src, const QRect &rect)
 {
     m_d->currentStrategy()->fastBitBlt(src, rect);
 }
 
 void KisPaintDevice::fastBitBltOldData(KisPaintDeviceSP src, const QRect &rect)
 {
     m_d->currentStrategy()->fastBitBltOldData(src, rect);
 }
 
 void KisPaintDevice::fastBitBltRough(KisPaintDeviceSP src, const QRect &rect)
 {
     m_d->currentStrategy()->fastBitBltRough(src, rect);
 }
 
 void KisPaintDevice::fastBitBltRoughOldData(KisPaintDeviceSP src, const QRect &rect)
 {
     m_d->currentStrategy()->fastBitBltRoughOldData(src, rect);
 }
 
 void KisPaintDevice::readBytes(quint8 * data, qint32 x, qint32 y, qint32 w, qint32 h) const
 {
     readBytes(data, QRect(x, y, w, h));
 }
 
 void KisPaintDevice::readBytes(quint8 *data, const QRect &rect) const
 {
     m_d->currentStrategy()->readBytes(data, rect);
 }
 
 void KisPaintDevice::writeBytes(const quint8 *data, qint32 x, qint32 y, qint32 w, qint32 h)
 {
     writeBytes(data, QRect(x, y, w, h));
 }
 
 void KisPaintDevice::writeBytes(const quint8 *data, const QRect &rect)
 {
     m_d->currentStrategy()->writeBytes(data, rect);
 }
 
 QVector<quint8*> KisPaintDevice::readPlanarBytes(qint32 x, qint32 y, qint32 w, qint32 h) const
 {
     return m_d->currentStrategy()->readPlanarBytes(x, y, w, h);
 }
 
 void KisPaintDevice::writePlanarBytes(QVector<quint8*> planes, qint32 x, qint32 y, qint32 w, qint32 h)
 {
     m_d->currentStrategy()->writePlanarBytes(planes, x, y, w, h);
 }
 
 
 quint32 KisPaintDevice::pixelSize() const
 {
     quint32 _pixelSize = m_d->colorSpace()->pixelSize();
     Q_ASSERT(_pixelSize > 0);
     return _pixelSize;
 }
 
 quint32 KisPaintDevice::channelCount() const
 {
     quint32 _channelCount = m_d->colorSpace()->channelCount();
     Q_ASSERT(_channelCount > 0);
     return _channelCount;
 }
 
 KisRasterKeyframeChannel *KisPaintDevice::createKeyframeChannel(const KoID &id)
 {
     Q_ASSERT(!m_d->framesInterface);
     m_d->framesInterface.reset(new KisPaintDeviceFramesInterface(this));
 
     Q_ASSERT(!m_d->contentChannel);
     m_d->contentChannel.reset(new KisRasterKeyframeChannel(id, this, m_d->defaultBounds));
 
     // Raster channels always have at least one frame (representing a static image)
     KUndo2Command tempParentCommand;
     m_d->contentChannel->addKeyframe(0, &tempParentCommand);
 
     return m_d->contentChannel.data();
 }
 
 KisRasterKeyframeChannel* KisPaintDevice::keyframeChannel() const
 {
     Q_ASSERT(m_d->contentChannel);
     return m_d->contentChannel.data();
 }
 
 const KoColorSpace* KisPaintDevice::colorSpace() const
 {
     Q_ASSERT(m_d->colorSpace() != 0);
     return m_d->colorSpace();
 }
 
 KisPaintDeviceSP KisPaintDevice::createCompositionSourceDevice() const
 {
     KisPaintDeviceSP device = new KisPaintDevice(compositionSourceColorSpace());
     device->setDefaultBounds(defaultBounds());
     return device;
 }
 
 KisPaintDeviceSP KisPaintDevice::createCompositionSourceDevice(KisPaintDeviceSP cloneSource) const
 {
     KisPaintDeviceSP clone = new KisPaintDevice(*cloneSource);
     clone->setDefaultBounds(defaultBounds());
     clone->convertTo(compositionSourceColorSpace(),
                      KoColorConversionTransformation::internalRenderingIntent(),
                      KoColorConversionTransformation::internalConversionFlags());
     return clone;
 }
 
 KisPaintDeviceSP KisPaintDevice::createCompositionSourceDevice(KisPaintDeviceSP cloneSource, const QRect roughRect) const
 {
     KisPaintDeviceSP clone = new KisPaintDevice(colorSpace());
     clone->setDefaultBounds(defaultBounds());
     clone->makeCloneFromRough(cloneSource, roughRect);
     clone->convertTo(compositionSourceColorSpace(),
                      KoColorConversionTransformation::internalRenderingIntent(),
                      KoColorConversionTransformation::internalConversionFlags());
     return clone;
 }
 
 KisFixedPaintDeviceSP KisPaintDevice::createCompositionSourceDeviceFixed() const
 {
     return new KisFixedPaintDevice(compositionSourceColorSpace());
 }
 
 const KoColorSpace* KisPaintDevice::compositionSourceColorSpace() const
 {
     return colorSpace();
 }
 
 QVector<qint32> KisPaintDevice::channelSizes() const
 {
     QVector<qint32> sizes;
     QList<KoChannelInfo*> channels = colorSpace()->channels();
     std::sort(channels.begin(), channels.end());
 
     Q_FOREACH (KoChannelInfo * channelInfo, channels) {
         sizes.append(channelInfo->size());
     }
     return sizes;
 }
 
 KisPaintDevice::MemoryReleaseObject::~MemoryReleaseObject()
 {
     KisDataManager::releaseInternalPools();
 }
 
 KisPaintDevice::MemoryReleaseObject* KisPaintDevice::createMemoryReleaseObject()
 {
     return new MemoryReleaseObject();
 }
 
 KisPaintDevice::LodDataStruct::~LodDataStruct()
 {
 }
 
 QRegion KisPaintDevice::regionForLodSyncing() const
 {
     return m_d->regionForLodSyncing();
 }
 
 KisPaintDevice::LodDataStruct* KisPaintDevice::createLodDataStruct(int lod)
 {
     return m_d->createLodDataStruct(lod);
 }
 
 void KisPaintDevice::updateLodDataStruct(LodDataStruct *dst, const QRect &srcRect)
 {
     m_d->updateLodDataStruct(dst, srcRect);
 }
 
 void KisPaintDevice::uploadLodDataStruct(LodDataStruct *dst)
 {
     m_d->uploadLodDataStruct(dst);
 }
 
 
 KisPaintDeviceFramesInterface* KisPaintDevice::framesInterface()
 {
     return m_d->framesInterface.data();
 }
 
 /******************************************************************/
 /*               KisPaintDeviceFramesInterface                    */
 /******************************************************************/
 
 KisPaintDeviceFramesInterface::KisPaintDeviceFramesInterface(KisPaintDevice *parentDevice)
     : q(parentDevice)
 {
 }
 
 QList<int> KisPaintDeviceFramesInterface::frames()
 {
     return q->m_d->frameIds();
 }
 
 int KisPaintDeviceFramesInterface::createFrame(bool copy, int copySrc, const QPoint &offset, KUndo2Command *parentCommand)
 {
     return q->m_d->createFrame(copy, copySrc, offset, parentCommand);
 }
 
 void KisPaintDeviceFramesInterface::deleteFrame(int frame, KUndo2Command *parentCommand)
 {
     return q->m_d->deleteFrame(frame, parentCommand);
 }
 
 void KisPaintDeviceFramesInterface::fetchFrame(int frameId, KisPaintDeviceSP targetDevice)
 {
     q->m_d->fetchFrame(frameId, targetDevice);
 }
 
 void KisPaintDeviceFramesInterface::uploadFrame(int srcFrameId, int dstFrameId, KisPaintDeviceSP srcDevice)
 {
     q->m_d->uploadFrame(srcFrameId, dstFrameId, srcDevice);
 }
 
 void KisPaintDeviceFramesInterface::uploadFrame(int dstFrameId, KisPaintDeviceSP srcDevice)
 {
     q->m_d->uploadFrame(dstFrameId, srcDevice);
 }
 
 QRect KisPaintDeviceFramesInterface::frameBounds(int frameId)
 {
     return q->m_d->frameBounds(frameId);
 }
 
 QPoint KisPaintDeviceFramesInterface::frameOffset(int frameId) const
 {
     return q->m_d->frameOffset(frameId);
 }
 
 void KisPaintDeviceFramesInterface::setFrameDefaultPixel(const KoColor &defPixel, int frameId)
 {
     KIS_ASSERT_RECOVER_RETURN(frameId >= 0);
     q->m_d->setFrameDefaultPixel(defPixel, frameId);
 }
 
 KoColor KisPaintDeviceFramesInterface::frameDefaultPixel(int frameId) const
 {
     KIS_ASSERT_RECOVER(frameId >= 0) {
         return KoColor(Qt::red, q->m_d->colorSpace());
     }
     return q->m_d->frameDefaultPixel(frameId);
 }
 
 bool KisPaintDeviceFramesInterface::writeFrame(KisPaintDeviceWriter &store, int frameId)
 {
     KIS_ASSERT_RECOVER(frameId >= 0) {
         return false;
     }
     return q->m_d->writeFrame(store, frameId);
 }
 
 bool KisPaintDeviceFramesInterface::readFrame(QIODevice *stream, int frameId)
 {
     KIS_ASSERT_RECOVER(frameId >= 0) {
         return false;
     }
     return q->m_d->readFrame(stream, frameId);
 }
 
 int KisPaintDeviceFramesInterface::currentFrameId() const
 {
     return q->m_d->currentFrameId();
 }
 
 KisDataManagerSP KisPaintDeviceFramesInterface::frameDataManager(int frameId) const
 {
     KIS_ASSERT_RECOVER(frameId >= 0) {
         return q->m_d->dataManager();
     }
     return q->m_d->frameDataManager(frameId);
 }
 
 void KisPaintDeviceFramesInterface::invalidateFrameCache(int frameId)
 {
     KIS_ASSERT_RECOVER_RETURN(frameId >= 0);
 
     return q->m_d->invalidateFrameCache(frameId);
 }
 
 void KisPaintDeviceFramesInterface::setFrameOffset(int frameId, const QPoint &offset)
 {
     KIS_ASSERT_RECOVER_RETURN(frameId >= 0);
     return q->m_d->setFrameOffset(frameId, offset);
 }
 
 KisPaintDeviceFramesInterface::TestingDataObjects
 KisPaintDeviceFramesInterface::testingGetDataObjects() const
 {
     TestingDataObjects objects;
 
     objects.m_data = q->m_d->m_data.data();
     objects.m_lodData = q->m_d->m_lodData.data();
     objects.m_externalFrameData = q->m_d->m_externalFrameData.data();
 
     typedef KisPaintDevice::Private::FramesHash FramesHash;
 
     FramesHash::const_iterator it = q->m_d->m_frames.constBegin();
     FramesHash::const_iterator end = q->m_d->m_frames.constEnd();
 
     for (; it != end; ++it) {
         objects.m_frames.insert(it.key(), it.value().data());
     }
 
     objects.m_currentData = q->m_d->currentData();
 
     return objects;
 }
 
 QList<KisPaintDeviceData*> KisPaintDeviceFramesInterface::testingGetDataObjectsList() const
 {
     return q->m_d->allDataObjects();
 }
 
 void KisPaintDevice::tesingFetchLodDevice(KisPaintDeviceSP targetDevice)
 {
     m_d->tesingFetchLodDevice(targetDevice);
 }
diff --git a/libs/libkis/Action.cpp b/libs/libkis/Action.cpp
index 75005dce79..faafc23113 100644
--- a/libs/libkis/Action.cpp
+++ b/libs/libkis/Action.cpp
@@ -1,169 +1,158 @@
 /*
  *  Copyright (c) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser 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 Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "Action.h"
 
 
 struct Action::Private {
     Private() {}
     QAction *action {0};
 };
 
 Action::Action(QObject *parent)
     : QObject(parent)
     , d(new Private)
 {
     d->action = new KisAction(this);
     connect(d->action, SIGNAL(triggered(bool)), SIGNAL(triggered(bool)));
 }
 
 Action::Action(const QString &name, QAction *action, QObject *parent)
     : QObject(parent)
     , d(new Private)
 {
     d->action = action;
     d->action->setObjectName(name);
     connect(d->action, SIGNAL(triggered(bool)), SIGNAL(triggered(bool)));
 }
 
 Action::~Action()
 {
     delete d;
 }
 
 
 bool Action::operator==(const Action &other) const
 {
     return (d->action == other.d->action);
 }
 
 bool Action::operator!=(const Action &other) const
 {
     return !(operator==(other));
 }
 
 
 QString Action::text() const
 {
     if (!d->action) return "";
     return d->action->text();
 }
 
 void Action::setText(QString text)
 {
     if (!d->action) return;
     d->action->setText(text);
 }
 
 QString Action::name() const
 {
     if (!d->action) return "";
     return d->action->objectName();
 }
 
 void Action::setName(QString name)
 {
     if (!d->action) return;
     d->action->setObjectName(name);
 }
 
 bool Action::isCheckable() const
 {
     if (!d->action) return false;
     return d->action->isCheckable();
 }
 
 void Action::setCheckable(bool value)
 {
     if (!d->action) return;
     d->action->setCheckable(value);
 }
 
 bool Action::isChecked() const
 {
     if (!d->action) return false;
     return d->action->isChecked();
 }
 
 void Action::setChecked(bool value)
 {
     if (!d->action) return;
     d->action->setChecked(value);
 }
 
 QString Action::shortcut() const
 {
     if (!d->action) return QString();
     return d->action->shortcut().toString();
 }
 
 void Action::setShortcut(QString value)
 {
     if (!d->action) return;
     d->action->setShortcut(QKeySequence::fromString(value));
 }
 
 bool Action::isVisible() const
 {
     if (!d->action) return false;
     return d->action->isVisible();
 }
 
 void Action::setVisible(bool value)
 {
     if (!d->action) return;
     d->action->setVisible(value);
 }
 
 bool Action::isEnabled() const
 {
     if (!d->action) return false;
     return d->action->isEnabled();
 }
 
 void Action::setEnabled(bool value)
 {
     if (!d->action) return;
     d->action->setEnabled(value);
 }
 
 void Action::setToolTip(QString tooltip)
 {
     if (!d->action) return;
     d->action->setToolTip(tooltip);
 }
 
 QString Action::tooltip() const
 {
     return d->action->toolTip();
 }
 
 void Action::trigger()
 {
     d->action->trigger();
 }
-
-
-void Action::setMenu(const QString menu)
-{
-    d->action->setProperty("menu", menu);
-}
-
-QString Action::menu() const
-{
-    return d->action->property("menu").toString();
-}
diff --git a/libs/libkis/Action.h b/libs/libkis/Action.h
index 3d8b470013..9546fc644d 100644
--- a/libs/libkis/Action.h
+++ b/libs/libkis/Action.h
@@ -1,165 +1,153 @@
 /*
  *  Copyright (c) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser 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 Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef LIBKIS_ACTION_H
 #define LIBKIS_ACTION_H
 
 #include <kis_action.h>
 
 #include "kritalibkis_export.h"
 #include "libkis.h"
 
 /**
  * Action encapsulates a KisAction. By default, actions are put in the Tools/Scripts menu.
  */
 class KRITALIBKIS_EXPORT Action : public QObject
 {
     Q_OBJECT
 
 public:
     /**
      * @brief Action Create a new action object
      * @param parent the parent if it's in a QObject hierarchy
      */
     explicit Action(QObject *parent = 0);
 
     /**
      * @brief Action Create a new action object
      * @param name the name of the action
      * @param action the QAction it wraps
      * @param parent the parent if it's in a QObject hierarchy
      */
     Action(const QString &name, QAction *action, QObject *parent = 0);
     ~Action() override;
 
     bool operator==(const Action &other) const;
     bool operator!=(const Action &other) const;
 
 public Q_SLOTS:
 
     /**
      * @return the user-visible text of the action.
      */
     QString text() const;
 
     /**
      * set the user-visible text of the action to @param text.
      */
     void setText(QString text);
 
     /**
      * @return the internal name of the action.
      */
     QString name() const;
 
     /**
      * set the name of the action to @param name. This is not the user-visible name, but the internal one
      */
     void setName(QString name);
 
     /**
      * @return true if the action is checkable, false if it isn't*
      */
     bool isCheckable() const;
 
     /**
      * Set the action action checkable if @param value is true, unchecked if it's false
      */
     void setCheckable(bool value);
 
     /**
      * @return true if the action is checked, false if it isn't
      */
     bool isChecked() const;
 
     /**
      * Set the action checked if @param value is true, unchecked if it's false
      */
     void setChecked(bool value);
 
     /**
      * Return the action's shortcut as a string
      */
     QString shortcut() const;
 
     /**
      * set the action's shortcut to the given string.
      * @code
      * action.setShortcut("CTRL+SHIFT+S")
      * @endcode
      */
     void setShortcut(QString value);
 
     bool isVisible() const;
     /**
      * @brief setVisible determines whether the action will be visible in the scripting menu.
      * @param value true if the action is to be shown in the menu, false otherwise
      */
     void setVisible(bool value);
 
     /**
      * @return true if the action is enabled, false if not
      */
     bool isEnabled() const;
 
     /**
      * Set the action enabled or disabled according to @param value
      */
     void setEnabled(bool value);
 
     /**
      * Set the tooltip to the given @param tooltip
      */
     void setToolTip(QString tooltip);
 
     /**
      * @return the tooltip text
      */
     QString tooltip() const;
 
     /**
      * Trigger this action
      */
     void trigger();
 
-    /**
-     * @brief setMenu determines in which menu the action will be placed. The default is tools/scripts
-     * @param menu the menu where the action should go, / -separated to drill down the hierarchy
-     */
-    void setMenu(const QString menu);
-
-    /**
-     * @return the menu in which this action is to be placed.
-     */
-    QString menu() const;
-
-
 Q_SIGNALS:
 
     /**
      * Emitted whenever the action is triggered.
      */
     void triggered(bool);
 
 private:
     struct Private;
     Private *const d;
 
 };
 
 
 #endif // LIBKIS_ACTION_H
diff --git a/libs/libkis/Extension.h b/libs/libkis/Extension.h
index fc9d76c47e..eb9502a953 100644
--- a/libs/libkis/Extension.h
+++ b/libs/libkis/Extension.h
@@ -1,78 +1,86 @@
 /*
  *  Copyright (c) 2015 Cyrille Berger <cberger@cberger.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; either version 2 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 Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef LIBKIS_EXTENSION_H
 #define LIBKIS_EXTENSION_H
 
 #include "kritalibkis_export.h"
 
 #include <QObject>
+#include <Window.h>
 
 /**
- * An Extension is the base for classes that extend Krita. An Extension 
+ * An Extension is the base for classes that extend Krita. An Extension
  * is loaded on startup, when the setup() method will be executed.
- * 
- * The extension instance should be added to the Krita Application object 
+ *
+ * The extension instance should be added to the Krita Application object
  * using Krita.instance().addViewExtension or Application.addViewExtension
  * or Scripter.addViewExtension.
- * 
+ *
  * Example:
- * 
+ *
  * @code
  * import sys
  * from PyQt5.QtGui import *
  * from PyQt5.QtWidgets import *
  * from krita import *
  * class HelloExtension(Extension):
  *
  * def __init__(self, parent):
  *     super().__init__(parent)
  *
  * def hello(self):
  *     QMessageBox.information(QWidget(), "Test", "Hello! This is Krita " + Application.version())
- * 
+ *
  * def setup(self):
  *     qDebug("Hello Setup")
- *     action = Krita.instance().createAction("hello")
+ *
+ * def createActions(self, window)
+ *     action = window.createAction("hello")
  *     action.triggered.connect(self.hello)
  *
  * Scripter.addExtension(HelloExtension(Krita.instance()))
- * 
+ *
  * @endcode
  */
 class KRITALIBKIS_EXPORT Extension : public QObject
 {
     Q_OBJECT
 public:
-    
+
     /**
-     * Create a new extension. The extension will be 
+     * Create a new extension. The extension will be
      * owned by @param parent.
      */
     explicit Extension(QObject *parent = 0);
     ~Extension() override;
-    
+
     /**
-     * Override this function to setup your Extension. You can use it to add
-     * Actions to the action collection or integrate in any other way with 
-     * the application.
+     * Override this function to setup your Extension. You can use it to integrate
+     * with the Krita application instance.
      */
     virtual void setup() = 0;
+
+    virtual void createActions(Window *window) = 0;
+
 };
 
+
+
+
 #endif
diff --git a/libs/libkis/Krita.cpp b/libs/libkis/Krita.cpp
index b9421a573e..a90f5ec0ea 100644
--- a/libs/libkis/Krita.cpp
+++ b/libs/libkis/Krita.cpp
@@ -1,433 +1,423 @@
 /*
  *  Copyright (c) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser 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 Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "Krita.h"
 
 #include <QPointer>
 #include <QVariant>
 
 #include <ksharedconfig.h>
 #include <kconfiggroup.h>
 
 #include <KoColorSpaceRegistry.h>
 #include <KoColorProfile.h>
 #include <KoColorSpace.h>
 #include <KoDockRegistry.h>
 #include <KoColorSpaceEngine.h>
 #include <KoColorModelStandardIds.h>
 #include <KoID.h>
 
 #include <kis_filter_strategy.h>
 #include <kactioncollection.h>
 #include <KisPart.h>
 #include <KisMainWindow.h>
 #include <KisDocument.h>
 #include <kis_image.h>
 #include <kis_action.h>
-#include <kis_script_manager.h>
 #include <KisViewManager.h>
 #include <KritaVersionWrapper.h>
 #include <kis_filter_registry.h>
 #include <kis_filter.h>
 #include <kis_filter_configuration.h>
 #include <kis_properties_configuration.h>
 #include <kis_config.h>
 #include <kis_resource_server_provider.h>
 #include <kis_workspace_resource.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <kis_brush_server.h>
 #include <KoResourceServerProvider.h>
 #include <kis_action_registry.h>
 #include <kis_icon_utils.h>
+#include <KisPart.h>
 
 #include "View.h"
 #include "Document.h"
 #include "Window.h"
 #include "Extension.h"
 #include "DockWidgetFactoryBase.h"
 #include "Filter.h"
 #include "InfoObject.h"
 #include "Resource.h"
 
 Krita* Krita::s_instance = 0;
 
 struct Krita::Private {
     Private() {}
     QList<Extension*> extensions;
     bool batchMode {false};
     Notifier *notifier{new Notifier()};
 };
 
 Krita::Krita(QObject *parent)
     : QObject(parent)
     , d(new Private)
 {
     qRegisterMetaType<Notifier*>();
+    connect(KisPart::instance(), SIGNAL(sigWindowAdded(KisMainWindow*)), SLOT(mainWindowAdded(KisMainWindow*)));
 }
 
 Krita::~Krita()
 {
     qDeleteAll(d->extensions);
     delete d->notifier;
     delete d;
 }
 
 QList<Action *> Krita::actions() const
 {
     QList<Action*> actionList;
     KisMainWindow *mainWindow = KisPart::instance()->currentMainwindow();
     if (!mainWindow) {
         return actionList;
     }
     KActionCollection *actionCollection = mainWindow->actionCollection();
     Q_FOREACH(QAction *action, actionCollection->actions()) {
         actionList << new Action(action->objectName(), action);
     }
     return actionList;
 }
 
 Action *Krita::action(const QString &name) const
 {
     KisMainWindow *mainWindow = KisPart::instance()->currentMainwindow();
     if (!mainWindow) {
         return 0;
     }
     KActionCollection *actionCollection = mainWindow->actionCollection();
     QAction *action = actionCollection->action(name);
     if (action) {
         return new Action(name, action);
     }
     return 0;
 }
 
 Document* Krita::activeDocument() const
 {
     KisMainWindow *mainWindow = KisPart::instance()->currentMainwindow();
     if (!mainWindow) {
         return 0;
     }
     KisView *view = mainWindow->activeView();
     if (!view) {
         return 0;
     }
     KisDocument *document = view->document();
     return new Document(document);
 }
 
 void Krita::setActiveDocument(Document* value)
 {
     Q_FOREACH(KisView *view, KisPart::instance()->views()) {
         if (view->document() == value->document().data()) {
             view->activateWindow();
             break;
         }
     }
 }
 
 bool Krita::batchmode() const
 {
     return d->batchMode;
 }
 
 void Krita::setBatchmode(bool value)
 {
     d->batchMode = value;
 }
 
 
 QList<Document *> Krita::documents() const
 {
     QList<Document *> ret;
     foreach(QPointer<KisDocument> doc, KisPart::instance()->documents()) {
         ret << new Document(doc);
     }
     return ret;
 }
 
 QStringList Krita::filters() const
 {
     QStringList ls = KisFilterRegistry::instance()->keys();
     std::sort(ls.begin(), ls.end());
     return ls;
 }
 
 Filter *Krita::filter(const QString &name) const
 {
     if (!filters().contains(name)) return 0;
 
     Filter *filter = new Filter();
     filter->setName(name);
     KisFilterSP f = KisFilterRegistry::instance()->value(name);
     KisFilterConfigurationSP fc = f->defaultConfiguration();
     InfoObject *info = new InfoObject(fc);
     filter->setConfiguration(info);
     return filter;
 }
 
 QStringList Krita::colorModels() const
 {
     QSet<QString> colorModelsIds;
     QList<KoID> ids = KoColorSpaceRegistry::instance()->colorModelsList(KoColorSpaceRegistry::AllColorSpaces);
     Q_FOREACH(KoID id, ids) {
         colorModelsIds << id.id();
     }
     return colorModelsIds.toList();;
 }
 
 QStringList Krita::colorDepths(const QString &colorModel) const
 {
     QSet<QString> colorDepthsIds;
     QList<KoID> ids = KoColorSpaceRegistry::instance()->colorDepthList(colorModel, KoColorSpaceRegistry::AllColorSpaces);
     Q_FOREACH(KoID id, ids) {
         colorDepthsIds << id.id();
     }
     return colorDepthsIds.toList();;
 }
 
 QStringList Krita::filterStrategies() const
 {
     return KisFilterStrategyRegistry::instance()->keys();
 }
 
 QStringList Krita::profiles(const QString &colorModel, const QString &colorDepth) const
 {
     QSet<QString> profileNames;
     QString id = KoColorSpaceRegistry::instance()->colorSpaceId(colorModel, colorDepth);
     QList<const KoColorProfile *> profiles = KoColorSpaceRegistry::instance()->profilesFor(id);
     Q_FOREACH(const KoColorProfile *profile, profiles) {
         profileNames << profile->name();
     }
     return profileNames.toList();
 }
 
 bool Krita::addProfile(const QString &profilePath)
 {
     KoColorSpaceEngine *iccEngine = KoColorSpaceEngineRegistry::instance()->get("icc");
     return iccEngine->addProfile(profilePath);
 }
 
 Notifier* Krita::notifier() const
 {
     return d->notifier;
 }
 
 QString Krita::version() const
 {
     return KritaVersionWrapper::versionString(true);
 }
 
 QList<View *> Krita::views() const
 {
     QList<View *> ret;
     foreach(QPointer<KisView> view, KisPart::instance()->views()) {
         ret << new View(view);
     }
     return ret;
 }
 
 Window *Krita::activeWindow() const
 {
     KisMainWindow *mainWindow = KisPart::instance()->currentMainwindow();
     if (!mainWindow) {
         return 0;
     }
     return new Window(mainWindow);
 }
 
 QList<Window*>  Krita::windows() const
 {
     QList<Window*> ret;
     foreach(QPointer<KisMainWindow> mainWin, KisPart::instance()->mainWindows()) {
         ret << new Window(mainWin);
     }
     return ret;
 }
 
 QMap<QString, Resource *> Krita::resources(const QString &type) const
 {
     QMap<QString, Resource *> resources = QMap<QString, Resource *> ();
 
     if (type.toLower() == "pattern") {
         KoResourceServer<KoPattern>* server = KoResourceServerProvider::instance()->patternServer();
         Q_FOREACH (KoResource *res, server->resources()) {
             resources[res->name()] = new Resource(res);
         }
     }
     else if (type.toLower() == "gradient") {
         KoResourceServer<KoAbstractGradient>* server = KoResourceServerProvider::instance()->gradientServer();
         Q_FOREACH (KoResource *res, server->resources()) {
             resources[res->name()] = new Resource(res);
         }
     }
     else if (type.toLower() == "brush") {
         KisBrushResourceServer* server = KisBrushServer::instance()->brushServer();
         Q_FOREACH (KisBrushSP res, server->resources()) {
             resources[res->name()] = new Resource(res.data());
         }
     }
     else if (type.toLower() == "preset") {
         KisPaintOpPresetResourceServer* server = KisResourceServerProvider::instance()->paintOpPresetServer();
         Q_FOREACH (KisPaintOpPresetSP res, server->resources()) {
             resources[res->name()] = new Resource(res.data());
         }
     }
     else if (type.toLower() == "palette") {
         KoResourceServer<KoColorSet>* server = KoResourceServerProvider::instance()->paletteServer();
         Q_FOREACH (KoResource *res, server->resources()) {
             resources[res->name()] = new Resource(res);
         }
     }
     else if (type.toLower() == "workspace") {
         KoResourceServer< KisWorkspaceResource >* server = KisResourceServerProvider::instance()->workspaceServer();
         Q_FOREACH (KoResource *res, server->resources()) {
             resources[res->name()] = new Resource(res);
         }
     }
     return resources;
 }
 
 QStringList Krita::recentDocuments() const
 {
     KConfigGroup grp = KSharedConfig::openConfig()->group(QString("RecentFiles"));
     QStringList keys = grp.keyList();
     QStringList recentDocuments;
 
     for(int i = 0; i <= keys.filter("File").count(); i++)
         recentDocuments << grp.readEntry(QString("File%1").arg(i), QString(""));
 
     return recentDocuments;
 }
 
 Document* Krita::createDocument(int width, int height, const QString &name, const QString &colorModel, const QString &colorDepth, const QString &profile, double resolution)
 {
     KisDocument *document = KisPart::instance()->createDocument();
     KisPart::instance()->addDocument(document);
     const KoColorSpace *cs = KoColorSpaceRegistry::instance()->colorSpace(colorModel, colorDepth, profile);
     Q_ASSERT(cs);
 
     QColor qc(Qt::white);
     qc.setAlpha(0);
     KoColor bgColor(qc, cs);
 
     if (!document->newImage(name, width, height, cs, bgColor, true, 1, "", double(resolution / 72) )) {
         qDebug() << "Could not create a new image";
         return 0;
     }
 
     Q_ASSERT(document->image());
     qDebug() << document->image()->objectName();
 
     return new Document(document);
 }
 
 Document* Krita::openDocument(const QString &filename)
 {
     KisDocument *document = KisPart::instance()->createDocument();
     KisPart::instance()->addDocument(document);
     document->openUrl(QUrl::fromLocalFile(filename), KisDocument::DontAddToRecent);
     return new Document(document);
 }
 
 Window* Krita::openWindow()
 {
     KisMainWindow *mw = KisPart::instance()->createMainWindow();
     return new Window(mw);
 }
 
-Action *Krita::createAction(const QString &id, const QString &text, bool addToScriptMenu)
-{
-    KisAction *action = new KisAction(text, this);
-    action->setObjectName(id);
-
-    KisActionRegistry *actionRegistry = KisActionRegistry::instance();
-    actionRegistry->propertizeAction(action->objectName(), action);
-    bool ok; // We will skip this check
-    int activationFlags = actionRegistry->getActionProperty(id, "activationFlags").toInt(&ok, 2);
-    int activationConditions = actionRegistry->getActionProperty(id, "activationConditions").toInt(&ok, 2);
-    action->setActivationFlags((KisAction::ActivationFlags) activationFlags);
-    action->setActivationConditions((KisAction::ActivationConditions) activationConditions);
-
-    if (addToScriptMenu) {
-        KisPart::instance()->addScriptAction(action);
-    }
-    return new Action(action->objectName(), action);
-}
-
 void Krita::addExtension(Extension* extension)
 {
     d->extensions.append(extension);
 }
 
 QList< Extension* > Krita::extensions()
 {
     return d->extensions;
 }
 
 void Krita::writeSetting(const QString &group, const QString &name, const QString &value)
 {
     KConfigGroup grp = KSharedConfig::openConfig()->group(group);
     grp.writeEntry(name, value);
 }
 
 QString Krita::readSetting(const QString &group, const QString &name, const QString &defaultValue)
 {
     KConfigGroup grp = KSharedConfig::openConfig()->group(group);
     return grp.readEntry(name, defaultValue);
 }
 
 QIcon Krita::icon(QString &iconName) const
 {
     return KisIconUtils::loadIcon(iconName);
 }
 
 void Krita::addDockWidgetFactory(DockWidgetFactoryBase* factory)
 {
     KoDockRegistry::instance()->add(factory);
 }
 
 Krita* Krita::instance()
 {
     if (!s_instance)
     {
         s_instance = new Krita;
     }
     return s_instance;
 }
 
 /**
  * Scripter.fromVariant(variant)
  * variant is a QVariant
  * returns instance of QObject-subclass
  *
  * This is a helper method for PyQt because PyQt cannot cast a variant to a QObject or QWidget
  */
 QObject *Krita::fromVariant(const QVariant& v)
 {
 
     if (v.canConvert< QWidget* >())
     {
         QObject* obj = qvariant_cast< QWidget* >(v);
         return obj;
     }
     else if (v.canConvert< QObject* >())
     {
         QObject* obj = qvariant_cast< QObject* >(v);
         return obj;
     }
     else
         return 0;
 }
+
+void Krita::mainWindowAdded(KisMainWindow *kisWindow)
+{
+    Q_FOREACH(Extension *extension, d->extensions) {
+        Window window(kisWindow);
+        extension->createActions(&window);
+    }
+}
diff --git a/libs/libkis/Krita.h b/libs/libkis/Krita.h
index fc4f5b6a36..5fd47153fb 100644
--- a/libs/libkis/Krita.h
+++ b/libs/libkis/Krita.h
@@ -1,350 +1,344 @@
 /*
  *  Copyright (c) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser 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 Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef LIBKIS_KRITA_H
 #define LIBKIS_KRITA_H
 
 #include <QObject>
 
 #include "kritalibkis_export.h"
 #include "libkis.h"
 
 #include "Extension.h"
 #include "Document.h"
 #include "Window.h"
 #include "View.h"
 #include "Action.h"
 #include "Notifier.h"
 
 class QAction;
 
 /**
  * Krita is a singleton class that offers the root access to the Krita object hierarchy.
  *
  * The Krita.instance() is aliased as two builtins: Scripter and Application.
  */
 class KRITALIBKIS_EXPORT Krita : public QObject
 {
     Q_OBJECT
 
 public:
     explicit Krita(QObject *parent = 0);
     ~Krita() override;
 
 public Q_SLOTS:
 
 
     /**
      * @return the currently active document, if there is one.
      */
     Document* activeDocument() const;
 
     /**
      * @brief setActiveDocument activates the first view that shows the given document
      * @param value the document we want to activate
      */
     void setActiveDocument(Document* value);
 
     /**
      * @brief batchmode determines whether the script is run in batch mode. If batchmode
      * is true, scripts should now show messageboxes or dialog boxes.
      *
      * Note that this separate from Document.setBatchmode(), which determines whether
      * export/save option dialogs are shown.
      *
      * @return true if the script is run in batchmode
      */
     bool batchmode() const;
 
     /**
      * @brief setBatchmode sets the batchmode to @param value; if true, scripts should
      * not show dialogs or messageboxes.
      */
     void setBatchmode(bool value);
 
     /**
      * @return return a list of all actions for the currently active mainWindow.
      */
     QList<Action*> actions() const;
 
     /**
      * @return the action that has been registered under the given name, or 0 if no such action exists.
      */
     Action *action(const QString &name) const;
 
     /**
      * @return a list of all open Documents
      */
     QList<Document*> documents() const;
 
     /**
      * @brief Filters are identified by an internal name. This function returns a list
      * of all existing registered filters.
      * @return a list of all registered filters
      */
     QStringList filters() const;
 
     /**
      * @brief filter construct a Filter object with a default configuration.
      * @param name the name of the filter. Use Krita.instance().filters() to get
      * a list of all possible filters.
      * @return the filter or None if there is no such filter.
      */
     Filter *filter(const QString &name) const;
 
     /**
      * @brief colorModels creates a list with all color models id's registered.
      * @return a list of all color models or a empty list if there is no such color models.
      */
     QStringList colorModels() const;
 
     /**
      * @brief colorDepths creates a list with the names of all color depths
      * compatible with the given color model.
      * @param colorModel the id of a color model.
      * @return a list of all color depths or a empty list if there is no such
      * color depths.
      */
     QStringList colorDepths(const QString &colorModel) const;
 
     /**
      * @brief filterStrategies Retrieves all installed filter strategies. A filter
      * strategy is used when transforming (scaling, shearing, rotating) an image to
      * calculate the value of the new pixels. You can use th
      * @return the id's of all available filters.
      */
     QStringList filterStrategies() const;
 
     /**
      * @brief profiles creates a list with the names of all color profiles compatible
      * with the given color model and color depth.
      * @param colorModel A string describing the color model of the image:
      * <ul>
      * <li>A: Alpha mask</li>
      * <li>RGBA: RGB with alpha channel (The actual order of channels is most often BGR!)</li>
      * <li>XYZA: XYZ with alpha channel</li>
      * <li>LABA: LAB with alpha channel</li>
      * <li>CMYKA: CMYK with alpha channel</li>
      * <li>GRAYA: Gray with alpha channel</li>
      * <li>YCbCrA: YCbCr with alpha channel</li>
      * </ul>
      * @param colorDepth A string describing the color depth of the image:
      * <ul>
      * <li>U8: unsigned 8 bits integer, the most common type</li>
      * <li>U16: unsigned 16 bits integer</li>
      * <li>F16: half, 16 bits floating point. Only available if Krita was built with OpenEXR</li>
      * <li>F32: 32 bits floating point</li>
      * </ul>
      * @return a list with valid names
      */
     QStringList profiles(const QString &colorModel, const QString &colorDepth) const;
 
     /**
      * @brief addProfile load the given profile into the profile registry.
      * @param profilePath the path to the profile.
      * @return true if adding the profile succeeded.
      */
     bool addProfile(const QString &profilePath);
 
     /**
      * @brief notifier the Notifier singleton emits signals when documents are opened and
      * closed, the configuration changes, views are opened and closed or windows are opened.
      * @return the notifier object
      */
     Notifier *notifier() const;
 
     /**
      * @brief version Determine the version of Krita
      *
      * Usage: print(Application.version ())
      *
      * @return the version string including git sha1 if Krita was built from git
      */
     QString version() const;
 
     /**
      * @return a list of all views. A Document can be shown in more than one view.
      */
     QList<View*> views() const;
 
     /**
      * @return the currently active window or None if there is no window
      */
     Window *activeWindow() const;
 
     /**
      * @return a list of all windows
      */
     QList<Window *> windows() const;
 
     /**
      * @brief resources returns a list of Resource objects of the given type
      * @param type Valid types are:
      *
      * <ul>
      * <li>pattern</li>
      * <li>gradient</li>
      * <li>brush</li>
      * <li>preset</li>
      * <li>palette</li>
      * <li>workspace</li>
      * </ul>
      */
     QMap<QString, Resource*> resources(const QString &type) const;
 
 
     /**
      * @brief return all recent documents registered in the RecentFiles group of the kritarc
      */
     QStringList recentDocuments() const;
 
 
     /**
      * @brief createDocument creates a new document and image and registers
      * the document with the Krita application.
      *
      * Unless you explicitly call Document::close() the document wil remain
      * known to the Krita document registry. The document and its image will
      * only be deleted when Krita exits.
      *
      * The document will have one transparent layer.
      *
      * To create a new document and show it, do something like:
 @code
 from Krita import *
 
 def add_document_to_window():
     d = Application.createDocument(100, 100, "Test", "RGBA", "U8", "", 120.0)
     Application.activeWindow().addView(d)
 
 add_document_to_window()
 @endcode
      *
      * @param width the width in pixels
      * @param height the height in pixels
      * @param name the name of the image (not the filename of the document)
      * @param colorModel A string describing the color model of the image:
      * <ul>
      * <li>A: Alpha mask</li>
      * <li>RGBA: RGB with alpha channel (The actual order of channels is most often BGR!)</li>
      * <li>XYZA: XYZ with alpha channel</li>
      * <li>LABA: LAB with alpha channel</li>
      * <li>CMYKA: CMYK with alpha channel</li>
      * <li>GRAYA: Gray with alpha channel</li>
      * <li>YCbCrA: YCbCr with alpha channel</li>
      * </ul>
      * @param colorDepth A string describing the color depth of the image:
      * <ul>
      * <li>U8: unsigned 8 bits integer, the most common type</li>
      * <li>U16: unsigned 16 bits integer</li>
      * <li>F16: half, 16 bits floating point. Only available if Krita was built with OpenEXR</li>
      * <li>F32: 32 bits floating point</li>
      * </ul>
      * @param profile The name of an icc profile that is known to Krita. If an empty string is passed, the default is
      * taken.
      * @param resolution the resolution in points per inch.
      * @return the created document.
      */
     Document *createDocument(int width, int height, const QString &name, const QString &colorModel, const QString &colorDepth, const QString &profile, double resolution);
 
     /**
      * @brief openDocument creates a new Document, registers it with the Krita application and loads the given file.
      * @param filename the file to open in the document
      * @return the document
      */
     Document *openDocument(const QString &filename);
 
     /**
      * @brief openWindow create a new main window. The window is not shown by default.
      */
     Window *openWindow();
 
-    /**
-     * @brief createAction creates an action with the given text and passes it to Krita. Every newly created
-     *     mainwindow will create an instance of this action. This means that actions need to be created in the
-     *     setup phase of the plugin, not on the fly.
-     * @param id the unique id for this action
-     * @param text the user-visible text
-     * @return the Action you can connect a slot to.
-     */
-    Action *createAction(const QString &name, const QString &text, bool addToScriptMenu = true);
-
     /**
      * @brief addExtension add the given plugin to Krita. There will be a single instance of each Extension in the Krita process.
      * @param extension the extension to add.
      */
     void addExtension(Extension* extension);
 
     /**
      * return a list with all registered extension objects.
      */
     QList<Extension*> extensions();
 
     /**
      * @brief addDockWidgetFactory Add the given docker factory to the application. For scripts
      * loaded on startup, this means that every window will have one of the dockers created by the
      * factory.
      * @param factory The factory object.
      */
     void addDockWidgetFactory(DockWidgetFactoryBase* factory );
 
     /**
      * @brief writeSetting write the given setting under the given name to the kritarc file in
      * the given settings group.
      * @param group The group the setting belongs to. If empty, then the setting is written in the
      * general section
      * @param name The name of the setting
      * @param value The value of the setting. Script settings are always written as strings.
      */
     void writeSetting(const QString &group, const QString &name, const QString &value);
 
     /**
      * @brief readSetting read the given setting value from the kritarc file.
      * @param group The group the setting is part of. If empty, then the setting is read from
      * the general group.
      * @param name The name of the setting
      * @param defaultValue The default value of the setting
      * @return a string representing the setting.
      */
     QString readSetting(const QString &group, const QString &name, const QString &defaultValue);
 
     /**
      * @brief icon
      * This allows you to get icons from Krita's internal icons.
      * @param iconName name of the icon.
      * @return the icon related to this name.
      */
     QIcon icon(QString &iconName) const;
 
     /**
      * @brief instance retrieve the singleton instance of the Application object.
      */
     static Krita* instance();
 
     // Internal only: for use with mikro.py
     static QObject *fromVariant(const QVariant& v);
 
+private Q_SLOTS:
+
+    void mainWindowAdded(KisMainWindow *window);
+
 private:
     struct Private;
     Private *const d;
     static Krita* s_instance;
 
 };
 
 Q_DECLARE_METATYPE(Notifier*);
 
 #endif // LIBKIS_KRITA_H
diff --git a/libs/libkis/Mainpage.dox b/libs/libkis/Mainpage.dox
index 03b09767d3..c98cbcf7c8 100644
--- a/libs/libkis/Mainpage.dox
+++ b/libs/libkis/Mainpage.dox
@@ -1,147 +1,150 @@
 /*
  *  Copyright (C) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 /**
   \mainpage Krita Scripting and Plugin Wrapper Library: libkis
 
   Libkis is a QObject-based wrapper around Krita's internal libraries.
   The wrapper can be used from C++ plugins that do not need the
   advanced and volatile internal libraries of Krita, or can be bound
   to scripting languages like Python or Javascript.
 
   All classes are based on QObject, so QMetaObject introspection can
   be used to discover properties, slots and signals and automatically
   expose all functionality to the client.
 
   Note that all objects that are created are wrapper objects that are
   owned by the scripting environment or the plugin.
 
 
   Using the functionality in this library, either through a scripting
   environment like Python or Javascript, or directly from C++, you can,
   among other things achieve the following functionality:
 
   <ul>
      <li>Open, save, export, rename files.
      <li>Access the layers and masks in a file
      <li>Read and write pixel data
      <li>Add menu items, toolbar items and docker palettes
   </ul>
 
   The reference implementation of scripting in Krita is implemented
   in Python 3. All examples in the documentation for scripting will be
   provided using Python, although the api documentation is generated
   from C++ header files and shows c++ syntax for arguments.
 
   Autostarting Scripts
   ====================
 
   Autostarting scripts or script-based plugins are scripts that Krita
   loads on startup. You can add autostarting scripts to Krita by placing
   them in the pykrita folder in the resources folder: go to settings/
   manage resources and press the Open Resources Folder to open your
   local resources folder.
 
   Scripts are identified by a file that ends in a `.desktop` extension
   that contain information about the script itself. For example:
 
 @code
     [Desktop Entry]
     Type=Service
     ServiceTypes=Krita/PythonPlugin
     X-KDE-Library=hello
     X-Python-2-Compatible=false
     Name=Hello World
     Comment=Basic plugin to test PyKrita
 @endcode
 
   The Python code itself should be placed in the pykrita/hello folder.
   Your Python plugin needs to be a module, so needs to have a `__init__.py`
   file:
 
 @code
     # let's make a module
     from .hello import *
 @endcode
 
 Krita is a Qt-based application. In principle, you can use any Python
 binding to Qt as long as it's using exactly the same version of Qt
 that Krita uses. In our examples we will be using [PyQt](https://www.riverbankcomputing.com/software/pyqt/intro).
 
 The easiest access to the Krita api is by simply importing the "krita"
 module. This automatically adds two built-ins: Scripter and Application.
 
 This is an alias for Krita.instance(), which is the first place from
 which to access the running Krita instance.
 
 @code
 from PyQt5.QtGui import *
 from PyQt5.QtWidgets import *
 from krita import *
 
 def hello():
     QMessageBox.information(QWidget(), "Test", "Hello World")
 
 class HelloExtension(Extension):
 
   def __init__(self, parent):
       super().__init__(parent)
 
-  def setup(self, viewManager):
-      action = viewManager.createAction("Hello")
+  def setup(self):
+      pass
+
+  def createActions(self, window):
+      action = window.createAction("Hello")
       action.triggered.connect(hello)
 
 Krita.instance().addExtension(HelloExtension(Krita.instance()))
 @endcode
 
 
 The Krita Object Model
 ======================
 
 The starting point is the @see Krita class, which provides a singleton
 object for easy reference. From the Krita class, a hierarchy is provided
 where you can access windows, lviews, documents, nodes and channels.
 
 You can access the Krita class as
 
  * Krita.instance()
  * Application
  * Scripter
 
 For ease of use.
 
 The Document class is provided to allow access to the images Krita has
 loaded. *Note*: internally, Krita distinguishes between images and documents.
 
 A document contains an image and knows the filename of the image, the image
 itself only knows about the layers and masks it contains. The generic
 name for layers and masks is *node*.
 
 A Node can be a group layer, a file layer, a vector layer, a filter layer,
 a generator layer, a clone layer, a paint layer or a transform mask, a selection
 mask, a transparency mask or a colorize mask. You can change some properties
 of Nodes, but not all of them.
 
 The Window class is provided to allow access to the windows and views Krita
 has open. A given Document can be shown in more than one View, and in more than
 one Window. You can open and close windows and views.
 
  */
 
 // DOXYGEN_SET_PROJECT_NAME = Krita
 // DOXYGEN_SET_IGNORE_PREFIX = Kis Ko K
diff --git a/libs/libkis/Window.cpp b/libs/libkis/Window.cpp
index e5b2189e77..59d273e1b1 100644
--- a/libs/libkis/Window.cpp
+++ b/libs/libkis/Window.cpp
@@ -1,117 +1,151 @@
 /*
  *  Copyright (c) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser 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 Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "Window.h"
 
+#include <QMenuBar>
+#include <QObject>
+
 #include <KisMainWindow.h>
 #include <KisPart.h>
 #include <KisDocument.h>
+#include <KisViewManager.h>
+#include <kis_action_manager.h>
 
 #include <Document.h>
 #include <View.h>
-
+#include <Action.h>
 
 struct Window::Private {
     Private() {}
 
     QPointer<KisMainWindow> window;
 };
 
 Window::Window(KisMainWindow *window, QObject *parent)
     : QObject(parent)
     , d(new Private)
 {
     d->window = window;
     connect(window, SIGNAL(destroyed(QObject*)), SIGNAL(windowClosed()));
 }
 
 Window::~Window()
 {
     delete d;
 }
 
 bool Window::operator==(const Window &other) const
 {
     return (d->window == other.d->window);
 }
 
 bool Window::operator!=(const Window &other) const
 {
     return !(operator==(other));
 }
 
 QMainWindow *Window::qwindow() const
 {
     return d->window;
 }
 
 QList<View*> Window::views() const
 {
     QList<View *> ret;
     if (d->window) {
         foreach(QPointer<KisView> view, KisPart::instance()->views()) {
             if (view->mainWindow() == d->window) {
                 ret << new View(view);
             }
         }
     }
     return ret;
 
 }
 
 View *Window::addView(Document *document)
 {
     if (d->window) {
         KisView *view = d->window->newView(document->document());
         return new View(view);
     }
     return 0;
 }
 
 void Window::showView(View *view)
 {
     if (views().contains(view)) {
         KisView *v = view->view();
         d->window->showView(v);
     }
 }
 
 View *Window::activeView() const
 {
     if (d->window) {
         return new View(d->window->activeView());
     }
     return 0;
 }
 
 void Window::activate()
 {
     if (d->window) {
         d->window->activateWindow();
     }
 }
 
 void Window::close()
 {
     if (d->window) {
         KisPart::instance()->removeMainWindow(d->window);
         d->window->close();
     }
 }
 
 
+Action *Window::createAction(const QString &id, const QString &text, const QString &menuLocation)
+{
+    KisAction *action = d->window->viewManager()->actionManager()->createAction(id);
+    action->setText(text);
+    action->setObjectName(id);
+    if (!menuLocation.isEmpty()) {
+        QAction *found = 0;
+        QList<QAction *> candidates = d->window->menuBar()->actions();
+        Q_FOREACH(const QString &name, menuLocation.split("/")) {
+            Q_FOREACH(QAction *candidate, candidates) {
+                if (candidate->objectName() == name) {
+                    found = candidate;
+                    candidates = candidate->menu()->actions();
+                    break;
+                }
+            }
+            if (candidates.isEmpty()) {
+                break;
+            }
+        }
+
+        if (found && found->menu()) {
+            found->menu()->addAction(action);
+        }
+    }
+    return new Action(action->objectName(), action);
+}
+
+
 
diff --git a/libs/libkis/Window.h b/libs/libkis/Window.h
index f6a5b0eac4..53c5f13942 100644
--- a/libs/libkis/Window.h
+++ b/libs/libkis/Window.h
@@ -1,95 +1,112 @@
 /*
  *  Copyright (c) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser 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 Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef LIBKIS_WINDOW_H
 #define LIBKIS_WINDOW_H
 
 #include <QObject>
+#include <QAction>
 #include <QMainWindow>
 
 #include "kritalibkis_export.h"
 #include "libkis.h"
 
 #include <KisMainWindow.h>
+
+class Action;
+
 /**
  * Window represents one Krita mainwindow. A window can have any number
  * of views open on any number of documents.
  */
 class KRITALIBKIS_EXPORT Window : public QObject
 {
     Q_OBJECT
 
 public:
     explicit Window(KisMainWindow *window, QObject *parent = 0);
     ~Window() override;
 
     bool operator==(const Window &other) const;
     bool operator!=(const Window &other) const;
 
 public Q_SLOTS:
 
     /**
      * Return a handle to the QMainWindow widget. This is useful
      * to e.g. parent dialog boxes and message box.
      */
     QMainWindow *qwindow() const;
 
     /**
      * @return a list of open views in this window
      */
     QList<View*> views() const;
 
     /**
      * Open a new view on the given document in this window
      */
     View *addView(Document *document);
 
     /**
      * Make the given view active in this window. If the view
      * does not belong to this window, nothing happens.
      */
     void showView(View *view);
 
 
     /**
      * @return the currently active view or 0 if no view is active
      */
     View *activeView() const;
 
     /**
      * @brief activate activates this Window.
      */
     void activate();
 
     /**
      * @brief close the active window and all its Views. If there
      * are no Views left for a given Document, that Document will
      * also be closed.
      */
     void close();
 
+    /**
+     * @brief createAction creates an Action object and adds it to the action
+     * manager for this Window.
+     * @param id The unique id for the action. This will be used to
+     *     propertize the action if any .action file is present
+     * @param text The user-visible text of the action. If empty, the text from the
+     *    .action file is used.
+     * @param menu a /-separated string that describes which menu the action should
+     *     be places in. Default is "tools/scripts"
+     * @return the new action.
+     */
+    Action *createAction(const QString &id, const QString &text = QString(), const QString &menuLocation = QString("tools/scripts"));
+
 Q_SIGNALS:
     /// Emitted when the window is closed.
     void windowClosed();
 
 private:
     struct Private;
     Private *const d;
 
 };
 
 #endif // LIBKIS_WINDOW_H
diff --git a/libs/ui/CMakeLists.txt b/libs/ui/CMakeLists.txt
index c876aedfe2..f2524f5ccb 100644
--- a/libs/ui/CMakeLists.txt
+++ b/libs/ui/CMakeLists.txt
@@ -1,592 +1,591 @@
 include_directories(
     ${CMAKE_CURRENT_SOURCE_DIR}/qtlockedfile
     ${EXIV2_INCLUDE_DIR}
 )
 
 include_directories(SYSTEM
     ${EIGEN3_INCLUDE_DIR}
     ${OCIO_INCLUDE_DIR}
 )
 
 add_subdirectory( tests )
 
 if (APPLE)
     find_library(FOUNDATION_LIBRARY Foundation)
     find_library(APPKIT_LIBRARY AppKit)
 endif ()
 
 set(kritaui_LIB_SRCS
     canvas/kis_canvas_widget_base.cpp
     canvas/kis_canvas2.cpp
     canvas/kis_canvas_updates_compressor.cpp
     canvas/kis_canvas_controller.cpp
     canvas/kis_paintop_transformation_connector.cpp
     canvas/kis_display_color_converter.cpp
     canvas/kis_display_filter.cpp
     canvas/kis_exposure_gamma_correction_interface.cpp
     canvas/kis_tool_proxy.cpp
     canvas/kis_canvas_decoration.cc
     canvas/kis_coordinates_converter.cpp
     canvas/kis_grid_manager.cpp
     canvas/kis_grid_decoration.cpp
     canvas/kis_grid_config.cpp
     canvas/kis_prescaled_projection.cpp
     canvas/kis_qpainter_canvas.cpp
     canvas/kis_projection_backend.cpp
     canvas/kis_update_info.cpp
     canvas/kis_image_patch.cpp
     canvas/kis_image_pyramid.cpp
     canvas/kis_infinity_manager.cpp
     canvas/kis_change_guides_command.cpp
     canvas/kis_guides_decoration.cpp
     canvas/kis_guides_manager.cpp
     canvas/kis_guides_config.cpp
     canvas/kis_snap_config.cpp
     canvas/kis_snap_line_strategy.cpp
     canvas/KisSnapPointStrategy.cpp
     dialogs/kis_about_application.cpp
     dialogs/kis_dlg_adj_layer_props.cc
     dialogs/kis_dlg_adjustment_layer.cc
     dialogs/kis_dlg_filter.cpp
     dialogs/kis_dlg_generator_layer.cpp
     dialogs/kis_dlg_file_layer.cpp
     dialogs/kis_dlg_filter.cpp
     dialogs/kis_dlg_stroke_selection_properties.cpp
     dialogs/kis_dlg_image_properties.cc
     dialogs/kis_dlg_layer_properties.cc
     dialogs/kis_dlg_preferences.cc
     dialogs/slider_and_spin_box_sync.cpp
     dialogs/kis_dlg_blacklist_cleanup.cpp
     dialogs/kis_dlg_layer_style.cpp
     dialogs/kis_dlg_png_import.cpp
     dialogs/kis_dlg_import_image_sequence.cpp
     dialogs/kis_delayed_save_dialog.cpp
     dialogs/kis_dlg_internal_color_selector.cpp
     dialogs/KisSessionManagerDialog.cpp
     dialogs/KisNewWindowLayoutDialog.cpp
     flake/kis_node_dummies_graph.cpp
     flake/kis_dummies_facade_base.cpp
     flake/kis_dummies_facade.cpp
     flake/kis_node_shapes_graph.cpp
     flake/kis_node_shape.cpp
     flake/kis_shape_controller.cpp
     flake/kis_shape_layer.cc
     flake/kis_shape_layer_canvas.cpp
     flake/kis_shape_selection.cpp
     flake/kis_shape_selection_canvas.cpp
     flake/kis_shape_selection_model.cpp
     flake/kis_take_all_shapes_command.cpp
     brushhud/kis_uniform_paintop_property_widget.cpp
     brushhud/kis_brush_hud.cpp
     brushhud/kis_round_hud_button.cpp
     brushhud/kis_dlg_brush_hud_config.cpp
     brushhud/kis_brush_hud_properties_list.cpp
     brushhud/kis_brush_hud_properties_config.cpp
     kis_aspect_ratio_locker.cpp
     kis_autogradient.cc
     kis_bookmarked_configurations_editor.cc
     kis_bookmarked_configurations_model.cc
     kis_bookmarked_filter_configurations_model.cc
     kis_base_option.cpp
     kis_canvas_resource_provider.cpp
     kis_derived_resources.cpp
     kis_categories_mapper.cpp
     kis_categorized_list_model.cpp
     kis_categorized_item_delegate.cpp
     kis_clipboard.cc
     kis_config.cc
     kis_config_notifier.cpp
     kis_control_frame.cpp
     kis_composite_ops_model.cc
     kis_paint_ops_model.cpp
     kis_cursor.cc
     kis_cursor_cache.cpp
     kis_custom_pattern.cc
     kis_file_layer.cpp
     kis_change_file_layer_command.h
     kis_safe_document_loader.cpp
     kis_splash_screen.cpp
     kis_filter_manager.cc
     kis_filters_model.cc
     kis_histogram_view.cc
     KisImageBarrierLockerWithFeedback.cpp
     kis_image_manager.cc
     kis_image_view_converter.cpp
     kis_import_catcher.cc
     kis_layer_manager.cc
     kis_mask_manager.cc
     kis_mimedata.cpp
     kis_node_commands_adapter.cpp
     kis_node_manager.cpp
     kis_node_juggler_compressed.cpp
     kis_node_selection_adapter.cpp
     kis_node_insertion_adapter.cpp
     kis_node_model.cpp
     kis_node_filter_proxy_model.cpp
     kis_model_index_converter_base.cpp
     kis_model_index_converter.cpp
     kis_model_index_converter_show_all.cpp
     kis_painting_assistant.cc
     kis_painting_assistants_decoration.cpp
     KisDecorationsManager.cpp
     kis_paintop_box.cc
     kis_paintop_option.cpp
     kis_paintop_options_model.cpp
     kis_paintop_settings_widget.cpp
     kis_popup_palette.cpp
     kis_png_converter.cpp
     kis_preference_set_registry.cpp
-    kis_script_manager.cpp
     kis_resource_server_provider.cpp
     KisSelectedShapesProxy.cpp
     kis_selection_decoration.cc
     kis_selection_manager.cc
     kis_statusbar.cc
     kis_zoom_manager.cc
     kis_favorite_resource_manager.cpp
     kis_workspace_resource.cpp
     kis_action.cpp
     kis_action_manager.cpp
-    kis_view_plugin.cpp
+    KisActionPlugin.cpp
     kis_canvas_controls_manager.cpp
     kis_tooltip_manager.cpp
     kis_multinode_property.cpp
     kis_stopgradient_editor.cpp
     kisexiv2/kis_exif_io.cpp
     kisexiv2/kis_exiv2.cpp
     kisexiv2/kis_iptc_io.cpp
     kisexiv2/kis_xmp_io.cpp
     opengl/kis_opengl.cpp
     opengl/kis_opengl_canvas2.cpp
     opengl/kis_opengl_canvas_debugger.cpp
     opengl/kis_opengl_image_textures.cpp
     opengl/kis_texture_tile.cpp
     opengl/kis_opengl_shader_loader.cpp
     opengl/kis_texture_tile_info_pool.cpp
     kis_fps_decoration.cpp
     recorder/kis_node_query_path_editor.cc
     recorder/kis_recorded_action_creator.cc
     recorder/kis_recorded_action_creator_factory.cc
     recorder/kis_recorded_action_creator_factory_registry.cc
     recorder/kis_recorded_action_editor_factory.cc
     recorder/kis_recorded_action_editor_factory_registry.cc
     recorder/kis_recorded_filter_action_editor.cc
     recorder/kis_recorded_filter_action_creator.cpp
     recorder/kis_recorded_paint_action_editor.cc
     tool/kis_selection_tool_helper.cpp
     tool/kis_selection_tool_config_widget_helper.cpp
     tool/kis_rectangle_constraint_widget.cpp
     tool/kis_shape_tool_helper.cpp
     tool/kis_tool.cc
     tool/kis_delegated_tool_policies.cpp
     tool/kis_tool_freehand.cc
     tool/kis_speed_smoother.cpp
     tool/kis_painting_information_builder.cpp
     tool/kis_stabilized_events_sampler.cpp
     tool/kis_tool_freehand_helper.cpp
     tool/kis_tool_multihand_helper.cpp
     tool/kis_figure_painting_tool_helper.cpp
     tool/kis_recording_adapter.cpp
     tool/kis_tool_paint.cc
     tool/kis_tool_shape.cc
     tool/kis_tool_ellipse_base.cpp
     tool/kis_tool_rectangle_base.cpp
     tool/kis_tool_polyline_base.cpp
     tool/kis_tool_utils.cpp
     tool/kis_resources_snapshot.cpp
     tool/kis_smoothing_options.cpp
     tool/KisStabilizerDelayedPaintHelper.cpp
     tool/KisStrokeSpeedMonitor.cpp
     tool/strokes/freehand_stroke.cpp
     tool/strokes/KisStrokeEfficiencyMeasurer.cpp
     tool/strokes/kis_painter_based_stroke_strategy.cpp
     tool/strokes/kis_filter_stroke_strategy.cpp
     tool/strokes/kis_color_picker_stroke_strategy.cpp
     tool/strokes/KisFreehandStrokeInfo.cpp
     tool/strokes/KisMaskedFreehandStrokePainter.cpp
     tool/strokes/KisMaskingBrushRenderer.cpp
     tool/strokes/KisMaskingBrushCompositeOpFactory.cpp
 
     widgets/kis_cmb_composite.cc
     widgets/kis_cmb_contour.cpp
     widgets/kis_cmb_gradient.cpp
     widgets/kis_paintop_list_widget.cpp
     widgets/kis_cmb_idlist.cc
     widgets/kis_color_space_selector.cc
     widgets/kis_advanced_color_space_selector.cc
     widgets/kis_cie_tongue_widget.cpp
     widgets/kis_tone_curve_widget.cpp
     widgets/kis_curve_widget.cpp
     widgets/kis_custom_image_widget.cc
     widgets/kis_image_from_clipboard_widget.cpp
     widgets/kis_double_widget.cc
     widgets/kis_filter_selector_widget.cc
     widgets/kis_gradient_chooser.cc
     widgets/kis_gradient_slider_widget.cc
     widgets/kis_gradient_slider.cpp
     widgets/kis_iconwidget.cc
     widgets/kis_mask_widgets.cpp
     widgets/kis_meta_data_merge_strategy_chooser_widget.cc
     widgets/kis_multi_bool_filter_widget.cc
     widgets/kis_multi_double_filter_widget.cc
     widgets/kis_multi_integer_filter_widget.cc
     widgets/kis_multipliers_double_slider_spinbox.cpp
     widgets/kis_paintop_presets_popup.cpp
     widgets/kis_tool_options_popup.cpp
     widgets/kis_paintop_presets_chooser_popup.cpp
     widgets/kis_paintop_presets_save.cpp
     widgets/kis_paintop_preset_icon_library.cpp
     widgets/kis_pattern_chooser.cc
 
     widgets/kis_popup_button.cc
     widgets/kis_preset_chooser.cpp
     widgets/kis_progress_widget.cpp
     widgets/kis_selection_options.cc
     widgets/kis_scratch_pad.cpp
     widgets/kis_scratch_pad_event_filter.cpp
     widgets/kis_preset_selector_strip.cpp
     widgets/kis_slider_spin_box.cpp
     widgets/KisSelectionPropertySlider.cpp
     widgets/kis_size_group.cpp
     widgets/kis_size_group_p.cpp
     widgets/kis_wdg_generator.cpp
     widgets/kis_workspace_chooser.cpp
     widgets/kis_categorized_list_view.cpp
     widgets/kis_widget_chooser.cpp
     widgets/kis_tool_button.cpp
     widgets/kis_floating_message.cpp
     widgets/kis_lod_availability_widget.cpp
     widgets/kis_color_label_selector_widget.cpp
     widgets/kis_color_filter_combo.cpp
     widgets/kis_elided_label.cpp
     widgets/kis_stopgradient_slider_widget.cpp
     widgets/kis_spinbox_color_selector.cpp
     widgets/kis_screen_color_picker.cpp
     widgets/kis_preset_live_preview_view.cpp
     widgets/KoDualColorButton.cpp
     widgets/kis_color_input.cpp
     widgets/kis_color_button.cpp
     widgets/KisVisualColorSelector.cpp
     widgets/KisVisualColorSelectorShape.cpp
     widgets/KisVisualEllipticalSelectorShape.cpp
     widgets/KisVisualRectangleSelectorShape.cpp
     widgets/KisVisualTriangleSelectorShape.cpp
     widgets/KoStrokeConfigWidget.cpp
     widgets/KoFillConfigWidget.cpp
 
     widgets/KisLayoutSelector.cpp
 
 
     utils/kis_document_aware_spin_box_unit_manager.cpp
 
     input/kis_input_manager.cpp
     input/kis_input_manager_p.cpp
     input/kis_extended_modifiers_mapper.cpp
     input/kis_abstract_input_action.cpp
     input/kis_tool_invocation_action.cpp
     input/kis_pan_action.cpp
     input/kis_alternate_invocation_action.cpp
     input/kis_rotate_canvas_action.cpp
     input/kis_zoom_action.cpp
     input/kis_change_frame_action.cpp
     input/kis_gamma_exposure_action.cpp
     input/kis_show_palette_action.cpp
     input/kis_change_primary_setting_action.cpp
     input/kis_abstract_shortcut.cpp
     input/kis_native_gesture_shortcut.cpp
     input/kis_single_action_shortcut.cpp
     input/kis_stroke_shortcut.cpp
     input/kis_shortcut_matcher.cpp
     input/kis_select_layer_action.cpp
     input/KisQtWidgetsTweaker.cpp
     input/KisInputActionGroup.cpp
 
     operations/kis_operation.cpp
     operations/kis_operation_configuration.cpp
     operations/kis_operation_registry.cpp
     operations/kis_operation_ui_factory.cpp
     operations/kis_operation_ui_widget.cpp
     operations/kis_filter_selection_operation.cpp
     actions/kis_selection_action_factories.cpp
     actions/KisPasteActionFactory.cpp
     input/kis_touch_shortcut.cpp
     kis_document_undo_store.cpp
     kis_transaction_based_command.cpp
     kis_gui_context_command.cpp
     kis_gui_context_command_p.cpp
     input/kis_tablet_debugger.cpp
     input/kis_input_profile_manager.cpp
     input/kis_input_profile.cpp
     input/kis_shortcut_configuration.cpp
     input/config/kis_input_configuration_page.cpp
     input/config/kis_edit_profiles_dialog.cpp
     input/config/kis_input_profile_model.cpp
     input/config/kis_input_configuration_page_item.cpp
     input/config/kis_action_shortcuts_model.cpp
     input/config/kis_input_type_delegate.cpp
     input/config/kis_input_mode_delegate.cpp
     input/config/kis_input_button.cpp
     input/config/kis_input_editor_delegate.cpp
     input/config/kis_mouse_input_editor.cpp
     input/config/kis_wheel_input_editor.cpp
     input/config/kis_key_input_editor.cpp
     processing/fill_processing_visitor.cpp
     kis_asl_layer_style_serializer.cpp
     kis_psd_layer_style_resource.cpp
     canvas/kis_mirror_axis.cpp
 
     kis_abstract_perspective_grid.cpp
     
     KisApplication.cpp
     KisAutoSaveRecoveryDialog.cpp
     KisDetailsPane.cpp
     KisDocument.cpp
     KisNodeDelegate.cpp
     kis_node_view_visibility_delegate.cpp
     KisNodeToolTip.cpp
     KisNodeView.cpp
     kis_node_view_color_scheme.cpp
     KisImportExportFilter.cpp
     KisFilterEntry.cpp
     KisImportExportManager.cpp
     KisImportExportUtils.cpp
     kis_async_action_feedback.cpp
     KisMainWindow.cpp
     KisOpenPane.cpp
     KisPart.cpp
     KisPrintJob.cpp
     KisTemplate.cpp
     KisTemplateCreateDia.cpp
     KisTemplateGroup.cpp
     KisTemplates.cpp
     KisTemplatesPane.cpp
     KisTemplateTree.cpp
     KisUndoStackAction.cpp
     KisView.cpp
 
     thememanager.cpp
 
     kis_mainwindow_observer.cpp
     KisViewManager.cpp
     kis_mirror_manager.cpp
 
     qtlockedfile/qtlockedfile.cpp
 
     qtsingleapplication/qtlocalpeer.cpp
     qtsingleapplication/qtsingleapplication.cpp
 
     KisResourceBundle.cpp
     KisResourceBundleManifest.cpp
 
     kis_md5_generator.cpp
     KisApplicationArguments.cpp
 
     KisNetworkAccessManager.cpp
     KisMultiFeedRSSModel.cpp
     KisRemoteFileFetcher.cpp
 
     KisPaletteModel.cpp
     kis_palette_delegate.cpp
     kis_palette_view.cpp
     KisColorsetChooser.cpp
     KisSaveGroupVisitor.cpp
     KisWindowLayoutResource.cpp
     KisWindowLayoutManager.cpp
     KisSessionResource.cpp
 
     KisReferenceImagesDecoration.cpp
     KisReferenceImage.cpp
     flake/KisReferenceImagesLayer.cpp
     flake/KisReferenceImagesLayer.h
 )
 
 if(WIN32)
     set(kritaui_LIB_SRCS
         ${kritaui_LIB_SRCS}
         input/kis_tablet_event.cpp
         input/wintab/kis_tablet_support_win.cpp
         input/wintab/kis_screen_size_choice_dialog.cpp
         qtlockedfile/qtlockedfile_win.cpp
         input/wintab/kis_tablet_support_win8.cpp
         opengl/kis_opengl_win.cpp
         )
 endif()
 
     set(kritaui_LIB_SRCS
         ${kritaui_LIB_SRCS}
         kis_animation_frame_cache.cpp
         kis_animation_cache_populator.cpp
         KisAsyncAnimationRendererBase.cpp
         KisAsyncAnimationCacheRenderer.cpp
         KisAsyncAnimationFramesSavingRenderer.cpp
         dialogs/KisAsyncAnimationRenderDialogBase.cpp
         dialogs/KisAsyncAnimationCacheRenderDialog.cpp
         dialogs/KisAsyncAnimationFramesSaveDialog.cpp
         canvas/kis_animation_player.cpp
         kis_animation_importer.cpp
         KisSyncedAudioPlayback.cpp
     )
 
 if(UNIX)
     set(kritaui_LIB_SRCS
         ${kritaui_LIB_SRCS}
         input/kis_tablet_event.cpp
         input/wintab/kis_tablet_support.cpp
         qtlockedfile/qtlockedfile_unix.cpp
         )
     if(NOT APPLE)
         set(kritaui_LIB_SRCS
             ${kritaui_LIB_SRCS}
             input/wintab/qxcbconnection_xi2.cpp
             input/wintab/qxcbconnection.cpp
             input/wintab/kis_xi2_event_filter.cpp
             )
     endif()
 endif()
 
 if(APPLE)
     set(kritaui_LIB_SRCS
         ${kritaui_LIB_SRCS}
         osx.mm
     )
 endif()
 
 ki18n_wrap_ui(kritaui_LIB_SRCS
     widgets/KoFillConfigWidget.ui
     widgets/KoStrokeConfigWidget.ui
     forms/wdgdlgpngimport.ui
     forms/wdgfullscreensettings.ui
     forms/wdgautogradient.ui
     forms/wdggeneralsettings.ui
     forms/wdgperformancesettings.ui
     forms/wdggenerators.ui
     forms/wdgbookmarkedconfigurationseditor.ui
     forms/wdgapplyprofile.ui
     forms/wdgcustompattern.ui
     forms/wdglayerproperties.ui
     forms/wdgcolorsettings.ui
     forms/wdgtabletsettings.ui
     forms/wdgcolorspaceselector.ui
     forms/wdgcolorspaceselectoradvanced.ui
     forms/wdgdisplaysettings.ui
     forms/kis_previewwidgetbase.ui
     forms/kis_matrix_widget.ui
     forms/wdgselectionoptions.ui
     forms/wdggeometryoptions.ui
     forms/wdgnewimage.ui
     forms/wdgimageproperties.ui
     forms/wdgmaskfromselection.ui
     forms/wdgmasksource.ui
     forms/wdgfilterdialog.ui
     forms/wdgmetadatamergestrategychooser.ui
     forms/wdgpaintoppresets.ui
     forms/wdgpaintopsettings.ui
     forms/wdgdlggeneratorlayer.ui
     forms/wdgdlgfilelayer.ui
     forms/wdgfilterselector.ui
     forms/wdgfilternodecreation.ui
     forms/wdgpaintactioneditor.ui
     forms/wdgmultipliersdoublesliderspinbox.ui
     forms/wdgnodequerypatheditor.ui
     forms/wdgpresetselectorstrip.ui
     forms/wdgsavebrushpreset.ui
     forms/wdgpreseticonlibrary.ui
     forms/wdgdlgblacklistcleanup.ui
     forms/wdgrectangleconstraints.ui
     forms/wdgimportimagesequence.ui
     forms/wdgstrokeselectionproperties.ui
     forms/KisDetailsPaneBase.ui
     forms/KisOpenPaneBase.ui
     forms/wdgstopgradienteditor.ui
     forms/wdgsessionmanager.ui
     forms/wdgnewwindowlayout.ui
     brushhud/kis_dlg_brush_hud_config.ui
     forms/wdgdlginternalcolorselector.ui
     dialogs/kis_delayed_save_dialog.ui
     input/config/kis_input_configuration_page.ui
     input/config/kis_edit_profiles_dialog.ui
     input/config/kis_input_configuration_page_item.ui
     input/config/kis_mouse_input_editor.ui
     input/config/kis_wheel_input_editor.ui
     input/config/kis_key_input_editor.ui
 
     layerstyles/wdgBevelAndEmboss.ui
     layerstyles/wdgblendingoptions.ui
     layerstyles/WdgColorOverlay.ui
     layerstyles/wdgContour.ui
     layerstyles/wdgdropshadow.ui
     layerstyles/WdgGradientOverlay.ui
     layerstyles/wdgInnerGlow.ui
     layerstyles/wdglayerstyles.ui
     layerstyles/WdgPatternOverlay.ui
     layerstyles/WdgSatin.ui
     layerstyles/WdgStroke.ui
     layerstyles/wdgstylesselector.ui
     layerstyles/wdgTexture.ui
 
     wdgsplash.ui
     input/wintab/kis_screen_size_choice_dialog.ui
 
 )
 
 
 QT5_WRAP_CPP(kritaui_HEADERS_MOC KisNodePropertyAction_p.h)
 
 add_library(kritaui SHARED ${kritaui_HEADERS_MOC} ${kritaui_LIB_SRCS} )
 generate_export_header(kritaui BASE_NAME kritaui)
 
 target_link_libraries(kritaui KF5::CoreAddons KF5::Completion KF5::I18n KF5::ItemViews Qt5::Network
                       kritaimpex kritacolor kritaimage kritalibbrush kritawidgets kritawidgetutils ${PNG_LIBRARIES} ${EXIV2_LIBRARIES}
 )
 
 if (HAVE_QT_MULTIMEDIA)
     target_link_libraries(kritaui Qt5::Multimedia)
 endif()
 
 if (HAVE_KIO)
     target_link_libraries(kritaui KF5::KIOCore)
 endif() 
 
 if (NOT WIN32 AND NOT APPLE)
   target_link_libraries(kritaui ${X11_X11_LIB}
                                 ${X11_Xinput_LIB}
                                 ${XCB_LIBRARIES})
 endif()
 
 if(APPLE)
     target_link_libraries(kritaui ${FOUNDATION_LIBRARY})
     target_link_libraries(kritaui ${APPKIT_LIBRARY})
 endif ()
 
 
 target_link_libraries(kritaui ${OPENEXR_LIBRARIES})
 
 # Add VSync disable workaround
 if(NOT WIN32 AND NOT APPLE)
     target_link_libraries(kritaui ${CMAKE_DL_LIBS} Qt5::X11Extras)
 endif()
 
 if(X11_FOUND)
     target_link_libraries(kritaui Qt5::X11Extras ${X11_LIBRARIES})
 endif()
 
 target_include_directories(kritaui
     PUBLIC
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/canvas>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/flake>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/ora>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/tool>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/utils>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/widgets>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/input/wintab>
 )
 
 set_target_properties(kritaui
     PROPERTIES VERSION ${GENERIC_KRITA_LIB_VERSION} SOVERSION ${GENERIC_KRITA_LIB_SOVERSION}
 )
 install(TARGETS kritaui  ${INSTALL_TARGETS_DEFAULT_ARGS})
 
 
 if (APPLE)
     install(FILES osx.stylesheet DESTINATION ${DATA_INSTALL_DIR}/krita)
 endif ()
diff --git a/libs/ui/kis_view_plugin.cpp b/libs/ui/KisActionPlugin.cpp
similarity index 51%
rename from libs/ui/kis_view_plugin.cpp
rename to libs/ui/KisActionPlugin.cpp
index 3351391c30..3968b9ffe1 100644
--- a/libs/ui/kis_view_plugin.cpp
+++ b/libs/ui/KisActionPlugin.cpp
@@ -1,63 +1,68 @@
 /*
  *  Copyright (c) 2013 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 
-#include "kis_view_plugin.h"
+#include "KisActionPlugin.h"
 #include "KisViewManager.h"
 #include "kis_action_manager.h"
 #include "operations/kis_operation.h"
 
-KisViewPlugin::KisViewPlugin(QObject* parent)
+KisActionPlugin::KisActionPlugin(QObject* parent)
     : QObject(parent)
 {
-    m_view = qobject_cast<KisViewManager*>(parent);
-    Q_ASSERT(m_view);
+    m_viewManager = qobject_cast<KisViewManager*>(parent);
+    Q_ASSERT(m_viewManager);
 }
 
-KisViewPlugin::~KisViewPlugin()
+KisActionPlugin::~KisActionPlugin()
 {
 }
 
-void KisViewPlugin::addAction(const QString& name, KisAction* action)
+void KisActionPlugin::addAction(const QString& name, KisAction* action)
 {
-    if (m_view) {
-        m_view->actionManager()->addAction(name, action);
+    if (m_viewManager) {
+        m_viewManager->actionManager()->addAction(name, action);
     }
 }
 
-KisAction* KisViewPlugin::createAction(const QString& name)
+KisAction* KisActionPlugin::createAction(const QString& name)
 {
-  if (m_view) {
-    return m_view->actionManager()->createAction(name);
+  if (m_viewManager) {
+    return m_viewManager->actionManager()->createAction(name);
   }
   return 0;
 }
 
-void KisViewPlugin::addUIFactory(KisOperationUIFactory* factory)
+void KisActionPlugin::addUIFactory(KisOperationUIFactory* factory)
 {
-    if (m_view) {
-        m_view->actionManager()->registerOperationUIFactory(factory);
+    if (m_viewManager) {
+        m_viewManager->actionManager()->registerOperationUIFactory(factory);
     }
 }
 
-void KisViewPlugin::addOperation(KisOperation* operation)
+void KisActionPlugin::addOperation(KisOperation* operation)
 {
-    if (m_view) {
-        m_view->actionManager()->registerOperation(operation);
+    if (m_viewManager) {
+        m_viewManager->actionManager()->registerOperation(operation);
     }
 }
+
+QPointer<KisViewManager> KisActionPlugin::viewManager() const
+{
+    return m_viewManager;
+}
diff --git a/libs/ui/kis_view_plugin.h b/libs/ui/KisActionPlugin.h
similarity index 70%
rename from libs/ui/kis_view_plugin.h
rename to libs/ui/KisActionPlugin.h
index bdaa6041c8..43e551bc6d 100644
--- a/libs/ui/kis_view_plugin.h
+++ b/libs/ui/KisActionPlugin.h
@@ -1,60 +1,63 @@
 /*
  *  Copyright (c) 2013 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 
 #ifndef KIS_VIEW_PLUGIN_H
 #define KIS_VIEW_PLUGIN_H
 
 #include <kritaui_export.h>
 #include <QObject>
 #include <QPointer>
 
 class KisOperation;
 class KisOperationUIFactory;
 class KisAction;
 class KisViewManager;
 
 /**
- *  KisViewPlugin is the base for plugins which add actions to the view
+ *  KisActionPlugin is the base for plugins which add actions to the main window
  */
-class KRITAUI_EXPORT KisViewPlugin : public QObject
+class KRITAUI_EXPORT KisActionPlugin : public QObject
 {
     Q_OBJECT
 public:
-    KisViewPlugin(QObject* parent = 0);
-    ~KisViewPlugin() override;
+    KisActionPlugin(QObject *parent = 0);
+    ~KisActionPlugin() override;
 
 protected:
 
    /**
     *  Registers a KisAction to the UI and action manager.
     *  @param name - title of the action in the krita4.xmlgui file
     *  @param action the action that should be added
     */
-    void addAction(const QString& name, KisAction* action);
+    void addAction(const QString& name, KisAction *action);
 
-    KisAction* createAction(const QString& name);
+    KisAction *createAction(const QString &name);
 
-    void addUIFactory(KisOperationUIFactory* factory);
+    void addUIFactory(KisOperationUIFactory *factory);
 
-    void addOperation(KisOperation* operation);
+    void addOperation(KisOperation *operation);
 
-    QPointer<KisViewManager> m_view;
+    QPointer<KisViewManager> viewManager() const;
+
+private:
+    QPointer<KisViewManager> m_viewManager;
 };
 
 #endif // KIS_VIEW_PLUGIN_H
diff --git a/libs/ui/KisMainWindow.cpp b/libs/ui/KisMainWindow.cpp
index 203675776a..82a5afcade 100644
--- a/libs/ui/KisMainWindow.cpp
+++ b/libs/ui/KisMainWindow.cpp
@@ -1,2606 +1,2609 @@
 /* This file is part of the KDE project
    Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
    Copyright (C) 2000-2006 David Faure <faure@kde.org>
    Copyright (C) 2007, 2009 Thomas zander <zander@kde.org>
    Copyright (C) 2010 Benjamin Port <port.benjamin@gmail.com>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #include "KisMainWindow.h"
 
 #include <KoConfig.h>
 
 // qt includes
 #include <QApplication>
 #include <QByteArray>
 #include <QCloseEvent>
 #include <QStandardPaths>
 #include <QDesktopServices>
 #include <QDesktopServices>
 #include <QDesktopWidget>
 #include <QDialog>
 #include <QDockWidget>
 #include <QIcon>
 #include <QInputDialog>
 #include <QLabel>
 #include <QLayout>
 #include <QMdiArea>
 #include <QMdiSubWindow>
 #include <QMutex>
 #include <QMutexLocker>
 #include <QPointer>
 #include <QPrintDialog>
 #include <QPrinter>
 #include <QPrintPreviewDialog>
 #include <QToolButton>
 #include <QSignalMapper>
 #include <QTabBar>
 #include <QMoveEvent>
 #include <QUrl>
 #include <QMessageBox>
 #include <QTemporaryFile>
 #include <QStatusBar>
 #include <QMenu>
 #include <QMenuBar>
 #include <KisMimeDatabase.h>
 #include <QMimeData>
 
 #include <kactioncollection.h>
 #include <QAction>
 #include <kactionmenu.h>
 #include <kis_debug.h>
 #include <kedittoolbar.h>
 #include <khelpmenu.h>
 #include <klocalizedstring.h>
 #include <kaboutdata.h>
 #include <kis_workspace_resource.h>
 #include <input/kis_input_manager.h>
 
 #ifdef HAVE_KIO
 #include <krecentdocument.h>
 #endif
 #include <krecentfilesaction.h>
 #include <KoResourcePaths.h>
 #include <ktoggleaction.h>
 #include <ktoolbar.h>
 #include <kmainwindow.h>
 #include <kxmlguiwindow.h>
 #include <kxmlguifactory.h>
 #include <kxmlguiclient.h>
 #include <kguiitem.h>
 #include <kwindowconfig.h>
 
 #include "KoDockFactoryBase.h"
 #include "KoDockWidgetTitleBar.h"
 #include "KoDocumentInfoDlg.h"
 #include "KoDocumentInfo.h"
 #include "KoFileDialog.h"
 #include <kis_icon.h>
 #include <KoPageLayoutDialog.h>
 #include <KoPageLayoutWidget.h>
 #include <KoToolManager.h>
 #include <KoZoomController.h>
 #include "KoToolDocker.h"
 #include <KoToolBoxFactory.h>
 #include <KoDockRegistry.h>
 #include <KoPluginLoader.h>
 #include <KoColorSpaceEngine.h>
 #include <KoUpdater.h>
 #include <KoResourceModel.h>
 
 #include <KisMimeDatabase.h>
 #include <brushengine/kis_paintop_settings.h>
 #include "dialogs/kis_about_application.h"
 #include "dialogs/kis_delayed_save_dialog.h"
 #include "dialogs/kis_dlg_preferences.h"
 #include "kis_action.h"
 #include "kis_action_manager.h"
 #include "KisApplication.h"
 #include "kis_canvas2.h"
 #include "kis_canvas_controller.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_clipboard.h"
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_custom_image_widget.h"
 #include <KisDocument.h>
 #include "kis_group_layer.h"
 #include "kis_icon_utils.h"
 #include "kis_image_from_clipboard_widget.h"
 #include "kis_image.h"
 #include <KisImportExportFilter.h>
 #include "KisImportExportManager.h"
 #include "kis_mainwindow_observer.h"
 #include "kis_memory_statistics_server.h"
 #include "kis_node.h"
 #include "KisOpenPane.h"
 #include "kis_paintop_box.h"
 #include "KisPart.h"
 #include "KisPrintJob.h"
 #include "kis_resource_server_provider.h"
 #include "kis_signal_compressor_with_param.h"
 #include "kis_statusbar.h"
 #include "KisView.h"
 #include "KisViewManager.h"
 #include "thememanager.h"
 #include "kis_animation_importer.h"
 #include "dialogs/kis_dlg_import_image_sequence.h"
 #include <KisUpdateSchedulerConfigNotifier.h>
 #include "KisWindowLayoutManager.h"
 
 #include <mutex>
 
 #ifdef Q_OS_WIN
   #include <QtPlatformHeaders/QWindowsWindowFunctions>
 #endif
 
 class ToolDockerFactory : public KoDockFactoryBase
 {
 public:
     ToolDockerFactory() : KoDockFactoryBase() { }
 
     QString id() const override {
         return "sharedtooldocker";
     }
 
     QDockWidget* createDockWidget() override {
         KoToolDocker* dockWidget = new KoToolDocker();
         dockWidget->setTabEnabled(false);
         return dockWidget;
     }
 
     DockPosition defaultDockPosition() const override {
         return DockRight;
     }
 };
 
 class Q_DECL_HIDDEN KisMainWindow::Private
 {
 public:
     Private(KisMainWindow *parent, QUuid id)
         : q(parent)
         , id(id)
         , dockWidgetMenu(new KActionMenu(i18nc("@action:inmenu", "&Dockers"), parent))
         , windowMenu(new KActionMenu(i18nc("@action:inmenu", "&Window"), parent))
         , documentMenu(new KActionMenu(i18nc("@action:inmenu", "New &View"), parent))
         , workspaceMenu(new KActionMenu(i18nc("@action:inmenu", "Wor&kspace"), parent))
         , mdiArea(new QMdiArea(parent))
         , windowMapper(new QSignalMapper(parent))
         , documentMapper(new QSignalMapper(parent))
     {
         if (id.isNull()) this->id = QUuid::createUuid();
         mdiArea->setTabsMovable(true);
         mdiArea->setActivationOrder(QMdiArea::ActivationHistoryOrder);
     }
 
     ~Private() {
         qDeleteAll(toolbarList);
     }
 
     KisMainWindow *q {0};
     QUuid id;
 
     KisViewManager *viewManager {0};
 
     QPointer<KisView> activeView;
 
     QList<QAction *> toolbarList;
 
     bool firstTime {true};
     bool windowSizeDirty {false};
     bool readOnly {false};
 
     KisAction *showDocumentInfo {0};
     KisAction *saveAction {0};
     KisAction *saveActionAs {0};
 //    KisAction *printAction;
 //    KisAction *printActionPreview;
 //    KisAction *exportPdf {0};
     KisAction *importAnimation {0};
     KisAction *closeAll {0};
 //    KisAction *reloadFile;
     KisAction *importFile {0};
     KisAction *exportFile {0};
     KisAction *undo {0};
     KisAction *redo {0};
     KisAction *newWindow {0};
     KisAction *close {0};
     KisAction *mdiCascade {0};
     KisAction *mdiTile {0};
     KisAction *mdiNextWindow {0};
     KisAction *mdiPreviousWindow {0};
     KisAction *toggleDockers {0};
     KisAction *toggleDockerTitleBars {0};
     KisAction *fullScreenMode {0};
     KisAction *showSessionManager {0};
 
     KisAction *expandingSpacers[2];
 
     KActionMenu *dockWidgetMenu;
     KActionMenu *windowMenu;
     KActionMenu *documentMenu;
     KActionMenu *workspaceMenu;
 
     KHelpMenu *helpMenu  {0};
 
     KRecentFilesAction *recentFiles {0};
     KoResourceModel *workspacemodel {0};
 
     QString lastExportLocation;
 
     QMap<QString, QDockWidget *> dockWidgetsMap;
     QByteArray dockerStateBeforeHiding;
     KoToolDocker *toolOptionsDocker {0};
 
     QCloseEvent *deferredClosingEvent {0};
 
     Digikam::ThemeManager *themeManager {0};
 
     QMdiArea *mdiArea;
     QMdiSubWindow *activeSubWindow  {0};
     QSignalMapper *windowMapper;
     QSignalMapper *documentMapper;
 
     QByteArray lastExportedFormat;
     QScopedPointer<KisSignalCompressorWithParam<int> > tabSwitchCompressor;
     QMutex savingEntryMutex;
 
     KConfigGroup windowStateConfig;
 
     QUuid workspaceBorrowedBy;
 
     KisActionManager * actionManager() {
         return viewManager->actionManager();
     }
 
     QTabBar* findTabBarHACK() {
         QObjectList objects = mdiArea->children();
         Q_FOREACH (QObject *object, objects) {
             QTabBar *bar = qobject_cast<QTabBar*>(object);
             if (bar) {
                 return bar;
             }
         }
         return 0;
     }
 };
 
 KisMainWindow::KisMainWindow(QUuid uuid)
     : KXmlGuiWindow()
     , d(new Private(this, uuid))
 {
     auto rserver = KisResourceServerProvider::instance()->workspaceServer(false);
     QSharedPointer<KoAbstractResourceServerAdapter> adapter(new KoResourceServerAdapter<KisWorkspaceResource>(rserver));
     d->workspacemodel = new KoResourceModel(adapter, this);
     connect(d->workspacemodel, &KoResourceModel::afterResourcesLayoutReset, this, [&]() { updateWindowMenu(); });
 
     KisConfig cfg;
 
     d->viewManager = new KisViewManager(this, actionCollection());
     KConfigGroup group( KSharedConfig::openConfig(), "theme");
     d->themeManager = new Digikam::ThemeManager(group.readEntry("Theme", "Krita dark"), this);
 
     d->windowStateConfig = KSharedConfig::openConfig()->group("MainWindow");
 
     setAcceptDrops(true);
     setStandardToolBarMenuEnabled(true);
     setTabPosition(Qt::AllDockWidgetAreas, QTabWidget::North);
     setDockNestingEnabled(true);
 
     qApp->setStartDragDistance(25);     // 25 px is a distance that works well for Tablet and Mouse events
 
 #ifdef Q_OS_OSX
     setUnifiedTitleAndToolBarOnMac(true);
 #endif
 
     connect(this, SIGNAL(restoringDone()), this, SLOT(forceDockTabFonts()));
     connect(this, SIGNAL(themeChanged()), d->viewManager, SLOT(updateIcons()));
     connect(KisPart::instance(), SIGNAL(documentClosed(QString)), SLOT(updateWindowMenu()));
     connect(KisPart::instance(), SIGNAL(documentOpened(QString)), SLOT(updateWindowMenu()));
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), this, SLOT(configChanged()));
 
     actionCollection()->addAssociatedWidget(this);
 
-    KoPluginLoader::instance()->load("Krita/ViewPlugin", "Type == 'Service' and ([X-Krita-Version] == 28)", KoPluginLoader::PluginsConfig(), d->viewManager);
+    KoPluginLoader::instance()->load("Krita/ViewPlugin", "Type == 'Service' and ([X-Krita-Version] == 28)", KoPluginLoader::PluginsConfig(), d->viewManager, false);
+
+    // Load the per-application plugins (Right now, only Python) We do this only once, when the first mainwindow is being created.
+    KoPluginLoader::instance()->load("Krita/ApplicationPlugin", "Type == 'Service' and ([X-Krita-Version] == 28)", KoPluginLoader::PluginsConfig(), qApp, true);
 
     KoToolBoxFactory toolBoxFactory;
     QDockWidget *toolbox = createDockWidget(&toolBoxFactory);
     toolbox->setFeatures(QDockWidget::DockWidgetMovable | QDockWidget::DockWidgetFloatable | QDockWidget::DockWidgetClosable);
 
     if (cfg.toolOptionsInDocker()) {
         ToolDockerFactory toolDockerFactory;
         d->toolOptionsDocker = qobject_cast<KoToolDocker*>(createDockWidget(&toolDockerFactory));
         d->toolOptionsDocker->toggleViewAction()->setEnabled(true);
     }
 
     QMap<QString, QAction*> dockwidgetActions;
     dockwidgetActions[toolbox->toggleViewAction()->text()] = toolbox->toggleViewAction();
     Q_FOREACH (const QString & docker, KoDockRegistry::instance()->keys()) {
         KoDockFactoryBase *factory = KoDockRegistry::instance()->value(docker);
         QDockWidget *dw = createDockWidget(factory);
         dockwidgetActions[dw->toggleViewAction()->text()] = dw->toggleViewAction();
     }
 
     if (d->toolOptionsDocker) {
         dockwidgetActions[d->toolOptionsDocker->toggleViewAction()->text()] = d->toolOptionsDocker->toggleViewAction();
     }
     connect(KoToolManager::instance(), SIGNAL(toolOptionWidgetsChanged(KoCanvasController*, QList<QPointer<QWidget> >)), this, SLOT(newOptionWidgets(KoCanvasController*, QList<QPointer<QWidget> >)));
 
     Q_FOREACH (QString title, dockwidgetActions.keys()) {
         d->dockWidgetMenu->addAction(dockwidgetActions[title]);
     }
 
 
     Q_FOREACH (QDockWidget *wdg, dockWidgets()) {
         if ((wdg->features() & QDockWidget::DockWidgetClosable) == 0) {
             wdg->setVisible(true);
         }
     }
 
     Q_FOREACH (KoCanvasObserverBase* observer, canvasObservers()) {
         observer->setObservedCanvas(0);
         KisMainwindowObserver* mainwindowObserver = dynamic_cast<KisMainwindowObserver*>(observer);
         if (mainwindowObserver) {
             mainwindowObserver->setMainWindow(d->viewManager);
         }
     }
 
     d->mdiArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     d->mdiArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     d->mdiArea->setTabPosition(QTabWidget::North);
     d->mdiArea->setTabsClosable(true);
 
     setCentralWidget(d->mdiArea);
 
     connect(d->mdiArea, SIGNAL(subWindowActivated(QMdiSubWindow*)), this, SLOT(subWindowActivated()));
     connect(d->windowMapper, SIGNAL(mapped(QWidget*)), this, SLOT(setActiveSubWindow(QWidget*)));
     connect(d->documentMapper, SIGNAL(mapped(QObject*)), this, SLOT(newView(QObject*)));
 
     createActions();
 
     setAutoSaveSettings(d->windowStateConfig, false);
 
     subWindowActivated();
     updateWindowMenu();
 
 
     if (isHelpMenuEnabled() && !d->helpMenu) {
         // workaround for KHelpMenu (or rather KAboutData::applicationData()) internally
         // not using the Q*Application metadata ATM, which results e.g. in the bugreport wizard
         // not having the app version preset
         // fixed hopefully in KF5 5.22.0, patch pending
         QGuiApplication *app = qApp;
         KAboutData aboutData(app->applicationName(), app->applicationDisplayName(), app->applicationVersion());
         aboutData.setOrganizationDomain(app->organizationDomain().toUtf8());
         d->helpMenu = new KHelpMenu(this, aboutData, false);
         // workaround-less version:
         // d->helpMenu = new KHelpMenu(this, QString()/*unused*/, false);
 
         // The difference between using KActionCollection->addAction() is that
         // these actions do not get tied to the MainWindow.  What does this all do?
         KActionCollection *actions = d->viewManager->actionCollection();
         QAction *helpContentsAction = d->helpMenu->action(KHelpMenu::menuHelpContents);
         QAction *whatsThisAction = d->helpMenu->action(KHelpMenu::menuWhatsThis);
         QAction *reportBugAction = d->helpMenu->action(KHelpMenu::menuReportBug);
         QAction *switchLanguageAction = d->helpMenu->action(KHelpMenu::menuSwitchLanguage);
         QAction *aboutAppAction = d->helpMenu->action(KHelpMenu::menuAboutApp);
         QAction *aboutKdeAction = d->helpMenu->action(KHelpMenu::menuAboutKDE);
 
         if (helpContentsAction) {
             actions->addAction(helpContentsAction->objectName(), helpContentsAction);
         }
         if (whatsThisAction) {
             actions->addAction(whatsThisAction->objectName(), whatsThisAction);
         }
         if (reportBugAction) {
             actions->addAction(reportBugAction->objectName(), reportBugAction);
         }
         if (switchLanguageAction) {
             actions->addAction(switchLanguageAction->objectName(), switchLanguageAction);
         }
         if (aboutAppAction) {
             actions->addAction(aboutAppAction->objectName(), aboutAppAction);
         }
         if (aboutKdeAction) {
             actions->addAction(aboutKdeAction->objectName(), aboutKdeAction);
         }
 
         connect(d->helpMenu, SIGNAL(showAboutApplication()), SLOT(showAboutApplication()));
     }
 
     // KDE' libs 4''s help contents action is broken outside kde, for some reason... We can handle it just as easily ourselves
     QAction *helpAction = actionCollection()->action("help_contents");
     helpAction->disconnect();
     connect(helpAction, SIGNAL(triggered()), this, SLOT(showManual()));
 
 
 #if 0
     //check for colliding shortcuts
     QSet<QKeySequence> existingShortcuts;
     Q_FOREACH (QAction* action, actionCollection()->actions()) {
         if(action->shortcut() == QKeySequence(0)) {
             continue;
         }
         dbgKrita << "shortcut " << action->text() << " " << action->shortcut();
         Q_ASSERT(!existingShortcuts.contains(action->shortcut()));
         existingShortcuts.insert(action->shortcut());
     }
 #endif
 
     configChanged();
 
     // If we have customized the toolbars, load that first
     setLocalXMLFile(KoResourcePaths::locateLocal("data", "krita4.xmlgui"));
     setXMLFile(":/kxmlgui5/krita4.xmlgui");
 
     guiFactory()->addClient(this);
 
     // Create and plug toolbar list for Settings menu
     QList<QAction *> toolbarList;
     Q_FOREACH (QWidget* it, guiFactory()->containers("ToolBar")) {
         KToolBar * toolBar = ::qobject_cast<KToolBar *>(it);
 
         if (toolBar) {
             if (toolBar->objectName() == "BrushesAndStuff") {
                 toolBar->setEnabled(false);
             }
 
             KToggleAction* act = new KToggleAction(i18n("Show %1 Toolbar", toolBar->windowTitle()), this);
             actionCollection()->addAction(toolBar->objectName().toUtf8(), act);
             act->setCheckedState(KGuiItem(i18n("Hide %1 Toolbar", toolBar->windowTitle())));
             connect(act, SIGNAL(toggled(bool)), this, SLOT(slotToolbarToggled(bool)));
             act->setChecked(!toolBar->isHidden());
             toolbarList.append(act);
         } else {
             warnUI << "Toolbar list contains a " << it->metaObject()->className() << " which is not a toolbar!";
         }
     }
     plugActionList("toolbarlist", toolbarList);
     d->toolbarList = toolbarList;
 
     applyToolBarLayout();
 
     d->viewManager->updateGUI();
     d->viewManager->updateIcons();
 
 #ifdef Q_OS_WIN
     auto w = qApp->activeWindow();
     if (w) QWindowsWindowFunctions::setHasBorderInFullScreen(w->windowHandle(), true);
 #endif
 
     QTimer::singleShot(1000, this, SLOT(checkSanity()));
 
     {
         using namespace std::placeholders; // For _1 placeholder
         std::function<void (int)> callback(
             std::bind(&KisMainWindow::switchTab, this, _1));
 
         d->tabSwitchCompressor.reset(
             new KisSignalCompressorWithParam<int>(500, callback, KisSignalCompressor::FIRST_INACTIVE));
     }
 }
 
 KisMainWindow::~KisMainWindow()
 {
 //    Q_FOREACH (QAction *ac, actionCollection()->actions()) {
 //        QAction *action = qobject_cast<QAction*>(ac);
 //        if (action) {
 //        dbgKrita << "<Action"
 //                 << "name=" << action->objectName()
 //                 << "icon=" << action->icon().name()
 //                 << "text="  << action->text().replace("&", "&amp;")
 //                 << "whatsThis="  << action->whatsThis()
 //                 << "toolTip="  << action->toolTip().replace("<html>", "").replace("</html>", "")
 //                 << "iconText="  << action->iconText().replace("&", "&amp;")
 //                 << "shortcut="  << action->shortcut(QAction::ActiveShortcut).toString()
 //                 << "defaultShortcut="  << action->shortcut(QAction::DefaultShortcut).toString()
 //                 << "isCheckable="  << QString((action->isChecked() ? "true" : "false"))
 //                 << "statusTip=" << action->statusTip()
 //                 << "/>"   ;
 //        }
 //        else {
 //            dbgKrita << "Got a QAction:" << ac->objectName();
 //        }
 
 //    }
 
     // The doc and view might still exist (this is the case when closing the window)
     KisPart::instance()->removeMainWindow(this);
 
     delete d->viewManager;
     delete d;
 
 }
 
 QUuid KisMainWindow::id() const {
     return d->id;
 }
 
 void KisMainWindow::addView(KisView *view)
 {
     if (d->activeView == view) return;
 
     if (d->activeView) {
         d->activeView->disconnect(this);
     }
 
     // register the newly created view in the input manager
     viewManager()->inputManager()->addTrackedCanvas(view->canvasBase());
 
     showView(view);
     updateCaption();
     emit restoringDone();
 
     if (d->activeView) {
         connect(d->activeView, SIGNAL(titleModified(QString,bool)), SLOT(slotDocumentTitleModified()));
         connect(d->viewManager->statusBar(), SIGNAL(memoryStatusUpdated()), this, SLOT(updateCaption()));
     }
 }
 
 void KisMainWindow::notifyChildViewDestroyed(KisView *view)
 {
     viewManager()->inputManager()->removeTrackedCanvas(view->canvasBase());
     if (view->canvasBase() == viewManager()->canvasBase()) {
         viewManager()->setCurrentView(0);
     }
 }
 
 
 void KisMainWindow::showView(KisView *imageView)
 {
     if (imageView && activeView() != imageView) {
         // XXX: find a better way to initialize this!
         imageView->setViewManager(d->viewManager);
 
         imageView->canvasBase()->setFavoriteResourceManager(d->viewManager->paintOpBox()->favoriteResourcesManager());
         imageView->slotLoadingFinished();
 
         QMdiSubWindow *subwin = d->mdiArea->addSubWindow(imageView);
         imageView->setSubWindow(subwin);
         subwin->setAttribute(Qt::WA_DeleteOnClose, true);
         connect(subwin, SIGNAL(destroyed()), SLOT(updateWindowMenu()));
 
         KisConfig cfg;
         subwin->setOption(QMdiSubWindow::RubberBandMove, cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
         subwin->setOption(QMdiSubWindow::RubberBandResize, cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
         subwin->setWindowIcon(qApp->windowIcon());
 
         /**
          * Hack alert!
          *
          * Here we explicitly request KoToolManager to emit all the tool
          * activation signals, to reinitialize the tool options docker.
          *
          * That is needed due to a design flaw we have in the
          * initialization procedure.  The tool in the KoToolManager is
          * initialized in KisView::setViewManager() calls, which
          * happens early enough. During this call the tool manager
          * requests KoCanvasControllerWidget to emit the signal to
          * update the widgets in the tool docker. *But* at that moment
          * of time the view is not yet connected to the main window,
          * because it happens in KisViewManager::setCurrentView a bit
          * later. This fact makes the widgets updating signals be lost
          * and never reach the tool docker.
          *
          * So here we just explicitly call the tool activation stub.
          */
 
         KoToolManager::instance()->initializeCurrentToolForCanvas();
 
         if (d->mdiArea->subWindowList().size() == 1) {
             imageView->showMaximized();
         }
         else {
             imageView->show();
         }
 
         // No, no, no: do not try to call this _before_ the show() has
         // been called on the view; only when that has happened is the
         // opengl context active, and very bad things happen if we tell
         // the dockers to update themselves with a view if the opengl
         // context is not active.
         setActiveView(imageView);
 
         updateWindowMenu();
         updateCaption();
     }
 }
 
 void KisMainWindow::slotPreferences()
 {
     if (KisDlgPreferences::editPreferences()) {
         KisConfigNotifier::instance()->notifyConfigChanged();
         KisConfigNotifier::instance()->notifyPixelGridModeChanged();
         KisUpdateSchedulerConfigNotifier::instance()->notifyConfigChanged();
 
         // XXX: should this be changed for the views in other windows as well?
         Q_FOREACH (QPointer<KisView> koview, KisPart::instance()->views()) {
             KisViewManager *view = qobject_cast<KisViewManager*>(koview);
             if (view) {
                 // Update the settings for all nodes -- they don't query
                 // KisConfig directly because they need the settings during
                 // compositing, and they don't connect to the config notifier
                 // because nodes are not QObjects (because only one base class
                 // can be a QObject).
                 KisNode* node = dynamic_cast<KisNode*>(view->image()->rootLayer().data());
                 node->updateSettings();
             }
 
         }
 
         d->viewManager->showHideScrollbars();
     }
 }
 
 void KisMainWindow::slotThemeChanged()
 {
     // save theme changes instantly
     KConfigGroup group( KSharedConfig::openConfig(), "theme");
     group.writeEntry("Theme", d->themeManager->currentThemeName());
 
     // reload action icons!
     Q_FOREACH (QAction *action, actionCollection()->actions()) {
         KisIconUtils::updateIcon(action);
     }
 
     emit themeChanged();
 }
 
 void KisMainWindow::updateReloadFileAction(KisDocument *doc)
 {
     Q_UNUSED(doc);
 //    d->reloadFile->setEnabled(doc && !doc->url().isEmpty());
 }
 
 void KisMainWindow::setReadWrite(bool readwrite)
 {
     d->saveAction->setEnabled(readwrite);
     d->importFile->setEnabled(readwrite);
     d->readOnly = !readwrite;
     updateCaption();
 }
 
 void KisMainWindow::addRecentURL(const QUrl &url)
 {
     // Add entry to recent documents list
     // (call coming from KisDocument because it must work with cmd line, template dlg, file/open, etc.)
     if (!url.isEmpty()) {
         bool ok = true;
         if (url.isLocalFile()) {
             QString path = url.adjusted(QUrl::StripTrailingSlash).toLocalFile();
             const QStringList tmpDirs = KoResourcePaths::resourceDirs("tmp");
             for (QStringList::ConstIterator it = tmpDirs.begin() ; ok && it != tmpDirs.end() ; ++it) {
                 if (path.contains(*it)) {
                     ok = false; // it's in the tmp resource
                 }
             }
 #ifdef HAVE_KIO
             if (ok) {
                 KRecentDocument::add(QUrl::fromLocalFile(path));
             }
 #endif
         }
 #ifdef HAVE_KIO
         else {
             KRecentDocument::add(url.adjusted(QUrl::StripTrailingSlash));
         }
 #endif
         if (ok) {
             d->recentFiles->addUrl(url);
         }
         saveRecentFiles();
 
     }
 }
 
 void KisMainWindow::saveRecentFiles()
 {
     // Save list of recent files
     KSharedConfigPtr config =  KSharedConfig::openConfig();
     d->recentFiles->saveEntries(config->group("RecentFiles"));
     config->sync();
 
     // Tell all windows to reload their list, after saving
     // Doesn't work multi-process, but it's a start
     Q_FOREACH (KisMainWindow *mw, KisPart::instance()->mainWindows()) {
         if (mw != this) {
             mw->reloadRecentFileList();
         }
     }
 }
 
 void KisMainWindow::reloadRecentFileList()
 {
     d->recentFiles->loadEntries(KSharedConfig::openConfig()->group("RecentFiles"));
 }
 
 void KisMainWindow::updateCaption()
 {
     if (!d->mdiArea->activeSubWindow()) {
         updateCaption(QString(), false);
     }
     else if (d->activeView && d->activeView->document() && d->activeView->image()){
         KisDocument *doc = d->activeView->document();
 
         QString caption(doc->caption());
         if (d->readOnly) {
             caption += " [" + i18n("Write Protected") + "] ";
         }
 
         if (doc->isRecovered()) {
             caption += " [" + i18n("Recovered") + "] ";
         }
 
 
         // new documents aren't saved yet, so we don't need to say it is modified
         // new files don't have a URL, so we are using that for the check
         if (!doc->url().isEmpty()) {
 
             if ( doc->isModified()) {
                 caption += " [" + i18n("Modified") + "] ";
             }
         }
 
         // show the file size for the document
 
 
         KisMemoryStatisticsServer::Statistics m_fileSizeStats = KisMemoryStatisticsServer::instance()->fetchMemoryStatistics(d->activeView ? d->activeView->image() : 0);
 
 
         if (m_fileSizeStats.imageSize) {
             caption += QString(" (").append( KisStatusBar::formatSize(m_fileSizeStats.imageSize)).append( ")");
         }
 
 
         d->activeView->setWindowTitle(caption);
         d->activeView->setWindowModified(doc->isModified());
 
         updateCaption(caption, doc->isModified());
 
         if (!doc->url().fileName().isEmpty())
             d->saveAction->setToolTip(i18n("Save as %1", doc->url().fileName()));
         else
             d->saveAction->setToolTip(i18n("Save"));
     }
 }
 
 void KisMainWindow::updateCaption(const QString & caption, bool mod)
 {
     dbgUI << "KisMainWindow::updateCaption(" << caption << "," << mod << ")";
 #ifdef KRITA_ALPHA
     setCaption(QString("ALPHA %1: %2").arg(KRITA_ALPHA).arg(caption), mod);
     return;
 #endif
 #ifdef KRITA_BETA
     setCaption(QString("BETA %1: %2").arg(KRITA_BETA).arg(caption), mod);
     return;
 #endif
 #ifdef KRITA_RC
     setCaption(QString("RELEASE CANDIDATE %1: %2").arg(KRITA_RC).arg(caption), mod);
     return;
 #endif
 
     setCaption(caption, mod);
 }
 
 
 KisView *KisMainWindow::activeView() const
 {
     if (d->activeView) {
         return d->activeView;
     }
     return 0;
 }
 
 bool KisMainWindow::openDocument(const QUrl &url, OpenFlags flags)
 {
     if (!QFile(url.toLocalFile()).exists()) {
         if (!flags && BatchMode) {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("The file %1 does not exist.", url.url()));
         }
         d->recentFiles->removeUrl(url); //remove the file from the recent-opened-file-list
         saveRecentFiles();
         return false;
     }
     return openDocumentInternal(url, flags);
 }
 
 bool KisMainWindow::openDocumentInternal(const QUrl &url, OpenFlags flags)
 {
     if (!url.isLocalFile()) {
         qWarning() << "KisMainWindow::openDocumentInternal. Not a local file:" << url;
         return false;
     }
 
     KisDocument *newdoc = KisPart::instance()->createDocument();
 
     if (flags & BatchMode) {
         newdoc->setFileBatchMode(true);
     }
 
     d->firstTime = true;
     connect(newdoc, SIGNAL(completed()), this, SLOT(slotLoadCompleted()));
     connect(newdoc, SIGNAL(canceled(const QString &)), this, SLOT(slotLoadCanceled(const QString &)));
 
     KisDocument::OpenFlags openFlags = KisDocument::None;
     if (flags & RecoveryFile) {
         openFlags |= KisDocument::RecoveryFile;
     }
 
     bool openRet = !(flags & Import) ? newdoc->openUrl(url, openFlags) : newdoc->importDocument(url);
 
 
     if (!openRet) {
         delete newdoc;
         return false;
     }
 
     KisPart::instance()->addDocument(newdoc);
     updateReloadFileAction(newdoc);
 
     if (!QFileInfo(url.toLocalFile()).isWritable()) {
         setReadWrite(false);
     }
     return true;
 }
 
 void KisMainWindow::showDocument(KisDocument *document) {
     Q_FOREACH(QMdiSubWindow *subwindow, d->mdiArea->subWindowList()) {
         KisView *view = qobject_cast<KisView*>(subwindow->widget());
         KIS_SAFE_ASSERT_RECOVER_NOOP(view);
 
         if (view) {
             if (view->document() == document) {
                 setActiveSubWindow(subwindow);
                 return;
             }
         }
     }
 
     addViewAndNotifyLoadingCompleted(document);
 }
 
 KisView* KisMainWindow::addViewAndNotifyLoadingCompleted(KisDocument *document)
 {
     KisView *view = KisPart::instance()->createView(document, resourceManager(), actionCollection(), this);
     addView(view);
 
     emit guiLoadingFinished();
 
     return view;
 }
 
 QStringList KisMainWindow::showOpenFileDialog(bool isImporting)
 {
     KoFileDialog dialog(this, KoFileDialog::ImportFiles, "OpenDocument");
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
     dialog.setMimeTypeFilters(KisImportExportManager::mimeFilter(KisImportExportManager::Import));
     dialog.setCaption(isImporting ? i18n("Import Images") : i18n("Open Images"));
 
     return dialog.filenames();
 }
 
 // Separate from openDocument to handle async loading (remote URLs)
 void KisMainWindow::slotLoadCompleted()
 {
     KisDocument *newdoc = qobject_cast<KisDocument*>(sender());
     if (newdoc && newdoc->image()) {
         addViewAndNotifyLoadingCompleted(newdoc);
 
         disconnect(newdoc, SIGNAL(completed()), this, SLOT(slotLoadCompleted()));
         disconnect(newdoc, SIGNAL(canceled(const QString &)), this, SLOT(slotLoadCanceled(const QString &)));
 
         emit loadCompleted();
     }
 }
 
 void KisMainWindow::slotLoadCanceled(const QString & errMsg)
 {
     dbgUI << "KisMainWindow::slotLoadCanceled";
     if (!errMsg.isEmpty())   // empty when canceled by user
         QMessageBox::critical(this, i18nc("@title:window", "Krita"), errMsg);
     // ... can't delete the document, it's the one who emitted the signal...
 
     KisDocument* doc = qobject_cast<KisDocument*>(sender());
     Q_ASSERT(doc);
     disconnect(doc, SIGNAL(completed()), this, SLOT(slotLoadCompleted()));
     disconnect(doc, SIGNAL(canceled(const QString &)), this, SLOT(slotLoadCanceled(const QString &)));
 }
 
 void KisMainWindow::slotSaveCanceled(const QString &errMsg)
 {
     dbgUI << "KisMainWindow::slotSaveCanceled";
     if (!errMsg.isEmpty())   // empty when canceled by user
         QMessageBox::critical(this, i18nc("@title:window", "Krita"), errMsg);
     slotSaveCompleted();
 }
 
 void KisMainWindow::slotSaveCompleted()
 {
     dbgUI << "KisMainWindow::slotSaveCompleted";
     KisDocument* doc = qobject_cast<KisDocument*>(sender());
     Q_ASSERT(doc);
     disconnect(doc, SIGNAL(completed()), this, SLOT(slotSaveCompleted()));
     disconnect(doc, SIGNAL(canceled(const QString &)), this, SLOT(slotSaveCanceled(const QString &)));
 
     if (d->deferredClosingEvent) {
         KXmlGuiWindow::closeEvent(d->deferredClosingEvent);
     }
 }
 
 bool KisMainWindow::hackIsSaving() const
 {
     StdLockableWrapper<QMutex> wrapper(&d->savingEntryMutex);
     std::unique_lock<StdLockableWrapper<QMutex>> l(wrapper, std::try_to_lock);
     return !l.owns_lock();
 }
 
 bool KisMainWindow::saveDocument(KisDocument *document, bool saveas, bool isExporting)
 {
     if (!document) {
         return true;
     }
 
     /**
      * Make sure that we cannot enter this method twice!
      *
      * The lower level functions may call processEvents() so
      * double-entry is quite possible to achieve. Here we try to lock
      * the mutex, and if it is failed, just cancel saving.
      */
     StdLockableWrapper<QMutex> wrapper(&d->savingEntryMutex);
     std::unique_lock<StdLockableWrapper<QMutex>> l(wrapper, std::try_to_lock);
     if (!l.owns_lock()) return false;
 
     // no busy wait for saving because it is dangerous!
     KisDelayedSaveDialog dlg(document->image(), KisDelayedSaveDialog::SaveDialog, 0, this);
     dlg.blockIfImageIsBusy();
 
     if (dlg.result() == KisDelayedSaveDialog::Rejected) {
         return false;
     }
     else if (dlg.result() == KisDelayedSaveDialog::Ignored) {
         QMessageBox::critical(0,
                               i18nc("@title:window", "Krita"),
                               i18n("You are saving a file while the image is "
                                    "still rendering. The saved file may be "
                                    "incomplete or corrupted.\n\n"
                                    "Please select a location where the original "
                                    "file will not be overridden!"));
 
 
         saveas = true;
     }
 
     if (document->isRecovered()) {
         saveas = true;
     }
 
     bool reset_url;
 
     if (document->url().isEmpty()) {
         reset_url = true;
         saveas = true;
     }
     else {
         reset_url = false;
     }
 
     connect(document, SIGNAL(completed()), this, SLOT(slotSaveCompleted()));
     connect(document, SIGNAL(canceled(const QString &)), this, SLOT(slotSaveCanceled(const QString &)));
 
     QUrl oldURL = document->url();
     QString oldFile = document->localFilePath();
 
     QByteArray nativeFormat = document->nativeFormatMimeType();
     QByteArray oldMimeFormat = document->mimeType();
 
     QUrl suggestedURL = document->url();
 
     QStringList mimeFilter = KisImportExportManager::mimeFilter(KisImportExportManager::Export);
 
     mimeFilter = KisImportExportManager::mimeFilter(KisImportExportManager::Export);
     if (!mimeFilter.contains(oldMimeFormat)) {
         dbgUI << "KisMainWindow::saveDocument no export filter for" << oldMimeFormat;
 
         // --- don't setOutputMimeType in case the user cancels the Save As
         // dialog and then tries to just plain Save ---
 
         // suggest a different filename extension (yes, we fortunately don't all live in a world of magic :))
         QString suggestedFilename = QFileInfo(suggestedURL.toLocalFile()).baseName();
 
         if (!suggestedFilename.isEmpty()) {  // ".kra" looks strange for a name
             suggestedFilename = suggestedFilename + "." + KisMimeDatabase::suffixesForMimeType(KIS_MIME_TYPE).first();
             suggestedURL = suggestedURL.adjusted(QUrl::RemoveFilename);
             suggestedURL.setPath(suggestedURL.path() + suggestedFilename);
         }
 
         // force the user to choose outputMimeType
         saveas = true;
     }
 
     bool ret = false;
 
     if (document->url().isEmpty() || isExporting || saveas) {
         // if you're just File/Save As'ing to change filter options you
         // don't want to be reminded about overwriting files etc.
         bool justChangingFilterOptions = false;
 
         KoFileDialog dialog(this, KoFileDialog::SaveFile, "SaveAs");
         dialog.setCaption(isExporting ? i18n("Exporting") : i18n("Saving As"));
 
         //qDebug() << ">>>>>" << isExporting << d->lastExportLocation << d->lastExportedFormat << QString::fromLatin1(document->mimeType());
 
         if (isExporting && !d->lastExportLocation.isEmpty()) {
 
             // Use the location where we last exported to, if it's set, as the opening location for the file dialog
             QString proposedPath = QFileInfo(d->lastExportLocation).absolutePath();
             // If the document doesn't have a filename yet, use the title
             QString proposedFileName = suggestedURL.isEmpty() ? document->documentInfo()->aboutInfo("title") :  QFileInfo(suggestedURL.toLocalFile()).baseName();
             // Use the last mimetype we exported to by default
             QString proposedMimeType =  d->lastExportedFormat.isEmpty() ? "" : d->lastExportedFormat;
             QString proposedExtension = KisMimeDatabase::suffixesForMimeType(proposedMimeType).first().remove("*,");
 
             // Set the default dir: this overrides the one loaded from the config file, since we're exporting and the lastExportLocation is not empty
             dialog.setDefaultDir(proposedPath + "/" + proposedFileName + "." + proposedExtension, true);
             dialog.setMimeTypeFilters(mimeFilter, proposedMimeType);
         }
         else {
             // Get the last used location for saving
             KConfigGroup group =  KSharedConfig::openConfig()->group("File Dialogs");
             QString proposedPath = group.readEntry("SaveAs", "");
             // if that is empty, get the last used location for loading
             if (proposedPath.isEmpty()) {
                 proposedPath = group.readEntry("OpenDocument", "");
             }
             // If that is empty, too, use the Pictures location.
             if (proposedPath.isEmpty()) {
                 proposedPath = QStandardPaths::writableLocation(QStandardPaths::PicturesLocation);
             }
             // But only use that if the suggestedUrl, that is, the document's own url is empty, otherwise
             // open the location where the document currently is.
             dialog.setDefaultDir(suggestedURL.isEmpty() ? proposedPath : suggestedURL.toLocalFile(), true);
 
             // If exporting, default to all supported file types if user is exporting
             QByteArray default_mime_type = "";
             if (!isExporting) {
                 // otherwise use the document's mimetype, or if that is empty, kra, which is the savest.
                 default_mime_type = document->mimeType().isEmpty() ? nativeFormat : document->mimeType();
             }
             dialog.setMimeTypeFilters(mimeFilter, QString::fromLatin1(default_mime_type));
         }
 
         QUrl newURL = QUrl::fromUserInput(dialog.filename());
 
         if (newURL.isLocalFile()) {
             QString fn = newURL.toLocalFile();
             if (QFileInfo(fn).completeSuffix().isEmpty()) {
                 fn.append(KisMimeDatabase::suffixesForMimeType(nativeFormat).first());
                 newURL = QUrl::fromLocalFile(fn);
             }
         }
 
         if (document->documentInfo()->aboutInfo("title") == i18n("Unnamed")) {
             QString fn = newURL.toLocalFile();
             QFileInfo info(fn);
             document->documentInfo()->setAboutInfo("title", info.baseName());
         }
 
         QByteArray outputFormat = nativeFormat;
 
         QString outputFormatString = KisMimeDatabase::mimeTypeForFile(newURL.toLocalFile(), false);
         outputFormat = outputFormatString.toLatin1();
 
 
         if (!isExporting) {
             justChangingFilterOptions = (newURL == document->url()) && (outputFormat == document->mimeType());
         }
         else {
             QString path = QFileInfo(d->lastExportLocation).absolutePath();
             QString filename = QFileInfo(document->url().toLocalFile()).baseName();
             justChangingFilterOptions = (QFileInfo(newURL.toLocalFile()).absolutePath() == path)
                     && (QFileInfo(newURL.toLocalFile()).baseName() == filename)
                     && (outputFormat == d->lastExportedFormat);
         }
 
         bool bOk = true;
         if (newURL.isEmpty()) {
             bOk = false;
         }
 
         if (bOk) {
             bool wantToSave = true;
 
             // don't change this line unless you know what you're doing :)
             if (!justChangingFilterOptions) {
                 if (!document->isNativeFormat(outputFormat))
                     wantToSave = true;
             }
 
             if (wantToSave) {
                 if (!isExporting) {  // Save As
                     ret = document->saveAs(newURL, outputFormat, true);
                     if (ret) {
                         dbgUI << "Successful Save As!";
                         KisPart::instance()->addRecentURLToAllMainWindows(newURL);
                         setReadWrite(true);
                     } else {
                         dbgUI << "Failed Save As!";
                         document->setUrl(oldURL);
                         document->setLocalFilePath(oldFile);
                     }
                 }
                 else { // Export
                     ret = document->exportDocument(newURL, outputFormat);
 
                     if (ret) {
                         d->lastExportLocation = newURL.toLocalFile();
                         d->lastExportedFormat = outputFormat;
                     }
                 }
 
             }   // if (wantToSave)  {
             else
                 ret = false;
         }   // if (bOk) {
         else
             ret = false;
     } else { // saving
         // We cannot "export" into the currently
         // opened document. We are not Gimp.
         KIS_ASSERT_RECOVER_NOOP(!isExporting);
 
         // be sure document has the correct outputMimeType!
         if (document->isModified()) {
             ret = document->save(true, 0);
         }
 
         if (!ret) {
             dbgUI << "Failed Save!";
             document->setUrl(oldURL);
             document->setLocalFilePath(oldFile);
         }
     }
 
     if (ret && !isExporting) {
         document->setRecovered(false);
     }
 
     if (!ret && reset_url)
         document->resetURL(); //clean the suggested filename as the save dialog was rejected
 
     updateReloadFileAction(document);
     updateCaption();
 
     return ret;
 }
 
 void KisMainWindow::undo()
 {
     if (activeView()) {
         activeView()->undoAction()->trigger();
         d->undo->setText(activeView()->undoAction()->text());
     }
 }
 
 void KisMainWindow::redo()
 {
     if (activeView()) {
         activeView()->redoAction()->trigger();
         d->redo->setText(activeView()->redoAction()->text());
     }
 }
 
 void KisMainWindow::closeEvent(QCloseEvent *e)
 {
     if (!KisPart::instance()->closingSession()) {
         QAction *action= d->viewManager->actionCollection()->action("view_show_canvas_only");
         if ((action) && (action->isChecked())) {
             action->setChecked(false);
         }
 
         // Save session when last window is closed
         if (KisPart::instance()->mainwindowCount() == 1) {
             bool closeAllowed = KisPart::instance()->closeSession();
 
             if (!closeAllowed) {
                 e->setAccepted(false);
             }
             return;
         }
     }
 
     d->mdiArea->closeAllSubWindows();
 
     QList<QMdiSubWindow*> childrenList = d->mdiArea->subWindowList();
 
     if (childrenList.isEmpty()) {
         d->deferredClosingEvent = e;
         saveWindowState(true);
     } else {
         e->setAccepted(false);
     }
 }
 
 void KisMainWindow::saveWindowSettings()
 {
     KSharedConfigPtr config =  KSharedConfig::openConfig();
 
     if (d->windowSizeDirty ) {
         dbgUI << "KisMainWindow::saveWindowSettings";
         KConfigGroup group = d->windowStateConfig;
         KWindowConfig::saveWindowSize(windowHandle(), group);
         config->sync();
         d->windowSizeDirty = false;
     }
 
     if (!d->activeView || d->activeView->document()) {
 
         // Save toolbar position into the config file of the app, under the doc's component name
         KConfigGroup group = d->windowStateConfig;
         saveMainWindowSettings(group);
 
         // Save collapsible state of dock widgets
         for (QMap<QString, QDockWidget*>::const_iterator i = d->dockWidgetsMap.constBegin();
              i != d->dockWidgetsMap.constEnd(); ++i) {
             if (i.value()->widget()) {
                 KConfigGroup dockGroup = group.group(QString("DockWidget ") + i.key());
                 dockGroup.writeEntry("Collapsed", i.value()->widget()->isHidden());
                 dockGroup.writeEntry("Locked", i.value()->property("Locked").toBool());
                 dockGroup.writeEntry("DockArea", (int) dockWidgetArea(i.value()));
                 dockGroup.writeEntry("xPosition", (int) i.value()->widget()->x());
                 dockGroup.writeEntry("yPosition", (int) i.value()->widget()->y());
 
                 dockGroup.writeEntry("width", (int) i.value()->widget()->width());
                 dockGroup.writeEntry("height", (int) i.value()->widget()->height());
             }
         }
 
     }
 
      KSharedConfig::openConfig()->sync();
     resetAutoSaveSettings(); // Don't let KMainWindow override the good stuff we wrote down
 
 }
 
 void KisMainWindow::resizeEvent(QResizeEvent * e)
 {
     d->windowSizeDirty = true;
     KXmlGuiWindow::resizeEvent(e);
 }
 
 void KisMainWindow::setActiveView(KisView* view)
 {
     d->activeView = view;
     updateCaption();
     actionCollection()->action("edit_undo")->setText(activeView()->undoAction()->text());
     actionCollection()->action("edit_redo")->setText(activeView()->redoAction()->text());
     d->viewManager->setCurrentView(view);
 
     auto *kisPart = KisPart::instance();
     if (KisWindowLayoutManager::instance()->isShowImageInAllWindowsEnabled()) {
         Q_FOREACH(QPointer<KisMainWindow> window, kisPart->mainWindows()) {
             if (window == this) continue;
             window->showDocument(view->document());
         }
     }
 }
 
 void KisMainWindow::dragEnterEvent(QDragEnterEvent *event)
 {
     if (event->mimeData()->hasUrls() ||
         event->mimeData()->hasFormat("application/x-krita-node") ||
         event->mimeData()->hasFormat("application/x-qt-image")) {
 
         event->accept();
     }
 }
 
 void KisMainWindow::dropEvent(QDropEvent *event)
 {
     if (event->mimeData()->hasUrls() && event->mimeData()->urls().size() > 0) {
         Q_FOREACH (const QUrl &url, event->mimeData()->urls()) {
             openDocument(url, None);
         }
     }
 }
 
 void KisMainWindow::dragMoveEvent(QDragMoveEvent * event)
 {
     QTabBar *tabBar = d->findTabBarHACK();
 
     if (!tabBar && d->mdiArea->viewMode() == QMdiArea::TabbedView) {
         qWarning() << "WARNING!!! Cannot find QTabBar in the main window! Looks like Qt has changed behavior. Drag & Drop between multiple tabs might not work properly (tabs will not switch automatically)!";
     }
 
     if (tabBar && tabBar->isVisible()) {
         QPoint pos = tabBar->mapFromGlobal(mapToGlobal(event->pos()));
         if (tabBar->rect().contains(pos)) {
             const int tabIndex = tabBar->tabAt(pos);
 
             if (tabIndex >= 0 && tabBar->currentIndex() != tabIndex) {
                 d->tabSwitchCompressor->start(tabIndex);
             }
         } else if (d->tabSwitchCompressor->isActive()) {
             d->tabSwitchCompressor->stop();
         }
     }
 }
 
 void KisMainWindow::dragLeaveEvent(QDragLeaveEvent * /*event*/)
 {
     if (d->tabSwitchCompressor->isActive()) {
         d->tabSwitchCompressor->stop();
     }
 }
 
 void KisMainWindow::mouseReleaseEvent(QMouseEvent *event)
 {
     /**
      * This ensures people who do not understand that you
      * need to make a canvas first, will find the new image
      * dialog on click.
      */
     if (centralWidget()->geometry().contains(event->pos())
             && KisPart::instance()->documents().size()==0 && event->button() == Qt::LeftButton) {
         this->slotFileNew();
         event->accept();
     } else {
         event->ignore();
     }
 }
 
 void KisMainWindow::switchTab(int index)
 {
     QTabBar *tabBar = d->findTabBarHACK();
     if (!tabBar) return;
 
     tabBar->setCurrentIndex(index);
 }
 
 void KisMainWindow::slotFileNew()
 {
     const QStringList mimeFilter = KisImportExportManager::mimeFilter(KisImportExportManager::Import);
 
     KisOpenPane *startupWidget = new KisOpenPane(this, mimeFilter, QStringLiteral("templates/"));
     startupWidget->setWindowModality(Qt::WindowModal);
     startupWidget->setWindowTitle(i18n("Create new document"));
 
 
     KisConfig cfg;
 
     int w = cfg.defImageWidth();
     int h = cfg.defImageHeight();
     const double resolution = cfg.defImageResolution();
     const QString colorModel = cfg.defColorModel();
     const QString colorDepth = cfg.defaultColorDepth();
     const QString colorProfile = cfg.defColorProfile();
 
 
     CustomDocumentWidgetItem item;
     item.widget = new KisCustomImageWidget(startupWidget,
                                            w,
                                            h,
                                            resolution,
                                            colorModel,
                                            colorDepth,
                                            colorProfile,
                                            i18n("Unnamed"));
 
     item.icon = "document-new";
 
     startupWidget->addCustomDocumentWidget(item.widget, item.title, item.icon);
 
     QSize sz = KisClipboard::instance()->clipSize();
     if (sz.isValid() && sz.width() != 0 && sz.height() != 0) {
         w = sz.width();
         h = sz.height();
     }
 
     item.widget = new KisImageFromClipboard(startupWidget,
                                             w,
                                             h,
                                             resolution,
                                             colorModel,
                                             colorDepth,
                                             colorProfile,
                                             i18n("Unnamed"));
 
     item.title = i18n("Create from Clipboard");
     item.icon = "tab-new";
 
     startupWidget->addCustomDocumentWidget(item.widget, item.title, item.icon);
 
     // calls deleteLater
     connect(startupWidget, SIGNAL(documentSelected(KisDocument*)), KisPart::instance(), SLOT(startCustomDocument(KisDocument*)));
     // calls deleteLater
     connect(startupWidget, SIGNAL(openTemplate(const QUrl&)), KisPart::instance(), SLOT(openTemplate(const QUrl&)));
 
     startupWidget->exec();
 
     // Cancel calls deleteLater...
 
 }
 
 void KisMainWindow::slotImportFile()
 {
     dbgUI << "slotImportFile()";
     slotFileOpen(true);
 }
 
 
 void KisMainWindow::slotFileOpen(bool isImporting)
 {
     QStringList urls = showOpenFileDialog(isImporting);
 
     if (urls.isEmpty())
         return;
 
     Q_FOREACH (const QString& url, urls) {
 
         if (!url.isEmpty()) {
             OpenFlags flags = isImporting ? Import : None;
             bool res = openDocument(QUrl::fromLocalFile(url), flags);
             if (!res) {
                 warnKrita << "Loading" << url << "failed";
             }
         }
     }
 }
 
 void KisMainWindow::slotFileOpenRecent(const QUrl &url)
 {
     (void) openDocument(QUrl::fromLocalFile(url.toLocalFile()), None);
 }
 
 void KisMainWindow::slotFileSave()
 {
     if (saveDocument(d->activeView->document(), false, false)) {
         emit documentSaved();
     }
 }
 
 void KisMainWindow::slotFileSaveAs()
 {
     if (saveDocument(d->activeView->document(), true, false)) {
         emit documentSaved();
     }
 }
 
 void KisMainWindow::slotExportFile()
 {
     if (saveDocument(d->activeView->document(), true, true)) {
         emit documentSaved();
     }
 }
 
 void KisMainWindow::slotShowSessionManager() {
     KisPart::instance()->showSessionManager();
 }
 
 KoCanvasResourceManager *KisMainWindow::resourceManager() const
 {
     return d->viewManager->resourceProvider()->resourceManager();
 }
 
 int KisMainWindow::viewCount() const
 {
     return d->mdiArea->subWindowList().size();
 }
 
 const KConfigGroup &KisMainWindow::windowStateConfig() const
 {
     return d->windowStateConfig;
 }
 
 void KisMainWindow::saveWindowState(bool restoreNormalState)
 {
     if (restoreNormalState) {
         QAction *showCanvasOnly = d->viewManager->actionCollection()->action("view_show_canvas_only");
 
         if (showCanvasOnly && showCanvasOnly->isChecked()) {
             showCanvasOnly->setChecked(false);
         }
 
         d->windowStateConfig.writeEntry("ko_geometry", saveGeometry().toBase64());
         d->windowStateConfig.writeEntry("State", saveState().toBase64());
 
         if (!d->dockerStateBeforeHiding.isEmpty()) {
             restoreState(d->dockerStateBeforeHiding);
         }
 
         statusBar()->setVisible(true);
         menuBar()->setVisible(true);
 
         saveWindowSettings();
 
     } else {
         saveMainWindowSettings(d->windowStateConfig);
     }
 
 }
 
 bool KisMainWindow::restoreWorkspace(const QByteArray &state)
 {
     QByteArray oldState = saveState();
     const bool showTitlebars = KisConfig().showDockerTitleBars();
 
     // needed because otherwise the layout isn't correctly restored in some situations
     Q_FOREACH (QDockWidget *dock, dockWidgets()) {
         dock->hide();
         dock->titleBarWidget()->setVisible(showTitlebars);
     }
 
     bool success = KXmlGuiWindow::restoreState(state);
 
     if (!success) {
         KXmlGuiWindow::restoreState(oldState);
         Q_FOREACH (QDockWidget *dock, dockWidgets()) {
             if (dock->titleBarWidget()) {
                 dock->titleBarWidget()->setVisible(showTitlebars || dock->isFloating());
             }
         }
         return false;
     }
 
 
     Q_FOREACH (QDockWidget *dock, dockWidgets()) {
         if (dock->titleBarWidget()) {
             const bool isCollapsed = (dock->widget() && dock->widget()->isHidden()) || !dock->widget();
             dock->titleBarWidget()->setVisible(showTitlebars || (dock->isFloating() && isCollapsed));
         }
     }
 
     return success;
 }
 
 QByteArray KisMainWindow::borrowWorkspace(KisMainWindow *other)
 {
     QByteArray currentWorkspace = saveState();
 
     if (!d->workspaceBorrowedBy.isNull()) {
         if (other->id() == d->workspaceBorrowedBy) {
             // We're swapping our original workspace back
             d->workspaceBorrowedBy = QUuid();
             return currentWorkspace;
         } else {
             // Get our original workspace back before swapping with a third window
             KisMainWindow *borrower = KisPart::instance()->windowById(d->workspaceBorrowedBy);
             if (borrower) {
                 QByteArray originalLayout = borrower->borrowWorkspace(this);
                 borrower->restoreWorkspace(currentWorkspace);
 
                 d->workspaceBorrowedBy = other->id();
                 return originalLayout;
             }
         }
     }
 
     d->workspaceBorrowedBy = other->id();
     return currentWorkspace;
 }
 
 void KisMainWindow::swapWorkspaces(KisMainWindow *a, KisMainWindow *b)
 {
     QByteArray workspaceA = a->borrowWorkspace(b);
     QByteArray workspaceB = b->borrowWorkspace(a);
 
     a->restoreWorkspace(workspaceB);
     b->restoreWorkspace(workspaceA);
 }
 
 KisViewManager *KisMainWindow::viewManager() const
 {
     return d->viewManager;
 }
 
 void KisMainWindow::slotDocumentInfo()
 {
     if (!d->activeView->document())
         return;
 
     KoDocumentInfo *docInfo = d->activeView->document()->documentInfo();
 
     if (!docInfo)
         return;
 
     KoDocumentInfoDlg *dlg = d->activeView->document()->createDocumentInfoDialog(this, docInfo);
 
     if (dlg->exec()) {
         if (dlg->isDocumentSaved()) {
             d->activeView->document()->setModified(false);
         } else {
             d->activeView->document()->setModified(true);
         }
         d->activeView->document()->setTitleModified();
     }
 
     delete dlg;
 }
 
 bool KisMainWindow::slotFileCloseAll()
 {
     Q_FOREACH (QMdiSubWindow *subwin, d->mdiArea->subWindowList()) {
         if (subwin) {
             if(!subwin->close())
                 return false;
         }
     }
 
     updateCaption();
     return true;
 }
 
 void KisMainWindow::slotFileQuit()
 {
     KisPart::instance()->closeSession();
 }
 
 void KisMainWindow::slotFilePrint()
 {
     if (!activeView())
         return;
     KisPrintJob *printJob = activeView()->createPrintJob();
     if (printJob == 0)
         return;
     applyDefaultSettings(printJob->printer());
     QPrintDialog *printDialog = activeView()->createPrintDialog( printJob, this );
     if (printDialog && printDialog->exec() == QDialog::Accepted) {
         printJob->printer().setPageMargins(0.0, 0.0, 0.0, 0.0, QPrinter::Point);
         printJob->printer().setPaperSize(QSizeF(activeView()->image()->width() / (72.0 * activeView()->image()->xRes()),
                                                 activeView()->image()->height()/ (72.0 * activeView()->image()->yRes())),
                                          QPrinter::Inch);
         printJob->startPrinting(KisPrintJob::DeleteWhenDone);
     }
     else {
         delete printJob;
     }
     delete printDialog;
 }
 
 void KisMainWindow::slotFilePrintPreview()
 {
     if (!activeView())
         return;
     KisPrintJob *printJob = activeView()->createPrintJob();
     if (printJob == 0)
         return;
 
     /* Sets the startPrinting() slot to be blocking.
      The Qt print-preview dialog requires the printing to be completely blocking
      and only return when the full document has been printed.
      By default the KisPrintingDialog is non-blocking and
      multithreading, setting blocking to true will allow it to be used in the preview dialog */
     printJob->setProperty("blocking", true);
     QPrintPreviewDialog *preview = new QPrintPreviewDialog(&printJob->printer(), this);
     printJob->setParent(preview); // will take care of deleting the job
     connect(preview, SIGNAL(paintRequested(QPrinter*)), printJob, SLOT(startPrinting()));
     preview->exec();
     delete preview;
 }
 
 KisPrintJob* KisMainWindow::exportToPdf(QString pdfFileName)
 {
     if (!activeView())
         return 0;
 
     if (!activeView()->document())
         return 0;
 
     KoPageLayout pageLayout;
     pageLayout.width = 0;
     pageLayout.height = 0;
     pageLayout.topMargin = 0;
     pageLayout.bottomMargin = 0;
     pageLayout.leftMargin = 0;
     pageLayout.rightMargin = 0;
 
     if (pdfFileName.isEmpty()) {
         KConfigGroup group =  KSharedConfig::openConfig()->group("File Dialogs");
         QString defaultDir = group.readEntry("SavePdfDialog");
         if (defaultDir.isEmpty())
             defaultDir = QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation);
         QUrl startUrl = QUrl::fromLocalFile(defaultDir);
         KisDocument* pDoc = d->activeView->document();
         /** if document has a file name, take file name and replace extension with .pdf */
         if (pDoc && pDoc->url().isValid()) {
             startUrl = pDoc->url();
             QString fileName = startUrl.toLocalFile();
             fileName = fileName.replace( QRegExp( "\\.\\w{2,5}$", Qt::CaseInsensitive ), ".pdf" );
             startUrl = startUrl.adjusted(QUrl::RemoveFilename);
             startUrl.setPath(startUrl.path() +  fileName );
         }
 
         QPointer<KoPageLayoutDialog> layoutDlg(new KoPageLayoutDialog(this, pageLayout));
         layoutDlg->setWindowModality(Qt::WindowModal);
         if (layoutDlg->exec() != QDialog::Accepted || !layoutDlg) {
             delete layoutDlg;
             return 0;
         }
         pageLayout = layoutDlg->pageLayout();
         delete layoutDlg;
 
         KoFileDialog dialog(this, KoFileDialog::SaveFile, "OpenDocument");
         dialog.setCaption(i18n("Export as PDF"));
         dialog.setDefaultDir(startUrl.toLocalFile());
         dialog.setMimeTypeFilters(QStringList() << "application/pdf");
         QUrl url = QUrl::fromUserInput(dialog.filename());
 
         pdfFileName = url.toLocalFile();
         if (pdfFileName.isEmpty())
             return 0;
     }
 
     KisPrintJob *printJob = activeView()->createPrintJob();
     if (printJob == 0)
         return 0;
     if (isHidden()) {
         printJob->setProperty("noprogressdialog", true);
     }
 
     applyDefaultSettings(printJob->printer());
     // TODO for remote files we have to first save locally and then upload.
     printJob->printer().setOutputFileName(pdfFileName);
     printJob->printer().setDocName(pdfFileName);
     printJob->printer().setColorMode(QPrinter::Color);
 
     if (pageLayout.format == KoPageFormat::CustomSize) {
         printJob->printer().setPaperSize(QSizeF(pageLayout.width, pageLayout.height), QPrinter::Millimeter);
     } else {
         printJob->printer().setPaperSize(KoPageFormat::printerPageSize(pageLayout.format));
     }
 
     printJob->printer().setPageMargins(pageLayout.leftMargin, pageLayout.topMargin, pageLayout.rightMargin, pageLayout.bottomMargin, QPrinter::Millimeter);
 
     switch (pageLayout.orientation) {
     case KoPageFormat::Portrait:
         printJob->printer().setOrientation(QPrinter::Portrait);
         break;
     case KoPageFormat::Landscape:
         printJob->printer().setOrientation(QPrinter::Landscape);
         break;
     }
 
     //before printing check if the printer can handle printing
     if (!printJob->canPrint()) {
         QMessageBox::critical(this, i18nc("@title:window", "Krita"), i18n("Cannot export to the specified file"));
     }
 
     printJob->startPrinting(KisPrintJob::DeleteWhenDone);
     return printJob;
 }
 
 void KisMainWindow::importAnimation()
 {
     if (!activeView()) return;
 
     KisDocument *document = activeView()->document();
     if (!document) return;
 
     KisDlgImportImageSequence dlg(this, document);
 
     if (dlg.exec() == QDialog::Accepted) {
         QStringList files = dlg.files();
         int firstFrame = dlg.firstFrame();
         int step = dlg.step();
 
         KoUpdaterPtr updater =
             !document->fileBatchMode() ? viewManager()->createUnthreadedUpdater(i18n("Import frames")) : 0;
         KisAnimationImporter importer(document->image(), updater);
         KisImportExportFilter::ConversionStatus status = importer.import(files, firstFrame, step);
 
         if (status != KisImportExportFilter::OK && status != KisImportExportFilter::InternalError) {
             QString msg = KisImportExportFilter::conversionStatusString(status);
 
             if (!msg.isEmpty())
                 QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not finish import animation:\n%1", msg));
         }
         activeView()->canvasBase()->refetchDataFromImage();
     }
 }
 
 void KisMainWindow::slotConfigureToolbars()
 {
     saveWindowState();
     KEditToolBar edit(factory(), this);
     connect(&edit, SIGNAL(newToolBarConfig()), this, SLOT(slotNewToolbarConfig()));
     (void) edit.exec();
     applyToolBarLayout();
 }
 
 void KisMainWindow::slotNewToolbarConfig()
 {
     applyMainWindowSettings(d->windowStateConfig);
 
     KXMLGUIFactory *factory = guiFactory();
     Q_UNUSED(factory);
 
     // Check if there's an active view
     if (!d->activeView)
         return;
 
     plugActionList("toolbarlist", d->toolbarList);
     applyToolBarLayout();
 }
 
 void KisMainWindow::slotToolbarToggled(bool toggle)
 {
     //dbgUI <<"KisMainWindow::slotToolbarToggled" << sender()->name() <<" toggle=" << true;
     // The action (sender) and the toolbar have the same name
     KToolBar * bar = toolBar(sender()->objectName());
     if (bar) {
         if (toggle) {
             bar->show();
         }
         else {
             bar->hide();
         }
 
         if (d->activeView && d->activeView->document()) {
             saveWindowState();
         }
     } else
         warnUI << "slotToolbarToggled : Toolbar " << sender()->objectName() << " not found!";
 }
 
 void KisMainWindow::viewFullscreen(bool fullScreen)
 {
     KisConfig cfg;
     cfg.setFullscreenMode(fullScreen);
 
     if (fullScreen) {
         setWindowState(windowState() | Qt::WindowFullScreen);   // set
     } else {
         setWindowState(windowState() & ~Qt::WindowFullScreen);   // reset
     }
 }
 
 void KisMainWindow::setMaxRecentItems(uint _number)
 {
     d->recentFiles->setMaxItems(_number);
 }
 
 void KisMainWindow::slotReloadFile()
 {
     KisDocument* document = d->activeView->document();
     if (!document || document->url().isEmpty())
         return;
 
     if (document->isModified()) {
         bool ok = QMessageBox::question(this,
                                         i18nc("@title:window", "Krita"),
                                         i18n("You will lose all changes made since your last save\n"
                                              "Do you want to continue?"),
                                         QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes) == QMessageBox::Yes;
         if (!ok)
             return;
     }
 
     QUrl url = document->url();
 
     saveWindowSettings();
     if (!document->reload()) {
         QMessageBox::critical(this, i18nc("@title:window", "Krita"), i18n("Error: Could not reload this document"));
     }
 
     return;
 
 }
 
 QDockWidget* KisMainWindow::createDockWidget(KoDockFactoryBase* factory)
 {
     QDockWidget* dockWidget = 0;
 
     if (!d->dockWidgetsMap.contains(factory->id())) {
         dockWidget = factory->createDockWidget();
 
         // It is quite possible that a dock factory cannot create the dock; don't
         // do anything in that case.
         if (!dockWidget) {
             warnKrita << "Could not create docker for" << factory->id();
             return 0;
         }
 
         KoDockWidgetTitleBar *titleBar = dynamic_cast<KoDockWidgetTitleBar*>(dockWidget->titleBarWidget());
 
         // Check if the dock widget is supposed to be collapsible
         if (!dockWidget->titleBarWidget()) {
             titleBar = new KoDockWidgetTitleBar(dockWidget);
             dockWidget->setTitleBarWidget(titleBar);
             titleBar->setCollapsable(factory->isCollapsable());
         }
         titleBar->setFont(KoDockRegistry::dockFont());
 
         dockWidget->setObjectName(factory->id());
         dockWidget->setParent(this);
 
         if (dockWidget->widget() && dockWidget->widget()->layout())
             dockWidget->widget()->layout()->setContentsMargins(1, 1, 1, 1);
 
         Qt::DockWidgetArea side = Qt::RightDockWidgetArea;
         bool visible = true;
 
         switch (factory->defaultDockPosition()) {
         case KoDockFactoryBase::DockTornOff:
             dockWidget->setFloating(true); // position nicely?
             break;
         case KoDockFactoryBase::DockTop:
             side = Qt::TopDockWidgetArea; break;
         case KoDockFactoryBase::DockLeft:
             side = Qt::LeftDockWidgetArea; break;
         case KoDockFactoryBase::DockBottom:
             side = Qt::BottomDockWidgetArea; break;
         case KoDockFactoryBase::DockRight:
             side = Qt::RightDockWidgetArea; break;
         case KoDockFactoryBase::DockMinimized:
         default:
             side = Qt::RightDockWidgetArea;
             visible = false;
         }
 
         KConfigGroup group = d->windowStateConfig.group("DockWidget " + factory->id());
         side = static_cast<Qt::DockWidgetArea>(group.readEntry("DockArea", static_cast<int>(side)));
         if (side == Qt::NoDockWidgetArea) side = Qt::RightDockWidgetArea;
 
         addDockWidget(side, dockWidget);
         if (!visible) {
             dockWidget->hide();
         }
         bool collapsed = factory->defaultCollapsed();
 
         bool locked = false;
         group = d->windowStateConfig.group("DockWidget " + factory->id());
         collapsed = group.readEntry("Collapsed", collapsed);
         locked = group.readEntry("Locked", locked);
 
         //dbgKrita << "docker" << factory->id() << dockWidget << "collapsed" << collapsed << "locked" << locked << "titlebar" << titleBar;
 
         if (titleBar && collapsed)
             titleBar->setCollapsed(true);
 
         if (titleBar && locked)
             titleBar->setLocked(true);
 
         d->dockWidgetsMap.insert(factory->id(), dockWidget);
     }
     else {
         dockWidget = d->dockWidgetsMap[factory->id()];
     }
 
 #ifdef Q_OS_OSX
     dockWidget->setAttribute(Qt::WA_MacSmallSize, true);
 #endif
     dockWidget->setFont(KoDockRegistry::dockFont());
 
     connect(dockWidget, SIGNAL(dockLocationChanged(Qt::DockWidgetArea)), this, SLOT(forceDockTabFonts()));
 
     return dockWidget;
 }
 
 void KisMainWindow::forceDockTabFonts()
 {
     Q_FOREACH (QObject *child, children()) {
         if (child->inherits("QTabBar")) {
             ((QTabBar *)child)->setFont(KoDockRegistry::dockFont());
         }
     }
 }
 
 QList<QDockWidget*> KisMainWindow::dockWidgets() const
 {
     return d->dockWidgetsMap.values();
 }
 
 QDockWidget* KisMainWindow::dockWidget(const QString &id)
 {
     if (!d->dockWidgetsMap.contains(id)) return 0;
     return d->dockWidgetsMap[id];
 }
 
 QList<KoCanvasObserverBase*> KisMainWindow::canvasObservers() const
 {
     QList<KoCanvasObserverBase*> observers;
 
     Q_FOREACH (QDockWidget *docker, dockWidgets()) {
         KoCanvasObserverBase *observer = dynamic_cast<KoCanvasObserverBase*>(docker);
         if (observer) {
             observers << observer;
         }
         else {
             warnKrita << docker << "is not a canvas observer";
         }
     }
     return observers;
 }
 
 
 void KisMainWindow::toggleDockersVisibility(bool visible)
 {
     if (!visible) {
         d->dockerStateBeforeHiding = saveState();
 
         Q_FOREACH (QObject* widget, children()) {
             if (widget->inherits("QDockWidget")) {
                 QDockWidget* dw = static_cast<QDockWidget*>(widget);
                 if (dw->isVisible()) {
                     dw->hide();
                 }
             }
         }
     }
     else {
         restoreState(d->dockerStateBeforeHiding);
     }
 }
 
 void KisMainWindow::slotDocumentTitleModified()
 {
     updateCaption();
     updateReloadFileAction(d->activeView ? d->activeView->document() : 0);
 }
 
 
 void KisMainWindow::subWindowActivated()
 {
     bool enabled = (activeKisView() != 0);
 
     d->mdiCascade->setEnabled(enabled);
     d->mdiNextWindow->setEnabled(enabled);
     d->mdiPreviousWindow->setEnabled(enabled);
     d->mdiTile->setEnabled(enabled);
     d->close->setEnabled(enabled);
     d->closeAll->setEnabled(enabled);
 
     setActiveSubWindow(d->mdiArea->activeSubWindow());
     Q_FOREACH (QToolBar *tb, toolBars()) {
         if (tb->objectName() == "BrushesAndStuff") {
             tb->setEnabled(enabled);
         }
     }
 
     updateCaption();
     d->actionManager()->updateGUI();
 }
 
 void KisMainWindow::windowFocused()
 {
     auto *kisPart = KisPart::instance();
     auto *layoutManager = KisWindowLayoutManager::instance();
     if (!layoutManager->primaryWorkspaceFollowsFocus()) return;
 
     QUuid primary = layoutManager->primaryWindowId();
     if (primary.isNull()) return;
 
     if (d->id == primary) {
         if (!d->workspaceBorrowedBy.isNull()) {
             KisMainWindow *borrower = kisPart->windowById(d->workspaceBorrowedBy);
             if (!borrower) return;
             swapWorkspaces(this, borrower);
         }
     } else {
         if (d->workspaceBorrowedBy == primary) return;
 
         KisMainWindow *primaryWindow = kisPart->windowById(primary);
         if (!primaryWindow) return;
         swapWorkspaces(this, primaryWindow);
     }
 }
 
 void KisMainWindow::updateWindowMenu()
 {
     QMenu *menu = d->windowMenu->menu();
     menu->clear();
 
     menu->addAction(d->newWindow);
     menu->addAction(d->documentMenu);
 
     QMenu *docMenu = d->documentMenu->menu();
     docMenu->clear();
 
     Q_FOREACH (QPointer<KisDocument> doc, KisPart::instance()->documents()) {
         if (doc) {
             QString title = doc->url().toDisplayString();
             if (title.isEmpty() && doc->image()) {
                 title = doc->image()->objectName();
             }
             QAction *action = docMenu->addAction(title);
             action->setIcon(qApp->windowIcon());
             connect(action, SIGNAL(triggered()), d->documentMapper, SLOT(map()));
             d->documentMapper->setMapping(action, doc);
         }
     }
 
     menu->addAction(d->workspaceMenu);
     QMenu *workspaceMenu = d->workspaceMenu->menu();
     workspaceMenu->clear();
 
     auto workspaces = KisResourceServerProvider::instance()->workspaceServer(false)->resources();
     auto m_this = this;
     for (auto &w : workspaces) {
         auto action = workspaceMenu->addAction(w->name());
         auto ds = w->dockerState();
         connect(action, &QAction::triggered, this, [=]() { m_this->restoreWorkspace(ds); });
     }
     workspaceMenu->addSeparator();
     connect(workspaceMenu->addAction(i18nc("@action:inmenu", "&Import Workspace...")),
             &QAction::triggered,
             this,
             [&]() {
         QString extensions = d->workspacemodel->extensions();
         QStringList mimeTypes;
         for(const QString &suffix : extensions.split(":")) {
             mimeTypes << KisMimeDatabase::mimeTypeForSuffix(suffix);
         }
 
         KoFileDialog dialog(0, KoFileDialog::OpenFile, "OpenDocument");
         dialog.setMimeTypeFilters(mimeTypes);
         dialog.setCaption(i18nc("@title:window", "Choose File to Add"));
         QString filename = dialog.filename();
 
         d->workspacemodel->importResourceFile(filename);
     });
 
     connect(workspaceMenu->addAction(i18nc("@action:inmenu", "&New Workspace...")),
             &QAction::triggered,
             [=]() {
         QString name = QInputDialog::getText(this, i18nc("@title:window", "New Workspace..."),
                                              i18nc("@label:textbox", "Name:"));
         if (name.isEmpty()) return;
         auto rserver = KisResourceServerProvider::instance()->workspaceServer();
 
         KisWorkspaceResource* workspace = new KisWorkspaceResource("");
         workspace->setDockerState(m_this->saveState());
         d->viewManager->resourceProvider()->notifySavingWorkspace(workspace);
         workspace->setValid(true);
         QString saveLocation = rserver->saveLocation();
 
         bool newName = false;
         if(name.isEmpty()) {
             newName = true;
             name = i18n("Workspace");
         }
         QFileInfo fileInfo(saveLocation + name + workspace->defaultFileExtension());
 
         int i = 1;
         while (fileInfo.exists()) {
             fileInfo.setFile(saveLocation + name + QString("%1").arg(i) + workspace->defaultFileExtension());
             i++;
         }
         workspace->setFilename(fileInfo.filePath());
         if(newName) {
             name = i18n("Workspace %1", i);
         }
         workspace->setName(name);
         rserver->addResource(workspace);
     });
 
     // TODO: What to do about delete?
 //    workspaceMenu->addAction(i18nc("@action:inmenu", "&Delete Workspace..."));
 
     menu->addSeparator();
     menu->addAction(d->close);
     menu->addAction(d->closeAll);
     if (d->mdiArea->viewMode() == QMdiArea::SubWindowView) {
         menu->addSeparator();
         menu->addAction(d->mdiTile);
         menu->addAction(d->mdiCascade);
     }
     menu->addSeparator();
     menu->addAction(d->mdiNextWindow);
     menu->addAction(d->mdiPreviousWindow);
     menu->addSeparator();
 
     QList<QMdiSubWindow *> windows = d->mdiArea->subWindowList();
     for (int i = 0; i < windows.size(); ++i) {
         QPointer<KisView>child = qobject_cast<KisView*>(windows.at(i)->widget());
         if (child && child->document()) {
             QString text;
             if (i < 9) {
                 text = i18n("&%1 %2", i + 1, child->document()->url().toDisplayString());
             }
             else {
                 text = i18n("%1 %2", i + 1, child->document()->url().toDisplayString());
             }
 
             QAction *action  = menu->addAction(text);
             action->setIcon(qApp->windowIcon());
             action->setCheckable(true);
             action->setChecked(child == activeKisView());
             connect(action, SIGNAL(triggered()), d->windowMapper, SLOT(map()));
             d->windowMapper->setMapping(action, windows.at(i));
         }
     }
 
     updateCaption();
 }
 
 void KisMainWindow::setActiveSubWindow(QWidget *window)
 {
     if (!window) return;
     QMdiSubWindow *subwin = qobject_cast<QMdiSubWindow *>(window);
     //dbgKrita << "setActiveSubWindow();" << subwin << d->activeSubWindow;
 
     if (subwin && subwin != d->activeSubWindow) {
         KisView *view = qobject_cast<KisView *>(subwin->widget());
         //dbgKrita << "\t" << view << activeView();
         if (view && view != activeView()) {
              d->mdiArea->setActiveSubWindow(subwin);
             setActiveView(view);
         }
         d->activeSubWindow = subwin;
     }
     updateWindowMenu();
     d->actionManager()->updateGUI();
 }
 
 void KisMainWindow::configChanged()
 {
     KisConfig cfg;
     QMdiArea::ViewMode viewMode = (QMdiArea::ViewMode)cfg.readEntry<int>("mdi_viewmode", (int)QMdiArea::TabbedView);
     d->mdiArea->setViewMode(viewMode);
     Q_FOREACH (QMdiSubWindow *subwin, d->mdiArea->subWindowList()) {
         subwin->setOption(QMdiSubWindow::RubberBandMove, cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
         subwin->setOption(QMdiSubWindow::RubberBandResize, cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
 
         /**
          * Dirty workaround for a bug in Qt (checked on Qt 5.6.1):
          *
          * If you make a window "Show on top" and then switch to the tabbed mode
          * the window will contiue to be painted in its initial "mid-screen"
          * position. It will persist here until you explicitly switch to its tab.
          */
         if (viewMode == QMdiArea::TabbedView) {
             Qt::WindowFlags oldFlags = subwin->windowFlags();
             Qt::WindowFlags flags = oldFlags;
 
             flags &= ~Qt::WindowStaysOnTopHint;
             flags &= ~Qt::WindowStaysOnBottomHint;
 
             if (flags != oldFlags) {
                 subwin->setWindowFlags(flags);
                 subwin->showMaximized();
             }
         }
 
     }
 
     KConfigGroup group( KSharedConfig::openConfig(), "theme");
     d->themeManager->setCurrentTheme(group.readEntry("Theme", "Krita dark"));
     d->actionManager()->updateGUI();
 
     QBrush brush(cfg.getMDIBackgroundColor());
     d->mdiArea->setBackground(brush);
 
     QString backgroundImage = cfg.getMDIBackgroundImage();
     if (backgroundImage != "") {
         QImage image(backgroundImage);
         QBrush brush(image);
         d->mdiArea->setBackground(brush);
     }
 
     d->mdiArea->update();
 }
 
 KisView* KisMainWindow::newView(QObject *document)
 {
     KisDocument *doc = qobject_cast<KisDocument*>(document);
     KisView *view = addViewAndNotifyLoadingCompleted(doc);
     d->actionManager()->updateGUI();
 
     return view;
 }
 
 void KisMainWindow::newWindow()
 {
     KisMainWindow *mainWindow = KisPart::instance()->createMainWindow();
     mainWindow->initializeGeometry();
     mainWindow->show();
 }
 
 void KisMainWindow::closeCurrentWindow()
 {
     d->mdiArea->currentSubWindow()->close();
     d->actionManager()->updateGUI();
 }
 
 void KisMainWindow::checkSanity()
 {
     // print error if the lcms engine is not available
     if (!KoColorSpaceEngineRegistry::instance()->contains("icc")) {
         // need to wait 1 event since exiting here would not work.
         m_errorMessage = i18n("The Krita LittleCMS color management plugin is not installed. Krita will quit now.");
         m_dieOnError = true;
         QTimer::singleShot(0, this, SLOT(showErrorAndDie()));
         return;
     }
 
     KisPaintOpPresetResourceServer * rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
     if (rserver->resources().isEmpty()) {
         m_errorMessage = i18n("Krita cannot find any brush presets! Krita will quit now.");
         m_dieOnError = true;
         QTimer::singleShot(0, this, SLOT(showErrorAndDie()));
         return;
     }
 }
 
 void KisMainWindow::showErrorAndDie()
 {
     QMessageBox::critical(0, i18nc("@title:window", "Installation error"), m_errorMessage);
     if (m_dieOnError) {
         exit(10);
     }
 }
 
 void KisMainWindow::showAboutApplication()
 {
     KisAboutApplication dlg(this);
     dlg.exec();
 }
 
 QPointer<KisView>KisMainWindow::activeKisView()
 {
     if (!d->mdiArea) return 0;
     QMdiSubWindow *activeSubWindow = d->mdiArea->activeSubWindow();
     //dbgKrita << "activeKisView" << activeSubWindow;
     if (!activeSubWindow) return 0;
     return qobject_cast<KisView*>(activeSubWindow->widget());
 }
 
 void KisMainWindow::newOptionWidgets(KoCanvasController *controller, const QList<QPointer<QWidget> > &optionWidgetList)
 {
     KIS_ASSERT_RECOVER_NOOP(controller == KoToolManager::instance()->activeCanvasController());
     bool isOurOwnView = false;
 
     Q_FOREACH (QPointer<KisView> view, KisPart::instance()->views()) {
         if (view && view->canvasController() == controller) {
             isOurOwnView = view->mainWindow() == this;
         }
     }
 
     if (!isOurOwnView) return;
 
     Q_FOREACH (QWidget *w, optionWidgetList) {
 #ifdef Q_OS_OSX
         w->setAttribute(Qt::WA_MacSmallSize, true);
 #endif
         w->setFont(KoDockRegistry::dockFont());
     }
 
     if (d->toolOptionsDocker) {
         d->toolOptionsDocker->setOptionWidgets(optionWidgetList);
     }
     else {
         d->viewManager->paintOpBox()->newOptionWidgets(optionWidgetList);
     }
 }
 
 void KisMainWindow::applyDefaultSettings(QPrinter &printer) {
 
     if (!d->activeView) return;
 
     QString title = d->activeView->document()->documentInfo()->aboutInfo("title");
     if (title.isEmpty()) {
         QFileInfo info(d->activeView->document()->url().fileName());
         title = info.baseName();
     }
 
     if (title.isEmpty()) {
         // #139905
         title = i18n("%1 unsaved document (%2)", qApp->applicationDisplayName(),
                      QLocale().toString(QDate::currentDate(), QLocale::ShortFormat));
     }
     printer.setDocName(title);
 }
 
 void KisMainWindow::createActions()
 {
     KisActionManager *actionManager = d->actionManager();
     KisConfig cfg;
 
     actionManager->createStandardAction(KStandardAction::New, this, SLOT(slotFileNew()));
     actionManager->createStandardAction(KStandardAction::Open, this, SLOT(slotFileOpen()));
     actionManager->createStandardAction(KStandardAction::Quit, this, SLOT(slotFileQuit()));
     actionManager->createStandardAction(KStandardAction::ConfigureToolbars, this, SLOT(slotConfigureToolbars()));
     d->fullScreenMode = actionManager->createStandardAction(KStandardAction::FullScreen, this, SLOT(viewFullscreen(bool)));
 
     d->recentFiles = KStandardAction::openRecent(this, SLOT(slotFileOpenRecent(QUrl)), actionCollection());
     connect(d->recentFiles, SIGNAL(recentListCleared()), this, SLOT(saveRecentFiles()));
     KSharedConfigPtr configPtr =  KSharedConfig::openConfig();
     d->recentFiles->loadEntries(configPtr->group("RecentFiles"));
 
     d->saveAction = actionManager->createStandardAction(KStandardAction::Save, this, SLOT(slotFileSave()));
     d->saveAction->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
     d->saveActionAs = actionManager->createStandardAction(KStandardAction::SaveAs, this, SLOT(slotFileSaveAs()));
     d->saveActionAs->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
 //    d->printAction = actionManager->createStandardAction(KStandardAction::Print, this, SLOT(slotFilePrint()));
 //    d->printAction->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
 //    d->printActionPreview = actionManager->createStandardAction(KStandardAction::PrintPreview, this, SLOT(slotFilePrintPreview()));
 //    d->printActionPreview->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
     d->undo = actionManager->createStandardAction(KStandardAction::Undo, this, SLOT(undo()));
     d->undo ->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
     d->redo = actionManager->createStandardAction(KStandardAction::Redo, this, SLOT(redo()));
     d->redo->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
 //    d->exportPdf  = actionManager->createAction("file_export_pdf");
 //    connect(d->exportPdf, SIGNAL(triggered()), this, SLOT(exportToPdf()));
 
     d->importAnimation  = actionManager->createAction("file_import_animation");
     connect(d->importAnimation, SIGNAL(triggered()), this, SLOT(importAnimation()));
 
     d->closeAll = actionManager->createAction("file_close_all");
     connect(d->closeAll, SIGNAL(triggered()), this, SLOT(slotFileCloseAll()));
 
 //    d->reloadFile  = actionManager->createAction("file_reload_file");
 //    d->reloadFile->setActivationFlags(KisAction::CURRENT_IMAGE_MODIFIED);
 //    connect(d->reloadFile, SIGNAL(triggered(bool)), this, SLOT(slotReloadFile()));
 
     d->importFile  = actionManager->createAction("file_import_file");
     connect(d->importFile, SIGNAL(triggered(bool)), this, SLOT(slotImportFile()));
 
     d->exportFile  = actionManager->createAction("file_export_file");
     connect(d->exportFile, SIGNAL(triggered(bool)), this, SLOT(slotExportFile()));
 
     /* The following entry opens the document information dialog.  Since the action is named so it
         intends to show data this entry should not have a trailing ellipses (...).  */
     d->showDocumentInfo  = actionManager->createAction("file_documentinfo");
     connect(d->showDocumentInfo, SIGNAL(triggered(bool)), this, SLOT(slotDocumentInfo()));
 
 
     d->themeManager->setThemeMenuAction(new KActionMenu(i18nc("@action:inmenu", "&Themes"), this));
     d->themeManager->registerThemeActions(actionCollection());
     connect(d->themeManager, SIGNAL(signalThemeChanged()), this, SLOT(slotThemeChanged()));
 
 
     d->toggleDockers = actionManager->createAction("view_toggledockers");
     cfg.showDockers(true);
     d->toggleDockers->setChecked(true);
     connect(d->toggleDockers, SIGNAL(toggled(bool)), SLOT(toggleDockersVisibility(bool)));
 
     d->toggleDockerTitleBars = actionManager->createAction("view_toggledockertitlebars");
     d->toggleDockerTitleBars->setChecked(cfg.showDockerTitleBars());
     connect(d->toggleDockerTitleBars, SIGNAL(toggled(bool)), SLOT(showDockerTitleBars(bool)));
 
     actionCollection()->addAction("settings_dockers_menu", d->dockWidgetMenu);
     actionCollection()->addAction("window", d->windowMenu);
 
     d->mdiCascade = actionManager->createAction("windows_cascade");
     connect(d->mdiCascade, SIGNAL(triggered()), d->mdiArea, SLOT(cascadeSubWindows()));
 
     d->mdiTile = actionManager->createAction("windows_tile");
     connect(d->mdiTile, SIGNAL(triggered()), d->mdiArea, SLOT(tileSubWindows()));
 
     d->mdiNextWindow = actionManager->createAction("windows_next");
     connect(d->mdiNextWindow, SIGNAL(triggered()), d->mdiArea, SLOT(activateNextSubWindow()));
 
     d->mdiPreviousWindow = actionManager->createAction("windows_previous");
     connect(d->mdiPreviousWindow, SIGNAL(triggered()), d->mdiArea, SLOT(activatePreviousSubWindow()));
 
     d->newWindow = actionManager->createAction("view_newwindow");
     connect(d->newWindow, SIGNAL(triggered(bool)), this, SLOT(newWindow()));
 
     d->close = actionManager->createAction("file_close");
     connect(d->close, SIGNAL(triggered()), SLOT(closeCurrentWindow()));
 
     d->showSessionManager = actionManager->createAction("file_sessions");
     connect(d->showSessionManager, SIGNAL(triggered(bool)), this, SLOT(slotShowSessionManager()));
 
     actionManager->createStandardAction(KStandardAction::Preferences, this, SLOT(slotPreferences()));
 
     for (int i = 0; i < 2; i++) {
         d->expandingSpacers[i] = new KisAction(i18n("Expanding Spacer"));
         d->expandingSpacers[i]->setDefaultWidget(new QWidget(this));
         d->expandingSpacers[i]->defaultWidget()->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
         actionManager->addAction(QString("expanding_spacer_%1").arg(i), d->expandingSpacers[i]);
     }
 }
 
 void KisMainWindow::applyToolBarLayout()
 {
     const bool isPlastiqueStyle = style()->objectName() == "plastique";
 
     Q_FOREACH (KToolBar *toolBar, toolBars()) {
         toolBar->layout()->setSpacing(4);
         if (isPlastiqueStyle) {
             toolBar->setContentsMargins(0, 0, 0, 2);
         }
         //Hide text for buttons with an icon in the toolbar
         Q_FOREACH (QAction *ac, toolBar->actions()){
             if (ac->icon().pixmap(QSize(1,1)).isNull() == false){
                 ac->setPriority(QAction::LowPriority);
             }else {
                 ac->setIcon(QIcon());
             }
         }
     }
 }
 
 void KisMainWindow::initializeGeometry()
 {
     // if the user didn's specify the geometry on the command line (does anyone do that still?),
     // we first figure out some good default size and restore the x,y position. See bug 285804Z.
     KConfigGroup cfg = d->windowStateConfig;
     QByteArray geom = QByteArray::fromBase64(cfg.readEntry("ko_geometry", QByteArray()));
     if (!restoreGeometry(geom)) {
         const int scnum = QApplication::desktop()->screenNumber(parentWidget());
         QRect desk = QApplication::desktop()->availableGeometry(scnum);
         // if the desktop is virtual then use virtual screen size
         if (QApplication::desktop()->isVirtualDesktop()) {
             desk = QApplication::desktop()->availableGeometry(QApplication::desktop()->screen(scnum));
         }
 
         quint32 x = desk.x();
         quint32 y = desk.y();
         quint32 w = 0;
         quint32 h = 0;
 
         // Default size -- maximize on small screens, something useful on big screens
         const int deskWidth = desk.width();
         if (deskWidth > 1024) {
             // a nice width, and slightly less than total available
             // height to componensate for the window decs
             w = (deskWidth / 3) * 2;
             h = (desk.height() / 3) * 2;
         }
         else {
             w = desk.width();
             h = desk.height();
         }
 
         x += (desk.width() - w) / 2;
         y += (desk.height() - h) / 2;
 
         move(x,y);
         setGeometry(geometry().x(), geometry().y(), w, h);
     }
     restoreWorkspace(QByteArray::fromBase64(cfg.readEntry("State", QByteArray())));
 
     d->fullScreenMode->setChecked(isFullScreen());
 }
 
 void KisMainWindow::showManual()
 {
     QDesktopServices::openUrl(QUrl("https://docs.krita.org"));
 }
 
 void KisMainWindow::showDockerTitleBars(bool show)
 {
     Q_FOREACH (QDockWidget *dock, dockWidgets()) {
         if (dock->titleBarWidget()) {
             const bool isCollapsed = (dock->widget() && dock->widget()->isHidden()) || !dock->widget();
             dock->titleBarWidget()->setVisible(show || (dock->isFloating() && isCollapsed));
         }
     }
 
     KisConfig cfg;
     cfg.setShowDockerTitleBars(show);
 }
 
 void KisMainWindow::moveEvent(QMoveEvent *e)
 {
     if (qApp->desktop()->screenNumber(this) != qApp->desktop()->screenNumber(e->oldPos())) {
         KisConfigNotifier::instance()->notifyConfigChanged();
     }
 }
 
 
 
 #include <moc_KisMainWindow.cpp>
diff --git a/libs/ui/KisPart.cpp b/libs/ui/KisPart.cpp
index 2f76fd43e2..59ce875d1f 100644
--- a/libs/ui/KisPart.cpp
+++ b/libs/ui/KisPart.cpp
@@ -1,587 +1,583 @@
 /* This file is part of the KDE project
  * Copyright (C) 1998-1999 Torben Weis       <weis@kde.org>
  * Copyright (C) 2000-2005 David Faure       <faure@kde.org>
  * Copyright (C) 2007-2008 Thorsten Zachmann <zachmann@kde.org>
  * Copyright (C) 2010-2012 Boudewijn Rempt   <boud@valdyas.org>
  * Copyright (C) 2011 Inge Wallin            <ingwa@kogmbh.com>
  * Copyright (C) 2015 Michael Abrahams       <miabraha@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "KisPart.h"
 
 #include "KoProgressProxy.h"
 #include <KoCanvasController.h>
 #include <KoCanvasControllerWidget.h>
 #include <KoColorSpaceEngine.h>
 #include <KoCanvasBase.h>
 #include <KoToolManager.h>
 #include <KoShapeBasedDocumentBase.h>
 #include <KoResourceServerProvider.h>
 #include <kis_icon.h>
 
 #include "KisApplication.h"
 #include "KisMainWindow.h"
 #include "KisDocument.h"
 #include "KisView.h"
 #include "KisViewManager.h"
 #include "KisImportExportManager.h"
 
 #include <kis_debug.h>
 #include <KoResourcePaths.h>
 #include <KoDialog.h>
 #include <kdesktopfile.h>
 #include <QMessageBox>
 #include <klocalizedstring.h>
 #include <kactioncollection.h>
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <QKeySequence>
 
 #include <QDialog>
 #include <QApplication>
 #include <QDomDocument>
 #include <QDomElement>
 #include <QGlobalStatic>
 #include <KisMimeDatabase.h>
 #include <dialogs/KisSessionManagerDialog.h>
 
 #include "KisView.h"
 #include "KisDocument.h"
 #include "kis_config.h"
 #include "kis_shape_controller.h"
 #include "kis_resource_server_provider.h"
 #include "kis_animation_cache_populator.h"
 #include "kis_idle_watcher.h"
 #include "kis_image.h"
 #include "KisImportExportManager.h"
 #include "KisDocument.h"
 #include "KoToolManager.h"
 #include "KisViewManager.h"
-#include "kis_script_manager.h"
 #include "KisOpenPane.h"
 
 #include "kis_color_manager.h"
 #include "kis_debug.h"
 
 #include "kis_action.h"
 #include "kis_action_registry.h"
 #include "KisSessionResource.h"
 
 Q_GLOBAL_STATIC(KisPart, s_instance)
 
 
 class Q_DECL_HIDDEN KisPart::Private
 {
 public:
     Private(KisPart *_part)
         : part(_part)
         , idleWatcher(2500)
         , animationCachePopulator(_part)
     {
     }
 
     ~Private()
     {
     }
 
     KisPart *part;
 
     QList<QPointer<KisView> > views;
     QList<QPointer<KisMainWindow> > mainWindows;
     QList<QPointer<KisDocument> > documents;
-    QList<KisAction*> scriptActions;
-
     KActionCollection *actionCollection{0};
-
     KisIdleWatcher idleWatcher;
     KisAnimationCachePopulator animationCachePopulator;
 
     KisSessionResource *currentSession = nullptr;
     bool closingSession{false};
     QScopedPointer<KisSessionManagerDialog> sessionManager;
 
     bool queryCloseDocument(KisDocument *document) {
         Q_FOREACH(auto view, views) {
             if (view && view->isVisible() && view->document() == document) {
                 return view->queryClose();
             }
         }
 
         return false;
     }
 };
 
 
 KisPart* KisPart::instance()
 {
     return s_instance;
 }
 
 
 KisPart::KisPart()
     : d(new Private(this))
 {
     // Preload all the resources in the background
     Q_UNUSED(KoResourceServerProvider::instance());
     Q_UNUSED(KisResourceServerProvider::instance());
     Q_UNUSED(KisColorManager::instance());
 
     connect(this, SIGNAL(documentOpened(QString)),
             this, SLOT(updateIdleWatcherConnections()));
 
     connect(this, SIGNAL(documentClosed(QString)),
             this, SLOT(updateIdleWatcherConnections()));
 
     connect(KisActionRegistry::instance(), SIGNAL(shortcutsUpdated()),
             this, SLOT(updateShortcuts()));
     connect(&d->idleWatcher, SIGNAL(startedIdleMode()),
             &d->animationCachePopulator, SLOT(slotRequestRegeneration()));
 
 
     d->animationCachePopulator.slotRequestRegeneration();
 }
 
 KisPart::~KisPart()
 {
     while (!d->documents.isEmpty()) {
         delete d->documents.takeFirst();
     }
 
     while (!d->views.isEmpty()) {
         delete d->views.takeFirst();
     }
 
     while (!d->mainWindows.isEmpty()) {
         delete d->mainWindows.takeFirst();
     }
 
     delete d;
 }
 
 void KisPart::updateIdleWatcherConnections()
 {
     QVector<KisImageSP> images;
 
     Q_FOREACH (QPointer<KisDocument> document, documents()) {
         if (document->image()) {
             images << document->image();
         }
     }
 
     d->idleWatcher.setTrackedImages(images);
 }
 
 void KisPart::addDocument(KisDocument *document)
 {
     //dbgUI << "Adding document to part list" << document;
     Q_ASSERT(document);
     if (!d->documents.contains(document)) {
         d->documents.append(document);
         emit documentOpened('/'+objectName());
         emit sigDocumentAdded(document);
         connect(document, SIGNAL(sigSavingFinished()), SLOT(slotDocumentSaved()));
     }
 }
 
 QList<QPointer<KisDocument> > KisPart::documents() const
 {
     return d->documents;
 }
 
 KisDocument *KisPart::createDocument() const
 {
     KisDocument *doc = new KisDocument();
     return doc;
 }
 
 
 int KisPart::documentCount() const
 {
     return d->documents.size();
 }
 
 void KisPart::removeDocument(KisDocument *document)
 {
     d->documents.removeAll(document);
     emit documentClosed('/'+objectName());
     emit sigDocumentRemoved(document->url().toLocalFile());
     document->deleteLater();
 }
 
 KisMainWindow *KisPart::createMainWindow(QUuid id)
 {
     KisMainWindow *mw = new KisMainWindow(id);
-    Q_FOREACH(KisAction *action, d->scriptActions) {
-        mw->viewManager()->scriptManager()->addAction(action);
-    }
     dbgUI <<"mainWindow" << (void*)mw << "added to view" << this;
     d->mainWindows.append(mw);
     emit sigWindowAdded(mw);
     return mw;
 }
 
 KisView *KisPart::createView(KisDocument *document,
                              KoCanvasResourceManager *resourceManager,
                              KActionCollection *actionCollection,
                              QWidget *parent)
 {
     // If creating the canvas fails, record this and disable OpenGL next time
     KisConfig cfg;
     KConfigGroup grp( KSharedConfig::openConfig(), "crashprevention");
     if (grp.readEntry("CreatingCanvas", false)) {
         cfg.setUseOpenGL(false);
     }
     if (cfg.canvasState() == "OPENGL_FAILED") {
         cfg.setUseOpenGL(false);
     }
     grp.writeEntry("CreatingCanvas", true);
     grp.sync();
 
     QApplication::setOverrideCursor(Qt::WaitCursor);
     KisView *view  = new KisView(document, resourceManager, actionCollection, parent);
     QApplication::restoreOverrideCursor();
 
     // Record successful canvas creation
     grp.writeEntry("CreatingCanvas", false);
     grp.sync();
 
     addView(view);
 
     return view;
 }
 
 void KisPart::addView(KisView *view)
 {
     if (!view)
         return;
 
     if (!d->views.contains(view)) {
         d->views.append(view);
     }
 
     emit sigViewAdded(view);
 }
 
 void KisPart::removeView(KisView *view)
 {
     if (!view) return;
 
     /**
      * HACK ALERT: we check here explicitly if the document (or main
      *             window), is saving the stuff. If we close the
      *             document *before* the saving is completed, a crash
      *             will happen.
      */
     KIS_ASSERT_RECOVER_RETURN(!view->mainWindow()->hackIsSaving());
 
     emit sigViewRemoved(view);
 
     QPointer<KisDocument> doc = view->document();
     d->views.removeAll(view);
 
     if (doc) {
         bool found = false;
         Q_FOREACH (QPointer<KisView> view, d->views) {
             if (view && view->document() == doc) {
                 found = true;
                 break;
             }
         }
         if (!found) {
             removeDocument(doc);
         }
     }
 }
 
 QList<QPointer<KisView> > KisPart::views() const
 {
     return d->views;
 }
 
 int KisPart::viewCount(KisDocument *doc) const
 {
     if (!doc) {
         return d->views.count();
     }
     else {
         int count = 0;
         Q_FOREACH (QPointer<KisView> view, d->views) {
             if (view && view->isVisible() && view->document() == doc) {
                 count++;
             }
         }
         return count;
     }
 }
 
 bool KisPart::closingSession() const
 {
     return d->closingSession;
 }
 
 bool KisPart::closeSession(bool keepWindows)
 {
     d->closingSession = true;
 
     Q_FOREACH(auto document, d->documents) {
         if (!d->queryCloseDocument(document.data())) {
             d->closingSession = false;
             return false;
         }
     }
 
     if (d->currentSession) {
         KisConfig kisCfg;
         if (kisCfg.saveSessionOnQuit(false)) {
 
             d->currentSession->storeCurrentWindows();
             d->currentSession->save();
 
             KConfigGroup cfg = KSharedConfig::openConfig()->group("session");
             cfg.writeEntry("previousSession", d->currentSession->name());
         }
 
         d->currentSession = nullptr;
     }
 
     if (!keepWindows) {
         Q_FOREACH (auto window, d->mainWindows) {
             window->close();
         }
 
         if (d->sessionManager) {
             d->sessionManager->close();
         }
     }
 
     d->closingSession = false;
     return true;
 }
 
 void KisPart::slotDocumentSaved()
 {
     KisDocument *doc = qobject_cast<KisDocument*>(sender());
     emit sigDocumentSaved(doc->url().toLocalFile());
 }
 
 void KisPart::removeMainWindow(KisMainWindow *mainWindow)
 {
     dbgUI <<"mainWindow" << (void*)mainWindow <<"removed from doc" << this;
     if (mainWindow) {
         d->mainWindows.removeAll(mainWindow);
     }
 }
 
 const QList<QPointer<KisMainWindow> > &KisPart::mainWindows() const
 {
     return d->mainWindows;
 }
 
 int KisPart::mainwindowCount() const
 {
     return d->mainWindows.count();
 }
 
 
 KisMainWindow *KisPart::currentMainwindow() const
 {
     QWidget *widget = qApp->activeWindow();
     KisMainWindow *mainWindow = qobject_cast<KisMainWindow*>(widget);
     while (!mainWindow && widget) {
         widget = widget->parentWidget();
         mainWindow = qobject_cast<KisMainWindow*>(widget);
     }
 
     if (!mainWindow && mainWindows().size() > 0) {
         mainWindow = mainWindows().first();
     }
     return mainWindow;
 
 }
 
+<<<<<<< HEAD
 KisMainWindow * KisPart::windowById(QUuid id) const
 {
     Q_FOREACH(QPointer<KisMainWindow> mainWindow, d->mainWindows) {
         if (mainWindow->id() == id) {
             return mainWindow;
         }
     }
 
     return nullptr;
 }
 
 void KisPart::addScriptAction(KisAction *action)
 {
     d->scriptActions << action;
 }
+=======
+>>>>>>> master
 
 KisIdleWatcher* KisPart::idleWatcher() const
 {
     return &d->idleWatcher;
 }
 
 KisAnimationCachePopulator* KisPart::cachePopulator() const
 {
     return &d->animationCachePopulator;
 }
 
 void KisPart::openExistingFile(const QUrl &url)
 {
     // TODO: refactor out this method!
 
     KisMainWindow *mw = currentMainwindow();
     KIS_SAFE_ASSERT_RECOVER_RETURN(mw);
 
     mw->openDocument(url, KisMainWindow::None);
 }
 
 void KisPart::updateShortcuts()
 {
     // Update any non-UI actionCollections.  That includes:
     //  - Shortcuts called inside of tools
     //  - Perhaps other things?
     KoToolManager::instance()->updateToolShortcuts();
 
     // Now update the UI actions.
     Q_FOREACH (KisMainWindow *mainWindow, d->mainWindows) {
         KActionCollection *ac = mainWindow->actionCollection();
 
         ac->updateShortcuts();
 
         // Loop through mainWindow->actionCollections() to modify tooltips
         // so that they list shortcuts at the end in parentheses
         Q_FOREACH ( QAction* action, ac->actions())
         {
             // Remove any existing suffixes from the tooltips.
             // Note this regexp starts with a space, e.g. " (Ctrl-a)"
             QString strippedTooltip = action->toolTip().remove(QRegExp("\\s\\(.*\\)"));
 
             // Now update the tooltips with the new shortcut info.
             if(action->shortcut() == QKeySequence(0))
                 action->setToolTip(strippedTooltip);
             else
                 action->setToolTip( strippedTooltip + " (" + action->shortcut().toString() + ")");
         }
     }
 }
 
 void KisPart::openTemplate(const QUrl &url)
 {
     qApp->setOverrideCursor(Qt::BusyCursor);
     KisDocument *document = createDocument();
 
     bool ok = document->loadNativeFormat(url.toLocalFile());
     document->setModified(false);
     document->undoStack()->clear();
 
     if (ok) {
         QString mimeType = KisMimeDatabase::mimeTypeForFile(url.toLocalFile());
         // in case this is a open document template remove the -template from the end
         mimeType.remove( QRegExp( "-template$" ) );
         document->setMimeTypeAfterLoading(mimeType);
         document->resetURL();
     }
     else {
         if (document->errorMessage().isEmpty()) {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not create document from template\n%1", document->localFilePath()));
         }
         else {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not create document from template\n%1\nReason: %2", document->localFilePath(), document->errorMessage()));
         }
         delete document;
         return;
     }
     addDocument(document);
 
     KisMainWindow *mw = currentMainwindow();
     mw->addViewAndNotifyLoadingCompleted(document);
 
     KisOpenPane *pane = qobject_cast<KisOpenPane*>(sender());
     if (pane) {
         pane->hide();
         pane->deleteLater();
 
     }
 
     qApp->restoreOverrideCursor();
 }
 
 void KisPart::addRecentURLToAllMainWindows(QUrl url)
 {
     // Add to recent actions list in our mainWindows
     Q_FOREACH (KisMainWindow *mainWindow, d->mainWindows) {
         mainWindow->addRecentURL(url);
     }
 }
 
 
 void KisPart::startCustomDocument(KisDocument* doc)
 {
     addDocument(doc);
     KisMainWindow *mw = currentMainwindow();
     KisOpenPane *pane = qobject_cast<KisOpenPane*>(sender());
     if (pane) {
         pane->hide();
         pane->deleteLater();
     }
     mw->addViewAndNotifyLoadingCompleted(doc);
 
 }
 
 KisInputManager* KisPart::currentInputManager()
 {
     KisMainWindow *mw = currentMainwindow();
     KisViewManager *manager = mw ? mw->viewManager() : 0;
     return manager ? manager->inputManager() : 0;
 }
 
 void KisPart::showSessionManager()
 {
     if (d->sessionManager.isNull()) {
         d->sessionManager.reset(new KisSessionManagerDialog());
     }
 
     d->sessionManager->show();
     d->sessionManager->activateWindow();
 }
 
 void KisPart::startBlankSession()
 {
     KisMainWindow *window = createMainWindow();
     window->initializeGeometry();
     window->show();
 
 }
 
 bool KisPart::restoreSession(const QString &sessionName)
 {
     if (sessionName.isNull()) return false;
 
     KoResourceServer<KisSessionResource> * rserver = KisResourceServerProvider::instance()->sessionServer();
     auto *session = rserver->resourceByName(sessionName);
     if (!session || !session->valid()) return false;
 
     session->restore();
 
     return true;
 }
 
 void KisPart::setCurrentSession(KisSessionResource *session)
 {
     d->currentSession = session;
 }
diff --git a/libs/ui/KisPart.h b/libs/ui/KisPart.h
index 7a451923c9..2202f1f93e 100644
--- a/libs/ui/KisPart.h
+++ b/libs/ui/KisPart.h
@@ -1,287 +1,276 @@
 /* This file is part of the KDE project
    Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
    Copyright (C) 2000-2005 David Faure  <faure@kde.org>
    Copyright (C) 2007 Thorsten Zachmann <zachmann@kde.org>
    Copyright (C) 2010 Boudewijn Rempt   <boud@valdyas.org>
    Copyright (C) 2015 Michael Abrahams  <miabraha@gmail.com>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #ifndef KIS_PART_H
 #define KIS_PART_H
 
 #include <QList>
 #include <QPointer>
 #include <QUrl>
 #include <QUuid>
 
 #include "kritaui_export.h"
 #include <KConfigCore/kconfiggroup.h>
 #include <KoConfig.h>
 #include <KisMainWindow.h>
 
 namespace KIO {
 }
 
 class KisAction;
 class KisDocument;
 class KisView;
 class KisDocument;
 class KisIdleWatcher;
 class KisAnimationCachePopulator;
 class KisSessionResource;
 
 /**
  * KisPart is the Great Deku Tree of Krita.
  *
  * It is a singleton class which provides the main entry point to the application.
  * Krita supports multiple documents, multiple main windows, and multiple
  * components.  KisPart manages these resources and provides them to the rest of
  * Krita.  It manages lists of Actions and shortcuts as well.
  *
  * The terminology comes from KParts, which is a system allowing one KDE app
  * to be run from inside another, like pressing F4 inside dophin to run konsole.
  *
  * Needless to say, KisPart hasn't got much to do with KParts anymore.
  */
 class KRITAUI_EXPORT KisPart : public QObject
 {
     Q_OBJECT
 
 public:
 
     static KisPart *instance();
 
     /**
      * Constructor.
      *
      * @param parent may be another KisDocument, or anything else.
      *        Usually passed by KPluginFactory::create.
      */
     explicit KisPart();
 
     /**
      *  Destructor.
      *
      * The destructor does not delete any attached KisView objects and it does not
      * delete the attached widget as returned by widget().
      */
     ~KisPart() override;
 
     // ----------------- Document management -----------------
 
     /**
      * create an empty document. The document is not automatically registered with the part.
      */
     KisDocument *createDocument() const;
 
     /**
      * Add the specified document to the list of documents this KisPart manages.
      */
     void addDocument(KisDocument *document);
 
     /**
      * @return a list of all documents this part manages
      */
     QList<QPointer<KisDocument> > documents() const;
 
     /**
      * @return number of documents this part manages.
      */
     int documentCount() const;
 
     void removeDocument(KisDocument *document);
 
     // ----------------- MainWindow management -----------------
 
 
     /**
      * Create a new main window.
      */
     KisMainWindow *createMainWindow(QUuid id = QUuid());
 
     /**
      * Removes a main window from the list of managed windows.
      *
      * This is called by the MainWindow after it finishes its shutdown routine.
      */
     void removeMainWindow(KisMainWindow *mainWindow);
 
     /**
      * @return the list of main windows.
      */
     const QList<QPointer<KisMainWindow> >& mainWindows() const;
 
     /**
      * @return the number of shells for the main window
      */
     int mainwindowCount() const;
 
     void addRecentURLToAllMainWindows(QUrl url);
 
     /**
      * @return the currently active main window.
      */
     KisMainWindow *currentMainwindow() const;
 
     KisMainWindow *windowById(QUuid id) const;
 
-    /**
-     * Add a given action to the list of dynamically defined actions. On creating
-     * a mainwindow, all these actions will be added to the script manager.
-     */
-    void addScriptAction(KisAction *);
-
-    /**
-     * Load actions for currently active main window into KisActionRegistry.
-     */
-    void loadActions();
-
     /**
      * @return the application-wide KisIdleWatcher.
      */
     KisIdleWatcher *idleWatcher() const;
 
     /**
      * @return the application-wide AnimationCachePopulator.
      */
     KisAnimationCachePopulator *cachePopulator() const;
 
 public Q_SLOTS:
 
     /**
      * This slot loads an existing file.
      * @param url the file to load
      */
     void openExistingFile(const QUrl &url);
 
     /**
      * This slot loads a template and deletes the sender.
      * @param url the template to load
      */
     void openTemplate(const QUrl &url);
 
 
     /**
      * @brief startCustomDocument adds the given document to the document list and deletes the sender()
      * @param doc
      */
     void startCustomDocument(KisDocument *doc);
 
 private Q_SLOTS:
 
     void updateIdleWatcherConnections();
 
     void updateShortcuts();
 
 Q_SIGNALS:
     /**
      * emitted when a new document is opened. (for the idle watcher)
      */
     void documentOpened(const QString &ref);
 
     /**
      * emitted when an old document is closed. (for the idle watcher)
      */
     void documentClosed(const QString &ref);
 
     // These signals are for libkis or sketch
     void sigViewAdded(KisView *view);
     void sigViewRemoved(KisView *view);
     void sigDocumentAdded(KisDocument *document);
     void sigDocumentSaved(const QString &url);
     void sigDocumentRemoved(const QString &filename);
     void sigWindowAdded(KisMainWindow *window);
 
 public:
 
     KisInputManager *currentInputManager();
 
     //------------------ View management ------------------
 
     /**
      * Create a new view for the document. The view is added to the list of
      * views, and if the document wasn't known yet, it's registered as well.
      */
     KisView *createView(KisDocument *document,
                         KoCanvasResourceManager *resourceManager,
                         KActionCollection *actionCollection,
                         QWidget *parent);
 
     /**
      * Adds a view to the document. If the part doesn't know yet about
      * the document, it is registered.
      *
      * This calls KisView::updateReadWrite to tell the new view
      * whether the document is readonly or not.
      */
     void addView(KisView *view);
 
     /**
      * Removes a view of the document.
      */
     void removeView(KisView *view);
 
     /**
      * @return a list of views this document is displayed in
      */
     QList<QPointer<KisView> > views() const;
 
     /**
      * @return number of views this document is displayed in
      */
     int viewCount(KisDocument *doc) const;
 
     //------------------ Session management ------------------
 
     void showSessionManager();
 
     void startBlankSession();
 
     /**
      * Restores a saved session by name
      */
     bool restoreSession(const QString &sessionName);
 
     void setCurrentSession(KisSessionResource *session);
 
     /**
      * Attempts to save the session and close all windows.
      * This may involve asking the user to save open files.
      * @return false, if closing was cancelled by the user
      */
     bool closeSession(bool keepWindows = false);
 
     /**
      * Are we in the process of closing the application through closeSession().
      */
     bool closingSession() const;
 
 private Q_SLOTS:
 
     void slotDocumentSaved();
 
 private:
 
     Q_DISABLE_COPY(KisPart)
 
     class Private;
     Private *const d;
 
 };
 
 #endif
diff --git a/libs/ui/KisViewManager.cpp b/libs/ui/KisViewManager.cpp
index e8b36b1da3..c9e8cddd1d 100644
--- a/libs/ui/KisViewManager.cpp
+++ b/libs/ui/KisViewManager.cpp
@@ -1,1417 +1,1407 @@
 /*
  *  This file is part of KimageShop^WKrayon^WKrita
  *
  *  Copyright (c) 1999 Matthias Elter  <me@kde.org>
  *                1999 Michael Koch    <koch@kde.org>
  *                1999 Carsten Pfeiffer <pfeiffer@kde.org>
  *                2002 Patrick Julien <freak@codepimps.org>
  *                2003-2011 Boudewijn Rempt <boud@valdyas.org>
  *                2004 Clarence Dang <dang@kde.org>
  *                2011 José Luis Vergara <pentalis@gmail.com>
  *                2017 L. E. Segovia <leo.segovia@siggraph.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 <stdio.h>
 
 #include "KisViewManager.h"
 #include <QPrinter>
 
 #include <QAction>
 #include <QApplication>
 #include <QBuffer>
 #include <QByteArray>
 #include <QStandardPaths>
 #include <QDesktopWidget>
 #include <QDesktopServices>
 #include <QGridLayout>
 #include <QMainWindow>
 #include <QMenu>
 #include <QMenuBar>
 #include <QMessageBox>
 #include <QObject>
 #include <QPoint>
 #include <QPrintDialog>
 #include <QRect>
 #include <QScrollBar>
 #include <QStatusBar>
 #include <QToolBar>
 #include <QUrl>
 #include <QWidget>
 
 #include <kactioncollection.h>
 #include <klocalizedstring.h>
 #include <KoResourcePaths.h>
 #include <kselectaction.h>
 
 #include <KoCanvasController.h>
 #include <KoCompositeOp.h>
 #include <KoDockRegistry.h>
 #include <KoDockWidgetTitleBar.h>
 #include <KoProperties.h>
 #include <KoResourceItemChooserSync.h>
 #include <KoSelection.h>
 #include <KoStore.h>
 #include <KoToolManager.h>
 #include <KoToolRegistry.h>
 #include <KoViewConverter.h>
 #include <KoZoomHandler.h>
 #include <KoPluginLoader.h>
 #include <KoDocumentInfo.h>
 #include <KoGlobal.h>
 #include <KoColorSpaceRegistry.h>
 
 #include "input/kis_input_manager.h"
 #include "canvas/kis_canvas2.h"
 #include "canvas/kis_canvas_controller.h"
 #include "canvas/kis_grid_manager.h"
 #include "dialogs/kis_dlg_blacklist_cleanup.h"
 #include "input/kis_input_profile_manager.h"
 #include "kis_action_manager.h"
 #include "kis_action.h"
 #include "kis_canvas_controls_manager.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_composite_progress_proxy.h"
 #include <KoProgressUpdater.h>
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_control_frame.h"
 #include "kis_coordinates_converter.h"
 #include "KisDocument.h"
 #include "kis_favorite_resource_manager.h"
 #include "kis_filter_manager.h"
 #include "kis_group_layer.h"
 #include <kis_image.h>
 #include <kis_image_barrier_locker.h>
 #include "kis_image_manager.h"
 #include <kis_layer.h>
 #include "kis_mainwindow_observer.h"
 #include "kis_mask_manager.h"
 #include "kis_mimedata.h"
 #include "kis_mirror_manager.h"
 #include "kis_node_commands_adapter.h"
 #include "kis_node.h"
 #include "kis_node_manager.h"
 #include "KisDecorationsManager.h"
 #include <kis_paint_layer.h>
 #include "kis_paintop_box.h"
 #include <brushengine/kis_paintop_preset.h>
 #include "KisPart.h"
 #include "KisPrintJob.h"
 #include <KoUpdater.h>
 #include "kis_resource_server_provider.h"
 #include "kis_selection.h"
 #include "kis_selection_manager.h"
 #include "kis_shape_controller.h"
 #include "kis_shape_layer.h"
 #include <kis_signal_compressor.h>
 #include "kis_statusbar.h"
 #include <KisTemplateCreateDia.h>
 #include <kis_tool_freehand.h>
 #include "kis_tooltip_manager.h"
 #include <kis_undo_adapter.h>
 #include "KisView.h"
 #include "kis_zoom_manager.h"
 #include "widgets/kis_floating_message.h"
 #include "kis_signal_auto_connection.h"
-#include "kis_script_manager.h"
 #include "kis_icon_utils.h"
 #include "kis_guides_manager.h"
 #include "kis_derived_resources.h"
 #include "dialogs/kis_delayed_save_dialog.h"
 #include <kis_image.h>
 #include <KisMainWindow.h>
 #include "kis_signals_blocker.h"
 
 
 class BlockingUserInputEventFilter : public QObject
 {
     bool eventFilter(QObject *watched, QEvent *event) override
     {
         Q_UNUSED(watched);
         if(dynamic_cast<QWheelEvent*>(event)
                 || dynamic_cast<QKeyEvent*>(event)
                 || dynamic_cast<QMouseEvent*>(event)) {
             return true;
         }
         else {
             return false;
         }
     }
 };
 
 class KisViewManager::KisViewManagerPrivate
 {
 
 public:
 
     KisViewManagerPrivate(KisViewManager *_q, KActionCollection *_actionCollection, QWidget *_q_parent)
         : filterManager(_q)
         , createTemplate(0)
         , saveIncremental(0)
         , saveIncrementalBackup(0)
         , openResourcesDirectory(0)
         , rotateCanvasRight(0)
         , rotateCanvasLeft(0)
         , resetCanvasRotation(0)
         , wrapAroundAction(0)
         , levelOfDetailAction(0)
         , showRulersAction(0)
         , rulersTrackMouseAction(0)
         , zoomTo100pct(0)
         , zoomIn(0)
         , zoomOut(0)
         , selectionManager(_q)
         , statusBar(_q)
         , controlFrame(_q, _q_parent)
         , nodeManager(_q)
         , imageManager(_q)
         , gridManager(_q)
         , canvasControlsManager(_q)
         , paintingAssistantsManager(_q)
         , actionManager(_q, _actionCollection)
         , mainWindow(0)
         , showFloatingMessage(true)
         , currentImageView(0)
         , canvasResourceProvider(_q)
         , canvasResourceManager()
         , guiUpdateCompressor(30, KisSignalCompressor::POSTPONE, _q)
         , actionCollection(_actionCollection)
         , mirrorManager(_q)
         , inputManager(_q)
-        , scriptManager(_q)
         , actionAuthor(0)
         , showPixelGrid(0)
     {
         KisViewManager::initializeResourceManager(&canvasResourceManager);
     }
 
 public:
     KisFilterManager filterManager;
     KisAction *createTemplate;
     KisAction *createCopy;
     KisAction *saveIncremental;
     KisAction *saveIncrementalBackup;
     KisAction *openResourcesDirectory;
     KisAction *rotateCanvasRight;
     KisAction *rotateCanvasLeft;
     KisAction *resetCanvasRotation;
     KisAction *wrapAroundAction;
     KisAction *levelOfDetailAction;
     KisAction *showRulersAction;
     KisAction *rulersTrackMouseAction;
     KisAction *zoomTo100pct;
     KisAction *zoomIn;
     KisAction *zoomOut;
     KisAction *softProof;
     KisAction *gamutCheck;
 
     KisSelectionManager selectionManager;
     KisGuidesManager guidesManager;
     KisStatusBar statusBar;
     QPointer<KoUpdater> persistentImageProgressUpdater;
 
     QScopedPointer<KoProgressUpdater> persistentUnthreadedProgressUpdaterRouter;
     QPointer<KoUpdater> persistentUnthreadedProgressUpdater;
 
     KisControlFrame controlFrame;
     KisNodeManager nodeManager;
     KisImageManager imageManager;
     KisGridManager gridManager;
     KisCanvasControlsManager canvasControlsManager;
     KisDecorationsManager paintingAssistantsManager;
     BlockingUserInputEventFilter blockingEventFilter;
     KisActionManager actionManager;
     QMainWindow* mainWindow;
     QPointer<KisFloatingMessage> savedFloatingMessage;
     bool showFloatingMessage;
     QPointer<KisView> currentImageView;
     KisCanvasResourceProvider canvasResourceProvider;
     KoCanvasResourceManager canvasResourceManager;
     KisSignalCompressor guiUpdateCompressor;
     KActionCollection *actionCollection;
     KisMirrorManager mirrorManager;
     KisInputManager inputManager;
 
     KisSignalAutoConnectionsStore viewConnections;
-    KisScriptManager scriptManager;
     KSelectAction *actionAuthor; // Select action for author profile.
     KisAction *showPixelGrid;
 
     QByteArray canvasState;
 #if QT_VERSION < QT_VERSION_CHECK(5, 10, 0)
     QFlags<Qt::WindowState> windowFlags;
 #endif
 
     bool blockUntilOperationsFinishedImpl(KisImageSP image, bool force);
 };
 
 KisViewManager::KisViewManager(QWidget *parent, KActionCollection *_actionCollection)
     : d(new KisViewManagerPrivate(this, _actionCollection, parent))
 {
     d->actionCollection = _actionCollection;
     d->mainWindow = dynamic_cast<QMainWindow*>(parent);
     d->canvasResourceProvider.setResourceManager(&d->canvasResourceManager);
     connect(&d->guiUpdateCompressor, SIGNAL(timeout()), this, SLOT(guiUpdateTimeout()));
 
     createActions();
     setupManagers();
 
     // These initialization functions must wait until KisViewManager ctor is complete.
     d->statusBar.setup();
     d->persistentImageProgressUpdater =
         d->statusBar.progressUpdater()->startSubtask(1, "", true);
     // reset state to "completed"
     d->persistentImageProgressUpdater->setRange(0,100);
     d->persistentImageProgressUpdater->setValue(100);
 
     d->persistentUnthreadedProgressUpdater =
         d->statusBar.progressUpdater()->startSubtask(1, "", true);
         // reset state to "completed"
     d->persistentUnthreadedProgressUpdater->setRange(0,100);
     d->persistentUnthreadedProgressUpdater->setValue(100);
 
     d->persistentUnthreadedProgressUpdaterRouter.reset(
         new KoProgressUpdater(d->persistentUnthreadedProgressUpdater,
                               KoProgressUpdater::Unthreaded));
     d->persistentUnthreadedProgressUpdaterRouter->setAutoNestNames(true);
 
     d->controlFrame.setup(parent);
 
     //Check to draw scrollbars after "Canvas only mode" toggle is created.
     this->showHideScrollbars();
 
     QScopedPointer<KoDummyCanvasController> dummy(new KoDummyCanvasController(actionCollection()));
     KoToolManager::instance()->registerToolActions(actionCollection(), dummy.data());
 
     QTimer::singleShot(0, this, SLOT(initializeStatusBarVisibility()));
 
     connect(KoToolManager::instance(), SIGNAL(inputDeviceChanged(KoInputDevice)),
             d->controlFrame.paintopBox(), SLOT(slotInputDeviceChanged(KoInputDevice)));
 
     connect(KoToolManager::instance(), SIGNAL(changedTool(KoCanvasController*,int)),
             d->controlFrame.paintopBox(), SLOT(slotToolChanged(KoCanvasController*,int)));
 
     connect(&d->nodeManager, SIGNAL(sigNodeActivated(KisNodeSP)),
             resourceProvider(), SLOT(slotNodeActivated(KisNodeSP)));
 
     connect(resourceProvider()->resourceManager(), SIGNAL(canvasResourceChanged(int,QVariant)),
             d->controlFrame.paintopBox(), SLOT(slotCanvasResourceChanged(int,QVariant)));
 
     connect(KisPart::instance(), SIGNAL(sigViewAdded(KisView*)), SLOT(slotViewAdded(KisView*)));
     connect(KisPart::instance(), SIGNAL(sigViewRemoved(KisView*)), SLOT(slotViewRemoved(KisView*)));
 
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotUpdateAuthorProfileActions()));
     connect(KisConfigNotifier::instance(), SIGNAL(pixelGridModeChanged()), SLOT(slotUpdatePixelGridAction()));
 
     KisInputProfileManager::instance()->loadProfiles();
 
     KisConfig cfg;
     d->showFloatingMessage = cfg.showCanvasMessages();
 
 }
 
 
 KisViewManager::~KisViewManager()
 {
     KisConfig cfg;
     if (resourceProvider() && resourceProvider()->currentPreset()) {
         cfg.writeEntry("LastPreset", resourceProvider()->currentPreset()->name());
         cfg.writeKoColor("LastForeGroundColor",resourceProvider()->fgColor());
         cfg.writeKoColor("LastBackGroundColor",resourceProvider()->bgColor());
 
     }
 
     cfg.writeEntry("baseLength", KoResourceItemChooserSync::instance()->baseLength());
 
     delete d;
 }
 
 void KisViewManager::initializeResourceManager(KoCanvasResourceManager *resourceManager)
 {
     resourceManager->addDerivedResourceConverter(toQShared(new KisCompositeOpResourceConverter));
     resourceManager->addDerivedResourceConverter(toQShared(new KisEffectiveCompositeOpResourceConverter));
     resourceManager->addDerivedResourceConverter(toQShared(new KisOpacityResourceConverter));
     resourceManager->addDerivedResourceConverter(toQShared(new KisFlowResourceConverter));
     resourceManager->addDerivedResourceConverter(toQShared(new KisSizeResourceConverter));
     resourceManager->addDerivedResourceConverter(toQShared(new KisLodAvailabilityResourceConverter));
     resourceManager->addDerivedResourceConverter(toQShared(new KisLodSizeThresholdResourceConverter));
     resourceManager->addDerivedResourceConverter(toQShared(new KisLodSizeThresholdSupportedResourceConverter));
     resourceManager->addDerivedResourceConverter(toQShared(new KisEraserModeResourceConverter));
     resourceManager->addResourceUpdateMediator(toQShared(new KisPresetUpdateMediator));
 }
 
 KActionCollection *KisViewManager::actionCollection() const
 {
     return d->actionCollection;
 }
 
 void KisViewManager::slotViewAdded(KisView *view)
 {
     // WARNING: this slot is called even when a view from another main windows is added!
     //          Don't expect \p view be a child of this view manager!
     Q_UNUSED(view);
 
     if (viewCount() == 0) {
         d->statusBar.showAllStatusBarItems();
     }
 }
 
 void KisViewManager::slotViewRemoved(KisView *view)
 {
     // WARNING: this slot is called even when a view from another main windows is removed!
     //          Don't expect \p view be a child of this view manager!
     Q_UNUSED(view);
 
     if (viewCount() == 0) {
         d->statusBar.hideAllStatusBarItems();
     }
 }
 
 void KisViewManager::setCurrentView(KisView *view)
 {
     bool first = true;
     if (d->currentImageView) {
         d->currentImageView->notifyCurrentStateChanged(false);
 
         d->currentImageView->canvasBase()->setCursor(QCursor(Qt::ArrowCursor));
         first = false;
         KisDocument* doc = d->currentImageView->document();
         if (doc) {
             doc->image()->compositeProgressProxy()->removeProxy(d->persistentImageProgressUpdater);
             doc->disconnect(this);
         }
         d->currentImageView->canvasController()->proxyObject->disconnect(&d->statusBar);
         d->viewConnections.clear();
     }
 
 
     QPointer<KisView> imageView = qobject_cast<KisView*>(view);
     d->currentImageView = imageView;
 
     if (imageView) {
         d->softProof->setChecked(imageView->softProofing());
         d->gamutCheck->setChecked(imageView->gamutCheck());
 
         // Wait for the async image to have loaded
         KisDocument* doc = view->document();
         //        connect(canvasController()->proxyObject, SIGNAL(documentMousePositionChanged(QPointF)), d->statusBar, SLOT(documentMousePositionChanged(QPointF)));
 
         // Restore the last used brush preset, color and background color.
         if (first) {
             KisConfig cfg;
             KisPaintOpPresetResourceServer * rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
             QString defaultPresetName = "basic_tip_default";
             bool foundTip = false;
             for (int i=0; i<rserver->resourceCount(); i++) {
                 KisPaintOpPresetSP resource = rserver->resources().at(i);
                 if (resource->name().toLower().contains("basic_tip_default")) {
                     defaultPresetName = resource->name();
                     foundTip = true;
                 } else if (foundTip == false && (resource->name().toLower().contains("default") ||
                                                  resource->filename().toLower().contains("default"))) {
                     defaultPresetName = resource->name();
                     foundTip = true;
                 }
             }
             QString lastPreset = cfg.readEntry("LastPreset", defaultPresetName);
             KisPaintOpPresetSP preset = rserver->resourceByName(lastPreset);
             if (!preset) {
                 preset = rserver->resourceByName(defaultPresetName);
             }
 
             if (!preset) {
                 preset = rserver->resources().first();
             }
             if (preset) {
                 paintOpBox()->restoreResource(preset.data());
             }
 
             const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
             KoColor foreground(Qt::black, cs);
             d->canvasResourceProvider.setFGColor(cfg.readKoColor("LastForeGroundColor",foreground));
             KoColor background(Qt::white, cs);
             d->canvasResourceProvider.setBGColor(cfg.readKoColor("LastBackGroundColor",background));
 
         }
 
         KisCanvasController *canvasController = dynamic_cast<KisCanvasController*>(d->currentImageView->canvasController());
 
         d->viewConnections.addUniqueConnection(&d->nodeManager, SIGNAL(sigNodeActivated(KisNodeSP)), doc->image(), SLOT(requestStrokeEndActiveNode()));
         d->viewConnections.addUniqueConnection(d->rotateCanvasRight, SIGNAL(triggered()), canvasController, SLOT(rotateCanvasRight15()));
         d->viewConnections.addUniqueConnection(d->rotateCanvasLeft, SIGNAL(triggered()),canvasController, SLOT(rotateCanvasLeft15()));
         d->viewConnections.addUniqueConnection(d->resetCanvasRotation, SIGNAL(triggered()),canvasController, SLOT(resetCanvasRotation()));
 
         d->viewConnections.addUniqueConnection(d->wrapAroundAction, SIGNAL(toggled(bool)), canvasController, SLOT(slotToggleWrapAroundMode(bool)));
         d->wrapAroundAction->setChecked(canvasController->wrapAroundMode());
 
         d->viewConnections.addUniqueConnection(d->levelOfDetailAction, SIGNAL(toggled(bool)), canvasController, SLOT(slotToggleLevelOfDetailMode(bool)));
         d->levelOfDetailAction->setChecked(canvasController->levelOfDetailMode());
 
         d->viewConnections.addUniqueConnection(d->currentImageView->image(), SIGNAL(sigColorSpaceChanged(const KoColorSpace*)), d->controlFrame.paintopBox(), SLOT(slotColorSpaceChanged(const KoColorSpace*)));
         d->viewConnections.addUniqueConnection(d->showRulersAction, SIGNAL(toggled(bool)), imageView->zoomManager(), SLOT(setShowRulers(bool)));
         d->viewConnections.addUniqueConnection(d->rulersTrackMouseAction, SIGNAL(toggled(bool)), imageView->zoomManager(), SLOT(setRulersTrackMouse(bool)));
         d->viewConnections.addUniqueConnection(d->zoomTo100pct, SIGNAL(triggered()), imageView->zoomManager(), SLOT(zoomTo100()));
         d->viewConnections.addUniqueConnection(d->zoomIn, SIGNAL(triggered()), imageView->zoomController()->zoomAction(), SLOT(zoomIn()));
         d->viewConnections.addUniqueConnection(d->zoomOut, SIGNAL(triggered()), imageView->zoomController()->zoomAction(), SLOT(zoomOut()));
 
         d->viewConnections.addUniqueConnection(d->softProof, SIGNAL(toggled(bool)), view, SLOT(slotSoftProofing(bool)) );
         d->viewConnections.addUniqueConnection(d->gamutCheck, SIGNAL(toggled(bool)), view, SLOT(slotGamutCheck(bool)) );
 
         // set up progrress reporting
         doc->image()->compositeProgressProxy()->addProxy(d->persistentImageProgressUpdater);
         d->viewConnections.addUniqueConnection(&d->statusBar, SIGNAL(sigCancellationRequested()), doc->image(), SLOT(requestStrokeCancellation()));
 
         d->viewConnections.addUniqueConnection(d->showPixelGrid, SIGNAL(toggled(bool)), canvasController, SLOT(slotTogglePixelGrid(bool)));
 
         imageView->zoomManager()->setShowRulers(d->showRulersAction->isChecked());
         imageView->zoomManager()->setRulersTrackMouse(d->rulersTrackMouseAction->isChecked());
 
         showHideScrollbars();
     }
 
     d->filterManager.setView(imageView);
     d->selectionManager.setView(imageView);
     d->guidesManager.setView(imageView);
     d->nodeManager.setView(imageView);
     d->imageManager.setView(imageView);
     d->canvasControlsManager.setView(imageView);
     d->actionManager.setView(imageView);
     d->gridManager.setView(imageView);
     d->statusBar.setView(imageView);
     d->paintingAssistantsManager.setView(imageView);
     d->mirrorManager.setView(imageView);
 
     if (d->currentImageView) {
         d->currentImageView->notifyCurrentStateChanged(true);
         d->currentImageView->canvasController()->activate();
         d->currentImageView->canvasController()->setFocus();
 
         d->viewConnections.addUniqueConnection(
             image(), SIGNAL(sigSizeChanged(const QPointF&, const QPointF&)),
             resourceProvider(), SLOT(slotImageSizeChanged()));
 
         d->viewConnections.addUniqueConnection(
             image(), SIGNAL(sigResolutionChanged(double,double)),
             resourceProvider(), SLOT(slotOnScreenResolutionChanged()));
 
         d->viewConnections.addUniqueConnection(
             image(), SIGNAL(sigNodeChanged(KisNodeSP)),
             this, SLOT(updateGUI()));
 
         d->viewConnections.addUniqueConnection(
             d->currentImageView->zoomManager()->zoomController(),
             SIGNAL(zoomChanged(KoZoomMode::Mode,qreal)),
             resourceProvider(), SLOT(slotOnScreenResolutionChanged()));
 
     }
 
     d->actionManager.updateGUI();
 
     resourceProvider()->slotImageSizeChanged();
     resourceProvider()->slotOnScreenResolutionChanged();
 
     Q_EMIT viewChanged();
 }
 
 
 KoZoomController *KisViewManager::zoomController() const
 {
     if (d->currentImageView) {
         return d->currentImageView->zoomController();
     }
     return 0;
 }
 
 KisImageWSP KisViewManager::image() const
 {
     if (document()) {
         return document()->image();
     }
     return 0;
 }
 
 KisCanvasResourceProvider * KisViewManager::resourceProvider()
 {
     return &d->canvasResourceProvider;
 }
 
 KisCanvas2 * KisViewManager::canvasBase() const
 {
     if (d && d->currentImageView) {
         return d->currentImageView->canvasBase();
     }
     return 0;
 }
 
 QWidget* KisViewManager::canvas() const
 {
     if (d && d->currentImageView && d->currentImageView->canvasBase()->canvasWidget()) {
         return d->currentImageView->canvasBase()->canvasWidget();
     }
     return 0;
 }
 
 KisStatusBar * KisViewManager::statusBar() const
 {
     return &d->statusBar;
 }
 
 void KisViewManager::addStatusBarItem(QWidget *widget, int stretch, bool permanent)
 {
     d->statusBar.addStatusBarItem(widget, stretch, permanent);
 }
 
 void KisViewManager::removeStatusBarItem(QWidget *widget)
 {
     d->statusBar.removeStatusBarItem(widget);
 }
 
 KisPaintopBox* KisViewManager::paintOpBox() const
 {
     return d->controlFrame.paintopBox();
 }
 
 QPointer<KoUpdater> KisViewManager::createUnthreadedUpdater(const QString &name)
 {
     return d->persistentUnthreadedProgressUpdaterRouter->startSubtask(1, name, false);
 }
 
 QPointer<KoUpdater> KisViewManager::createThreadedUpdater(const QString &name)
 {
     return d->statusBar.progressUpdater()->startSubtask(1, name, false);
 }
 
 KisSelectionManager * KisViewManager::selectionManager()
 {
     return &d->selectionManager;
 }
 
 KisNodeSP KisViewManager::activeNode()
 {
     return d->nodeManager.activeNode();
 }
 
 KisLayerSP KisViewManager::activeLayer()
 {
     return d->nodeManager.activeLayer();
 }
 
 KisPaintDeviceSP KisViewManager::activeDevice()
 {
     return d->nodeManager.activePaintDevice();
 }
 
 KisZoomManager * KisViewManager::zoomManager()
 {
     if (d->currentImageView) {
         return d->currentImageView->zoomManager();
     }
     return 0;
 }
 
 KisFilterManager * KisViewManager::filterManager()
 {
     return &d->filterManager;
 }
 
 KisImageManager * KisViewManager::imageManager()
 {
     return &d->imageManager;
 }
 
 KisInputManager* KisViewManager::inputManager() const
 {
     return &d->inputManager;
 }
 
 KisSelectionSP KisViewManager::selection()
 {
     if (d->currentImageView) {
         return d->currentImageView->selection();
     }
     return 0;
 
 }
 
 bool KisViewManager::selectionEditable()
 {
     KisLayerSP layer = activeLayer();
     if (layer) {
         KoProperties properties;
         QList<KisNodeSP> masks = layer->childNodes(QStringList("KisSelectionMask"), properties);
         if (masks.size() == 1) {
             return masks[0]->isEditable();
         }
     }
     // global selection is always editable
     return true;
 }
 
 KisUndoAdapter * KisViewManager::undoAdapter()
 {
     if (!document()) return 0;
 
     KisImageWSP image = document()->image();
     Q_ASSERT(image);
 
     return image->undoAdapter();
 }
 
 void KisViewManager::createActions()
 {
     KisConfig cfg;
 
     d->saveIncremental = actionManager()->createAction("save_incremental_version");
     connect(d->saveIncremental, SIGNAL(triggered()), this, SLOT(slotSaveIncremental()));
 
     d->saveIncrementalBackup = actionManager()->createAction("save_incremental_backup");
     connect(d->saveIncrementalBackup, SIGNAL(triggered()), this, SLOT(slotSaveIncrementalBackup()));
 
     connect(mainWindow(), SIGNAL(documentSaved()), this, SLOT(slotDocumentSaved()));
 
     d->saveIncremental->setEnabled(false);
     d->saveIncrementalBackup->setEnabled(false);
 
     KisAction *tabletDebugger = actionManager()->createAction("tablet_debugger");
     connect(tabletDebugger, SIGNAL(triggered()), this, SLOT(toggleTabletLogger()));
 
     d->createTemplate = actionManager()->createAction("create_template");
     connect(d->createTemplate, SIGNAL(triggered()), this, SLOT(slotCreateTemplate()));
 
     d->createCopy = actionManager()->createAction("create_copy");
     connect(d->createCopy, SIGNAL(triggered()), this, SLOT(slotCreateCopy()));
 
     d->openResourcesDirectory = actionManager()->createAction("open_resources_directory");
     connect(d->openResourcesDirectory, SIGNAL(triggered()), SLOT(openResourcesDirectory()));
 
     d->rotateCanvasRight   = actionManager()->createAction("rotate_canvas_right");
     d->rotateCanvasLeft    = actionManager()->createAction("rotate_canvas_left");
     d->resetCanvasRotation = actionManager()->createAction("reset_canvas_rotation");
     d->wrapAroundAction    = actionManager()->createAction("wrap_around_mode");
     d->levelOfDetailAction = actionManager()->createAction("level_of_detail_mode");
     d->softProof           = actionManager()->createAction("softProof");
     d->gamutCheck          = actionManager()->createAction("gamutCheck");
 
     KisAction *tAction = actionManager()->createAction("showStatusBar");
     tAction->setChecked(cfg.showStatusBar());
     connect(tAction, SIGNAL(toggled(bool)), this, SLOT(showStatusBar(bool)));
 
     tAction = actionManager()->createAction("view_show_canvas_only");
     tAction->setChecked(false);
     connect(tAction, SIGNAL(toggled(bool)), this, SLOT(switchCanvasOnly(bool)));
 
     //Workaround, by default has the same shortcut as mirrorCanvas
     KisAction *a = dynamic_cast<KisAction*>(actionCollection()->action("format_italic"));
     if (a) {
         a->setDefaultShortcut(QKeySequence());
     }
 
     a = actionManager()->createAction("edit_blacklist_cleanup");
     connect(a, SIGNAL(triggered()), this, SLOT(slotBlacklistCleanup()));
 
     actionManager()->createAction("ruler_pixel_multiple2");
     d->showRulersAction = actionManager()->createAction("view_ruler");
     d->showRulersAction->setChecked(cfg.showRulers());
     connect(d->showRulersAction, SIGNAL(toggled(bool)), SLOT(slotSaveShowRulersState(bool)));
 
     d->rulersTrackMouseAction = actionManager()->createAction("rulers_track_mouse");
     d->rulersTrackMouseAction->setChecked(cfg.rulersTrackMouse());
     connect(d->rulersTrackMouseAction, SIGNAL(toggled(bool)), SLOT(slotSaveRulersTrackMouseState(bool)));
 
     d->zoomTo100pct = actionManager()->createAction("zoom_to_100pct");
 
     d->zoomIn = actionManager()->createStandardAction(KStandardAction::ZoomIn, 0, "");
     d->zoomOut = actionManager()->createStandardAction(KStandardAction::ZoomOut, 0, "");
 
     d->actionAuthor  = new KSelectAction(KisIconUtils::loadIcon("im-user"), i18n("Active Author Profile"), this);
     connect(d->actionAuthor, SIGNAL(triggered(const QString &)), this, SLOT(changeAuthorProfile(const QString &)));
     actionCollection()->addAction("settings_active_author", d->actionAuthor);
     slotUpdateAuthorProfileActions();
 
     d->showPixelGrid = actionManager()->createAction("view_pixel_grid");
     slotUpdatePixelGridAction();
 }
 
 void KisViewManager::setupManagers()
 {
     // Create the managers for filters, selections, layers etc.
     // XXX: When the currentlayer changes, call updateGUI on all
     // managers
 
     d->filterManager.setup(actionCollection(), actionManager());
 
     d->selectionManager.setup(actionManager());
 
     d->guidesManager.setup(actionManager());
 
     d->nodeManager.setup(actionCollection(), actionManager());
 
     d->imageManager.setup(actionManager());
 
     d->gridManager.setup(actionManager());
 
     d->paintingAssistantsManager.setup(actionManager());
 
     d->canvasControlsManager.setup(actionManager());
 
     d->mirrorManager.setup(actionCollection());
-
-    d->scriptManager.setup(actionCollection(), actionManager());
 }
 
 void KisViewManager::updateGUI()
 {
     d->guiUpdateCompressor.start();
 }
 
 void KisViewManager::slotBlacklistCleanup()
 {
     KisDlgBlacklistCleanup dialog;
     dialog.exec();
 }
 
 KisNodeManager * KisViewManager::nodeManager() const
 {
     return &d->nodeManager;
 }
 
 KisActionManager* KisViewManager::actionManager() const
 {
     return &d->actionManager;
 }
 
 KisGridManager * KisViewManager::gridManager() const
 {
     return &d->gridManager;
 }
 
 KisGuidesManager * KisViewManager::guidesManager() const
 {
     return &d->guidesManager;
 }
 
 KisDocument *KisViewManager::document() const
 {
     if (d->currentImageView && d->currentImageView->document()) {
         return d->currentImageView->document();
     }
     return 0;
 }
 
-KisScriptManager *KisViewManager::scriptManager() const
-{
-  return &d->scriptManager;
-}
-
 int KisViewManager::viewCount() const
 {
     KisMainWindow *mw  = qobject_cast<KisMainWindow*>(d->mainWindow);
     if (mw) {
         return mw->viewCount();
     }
     return 0;
 }
 
 bool KisViewManager::KisViewManagerPrivate::blockUntilOperationsFinishedImpl(KisImageSP image, bool force)
 {
     const int busyWaitDelay = 1000;
     KisDelayedSaveDialog dialog(image, !force ? KisDelayedSaveDialog::GeneralDialog : KisDelayedSaveDialog::ForcedDialog, busyWaitDelay, mainWindow);
     dialog.blockIfImageIsBusy();
 
     return dialog.result() == QDialog::Accepted;
 }
 
 
 bool KisViewManager::blockUntilOperationsFinished(KisImageSP image)
 {
     return d->blockUntilOperationsFinishedImpl(image, false);
 }
 
 void KisViewManager::blockUntilOperationsFinishedForced(KisImageSP image)
 {
     d->blockUntilOperationsFinishedImpl(image, true);
 }
 
 void KisViewManager::slotCreateTemplate()
 {
     if (!document()) return;
     KisTemplateCreateDia::createTemplate( QStringLiteral("templates/"), ".kra", document(), mainWindow());
 }
 
 void KisViewManager::slotCreateCopy()
 {
     KisDocument *srcDoc = document();
     if (!srcDoc) return;
 
     if (!this->blockUntilOperationsFinished(srcDoc->image())) return;
 
     KisDocument *doc = 0;
     {
         KisImageBarrierLocker l(srcDoc->image());
         doc = srcDoc->clone();
     }
     KIS_SAFE_ASSERT_RECOVER_RETURN(doc);
 
     QString name = srcDoc->documentInfo()->aboutInfo("name");
     if (name.isEmpty()) {
         name = document()->url().toLocalFile();
     }
     name = i18n("%1 (Copy)", name);
     doc->documentInfo()->setAboutInfo("title", name);
 
     KisPart::instance()->addDocument(doc);
     KisMainWindow *mw  = qobject_cast<KisMainWindow*>(d->mainWindow);
     mw->addViewAndNotifyLoadingCompleted(doc);
 }
 
 
 QMainWindow* KisViewManager::qtMainWindow() const
 {
     if (d->mainWindow)
         return d->mainWindow;
 
     //Fallback for when we have not yet set the main window.
     QMainWindow* w = qobject_cast<QMainWindow*>(qApp->activeWindow());
     if(w)
         return w;
 
     return mainWindow();
 }
 
 void KisViewManager::setQtMainWindow(QMainWindow* newMainWindow)
 {
     d->mainWindow = newMainWindow;
 }
 
 void KisViewManager::slotDocumentSaved()
 {
     d->saveIncremental->setEnabled(true);
     d->saveIncrementalBackup->setEnabled(true);
 }
 
 void KisViewManager::slotSaveIncremental()
 {
     if (!document()) return;
 
     if (document()->url().isEmpty()) {
         KisMainWindow *mw = qobject_cast<KisMainWindow*>(d->mainWindow);
         mw->saveDocument(document(), true, false);
         return;
     }
 
     bool foundVersion;
     bool fileAlreadyExists;
     bool isBackup;
     QString version = "000";
     QString newVersion;
     QString letter;
     QString fileName = document()->localFilePath();
 
     // Find current version filenames
     // v v Regexp to find incremental versions in the filename, taking our backup scheme into account as well
     // Considering our incremental version and backup scheme, format is filename_001~001.ext
     QRegExp regex("_\\d{1,4}[.]|_\\d{1,4}[a-z][.]|_\\d{1,4}[~]|_\\d{1,4}[a-z][~]");
     regex.indexIn(fileName);     //  Perform the search
     QStringList matches = regex.capturedTexts();
     foundVersion = matches.at(0).isEmpty() ? false : true;
 
     // Ensure compatibility with Save Incremental Backup
     // If this regex is not kept separate, the entire algorithm needs modification;
     // It's simpler to just add this.
     QRegExp regexAux("_\\d{1,4}[~]|_\\d{1,4}[a-z][~]");
     regexAux.indexIn(fileName);     //  Perform the search
     QStringList matchesAux = regexAux.capturedTexts();
     isBackup = matchesAux.at(0).isEmpty() ? false : true;
 
     // If the filename has a version, prepare it for incrementation
     if (foundVersion) {
         version = matches.at(matches.count() - 1);     //  Look at the last index, we don't care about other matches
         if (version.contains(QRegExp("[a-z]"))) {
             version.chop(1);             //  Trim "."
             letter = version.right(1);   //  Save letter
             version.chop(1);             //  Trim letter
         } else {
             version.chop(1);             //  Trim "."
         }
         version.remove(0, 1);            //  Trim "_"
     } else {
         // TODO: this will not work with files extensions like jp2
         // ...else, simply add a version to it so the next loop works
         QRegExp regex2("[.][a-z]{2,4}$");  //  Heuristic to find file extension
         regex2.indexIn(fileName);
         QStringList matches2 = regex2.capturedTexts();
         QString extensionPlusVersion = matches2.at(0);
         extensionPlusVersion.prepend(version);
         extensionPlusVersion.prepend("_");
         fileName.replace(regex2, extensionPlusVersion);
     }
 
     // Prepare the base for new version filename
     int intVersion = version.toInt(0);
     ++intVersion;
     QString baseNewVersion = QString::number(intVersion);
     while (baseNewVersion.length() < version.length()) {
         baseNewVersion.prepend("0");
     }
 
     // Check if the file exists under the new name and search until options are exhausted (test appending a to z)
     do {
         newVersion = baseNewVersion;
         newVersion.prepend("_");
         if (!letter.isNull()) newVersion.append(letter);
         if (isBackup) {
             newVersion.append("~");
         } else {
             newVersion.append(".");
         }
         fileName.replace(regex, newVersion);
         fileAlreadyExists = QFile(fileName).exists();
         if (fileAlreadyExists) {
             if (!letter.isNull()) {
                 char letterCh = letter.at(0).toLatin1();
                 ++letterCh;
                 letter = QString(QChar(letterCh));
             } else {
                 letter = 'a';
             }
         }
     } while (fileAlreadyExists && letter != "{");  // x, y, z, {...
 
     if (letter == "{") {
         QMessageBox::critical(mainWindow(), i18nc("@title:window", "Couldn't save incremental version"), i18n("Alternative names exhausted, try manually saving with a higher number"));
         return;
     }
     document()->setFileBatchMode(true);
     document()->saveAs(QUrl::fromUserInput(fileName), document()->mimeType(), true);
     document()->setFileBatchMode(false);
 
     if (mainWindow()) {
         mainWindow()->updateCaption();
     }
 
 }
 
 void KisViewManager::slotSaveIncrementalBackup()
 {
     if (!document()) return;
 
     if (document()->url().isEmpty()) {
         KisMainWindow *mw = qobject_cast<KisMainWindow*>(d->mainWindow);
         mw->saveDocument(document(), true, false);
         return;
     }
 
     bool workingOnBackup;
     bool fileAlreadyExists;
     QString version = "000";
     QString newVersion;
     QString letter;
     QString fileName = document()->localFilePath();
 
     // First, discover if working on a backup file, or a normal file
     QRegExp regex("~\\d{1,4}[.]|~\\d{1,4}[a-z][.]");
     regex.indexIn(fileName);     //  Perform the search
     QStringList matches = regex.capturedTexts();
     workingOnBackup = matches.at(0).isEmpty() ? false : true;
 
     if (workingOnBackup) {
         // Try to save incremental version (of backup), use letter for alt versions
         version = matches.at(matches.count() - 1);     //  Look at the last index, we don't care about other matches
         if (version.contains(QRegExp("[a-z]"))) {
             version.chop(1);             //  Trim "."
             letter = version.right(1);   //  Save letter
             version.chop(1);             //  Trim letter
         } else {
             version.chop(1);             //  Trim "."
         }
         version.remove(0, 1);            //  Trim "~"
 
         // Prepare the base for new version filename
         int intVersion = version.toInt(0);
         ++intVersion;
         QString baseNewVersion = QString::number(intVersion);
         QString backupFileName = document()->localFilePath();
         while (baseNewVersion.length() < version.length()) {
             baseNewVersion.prepend("0");
         }
 
         // Check if the file exists under the new name and search until options are exhausted (test appending a to z)
         do {
             newVersion = baseNewVersion;
             newVersion.prepend("~");
             if (!letter.isNull()) newVersion.append(letter);
             newVersion.append(".");
             backupFileName.replace(regex, newVersion);
             fileAlreadyExists = QFile(backupFileName).exists();
             if (fileAlreadyExists) {
                 if (!letter.isNull()) {
                     char letterCh = letter.at(0).toLatin1();
                     ++letterCh;
                     letter = QString(QChar(letterCh));
                 } else {
                     letter = 'a';
                 }
             }
         } while (fileAlreadyExists && letter != "{");  // x, y, z, {...
 
         if (letter == "{") {
             QMessageBox::critical(mainWindow(), i18nc("@title:window", "Couldn't save incremental backup"), i18n("Alternative names exhausted, try manually saving with a higher number"));
             return;
         }
         QFile::copy(fileName, backupFileName);
         document()->saveAs(QUrl::fromUserInput(fileName), document()->mimeType(), true);
 
         if (mainWindow()) mainWindow()->updateCaption();
     }
     else { // if NOT working on a backup...
         // Navigate directory searching for latest backup version, ignore letters
         const quint8 HARDCODED_DIGIT_COUNT = 3;
         QString baseNewVersion = "000";
         QString backupFileName = document()->localFilePath();
         QRegExp regex2("[.][a-z]{2,4}$");  //  Heuristic to find file extension
         regex2.indexIn(backupFileName);
         QStringList matches2 = regex2.capturedTexts();
         QString extensionPlusVersion = matches2.at(0);
         extensionPlusVersion.prepend(baseNewVersion);
         extensionPlusVersion.prepend("~");
         backupFileName.replace(regex2, extensionPlusVersion);
 
         // Save version with 1 number higher than the highest version found ignoring letters
         do {
             newVersion = baseNewVersion;
             newVersion.prepend("~");
             newVersion.append(".");
             backupFileName.replace(regex, newVersion);
             fileAlreadyExists = QFile(backupFileName).exists();
             if (fileAlreadyExists) {
                 // Prepare the base for new version filename, increment by 1
                 int intVersion = baseNewVersion.toInt(0);
                 ++intVersion;
                 baseNewVersion = QString::number(intVersion);
                 while (baseNewVersion.length() < HARDCODED_DIGIT_COUNT) {
                     baseNewVersion.prepend("0");
                 }
             }
         } while (fileAlreadyExists);
 
         // Save both as backup and on current file for interapplication workflow
         document()->setFileBatchMode(true);
         QFile::copy(fileName, backupFileName);
         document()->saveAs(QUrl::fromUserInput(fileName), document()->mimeType(), true);
         document()->setFileBatchMode(false);
 
         if (mainWindow()) mainWindow()->updateCaption();
     }
 }
 
 void KisViewManager::disableControls()
 {
     // prevents possible crashes, if somebody changes the paintop during dragging by using the mousewheel
     // this is for Bug 250944
     // the solution blocks all wheel, mouse and key event, while dragging with the freehand tool
     // see KisToolFreehand::initPaint() and endPaint()
     d->controlFrame.paintopBox()->installEventFilter(&d->blockingEventFilter);
     Q_FOREACH (QObject* child, d->controlFrame.paintopBox()->children()) {
         child->installEventFilter(&d->blockingEventFilter);
     }
 }
 
 void KisViewManager::enableControls()
 {
     d->controlFrame.paintopBox()->removeEventFilter(&d->blockingEventFilter);
     Q_FOREACH (QObject* child, d->controlFrame.paintopBox()->children()) {
         child->removeEventFilter(&d->blockingEventFilter);
     }
 }
 
 void KisViewManager::showStatusBar(bool toggled)
 {
     KisMainWindow *mw = mainWindow();
     if(mw && mw->statusBar()) {
         mw->statusBar()->setVisible(toggled);
         KisConfig cfg;
         cfg.setShowStatusBar(toggled);
     }
 }
 
 void KisViewManager::switchCanvasOnly(bool toggled)
 {
     KisConfig cfg;
     KisMainWindow* main = mainWindow();
 
     if(!main) {
         dbgUI << "Unable to switch to canvas-only mode, main window not found";
         return;
     }
 
     if (toggled) {
         d->canvasState = qtMainWindow()->saveState();
 #if QT_VERSION < QT_VERSION_CHECK(5, 10, 0)
         d->windowFlags = main->windowState();
 #endif
     }
 
     if (cfg.hideStatusbarFullscreen()) {
         if (main->statusBar()) {
             if (!toggled) {
                 if (main->statusBar()->dynamicPropertyNames().contains("wasvisible")) {
                     if (main->statusBar()->property("wasvisible").toBool()) {
                         main->statusBar()->setVisible(true);
                     }
                 }
             }
             else {
                 main->statusBar()->setProperty("wasvisible", main->statusBar()->isVisible());
                 main->statusBar()->setVisible(false);
             }
         }
     }
 
     if (cfg.hideDockersFullscreen()) {
         KisAction* action = qobject_cast<KisAction*>(main->actionCollection()->action("view_toggledockers"));
         if (action) {
             action->setCheckable(true);
             if (toggled) {
                 if (action->isChecked()) {
                     cfg.setShowDockers(action->isChecked());
                     action->setChecked(false);
                 } else {
                     cfg.setShowDockers(false);
                 }
             } else {
                 action->setChecked(cfg.showDockers());
             }
         }
     }
 
     // QT in windows does not return to maximized upon 4th tab in a row
     // https://bugreports.qt.io/browse/QTBUG-57882, https://bugreports.qt.io/browse/QTBUG-52555, https://codereview.qt-project.org/#/c/185016/
     if (cfg.hideTitlebarFullscreen() && !cfg.fullscreenMode()) {
         if(toggled) {
             main->setWindowState( main->windowState() | Qt::WindowFullScreen);
         } else {
             main->setWindowState( main->windowState() & ~Qt::WindowFullScreen);
 #if QT_VERSION < QT_VERSION_CHECK(5, 10, 0)
             // If window was maximized prior to fullscreen, restore that
             if (d->windowFlags & Qt::WindowMaximized) {
                 main->setWindowState( main->windowState() | Qt::WindowMaximized);
             }
 #endif
         }
     }
 
     if (cfg.hideMenuFullscreen()) {
         if (!toggled) {
             if (main->menuBar()->dynamicPropertyNames().contains("wasvisible")) {
                 if (main->menuBar()->property("wasvisible").toBool()) {
                     main->menuBar()->setVisible(true);
                 }
             }
         }
         else {
             main->menuBar()->setProperty("wasvisible", main->menuBar()->isVisible());
             main->menuBar()->setVisible(false);
         }
     }
 
     if (cfg.hideToolbarFullscreen()) {
         QList<QToolBar*> toolBars = main->findChildren<QToolBar*>();
         Q_FOREACH (QToolBar* toolbar, toolBars) {
             if (!toggled) {
                 if (toolbar->dynamicPropertyNames().contains("wasvisible")) {
                     if (toolbar->property("wasvisible").toBool()) {
                         toolbar->setVisible(true);
                     }
                 }
             }
             else {
                 toolbar->setProperty("wasvisible", toolbar->isVisible());
                 toolbar->setVisible(false);
             }
         }
     }
 
     showHideScrollbars();
 
     if (toggled) {
         // show a fading heads-up display about the shortcut to go back
 
         showFloatingMessage(i18n("Going into Canvas-Only mode.\nPress %1 to go back.",
                                  actionCollection()->action("view_show_canvas_only")->shortcut().toString()), QIcon());
     }
     else {
         main->restoreState(d->canvasState);
     }
 
 }
 
 void KisViewManager::toggleTabletLogger()
 {
     d->inputManager.toggleTabletLogger();
 }
 
 void KisViewManager::openResourcesDirectory()
 {
     QString dir = KoResourcePaths::locateLocal("data", "");
     QDesktopServices::openUrl(QUrl::fromLocalFile(dir));
 }
 
 void KisViewManager::updateIcons()
 {
     if (mainWindow()) {
         QList<QDockWidget*> dockers = mainWindow()->dockWidgets();
         Q_FOREACH (QDockWidget* dock, dockers) {
             dbgKrita << "name " << dock->objectName();
             KoDockWidgetTitleBar* titlebar = dynamic_cast<KoDockWidgetTitleBar*>(dock->titleBarWidget());
             if (titlebar) {
                 titlebar->updateIcons();
             }
 
             QObjectList objects;
             objects.append(dock);
             while (!objects.isEmpty()) {
                 QObject* object = objects.takeFirst();
                 objects.append(object->children());
                 KisIconUtils::updateIconCommon(object);
             }
         }
     }
 }
 void KisViewManager::initializeStatusBarVisibility()
 {
     KisConfig cfg;
     d->mainWindow->statusBar()->setVisible(cfg.showStatusBar());
 }
 
 void KisViewManager::guiUpdateTimeout()
 {
     d->nodeManager.updateGUI();
     d->selectionManager.updateGUI();
     d->filterManager.updateGUI();
     if (zoomManager()) {
         zoomManager()->updateGUI();
     }
     d->gridManager.updateGUI();
     d->actionManager.updateGUI();
 }
 
 void KisViewManager::showFloatingMessage(const QString &message, const QIcon& icon, int timeout, KisFloatingMessage::Priority priority, int alignment)
 {
     if (!d->currentImageView) return;
     d->currentImageView->showFloatingMessageImpl(message, icon, timeout, priority, alignment);
 
     emit floatingMessageRequested(message, icon.name());
 }
 
 KisMainWindow *KisViewManager::mainWindow() const
 {
     return qobject_cast<KisMainWindow*>(d->mainWindow);
 }
 
 
 void KisViewManager::showHideScrollbars()
 {
     if (!d->currentImageView) return;
     if (!d->currentImageView->canvasController()) return;
 
     KisConfig cfg;
     bool toggled = actionCollection()->action("view_show_canvas_only")->isChecked();
 
     if ( (toggled && cfg.hideScrollbarsFullscreen()) || (!toggled && cfg.hideScrollbars()) ) {
         d->currentImageView->canvasController()->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
         d->currentImageView->canvasController()->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
     } else {
         d->currentImageView->canvasController()->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
         d->currentImageView->canvasController()->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
     }
 }
 
 void KisViewManager::slotSaveShowRulersState(bool value)
 {
     KisConfig cfg;
     cfg.setShowRulers(value);
 }
 
 void KisViewManager::slotSaveRulersTrackMouseState(bool value)
 {
     KisConfig cfg;
     cfg.setRulersTrackMouse(value);
 }
 
 void KisViewManager::setShowFloatingMessage(bool show)
 {
     d->showFloatingMessage = show;
 }
 
 void KisViewManager::changeAuthorProfile(const QString &profileName)
 {
     KConfigGroup appAuthorGroup(KoGlobal::calligraConfig(), "Author");
     if (profileName.isEmpty() || profileName == i18nc("choice for author profile", "Anonymous")) {
         appAuthorGroup.writeEntry("active-profile", "");
     } else {
         appAuthorGroup.writeEntry("active-profile", profileName);
     }
     appAuthorGroup.sync();
     Q_FOREACH (KisDocument *doc, KisPart::instance()->documents()) {
         doc->documentInfo()->updateParameters();
     }
 }
 
 void KisViewManager::slotUpdateAuthorProfileActions()
 {
     Q_ASSERT(d->actionAuthor);
     if (!d->actionAuthor) {
         return;
     }
     d->actionAuthor->clear();
     d->actionAuthor->addAction(i18nc("choice for author profile", "Anonymous"));
 
     KConfigGroup authorGroup(KoGlobal::calligraConfig(), "Author");
     QStringList profiles = authorGroup.readEntry("profile-names", QStringList());
     QString authorInfo = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/authorinfo/";
     QStringList filters = QStringList() << "*.authorinfo";
     QDir dir(authorInfo);
     Q_FOREACH(QString entry, dir.entryList(filters)) {
         int ln = QString(".authorinfo").size();
         entry.chop(ln);
         if (!profiles.contains(entry)) {
             profiles.append(entry);
         }
     }
     Q_FOREACH (const QString &profile , profiles) {
         d->actionAuthor->addAction(profile);
     }
 
     KConfigGroup appAuthorGroup(KoGlobal::calligraConfig(), "Author");
     QString profileName = appAuthorGroup.readEntry("active-profile", "");
 
     if (profileName == "anonymous" || profileName.isEmpty()) {
         d->actionAuthor->setCurrentItem(0);
     } else if (profiles.contains(profileName)) {
         d->actionAuthor->setCurrentAction(profileName);
     }
 }
 
 void KisViewManager::slotUpdatePixelGridAction()
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(d->showPixelGrid);
 
     KisSignalsBlocker b(d->showPixelGrid);
 
     KisConfig cfg;
     d->showPixelGrid->setChecked(cfg.pixelGridEnabled());
 }
diff --git a/libs/ui/KisViewManager.h b/libs/ui/KisViewManager.h
index 095b2178d3..d09d93a863 100644
--- a/libs/ui/KisViewManager.h
+++ b/libs/ui/KisViewManager.h
@@ -1,274 +1,271 @@
 /*
  *  Copyright (c) 2006 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_GUI_CLIENT_H
 #define KIS_GUI_CLIENT_H
 
 #include <QDockWidget>
 #include <QQueue>
 #include <QPointer>
 
 #include <KisMainWindow.h>
 #include <KoToolManager.h>
 
 #include <kritaui_export.h>
 #include <kis_types.h>
 
 #include "kis_floating_message.h"
 
 class QPoint;
 class KisView;
 
 class KisCanvas2;
 class KisCanvasResourceProvider;
 class KisDocument;
 class KisFilterManager;
 class KisGridManager;
 class KisGuidesManager;
 class KisImageManager;
 class KisNodeManager;
 class KisDecorationsManager;
 class KisPaintopBox;
 class KisSelectionManager;
 class KisStatusBar;
 class KisUndoAdapter;
 class KisZoomManager;
 class KisPaintopBox;
 class KisActionManager;
-class KisScriptManager;
 class KisInputManager;
 class KoUpdater;
 class KoProgressUpdater;
 
 /**
  * KisViewManager manages the collection of views shown in a single mainwindow.
  */
 class KRITAUI_EXPORT KisViewManager : public QObject
 {
 
     Q_OBJECT
 
 public:
     /**
      * Construct a new view on the krita document.
      * @param document   the document we show.
      * @param parent   a parent widget we show ourselves in.
      */
     KisViewManager(QWidget *parent, KActionCollection *actionCollection);
     ~KisViewManager() override;
 
     /**
      * Retrieves the entire action collection.
      */
     virtual KActionCollection* actionCollection() const;
 
 public:  // Krita specific interfaces
 
     void setCurrentView(KisView *view);
 
     /// Return the image this view is displaying
     KisImageWSP image() const;
 
     KoZoomController *zoomController() const;
 
     /// The resource provider contains all per-view settings, such as
     /// current color, current paint op etc.
     KisCanvasResourceProvider *resourceProvider();
 
     /// Return the canvasbase class
     KisCanvas2 *canvasBase() const;
 
     /// Return the actual widget that is displaying the current image
     QWidget* canvas() const;
 
     /// Return the wrapper class around the statusbar
     KisStatusBar *statusBar() const;
 
     /**
       * This adds a widget to the statusbar for this view.
       * If you use this method instead of using statusBar() directly,
       * KisView will take care of removing the items when the view GUI is deactivated
       * and readding them when it is reactivated.
       * The parameters are the same as QStatusBar::addWidget().
     */
     void addStatusBarItem(QWidget * widget, int stretch = 0, bool permanent = false);
 
 
     /**
       * Remove a widget from the statusbar for this view.
       */
     void removeStatusBarItem(QWidget * widget);
 
     KisPaintopBox* paintOpBox() const;
 
     /// create a new progress updater
     QPointer<KoUpdater> createUnthreadedUpdater(const QString &name);
     QPointer<KoUpdater> createThreadedUpdater(const QString &name);
 
     /// The selection manager handles everything action related to
     /// selections.
     KisSelectionManager *selectionManager();
 
     /// The node manager handles everything about nodes
     KisNodeManager *nodeManager() const;
 
     KisActionManager *actionManager() const;
 
     /**
      * Convenience method to get at the active node, which may be
      * a layer or a mask or a selection
      */
     KisNodeSP activeNode();
 
     /// Convenience method to get at the active layer
     KisLayerSP activeLayer();
 
     /// Convenience method to get at the active paint device
     KisPaintDeviceSP activeDevice();
 
     /// The filtermanager handles everything action-related to filters
     KisFilterManager *filterManager();
 
     /// The image manager handles everything action-related to the
     /// current image
     KisImageManager *imageManager();
 
     /// Filters events and sends them to canvas actions
     KisInputManager *inputManager() const;
 
     /// Convenience method to get at the active selection (the
     /// selection of the current layer, or, if that does not exist,
     /// the global selection.
     KisSelectionSP selection();
 
     /// Checks if the current global or local selection is editable
     bool selectionEditable();
 
     /// The undo adapter is used to add commands to the undo stack
     KisUndoAdapter *undoAdapter();
 
     KisDocument *document() const;
 
-    KisScriptManager *scriptManager() const;
-
     int viewCount() const;
 
     /**
      * @brief blockUntilOperationsFinished blocks the GUI of the application until execution
      *        of actions on \p image is finished
      * @param image the image which we should wait for
      * @return true if the image has finished execution of the actions, false if
      *         the user cancelled operation
      */
     bool blockUntilOperationsFinished(KisImageSP image);
 
 
     /**
      * @brief blockUntilOperationsFinished blocks the GUI of the application until execution
      *        of actions on \p image is finished. Does *not* provide a "Cancel" button. So the
      *        user is forced to wait.
      * @param image the image which we should wait for
      */
     void blockUntilOperationsFinishedForced(KisImageSP image);
 
 public:
 
     KisGridManager * gridManager() const;
     KisGuidesManager * guidesManager() const;
 
     /// disable and enable toolbar controls. used for disabling them during painting.
     void enableControls();
     void disableControls();
 
 
     /// shows a floating message in the top right corner of the canvas
     void showFloatingMessage(const QString &message, const QIcon& icon, int timeout = 4500,
                              KisFloatingMessage::Priority priority = KisFloatingMessage::Medium,
                              int alignment = Qt::AlignCenter | Qt::TextWordWrap);
 
     /// @return the KoMaindow this view is in, or 0
     KisMainWindow *mainWindow() const;
 
     /// The QMainWindow associated with this view. This is most likely going to be shell(), but
     /// when running as Gemini or Sketch, this will be set to the applications' own QMainWindow.
     /// This can be checked by qobject_casting to KisMainWindow to check the difference.
     QMainWindow* qtMainWindow() const;
 
     /// The mainWindow function will return the shell() value, unless this function is called
     /// with a non-null value. To make it return shell() again, simply pass null to this function.
     void setQtMainWindow(QMainWindow* newMainWindow);
 
     static void initializeResourceManager(KoCanvasResourceManager *resourceManager);
 
 public Q_SLOTS:
 
     void switchCanvasOnly(bool toggled);
     void setShowFloatingMessage(bool show);
     void showHideScrollbars();
 
     /// Visit all managers to update gui elements, e.g. enable / disable actions.
     /// This is heavy-duty call, so it uses a compressor.
     void updateGUI();
 
     /// Update the style of all the icons
     void updateIcons();
 
     void slotViewAdded(KisView *view);
     void slotViewRemoved(KisView *view);
 
 Q_SIGNALS:
 
     void floatingMessageRequested(const QString &message, const QString &iconName);
     /**
      * @brief viewChanged
      * sent out when the view has changed.
      */
     void viewChanged();
 
 private Q_SLOTS:
 
     void slotBlacklistCleanup();
     void slotCreateTemplate();
     void slotCreateCopy();
     void slotDocumentSaved();
     void slotSaveIncremental();
     void slotSaveIncrementalBackup();
     void showStatusBar(bool toggled);
     void toggleTabletLogger();
     void openResourcesDirectory();
     void initializeStatusBarVisibility();
     void guiUpdateTimeout();
     void changeAuthorProfile(const QString &profileName);
     void slotUpdateAuthorProfileActions();
     void slotUpdatePixelGridAction();
     void slotSaveShowRulersState(bool value);
     void slotSaveRulersTrackMouseState(bool value);
 
 private:
     void createActions();
     void setupManagers();
 
     /// The zoommanager handles everything action-related to zooming
     KisZoomManager * zoomManager();
 
 private:
     class KisViewManagerPrivate;
     KisViewManagerPrivate * const d;
 };
 
 #endif
diff --git a/libs/ui/dialogs/KisAsyncAnimationCacheRenderDialog.cpp b/libs/ui/dialogs/KisAsyncAnimationCacheRenderDialog.cpp
index faeace2022..6e5054d161 100644
--- a/libs/ui/dialogs/KisAsyncAnimationCacheRenderDialog.cpp
+++ b/libs/ui/dialogs/KisAsyncAnimationCacheRenderDialog.cpp
@@ -1,137 +1,147 @@
 /*
  *  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 "KisAsyncAnimationCacheRenderDialog.h"
 
 #include "KisAsyncAnimationCacheRenderer.h"
 #include "kis_animation_frame_cache.h"
 #include <kis_time_range.h>
 #include <kis_image.h>
 #include <kis_image_animation_interface.h>
 
 namespace {
 
 QList<int> calcDirtyFramesList(KisAnimationFrameCacheSP cache, const KisTimeRange &playbackRange)
 {
     QList<int> result;
 
     KisImageSP image = cache->image();
     if (!image) return result;
 
     KisImageAnimationInterface *animation = image->animationInterface();
     if (!animation->hasAnimation()) return result;
 
     if (playbackRange.isValid()) {
         KIS_ASSERT_RECOVER_RETURN_VALUE(!playbackRange.isInfinite(), result);
 
         // TODO: optimize check for fully-cached case
         for (int frame = playbackRange.start(); frame <= playbackRange.end(); frame++) {
             KisTimeRange stillFrameRange = KisTimeRange::infinite(0);
             KisTimeRange::calculateTimeRangeRecursive(image->root(), frame, stillFrameRange, true);
 
             KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(stillFrameRange.isValid(), result);
 
             if (cache->frameStatus(stillFrameRange.start()) == KisAnimationFrameCache::Uncached) {
                 result.append(stillFrameRange.start());
             }
 
             if (stillFrameRange.isInfinite()) {
                 break;
             } else {
                 frame = stillFrameRange.end();
             }
         }
     }
 
     return result;
 }
 
 }
 
 int KisAsyncAnimationCacheRenderDialog::calcFirstDirtyFrame(KisAnimationFrameCacheSP cache, const KisTimeRange &playbackRange, const KisTimeRange &skipRange)
 {
     int result = -1;
 
     KisImageSP image = cache->image();
     if (!image) return result;
 
     KisImageAnimationInterface *animation = image->animationInterface();
     if (!animation->hasAnimation()) return result;
 
     if (playbackRange.isValid()) {
         KIS_ASSERT_RECOVER_RETURN_VALUE(!playbackRange.isInfinite(), result);
 
         // TODO: optimize check for fully-cached case
         for (int frame = playbackRange.start(); frame <= playbackRange.end(); frame++) {
             if (skipRange.contains(frame)) {
                 if (skipRange.isInfinite()) {
                     break;
                 } else {
                     frame = skipRange.end();
                     continue;
                 }
             }
 
             if (cache->frameStatus(frame) != KisAnimationFrameCache::Cached) {
                 result = frame;
                 break;
             }
         }
     }
 
     return result;
 }
 
 
 struct KisAsyncAnimationCacheRenderDialog::Private
 {
     Private(KisAnimationFrameCacheSP _cache, const KisTimeRange &_range)
         : cache(_cache),
           range(_range)
     {
     }
 
     KisAnimationFrameCacheSP cache;
     KisTimeRange range;
 };
 
 KisAsyncAnimationCacheRenderDialog::KisAsyncAnimationCacheRenderDialog(KisAnimationFrameCacheSP cache, const KisTimeRange &range, int busyWait)
     : KisAsyncAnimationRenderDialogBase(i18n("Regenerating cache..."), cache->image(), busyWait),
       m_d(new Private(cache, range))
 {
 }
 
 KisAsyncAnimationCacheRenderDialog::~KisAsyncAnimationCacheRenderDialog()
 {
 
 }
 
 QList<int> KisAsyncAnimationCacheRenderDialog::calcDirtyFrames() const
 {
     return calcDirtyFramesList(m_d->cache, m_d->range);
 }
 
 KisAsyncAnimationRendererBase *KisAsyncAnimationCacheRenderDialog::createRenderer(KisImageSP image)
 {
     Q_UNUSED(image);
+    return new KisAsyncAnimationCacheRenderer();
+}
+
+void KisAsyncAnimationCacheRenderDialog::initializeRendererForFrame(KisAsyncAnimationRendererBase *renderer, KisImageSP image, int frame)
+{
+    Q_UNUSED(image);
+    Q_UNUSED(frame);
+
+    KisAsyncAnimationCacheRenderer *cacheRenderer =
+        dynamic_cast<KisAsyncAnimationCacheRenderer*>(renderer);
+
+    KIS_SAFE_ASSERT_RECOVER_RETURN(cacheRenderer);
 
-    KisAsyncAnimationCacheRenderer *renderer = new KisAsyncAnimationCacheRenderer();
-    renderer->setFrameCache(m_d->cache);
-    return renderer;
+    cacheRenderer->setFrameCache(m_d->cache);
 }
 
diff --git a/libs/ui/dialogs/KisAsyncAnimationCacheRenderDialog.h b/libs/ui/dialogs/KisAsyncAnimationCacheRenderDialog.h
index c96eb85a8a..6c698b1c2e 100644
--- a/libs/ui/dialogs/KisAsyncAnimationCacheRenderDialog.h
+++ b/libs/ui/dialogs/KisAsyncAnimationCacheRenderDialog.h
@@ -1,43 +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 KISASYNCANIMATIONCACHERENDERDIALOG_H
 #define KISASYNCANIMATIONCACHERENDERDIALOG_H
 
 #include "KisAsyncAnimationRenderDialogBase.h"
 #include "kis_types.h"
 
 
 class KisAsyncAnimationCacheRenderDialog : public KisAsyncAnimationRenderDialogBase
 {
 public:
     KisAsyncAnimationCacheRenderDialog(KisAnimationFrameCacheSP cache, const KisTimeRange &range, int busyWait = 200);
     ~KisAsyncAnimationCacheRenderDialog();
 
     static int calcFirstDirtyFrame(KisAnimationFrameCacheSP cache, const KisTimeRange &playbackRange, const KisTimeRange &skipRange);
 
 protected:
     QList<int> calcDirtyFrames() const override;
     KisAsyncAnimationRendererBase* createRenderer(KisImageSP image) override;
+    void initializeRendererForFrame(KisAsyncAnimationRendererBase *renderer,
+                                    KisImageSP image, int frame) override;
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 #endif // KISASYNCANIMATIONCACHERENDERDIALOG_H
diff --git a/libs/ui/dialogs/KisAsyncAnimationFramesSaveDialog.cpp b/libs/ui/dialogs/KisAsyncAnimationFramesSaveDialog.cpp
index dadcea033a..c15d689842 100644
--- a/libs/ui/dialogs/KisAsyncAnimationFramesSaveDialog.cpp
+++ b/libs/ui/dialogs/KisAsyncAnimationFramesSaveDialog.cpp
@@ -1,174 +1,180 @@
 /*
  *  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 "KisAsyncAnimationFramesSaveDialog.h"
 
 #include <kis_image.h>
 #include <kis_time_range.h>
 
 #include <KisAsyncAnimationFramesSavingRenderer.h>
 #include "kis_properties_configuration.h"
 
 #include "KisMimeDatabase.h"
 
 #include <QFileInfo>
 #include <QDir>
 #include <QMessageBox>
 
 struct KisAsyncAnimationFramesSaveDialog::Private {
     Private(KisImageSP _image,
             const KisTimeRange &_range,
             const QString &baseFilename,
             int _sequenceNumberingOffset,
             KisPropertiesConfigurationSP _exportConfiguration)
         : originalImage(_image),
           range(_range),
           sequenceNumberingOffset(_sequenceNumberingOffset),
           exportConfiguration(_exportConfiguration)
     {
         int baseLength = baseFilename.lastIndexOf(".");
         if (baseLength > -1) {
             filenamePrefix = baseFilename.left(baseLength);
             filenameSuffix = baseFilename.right(baseFilename.length() - baseLength);
         } else {
             filenamePrefix = baseFilename;
         }
 
         outputMimeType = KisMimeDatabase::mimeTypeForFile(baseFilename, false).toLatin1();
     }
 
     KisImageSP originalImage;
     KisTimeRange range;
 
     QString filenamePrefix;
     QString filenameSuffix;
     QByteArray outputMimeType;
 
     int sequenceNumberingOffset;
     KisPropertiesConfigurationSP exportConfiguration;
 };
 
 KisAsyncAnimationFramesSaveDialog::KisAsyncAnimationFramesSaveDialog(KisImageSP originalImage,
                                                                      const KisTimeRange &range,
                                                                      const QString &baseFilename,
                                                                      int sequenceNumberingOffset,
                                                                      KisPropertiesConfigurationSP exportConfiguration)
     : KisAsyncAnimationRenderDialogBase("Saving frames...", originalImage, 0),
       m_d(new Private(originalImage, range, baseFilename, sequenceNumberingOffset, exportConfiguration))
 {
 
 
 }
 
 KisAsyncAnimationFramesSaveDialog::~KisAsyncAnimationFramesSaveDialog()
 {
 }
 
 KisAsyncAnimationRenderDialogBase::Result KisAsyncAnimationFramesSaveDialog::regenerateRange(KisViewManager *viewManager)
 {
     QFileInfo info(savedFilesMaskWildcard());
 
     QDir dir(info.absolutePath());
 
     if (!dir.exists()) {
         dir.mkpath(info.absolutePath());
     }
     KIS_SAFE_ASSERT_RECOVER_NOOP(dir.exists());
 
     QStringList filesList = dir.entryList({ info.fileName() });
 
     if (!filesList.isEmpty()) {
         if (batchMode()) {
             return RenderFailed;
         }
 
         QStringList truncatedList = filesList;
 
         while (truncatedList.size() > 3) {
             truncatedList.takeLast();
         }
 
         QString exampleFiles = truncatedList.join(", ");
         if (truncatedList.size() != filesList.size()) {
             exampleFiles += QString(", ...");
         }
 
         QMessageBox::StandardButton result =
                 QMessageBox::warning(0,
                                      i18n("Delete old frames?"),
                                      i18n("Frames with the same naming "
                                           "scheme exist in the destination "
                                           "directory. They are going to be "
                                           "deleted, continue?\n\n"
                                           "Directory: %1\n"
                                           "Files: %2",
                                           info.absolutePath(), exampleFiles),
                                      QMessageBox::Yes | QMessageBox::No,
                                      QMessageBox::No);
 
         if (result == QMessageBox::Yes) {
             Q_FOREACH (const QString &file, filesList) {
                 if (!dir.remove(file)) {
                     QMessageBox::critical(0,
                                           i18n("Failed to delete"),
                                           i18n("Failed to delete an old frame file:\n\n"
                                                "%1\n\n"
                                                "Rendering cancelled.", dir.absoluteFilePath(file)));
 
                     return RenderFailed;
                 }
             }
         } else {
             return RenderCancelled;
         }
     }
 
     return KisAsyncAnimationRenderDialogBase::regenerateRange(viewManager);
 }
 
 QList<int> KisAsyncAnimationFramesSaveDialog::calcDirtyFrames() const
 {
     // TODO: optimize!
     QList<int> result;
     for (int i = m_d->range.start(); i <= m_d->range.end(); i++) {
         result.append(i);
     }
     return result;
 }
 
 KisAsyncAnimationRendererBase *KisAsyncAnimationFramesSaveDialog::createRenderer(KisImageSP image)
 {
     return new KisAsyncAnimationFramesSavingRenderer(image,
                                                      m_d->filenamePrefix,
                                                      m_d->filenameSuffix,
                                                      m_d->outputMimeType,
                                                      m_d->range,
                                                      m_d->sequenceNumberingOffset,
                                                      m_d->exportConfiguration);
 }
 
+void KisAsyncAnimationFramesSaveDialog::initializeRendererForFrame(KisAsyncAnimationRendererBase *renderer, KisImageSP image, int frame)
+{
+    Q_UNUSED(renderer);
+    Q_UNUSED(image);
+    Q_UNUSED(frame);
+}
 
 QString KisAsyncAnimationFramesSaveDialog::savedFilesMask() const
 {
     return m_d->filenamePrefix + "%04d" + m_d->filenameSuffix;
 }
 
 QString KisAsyncAnimationFramesSaveDialog::savedFilesMaskWildcard() const
 {
     return m_d->filenamePrefix + "????" + m_d->filenameSuffix;
 }
diff --git a/libs/ui/dialogs/KisAsyncAnimationFramesSaveDialog.h b/libs/ui/dialogs/KisAsyncAnimationFramesSaveDialog.h
index dca29ab37c..02b65c6cd2 100644
--- a/libs/ui/dialogs/KisAsyncAnimationFramesSaveDialog.h
+++ b/libs/ui/dialogs/KisAsyncAnimationFramesSaveDialog.h
@@ -1,51 +1,53 @@
 /*
  *  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 KISASYNCANIMATIONFRAMESSAVEDIALOG_H
 #define KISASYNCANIMATIONFRAMESSAVEDIALOG_H
 
 #include "KisAsyncAnimationRenderDialogBase.h"
 #include "kis_types.h"
 
 
 class KRITAUI_EXPORT KisAsyncAnimationFramesSaveDialog : public KisAsyncAnimationRenderDialogBase
 {
 public:
     KisAsyncAnimationFramesSaveDialog(KisImageSP image,
                                       const KisTimeRange &range,
                                       const QString &baseFilename,
                                       int sequenceNumberingOffset,
                                       KisPropertiesConfigurationSP exportConfiguration);
 
     ~KisAsyncAnimationFramesSaveDialog();
 
     Result regenerateRange(KisViewManager *viewManager);
 
     QString savedFilesMask() const;
     QString savedFilesMaskWildcard() const;
 
 protected:
     QList<int> calcDirtyFrames() const override;
     KisAsyncAnimationRendererBase* createRenderer(KisImageSP image) override;
+    void initializeRendererForFrame(KisAsyncAnimationRendererBase *renderer,
+                                    KisImageSP image, int frame) override;
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 #endif // KISASYNCANIMATIONFRAMESSAVEDIALOG_H
diff --git a/libs/ui/dialogs/KisAsyncAnimationRenderDialogBase.cpp b/libs/ui/dialogs/KisAsyncAnimationRenderDialogBase.cpp
index d6db78bb17..1424441c1d 100644
--- a/libs/ui/dialogs/KisAsyncAnimationRenderDialogBase.cpp
+++ b/libs/ui/dialogs/KisAsyncAnimationRenderDialogBase.cpp
@@ -1,307 +1,309 @@
 /*
  *  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 "KisAsyncAnimationRenderDialogBase.h"
 
 #include <QEventLoop>
 #include <QProgressDialog>
 #include <QElapsedTimer>
 #include <QApplication>
 #include <QThread>
 #include <QTime>
 #include <QList>
 #include <QtMath>
 
 #include <klocalizedstring.h>
 
 #include "KisViewManager.h"
 #include "KisAsyncAnimationRendererBase.h"
 #include "kis_time_range.h"
 #include "kis_image.h"
 #include "kis_image_config.h"
 #include "kis_memory_statistics_server.h"
 
 #include <vector>
 #include <memory>
 
 namespace {
 struct RendererPair {
     std::unique_ptr<KisAsyncAnimationRendererBase> renderer;
     KisImageSP image;
 
     RendererPair() {}
     RendererPair(KisAsyncAnimationRendererBase *_renderer, KisImageSP _image)
         : renderer(_renderer),
           image(_image)
     {
     }
     RendererPair(RendererPair &&rhs)
         : renderer(std::move(rhs.renderer)),
           image(rhs.image)
     {
     }
 };
 
 int calculateNumberMemoryAllowedClones(KisImageSP image)
 {
     KisMemoryStatisticsServer::Statistics stats =
         KisMemoryStatisticsServer::instance()
         ->fetchMemoryStatistics(image);
 
     const qint64 allowedMemory = 0.8 * stats.tilesHardLimit - stats.realMemorySize;
     const qint64 cloneSize = stats.projectionsSize;
 
     return allowedMemory > 0 ? allowedMemory / cloneSize : 0;
 }
 
 }
 
 
 struct KisAsyncAnimationRenderDialogBase::Private
 {
     Private(const QString &_actionTitle, KisImageSP _image, int _busyWait)
         : actionTitle(_actionTitle),
           image(_image),
           busyWait(_busyWait)
     {
     }
 
     QString actionTitle;
     KisImageSP image;
     int busyWait;
     bool isBatchMode = false;
 
     std::vector<RendererPair> asyncRenderers;
     bool memoryLimitReached = false;
 
     QElapsedTimer processingTime;
     QScopedPointer<QProgressDialog> progressDialog;
     QEventLoop waitLoop;
 
     QList<int> stillDirtyFrames;
     QList<int> framesInProgress;
     int dirtyFramesCount = 0;
     Result result = RenderComplete;
 
     int numDirtyFramesLeft() const {
         return stillDirtyFrames.size() + framesInProgress.size();
     }
 
 };
 
 KisAsyncAnimationRenderDialogBase::KisAsyncAnimationRenderDialogBase(const QString &actionTitle, KisImageSP image, int busyWait)
     : m_d(new Private(actionTitle, image, busyWait))
 {
 }
 
 KisAsyncAnimationRenderDialogBase::~KisAsyncAnimationRenderDialogBase()
 {
 }
 
 KisAsyncAnimationRenderDialogBase::Result
 KisAsyncAnimationRenderDialogBase::regenerateRange(KisViewManager *viewManager)
 {
     m_d->stillDirtyFrames = calcDirtyFrames();
     m_d->framesInProgress.clear();
     m_d->result = RenderComplete;
     m_d->dirtyFramesCount = m_d->stillDirtyFrames.size();
 
     if (!m_d->isBatchMode) {
         QWidget *parentWidget = viewManager ? viewManager->mainWindow() : 0;
         m_d->progressDialog.reset(new QProgressDialog(m_d->actionTitle, i18n("Cancel"), 0, 0, parentWidget));
         m_d->progressDialog->setWindowModality(Qt::ApplicationModal);
         m_d->progressDialog->setMinimum(0);
         m_d->progressDialog->setMaximum(m_d->dirtyFramesCount);
         m_d->progressDialog->setMinimumDuration(m_d->busyWait);
         connect(m_d->progressDialog.data(), SIGNAL(canceled()), SLOT(slotCancelRegeneration()));
     }
 
     if (m_d->dirtyFramesCount <= 0) return m_d->result;
 
     m_d->processingTime.start();
 
     KisImageConfig cfg;
 
     const int maxThreads = cfg.maxNumberOfThreads();
     const int numAllowedWorker = 1 + calculateNumberMemoryAllowedClones(m_d->image);
     const int proposedNumWorkers = qMin(m_d->dirtyFramesCount, cfg.frameRenderingClones());
     const int numWorkers = qMin(proposedNumWorkers, numAllowedWorker);
     const int numThreadsPerWorker = qMax(1, qCeil(qreal(maxThreads) / numWorkers));
 
     m_d->memoryLimitReached = numWorkers < proposedNumWorkers;
 
     const int oldWorkingThreadsLimit = m_d->image->workingThreadsLimit();
 
     ENTER_FUNCTION() << ppVar(numWorkers) << ppVar(numThreadsPerWorker);
 
     for (int i = 0; i < numWorkers; i++) {
         // reuse the image for one of the workers
         KisImageSP image = i == numWorkers - 1 ? m_d->image : m_d->image->clone(true);
 
         image->setWorkingThreadsLimit(numThreadsPerWorker);
         KisAsyncAnimationRendererBase *renderer = createRenderer(image);
 
         connect(renderer, SIGNAL(sigFrameCompleted(int)), SLOT(slotFrameCompleted(int)));
         connect(renderer, SIGNAL(sigFrameCancelled(int)), SLOT(slotFrameCancelled(int)));
 
         m_d->asyncRenderers.push_back(RendererPair(renderer, image));
     }
 
     ENTER_FUNCTION() << "Copying done in" << m_d->processingTime.elapsed();
 
     tryInitiateFrameRegeneration();
     updateProgressLabel();
 
     if (m_d->numDirtyFramesLeft() > 0) {
         m_d->waitLoop.exec();
     }
 
     ENTER_FUNCTION() << "Full regeneration done in" << m_d->processingTime.elapsed();
 
     for (auto &pair : m_d->asyncRenderers) {
         KIS_SAFE_ASSERT_RECOVER_NOOP(!pair.renderer->isActive());
         if (viewManager) {
             viewManager->blockUntilOperationsFinishedForced(pair.image);
         } else {
             pair.image->barrierLock(true);
             pair.image->unlock();
         }
 
     }
     m_d->asyncRenderers.clear();
 
     if (viewManager) {
         viewManager->blockUntilOperationsFinishedForced(m_d->image);
     } else {
         m_d->image->barrierLock(true);
         m_d->image->unlock();
     }
 
     m_d->image->setWorkingThreadsLimit(oldWorkingThreadsLimit);
 
     m_d->progressDialog.reset();
 
     return m_d->result;
 }
 
 void KisAsyncAnimationRenderDialogBase::slotFrameCompleted(int frame)
 {
     Q_UNUSED(frame);
 
     m_d->framesInProgress.removeOne(frame);
 
     tryInitiateFrameRegeneration();
     updateProgressLabel();
 }
 
 void KisAsyncAnimationRenderDialogBase::slotFrameCancelled(int frame)
 {
     Q_UNUSED(frame);
 
     cancelProcessingImpl(false);
 }
 
 void KisAsyncAnimationRenderDialogBase::slotCancelRegeneration()
 {
     cancelProcessingImpl(true);
 }
 
 void KisAsyncAnimationRenderDialogBase::cancelProcessingImpl(bool isUserCancelled)
 {
     for (auto &pair : m_d->asyncRenderers) {
         if (pair.renderer->isActive()) {
             pair.renderer->cancelCurrentFrameRendering();
         }
         KIS_SAFE_ASSERT_RECOVER_NOOP(!pair.renderer->isActive());
     }
 
     m_d->stillDirtyFrames.clear();
     m_d->framesInProgress.clear();
     m_d->result = isUserCancelled ? RenderCancelled : RenderFailed;
     updateProgressLabel();
 }
 
 
 void KisAsyncAnimationRenderDialogBase::tryInitiateFrameRegeneration()
 {
     bool hadWorkOnPreviousCycle = false;
 
     while (!m_d->stillDirtyFrames.isEmpty()) {
         for (auto &pair : m_d->asyncRenderers) {
             if (!pair.renderer->isActive()) {
                 const int currentDirtyFrame = m_d->stillDirtyFrames.takeFirst();
+
+                initializeRendererForFrame(pair.renderer.get(), pair.image, currentDirtyFrame);
                 pair.renderer->startFrameRegeneration(pair.image, currentDirtyFrame);
                 hadWorkOnPreviousCycle = true;
                 m_d->framesInProgress.append(currentDirtyFrame);
                 break;
             }
         }
 
         if (!hadWorkOnPreviousCycle) break;
         hadWorkOnPreviousCycle = false;
     }
 }
 
 void KisAsyncAnimationRenderDialogBase::updateProgressLabel()
 {
     const int processedFramesCount = m_d->dirtyFramesCount - m_d->numDirtyFramesLeft();
 
     const qint64 elapsedMSec = m_d->processingTime.elapsed();
     const qint64 estimatedMSec =
         !processedFramesCount ? 0 :
         elapsedMSec * m_d->dirtyFramesCount / processedFramesCount;
 
     const QTime elapsedTime = QTime::fromMSecsSinceStartOfDay(elapsedMSec);
     const QTime estimatedTime = QTime::fromMSecsSinceStartOfDay(estimatedMSec);
 
     const QString timeFormat = estimatedTime.hour() > 0 ? "HH:mm:ss" : "mm:ss";
 
     const QString elapsedTimeString = elapsedTime.toString(timeFormat);
     const QString estimatedTimeString = estimatedTime.toString(timeFormat);
 
     const QString memoryLimitMessage(
         i18n("\n\nMemory limit is reached!\nThe number of clones is limited to %1\n\n",
              m_d->asyncRenderers.size()));
 
 
     const QString progressLabel(i18n("%1\n\nElapsed: %2\nEstimated: %3\n\n%4",
                                      m_d->actionTitle,
                                      elapsedTimeString,
                                      estimatedTimeString,
                                      m_d->memoryLimitReached ? memoryLimitMessage : QString()));
     if (m_d->progressDialog) {
         m_d->progressDialog->setLabelText(progressLabel);
         m_d->progressDialog->setValue(processedFramesCount);
     }
 
     if (!m_d->numDirtyFramesLeft()) {
         m_d->waitLoop.quit();
     }
 }
 
 
 
 void KisAsyncAnimationRenderDialogBase::setBatchMode(bool value)
 {
     m_d->isBatchMode = value;
 }
 
 bool KisAsyncAnimationRenderDialogBase::batchMode() const
 {
     return m_d->isBatchMode;
 }
diff --git a/libs/ui/dialogs/KisAsyncAnimationRenderDialogBase.h b/libs/ui/dialogs/KisAsyncAnimationRenderDialogBase.h
index 804cc7d787..029e5e97a6 100644
--- a/libs/ui/dialogs/KisAsyncAnimationRenderDialogBase.h
+++ b/libs/ui/dialogs/KisAsyncAnimationRenderDialogBase.h
@@ -1,137 +1,140 @@
 /*
  *  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 KISASYNCANIMATIONRENDERDIALOGBASE_H
 #define KISASYNCANIMATIONRENDERDIALOGBASE_H
 
 #include <QObject>
 #include "kis_types.h"
 #include "kritaui_export.h"
 
 class KisTimeRange;
 class KisAsyncAnimationRendererBase;
 class KisViewManager;
 
 /**
  * @brief KisAsyncAnimationRenderDialogBase is a special class for rendering multiple
  *        frames of the image and putting them somewhere (saving into a file or just
  *        pushing into an openGL cache)
  *
  * The class handles a lot of boilerplate code for you and optimizes regeneration of
  * the frames using multithreading, according to the user's settings. The responsibilities
  * of the class are the following:
  *
  * Rendering itself:
  *   - fetch the list of dirtly frames using calcDirtyFrames()
  *   - create some clones of the image according to the user's settings
  *     to facilitate multithreaded rendering and processing of the frames
  *   - if the user doesn't have anough RAM, the clones will not be created
  *     (the memory overhead is calculated using "projections" metric of the
  *      statistics server).
  *   - feed the images/threads with dirty frames until the all the frames
  *     are done
  *
  * Progress reporting:
  *   - if batchMode() is false, the user will see a progress dialog showing
  *     the current progress with estimate about total processing timer
  *   - the user can also cancel the regeneration by pressing Cancel button
  *
  * Usage Details:
  *   - one should implement two methods to make the rendering work:
  *     - calcDirtyFrames()
  *     - createRenderer(KisImageSP image)
  *   - these methids will be called on the start of the rendering
  */
 class KRITAUI_EXPORT KisAsyncAnimationRenderDialogBase : public QObject
 {
     Q_OBJECT
 public:
     enum Result {
         RenderComplete,
         RenderCancelled,
         RenderFailed
     };
 
 public:
     /**
      * @brief construct and initialize the dialog
      * @param actionTitle the first line of the status reports that the user sees in the dialog
      * @param image the image that will be as a source of frames. Make sure the image is *not*
      *              locked by the time regenerateRange() is called
      * @param busyWait the dialog will not show for the specified time (in milliseconds)
      */
     KisAsyncAnimationRenderDialogBase(const QString &actionTitle, KisImageSP image, int busyWait = 200);
     virtual ~KisAsyncAnimationRenderDialogBase();
 
     /**
      * @brief start generation of frames and (if not in batch mode) show the dialog
      *
      * The link to view manager is used to barrier lock with visual feedback in the
      * end of the operation
      */
     virtual Result regenerateRange(KisViewManager *viewManager);
 
     /**
      * @brief setting batch mode to true will prevent any dialogs or message boxes from
      *        showing on screen. Please take it into account that using batch mode prevents
      *        some potentially dangerous recovery execution paths (e.g. delete the existing
      *        frames in the destination folder). In such case the rendering will be stopped with
      *        RenderFailed result.
      */
     void setBatchMode(bool value);
 
     /**
      * @see setBatchMode
      */
     bool batchMode() const;
 
 private Q_SLOTS:
     void slotFrameCompleted(int frame);
     void slotFrameCancelled(int frame);
 
     void slotCancelRegeneration();
 
 private:
     void tryInitiateFrameRegeneration();
     void updateProgressLabel();
     void cancelProcessingImpl(bool isUserCancelled);
 
 protected:
     /**
      * @brief returns a list of frames that should be regenerated by the dialog
      *
      * Called by the dialog in the very beginning of regenerateRange()
      */
     virtual QList<int> calcDirtyFrames() const = 0;
 
     /**
      * @brief create a renderer object linked to \p image
      *
      * Renderer are special objects that connect to the individual image signals,
      * react on them and fetch the final frames data
      *
      * @see KisAsyncAnimationRendererBase
      */
     virtual KisAsyncAnimationRendererBase* createRenderer(KisImageSP image) = 0;
 
+    virtual void initializeRendererForFrame(KisAsyncAnimationRendererBase *renderer,
+                                            KisImageSP image, int frame) = 0;
+
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 #endif // KISASYNCANIMATIONRENDERDIALOGBASE_H
diff --git a/libs/ui/kis_canvas_resource_provider.h b/libs/ui/kis_canvas_resource_provider.h
index 7f14a06fd7..be3151e033 100644
--- a/libs/ui/kis_canvas_resource_provider.h
+++ b/libs/ui/kis_canvas_resource_provider.h
@@ -1,244 +1,245 @@
 /*
  *  Copyright (c) 2006 Boudewijn Rempt  <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_CANVAS_RESOURCE_PROVIDER_H_
 #define KIS_CANVAS_RESOURCE_PROVIDER_H_
 
 #include <QObject>
 
 #include <KoColor.h>
 #include <KoID.h>
 #include <KoCanvasResourceManager.h>
 
 #include "kis_types.h"
 #include "kritaui_export.h"
 
 class KisWorkspaceResource;
 class KoColorProfile;
 class KoAbstractGradient;
 class KoResource;
 
 class KoCanvasBase;
 class KisViewManager;
 class KoPattern;
 class KisFilterConfiguration;
 
 #include <kis_abstract_perspective_grid.h>
 
 /**
  * KisCanvasResourceProvider contains the per-window current settings that
  * influence painting, like paintop, color, gradients and so on.
  */
 class KRITAUI_EXPORT KisCanvasResourceProvider : public QObject
 {
     Q_OBJECT
 
 public:
 
     enum Resources {
         HdrExposure = KoCanvasResourceManager::KritaStart + 1,
         CurrentPattern,
         CurrentGradient,
         CurrentDisplayProfile,
         CurrentKritaNode,
         CurrentPaintOpPreset,
         CurrentGeneratorConfiguration,
         CurrentCompositeOp,
         CurrentEffectiveCompositeOp,
         LodAvailability, ///<-user choice
         LodSizeThreshold, ///<-user choice
         LodSizeThresholdSupported, ///<-paintop property
+        EffectiveLodAvailablility, ///<- a superposition of user choice, threshold and paintop traits
         EraserMode,
         MirrorHorizontal,
         MirrorVertical,
         MirrorHorizontalLock,
         MirrorVerticalLock,
         MirrorVerticalHideDecorations,
         MirrorHorizontalHideDecorations,
         Opacity,
         Flow,
         Size,
         HdrGamma,
         GlobalAlphaLock,
         DisablePressure,
         PreviousPaintOpPreset,
         EffectiveZoom, ///<-Used only by painting tools for non-displaying purposes
         SelectionAction,
         SelectionMode
     };
 
 
     KisCanvasResourceProvider(KisViewManager * view);
     ~KisCanvasResourceProvider() override;
 
     void setResourceManager(KoCanvasResourceManager *resourceManager);
     KoCanvasResourceManager* resourceManager();
 
     KoCanvasBase * canvas() const;
 
     KoColor bgColor() const;
     void setBGColor(const KoColor& c);
 
     KoColor fgColor() const;
     void setFGColor(const KoColor& c);
 
     float HDRExposure() const;
     void setHDRExposure(float exposure);
 
     float HDRGamma() const;
     void setHDRGamma(float gamma);
 
     bool eraserMode() const;
     void setEraserMode(bool value);
 
     KoPattern *currentPattern() const;
 
     KoAbstractGradient *currentGradient() const;
 
     KisImageWSP currentImage() const;
 
     KisNodeSP currentNode() const;
 
     KisPaintOpPresetSP currentPreset() const;
     void setPaintOpPreset(const KisPaintOpPresetSP preset);
 
     KisPaintOpPresetSP previousPreset() const;
     void setPreviousPaintOpPreset(const KisPaintOpPresetSP preset);
 
     void setCurrentCompositeOp(const QString& compositeOp);
     QString currentCompositeOp() const;
 
     QList<QPointer<KisAbstractPerspectiveGrid> > perspectiveGrids() const;
     void addPerspectiveGrid(KisAbstractPerspectiveGrid*);
     void removePerspectiveGrid(KisAbstractPerspectiveGrid*);
     void clearPerspectiveGrids();
 
     void setMirrorHorizontal(bool mirrorHorizontal);
     bool mirrorHorizontal() const;
 
     void setMirrorVertical(bool mirrorVertical);
     bool mirrorVertical() const;
 
     // options for horizontal and vertical mirror toolbar
     void setMirrorHorizontalLock(bool isLocked);
     bool mirrorHorizontalLock();
     void setMirrorVerticalLock(bool isLocked);
     bool mirrorVerticalLock();
 
     void setMirrorVerticalHideDecorations(bool hide);
     bool mirrorVerticalHideDecorations();
 
     void setMirrorHorizontalHideDecorations(bool hide);
     bool mirrorHorizontalHideDecorations();
 
     void mirrorVerticalMoveCanvasToCenter();
     void mirrorHorizontalMoveCanvasToCenter();
 
     void setOpacity(qreal opacity);
     qreal opacity() const;
 
     void setFlow(qreal opacity);
     qreal flow() const;
 
     void setSize(qreal size);
     qreal size() const;
 
     void setGlobalAlphaLock(bool lock);
     bool globalAlphaLock() const;
 
     void setDisablePressure(bool value);
     bool disablePressure() const;
 
     ///Notify that the workspace is saved and settings should be saved to it
     void notifySavingWorkspace(KisWorkspaceResource* workspace);
 
     ///Notify that the workspace is loaded and settings can be read
     void notifyLoadingWorkspace(KisWorkspaceResource* workspace);
 
     int selectionAction();
     void setSelectionAction(int action);
     int selectionMode();
     void setSelectionMode(int mode);
 
 
 public Q_SLOTS:
 
     void slotSetFGColor(const KoColor& c);
     void slotSetBGColor(const KoColor& c);
     void slotPatternActivated(KoResource *pattern);
     void slotGradientActivated(KoResource *gradient);
     void slotNodeActivated(const KisNodeSP node);
     void slotPainting();
 
     /**
      * Set the image size in pixels. The resource provider will store
      * the image size in postscript points.
      */
     // FIXME: this slot doesn't catch the case when image resolution is changed
     void slotImageSizeChanged();
     void slotOnScreenResolutionChanged();
 
     // This is a flag to handle a bug:
     // If pop up palette is visible and a new colour is selected, the new colour
     // will be added when the user clicks on the canvas to hide the palette
     // In general, we want to be able to store recent color if the pop up palette
     // is not visible
     void slotResetEnableFGChange(bool);
 
 private Q_SLOTS:
 
     void slotCanvasResourceChanged(int key, const QVariant & res);
 
 Q_SIGNALS:
 
     void sigFGColorChanged(const KoColor &);
     void sigBGColorChanged(const KoColor &);
     void sigGradientChanged(KoAbstractGradient *);
     void sigPatternChanged(KoPattern *);
     void sigNodeChanged(const KisNodeSP);
     void sigDisplayProfileChanged(const KoColorProfile *);
     void sigFGColorUsed(const KoColor&);
     void sigOnScreenResolutionChanged(qreal scaleX, qreal scaleY);
     void sigOpacityChanged(qreal);
     void sigSavingWorkspace(KisWorkspaceResource* workspace);
     void sigLoadingWorkspace(KisWorkspaceResource* workspace);
     void sigSelectionActionChanged(const int);
     void sigSelectionModeChanged(const int);
 
     void mirrorModeChanged();
     void moveMirrorVerticalCenter();
     void moveMirrorHorizontalCenter();
 
 
 private:
 
     KisViewManager * m_view;
     KoCanvasResourceManager *m_resourceManager;
     bool m_fGChanged;
     QList<QPointer<KisAbstractPerspectiveGrid> > m_perspectiveGrids;
 
     // This is a flag to handle a bug:
     // If pop up palette is visible and a new colour is selected, the new colour
     // will be added when the user clicks on the canvas to hide the palette
     // In general, we want to be able to store recent color if the pop up palette
     // is not visible
     bool m_enablefGChange;
 
 };
 
 #endif
diff --git a/libs/ui/kis_paintop_box.cc b/libs/ui/kis_paintop_box.cc
index 6b8bc1344e..e011dc2bf8 100644
--- a/libs/ui/kis_paintop_box.cc
+++ b/libs/ui/kis_paintop_box.cc
@@ -1,1335 +1,1340 @@
 /*
  *  kis_paintop_box.cc - part of KImageShop/Krayon/Krita
  *
  *  Copyright (c) 2004 Boudewijn Rempt (boud@valdyas.org)
  *  Copyright (c) 2009-2011 Sven Langkamp (sven.langkamp@gmail.com)
  *  Copyright (c) 2010 Lukáš Tvrdý <lukast.dev@gmail.com>
  *  Copyright (C) 2011 Silvio Heinrich <plassy@web.de>
  *  Copyright (C) 2011 Srikanth Tiyyagura <srikanth.tulasiram@gmail.com>
  *  Copyright (c) 2014 Mohit Goyal <mohit.bits2011@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_paintop_box.h"
 
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QToolButton>
 #include <QPixmap>
 #include <QWidgetAction>
 #include <QApplication>
 #include <QMenu>
 #include <QTime>
 
 #include <kis_debug.h>
 
 #include <kactioncollection.h>
 #include <kacceleratormanager.h>
 #include <QKeySequence>
 
 
 #include <kis_icon.h>
 #include <KoColorSpace.h>
 #include <KoCompositeOpRegistry.h>
 #include <KoResourceSelector.h>
 #include <KoResourceServerAdapter.h>
 #include <KoToolManager.h>
 #include <QTemporaryFile>
 #include <KoColorSpaceRegistry.h>
 
 #include <kis_paint_device.h>
 #include <brushengine/kis_paintop_registry.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <brushengine/kis_paintop_settings.h>
 #include <brushengine/kis_paintop_settings_update_proxy.h>
 #include <kis_config_widget.h>
 #include <kis_image.h>
 #include <kis_node.h>
 #include <brushengine/kis_paintop_config_widget.h>
 #include <kis_action.h>
 #include <KisLayoutSelector.h>
 
 #include "kis_canvas2.h"
 #include "kis_node_manager.h"
 #include "KisViewManager.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_resource_server_provider.h"
 #include "kis_favorite_resource_manager.h"
 #include "kis_config.h"
 
 #include "widgets/kis_popup_button.h"
 #include "widgets/kis_iconwidget.h"
 #include "widgets/kis_tool_options_popup.h"
 #include "widgets/kis_paintop_presets_popup.h"
 #include "widgets/kis_tool_options_popup.h"
 #include "widgets/kis_paintop_presets_chooser_popup.h"
 #include "widgets/kis_workspace_chooser.h"
 #include "widgets/kis_paintop_list_widget.h"
 #include "widgets/kis_slider_spin_box.h"
 #include "widgets/kis_cmb_composite.h"
 #include "widgets/kis_widget_chooser.h"
 #include "tool/kis_tool.h"
 #include "kis_signals_blocker.h"
 #include "kis_action_manager.h"
 #include "kis_highlighted_button.h"
 
 typedef KoResourceServerSimpleConstruction<KisPaintOpPreset, SharedPointerStoragePolicy<KisPaintOpPresetSP> > KisPaintOpPresetResourceServer;
 typedef KoResourceServerAdapter<KisPaintOpPreset, SharedPointerStoragePolicy<KisPaintOpPresetSP> > KisPaintOpPresetResourceServerAdapter;
 
 KisPaintopBox::KisPaintopBox(KisViewManager *view, QWidget *parent, const char *name)
     : QWidget(parent)
     , m_resourceProvider(view->resourceProvider())
     , m_optionWidget(0)
     , m_toolOptionsPopupButton(0)
     , m_brushEditorPopupButton(0)
     , m_presetSelectorPopupButton(0)
     , m_toolOptionsPopup(0)
     , m_viewManager(view)
     , m_previousNode(0)
     , m_currTabletToolID(KoInputDevice::invalid())
     , m_presetsEnabled(true)
     , m_blockUpdate(false)
     , m_dirtyPresetsEnabled(false)
     , m_eraserBrushSizeEnabled(false)
     , m_eraserBrushOpacityEnabled(false)
 {
     Q_ASSERT(view != 0);
 
 
     setObjectName(name);
     KisConfig cfg;
     m_dirtyPresetsEnabled = cfg.useDirtyPresets();
     m_eraserBrushSizeEnabled = cfg.useEraserBrushSize();
     m_eraserBrushOpacityEnabled = cfg.useEraserBrushOpacity();
 
     KAcceleratorManager::setNoAccel(this);
 
     setWindowTitle(i18n("Painter's Toolchest"));
 
     m_favoriteResourceManager = new KisFavoriteResourceManager(this);
 
 
     KConfigGroup grp =  KSharedConfig::openConfig()->group("krita").group("Toolbar BrushesAndStuff");
     int iconsize = grp.readEntry("IconSize", 32);
 
     if (!cfg.toolOptionsInDocker()) {
         m_toolOptionsPopupButton = new KisPopupButton(this);
         m_toolOptionsPopupButton->setIcon(KisIconUtils::loadIcon("configure"));
         m_toolOptionsPopupButton->setToolTip(i18n("Tool Settings"));
         m_toolOptionsPopupButton->setFixedSize(iconsize, iconsize);
     }
 
     m_brushEditorPopupButton = new KisIconWidget(this);
     m_brushEditorPopupButton->setIcon(KisIconUtils::loadIcon("paintop_settings_02"));
     m_brushEditorPopupButton->setToolTip(i18n("Edit brush settings"));
     m_brushEditorPopupButton->setFixedSize(iconsize, iconsize);
 
     m_presetSelectorPopupButton = new KisPopupButton(this);
     m_presetSelectorPopupButton->setIcon(KisIconUtils::loadIcon("paintop_settings_01"));
     m_presetSelectorPopupButton->setToolTip(i18n("Choose brush preset"));
     m_presetSelectorPopupButton->setFixedSize(iconsize, iconsize);
 
     m_eraseModeButton = new KisHighlightedToolButton(this);
     m_eraseModeButton->setFixedSize(iconsize, iconsize);
     m_eraseModeButton->setCheckable(true);
 
     m_eraseAction = m_viewManager->actionManager()->createAction("erase_action");
     m_eraseModeButton->setDefaultAction(m_eraseAction);
 
     m_reloadButton = new QToolButton(this);
     m_reloadButton->setFixedSize(iconsize, iconsize);
 
     m_reloadAction = m_viewManager->actionManager()->createAction("reload_preset_action");
     m_reloadButton->setDefaultAction(m_reloadAction);
 
     m_alphaLockButton = new KisHighlightedToolButton(this);
     m_alphaLockButton->setFixedSize(iconsize, iconsize);
     m_alphaLockButton->setCheckable(true);
 
     KisAction* alphaLockAction = m_viewManager->actionManager()->createAction("preserve_alpha");
     m_alphaLockButton->setDefaultAction(alphaLockAction);
 
     // horizontal and vertical mirror toolbar buttons
 
     // mirror tool options for the X Mirror
     QMenu *toolbarMenuXMirror = new QMenu();
 
     hideCanvasDecorationsX = m_viewManager->actionManager()->createAction("mirrorX-hideDecorations");
     toolbarMenuXMirror->addAction(hideCanvasDecorationsX);
 
     lockActionX = m_viewManager->actionManager()->createAction("mirrorX-lock");
     toolbarMenuXMirror->addAction(lockActionX);
 
     moveToCenterActionX = m_viewManager->actionManager()->createAction("mirrorX-moveToCenter");
     toolbarMenuXMirror->addAction(moveToCenterActionX);
 
 
     // mirror tool options for the Y Mirror
     QMenu *toolbarMenuYMirror = new QMenu();
 
     hideCanvasDecorationsY = m_viewManager->actionManager()->createAction("mirrorY-hideDecorations");
     toolbarMenuYMirror->addAction(hideCanvasDecorationsY);
 
 
     lockActionY = m_viewManager->actionManager()->createAction("mirrorY-lock");
     toolbarMenuYMirror->addAction(lockActionY);
 
     moveToCenterActionY = m_viewManager->actionManager()->createAction("mirrorY-moveToCenter");
     toolbarMenuYMirror->addAction(moveToCenterActionY);
 
 
 
     // create horizontal and vertical mirror buttons
 
     m_hMirrorButton = new KisHighlightedToolButton(this);
     int menuPadding = 10;
     m_hMirrorButton->setFixedSize(iconsize + menuPadding, iconsize);
     m_hMirrorButton->setCheckable(true);
     m_hMirrorAction = m_viewManager->actionManager()->createAction("hmirror_action");
     m_hMirrorButton->setDefaultAction(m_hMirrorAction);
     m_hMirrorButton->setMenu(toolbarMenuXMirror);
     m_hMirrorButton->setPopupMode(QToolButton::MenuButtonPopup);
 
     m_vMirrorButton = new KisHighlightedToolButton(this);
     m_vMirrorButton->setFixedSize(iconsize + menuPadding, iconsize);
     m_vMirrorButton->setCheckable(true);
     m_vMirrorAction = m_viewManager->actionManager()->createAction("vmirror_action");
     m_vMirrorButton->setDefaultAction(m_vMirrorAction);
     m_vMirrorButton->setMenu(toolbarMenuYMirror);
     m_vMirrorButton->setPopupMode(QToolButton::MenuButtonPopup);
 
 
     // add connections for horizontal and mirrror buttons
     connect(lockActionX, SIGNAL(toggled(bool)), this, SLOT(slotLockXMirrorToggle(bool)));
     connect(lockActionY, SIGNAL(toggled(bool)), this, SLOT(slotLockYMirrorToggle(bool)));
 
     connect(moveToCenterActionX, SIGNAL(triggered(bool)), this, SLOT(slotMoveToCenterMirrorX()));
     connect(moveToCenterActionY, SIGNAL(triggered(bool)), this, SLOT(slotMoveToCenterMirrorY()));
 
     connect(hideCanvasDecorationsX, SIGNAL(toggled(bool)), this, SLOT(slotHideDecorationMirrorX(bool)));
     connect(hideCanvasDecorationsY, SIGNAL(toggled(bool)), this, SLOT(slotHideDecorationMirrorY(bool)));
 
     const bool sliderLabels = cfg.sliderLabels();
     int sliderWidth;
 
     if (sliderLabels) {
         sliderWidth = 150 * logicalDpiX() / 96;
     }
     else {
         sliderWidth = 120 * logicalDpiX() / 96;
     }
 
     for (int i = 0; i < 3; ++i) {
         m_sliderChooser[i] = new KisWidgetChooser(i + 1);
 
         KisDoubleSliderSpinBox* slOpacity;
         KisDoubleSliderSpinBox* slFlow;
         KisDoubleSliderSpinBox* slSize;
         if (sliderLabels) {
             slOpacity = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("opacity");
             slFlow    = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("flow");
             slSize    = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("size");
             slOpacity->setPrefix(QString("%1  ").arg(i18n("Opacity:")));
             slFlow->setPrefix(QString("%1  ").arg(i18n("Flow:")));
             slSize->setPrefix(QString("%1  ").arg(i18n("Size:")));
         }
         else {
             slOpacity = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("opacity", i18n("Opacity:"));
             slFlow    = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("flow", i18n("Flow:"));
             slSize    = m_sliderChooser[i]->addWidget<KisDoubleSliderSpinBox>("size", i18n("Size:"));
         }
 
         slOpacity->setRange(0.0, 1.0, 2);
         slOpacity->setValue(1.0);
         slOpacity->setSingleStep(0.05);
         slOpacity->setMinimumWidth(qMax(sliderWidth, slOpacity->sizeHint().width()));
         slOpacity->setFixedHeight(iconsize);
         slOpacity->setBlockUpdateSignalOnDrag(true);
 
         slFlow->setRange(0.0, 1.0, 2);
         slFlow->setValue(1.0);
         slFlow->setSingleStep(0.05);
         slFlow->setMinimumWidth(qMax(sliderWidth, slFlow->sizeHint().width()));
         slFlow->setFixedHeight(iconsize);
         slFlow->setBlockUpdateSignalOnDrag(true);
 
         slSize->setRange(0, cfg.readEntry("maximumBrushSize", 1000), 2);
         slSize->setValue(100);
 
         slSize->setSingleStep(1);
         slSize->setExponentRatio(3.0);
         slSize->setSuffix(i18n(" px"));
         slSize->setMinimumWidth(qMax(sliderWidth, slSize->sizeHint().width()));
         slSize->setFixedHeight(iconsize);
         slSize->setBlockUpdateSignalOnDrag(true);
 
         m_sliderChooser[i]->chooseWidget(cfg.toolbarSlider(i + 1));
     }
 
     m_cmbCompositeOp = new KisCompositeOpComboBox();
     m_cmbCompositeOp->setFixedHeight(iconsize);
     Q_FOREACH (KisAction * a, m_cmbCompositeOp->blendmodeActions()) {
         m_viewManager->actionManager()->addAction(a->text(), a);
     }
 
     m_workspaceWidget = new KisPopupButton(this);
     m_workspaceWidget->setIcon(KisIconUtils::loadIcon("view-choose"));
     m_workspaceWidget->setToolTip(i18n("Choose workspace"));
     m_workspaceWidget->setFixedSize(iconsize, iconsize);
     m_workspaceWidget->setPopupWidget(new KisWorkspaceChooser(view));
 
     QHBoxLayout* baseLayout = new QHBoxLayout(this);
     m_paintopWidget = new QWidget(this);
     baseLayout->addWidget(m_paintopWidget);
     baseLayout->setSpacing(4);
     baseLayout->setContentsMargins(0, 0, 0, 0);
 
     m_layout = new QHBoxLayout(m_paintopWidget);
     if (!cfg.toolOptionsInDocker()) {
         m_layout->addWidget(m_toolOptionsPopupButton);
     }
     m_layout->addWidget(m_brushEditorPopupButton);
     m_layout->addWidget(m_presetSelectorPopupButton);
     m_layout->setSpacing(4);
     m_layout->setContentsMargins(0, 0, 0, 0);
 
     QWidget* compositeActions = new QWidget(this);
     QHBoxLayout* compositeLayout = new QHBoxLayout(compositeActions);
     compositeLayout->addWidget(m_cmbCompositeOp);
     compositeLayout->addWidget(m_eraseModeButton);
     compositeLayout->addWidget(m_alphaLockButton);
 
     compositeLayout->setSpacing(4);
     compositeLayout->setContentsMargins(0, 0, 0, 0);
 
     compositeLayout->addWidget(m_reloadButton);
 
     QWidgetAction * action;
 
     action = new QWidgetAction(this);
     view->actionCollection()->addAction("composite_actions", action);
     action->setText(i18n("Brush composite"));
     action->setDefaultWidget(compositeActions);
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("brushslider1", action);
     view->actionCollection()->addAction("brushslider1", action);
     action->setDefaultWidget(m_sliderChooser[0]);
     connect(action, SIGNAL(triggered()), m_sliderChooser[0], SLOT(showPopupWidget()));
     connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), m_sliderChooser[0], SLOT(updateThemedIcons()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("brushslider2", action);
     view->actionCollection()->addAction("brushslider2", action);
     action->setDefaultWidget(m_sliderChooser[1]);
     connect(action, SIGNAL(triggered()), m_sliderChooser[1], SLOT(showPopupWidget()));
     connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), m_sliderChooser[1], SLOT(updateThemedIcons()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("brushslider3", action);
     view->actionCollection()->addAction("brushslider3", action);
     action->setDefaultWidget(m_sliderChooser[2]);
     connect(action, SIGNAL(triggered()), m_sliderChooser[2], SLOT(showPopupWidget()));
         connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), m_sliderChooser[2], SLOT(updateThemedIcons()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("next_favorite_preset", action);
     view->actionCollection()->addAction("next_favorite_preset", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotNextFavoritePreset()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("previous_favorite_preset", action);
     view->actionCollection()->addAction("previous_favorite_preset", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotPreviousFavoritePreset()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("previous_preset", action);
     view->actionCollection()->addAction("previous_preset", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotSwitchToPreviousPreset()));
 
     if (!cfg.toolOptionsInDocker()) {
         action = new QWidgetAction(this);
         KisActionRegistry::instance()->propertizeAction("show_tool_options", action);
         view->actionCollection()->addAction("show_tool_options", action);
         connect(action, SIGNAL(triggered()), m_toolOptionsPopupButton, SLOT(showPopupWidget()));
     }
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("show_brush_editor", action);
     view->actionCollection()->addAction("show_brush_editor", action);
     connect(action, SIGNAL(triggered()), m_brushEditorPopupButton, SLOT(showPopupWidget()));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("show_brush_presets", action);
     view->actionCollection()->addAction("show_brush_presets", action);
     connect(action, SIGNAL(triggered()), m_presetSelectorPopupButton, SLOT(showPopupWidget()));
 
     QWidget* mirrorActions = new QWidget(this);
     QHBoxLayout* mirrorLayout = new QHBoxLayout(mirrorActions);
     mirrorLayout->addWidget(m_hMirrorButton);
     mirrorLayout->addWidget(m_vMirrorButton);
     mirrorLayout->setSpacing(4);
     mirrorLayout->setContentsMargins(0, 0, 0, 0);
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("mirror_actions", action);
     action->setDefaultWidget(mirrorActions);
     view->actionCollection()->addAction("mirror_actions", action);
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("select_layout", action);
     view->actionCollection()->addAction("select_layout", action);
     action->setDefaultWidget(new KisLayoutSelector(this));
 
     action = new QWidgetAction(this);
     KisActionRegistry::instance()->propertizeAction("workspaces", action);
     view->actionCollection()->addAction("workspaces", action);
     action->setDefaultWidget(m_workspaceWidget);
 
     if (!cfg.toolOptionsInDocker()) {
         m_toolOptionsPopup = new KisToolOptionsPopup();
         m_toolOptionsPopupButton->setPopupWidget(m_toolOptionsPopup);
         m_toolOptionsPopup->switchDetached(false);
     }
 
 
     m_savePresetWidget = new KisPresetSaveWidget(this);
 
     m_presetsPopup = new KisPaintOpPresetsPopup(m_resourceProvider, m_favoriteResourceManager, m_savePresetWidget);
     m_brushEditorPopupButton->setPopupWidget(m_presetsPopup);
     m_presetsPopup->parentWidget()->setWindowTitle(i18n("Brush Editor"));
 
 
     connect(m_presetsPopup, SIGNAL(brushEditorShown()), SLOT(slotUpdateOptionsWidgetPopup()));
     connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), m_presetsPopup, SLOT(updateThemedIcons()));
 
     m_presetsChooserPopup = new KisPaintOpPresetsChooserPopup();
     m_presetsChooserPopup->setMinimumHeight(550);
     m_presetsChooserPopup->setMinimumWidth(450);
     m_presetSelectorPopupButton->setPopupWidget(m_presetsChooserPopup);
 
     m_currCompositeOpID = KoCompositeOpRegistry::instance().getDefaultCompositeOp().id();
 
     slotNodeChanged(view->activeNode());
     // Get all the paintops
     QList<QString> keys = KisPaintOpRegistry::instance()->keys();
     QList<KisPaintOpFactory*> factoryList;
 
     Q_FOREACH (const QString & paintopId, keys) {
         factoryList.append(KisPaintOpRegistry::instance()->get(paintopId));
     }
     m_presetsPopup->setPaintOpList(factoryList);
 
     connect(m_presetsPopup       , SIGNAL(paintopActivated(QString))          , SLOT(slotSetPaintop(QString)));
     connect(m_presetsPopup       , SIGNAL(defaultPresetClicked())             , SLOT(slotSetupDefaultPreset()));
     connect(m_presetsPopup       , SIGNAL(signalResourceSelected(KoResource*)), SLOT(resourceSelected(KoResource*)));
     connect(m_presetsPopup       , SIGNAL(reloadPresetClicked())              , SLOT(slotReloadPreset()));
     connect(m_presetsPopup       , SIGNAL(dirtyPresetToggled(bool))           , SLOT(slotDirtyPresetToggled(bool)));
     connect(m_presetsPopup       , SIGNAL(eraserBrushSizeToggled(bool))       , SLOT(slotEraserBrushSizeToggled(bool)));
     connect(m_presetsPopup       , SIGNAL(eraserBrushOpacityToggled(bool))       , SLOT(slotEraserBrushOpacityToggled(bool)));
 
     connect(m_presetsPopup, SIGNAL(createPresetFromScratch(QString)), this, SLOT(slotCreatePresetFromScratch(QString)));
 
     connect(m_presetsChooserPopup, SIGNAL(resourceSelected(KoResource*))      , SLOT(resourceSelected(KoResource*)));
     connect(m_presetsChooserPopup, SIGNAL(resourceClicked(KoResource*))      , SLOT(resourceSelected(KoResource*)));
 
     connect(m_resourceProvider   , SIGNAL(sigNodeChanged(const KisNodeSP))    , SLOT(slotNodeChanged(const KisNodeSP)));
     connect(m_cmbCompositeOp     , SIGNAL(currentIndexChanged(int))           , SLOT(slotSetCompositeMode(int)));
     connect(m_eraseAction          , SIGNAL(toggled(bool))                    , SLOT(slotToggleEraseMode(bool)));
     connect(alphaLockAction      , SIGNAL(toggled(bool))                    , SLOT(slotToggleAlphaLockMode(bool)));
 
     m_disablePressureAction = m_viewManager->actionManager()->createAction("disable_pressure");
     connect(m_disablePressureAction  , SIGNAL(toggled(bool))                    , SLOT(slotDisablePressureMode(bool)));
     m_disablePressureAction->setChecked(true);
 
     connect(m_hMirrorAction        , SIGNAL(toggled(bool))                    , SLOT(slotHorizontalMirrorChanged(bool)));
     connect(m_vMirrorAction        , SIGNAL(toggled(bool))                    , SLOT(slotVerticalMirrorChanged(bool)));
     connect(m_reloadAction         , SIGNAL(triggered())                        , SLOT(slotReloadPreset()));
 
     connect(m_sliderChooser[0]->getWidget<KisDoubleSliderSpinBox>("opacity"), SIGNAL(valueChanged(qreal)), SLOT(slotSlider1Changed()));
     connect(m_sliderChooser[0]->getWidget<KisDoubleSliderSpinBox>("flow")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider1Changed()));
     connect(m_sliderChooser[0]->getWidget<KisDoubleSliderSpinBox>("size")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider1Changed()));
     connect(m_sliderChooser[1]->getWidget<KisDoubleSliderSpinBox>("opacity"), SIGNAL(valueChanged(qreal)), SLOT(slotSlider2Changed()));
     connect(m_sliderChooser[1]->getWidget<KisDoubleSliderSpinBox>("flow")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider2Changed()));
     connect(m_sliderChooser[1]->getWidget<KisDoubleSliderSpinBox>("size")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider2Changed()));
     connect(m_sliderChooser[2]->getWidget<KisDoubleSliderSpinBox>("opacity"), SIGNAL(valueChanged(qreal)), SLOT(slotSlider3Changed()));
     connect(m_sliderChooser[2]->getWidget<KisDoubleSliderSpinBox>("flow")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider3Changed()));
     connect(m_sliderChooser[2]->getWidget<KisDoubleSliderSpinBox>("size")   , SIGNAL(valueChanged(qreal)), SLOT(slotSlider3Changed()));
 
     //Needed to connect canvas to favorite resource manager
     connect(m_viewManager->resourceProvider(), SIGNAL(sigFGColorChanged(KoColor)), SLOT(slotUnsetEraseMode()));
 
 
     connect(m_resourceProvider, SIGNAL(sigFGColorUsed(KoColor)), m_favoriteResourceManager, SLOT(slotAddRecentColor(KoColor)));
 
     connect(m_resourceProvider, SIGNAL(sigFGColorChanged(KoColor)), m_favoriteResourceManager, SLOT(slotChangeFGColorSelector(KoColor)));
     connect(m_resourceProvider, SIGNAL(sigBGColorChanged(KoColor)), m_favoriteResourceManager, SLOT(slotSetBGColor(KoColor)));
     // cold initialization
     m_favoriteResourceManager->slotChangeFGColorSelector(m_resourceProvider->fgColor());
     m_favoriteResourceManager->slotSetBGColor(m_resourceProvider->bgColor());
 
     connect(m_favoriteResourceManager, SIGNAL(sigSetFGColor(KoColor)), m_resourceProvider, SLOT(slotSetFGColor(KoColor)));
     connect(m_favoriteResourceManager, SIGNAL(sigSetBGColor(KoColor)), m_resourceProvider, SLOT(slotSetBGColor(KoColor)));
     connect(m_favoriteResourceManager, SIGNAL(sigEnableChangeColor(bool)), m_resourceProvider, SLOT(slotResetEnableFGChange(bool)));
 
     connect(view->mainWindow(), SIGNAL(themeChanged()), this, SLOT(slotUpdateSelectionIcon()));
 
     slotInputDeviceChanged(KoToolManager::instance()->currentInputDevice());
 
     KisPaintOpPresetResourceServer *rserver = KisResourceServerProvider::instance()->paintOpPresetServer(false);
     m_eraserName = "eraser_circle";
     m_defaultPresetName = "basic_tip_default";
     bool foundEraser = false;
     bool foundTip = false;
     for (int i=0; i<rserver->resourceCount(); i++) {
         KisPaintOpPresetSP resource = rserver->resources().at(i);
         if (resource->name().toLower().contains("eraser_circle")) {
             m_eraserName = resource->name();
             foundEraser = true;
         } else if (foundEraser == false && (resource->name().toLower().contains("eraser") ||
                                             resource->filename().toLower().contains("eraser"))) {
             m_eraserName = resource->name();
             foundEraser = true;
         }
         if (resource->name().toLower().contains("basic_tip_default")) {
             m_defaultPresetName = resource->name();
             foundTip = true;
         } else if (foundTip == false && (resource->name().toLower().contains("default") ||
                                          resource->filename().toLower().contains("default"))) {
             m_defaultPresetName = resource->name();
             foundTip = true;
         }
     }
 }
 
 KisPaintopBox::~KisPaintopBox()
 {
     KisConfig cfg;
     QMapIterator<TabletToolID, TabletToolData> iter(m_tabletToolMap);
     while (iter.hasNext()) {
         iter.next();
         //qDebug() << "Writing last used preset for" << iter.key().pointer << iter.key().uniqueID << iter.value().preset->name();
         if ((iter.key().pointer) == QTabletEvent::Eraser) {
             cfg.writeEntry(QString("LastEraser_%1").arg(iter.key().uniqueID) , iter.value().preset->name());
         }
         else {
             cfg.writeEntry(QString("LastPreset_%1").arg(iter.key().uniqueID) , iter.value().preset->name());
         }
     }
     // Do not delete the widget, since it is global to the application, not owned by the view
     m_presetsPopup->setPaintOpSettingsWidget(0);
     qDeleteAll(m_paintopOptionWidgets);
     delete m_favoriteResourceManager;
 
     for (int i = 0; i < 3; ++i) {
         delete m_sliderChooser[i];
     }
 }
 
 void KisPaintopBox::restoreResource(KoResource* resource)
 {
 
     KisPaintOpPreset* preset = dynamic_cast<KisPaintOpPreset*>(resource);
     //qDebug() << "restoreResource" << resource << preset;
     if (preset) {
         setCurrentPaintop(preset);
 
         m_presetsPopup->setPresetImage(preset->image());
         m_presetsPopup->resourceSelected(resource);
     }
 }
 
 void KisPaintopBox::newOptionWidgets(const QList<QPointer<QWidget> > &optionWidgetList)
 {
     if (m_toolOptionsPopup) {
         m_toolOptionsPopup->newOptionWidgets(optionWidgetList);
     }
 }
 
 void KisPaintopBox::resourceSelected(KoResource* resource)
 {
     m_presetsPopup->setCreatingBrushFromScratch(false); // show normal UI elements when we are not creating
 
     KisPaintOpPreset* preset = dynamic_cast<KisPaintOpPreset*>(resource);
     if (preset && preset != m_resourceProvider->currentPreset()) {
         if (!preset->settings()->isLoadable())
             return;
 
         if (!m_dirtyPresetsEnabled) {
             KisSignalsBlocker blocker(m_optionWidget);
             if (!preset->load()) {
                 warnKrita << "failed to load the preset.";
             }
         }
         //qDebug() << "resourceSelected" << resource->name();
         setCurrentPaintop(preset);
 
         m_presetsPopup->setPresetImage(preset->image());
         m_presetsPopup->resourceSelected(resource);
     }
 
 
 }
 
 void KisPaintopBox::setCurrentPaintop(const KoID& paintop)
 {
     KisPaintOpPresetSP preset = activePreset(paintop);
     Q_ASSERT(preset && preset->settings());
     //qDebug() << "setCurrentPaintop();" << paintop << preset;
     setCurrentPaintop(preset);
 }
 
 void KisPaintopBox::setCurrentPaintop(KisPaintOpPresetSP preset)
 {
 
     //qDebug() << "setCurrentPaintop(); " << preset->name();
 
     if (preset == m_resourceProvider->currentPreset()) {
 
         if (preset == m_tabletToolMap[m_currTabletToolID].preset) {
             return;
         }
     }
     Q_ASSERT(preset);
     const KoID& paintop = preset->paintOp();
     m_presetConnections.clear();
 
     if (m_resourceProvider->currentPreset()) {
 
         m_resourceProvider->setPreviousPaintOpPreset(m_resourceProvider->currentPreset());
 
         if (m_optionWidget) {
             m_optionWidget->hide();
         }
 
     }
 
     if (!m_paintopOptionWidgets.contains(paintop))
         m_paintopOptionWidgets[paintop] = KisPaintOpRegistry::instance()->get(paintop.id())->createConfigWidget(this);
 
     m_optionWidget = m_paintopOptionWidgets[paintop];
 
     KisSignalsBlocker b(m_optionWidget);
 
     preset->setOptionsWidget(m_optionWidget);
 
     m_optionWidget->setImage(m_viewManager->image());
     m_optionWidget->setNode(m_viewManager->activeNode());
 
     m_presetsPopup->setPaintOpSettingsWidget(m_optionWidget);
 
     m_resourceProvider->setPaintOpPreset(preset);
 
     Q_ASSERT(m_optionWidget && m_presetSelectorPopupButton);
 
     m_presetConnections.addConnection(m_optionWidget, SIGNAL(sigConfigurationUpdated()), this, SLOT(slotGuiChangedCurrentPreset()));
     m_presetConnections.addConnection(m_optionWidget, SIGNAL(sigSaveLockedConfig(KisPropertiesConfigurationSP)), this, SLOT(slotSaveLockedOptionToPreset(KisPropertiesConfigurationSP)));
     m_presetConnections.addConnection(m_optionWidget, SIGNAL(sigDropLockedConfig(KisPropertiesConfigurationSP)), this, SLOT(slotDropLockedOption(KisPropertiesConfigurationSP)));
 
 
     // load the current brush engine icon for the brush editor toolbar button
 
     m_brushEditorPopupButton->slotSetItem(preset.data());
     m_presetsPopup->setCurrentPaintOpId(paintop.id());
 
 
     ////qDebug() << "\tsetting the new preset for" << m_currTabletToolID.uniqueID << "to" << preset->name();
     m_paintOpPresetMap[m_resourceProvider->currentPreset()->paintOp()] = preset;
     m_tabletToolMap[m_currTabletToolID].preset = preset;
     m_tabletToolMap[m_currTabletToolID].paintOpID = preset->paintOp();
 
 
     if (m_presetsPopup->currentPaintOpId() != paintop.id()) {
         // Must change the paintop as the current one is not supported
         // by the new colorspace.
         dbgKrita << "current paintop " << paintop.name() << " was not set, not supported by colorspace";
     }
 }
 
 void KisPaintopBox::slotUpdateOptionsWidgetPopup()
 {
     KisPaintOpPresetSP preset = m_resourceProvider->currentPreset();
     KIS_SAFE_ASSERT_RECOVER_RETURN(preset);
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_optionWidget);
 
     m_optionWidget->setConfigurationSafe(preset->settings());
 
     m_presetsPopup->resourceSelected(preset.data());
     m_presetsPopup->updateViewSettings();
 
     // the m_viewManager->image() is set earlier, but the reference will be missing when the stamp button is pressed
     // need to later do some research on how and when we should be using weak shared pointers (WSP) that creates this situation
     m_optionWidget->setImage(m_viewManager->image());
 }
 
 KisPaintOpPresetSP KisPaintopBox::defaultPreset(const KoID& paintOp)
 {
     QString defaultName = paintOp.id() + ".kpp";
     QString path = KoResourcePaths::findResource("kis_defaultpresets", defaultName);
 
     KisPaintOpPresetSP preset = new KisPaintOpPreset(path);
 
     if (!preset->load()) {
         preset = KisPaintOpRegistry::instance()->defaultPreset(paintOp);
     }
 
     Q_ASSERT(preset);
     Q_ASSERT(preset->valid());
 
     return preset;
 }
 
 KisPaintOpPresetSP KisPaintopBox::activePreset(const KoID& paintOp)
 {
     if (m_paintOpPresetMap[paintOp] == 0) {
         m_paintOpPresetMap[paintOp] = defaultPreset(paintOp);
     }
 
     return m_paintOpPresetMap[paintOp];
 }
 
 void KisPaintopBox::updateCompositeOp(QString compositeOpID)
 {
     if (!m_optionWidget) return;
     KisSignalsBlocker blocker(m_optionWidget);
 
     KisNodeSP node = m_resourceProvider->currentNode();
 
     if (node && node->paintDevice()) {
         if (!node->paintDevice()->colorSpace()->hasCompositeOp(compositeOpID))
             compositeOpID = KoCompositeOpRegistry::instance().getDefaultCompositeOp().id();
 
         {
             KisSignalsBlocker b1(m_cmbCompositeOp);
             m_cmbCompositeOp->selectCompositeOp(KoID(compositeOpID));
         }
         if (compositeOpID != m_currCompositeOpID) {
             m_currCompositeOpID = compositeOpID;
         }
         if (compositeOpID == COMPOSITE_ERASE || m_resourceProvider->eraserMode()) {
             m_eraseModeButton->setChecked(true);
         }
         else {
             m_eraseModeButton->setChecked(false);
         }
     }
 }
 
 void KisPaintopBox::setWidgetState(int flags)
 {
     if (flags & (ENABLE_COMPOSITEOP | DISABLE_COMPOSITEOP)) {
         m_cmbCompositeOp->setEnabled(flags & ENABLE_COMPOSITEOP);
         m_eraseModeButton->setEnabled(flags & ENABLE_COMPOSITEOP);
     }
 
     if (flags & (ENABLE_PRESETS | DISABLE_PRESETS)) {
         m_presetSelectorPopupButton->setEnabled(flags & ENABLE_PRESETS);
         m_brushEditorPopupButton->setEnabled(flags & ENABLE_PRESETS);
     }
 
     for (int i = 0; i < 3; ++i) {
         if (flags & (ENABLE_OPACITY | DISABLE_OPACITY))
             m_sliderChooser[i]->getWidget("opacity")->setEnabled(flags & ENABLE_OPACITY);
 
         if (flags & (ENABLE_FLOW | DISABLE_FLOW))
             m_sliderChooser[i]->getWidget("flow")->setEnabled(flags & ENABLE_FLOW);
 
         if (flags & (ENABLE_SIZE | DISABLE_SIZE))
             m_sliderChooser[i]->getWidget("size")->setEnabled(flags & ENABLE_SIZE);
     }
 }
 
 void KisPaintopBox::setSliderValue(const QString& sliderID, qreal value)
 {
     for (int i = 0; i < 3; ++i) {
         KisDoubleSliderSpinBox* slider = m_sliderChooser[i]->getWidget<KisDoubleSliderSpinBox>(sliderID);
         KisSignalsBlocker b(slider);
         slider->setValue(value);
     }
 }
 
 void KisPaintopBox::slotSetPaintop(const QString& paintOpId)
 {
     if (KisPaintOpRegistry::instance()->get(paintOpId) != 0) {
         KoID id(paintOpId, KisPaintOpRegistry::instance()->get(paintOpId)->name());
         //qDebug() << "slotsetpaintop" << id;
         setCurrentPaintop(id);
     }
 }
 
 void KisPaintopBox::slotInputDeviceChanged(const KoInputDevice& inputDevice)
 {
     TabletToolMap::iterator toolData = m_tabletToolMap.find(inputDevice);
 
     //qDebug() << "slotInputDeviceChanged()" << inputDevice.device() << inputDevice.uniqueTabletId();
 
     m_currTabletToolID = TabletToolID(inputDevice);
 
     if (toolData == m_tabletToolMap.end()) {
         KisConfig cfg;
         KisPaintOpPresetResourceServer *rserver = KisResourceServerProvider::instance()->paintOpPresetServer(false);
         KisPaintOpPresetSP preset;
         if (inputDevice.pointer() == QTabletEvent::Eraser) {
             preset = rserver->resourceByName(cfg.readEntry<QString>(QString("LastEraser_%1").arg(inputDevice.uniqueTabletId()), m_eraserName));
         }
         else {
             preset = rserver->resourceByName(cfg.readEntry<QString>(QString("LastPreset_%1").arg(inputDevice.uniqueTabletId()), m_defaultPresetName));
             //if (preset)
                 //qDebug() << "found stored preset " << preset->name() << "for" << inputDevice.uniqueTabletId();
             //else
                 //qDebug() << "no preset found for" << inputDevice.uniqueTabletId();
         }
         if (!preset) {
             preset = rserver->resourceByName(m_defaultPresetName);
         }
         if (preset) {
             //qDebug() << "inputdevicechanged 1" << preset;
             setCurrentPaintop(preset);
         }
     }
     else {
         if (toolData->preset) {
             //qDebug() << "inputdevicechanged 2" << toolData->preset;
             setCurrentPaintop(toolData->preset);
         }
         else {
             //qDebug() << "inputdevicechanged 3" << toolData->paintOpID;
             setCurrentPaintop(toolData->paintOpID);
         }
     }
 }
 
 void KisPaintopBox::slotCreatePresetFromScratch(QString paintop)
 {
     //First try to select an available default preset for that engine. If it doesn't exist, then
     //manually set the engine to use a new preset.
     KoID id(paintop, KisPaintOpRegistry::instance()->get(paintop)->name());
     KisPaintOpPresetSP preset = defaultPreset(id);
     if (!preset) {
         slotSetPaintop(paintop);  // change the paintop settings area and update the UI
         m_presetsPopup->setCreatingBrushFromScratch(true); // disable UI elements while creating from scratch
         preset = m_resourceProvider->currentPreset();
     } else {
         m_resourceProvider->setPaintOpPreset(preset);
         preset->setOptionsWidget(m_optionWidget);
     }
     m_presetsPopup->resourceSelected(preset.data());  // this helps update the UI on the brush editor
 }
 
 void KisPaintopBox::slotCanvasResourceChanged(int key, const QVariant &value)
 {
     if (m_viewManager) {
         sender()->blockSignals(true);
         KisPaintOpPresetSP preset = m_viewManager->resourceProvider()->resourceManager()->resource(KisCanvasResourceProvider::CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
         if (preset && m_resourceProvider->currentPreset()->name() != preset->name()) {
             QString compositeOp = preset->settings()->getString("CompositeOp");
             updateCompositeOp(compositeOp);
             resourceSelected(preset.data());
         }
 
         /**
          * Update currently selected preset in both the popup widgets
          */
         m_presetsChooserPopup->canvasResourceChanged(preset);
 
         m_presetsPopup->currentPresetChanged(preset);
 
         if (key == KisCanvasResourceProvider::CurrentCompositeOp) {
             if (m_resourceProvider->currentCompositeOp() != m_currCompositeOpID) {
                 updateCompositeOp(m_resourceProvider->currentCompositeOp());
             }
         }
 
         if (key == KisCanvasResourceProvider::Size) {
             setSliderValue("size", m_resourceProvider->size());
         }
 
         if (key == KisCanvasResourceProvider::Opacity) {
             setSliderValue("opacity", m_resourceProvider->opacity());
         }
 
         if (key == KisCanvasResourceProvider::Flow) {
             setSliderValue("flow", m_resourceProvider->flow());
         }
 
         if (key == KisCanvasResourceProvider::EraserMode) {
             m_eraseAction->setChecked(value.toBool());
         }
 
         if (key == KisCanvasResourceProvider::DisablePressure) {
             m_disablePressureAction->setChecked(value.toBool());
         }
 
         sender()->blockSignals(false);
     }
 }
 
 void KisPaintopBox::slotUpdatePreset()
 {
     if (!m_resourceProvider->currentPreset()) return;
 
     // block updates of avoid some over updating of the option widget
     m_blockUpdate = true;
 
     setSliderValue("size", m_resourceProvider->size());
 
     {
         qreal opacity = m_resourceProvider->currentPreset()->settings()->paintOpOpacity();
         m_resourceProvider->setOpacity(opacity);
         setSliderValue("opacity", opacity);
         setWidgetState(ENABLE_OPACITY);
     }
 
     {
         setSliderValue("flow", m_resourceProvider->currentPreset()->settings()->paintOpFlow());
         setWidgetState(ENABLE_FLOW);
     }
 
     {
         updateCompositeOp(m_resourceProvider->currentPreset()->settings()->paintOpCompositeOp());
         setWidgetState(ENABLE_COMPOSITEOP);
     }
 
     m_blockUpdate = false;
 }
 
 void KisPaintopBox::slotSetupDefaultPreset()
 {
     KisPaintOpPresetSP preset = defaultPreset(m_resourceProvider->currentPreset()->paintOp());
     preset->setOptionsWidget(m_optionWidget);
     m_resourceProvider->setPaintOpPreset(preset);
 
     // tell the brush editor that the resource has changed
     // so it can update everything
     m_presetsPopup->resourceSelected(preset.data());
 }
 
 void KisPaintopBox::slotNodeChanged(const KisNodeSP node)
 {
     if (m_previousNode.isValid() && m_previousNode->paintDevice())
         disconnect(m_previousNode->paintDevice().data(), SIGNAL(colorSpaceChanged(const KoColorSpace*)), this, SLOT(slotColorSpaceChanged(const KoColorSpace*)));
 
     // Reconnect colorspace change of node
     if (node && node->paintDevice()) {
         connect(node->paintDevice().data(), SIGNAL(colorSpaceChanged(const KoColorSpace*)), this, SLOT(slotColorSpaceChanged(const KoColorSpace*)));
         m_resourceProvider->setCurrentCompositeOp(m_currCompositeOpID);
         m_previousNode = node;
         slotColorSpaceChanged(node->colorSpace());
     }
 
     if (m_optionWidget) {
         m_optionWidget->setNode(node);
     }
 }
 
 void KisPaintopBox::slotColorSpaceChanged(const KoColorSpace* colorSpace)
 {
     m_cmbCompositeOp->validate(colorSpace);
 }
 
 void KisPaintopBox::slotToggleEraseMode(bool checked)
 {
     const bool oldEraserMode = m_resourceProvider->eraserMode();
     m_resourceProvider->setEraserMode(checked);
 
     if (oldEraserMode != checked && m_eraserBrushSizeEnabled) {
         const qreal currentSize = m_resourceProvider->size();
 
         KisPaintOpSettingsSP settings = m_resourceProvider->currentPreset()->settings();
 
         // remember brush size. set the eraser size to the normal brush size if not set
         if (checked) {
             settings->setSavedBrushSize(currentSize);
             if (qFuzzyIsNull(settings->savedEraserSize())) {
                 settings->setSavedEraserSize(currentSize);
             }
         } else {
             settings->setSavedEraserSize(currentSize);
             if (qFuzzyIsNull(settings->savedBrushSize())) {
                 settings->setSavedBrushSize(currentSize);
             }
         }
 
         //update value in UI (this is the main place the value is 'stored' in memory)
         qreal newSize = checked ? settings->savedEraserSize() : settings->savedBrushSize();
         m_resourceProvider->setSize(newSize);
     }
    if (oldEraserMode != checked && m_eraserBrushOpacityEnabled) {
         const qreal currentOpacity = m_resourceProvider->opacity();
 
         KisPaintOpSettingsSP settings = m_resourceProvider->currentPreset()->settings();
 
         // remember brush opacity. set the eraser opacity to the normal brush opacity if not set
         if (checked) {
             settings->setSavedBrushOpacity(currentOpacity);
             if (qFuzzyIsNull(settings->savedEraserOpacity())) {
                 settings->setSavedEraserOpacity(currentOpacity);
             }
         } else {
             settings->setSavedEraserOpacity(currentOpacity);
             if (qFuzzyIsNull(settings->savedBrushOpacity())) {
                 settings->setSavedBrushOpacity(currentOpacity);
             }
         }
 
         //update value in UI (this is the main place the value is 'stored' in memory)
         qreal newOpacity = checked ? settings->savedEraserOpacity() : settings->savedBrushOpacity();
         m_resourceProvider->setOpacity(newOpacity);
     }
 }
 
 void KisPaintopBox::slotSetCompositeMode(int index)
 {
     Q_UNUSED(index);
     QString compositeOp = m_cmbCompositeOp->selectedCompositeOp().id();
     m_resourceProvider->setCurrentCompositeOp(compositeOp);
 }
 
 void KisPaintopBox::slotHorizontalMirrorChanged(bool value)
 {
     m_resourceProvider->setMirrorHorizontal(value);
 }
 
 void KisPaintopBox::slotVerticalMirrorChanged(bool value)
 {
     m_resourceProvider->setMirrorVertical(value);
 }
 
 void KisPaintopBox::sliderChanged(int n)
 {
     if (!m_optionWidget) // widget will not exist if the are no documents open
         return;
 
 
     KisSignalsBlocker blocker(m_optionWidget);
 
     qreal opacity = m_sliderChooser[n]->getWidget<KisDoubleSliderSpinBox>("opacity")->value();
     qreal flow    = m_sliderChooser[n]->getWidget<KisDoubleSliderSpinBox>("flow")->value();
     qreal size    = m_sliderChooser[n]->getWidget<KisDoubleSliderSpinBox>("size")->value();
 
 
     setSliderValue("opacity", opacity);
     setSliderValue("flow"   , flow);
     setSliderValue("size"   , size);
 
     if (m_presetsEnabled) {
         // IMPORTANT: set the PaintOp size before setting the other properties
         //            it wont work the other way
         // TODO: why?!
 
         m_resourceProvider->setSize(size);
         m_resourceProvider->setOpacity(opacity);
         m_resourceProvider->setFlow(flow);
 
 
         KisLockedPropertiesProxySP propertiesProxy = KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(m_resourceProvider->currentPreset()->settings());
         propertiesProxy->setProperty("OpacityValue", opacity);
         propertiesProxy->setProperty("FlowValue", flow);
         m_optionWidget->setConfigurationSafe(m_resourceProvider->currentPreset()->settings().data());
     } else {
         m_resourceProvider->setOpacity(opacity);
     }
 
     m_presetsPopup->resourceSelected(m_resourceProvider->currentPreset().data());
 }
 
 void KisPaintopBox::slotSlider1Changed()
 {
     sliderChanged(0);
 }
 
 void KisPaintopBox::slotSlider2Changed()
 {
     sliderChanged(1);
 }
 
 void KisPaintopBox::slotSlider3Changed()
 {
     sliderChanged(2);
 }
 
 void KisPaintopBox::slotToolChanged(KoCanvasController* canvas, int toolId)
 {
     Q_UNUSED(canvas);
     Q_UNUSED(toolId);
 
     if (!m_viewManager->canvasBase()) return;
 
     QString  id   = KoToolManager::instance()->activeToolId();
     KisTool* tool = dynamic_cast<KisTool*>(KoToolManager::instance()->toolById(m_viewManager->canvasBase(), id));
 
     if (tool) {
         int flags = tool->flags();
 
         if (flags & KisTool::FLAG_USES_CUSTOM_COMPOSITEOP) {
             setWidgetState(ENABLE_COMPOSITEOP | ENABLE_OPACITY);
         } else                                              {
             setWidgetState(DISABLE_COMPOSITEOP | DISABLE_OPACITY);
         }
 
         if (flags & KisTool::FLAG_USES_CUSTOM_PRESET) {
             setWidgetState(ENABLE_PRESETS);
             slotUpdatePreset();
             m_presetsEnabled = true;
         } else {
             setWidgetState(DISABLE_PRESETS);
             m_presetsEnabled = false;
         }
 
         if (flags & KisTool::FLAG_USES_CUSTOM_SIZE) {
             setWidgetState(ENABLE_SIZE | ENABLE_FLOW);
         } else {
             setWidgetState(DISABLE_SIZE | DISABLE_FLOW);
         }
 
     } else setWidgetState(DISABLE_ALL);
 }
 
 void KisPaintopBox::slotPreviousFavoritePreset()
 {
     if (!m_favoriteResourceManager) return;
 
     QVector<KisPaintOpPresetSP> presets = m_favoriteResourceManager->favoritePresetList();
     for (int i=0; i < presets.size(); ++i) {
         if (m_resourceProvider->currentPreset() &&
                 m_resourceProvider->currentPreset()->name() == presets[i]->name()) {
             if (i > 0) {
                 m_favoriteResourceManager->slotChangeActivePaintop(i - 1);
             } else {
                 m_favoriteResourceManager->slotChangeActivePaintop(m_favoriteResourceManager->numFavoritePresets() - 1);
             }
             //floating message should have least 2 lines, otherwise
             //preset thumbnail will be too small to distinguish
             //(because size of image on floating message depends on amount of lines in msg)
             m_viewManager->showFloatingMessage(
                 i18n("%1\nselected",
                         m_resourceProvider->currentPreset()->name()),
                 QIcon(QPixmap::fromImage(m_resourceProvider->currentPreset()->image())));
 
             return;
         }
     }
 }
 
 void KisPaintopBox::slotNextFavoritePreset()
 {
     if (!m_favoriteResourceManager) return;
 
     QVector<KisPaintOpPresetSP> presets = m_favoriteResourceManager->favoritePresetList();
     for(int i = 0; i < presets.size(); ++i) {
         if (m_resourceProvider->currentPreset()->name() == presets[i]->name()) {
             if (i < m_favoriteResourceManager->numFavoritePresets() - 1) {
                 m_favoriteResourceManager->slotChangeActivePaintop(i + 1);
             } else {
                 m_favoriteResourceManager->slotChangeActivePaintop(0);
             }
             m_viewManager->showFloatingMessage(
                 i18n("%1\nselected",
                         m_resourceProvider->currentPreset()->name()),
                 QIcon(QPixmap::fromImage(m_resourceProvider->currentPreset()->image())));
 
             return;
         }
     }
 }
 
 void KisPaintopBox::slotSwitchToPreviousPreset()
 {
     if (m_resourceProvider->previousPreset()) {
         //qDebug() << "slotSwitchToPreviousPreset();" << m_resourceProvider->previousPreset();
         setCurrentPaintop(m_resourceProvider->previousPreset());
         m_viewManager->showFloatingMessage(
                 i18n("%1\nselected",
                         m_resourceProvider->currentPreset()->name()),
             QIcon(QPixmap::fromImage(m_resourceProvider->currentPreset()->image())));
     }
 }
 
 void KisPaintopBox::slotUnsetEraseMode()
 {
     m_eraseAction->setChecked(false);
 }
 
 void KisPaintopBox::slotToggleAlphaLockMode(bool checked)
 {
     if (checked) {
         m_alphaLockButton->actions()[0]->setIcon(KisIconUtils::loadIcon("transparency-locked"));
     } else {
         m_alphaLockButton->actions()[0]->setIcon(KisIconUtils::loadIcon("transparency-unlocked"));
     }
     m_resourceProvider->setGlobalAlphaLock(checked);
 }
 
 void KisPaintopBox::slotDisablePressureMode(bool checked)
 {
     if (checked) {
         m_disablePressureAction->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure"));
     } else {
         m_disablePressureAction->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure_locked"));
     }
 
     m_resourceProvider->setDisablePressure(checked);
 }
 
 void KisPaintopBox::slotReloadPreset()
 {
     KisSignalsBlocker blocker(m_optionWidget);
 
     //Here using the name and fetching the preset from the server was the only way the load was working. Otherwise it was not loading.
     KisPaintOpPresetResourceServer * rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
     KisPaintOpPresetSP preset = rserver->resourceByName(m_resourceProvider->currentPreset()->name());
     if (preset) {
         preset->load();
     }
 }
 void KisPaintopBox::slotGuiChangedCurrentPreset() // Called only when UI is changed and not when preset is changed
 {
     KisPaintOpPresetSP preset = m_resourceProvider->currentPreset();
 
     {
         /**
          * Here we postpone all the settings updates events until the entire writing
          * operation will be finished. As soon as it is finished, the updates will be
          * emitted happily (if there were any).
          */
 
         KisPaintOpPreset::UpdatedPostponer postponer(preset.data());
 
+
+        QStringList preserveProperties;
+        preserveProperties << "lodUserAllowed";
+        preserveProperties << "lodSizeThreshold";
+
         // clear all the properties before dumping the stuff into the preset,
         // some of the options add the values incrementally
         // (e.g. KisPaintOpUtils::RequiredBrushFilesListTag), therefore they
         // may add up if we pass the same preset multiple times
-        preset->settings()->resetSettings();
+        preset->settings()->resetSettings(preserveProperties);
 
         m_optionWidget->writeConfigurationSafe(const_cast<KisPaintOpSettings*>(preset->settings().data()));
     }
 
     // we should also update the preset strip to update the status of the "dirty" mark
     m_presetsPopup->resourceSelected(m_resourceProvider->currentPreset().data());
 
     // TODO!!!!!!!!
     //m_presetsPopup->updateViewSettings();
 }
 void KisPaintopBox::slotSaveLockedOptionToPreset(KisPropertiesConfigurationSP p)
 {
 
     QMapIterator<QString, QVariant> i(p->getProperties());
     while (i.hasNext()) {
         i.next();
         m_resourceProvider->currentPreset()->settings()->setProperty(i.key(), QVariant(i.value()));
         if (m_resourceProvider->currentPreset()->settings()->hasProperty(i.key() + "_previous")) {
             m_resourceProvider->currentPreset()->settings()->removeProperty(i.key() + "_previous");
         }
 
     }
     slotGuiChangedCurrentPreset();
 
 }
 
 void KisPaintopBox::slotDropLockedOption(KisPropertiesConfigurationSP p)
 {
     KisSignalsBlocker blocker(m_optionWidget);
     KisPaintOpPresetSP preset = m_resourceProvider->currentPreset();
 
     {
         KisPaintOpPreset::DirtyStateSaver dirtySaver(preset.data());
 
         QMapIterator<QString, QVariant> i(p->getProperties());
         while (i.hasNext()) {
             i.next();
             if (preset->settings()->hasProperty(i.key() + "_previous")) {
                 preset->settings()->setProperty(i.key(), preset->settings()->getProperty(i.key() + "_previous"));
                 preset->settings()->removeProperty(i.key() + "_previous");
             }
 
         }
     }
 
     //slotUpdatePreset();
 }
 void KisPaintopBox::slotDirtyPresetToggled(bool value)
 {
     if (!value) {
         slotReloadPreset();
         m_presetsPopup->resourceSelected(m_resourceProvider->currentPreset().data());
         m_presetsPopup->updateViewSettings();
     }
     m_dirtyPresetsEnabled = value;
     KisConfig cfg;
     cfg.setUseDirtyPresets(m_dirtyPresetsEnabled);
 
 }
 void KisPaintopBox::slotEraserBrushSizeToggled(bool value)
 {
     m_eraserBrushSizeEnabled = value;
     KisConfig cfg;
     cfg.setUseEraserBrushSize(m_eraserBrushSizeEnabled);
 }
 
 void KisPaintopBox::slotEraserBrushOpacityToggled(bool value)
 {
     m_eraserBrushOpacityEnabled = value;
     KisConfig cfg;
     cfg.setUseEraserBrushOpacity(m_eraserBrushOpacityEnabled);
 }
 
 void KisPaintopBox::slotUpdateSelectionIcon()
 {
     m_hMirrorAction->setIcon(KisIconUtils::loadIcon("symmetry-horizontal"));
     m_vMirrorAction->setIcon(KisIconUtils::loadIcon("symmetry-vertical"));
 
     KisConfig cfg;
     if (!cfg.toolOptionsInDocker() && m_toolOptionsPopupButton) {
         m_toolOptionsPopupButton->setIcon(KisIconUtils::loadIcon("configure"));
     }
 
     m_presetSelectorPopupButton->setIcon(KisIconUtils::loadIcon("paintop_settings_01"));
     m_brushEditorPopupButton->setIcon(KisIconUtils::loadIcon("paintop_settings_02"));
     m_workspaceWidget->setIcon(KisIconUtils::loadIcon("view-choose"));
 
     m_eraseAction->setIcon(KisIconUtils::loadIcon("draw-eraser"));
     m_reloadAction->setIcon(KisIconUtils::loadIcon("view-refresh"));
 
     if (m_disablePressureAction->isChecked()) {
         m_disablePressureAction->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure"));
     } else {
         m_disablePressureAction->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure_locked"));
     }
 }
 
 void KisPaintopBox::slotLockXMirrorToggle(bool toggleLock) {
     m_resourceProvider->setMirrorHorizontalLock(toggleLock);
 }
 
 void KisPaintopBox::slotLockYMirrorToggle(bool toggleLock) {
     m_resourceProvider->setMirrorVerticalLock(toggleLock);
 }
 
 void KisPaintopBox::slotHideDecorationMirrorX(bool toggled) {
     m_resourceProvider->setMirrorHorizontalHideDecorations(toggled);
 }
 
 void KisPaintopBox::slotHideDecorationMirrorY(bool toggled) {
     m_resourceProvider->setMirrorVerticalHideDecorations(toggled);
 }
 
 void KisPaintopBox::slotMoveToCenterMirrorX() {
   m_resourceProvider->mirrorHorizontalMoveCanvasToCenter();
 }
 
 void KisPaintopBox::slotMoveToCenterMirrorY() {
   m_resourceProvider->mirrorVerticalMoveCanvasToCenter();
 }
diff --git a/libs/ui/kis_script_manager.cpp b/libs/ui/kis_script_manager.cpp
deleted file mode 100644
index a93d544a5a..0000000000
--- a/libs/ui/kis_script_manager.cpp
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- *  Copyright (c) 2014 Boudewijn Rempt <boud@valdyas.org>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser 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 Lesser General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-
-#include "kis_script_manager.h"
-
-#include <QMenu>
-
-#include <KisPart.h>
-
-#include <kactionmenu.h>
-#include <klocalizedstring.h>
-#include <kactionmenu.h>
-#include <kactioncollection.h>
-#include <kis_action.h>
-
-#include <kis_action_manager.h>
-#include "KisViewManager.h"
-
-struct KisScriptManager::Private {
-    Private()
-        : actionCollection(0)
-        , actionManager(0)
-        , viewManager(0)
-        , scriptMenu(0)
-    {
-    }
-
-    KActionCollection *actionCollection;
-    KisActionManager *actionManager;
-    KisViewManager *viewManager;
-    KActionMenu *scriptMenu;
-    KActionMenu *hiddenMenu;
-};
-
-
-KisScriptManager::KisScriptManager(KisViewManager *view)
-    : QObject(view)
-    , d(new Private())
-{
-    d->viewManager = view;
-}
-
-KisScriptManager::~KisScriptManager()
-{
-    delete d;
-}
-
-
-void KisScriptManager::setup(KActionCollection * ac, KisActionManager *actionManager)
-{
-    d->actionCollection = ac;
-    d->actionManager = actionManager;
-
-    d->scriptMenu = new KActionMenu(i18n("Scripts"), this);
-    d->actionCollection->addAction("scripts", d->scriptMenu);
-    d->hiddenMenu = new KActionMenu("hidden", this);
-}
-
-void KisScriptManager::updateGUI()
-{
-    if (!d->viewManager) return;
-}
-
-void KisScriptManager::addAction(KisAction *action)
-{
-    d->actionManager->addAction(action->objectName(), action);
-    if (action->property("menu").toString() != "None") {
-        // XXX: find the right menu and add it there.
-        d->scriptMenu->addAction(action);
-    }
-    else {
-        d->hiddenMenu->addAction(action);
-        action->setShortcutContext(Qt::ApplicationShortcut);
-    }
-}
diff --git a/libs/ui/kis_script_manager.h b/libs/ui/kis_script_manager.h
deleted file mode 100644
index b1099473e9..0000000000
--- a/libs/ui/kis_script_manager.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- *  Copyright (c) 2014 Boudewijn Rempt <boud@valdyas.org>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser 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 Lesser General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-
-#ifndef KIS_SCRIPT_MANAGER_H
-#define KIS_SCRIPT_MANAGER_H
-
-#include <QObject>
-
-#include <kritaui_export.h>
-
-class KisAction;
-
-class KisActionManager;
-class KisViewManager;
-class KActionCollection;
-
-/**
- * @brief The KisScriptManager class is responsible for adding scripts to the menu
- */
-class KRITAUI_EXPORT KisScriptManager : public QObject
-{
-    Q_OBJECT
-public:
-    explicit KisScriptManager(KisViewManager * view);
-    ~KisScriptManager() override;
-
-    void setup(KActionCollection * ac, KisActionManager *actionManager);
-    void updateGUI();
-
-    void addAction(KisAction *action);
-
-private:
-    struct Private;
-    Private * const d;
-};
-
-#endif // KIS_SCRIPT_MANAGER_H
diff --git a/libs/ui/tool/kis_resources_snapshot.cpp b/libs/ui/tool/kis_resources_snapshot.cpp
index 71f73b32c1..733ef420a0 100644
--- a/libs/ui/tool/kis_resources_snapshot.cpp
+++ b/libs/ui/tool/kis_resources_snapshot.cpp
@@ -1,437 +1,429 @@
 /*
  *  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_resources_snapshot.h"
 
 #include <KoColor.h>
 #include <resources/KoAbstractGradient.h>
 #include <KoCompositeOpRegistry.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <brushengine/kis_paintop_settings.h>
 #include <brushengine/kis_paintop_registry.h>
 #include <kis_threaded_text_rendering_workaround.h>
 #include <resources/KoPattern.h>
 #include "kis_canvas_resource_provider.h"
 #include "filter/kis_filter_configuration.h"
 #include "kis_image.h"
 #include "kis_paint_device.h"
 #include "kis_paint_layer.h"
 #include "recorder/kis_recorded_paint_action.h"
 #include "kis_selection.h"
 #include "kis_selection_mask.h"
 #include "kis_algebra_2d.h"
 
 
 struct KisResourcesSnapshot::Private {
     Private()
         : currentPattern(0)
         , currentGradient(0)
         , currentGenerator(0)
         , compositeOp(0)
     {
     }
 
     KisImageSP image;
     KisDefaultBoundsBaseSP bounds;
     KoColor currentFgColor;
     KoColor currentBgColor;
     KoPattern *currentPattern = 0;
     KoAbstractGradient *currentGradient;
     KisPaintOpPresetSP currentPaintOpPreset;
     KisNodeSP currentNode;
     qreal currentExposure;
     KisFilterConfigurationSP currentGenerator;
 
     QPointF axesCenter;
     bool mirrorMaskHorizontal = false;
     bool mirrorMaskVertical = false;
 
     quint8 opacity = OPACITY_OPAQUE_U8;
     QString compositeOpId = COMPOSITE_OVER;
     const KoCompositeOp *compositeOp;
 
     KisPainter::StrokeStyle strokeStyle = KisPainter::StrokeStyleBrush;
     KisPainter::FillStyle fillStyle = KisPainter::FillStyleForegroundColor;
 
     bool globalAlphaLock = false;
     qreal effectiveZoom = 1.0;
     bool presetAllowsLod = false;
     KisSelectionSP selectionOverride;
 };
 
 KisResourcesSnapshot::KisResourcesSnapshot(KisImageSP image, KisNodeSP currentNode, KoCanvasResourceManager *resourceManager, KisDefaultBoundsBaseSP bounds)
     : m_d(new Private())
 {
     m_d->image = image;
     if (!bounds) {
         bounds = new KisDefaultBounds(m_d->image);
     }
     m_d->bounds = bounds;
     m_d->currentFgColor = resourceManager->resource(KoCanvasResourceManager::ForegroundColor).value<KoColor>();
     m_d->currentBgColor = resourceManager->resource(KoCanvasResourceManager::BackgroundColor).value<KoColor>();
     m_d->currentPattern = resourceManager->resource(KisCanvasResourceProvider::CurrentPattern).value<KoPattern*>();
     m_d->currentGradient = resourceManager->resource(KisCanvasResourceProvider::CurrentGradient).value<KoAbstractGradient*>();
 
     /**
      * We should deep-copy the preset, so that long-runnign actions
      * will have correct brush parameters. Theoretically this cloniong
      * can be expensive, but according to measurements, it takes
      * something like 0.1 ms for an average preset.
      */
     m_d->currentPaintOpPreset = resourceManager->resource(KisCanvasResourceProvider::CurrentPaintOpPreset).value<KisPaintOpPresetSP>()->clone();
 
 #ifdef HAVE_THREADED_TEXT_RENDERING_WORKAROUND
     KisPaintOpRegistry::instance()->preinitializePaintOpIfNeeded(m_d->currentPaintOpPreset);
 #endif /* HAVE_THREADED_TEXT_RENDERING_WORKAROUND */
 
     m_d->currentExposure = resourceManager->resource(KisCanvasResourceProvider::HdrExposure).toDouble();
     m_d->currentGenerator = resourceManager->resource(KisCanvasResourceProvider::CurrentGeneratorConfiguration).value<KisFilterConfiguration*>();
 
 
     QPointF relativeAxesCenter(0.5, 0.5);
     if (m_d->image) {
         relativeAxesCenter = m_d->image->mirrorAxesCenter();
     }
     m_d->axesCenter = KisAlgebra2D::relativeToAbsolute(relativeAxesCenter, m_d->bounds->bounds());
 
     m_d->mirrorMaskHorizontal = resourceManager->resource(KisCanvasResourceProvider::MirrorHorizontal).toBool();
     m_d->mirrorMaskVertical = resourceManager->resource(KisCanvasResourceProvider::MirrorVertical).toBool();
 
 
     qreal normOpacity = resourceManager->resource(KisCanvasResourceProvider::Opacity).toDouble();
     m_d->opacity = quint8(normOpacity * OPACITY_OPAQUE_U8);
 
     m_d->compositeOpId = resourceManager->resource(KisCanvasResourceProvider::CurrentEffectiveCompositeOp).toString();
     setCurrentNode(currentNode);
 
     /**
      * Fill and Stroke styles are not a part of the resource manager
      * so the tools should set them manually
      * TODO: port stroke and fill styles to be a part
      *       of the resource manager
      */
     m_d->strokeStyle = KisPainter::StrokeStyleBrush;
     m_d->fillStyle = KisPainter::FillStyleNone;
 
     m_d->globalAlphaLock = resourceManager->resource(KisCanvasResourceProvider::GlobalAlphaLock).toBool();
     m_d->effectiveZoom = resourceManager->resource(KisCanvasResourceProvider::EffectiveZoom).toDouble();
 
-
-    m_d->presetAllowsLod = true;
-
-    if (m_d->currentPaintOpPreset) {
-        m_d->presetAllowsLod =
-            KisPaintOpSettings::isLodUserAllowed(m_d->currentPaintOpPreset->settings()) &&
-            (!m_d->currentPaintOpPreset->settings()->lodSizeThresholdSupported() ||
-             m_d->currentPaintOpPreset->settings()->lodSizeThreshold() <= m_d->currentPaintOpPreset->settings()->paintOpSize());
-    }
+    m_d->presetAllowsLod = resourceManager->resource(KisCanvasResourceProvider::EffectiveLodAvailablility).toBool();
 }
 
 KisResourcesSnapshot::KisResourcesSnapshot(KisImageSP image, KisNodeSP currentNode, KisDefaultBoundsBaseSP bounds)
     : m_d(new Private())
 {
     m_d->image = image;
     if (!bounds) {
         bounds = new KisDefaultBounds(m_d->image);
     }
     m_d->bounds = bounds;
 
 #ifdef HAVE_THREADED_TEXT_RENDERING_WORKAROUND
     KisPaintOpRegistry::instance()->preinitializePaintOpIfNeeded(m_d->currentPaintOpPreset);
 #endif /* HAVE_THREADED_TEXT_RENDERING_WORKAROUND */
 
     QPointF relativeAxesCenter(0.5, 0.5);
     if (m_d->image) {
         relativeAxesCenter = m_d->image->mirrorAxesCenter();
     }
     m_d->axesCenter = KisAlgebra2D::relativeToAbsolute(relativeAxesCenter, m_d->bounds->bounds());
     m_d->opacity = OPACITY_OPAQUE_U8;
 
     setCurrentNode(currentNode);
 
     /**
      * Fill and Stroke styles are not a part of the resource manager
      * so the tools should set them manually
      * TODO: port stroke and fill styles to be a part
      *       of the resource manager
      */
     m_d->strokeStyle = KisPainter::StrokeStyleBrush;
     m_d->fillStyle = KisPainter::FillStyleNone;
 }
 
 
 KisResourcesSnapshot::~KisResourcesSnapshot()
 {
     delete m_d;
 }
 
 void KisResourcesSnapshot::setupPainter(KisPainter* painter)
 {
     painter->setPaintColor(m_d->currentFgColor);
     painter->setBackgroundColor(m_d->currentBgColor);
     painter->setGenerator(m_d->currentGenerator);
     painter->setPattern(m_d->currentPattern);
     painter->setGradient(m_d->currentGradient);
 
     QBitArray lockflags = channelLockFlags();
     if (lockflags.size() > 0) {
         painter->setChannelFlags(lockflags);
     }
 
     painter->setOpacity(m_d->opacity);
     painter->setCompositeOp(m_d->compositeOp);
     painter->setMirrorInformation(m_d->axesCenter, m_d->mirrorMaskHorizontal, m_d->mirrorMaskVertical);
 
     painter->setStrokeStyle(m_d->strokeStyle);
     painter->setFillStyle(m_d->fillStyle);
 
     /**
      * The paintOp should be initialized the last, because it may
      * ask the painter for some options while initialization
      */
     painter->setPaintOpPreset(m_d->currentPaintOpPreset, m_d->currentNode, m_d->image);
 }
 
 void KisResourcesSnapshot::setupMaskingBrushPainter(KisPainter *painter)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(painter->device());
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->currentPaintOpPreset->hasMaskingPreset());
 
     painter->setPaintColor(KoColor(Qt::white, painter->device()->colorSpace()));
     painter->setBackgroundColor(KoColor(Qt::black, painter->device()->colorSpace()));
 
     painter->setOpacity(OPACITY_OPAQUE_U8);
     painter->setChannelFlags(QBitArray());
 
     // masked brush always paints in indirect mode
     painter->setCompositeOp(COMPOSITE_ALPHA_DARKEN);
 
     painter->setMirrorInformation(m_d->axesCenter, m_d->mirrorMaskHorizontal, m_d->mirrorMaskVertical);
 
     /**
      * The paintOp should be initialized the last, because it may
      * ask the painter for some options while initialization
      */
     painter->setPaintOpPreset(m_d->currentPaintOpPreset->createMaskingPreset(),
                               m_d->currentNode, m_d->image);
 }
 
 void KisResourcesSnapshot::setupPaintAction(KisRecordedPaintAction *action)
 {
     action->setPaintOpPreset(m_d->currentPaintOpPreset);
     action->setPaintIncremental(!needsIndirectPainting());
 
     action->setPaintColor(m_d->currentFgColor);
     action->setBackgroundColor(m_d->currentBgColor);
     action->setGenerator(m_d->currentGenerator);
     action->setGradient(m_d->currentGradient);
     action->setPattern(m_d->currentPattern);
 
     action->setOpacity(m_d->opacity / qreal(OPACITY_OPAQUE_U8));
     action->setCompositeOp(m_d->compositeOp->id());
 
     action->setStrokeStyle(m_d->strokeStyle);
     action->setFillStyle(m_d->fillStyle);
 }
 
 KisPostExecutionUndoAdapter* KisResourcesSnapshot::postExecutionUndoAdapter() const
 {
     return m_d->image ? m_d->image->postExecutionUndoAdapter() : 0;
 }
 
 void KisResourcesSnapshot::setCurrentNode(KisNodeSP node)
 {
     m_d->currentNode = node;
 
     KisPaintDeviceSP device;
     if(m_d->currentNode && (device = m_d->currentNode->paintDevice())) {
         m_d->compositeOp = device->colorSpace()->compositeOp(m_d->compositeOpId);
         if(!m_d->compositeOp) {
             m_d->compositeOp = device->colorSpace()->compositeOp(COMPOSITE_OVER);
         }
     }
 }
 
 void KisResourcesSnapshot::setStrokeStyle(KisPainter::StrokeStyle strokeStyle)
 {
     m_d->strokeStyle = strokeStyle;
 }
 
 void KisResourcesSnapshot::setFillStyle(KisPainter::FillStyle fillStyle)
 {
     m_d->fillStyle = fillStyle;
 }
 
 KisNodeSP KisResourcesSnapshot::currentNode() const
 {
     return m_d->currentNode;
 }
 
 KisImageSP KisResourcesSnapshot::image() const
 {
     return m_d->image;
 }
 
 bool KisResourcesSnapshot::needsIndirectPainting() const
 {
     return !m_d->currentPaintOpPreset->settings()->paintIncremental();
 }
 
 QString KisResourcesSnapshot::indirectPaintingCompositeOp() const
 {
     return m_d->currentPaintOpPreset->settings()->indirectPaintingCompositeOp();
 }
 
 bool KisResourcesSnapshot::needsMaskingBrushRendering() const
 {
     return m_d->currentPaintOpPreset && m_d->currentPaintOpPreset->hasMaskingPreset();
 }
 
 KisSelectionSP KisResourcesSnapshot::activeSelection() const
 {
     /**
      * It is possible to have/use the snapshot without the image. Such
      * usecase is present for example in the scratchpad.
      */
     if (m_d->selectionOverride) {
         return m_d->selectionOverride;
     }
 
     KisSelectionSP selection = m_d->image ? m_d->image->globalSelection() : 0;
 
     KisLayerSP layer = qobject_cast<KisLayer*>(m_d->currentNode.data());
     KisSelectionMaskSP mask;
     if((layer = qobject_cast<KisLayer*>(m_d->currentNode.data()))) {
          selection = layer->selection();
     } else if ((mask = dynamic_cast<KisSelectionMask*>(m_d->currentNode.data())) &&
                mask->selection() == selection) {
 
          selection = 0;
     }
 
     return selection;
 }
 
 bool KisResourcesSnapshot::needsAirbrushing() const
 {
     return m_d->currentPaintOpPreset->settings()->isAirbrushing();
 }
 
 qreal KisResourcesSnapshot::airbrushingInterval() const
 {
     return m_d->currentPaintOpPreset->settings()->airbrushInterval();
 }
 
 bool KisResourcesSnapshot::needsSpacingUpdates() const
 {
     return m_d->currentPaintOpPreset->settings()->useSpacingUpdates();
 }
 
 void KisResourcesSnapshot::setOpacity(qreal opacity)
 {
     m_d->opacity = opacity * OPACITY_OPAQUE_U8;
 }
 
 quint8 KisResourcesSnapshot::opacity() const
 {
     return m_d->opacity;
 }
 
 const KoCompositeOp* KisResourcesSnapshot::compositeOp() const
 {
     return m_d->compositeOp;
 }
 
 QString KisResourcesSnapshot::compositeOpId() const
 {
     return m_d->compositeOpId;
 }
 
 KoPattern* KisResourcesSnapshot::currentPattern() const
 {
     return m_d->currentPattern;
 }
 
 KoColor KisResourcesSnapshot::currentFgColor() const
 {
     return m_d->currentFgColor;
 }
 
 KoColor KisResourcesSnapshot::currentBgColor() const
 {
     return m_d->currentBgColor;
 }
 
 KisPaintOpPresetSP KisResourcesSnapshot::currentPaintOpPreset() const
 {
     return m_d->currentPaintOpPreset;
 }
 
 
 QBitArray KisResourcesSnapshot::channelLockFlags() const
 {
     QBitArray channelFlags;
     KisPaintLayer *paintLayer;
     if ((paintLayer = dynamic_cast<KisPaintLayer*>(m_d->currentNode.data()))) {
 
         channelFlags = paintLayer->channelLockFlags();
         if (m_d->globalAlphaLock) {
             if (channelFlags.isEmpty()) {
                 channelFlags = paintLayer->colorSpace()->channelFlags(true, true);
             }
 
             channelFlags &= paintLayer->colorSpace()->channelFlags(true, false);
         }
     }
     return channelFlags;
 }
 
 qreal KisResourcesSnapshot::effectiveZoom() const
 {
     return m_d->effectiveZoom;
 }
 
 bool KisResourcesSnapshot::presetAllowsLod() const
 {
     return m_d->presetAllowsLod;
 }
 
 bool KisResourcesSnapshot::presetNeedsAsynchronousUpdates() const
 {
     return m_d->currentPaintOpPreset && m_d->currentPaintOpPreset->settings()->needsAsynchronousUpdates();
 }
 
 void KisResourcesSnapshot::setFGColorOverride(const KoColor &color)
 {
     m_d->currentFgColor = color;
 }
 
 void KisResourcesSnapshot::setBGColorOverride(const KoColor &color)
 {
     m_d->currentBgColor = color;
 }
 
 void KisResourcesSnapshot::setSelectionOverride(KisSelectionSP selection)
 {
     m_d->selectionOverride = selection;
 }
 
 void KisResourcesSnapshot::setBrush(const KisPaintOpPresetSP &brush)
 {
     m_d->currentPaintOpPreset = brush;
 }
diff --git a/libs/ui/widgets/kis_lod_availability_widget.cpp b/libs/ui/widgets/kis_lod_availability_widget.cpp
index 7e7397a9e6..0e9c645bcf 100644
--- a/libs/ui/widgets/kis_lod_availability_widget.cpp
+++ b/libs/ui/widgets/kis_lod_availability_widget.cpp
@@ -1,233 +1,252 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_lod_availability_widget.h"
 
 #include <QPushButton>
 #include <QCheckBox>
 #include <QHBoxLayout>
 #include <QToolTip>
 
 
 #include <kis_canvas_resource_provider.h>
 #include <kis_slider_spin_box.h>
 #include "kis_config.h"
 #include <QWidgetAction>
 #include <QMenu>
 
 #include "kis_signals_blocker.h"
 
 namespace {
 /**
  * These strings are added intentionally so we could relayout the threshold slider after
  * the string freeze for 4.0. Please translate them :)
  */
 static const QString stringForInstantPreviewThreshold1 = i18nc("@label:slider", "Threshold:");
 static const QString stringForInstantPreviewThreshold2 = i18nc("@label:slider", "Instant preview threshold:");
 }
 
 
 struct KisLodAvailabilityWidget::Private
 {
     Private() : chkLod(0), resourceManager(0) {}
 
     QCheckBox *chkLod;
     QPushButton *btnLod;
     QScopedPointer<QMenu> thresholdMenu;
     KisDoubleSliderSpinBox *thresholdSlider = 0;
     KoCanvasResourceManager *resourceManager;
 
     KisPaintopLodLimitations limitations;
     bool thresholdSupported = true;
 
     bool sizeThresholdPassed();
 };
 
 KisLodAvailabilityWidget::KisLodAvailabilityWidget(QWidget *parent)
     : QWidget(parent),
       m_d(new Private)
 {
     m_d->chkLod = new QCheckBox(this);
 
     m_d->btnLod = new QPushButton(this);
     m_d->btnLod->setFlat(true);
 
     connect(m_d->btnLod, SIGNAL(clicked()), SLOT(showLodToolTip()));
 
     {
         m_d->thresholdMenu.reset(new QMenu());
         m_d->thresholdMenu->addSection(i18n("Enable after:"));
 
         m_d->btnLod->setContextMenuPolicy(Qt::CustomContextMenu);
         connect(m_d->btnLod, SIGNAL(customContextMenuRequested(QPoint)),
                 this, SLOT(showLodThresholdWidget(QPoint)));
 
         KisConfig cfg;
         m_d->thresholdSlider = new KisDoubleSliderSpinBox(m_d->thresholdMenu.data());
 
         m_d->thresholdSlider->setRange(0, cfg.readEntry("maximumBrushSize", 1000), 2);
         m_d->thresholdSlider->setValue(100);
         m_d->thresholdSlider->setSingleStep(1);
         m_d->thresholdSlider->setExponentRatio(3.0);
         m_d->thresholdSlider->setSuffix(i18n(" px"));
         m_d->thresholdSlider->setBlockUpdateSignalOnDrag(true);
 
         QWidgetAction *sliderAction = new QWidgetAction(this);
         sliderAction->setDefaultWidget(m_d->thresholdSlider);
 
         m_d->thresholdMenu->addAction(sliderAction);
     }
 
     QHBoxLayout *layout = new QHBoxLayout;
     layout->addWidget(m_d->chkLod);
     layout->addWidget(m_d->btnLod);
 
     layout->setSpacing(0);
 
     setLayout(layout);
 
     // set no limitations
     setLimitations(m_d->limitations);
 
     connect(m_d->chkLod, SIGNAL(toggled(bool)), SIGNAL(sigUserChangedLodAvailability(bool)));
     connect(m_d->thresholdSlider, SIGNAL(valueChanged(qreal)), SIGNAL(sigUserChangedLodThreshold(qreal)));
 }
 
 KisLodAvailabilityWidget::~KisLodAvailabilityWidget()
 {
 }
 
 void KisLodAvailabilityWidget::showLodToolTip()
 {
     QToolTip::showText(QCursor::pos(), m_d->btnLod->toolTip(), m_d->btnLod);
 }
 
 void KisLodAvailabilityWidget::showLodThresholdWidget(const QPoint &pos)
 {
     Q_UNUSED(pos);
 
     if (m_d->thresholdSupported) {
         m_d->thresholdMenu->popup(QCursor::pos());
     }
 }
 
 void KisLodAvailabilityWidget::setLimitations(const KisPaintopLodLimitations &l)
 {
     QString limitationsText;
     Q_FOREACH (const KoID &id, l.limitations) {
         limitationsText.append("<li>");
         limitationsText.append(id.name());
         limitationsText.append("</li>");
     }
 
     QString blockersText;
     Q_FOREACH (const KoID &id, l.blockers) {
         blockersText.append("<li>");
         blockersText.append(id.name());
         blockersText.append("</li>");
     }
 
     bool isBlocked = !l.blockers.isEmpty();
     bool isLimited = !l.limitations.isEmpty();
 
     m_d->thresholdSupported =
         m_d->resourceManager ?
         m_d->resourceManager->resource(KisCanvasResourceProvider::LodSizeThresholdSupported).toBool() :
         true;
     bool isBlockedByThreshold = !m_d->sizeThresholdPassed() && m_d->thresholdSupported;
 
     const QString text = !isBlocked && !isBlockedByThreshold && isLimited ?
         i18n("(Instant Preview)*") : i18n("Instant Preview");
 
     QString toolTip;
 
     if (isBlocked) {
         toolTip = i18nc("@info:tooltip",
                         "<p>Instant Preview Mode is "
                         "disabled by the following options:"
                         "<ul>%1</ul></p>", blockersText);
     } else if (isBlockedByThreshold) {
         const qreal lodThreshold = m_d->resourceManager->resource(KisCanvasResourceProvider::LodSizeThreshold).toDouble();
         const qreal size = m_d->resourceManager->resource(KisCanvasResourceProvider::Size).toDouble();
 
         toolTip = i18nc("@info:tooltip",
                         "<p>Instant Preview Mode is "
                         "disabled by instant preview threshold. "
                         "Please right-click here to change the threshold"
                         "<ul><li>Brush size %1</li>"
                         "<li>Threshold: %2</li></ul></p>",
                         size, lodThreshold);
 
     } else if (isLimited) {
         toolTip = i18nc("@info:tooltip",
                         "<p>Instant Preview may look different "
                         "from the final result. In case of troubles "
                         "try disabling the following options:"
                         "<ul>%1</ul></p>", limitationsText);
     } else {
         toolTip = i18nc("@info:tooltip", "<p>Instant Preview Mode is available</p>");
     }
 
     {
         QFont font;
         font.setStrikeOut(isBlocked || isBlockedByThreshold);
         m_d->chkLod->setEnabled(!isBlocked);
         m_d->btnLod->setEnabled(!isBlocked);
         m_d->btnLod->setFont(font);
         m_d->btnLod->setText(text);
         m_d->btnLod->setToolTip(toolTip);
+
+        if (isBlocked) {
+            /**
+             * If LoD is really blocked by some limitation we sneakly reset
+             * the checkbox to let the user know it is fully disabled.
+             */
+
+            KisSignalsBlocker b(m_d->chkLod);
+            m_d->chkLod->setChecked(false);
+        }
     }
 
     m_d->limitations = l;
+
+    if (m_d->resourceManager) {
+        const bool lodAvailableForUse =
+            !isBlocked && !isBlockedByThreshold &&
+            m_d->resourceManager->resource(KisCanvasResourceProvider::LodAvailability).toBool();
+
+        m_d->resourceManager->setResource(KisCanvasResourceProvider::EffectiveLodAvailablility, lodAvailableForUse);
+    }
+
 }
 
 void KisLodAvailabilityWidget::slotUserChangedLodAvailability(bool value)
 {
     KisSignalsBlocker b(m_d->chkLod);
 
     m_d->chkLod->setChecked(value);
 }
 
 void KisLodAvailabilityWidget::slotUserChangedLodThreshold(qreal value)
 {
     KisSignalsBlocker b(m_d->thresholdSlider);
 
     m_d->thresholdSlider->setValue(value);
     setLimitations(m_d->limitations);
 }
 
 void KisLodAvailabilityWidget::slotUserChangedSize(qreal value)
 {
     Q_UNUSED(value);
     setLimitations(m_d->limitations);
 }
 
 void KisLodAvailabilityWidget::setCanvasResourceManager(KoCanvasResourceManager *resourceManager)
 {
     m_d->resourceManager = resourceManager;
 }
 
 bool KisLodAvailabilityWidget::Private::sizeThresholdPassed()
 {
     if (!resourceManager) return true;
 
     const qreal lodThreshold = resourceManager->resource(KisCanvasResourceProvider::LodSizeThreshold).toDouble();
     const qreal size = resourceManager->resource(KisCanvasResourceProvider::Size).toDouble();
 
     return size >= lodThreshold;
 }
diff --git a/libs/widgets/KoResourceServer.h b/libs/widgets/KoResourceServer.h
index a991bc2663..4dcc56d2c3 100644
--- a/libs/widgets/KoResourceServer.h
+++ b/libs/widgets/KoResourceServer.h
@@ -1,741 +1,753 @@
 /*  This file is part of the KDE project
 
     Copyright (c) 1999 Matthias Elter <elter@kde.org>
     Copyright (c) 2003 Patrick Julien <freak@codepimps.org>
     Copyright (c) 2005 Sven Langkamp <sven.langkamp@gmail.com>
     Copyright (c) 2007 Jan Hambrecht <jaham@gmx.net>
     Copyright (C) 2011 Srikanth Tiyyagura <srikanth.tulasiram@gmail.com>
     Copyright (c) 2013 Sascha Suelzer <s.suelzer@gmail.com>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Lesser General Public
     License as published by the Free Software Foundation; either
     version 2.1 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Lesser General Public License for more details.
 
     You should have received a copy of the GNU Lesser General Public
     License along with this library; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
 #ifndef KORESOURCESERVER_H
 #define KORESOURCESERVER_H
 
 #include <QMutex>
 #include <QString>
 #include <QStringList>
 #include <QList>
 #include <QFileInfo>
 #include <QDir>
 
 #include <QTemporaryFile>
 #include <QDomDocument>
 #include "resources/KoResource.h"
 #include "KoResourceServerPolicies.h"
 #include "KoResourceServerObserver.h"
 #include "KoResourceTagStore.h"
 #include "KoResourcePaths.h"
 
 
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 
 #include "kritawidgets_export.h"
 #include "WidgetsDebug.h"
 
 class KoResource;
 
 /**
  * KoResourceServerBase is the base class of all resource servers
  */
 class KRITAWIDGETS_EXPORT KoResourceServerBase {
 
 public:
     /**
     * Constructs a KoResourceServerBase
     * @param resource type, has to be the same as used by KoResourcePaths
     * @param extensions the file extensions separate by ':', e.g. "*.kgr:*.svg:*.ggr"
     */
     KoResourceServerBase(const QString& type, const QString& extensions)
         : m_type(type)
         , m_extensions(extensions)
     {
     }
 
     virtual ~KoResourceServerBase() {}
 
     virtual int resourceCount() const = 0;
     virtual void loadResources(QStringList filenames) = 0;
     virtual QStringList blackListedFiles() const = 0;
     virtual QStringList queryResources(const QString &query) const = 0;
     QString type() const { return m_type; }
 
     /**
     * File extensions for resources of the server
     * @returns the file extensions separated by ':', e.g. "*.kgr:*.svg:*.ggr"
     */
     QString extensions() const { return m_extensions; }
 
-    QStringList fileNames() const
+    QStringList fileNames()
     {
         QStringList extensionList = m_extensions.split(':');
         QStringList fileNames;
 
         foreach (const QString &extension, extensionList) {
             fileNames += KoResourcePaths::findAllResources(type().toLatin1(), extension, KoResourcePaths::Recursive);
+        }
 
+        if (type() == "kis_resourcebundles") {
+            KConfigGroup group = KSharedConfig::openConfig()->group("BundleHack");
+            if (group.readEntry("HideKrita3Bundle", true)) {
+                Q_FOREACH(const QString &filename, fileNames) {
+                    if (filename.endsWith("Krita_3_Default_Resources.bundle")) {
+                        if (!m_blackListFileNames.contains(filename)) {
+                            m_blackListFileNames.append(filename);
+                        }
+                    }
+                }
+            }
         }
         return fileNames;
     }
 
 protected:
 
+    QStringList m_blackListFileNames;
+
     friend class KoResourceTagStore;
     virtual KoResource *byMd5(const QByteArray &md5) const = 0;
     virtual KoResource *byFileName(const QString &fileName) const = 0;
 
 private:
     QString m_type;
     QString m_extensions;
 
 protected:
 
     QMutex m_loadLock;
 
 };
 
 /**
  * KoResourceServer manages the resources of one type. It stores,
  * loads and saves the resources.  To keep track of changes the server
  * can be observed with a KoResourceServerObserver
  *
  * The \p Policy template parameter defines the way how the lifetime
 
  * of a resource is handled.  There are to predefined policies:
 
  *
  *   o PointerStoragePolicy --- usual pointers with ownership over
  *                              the resource.
 
  *   o SharedPointerStoragePolicy --- shared pointers. The server does no
  *                                    extra handling for the lifetime of
  *                                    the resource.
  *
  * Use the former for usual resources and the latter for shared pointer based
  * ones.
  */
 
 template <class T, class Policy = PointerStoragePolicy<T> >
 class KoResourceServer : public KoResourceServerBase
 {
 public:
     typedef typename Policy::PointerType PointerType;
     typedef KoResourceServerObserver<T, Policy> ObserverType;
     KoResourceServer(const QString& type, const QString& extensions)
         : KoResourceServerBase(type, extensions)
     {
         m_blackListFile = KoResourcePaths::locateLocal("data", type + ".blacklist");
         m_blackListFileNames = readBlackListFile();
         m_tagStore = new KoResourceTagStore(this);
         m_tagStore->loadTags();
     }
 
     ~KoResourceServer() override
     {
         if (m_tagStore) {
             delete m_tagStore;
         }
 
         Q_FOREACH (ObserverType* observer, m_observers) {
             observer->unsetResourceServer();
         }
 
         Q_FOREACH (PointerType res, m_resources) {
             Policy::deleteResource(res);
         }
 
         m_resources.clear();
 
     }
 
     int resourceCount() const override {
         return m_resources.size();
     }
 
     /**
      * Loads a set of resources and adds them to the resource server.
      * If a filename appears twice the resource will only be added once. Resources that can't
      * be loaded or and invalid aren't added to the server.
      * @param filenames list of filenames to be loaded
      */
     void loadResources(QStringList filenames) override {
 
         QStringList uniqueFiles;
 
         while (!filenames.empty()) {
 
             QString front = filenames.first();
             filenames.pop_front();
 
             // In the save location, people can use sub-folders... And then they probably want
             // to load both versions! See https://bugs.kde.org/show_bug.cgi?id=321361.
             QString fname;
             if (front.contains(saveLocation())) {
                 fname = front.split(saveLocation())[1];
             }
             else {
                 fname = QFileInfo(front).fileName();
             }
 
             // XXX: Don't load resources with the same filename. Actually, we should look inside
             //      the resource to find out whether they are really the same, but for now this
             //      will prevent the same brush etc. showing up twice.
             if (!uniqueFiles.contains(fname)) {
                 m_loadLock.lock();
                 uniqueFiles.append(fname);
                 QList<PointerType> resources = createResources(front);
                 Q_FOREACH (PointerType resource, resources) {
                     Q_CHECK_PTR(resource);
                     if (resource->load() && resource->valid() && !resource->md5().isEmpty()) {
                         addResourceToMd5Registry(resource);
 
                         m_resourcesByFilename[resource->shortFilename()] = resource;
 
                         if (resource->name().isEmpty()) {
                             resource->setName(fname);
                         }
                         if (m_resourcesByName.contains(resource->name())) {
                             resource->setName(resource->name() + "(" + resource->shortFilename() + ")");
                         }
                         m_resourcesByName[resource->name()] = resource;
                         notifyResourceAdded(resource);
                     }
                     else {
                         warnWidgets << "Loading resource " << front << "failed";
                         Policy::deleteResource(resource);
                     }
                 }
                 m_loadLock.unlock();
             }
         }
 
         m_resources = sortedResources();
 
         Q_FOREACH (ObserverType* observer, m_observers) {
             observer->syncTaggedResourceView();
         }
         m_tagStore->clearOldSystemTags();
         debugWidgets << "done loading  resources for type " << type();
     }
 
 
     /// Adds an already loaded resource to the server
     bool addResource(PointerType resource, bool save = true, bool infront = false) {
         if (!resource->valid()) {
             warnWidgets << "Tried to add an invalid resource!";
             return false;
         }
 
         if (save) {
             QFileInfo fileInfo(resource->filename());
 
             QDir d(fileInfo.path());
             if (!d.exists()) {
                 d.mkdir(fileInfo.path());
             }
 
             if (fileInfo.exists()) {
                 QString filename = fileInfo.path() + "/" + fileInfo.baseName() + "XXXXXX" + "." + fileInfo.suffix();
                 debugWidgets << "fileName is " << filename;
                 QTemporaryFile file(filename);
                 if (file.open()) {
                     debugWidgets << "now " << file.fileName();
                     resource->setFilename(file.fileName());
                 }
             }
 
             if (!resource->save()) {
                 warnWidgets << "Could not save resource!";
                 return false;
             }
         }
 
         Q_ASSERT(!resource->filename().isEmpty() || !resource->name().isEmpty());
         if (resource->filename().isEmpty()) {
             resource->setFilename(resource->name());
         }
         else if (resource->name().isEmpty()) {
             resource->setName(resource->filename());
         }
 
         m_resourcesByFilename[resource->shortFilename()] = resource;
         addResourceToMd5Registry(resource);
         m_resourcesByName[resource->name()] = resource;
         if (infront) {
             m_resources.insert(0, resource);
         }
         else {
             m_resources.append(resource);
         }
 
         notifyResourceAdded(resource);
 
         return true;
     }
 
     /**
      * Removes a given resource from the blacklist.
      */
     bool removeFromBlacklist(PointerType resource) {
         if (m_blackListFileNames.contains(resource->filename())) {
             m_blackListFileNames.removeAll(resource->filename());
             writeBlackListFile();
-            }
-            else{
-                warnWidgets<<"Doesn't contain filename";
-                return false;
-            }
-
-
-        //then return true//
-        return true;
+            return true;
+        }
+        return false;
     }
+
     /// Remove a resource from Resource Server but not from a file
     bool removeResourceFromServer(PointerType resource){
         if ( !m_resourcesByFilename.contains( resource->shortFilename() ) ) {
             return false;
         }
         removeResourceFromMd5Registry(resource);
         m_resourcesByName.remove(resource->name());
         m_resourcesByFilename.remove(resource->shortFilename());
         m_resources.removeAt(m_resources.indexOf(resource));
         m_tagStore->removeResource(resource);
         notifyRemovingResource(resource);
 
         Policy::deleteResource(resource);
         return true;
     }
 
     /// Remove a resource from the resourceserver and blacklist it
 
     bool removeResourceAndBlacklist(PointerType resource) {
 
         if ( !m_resourcesByFilename.contains( resource->shortFilename() ) ) {
             return false;
         }
         removeResourceFromMd5Registry(resource);
         m_resourcesByName.remove(resource->name());
         m_resourcesByFilename.remove(resource->shortFilename());
         m_resources.removeAt(m_resources.indexOf(resource));
         m_tagStore->removeResource(resource);
         notifyRemovingResource(resource);
 
         m_blackListFileNames.append(resource->filename());
         writeBlackListFile();
         Policy::deleteResource(resource);
         return true;
     }
 
     QList<PointerType> resources() {
         m_loadLock.lock();
         QList<PointerType> resourceList = m_resources;
         Q_FOREACH (PointerType r, m_resourceBlackList) {
             resourceList.removeOne(r);
         }
         m_loadLock.unlock();
         return resourceList;
     }
 
     /// Returns path where to save user defined and imported resources to
     virtual QString saveLocation() {
         return KoResourcePaths::saveLocation(type().toLatin1());
     }
 
     /**
      * Creates a new resource from a given file and adds them to the resource server
      * The base implementation does only load one resource per file, override to implement collections
      * @param filename file name of the resource file to be imported
      * @param fileCreation decides whether to create the file in the saveLocation() directory
      */
     virtual bool importResourceFile(const QString & filename , bool fileCreation=true) {
 
         QFileInfo fi(filename);
         if (!fi.exists())
             return false;
         if ( fi.size() == 0)
             return false;
 
         PointerType resource = createResource( filename );
         resource->load();
         if (!resource->valid()) {
             warnWidgets << "Import failed! Resource is not valid";
             Policy::deleteResource(resource);
 
             return false;
 
         }
 
         if (fileCreation) {
             Q_ASSERT(!resource->defaultFileExtension().isEmpty());
             Q_ASSERT(!saveLocation().isEmpty());
 
             QString newFilename = saveLocation() + fi.baseName() + resource->defaultFileExtension();
             QFileInfo fileInfo(newFilename);
 
             int i = 1;
             while (fileInfo.exists()) {
                 fileInfo.setFile(saveLocation() + fi.baseName() + QString("%1").arg(i) + resource->defaultFileExtension());
                 i++;
             }
             resource->setFilename(fileInfo.filePath());
         }
 
 
         if(!addResource(resource)) {
             Policy::deleteResource(resource);
         }
 
         return true;
     }
 
     /// Removes the resource file from the resource server
     virtual void removeResourceFile(const QString & filename)
     {
         QFileInfo fi(filename);
 
         PointerType resource = resourceByFilename(fi.fileName());
         if (!resource) {
             warnWidgets << "Resource file do not exist ";
             return;
         }
 
         if (!removeResourceFromServer(resource))
             return;
     }
 
 
     /**
      * Addes an observer to the server
      * @param observer the observer to be added
      * @param notifyLoadedResources determines if the observer should be notified about the already loaded resources
      */
     void addObserver(ObserverType* observer, bool notifyLoadedResources = true)
     {
         m_loadLock.lock();
         if(observer && !m_observers.contains(observer)) {
             m_observers.append(observer);
 
             if(notifyLoadedResources) {
                 Q_FOREACH (PointerType resource, m_resourcesByFilename) {
                     observer->resourceAdded(resource);
 
                 }
             }
         }
         m_loadLock.unlock();
     }
 
     /**
      * Removes an observer from the server
      * @param observer the observer to be removed
      */
     void removeObserver(ObserverType* observer)
     {
         int index = m_observers.indexOf( observer );
         if( index < 0 )
             return;
 
         m_observers.removeAt( index );
     }
 
     PointerType resourceByFilename(const QString& filename) const
     {
         if (m_resourcesByFilename.contains(filename)) {
             return m_resourcesByFilename[filename];
         }
         return 0;
     }
 
 
     PointerType resourceByName( const QString& name ) const
     {
         if (m_resourcesByName.contains(name)) {
             return m_resourcesByName[name];
         }
         return 0;
     }
 
     PointerType resourceByMD5(const QByteArray& md5) const
     {
         return m_resourcesByMd5.value(md5);
     }
 
     /**
      * Call after changing the content of a resource;
      * Notifies the connected views.
      */
     void updateResource( PointerType resource )
     {
         notifyResourceChanged(resource);
     }
 
     QStringList blackListedFiles() const override
     {
         return m_blackListFileNames;
     }
 
     void removeBlackListedFiles() {
         QStringList remainingFiles; // Files that can't be removed e.g. no rights will stay blacklisted
         Q_FOREACH (const QString &filename, m_blackListFileNames) {
             QFile file( filename );
             if( ! file.remove() ) {
                 remainingFiles.append(filename);
             }
         }
         m_blackListFileNames = remainingFiles;
         writeBlackListFile();
     }
 
     QStringList tagNamesList() const
     {
         return m_tagStore->tagNamesList();
     }
 
     // don't use these method directly since it doesn't update views!
     void addTag( KoResource* resource,const QString& tag)
     {
         m_tagStore->addTag(resource,tag);
     }
 
     // don't use these method directly since it doesn't update views!
     void delTag( KoResource* resource,const QString& tag)
     {
         m_tagStore->delTag(resource, tag);
     }
 
     QStringList searchTag(const QString& lineEditText)
     {
         return m_tagStore->searchTag(lineEditText);
     }
 
     void tagCategoryAdded(const QString& tag)
     {
         m_tagStore->serializeTags();
         Q_FOREACH (ObserverType* observer, m_observers) {
             observer->syncTagAddition(tag);
         }
     }
 
     void tagCategoryRemoved(const QString& tag)
     {
         m_tagStore->delTag(tag);
         m_tagStore->serializeTags();
         Q_FOREACH (ObserverType* observer, m_observers) {
             observer->syncTagRemoval(tag);
         }
     }
 
     void tagCategoryMembersChanged()
     {
         m_tagStore->serializeTags();
         Q_FOREACH (ObserverType* observer, m_observers) {
             observer->syncTaggedResourceView();
         }
     }
 
     QStringList queryResources(const QString &query) const override
     {
         return m_tagStore->searchTag(query);
     }
 
     QStringList assignedTagsList(KoResource* resource) const
     {
         return m_tagStore->assignedTagsList(resource);
     }
 
 
     /**
      * Create one or more resources from a single file. By default one resource is created.
      * Override to create more resources from the file.
      * @param filename the filename of the resource or resource collection
      */
     virtual QList<PointerType> createResources( const QString & filename )
     {
         QList<PointerType> createdResources;
         createdResources.append(createResource(filename));
         return createdResources;
     }
 
     virtual PointerType createResource( const QString & filename ) = 0;
 
     /// Return the currently stored resources in alphabetical order, overwrite for customized sorting
     virtual QList<PointerType> sortedResources()
     {
         QMap<QString, PointerType> sortedNames;
         Q_FOREACH (const QString &name, m_resourcesByName.keys()) {
             sortedNames.insert(name.toLower(), m_resourcesByName[name]);
         }
         return sortedNames.values();
     }
 
 protected:
 
     void notifyResourceAdded(PointerType resource)
     {
         Q_FOREACH (ObserverType* observer, m_observers) {
             observer->resourceAdded(resource);
         }
     }
 
     void notifyRemovingResource(PointerType resource)
     {
         Q_FOREACH (ObserverType* observer, m_observers) {
             observer->removingResource(resource);
         }
     }
 
     void notifyResourceChanged(PointerType resource)
     {
         Q_FOREACH (ObserverType* observer, m_observers) {
             observer->resourceChanged(resource);
         }
     }
 
     /// Reads the xml file and returns the filenames as a list
     QStringList readBlackListFile()
     {
         QStringList filenameList;
 
         QFile f(m_blackListFile);
         if (!f.open(QIODevice::ReadOnly)) {
             return filenameList;
         }
 
         QDomDocument doc;
         if (!doc.setContent(&f)) {
             warnWidgets << "The file could not be parsed.";
             return filenameList;
         }
 
         QDomElement root = doc.documentElement();
         if (root.tagName() != "resourceFilesList") {
             warnWidgets << "The file doesn't seem to be of interest.";
             return filenameList;
         }
 
         QDomElement file = root.firstChildElement("file");
 
         while (!file.isNull()) {
             QDomNode n = file.firstChild();
             QDomElement e = n.toElement();
             if (e.tagName() == "name") {
-                filenameList.append((e.text()).replace(QString("~"),QDir::homePath()));
+                // If the krita bundle has landed in the blacklist, skip it.
+                if (type() == "kis_resourcebundles") {
+                    if (e.text().endsWith("Krita_3_Default_Resources.bundle")) {
+                        file = file.nextSiblingElement("file");
+                    }
+                }
+                filenameList.append(e.text().replace(QString("~"), QDir::homePath()));
             }
             file = file.nextSiblingElement("file");
         }
 
-        if (type() == "kis_resourcebundles") {
-            KConfigGroup group = KSharedConfig::openConfig()->group("BundleHack");
-            if (group.readEntry("HideKrita3Bundle", true)) {
-                QFileInfo fi(KoResourcePaths::getApplicationRoot() + "/share/krita/bundles/Krita_3_Default_Resources.bundle");
-                filenameList << fi.absoluteFilePath();
-            }
-        }
-
         return filenameList;
     }
 
     /// write the blacklist file entries to an xml file
     void writeBlackListFile()
     {
         QFile f(m_blackListFile);
 
         if (!f.open(QIODevice::WriteOnly | QIODevice::Text)) {
             warnWidgets << "Cannot write meta information to '" << m_blackListFile << "'." << endl;
             return;
         }
 
         QDomDocument doc;
         QDomElement root;
 
         QDomDocument docTemp("m_blackListFile");
         doc = docTemp;
         doc.appendChild(doc.createProcessingInstruction("xml", "version=\"1.0\" encoding=\"UTF-8\""));
         root = doc.createElement("resourceFilesList");
         doc.appendChild(root);
 
         Q_FOREACH (QString filename, m_blackListFileNames) {
+
+            // Don't write the krita3 bundle to the blacklist, since its location will change
+            // when using the appimate.
+            if (type() == "kis_resourcebundles") {
+                if (filename.endsWith("Krita_3_Default_Resources.bundle")) continue;
+            }
             QDomElement fileEl = doc.createElement("file");
             QDomElement nameEl = doc.createElement("name");
-            QDomText nameText = doc.createTextNode(filename.replace(QDir::homePath(),QString("~")));
+            QDomText nameText = doc.createTextNode(filename.replace(QDir::homePath(), QString("~")));
             nameEl.appendChild(nameText);
             fileEl.appendChild(nameEl);
             root.appendChild(fileEl);
         }
 
         QTextStream metastream(&f);
         metastream << doc.toString();
         f.close();
     }
 
 protected:
 
     KoResource* byMd5(const QByteArray &md5) const override
     {
         return Policy::toResourcePointer(resourceByMD5(md5));
     }
 
     KoResource* byFileName(const QString &fileName) const override
     {
         return Policy::toResourcePointer(resourceByFilename(fileName));
     }
 
 private:
     void addResourceToMd5Registry(PointerType resource) {
         const QByteArray md5 = resource->md5();
         if (!md5.isEmpty()) {
             m_resourcesByMd5.insert(md5, resource);
         }
     }
 
     void removeResourceFromMd5Registry(PointerType resource) {
         const QByteArray md5 = resource->md5();
         if (!md5.isEmpty()) {
             m_resourcesByMd5.remove(md5);
         }
     }
 
 private:
 
     QHash<QString, PointerType> m_resourcesByName;
     QHash<QString, PointerType> m_resourcesByFilename;
     QHash<QByteArray, PointerType> m_resourcesByMd5;
 
     QList<PointerType> m_resourceBlackList;
     QList<PointerType> m_resources; ///< list of resources in order of addition
     QList<ObserverType*> m_observers;
     QString m_blackListFile;
-    QStringList m_blackListFileNames;
     KoResourceTagStore* m_tagStore;
 
 };
 
 template <class T, class Policy = PointerStoragePolicy<T> >
-    class KoResourceServerSimpleConstruction : public KoResourceServer<T, Policy>
+class KoResourceServerSimpleConstruction : public KoResourceServer<T, Policy>
 {
 public:
     KoResourceServerSimpleConstruction(const QString& type, const QString& extensions)
-: KoResourceServer<T, Policy>(type, extensions)
+        : KoResourceServer<T, Policy>(type, extensions)
     {
     }
 
-typename KoResourceServer<T, Policy>::PointerType createResource( const QString & filename ) override {
+    typename KoResourceServer<T, Policy>::PointerType createResource( const QString & filename ) override {
         return new T(filename);
     }
 };
 
 #endif // KORESOURCESERVER_H
diff --git a/libs/widgets/KoResourceServerProvider.cpp b/libs/widgets/KoResourceServerProvider.cpp
index dbcd91b8d9..3cc8c9fe09 100644
--- a/libs/widgets/KoResourceServerProvider.cpp
+++ b/libs/widgets/KoResourceServerProvider.cpp
@@ -1,262 +1,263 @@
 /*  This file is part of the KDE project
 
     Copyright (c) 1999 Matthias Elter <elter@kde.org>
     Copyright (c) 2003 Patrick Julien <freak@codepimps.org>
     Copyright (c) 2005 Sven Langkamp <sven.langkamp@gmail.com>
     Copyright (C) 2011 Srikanth Tiyyagura <srikanth.tulasiram@gmail.com>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Lesser General Public
     License as published by the Free Software Foundation; either
     version 2.1 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Lesser General Public License for more details.
 
     You should have received a copy of the GNU Lesser General Public
     License along with this library; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
 #include "KoResourceServerProvider.h"
 
 #include <QApplication>
 #include <QFileInfo>
 #include <QStringList>
 #include <QDir>
 #include <QStandardPaths>
 #include <QGlobalStatic>
 
 
 #include <resources/KoSegmentGradient.h>
 #include <resources/KoStopGradient.h>
 #include "KoColorSpaceRegistry.h"
 #include "KoResourcePaths.h"
 #include <iostream>
 using namespace std;
 
 class GradientResourceServer : public KoResourceServer<KoAbstractGradient> {
 
 public:
 
     GradientResourceServer(const QString& type, const QString& extensions) :
             KoResourceServer<KoAbstractGradient>(type, extensions) , m_foregroundToTransparent(0) , m_foregroundToBackground(0)
     {
         insertSpecialGradients();
     }
 
     void insertSpecialGradients()
     {
         const KoColorSpace* cs = KoColorSpaceRegistry::instance()->rgb8();
         QList<KoGradientStop> stops;
 
         KoStopGradient* gradient = new KoStopGradient();
         gradient->setType(QGradient::LinearGradient);
         gradient->setName("Foreground to Transparent");
         stops << KoGradientStop(0.0, KoColor(Qt::black, cs)) << KoGradientStop(1.0, KoColor(QColor(0, 0, 0, 0), cs));
 
         gradient->setStops(stops);
         gradient->setValid(true);
         gradient->setPermanent(true);
         addResource(gradient, false, true);
         m_foregroundToTransparent = gradient;
 
         gradient = new KoStopGradient();
         gradient->setType(QGradient::LinearGradient);
         gradient->setName("Foreground to Background");
 
         stops.clear();
         stops << KoGradientStop(0.0, KoColor(Qt::black, cs)) << KoGradientStop(1.0, KoColor(Qt::white, cs));
 
         gradient->setStops(stops);
         gradient->setValid(true);
         gradient->setPermanent(true);
         addResource(gradient, false, true);
         m_foregroundToBackground = gradient;
     }
 
 private:
 
     friend class KoResourceBundle;
 
     KoAbstractGradient* createResource( const QString & filename ) override {
 
         QString fileExtension;
         int index = filename.lastIndexOf('.');
 
         if (index != -1)
             fileExtension = filename.mid(index).toLower();
 
         KoAbstractGradient* grad = 0;
 
         if(fileExtension == ".svg" || fileExtension == ".kgr")
             grad = new KoStopGradient(filename);
         else if(fileExtension == ".ggr" )
             grad = new KoSegmentGradient(filename);
 
         return grad;
     }
 
     QList< KoAbstractGradient* > sortedResources() override {
         QList< KoAbstractGradient* > resources = KoResourceServer<KoAbstractGradient>::sortedResources();
         QList< KoAbstractGradient* > sorted;
         if (m_foregroundToTransparent && resources.contains(m_foregroundToTransparent)) {
             sorted.append(resources.takeAt(resources.indexOf(m_foregroundToTransparent)));
         }
         if (m_foregroundToBackground && resources.contains(m_foregroundToBackground)) {
             sorted.append(resources.takeAt(resources.indexOf(m_foregroundToBackground)));
         }
         return sorted + resources;
     }
 
     KoAbstractGradient* m_foregroundToTransparent;
     KoAbstractGradient* m_foregroundToBackground;
 };
 
 KoResourceLoaderThread::KoResourceLoaderThread(KoResourceServerBase *server)
     : QThread()
     , m_server(server)
 {
     m_fileNames = m_server->fileNames();
-    QStringList fileNames = m_server->blackListedFiles();
+    QStringList blacklistedFileNames = m_server->blackListedFiles();
 
-    if (!fileNames.isEmpty()) {
-        foreach (const QString &s, fileNames) {
+    if (!blacklistedFileNames.isEmpty()) {
+        foreach (const QString &s, blacklistedFileNames) {
             qDebug() << "blacklisting" << s << m_fileNames;
             if (m_fileNames.contains(s)) {
                m_fileNames.removeAll(s);
             }
         }
     }
+
     connect(qApp, SIGNAL(aboutToQuit()), SLOT(barrier()));
 }
 
 KoResourceLoaderThread::~KoResourceLoaderThread()
 {
 }
 
 void KoResourceLoaderThread::loadSynchronously()
 {
     m_server->loadResources(m_fileNames);
 }
 
 void KoResourceLoaderThread::run()
 {
     m_server->loadResources(m_fileNames);
 }
 
 void KoResourceLoaderThread::barrier()
 {
     if(isRunning()) {
         wait();
     }
 }
 
 
 struct Q_DECL_HIDDEN KoResourceServerProvider::Private
 {
 
     KoResourceServer<KoPattern>* patternServer;
     KoResourceServer<KoAbstractGradient>* gradientServer;
     KoResourceServer<KoColorSet>* paletteServer;
     KoResourceServer<KoSvgSymbolCollectionResource> *svgSymbolCollectionServer;
 
     KoResourceLoaderThread *paletteThread;
     KoResourceLoaderThread *gradientThread;
     KoResourceLoaderThread *patternThread;
     KoResourceLoaderThread *svgSymbolCollectionThread;
 };
 
 KoResourceServerProvider::KoResourceServerProvider() : d(new Private)
 {
 
     d->patternServer = new KoResourceServerSimpleConstruction<KoPattern>("ko_patterns", "*.pat:*.jpg:*.gif:*.png:*.tif:*.xpm:*.bmp" );
     if (!QFileInfo(d->patternServer->saveLocation()).exists()) {
         QDir().mkpath(d->patternServer->saveLocation());
     }
 
     d->patternThread = new KoResourceLoaderThread(d->patternServer);
     d->patternThread->loadSynchronously();
 //    if (qApp->applicationName().contains(QLatin1String("test"), Qt::CaseInsensitive)) {
 //        d->patternThread->barrier();
 //    }
 
     d->gradientServer = new GradientResourceServer("ko_gradients", "*.kgr:*.svg:*.ggr");
     if (!QFileInfo(d->gradientServer->saveLocation()).exists()) {
         QDir().mkpath(d->gradientServer->saveLocation());
     }
 
     d->gradientThread = new KoResourceLoaderThread(d->gradientServer);
     d->gradientThread->loadSynchronously();
 //    if (qApp->applicationName().contains(QLatin1String("test"), Qt::CaseInsensitive)) {
 //        d->gradientThread->barrier();
 //    }
 
     d->paletteServer = new KoResourceServerSimpleConstruction<KoColorSet>("ko_palettes", "*.kpl:*.gpl:*.pal:*.act:*.aco:*.css:*.colors:*.xml:*.sbz");
     if (!QFileInfo(d->paletteServer->saveLocation()).exists()) {
         QDir().mkpath(d->paletteServer->saveLocation());
     }
 
     d->paletteThread = new KoResourceLoaderThread(d->paletteServer);
     d->paletteThread->loadSynchronously();
 //    if (qApp->applicationName().contains(QLatin1String("test"), Qt::CaseInsensitive)) {
 //        d->paletteThread->barrier();
 //    }
 
 
     d->svgSymbolCollectionServer = new KoResourceServerSimpleConstruction<KoSvgSymbolCollectionResource>("symbols", "*.svg");
     if (!QFileInfo(d->svgSymbolCollectionServer->saveLocation()).exists()) {
         QDir().mkpath(d->svgSymbolCollectionServer->saveLocation());
     }
     d->svgSymbolCollectionThread = new KoResourceLoaderThread(d->svgSymbolCollectionServer);
     d->svgSymbolCollectionThread ->loadSynchronously();
 }
 
 KoResourceServerProvider::~KoResourceServerProvider()
 {
     delete d->patternThread;
     delete d->gradientThread;
     delete d->paletteThread;
     delete d->svgSymbolCollectionThread;
 
     delete d->patternServer;
     delete d->gradientServer;
     delete d->paletteServer;
     delete d->svgSymbolCollectionServer;
 
     delete d;
 }
 
 Q_GLOBAL_STATIC(KoResourceServerProvider, s_instance);
 
 KoResourceServerProvider* KoResourceServerProvider::instance()
 {
     return s_instance;
 }
 
 KoResourceServer<KoPattern>* KoResourceServerProvider::patternServer(bool block)
 {
     if (block) d->patternThread->barrier();
     return d->patternServer;
 }
 
 KoResourceServer<KoAbstractGradient>* KoResourceServerProvider::gradientServer(bool block)
 {
     if (block) d->gradientThread->barrier();
     return d->gradientServer;
 }
 
 KoResourceServer<KoColorSet>* KoResourceServerProvider::paletteServer(bool block)
 {
     if (block) d->paletteThread->barrier();
     return d->paletteServer;
 }
 
 KoResourceServer<KoSvgSymbolCollectionResource> *KoResourceServerProvider::svgSymbolCollectionServer(bool block)
 {
     if (block) d->svgSymbolCollectionThread->barrier();
     return d->svgSymbolCollectionServer;
 }
 
diff --git a/plugins/dockers/throttle/ThrottlePlugin.h b/plugins/dockers/throttle/ThrottlePlugin.h
index 58f7ac2f27..3fb02c1868 100644
--- a/plugins/dockers/throttle/ThrottlePlugin.h
+++ b/plugins/dockers/throttle/ThrottlePlugin.h
@@ -1,49 +1,49 @@
 /*
  *  Copyright (c) 2017 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2.1 of the License.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef THROTTLEPLUGIN_H
 #define THROTTLEPLUGIN_H
 
-#include <kis_view_plugin.h>
+#include <KisActionPlugin.h>
 
 #include <QVariant>
 #include <QDockWidget>
 #include <klocalizedstring.h>
 #include <KoCanvasObserverBase.h>
 
 class Throttle;
 
 class BasicDocker : public QDockWidget, public KoCanvasObserverBase
 {
     Q_OBJECT
 public:
     BasicDocker() : QDockWidget(i18n("CPU Throttle")) {}
     ~BasicDocker() override {}
     QString observerName() override { return "ThrottleDocker"; }
     void setCanvas(KoCanvasBase *) override {}
     void unsetCanvas() override {}
 };
 
 class ThrottlePlugin : public QObject
 {
     Q_OBJECT
 public:
     ThrottlePlugin(QObject *parent, const QVariantList &);
     ~ThrottlePlugin() override;
 };
 
 #endif
diff --git a/plugins/extensions/animationrenderer/AnimationRenderer.cpp b/plugins/extensions/animationrenderer/AnimationRenderer.cpp
index bb56d326ec..836c2cb3f2 100644
--- a/plugins/extensions/animationrenderer/AnimationRenderer.cpp
+++ b/plugins/extensions/animationrenderer/AnimationRenderer.cpp
@@ -1,204 +1,204 @@
 /*
  * Copyright (c) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "AnimationRenderer.h"
 
 #include <QMessageBox>
 
 #include <klocalizedstring.h>
 #include <kpluginfactory.h>
 
 #include <kis_image.h>
 #include <KisViewManager.h>
 #include <KoUpdater.h>
 #include <kis_node_manager.h>
 #include <kis_image_manager.h>
 #include <kis_action.h>
 #include <kis_image_animation_interface.h>
 #include <kis_properties_configuration.h>
 #include <kis_config.h>
 #include <KisDocument.h>
 #include <KisMimeDatabase.h>
 #include <kis_time_range.h>
 #include <KisImportExportManager.h>
 
 #include "DlgAnimationRenderer.h"
 #include <dialogs/KisAsyncAnimationFramesSaveDialog.h>
 
 
 K_PLUGIN_FACTORY_WITH_JSON(AnimaterionRendererFactory, "kritaanimationrenderer.json", registerPlugin<AnimaterionRenderer>();)
 
 AnimaterionRenderer::AnimaterionRenderer(QObject *parent, const QVariantList &)
-    : KisViewPlugin(parent)
+    : KisActionPlugin(parent)
 {
     // Shows the big dialog
     KisAction *action = createAction("render_animation");
     action->setActivationFlags(KisAction::IMAGE_HAS_ANIMATION);
     connect(action,  SIGNAL(triggered()), this, SLOT(slotRenderAnimation()));
 
     // Re-renders the image sequence as defined in the last render
     action = createAction("render_image_sequence_again");
     action->setActivationFlags(KisAction::IMAGE_HAS_ANIMATION);
     connect(action,  SIGNAL(triggered()), this, SLOT(slotRenderSequenceAgain()));
 }
 
 AnimaterionRenderer::~AnimaterionRenderer()
 {
 }
 
 void AnimaterionRenderer::slotRenderAnimation()
 {
-    KisImageWSP image = m_view->image();
+    KisImageWSP image = viewManager()->image();
 
     if (!image) return;
     if (!image->animationInterface()->hasAnimation()) return;
 
-    KisDocument *doc = m_view->document();
+    KisDocument *doc = viewManager()->document();
 
-    DlgAnimationRenderer dlgAnimationRenderer(doc, m_view->mainWindow());
+    DlgAnimationRenderer dlgAnimationRenderer(doc, viewManager()->mainWindow());
 
     dlgAnimationRenderer.setCaption(i18n("Render Animation"));
 
     KisConfig kisConfig;
     KisPropertiesConfigurationSP cfg = new KisPropertiesConfiguration();
     cfg->fromXML(kisConfig.exportConfiguration("IMAGESEQUENCE"));
     dlgAnimationRenderer.setSequenceConfiguration(cfg);
 
     cfg->clearProperties();
     cfg->fromXML(kisConfig.exportConfiguration("ANIMATION_RENDERER"));
     dlgAnimationRenderer.setVideoConfiguration(cfg);
 
     cfg->clearProperties();
     cfg->fromXML(kisConfig.exportConfiguration("FFMPEG_CONFIG"));
     dlgAnimationRenderer.setEncoderConfiguration(cfg);
 
     // update the UI to show the selected export options
     dlgAnimationRenderer.updateExportUIOptions();
 
 
     if (dlgAnimationRenderer.exec() == QDialog::Accepted) {
         KisPropertiesConfigurationSP sequenceConfig = dlgAnimationRenderer.getSequenceConfiguration();
         kisConfig.setExportConfiguration("IMAGESEQUENCE", sequenceConfig);
         QString mimetype = sequenceConfig->getString("mimetype");
         QString extension = KisMimeDatabase::suffixesForMimeType(mimetype).first();
         QString baseFileName = QString("%1/%2.%3").arg(sequenceConfig->getString("directory"))
                 .arg(sequenceConfig->getString("basename"))
                 .arg(extension);
 
 
         const bool batchMode = false; // TODO: fetch correctly!
         KisAsyncAnimationFramesSaveDialog exporter(doc->image(),
                                                    KisTimeRange::fromTime(sequenceConfig->getInt("first_frame"), sequenceConfig->getInt("last_frame")),
                                                    baseFileName,
                                                    sequenceConfig->getInt("sequence_start"),
                                                    dlgAnimationRenderer.getFrameExportConfiguration());
         exporter.setBatchMode(batchMode);
 
 
         KisAsyncAnimationFramesSaveDialog::Result result =
-            exporter.regenerateRange(m_view->mainWindow()->viewManager());
+            exporter.regenerateRange(viewManager()->mainWindow()->viewManager());
 
         // the folder could have been read-only or something else could happen
         if (result == KisAsyncAnimationFramesSaveDialog::RenderComplete) {
             QString savedFilesMask = exporter.savedFilesMask();
 
             KisPropertiesConfigurationSP videoConfig = dlgAnimationRenderer.getVideoConfiguration();
             if (videoConfig) {
                 kisConfig.setExportConfiguration("ANIMATION_RENDERER", videoConfig);
 
                 KisPropertiesConfigurationSP encoderConfig = dlgAnimationRenderer.getEncoderConfiguration();
                 if (encoderConfig) {
                     kisConfig.setExportConfiguration("FFMPEG_CONFIG", encoderConfig);
                     encoderConfig->setProperty("savedFilesMask", savedFilesMask);
                 }
 
                 const QString fileName = videoConfig->getString("filename");
                 QString resultFile = fileName;
                 KIS_SAFE_ASSERT_RECOVER_NOOP(QFileInfo(resultFile).isAbsolute())
 
                 {
                     const QFileInfo info(resultFile);
                     QDir dir(info.absolutePath());
 
                     if (!dir.exists()) {
                         dir.mkpath(info.absolutePath());
                     }
                     KIS_SAFE_ASSERT_RECOVER_NOOP(dir.exists());
                 }
 
                 QSharedPointer<KisImportExportFilter> encoder = dlgAnimationRenderer.encoderFilter();
                 encoder->setMimeType(mimetype.toLatin1());
                 QFile fi(resultFile);
 
                 KisImportExportFilter::ConversionStatus res;
                 if (!fi.open(QIODevice::WriteOnly)) {
                     qWarning() << "Could not open" << fi.fileName() << "for writing!";
                     res = KisImportExportFilter::CreationError;
                 }
                 else {
                     encoder->setFilename(fi.fileName());
                     res = encoder->convert(doc, &fi, encoderConfig);
                     fi.close();
                 }
                 if (res != KisImportExportFilter::OK) {
                     QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not render animation:\n%1", doc->errorMessage()));
                 }
                 if (videoConfig->getBool("delete_sequence", false)) {
                     QDir d(sequenceConfig->getString("directory"));
                     QStringList sequenceFiles = d.entryList(QStringList() << sequenceConfig->getString("basename") + "*." + extension, QDir::Files);
                     Q_FOREACH(const QString &f, sequenceFiles) {
                         d.remove(f);
                     }
                 }
             }
         } else if (result == KisAsyncAnimationFramesSaveDialog::RenderFailed) {
-            m_view->mainWindow()->viewManager()->showFloatingMessage(i18n("Failed to render animation frames!"), QIcon());
+            viewManager()->mainWindow()->viewManager()->showFloatingMessage(i18n("Failed to render animation frames!"), QIcon());
         }
     }
 }
 
 void AnimaterionRenderer::slotRenderSequenceAgain()
 {
-    KisImageWSP image = m_view->image();
+    KisImageWSP image = viewManager()->image();
 
     if (!image) return;
     if (!image->animationInterface()->hasAnimation()) return;
 
-    KisDocument *doc = m_view->document();
+    KisDocument *doc = viewManager()->document();
 
     KisConfig kisConfig;
     KisPropertiesConfigurationSP sequenceConfig = new KisPropertiesConfiguration();
     sequenceConfig->fromXML(kisConfig.exportConfiguration("IMAGESEQUENCE"));
     QString mimetype = sequenceConfig->getString("mimetype");
     QString extension = KisMimeDatabase::suffixesForMimeType(mimetype).first();
     QString baseFileName = QString("%1/%2.%3").arg(sequenceConfig->getString("directory"))
             .arg(sequenceConfig->getString("basename"))
             .arg(extension);
 
     const bool batchMode = false; // TODO: fetch correctly!
     KisAsyncAnimationFramesSaveDialog exporter(doc->image(),
                                                KisTimeRange::fromTime(sequenceConfig->getInt("first_frame"), sequenceConfig->getInt("last_frame")),
                                                baseFileName,
                                                sequenceConfig->getInt("sequence_start"),
                                                0);
     exporter.setBatchMode(batchMode);
     bool success = exporter.regenerateRange(0) == KisAsyncAnimationFramesSaveDialog::RenderComplete;
     KIS_SAFE_ASSERT_RECOVER_NOOP(success);
 }
 
 #include "AnimationRenderer.moc"
diff --git a/plugins/extensions/animationrenderer/AnimationRenderer.h b/plugins/extensions/animationrenderer/AnimationRenderer.h
index 351b2cf6f6..786ad2d74c 100644
--- a/plugins/extensions/animationrenderer/AnimationRenderer.h
+++ b/plugins/extensions/animationrenderer/AnimationRenderer.h
@@ -1,39 +1,39 @@
 /*
  * Copyright (c) 2016 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
 
 #ifndef ANIMATIONRENDERERIMAGE_H
 #define ANIMATIONRENDERERIMAGE_H
 
 #include <QVariant>
 
-#include <kis_view_plugin.h>
+#include <KisActionPlugin.h>
 
-class AnimaterionRenderer : public KisViewPlugin
+class AnimaterionRenderer : public KisActionPlugin
 {
     Q_OBJECT
 public:
     AnimaterionRenderer(QObject *parent, const QVariantList &);
     ~AnimaterionRenderer() override;
 
 private Q_SLOTS:
 
     void slotRenderAnimation();
     void slotRenderSequenceAgain();
 
 };
 
 #endif // ANIMATIONRENDERERIMAGE_H
diff --git a/plugins/extensions/animationrenderer/wdg_animationrenderer.ui b/plugins/extensions/animationrenderer/wdg_animationrenderer.ui
index a6a635be35..42c796c01e 100644
--- a/plugins/extensions/animationrenderer/wdg_animationrenderer.ui
+++ b/plugins/extensions/animationrenderer/wdg_animationrenderer.ui
@@ -1,466 +1,469 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgAnimaterionRenderer</class>
  <widget class="QWidget" name="WdgAnimaterionRenderer">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>621</width>
     <height>381</height>
    </rect>
   </property>
   <property name="sizePolicy">
    <sizepolicy hsizetype="MinimumExpanding" vsizetype="Minimum">
     <horstretch>0</horstretch>
     <verstretch>0</verstretch>
    </sizepolicy>
   </property>
   <property name="windowTitle">
    <string>AnimationRenderer Image</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout_3">
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout_4">
      <property name="spacing">
       <number>20</number>
      </property>
      <property name="rightMargin">
       <number>0</number>
      </property>
      <item>
       <widget class="QLabel" name="label_10">
        <property name="text">
         <string>Export:</string>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QRadioButton" name="shouldExportOnlyImageSequence">
        <property name="text">
         <string>Image Se&amp;quence</string>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QRadioButton" name="shouldExportOnlyVideo">
        <property name="text">
         <string>&amp;Video</string>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QRadioButton" name="shouldExportAll">
        <property name="text">
         <string>Both</string>
        </property>
       </widget>
      </item>
      <item>
       <spacer name="horizontalSpacer">
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>40</width>
          <height>20</height>
         </size>
        </property>
       </spacer>
      </item>
     </layout>
    </item>
    <item>
     <layout class="QGridLayout" name="gridLayout_3">
      <item row="0" column="1">
       <widget class="QSpinBox" name="intStart">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
       </widget>
      </item>
      <item row="0" column="0">
       <widget class="QLabel" name="label_3">
        <property name="text">
         <string>First frame:</string>
        </property>
        <property name="alignment">
         <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
        </property>
       </widget>
      </item>
      <item row="0" column="4">
       <widget class="QLabel" name="fpsLabel">
        <property name="layoutDirection">
         <enum>Qt::LeftToRight</enum>
        </property>
        <property name="text">
         <string>FPS:</string>
        </property>
        <property name="alignment">
         <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
        </property>
       </widget>
      </item>
      <item row="0" column="5">
       <widget class="QSpinBox" name="intFramesPerSecond">
        <property name="minimum">
         <number>1</number>
        </property>
        <property name="singleStep">
         <number>1</number>
        </property>
       </widget>
      </item>
      <item row="1" column="1">
       <widget class="QSpinBox" name="intEnd">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
+       <property name="maximum">
+        <number>10000</number>
+       </property>
       </widget>
      </item>
      <item row="1" column="0">
       <widget class="QLabel" name="label_4">
        <property name="text">
         <string>Last frame:</string>
        </property>
        <property name="alignment">
         <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
        </property>
       </widget>
      </item>
      <item row="0" column="3">
       <widget class="QSpinBox" name="intWidth">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="suffix">
         <string> px</string>
        </property>
       </widget>
      </item>
      <item row="0" column="2">
       <widget class="QLabel" name="lblWidth">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="text">
         <string>Width:</string>
        </property>
        <property name="alignment">
         <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
        </property>
       </widget>
      </item>
      <item row="1" column="2">
       <widget class="QLabel" name="lblHeight">
        <property name="text">
         <string>Height:</string>
        </property>
        <property name="alignment">
         <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
        </property>
       </widget>
      </item>
      <item row="1" column="3">
       <widget class="QSpinBox" name="intHeight">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="suffix">
         <string> px</string>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout_5">
      <property name="spacing">
       <number>25</number>
      </property>
      <item>
       <widget class="QGroupBox" name="videoOptionsGroup">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="title">
         <string>Video Options</string>
        </property>
        <layout class="QVBoxLayout" name="verticalLayout">
         <item>
          <layout class="QGridLayout" name="gridLayout">
           <item row="1" column="0">
            <widget class="QLabel" name="label_6">
             <property name="text">
              <string>Render as:</string>
             </property>
             <property name="alignment">
              <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
             </property>
            </widget>
           </item>
           <item row="0" column="1">
            <widget class="KisFileNameRequester" name="ffmpegLocation" native="true"/>
           </item>
           <item row="1" column="1">
            <layout class="QHBoxLayout" name="horizontalLayout_3">
             <item>
              <widget class="QComboBox" name="cmbRenderType"/>
             </item>
             <item>
              <widget class="QToolButton" name="bnRenderOptions">
               <property name="toolTip">
                <string>Select the ffmpeg render options.</string>
               </property>
               <property name="text">
                <string>...</string>
               </property>
              </widget>
             </item>
            </layout>
           </item>
           <item row="2" column="0">
            <widget class="QLabel" name="label_7">
             <property name="text">
              <string>Video Location:</string>
             </property>
             <property name="alignment">
              <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
             </property>
            </widget>
           </item>
           <item row="2" column="1">
            <widget class="KisFileNameRequester" name="videoFilename" native="true">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
               <horstretch>1</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
            </widget>
           </item>
           <item row="0" column="0">
            <widget class="QLabel" name="label_9">
             <property name="text">
              <string>FF&amp;Mpeg: </string>
             </property>
             <property name="alignment">
              <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
             </property>
             <property name="buddy">
              <cstring>ffmpegLocation</cstring>
             </property>
            </widget>
           </item>
           <item row="3" column="1">
            <widget class="QCheckBox" name="chkIncludeAudio">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="text">
              <string>Include Audio</string>
             </property>
            </widget>
           </item>
          </layout>
         </item>
         <item>
          <spacer name="verticalSpacer_2">
           <property name="orientation">
            <enum>Qt::Vertical</enum>
           </property>
           <property name="sizeHint" stdset="0">
            <size>
             <width>20</width>
             <height>10</height>
            </size>
           </property>
          </spacer>
         </item>
        </layout>
       </widget>
      </item>
      <item>
       <widget class="QGroupBox" name="imageSequenceOptionsGroup">
        <property name="title">
         <string>Image Sequence Options</string>
        </property>
        <layout class="QVBoxLayout" name="verticalLayout_2">
         <item>
          <layout class="QGridLayout" name="gridLayout_2">
           <item row="2" column="0">
            <widget class="QLabel" name="label">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="text">
              <string>Base name:</string>
             </property>
             <property name="alignment">
              <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
             </property>
            </widget>
           </item>
           <item row="0" column="1">
            <layout class="QHBoxLayout" name="horizontalLayout_2">
             <item>
              <widget class="QComboBox" name="cmbMimetype">
               <property name="sizePolicy">
                <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
                 <horstretch>2</horstretch>
                 <verstretch>0</verstretch>
                </sizepolicy>
               </property>
               <property name="toolTip">
                <string>Select the file format for the image sequence. If you want to render to video or animated gif, you can only select PNG</string>
               </property>
              </widget>
             </item>
             <item>
              <widget class="QToolButton" name="bnExportOptions">
               <property name="toolTip">
                <string>Select the frame export options</string>
               </property>
               <property name="text">
                <string>...</string>
               </property>
              </widget>
             </item>
            </layout>
           </item>
           <item row="1" column="1">
            <widget class="KisFileNameRequester" name="dirRequester" native="true">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
               <horstretch>1</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
            </widget>
           </item>
           <item row="0" column="0">
            <widget class="QLabel" name="label_8">
             <property name="text">
              <string>Fi&amp;le format:</string>
             </property>
             <property name="alignment">
              <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
             </property>
             <property name="buddy">
              <cstring>label_8</cstring>
             </property>
            </widget>
           </item>
           <item row="3" column="1">
            <widget class="QSpinBox" name="sequenceStart">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
               <horstretch>1</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="maximum">
              <number>999</number>
             </property>
            </widget>
           </item>
           <item row="1" column="0">
            <widget class="QLabel" name="label_2">
             <property name="text">
              <string>Image location:</string>
             </property>
             <property name="alignment">
              <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
             </property>
            </widget>
           </item>
           <item row="2" column="1">
            <widget class="QLineEdit" name="txtBasename">
             <property name="text">
              <string>frame</string>
             </property>
            </widget>
           </item>
           <item row="3" column="0">
            <widget class="QLabel" name="label_5">
             <property name="text">
              <string>Start numbering at:</string>
             </property>
            </widget>
           </item>
          </layout>
         </item>
         <item>
          <spacer name="verticalSpacer_3">
           <property name="orientation">
            <enum>Qt::Vertical</enum>
           </property>
           <property name="sizeHint" stdset="0">
            <size>
             <width>20</width>
             <height>10</height>
            </size>
           </property>
          </spacer>
         </item>
        </layout>
       </widget>
      </item>
     </layout>
    </item>
    <item>
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>10</height>
       </size>
      </property>
     </spacer>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KisFileNameRequester</class>
    <extends>QWidget</extends>
    <header>kis_file_name_requester.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <tabstops>
   <tabstop>cmbMimetype</tabstop>
   <tabstop>cmbRenderType</tabstop>
  </tabstops>
  <resources/>
  <connections/>
 </ui>
diff --git a/plugins/extensions/bigbrother/bigbrother.cc b/plugins/extensions/bigbrother/bigbrother.cc
index 4b5c37b393..5cc600b8e9 100644
--- a/plugins/extensions/bigbrother/bigbrother.cc
+++ b/plugins/extensions/bigbrother/bigbrother.cc
@@ -1,238 +1,235 @@
 /*
  *  Copyright (c) 2007 Cyrille Berger (cberger@cberger.net)
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2.1 of the License.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "bigbrother.h"
 #include <cstdlib>
 #include <unistd.h>
 
 #include <kis_action.h>
 
 #include <kpluginfactory.h>
 #include <klocalizedstring.h>
 
 #include <KoIcon.h>
 #include <kis_icon.h>
 #include <KoUpdater.h>
 #include <KoResourceServerProvider.h>
 #include <KoFileDialog.h>
 #include <KoProgressUpdater.h>
 
 #include <kis_config.h>
 #include <kis_cursor.h>
 #include <kis_debug.h>
 #include <kis_global.h>
 #include <kis_image.h>
 #include <kis_resource_server_provider.h>
 #include <kis_types.h>
 #include <KisViewManager.h>
 #include <resources/KoPattern.h>
 #include <recorder/kis_action_recorder.h>
 #include <recorder/kis_macro.h>
 #include <recorder/kis_macro_player.h>
 #include <recorder/kis_play_info.h>
 #include <recorder/kis_recorded_action_factory_registry.h>
 #include <recorder/kis_recorded_action.h>
 #include <recorder/kis_recorded_action_load_context.h>
 #include <recorder/kis_recorded_action_save_context.h>
 
 #include "actionseditor/kis_actions_editor.h"
 #include "actionseditor/kis_actions_editor_dialog.h"
 
 #include <QStandardPaths>
 #include <QApplication>
 
 
 K_PLUGIN_FACTORY_WITH_JSON(BigBrotherPluginFactory, "kritabigbrother.json", registerPlugin<BigBrotherPlugin>();)
 
 class RecordedActionSaveContext : public KisRecordedActionSaveContext {
     public:
         void saveGradient(const KoAbstractGradient* ) override {}
         void savePattern(const KoPattern* ) override {}
 };
 
 class RecordedActionLoadContext : public KisRecordedActionLoadContext {
     public:
         KoAbstractGradient* gradient(const QString& name) const override
         {
             return KoResourceServerProvider::instance()->gradientServer()->resourceByName(name);
         }
         KoPattern* pattern(const QString& name) const override
         {
             return KoResourceServerProvider::instance()->patternServer()->resourceByName(name);
         }
 };
 
 BigBrotherPlugin::BigBrotherPlugin(QObject *parent, const QVariantList &)
-        : KisViewPlugin(parent)
+        : KisActionPlugin(parent)
         , m_recorder(0)
 {
     if (parent->inherits("KisViewManager")) {
-        m_view = (KisViewManager*) parent;
-
         // Open and play action
         KisAction* action  = createAction("Macro_Open_Play");
         connect(action, SIGNAL(triggered()), this, SLOT(slotOpenPlay()));
 
         // Open and edit action
         action = createAction("Macro_Open_Edit");
         connect(action, SIGNAL(triggered()), this, SLOT(slotOpenEdit()));
 
         // Start recording action
         m_startRecordingMacroAction = createAction("Recording_Start_Recording_Macro");
         connect(m_startRecordingMacroAction, SIGNAL(triggered()), this, SLOT(slotStartRecordingMacro()));
 
         // Save recorded action
         m_stopRecordingMacroAction = createAction("Recording_Stop_Recording_Macro");
         connect(m_stopRecordingMacroAction, SIGNAL(triggered()), this, SLOT(slotStopRecordingMacro()));
         m_stopRecordingMacroAction->setEnabled(false);
     }
 }
 
 BigBrotherPlugin::~BigBrotherPlugin()
 {
-    m_view = 0;
     delete m_recorder;
 }
 
 void BigBrotherPlugin::slotOpenPlay()
 {
     KisMacro* m = openMacro();
     dbgKrita << m;
     if (!m) return;
     dbgPlugins << "Play the macro";
-    KoUpdaterPtr updater = m_view->createUnthreadedUpdater(i18n("Playing back macro"));
-    KisMacroPlayer player(m, KisPlayInfo(m_view->image(), m_view->activeNode()), updater);
+    KoUpdaterPtr updater = viewManager()->createUnthreadedUpdater(i18n("Playing back macro"));
+    KisMacroPlayer player(m, KisPlayInfo(viewManager()->image(), viewManager()->activeNode()), updater);
     player.start();
     while(player.isRunning())
     {
         QApplication::processEvents();
     }
     dbgPlugins << "Finished";
     delete m;
 }
 
 
 void BigBrotherPlugin::slotOpenEdit()
 {
     KisMacro *macro = openMacro();
     if (!macro) return;
-    KisActionsEditorDialog aed(m_view->mainWindow());
+    KisActionsEditorDialog aed(viewManager()->mainWindow());
 
     aed.actionsEditor()->setMacro(macro);
 
     if (aed.exec() == QDialog::Accepted) {
         saveMacro(macro);
     }
 
     delete macro;
 }
 
 void BigBrotherPlugin::slotStartRecordingMacro()
 {
     dbgPlugins << "Start recording macro";
     if (m_recorder) return;
     // Alternate actions
     m_startRecordingMacroAction->setEnabled(false);
     m_stopRecordingMacroAction->setEnabled(true);
 
     // Create recorder
     m_recorder = new KisMacro();
-    connect(m_view->image()->actionRecorder(), SIGNAL(addedAction(const KisRecordedAction&)),
+    connect(viewManager()->image()->actionRecorder(), SIGNAL(addedAction(const KisRecordedAction&)),
             m_recorder, SLOT(addAction(const KisRecordedAction&)));
 }
 
 void BigBrotherPlugin::slotStopRecordingMacro()
 {
     dbgPlugins << "Stop recording macro";
     if (!m_recorder) return;
     // Alternate actions
     m_startRecordingMacroAction->setEnabled(true);
     m_stopRecordingMacroAction->setEnabled(false);
     // Save the macro
     saveMacro(m_recorder);
     // Delete recorder
     delete m_recorder;
     m_recorder = 0;
 }
 
 KisMacro* BigBrotherPlugin::openMacro()
 {
     QStringList mimeFilter;
     mimeFilter << "*.krarec|Recorded actions (*.krarec)";
 
-    KoFileDialog dialog(m_view->mainWindow(), KoFileDialog::OpenFile, "OpenDocument");
+    KoFileDialog dialog(viewManager()->mainWindow(), KoFileDialog::OpenFile, "OpenDocument");
     dialog.setCaption(i18n("Open Macro"));
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
     dialog.setMimeTypeFilters(QStringList() << "application/x-krita-recorded-macro");
     QString filename = dialog.filename();
     RecordedActionLoadContext loadContext;
 
     if (!filename.isNull()) {
         QDomDocument doc;
         QFile f(filename);
         if (f.exists()) {
             dbgPlugins << f.open(QIODevice::ReadOnly);
             QString err;
             int line, col;
             if (!doc.setContent(&f, &err, &line, &col)) {
                 // TODO error message
                 dbgPlugins << err << " line = " << line << " col = " << col;
                 f.close();
                 return 0;
             }
             f.close();
             QDomElement docElem = doc.documentElement();
             if (!docElem.isNull() && docElem.tagName() == "RecordedActions") {
                 dbgPlugins << "Load the macro";
                 KisMacro* m = new KisMacro();
                 m->fromXML(docElem, &loadContext);
                 return m;
             } else {
                 // TODO error message
             }
         } else {
             dbgPlugins << "Unexistant file : " << filename;
         }
     }
     return 0;
 }
 
 void BigBrotherPlugin::saveMacro(const KisMacro* macro)
 {
-    KoFileDialog dialog(m_view->mainWindow(), KoFileDialog::SaveFile, "bigbrother");
+    KoFileDialog dialog(viewManager()->mainWindow(), KoFileDialog::SaveFile, "bigbrother");
     dialog.setCaption(i18n("Save Macro"));
     dialog.setMimeTypeFilters(QStringList() << "application/x-krita-recorded-macro");
 
     QString filename = dialog.filename();
 
     if (!filename.isNull()) {
         QDomDocument doc;
         QDomElement e = doc.createElement("RecordedActions");
         RecordedActionSaveContext context;
         macro->toXML(doc, e, &context);
 
         doc.appendChild(e);
         QFile f(filename);
         f.open(QIODevice::WriteOnly);
         QTextStream stream(&f);
         stream.setCodec("UTF-8");
         doc.save(stream, 2);
         f.close();
     }
 }
 
 #include "bigbrother.moc"
diff --git a/plugins/extensions/bigbrother/bigbrother.h b/plugins/extensions/bigbrother/bigbrother.h
index 9459248136..c53b4c2fb4 100644
--- a/plugins/extensions/bigbrother/bigbrother.h
+++ b/plugins/extensions/bigbrother/bigbrother.h
@@ -1,54 +1,52 @@
 /*
  *  Copyright (c) 2007 Cyrille Berger (cberger@cberger.net)
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2.1 of the License.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef _BIGBROTHER_H_
 #define _BIGBROTHER_H_
 
 #include <QVariant>
-#include <kis_view_plugin.h>
+#include <KisActionPlugin.h>
 
 class KisAction;
 class KisMacro;
 class KisViewManager;
 
-class BigBrotherPlugin : public KisViewPlugin
+class BigBrotherPlugin : public KisActionPlugin
 {
     Q_OBJECT
 public:
     BigBrotherPlugin(QObject *parent, const QVariantList &);
     ~BigBrotherPlugin() override;
 
 private Q_SLOTS:
 
     void slotOpenPlay();
     void slotOpenEdit();
     void slotStartRecordingMacro();
     void slotStopRecordingMacro();
 
 private:
     void saveMacro(const KisMacro* macro);
     KisMacro *openMacro();
 private:
-
-    KisViewManager *m_view;
     KisMacro *m_recorder;
     KisAction *m_startRecordingMacroAction;
     KisAction *m_stopRecordingMacroAction;
 
 };
 
 #endif // bigbrotherPlugin_H
diff --git a/plugins/extensions/buginfo/buginfo.cpp b/plugins/extensions/buginfo/buginfo.cpp
index 3d6cd71384..c7ec1c84a7 100644
--- a/plugins/extensions/buginfo/buginfo.cpp
+++ b/plugins/extensions/buginfo/buginfo.cpp
@@ -1,51 +1,51 @@
 /*
  *  Copyright (c) 2017 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 "buginfo.h"
 
 #include <cmath>
 
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 #include <kpluginfactory.h>
 #include <kis_icon.h>
 #include <KisViewManager.h>
 #include <kis_action.h>
 #include "dlg_buginfo.h"
 
 K_PLUGIN_FACTORY_WITH_JSON(BugInfoFactory, "kritabuginfo.json", registerPlugin<BugInfo>();)
 
 BugInfo::BugInfo(QObject *parent, const QVariantList &)
-        : KisViewPlugin(parent)
+        : KisActionPlugin(parent)
 {
     KisAction *action  = createAction("buginfo");
     connect(action, SIGNAL(triggered()), this, SLOT(slotBugInfo()));
 }
 
 
 BugInfo::~BugInfo()
 {
 }
 
 void BugInfo::slotBugInfo()
 {
-    DlgBugInfo dlgBugInfo(m_view->mainWindow());
+    DlgBugInfo dlgBugInfo(viewManager()->mainWindow());
     dlgBugInfo.exec();
 }
 
 #include "buginfo.moc"
diff --git a/plugins/extensions/buginfo/buginfo.h b/plugins/extensions/buginfo/buginfo.h
index e6d031441c..21b24a90dc 100644
--- a/plugins/extensions/buginfo/buginfo.h
+++ b/plugins/extensions/buginfo/buginfo.h
@@ -1,40 +1,40 @@
 /*
  *  Copyright (c) 2017 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 BUGINFO_H
 #define BUGINFO_H
 
 #include <QVariant>
-#include <kis_view_plugin.h>
+#include <KisActionPlugin.h>
 
 class KUndo2MagicString;
 
-class BugInfo : public KisViewPlugin
+class BugInfo : public KisActionPlugin
 {
     Q_OBJECT
 public:
     BugInfo(QObject *parent, const QVariantList &);
     ~BugInfo() override;
 
 public Q_SLOTS:
 
     void slotBugInfo();
 
 };
 
 #endif // BUGINFO_H
diff --git a/plugins/extensions/clonesarray/clonesarray.cpp b/plugins/extensions/clonesarray/clonesarray.cpp
index 2a506c1909..d3e67de17d 100644
--- a/plugins/extensions/clonesarray/clonesarray.cpp
+++ b/plugins/extensions/clonesarray/clonesarray.cpp
@@ -1,61 +1,61 @@
 /*
  *  Copyright (c) 2013 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 "clonesarray.h"
 
 #include <cmath>
 
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 #include <kpluginfactory.h>
 #include <kis_image.h>
 #include <KisViewManager.h>
 #include <kis_action.h>
 
 #include "dlg_clonesarray.h"
 
 K_PLUGIN_FACTORY_WITH_JSON(ClonesArrayFactory, "kritaclonesarray.json", registerPlugin<ClonesArray>();)
 
 ClonesArray::ClonesArray(QObject *parent, const QVariantList &)
-        : KisViewPlugin(parent)
+        : KisActionPlugin(parent)
 {
     KisAction *action = createAction("clones_array");
     connect(action, SIGNAL(triggered()), this, SLOT(slotCreateClonesArray()));
 }
 
 
 ClonesArray::~ClonesArray()
 {
 }
 
 
 void ClonesArray::slotCreateClonesArray()
 {
-    KisImageWSP image = m_view->image();
+    KisImageWSP image = viewManager()->image();
     Q_ASSERT(image); Q_UNUSED(image);
 
-    DlgClonesArray *dialog = new DlgClonesArray(m_view, m_view->mainWindow());
+    DlgClonesArray *dialog = new DlgClonesArray(viewManager(), viewManager()->mainWindow());
     Q_CHECK_PTR(dialog);
 
     if (dialog->exec() == QDialog::Accepted) {
     }
 
     delete dialog;
 }
 
 #include "clonesarray.moc"
diff --git a/plugins/extensions/clonesarray/clonesarray.h b/plugins/extensions/clonesarray/clonesarray.h
index 63ab9213af..57b6027a23 100644
--- a/plugins/extensions/clonesarray/clonesarray.h
+++ b/plugins/extensions/clonesarray/clonesarray.h
@@ -1,36 +1,36 @@
 /*
  *  Copyright (c) 2013 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 CLONESARRAY_H
 #define CLONESARRAY_H
 
-#include <kis_view_plugin.h>
+#include <KisActionPlugin.h>
 #include <kis_types.h>
 
-class ClonesArray : public KisViewPlugin
+class ClonesArray : public KisActionPlugin
 {
     Q_OBJECT
 public:
     ClonesArray(QObject *parent, const QVariantList &);
     ~ClonesArray() override;
 
 private Q_SLOTS:
     void slotCreateClonesArray();
 };
 
 #endif // CLONESARRAY<_H
diff --git a/plugins/extensions/clonesarray/dlg_clonesarray.cpp b/plugins/extensions/clonesarray/dlg_clonesarray.cpp
index 76e3703b83..51447ae480 100644
--- a/plugins/extensions/clonesarray/dlg_clonesarray.cpp
+++ b/plugins/extensions/clonesarray/dlg_clonesarray.cpp
@@ -1,257 +1,257 @@
 /*
  *  Copyright (c) 2013 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 "dlg_clonesarray.h"
 
 #include <klocalizedstring.h>
 
 #include <KoColorSpaceConstants.h>
 
 #include <kis_debug.h>
 #include <KisViewManager.h>
 #include <kis_image.h>
 #include <kis_processing_applicator.h>
 #include <commands/kis_image_commands.h>
 #include <kis_node.h>
 #include <kis_group_layer.h>
 #include <kis_clone_layer.h>
 
 
-DlgClonesArray::DlgClonesArray(KisViewManager *view, QWidget *parent)
-    :   KoDialog(parent),
-        m_view(view),
-        m_applicator(0),
-        m_baseLayer(m_view->activeLayer())
+DlgClonesArray::DlgClonesArray(KisViewManager *viewManager, QWidget *parent)
+    : KoDialog(parent)
+    , m_viewManager(viewManager)
+    , m_applicator(0)
+    , m_baseLayer(m_viewManager->activeLayer())
 {
     Q_ASSERT(m_baseLayer);
 
     setCaption(i18n("Create Clones Array"));
     setButtons(Ok | Apply | Cancel);
     setDefaultButton(Ok);
     setObjectName("clones_array_dialog");
 
     m_page = new WdgClonesArray(this);
     Q_CHECK_PTR(m_page);
     m_page->setObjectName("clones_array");
 
     setMainWidget(m_page);
     resize(m_page->sizeHint());
 
     connect(this, SIGNAL(okClicked()), SLOT(okClicked()));
     connect(this, SIGNAL(applyClicked()), SLOT(applyClicked()));
     connect(this, SIGNAL(cancelClicked()), SLOT(cancelClicked()));
 
     connect(m_page->columnXOffset, SIGNAL(valueChanged(int)), SLOT(syncOrthogonalToAngular()));
     connect(m_page->columnYOffset, SIGNAL(valueChanged(int)), SLOT(syncOrthogonalToAngular()));
     connect(m_page->rowXOffset, SIGNAL(valueChanged(int)), SLOT(syncOrthogonalToAngular()));
     connect(m_page->rowYOffset, SIGNAL(valueChanged(int)), SLOT(syncOrthogonalToAngular()));
 
     connect(m_page->columnDistance, SIGNAL(valueChanged(double)), SLOT(syncAngularToOrthogonal()));
     connect(m_page->columnAngle, SIGNAL(valueChanged(double)), SLOT(syncAngularToOrthogonal()));
     connect(m_page->rowDistance, SIGNAL(valueChanged(double)), SLOT(syncAngularToOrthogonal()));
     connect(m_page->rowAngle, SIGNAL(valueChanged(double)), SLOT(syncAngularToOrthogonal()));
 
     connect(m_page->numNegativeColumns, SIGNAL(valueChanged(int)), SLOT(setDirty()));
     connect(m_page->numPositiveColumns, SIGNAL(valueChanged(int)), SLOT(setDirty()));
     connect(m_page->numNegativeRows, SIGNAL(valueChanged(int)), SLOT(setDirty()));
     connect(m_page->numPositiveRows, SIGNAL(valueChanged(int)), SLOT(setDirty()));
 
     connect(m_page->numNegativeColumns, SIGNAL(valueChanged(int)), SLOT(updateCheckboxAvailability()));
     connect(m_page->numPositiveColumns, SIGNAL(valueChanged(int)), SLOT(updateCheckboxAvailability()));
     connect(m_page->numNegativeRows, SIGNAL(valueChanged(int)), SLOT(updateCheckboxAvailability()));
     connect(m_page->numPositiveRows, SIGNAL(valueChanged(int)), SLOT(updateCheckboxAvailability()));
 
     connect(m_page->columnPreference, SIGNAL(stateChanged(int)), SLOT(setDirty()));
 
     initializeValues();
     updateCheckboxAvailability();
 }
 
 DlgClonesArray::~DlgClonesArray()
 {
     delete m_page;
 }
 
 void DlgClonesArray::initializeValues()
 {
     if (m_baseLayer && m_baseLayer->original()) {
         QRect bounds = m_baseLayer->original()->exactBounds();
         m_page->columnXOffset->setValue(bounds.width());
         m_page->rowYOffset->setValue(bounds.height());
     }
 }
 
 void DlgClonesArray::setDirty()
 {
     m_isDirty = true;
     enableButtonApply(m_isDirty);
 }
 
 void DlgClonesArray::setClean()
 {
     m_isDirty = false;
     enableButtonApply(m_isDirty);
 }
 
 void DlgClonesArray::updateCheckboxAvailability()
 {
     m_page->columnPreference->setEnabled(
-        m_page->numNegativeColumns->value() > 0 ||
-        m_page->numNegativeRows->value() > 0);
+                m_page->numNegativeColumns->value() > 0 ||
+                m_page->numNegativeRows->value() > 0);
 }
 
 void DlgClonesArray::syncOrthogonalToAngular()
 {
     setAngularSignalsEnabled(false);
 
     int x, y;
 
     x = m_page->columnXOffset->value();
     y = m_page->columnYOffset->value();
     m_page->columnDistance->setValue((float)sqrt(pow2(x) + pow2(y)));
     m_page->columnAngle->setValue(kisRadiansToDegrees(atan2((double) y, (double) x)));
 
     x = m_page->rowXOffset->value();
     y = m_page->rowYOffset->value();
     m_page->rowDistance->setValue((float)sqrt(pow2(x) + pow2(y)));
     m_page->rowAngle->setValue(kisRadiansToDegrees(atan2((double) y, (double) x)));
 
     setAngularSignalsEnabled(true);
     setDirty();
 }
 
 void DlgClonesArray::syncAngularToOrthogonal()
 {
     setOrthogonalSignalsEnabled(false);
 
     qreal a, d;
 
     d = m_page->columnDistance->value();
     a = kisDegreesToRadians(m_page->columnAngle->value());
     m_page->columnXOffset->setValue(qRound(d * cos(a)));
     m_page->columnYOffset->setValue(qRound(d * sin(a)));
 
     d = m_page->rowDistance->value();
     a = kisDegreesToRadians(m_page->rowAngle->value());
     m_page->rowXOffset->setValue(qRound(d * cos(a)));
     m_page->rowYOffset->setValue(qRound(d * sin(a)));
 
     setOrthogonalSignalsEnabled(true);
     setDirty();
 }
 
 void DlgClonesArray::setOrthogonalSignalsEnabled(bool value)
 {
     m_page->columnXOffset->blockSignals(!value);
     m_page->columnYOffset->blockSignals(!value);
     m_page->rowXOffset->blockSignals(!value);
     m_page->rowYOffset->blockSignals(!value);
 }
 
 void DlgClonesArray::setAngularSignalsEnabled(bool value)
 {
     m_page->columnDistance->blockSignals(!value);
     m_page->columnAngle->blockSignals(!value);
     m_page->rowDistance->blockSignals(!value);
     m_page->rowAngle->blockSignals(!value);
 }
 
 void DlgClonesArray::okClicked()
 {
     if (!m_applicator || m_isDirty) {
         reapplyClones();
     }
 
     Q_ASSERT(m_applicator);
 
     m_applicator->end();
     delete m_applicator;
     m_applicator = 0;
 }
 
 void DlgClonesArray::applyClicked()
 {
     reapplyClones();
 }
 
 void DlgClonesArray::cancelClicked()
 {
     if (m_applicator) {
         m_applicator->cancel();
         delete m_applicator;
         m_applicator = 0;
     }
 }
 
 void DlgClonesArray::reapplyClones()
 {
     cancelClicked();
 
-    KisImageSP image = m_view->image();
+    KisImageSP image = m_viewManager->image();
 
-    if (!m_view->blockUntilOperationsFinished(image)) return;
+    if (!m_viewManager->blockUntilOperationsFinished(image)) return;
 
     m_applicator =
-        new KisProcessingApplicator(image, 0,
-                                    KisProcessingApplicator::NONE,
-                                    KisImageSignalVector() << ModifiedSignal);
+            new KisProcessingApplicator(image, 0,
+                                        KisProcessingApplicator::NONE,
+                                        KisImageSignalVector() << ModifiedSignal);
 
     int columnXOffset = m_page->columnXOffset->value();
     int columnYOffset = m_page->columnYOffset->value();
     int rowXOffset = m_page->rowXOffset->value();
     int rowYOffset = m_page->rowYOffset->value();
     bool rowPreference = !m_page->columnPreference->isChecked();
 
     int startColumn = -m_page->numNegativeColumns->value();
     int startRow = -m_page->numNegativeRows->value();
 
     int endColumn = m_page->numPositiveColumns->value() - 1;
     int endRow = m_page->numPositiveRows->value() - 1;
 
     QString positiveGroupName = QString(i18n("+ Array of %1")).arg(m_baseLayer->name());
     KisGroupLayerSP positiveGroupLayer = new KisGroupLayer(image, positiveGroupName, OPACITY_OPAQUE_U8);
     m_applicator->applyCommand(new KisImageLayerAddCommand(image, positiveGroupLayer, m_baseLayer->parent(), m_baseLayer, false, true), KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
 
     KisGroupLayerSP negativeGroupLayer;
 
     if (startRow < 0 || startColumn < 0) {
         QString negativeGroupName = QString(i18n("- Array of %1")).arg(m_baseLayer->name());
         negativeGroupLayer = new KisGroupLayer(image, negativeGroupName, OPACITY_OPAQUE_U8);
         m_applicator->applyCommand(new KisImageLayerAddCommand(image, negativeGroupLayer, m_baseLayer->parent(), m_baseLayer->prevSibling(), false, true), KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
     }
 
     for (int row = endRow; row >= startRow; row--) {
         for (int col = endColumn; col >= startColumn; col--) {
             if (!col && !row) continue;
 
             bool choosePositiveGroup = rowPreference ? row > 0 || (row == 0 && col > 0) : col > 0 || (col == 0 && row > 0);
             KisNodeSP parent = choosePositiveGroup ? positiveGroupLayer : negativeGroupLayer;
 
 
             QString cloneName = QString("Clone %1, %2").arg(col).arg(row);
             KisCloneLayerSP clone = new KisCloneLayer(m_baseLayer, image, cloneName, OPACITY_OPAQUE_U8);
             clone->setX(-row * rowXOffset + col * columnXOffset);
             clone->setY(-row * rowYOffset + col * columnYOffset);
 
             m_applicator->applyCommand(new KisImageLayerAddCommand(image, clone, parent, 0, true, false), KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
         }
     }
 
     setClean();
 }
 
diff --git a/plugins/extensions/clonesarray/dlg_clonesarray.h b/plugins/extensions/clonesarray/dlg_clonesarray.h
index dac2cb9add..fbc6ee2908 100644
--- a/plugins/extensions/clonesarray/dlg_clonesarray.h
+++ b/plugins/extensions/clonesarray/dlg_clonesarray.h
@@ -1,79 +1,80 @@
 /*
  *  Copyright (c) 2013 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 DLG_CLONESARRAY
 #define DLG_CLONESARRAY
 
 #include <KoDialog.h>
 #include <kis_global.h>
+#include <QPointer>
 
 #include "kis_types.h"
 #include "ui_wdg_clonesarray.h"
 
 class KisViewManager;
 class KisProcessingApplicator;
 
 
 class WdgClonesArray : public QWidget, public Ui::WdgClonesArray
 {
     Q_OBJECT
 
 public:
     WdgClonesArray(QWidget *parent) : QWidget(parent) {
         setupUi(this);
     }
 };
 
 class DlgClonesArray: public KoDialog
 {
 
     Q_OBJECT
 
 public:
-    DlgClonesArray(KisViewManager *view, QWidget * parent = 0);
+    DlgClonesArray(KisViewManager *viewManager, QWidget * parent = 0);
     ~DlgClonesArray() override;
 
 private Q_SLOTS:
     void okClicked();
     void applyClicked();
     void cancelClicked();
 
     void syncOrthogonalToAngular();
     void syncAngularToOrthogonal();
 
     void setDirty();
     void updateCheckboxAvailability();
 
 private:
     void setOrthogonalSignalsEnabled(bool value);
     void setAngularSignalsEnabled(bool value);
 
     void initializeValues();
     void reapplyClones();
 
     void setClean();
 
 private:
     WdgClonesArray *m_page;
-    KisViewManager *m_view;
+    QPointer<KisViewManager> m_viewManager;
     KisProcessingApplicator *m_applicator;
     KisLayerSP m_baseLayer;
     bool m_isDirty;
 };
 
 #endif // DLG_CLONESARRAY
diff --git a/plugins/extensions/colorrange/colorrange.cc b/plugins/extensions/colorrange/colorrange.cc
index a836520d46..a6393cbf59 100644
--- a/plugins/extensions/colorrange/colorrange.cc
+++ b/plugins/extensions/colorrange/colorrange.cc
@@ -1,103 +1,103 @@
 /*
  * colorrange.h -- Part of Krita
  *
  * Copyright (c) 2004 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 "colorrange.h"
 
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 #include <kpluginfactory.h>
 
 #include "kis_image.h"
 #include "kis_layer.h"
 #include "kis_paint_device.h"
 #include "kis_global.h"
 #include "kis_types.h"
 #include "KisViewManager.h"
 #include "kis_selection.h"
 #include "kis_selection_manager.h"
 #include "kis_selection_tool_helper.h"
 #include "kis_canvas2.h"
 #include "kis_iterator_ng.h"
 #include "kis_action.h"
 
 #include "dlg_colorrange.h"
 #include <KoColorSpace.h>
 
 K_PLUGIN_FACTORY_WITH_JSON(ColorRangeFactory, "kritacolorrange.json", registerPlugin<ColorRange>();)
 
 
 ColorRange::ColorRange(QObject *parent, const QVariantList &)
-        : KisViewPlugin(parent)
+        : KisActionPlugin(parent)
 {
     KisAction* action = createAction("colorrange");
     connect(action, SIGNAL(triggered()), this, SLOT(slotActivated()));
 
     action  = createAction("selectopaque");
     connect(action, SIGNAL(triggered()), this, SLOT(selectOpaque()));
 }
 
 ColorRange::~ColorRange()
 {
 }
 
 void ColorRange::slotActivated()
 {
-    DlgColorRange *dlgColorRange = new DlgColorRange(m_view, m_view->mainWindow());
+    DlgColorRange *dlgColorRange = new DlgColorRange(viewManager(), viewManager()->mainWindow());
     Q_CHECK_PTR(dlgColorRange);
 
     dlgColorRange->exec();
 }
 
 void ColorRange::selectOpaque()
 {
-    KisCanvas2 *canvas = m_view->canvasBase();
-    KisPaintDeviceSP device = m_view->activeNode()->projection();
-    if (!device) device = m_view->activeNode()->paintDevice();
-    if (!device) device = m_view->activeNode()->original();
+    KisCanvas2 *canvas = viewManager()->canvasBase();
+    KisPaintDeviceSP device = viewManager()->activeNode()->projection();
+    if (!device) device = viewManager()->activeNode()->paintDevice();
+    if (!device) device = viewManager()->activeNode()->original();
     KIS_ASSERT_RECOVER_RETURN(canvas && device);
 
     QRect rc = device->exactBounds();
     if (rc.isEmpty()) return;
 
     KisSelectionToolHelper helper(canvas, kundo2_i18n("Select Opaque"));
 
     qint32 x, y, w, h;
     rc.getRect(&x, &y, &w, &h);
 
     const KoColorSpace * cs = device->colorSpace();
     KisPixelSelectionSP tmpSel = KisPixelSelectionSP(new KisPixelSelection());
 
     KisHLineConstIteratorSP deviter = device->createHLineConstIteratorNG(x, y, w);
     KisHLineIteratorSP selIter = tmpSel ->createHLineIteratorNG(x, y, w);
 
     for (int row = y; row < h + y; ++row) {
         do {
             *selIter->rawData() = cs->opacityU8(deviter->oldRawData());
         } while (deviter->nextPixel() && selIter->nextPixel());
         deviter->nextRow();
         selIter->nextRow();
     }
 
     tmpSel->invalidateOutlineCache();
     helper.selectPixelSelection(tmpSel, SELECTION_ADD);
 }
 
 #include "colorrange.moc"
 
diff --git a/plugins/extensions/colorrange/colorrange.h b/plugins/extensions/colorrange/colorrange.h
index e1ab5192b5..878a355b3d 100644
--- a/plugins/extensions/colorrange/colorrange.h
+++ b/plugins/extensions/colorrange/colorrange.h
@@ -1,40 +1,40 @@
 /*
  * colorrange.h -- Part of Krita
  *
  *  Copyright (c) 2004 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 COLORRANGE_H
 #define COLORRANGE_H
 
 #include <QVariant>
 
-#include <kis_view_plugin.h>
+#include <KisActionPlugin.h>
 
-class ColorRange : public KisViewPlugin
+class ColorRange : public KisActionPlugin
 {
     Q_OBJECT
 public:
     ColorRange(QObject *parent, const QVariantList &);
     ~ColorRange() override;
 
 private Q_SLOTS:
     void slotActivated();
     void selectOpaque();
 };
 
 #endif // COLORRANGE_H
diff --git a/plugins/extensions/colorrange/dlg_colorrange.cc b/plugins/extensions/colorrange/dlg_colorrange.cc
index e8693afa4b..755856120d 100644
--- a/plugins/extensions/colorrange/dlg_colorrange.cc
+++ b/plugins/extensions/colorrange/dlg_colorrange.cc
@@ -1,275 +1,274 @@
 /*
  *  dlg_colorrange.cc - part of KimageShop^WKrayon^WKrita
  *
  *  Copyright (c) 2004 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 "dlg_colorrange.h"
 #include <QApplication>
 #include <QPushButton>
 #include <QCheckBox>
 #include <QSlider>
 #include <QComboBox>
 #include <QImage>
 #include <QLabel>
 #include <QColor>
 #include <QRadioButton>
 
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 
 #include <KoColorConversions.h>
 #include <KoColorProfile.h>
 #include <KoColorSpace.h>
 #include <KoColor.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorModelStandardIds.h>
 #include <KoColorSpaceTraits.h>
 
 #include <kis_layer.h>
 #include <kis_paint_device.h>
 #include <kis_selection.h>
 #include <kis_selection_manager.h>
 #include <kis_types.h>
 #include <kis_undo_adapter.h>
 #include <KisViewManager.h>
 #include <kis_transaction.h>
 #include <kis_cursor.h>
 #include "kis_iterator_ng.h"
 #include "kis_selection_tool_helper.h"
 #include <kis_slider_spin_box.h>
 
-DlgColorRange::DlgColorRange(KisViewManager *view, QWidget *parent)
-        : KoDialog(parent)
-        , m_selectionCommandsAdded(0)
+DlgColorRange::DlgColorRange(KisViewManager *viewManager, QWidget *parent)
+    : KoDialog(parent)
+    , m_selectionCommandsAdded(0)
+    , m_viewManager(viewManager)
 {
     setCaption(i18n("Color Range"));
     setButtons(Ok | Cancel);
     setDefaultButton(Ok);
 
-    m_view = view;
-
     m_page = new WdgColorRange(this);
     Q_CHECK_PTR(m_page);
     m_page->setObjectName("color_range");
 
     setCaption(i18n("Color Range"));
     setMainWidget(m_page);
     resize(m_page->sizeHint());
 
     m_page->intFuzziness->setObjectName("fuzziness");
     m_page->intFuzziness->setRange(0, 200);
     m_page->intFuzziness->setSingleStep(10);
     m_page->intFuzziness->setValue(100);
 
     m_invert = false;
     m_mode = SELECTION_ADD;
     m_currentAction = REDS;
 
     connect(this, SIGNAL(okClicked()),
             this, SLOT(okClicked()));
 
     connect(this, SIGNAL(cancelClicked()),
             this, SLOT(cancelClicked()));
 
     connect(m_page->chkInvert, SIGNAL(clicked()),
             this, SLOT(slotInvertClicked()));
 
     connect(m_page->cmbSelect, SIGNAL(activated(int)),
             this, SLOT(slotSelectionTypeChanged(int)));
 
     connect(m_page->radioAdd, SIGNAL(toggled(bool)),
             this, SLOT(slotAdd(bool)));
 
     connect(m_page->radioSubtract, SIGNAL(toggled(bool)),
             this, SLOT(slotSubtract(bool)));
 
     connect(m_page->bnSelect, SIGNAL(clicked()),
             this, SLOT(slotSelectClicked()));
 
     connect(m_page->bnDeselect, SIGNAL(clicked()),
             this, SLOT(slotDeselectClicked()));
 
     m_page->bnDeselect->setEnabled(false);
 
 }
 
 DlgColorRange::~DlgColorRange()
 {
     delete m_page;
 }
 
 void DlgColorRange::okClicked()
 {
     accept();
 }
 
 void DlgColorRange::cancelClicked()
 {
-    if (!m_view) return;
-    if (!m_view->image()) return;
+    if (!m_viewManager) return;
+    if (!m_viewManager->image()) return;
 
     for (int i = 0; i < m_selectionCommandsAdded; i++) {
-        m_view->undoAdapter()->undoLastCommand();
+        m_viewManager->undoAdapter()->undoLastCommand();
     }
-    m_view->canvas()->update();
+    m_viewManager->canvas()->update();
     reject();
 }
 
 void DlgColorRange::slotInvertClicked()
 {
     m_invert = m_page->chkInvert->isChecked();
 }
 
 void DlgColorRange::slotSelectionTypeChanged(int index)
 {
     m_currentAction = (enumAction)index;
 }
 
 void DlgColorRange::slotSubtract(bool on)
 {
     if (on)
         m_mode = SELECTION_SUBTRACT;
 }
 
 void DlgColorRange::slotAdd(bool on)
 {
     if (on)
         m_mode = SELECTION_ADD;
 }
 
 void DlgColorRange::slotSelectClicked()
 {
-    KisPaintDeviceSP device = m_view->activeDevice();
+    KisPaintDeviceSP device = m_viewManager->activeDevice();
     KIS_ASSERT_RECOVER_RETURN(device);
 
     QRect rc = device->exactBounds();
     if (rc.isEmpty()) return;
 
     QApplication::setOverrideCursor(KisCursor::waitCursor());
 
     qint32 x, y, w, h;
     rc.getRect(&x, &y, &w, &h);
 
-    const KoColorSpace *cs = m_view->activeDevice()->colorSpace();
+    const KoColorSpace *cs = m_viewManager->activeDevice()->colorSpace();
     const KoColorSpace *lab = KoColorSpaceRegistry::instance()->lab16();
 
     KoColor match;
     switch (m_currentAction) {
     case REDS:
         match = KoColor(QColor(Qt::red), cs);
         break;
     case YELLOWS:
         match = KoColor(QColor(Qt::yellow), cs);
         break;
     case GREENS:
         match = KoColor(QColor(Qt::green), cs);
         break;
     case CYANS:
         match = KoColor(QColor(Qt::cyan), cs);
         break;
     case BLUES:
         match = KoColor(QColor(Qt::blue), cs);
         break;
     case MAGENTAS:
         match = KoColor(QColor(Qt::magenta), cs);
         break;
     default:
         ;
     };
 
     int fuzziness = m_page->intFuzziness->value();
 
-    KisSelectionSP selection = new KisSelection(new KisSelectionDefaultBounds(m_view->activeDevice(), m_view->image()));
+    KisSelectionSP selection = new KisSelection(new KisSelectionDefaultBounds(m_viewManager->activeDevice(), m_viewManager->image()));
 
-    KisHLineConstIteratorSP hiter = m_view->activeDevice()->createHLineConstIteratorNG(x, y, w);
+    KisHLineConstIteratorSP hiter = m_viewManager->activeDevice()->createHLineConstIteratorNG(x, y, w);
     KisHLineIteratorSP selIter = selection->pixelSelection()->createHLineIteratorNG(x, y, w);
 
     for (int row = y; row < h - y; ++row) {
         do {
             // Don't try to select transparent pixels.
             if (cs->opacityU8(hiter->oldRawData()) >  OPACITY_TRANSPARENT_U8) {
 
                 bool selected = false;
 
                 KoColor c(hiter->oldRawData(), cs);
                 if (m_currentAction > MAGENTAS) {
                     c.convertTo(lab);
                     quint8 L = lab->scaleToU8(c.data(), 0);
 
                     switch (m_currentAction) {
                     case HIGHLIGHTS:
                         selected = (L > MAX_SELECTED - fuzziness);
                         break;
                     case MIDTONES:
                         selected = (L > MAX_SELECTED / 2 - fuzziness && L < MAX_SELECTED / 2 + fuzziness);
                         break;
                     case SHADOWS:
                         selected = (L < MIN_SELECTED + fuzziness);
                         break;
                     default:
                         ;
                     }
                 }
                 else {
                     quint8 difference = cs->difference(match.data(), c.data());
                     selected = (difference <= fuzziness);
                 }
 
                 if (selected) {
                     if (!m_invert) {
                         if (m_mode == SELECTION_ADD) {
                             *(selIter->rawData()) =  MAX_SELECTED;
                         } else if (m_mode == SELECTION_SUBTRACT) {
                             *(selIter->rawData()) = MIN_SELECTED;
                         }
                     } else {
                         if (m_mode == SELECTION_ADD) {
                             *(selIter->rawData()) = MIN_SELECTED;
                         } else if (m_mode == SELECTION_SUBTRACT) {
                             *(selIter->rawData()) =  MAX_SELECTED;
                         }
                     }
                 }
             }
         } while (hiter->nextPixel() && selIter->nextPixel());
         hiter->nextRow();
         selIter->nextRow();
     }
 
     selection->pixelSelection()->invalidateOutlineCache();
-    KisSelectionToolHelper helper(m_view->canvasBase(), kundo2_i18n("Color Range Selection"));
+    KisSelectionToolHelper helper(m_viewManager->canvasBase(), kundo2_i18n("Color Range Selection"));
     helper.selectPixelSelection(selection->pixelSelection(), m_mode);
 
     m_page->bnDeselect->setEnabled(true);
     m_selectionCommandsAdded++;
     QApplication::restoreOverrideCursor();
 }
 
 void DlgColorRange::slotDeselectClicked()
 {
-    if (!m_view) return;
+    if (!m_viewManager) return;
 
 
-    m_view->undoAdapter()->undoLastCommand();
+    m_viewManager->undoAdapter()->undoLastCommand();
     m_selectionCommandsAdded--;
     if (!m_selectionCommandsAdded) {
         m_page->bnDeselect->setEnabled(false);
     }
 }
 
 
diff --git a/plugins/extensions/colorrange/dlg_colorrange.h b/plugins/extensions/colorrange/dlg_colorrange.h
index 7c4858b8f9..4b862c8205 100644
--- a/plugins/extensions/colorrange/dlg_colorrange.h
+++ b/plugins/extensions/colorrange/dlg_colorrange.h
@@ -1,100 +1,100 @@
 /*
  *  dlg_colorrange.h -- part of KimageShop^WKrayon^WKrita
  *
  *  Copyright (c) 2004 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 DLG_COLORRANGE
 #define DLG_COLORRANGE
 
 #include <QCursor>
 
 #include <KoDialog.h>
 
 #include <kis_selection.h> // For enums
 #include <kis_pixel_selection.h>
 #include <kis_types.h>
 #include <kis_global.h>
 
 #include "ui_wdg_colorrange.h"
 
 class KisViewManager;
 class DlgColorRange;
 
 enum enumAction {
     REDS,
     YELLOWS,
     GREENS,
     CYANS,
     BLUES,
     MAGENTAS,
     HIGHLIGHTS,
     MIDTONES,
     SHADOWS
 };
 
 class WdgColorRange : public QWidget, public Ui::WdgColorRange
 {
     Q_OBJECT
 
 public:
     WdgColorRange(QWidget *parent) : QWidget(parent) {
         setupUi(this);
     }
 };
 
 /**
 * This dialog allows the user to create a selection mask based
 * on a (range of) colors.
 */
 class DlgColorRange: public KoDialog
 {
 
     Q_OBJECT
 
 public:
 
-    DlgColorRange(KisViewManager *view, QWidget *parent = 0);
+    DlgColorRange(KisViewManager *viewManager, QWidget *parent = 0);
     ~DlgColorRange() override;
 
 private Q_SLOTS:
 
     void okClicked();
     void cancelClicked();
 
     void slotInvertClicked();
     void slotSelectionTypeChanged(int index);
     void slotSubtract(bool on);
     void slotAdd(bool on);
     void slotSelectClicked();
     void slotDeselectClicked();
 
 private:
     QImage createMask(KisSelectionSP selection, KisPaintDeviceSP layer);
 
 private:
 
-    WdgColorRange * m_page;
-    KisViewManager * m_view;
+    WdgColorRange *m_page;
+    int m_selectionCommandsAdded;
+    KisViewManager *m_viewManager;
     SelectionAction m_mode;
     QCursor m_oldCursor;
     enumAction m_currentAction;
     bool m_invert;
-    int m_selectionCommandsAdded;
 };
 
 
 #endif // DLG_COLORRANGE
diff --git a/plugins/extensions/colorspaceconversion/colorspaceconversion.cc b/plugins/extensions/colorspaceconversion/colorspaceconversion.cc
index dcfd10912f..5059beecbc 100644
--- a/plugins/extensions/colorspaceconversion/colorspaceconversion.cc
+++ b/plugins/extensions/colorspaceconversion/colorspaceconversion.cc
@@ -1,134 +1,134 @@
 /*
  * colorspaceconversion.cc -- Part of Krita
  *
  * Copyright (c) 2004 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 "colorspaceconversion.h"
 
 #include <QApplication>
 #include <QCursor>
 
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 #include <kpluginfactory.h>
 
 #include <KoColorSpace.h>
 
 #include <kis_undo_adapter.h>
 #include <kis_transaction.h>
 #include <kis_annotation.h>
 #include <kis_config.h>
 #include <kis_cursor.h>
 #include <kis_global.h>
 #include <kis_image.h>
 #include <kis_node_manager.h>
 #include <kis_layer.h>
 #include <kis_types.h>
 #include <kis_colorspace_convert_visitor.h>
 
 #include <KisViewManager.h>
 #include <kis_paint_device.h>
 #include <kis_action.h>
 #include <kis_group_layer.h>
 
 #include "dlg_colorspaceconversion.h"
 #include "kis_action_manager.h"
 
 K_PLUGIN_FACTORY_WITH_JSON(ColorSpaceConversionFactory, "kritacolorspaceconversion.json", registerPlugin<ColorSpaceConversion>();)
 
 
 ColorSpaceConversion::ColorSpaceConversion(QObject *parent, const QVariantList &)
-        : KisViewPlugin(parent)
+        : KisActionPlugin(parent)
 {
-    KisAction *action  = m_view->actionManager()->createAction("imagecolorspaceconversion");
+    KisAction *action  = viewManager()->actionManager()->createAction("imagecolorspaceconversion");
     connect(action, SIGNAL(triggered()), this, SLOT(slotImageColorSpaceConversion()));
 
-    action  = m_view->actionManager()->createAction("layercolorspaceconversion");
+    action  = viewManager()->actionManager()->createAction("layercolorspaceconversion");
     connect(action, SIGNAL(triggered()), this, SLOT(slotLayerColorSpaceConversion()));
 }
 
 ColorSpaceConversion::~ColorSpaceConversion()
 {
 }
 
 void ColorSpaceConversion::slotImageColorSpaceConversion()
 {
-    KisImageSP image = m_view->image().toStrongRef();
+    KisImageSP image = viewManager()->image().toStrongRef();
     if (!image) return;
 
-    DlgColorSpaceConversion * dlgColorSpaceConversion = new DlgColorSpaceConversion(m_view->mainWindow(), "ColorSpaceConversion");
+    DlgColorSpaceConversion * dlgColorSpaceConversion = new DlgColorSpaceConversion(viewManager()->mainWindow(), "ColorSpaceConversion");
     bool allowLCMSOptimization = KisConfig().allowLCMSOptimization();
     dlgColorSpaceConversion->m_page->chkAllowLCMSOptimization->setChecked(allowLCMSOptimization);
     Q_CHECK_PTR(dlgColorSpaceConversion);
 
     dlgColorSpaceConversion->setCaption(i18n("Convert All Layers From ") + image->colorSpace()->name());
     dlgColorSpaceConversion->setInitialColorSpace(image->colorSpace());
 
     if (dlgColorSpaceConversion->exec() == QDialog::Accepted) {
 
         const KoColorSpace * cs = dlgColorSpaceConversion->m_page->colorSpaceSelector->currentColorSpace();
         if (cs) {
             QApplication::setOverrideCursor(KisCursor::waitCursor());
             KoColorConversionTransformation::ConversionFlags conversionFlags = KoColorConversionTransformation::HighQuality;
             if (dlgColorSpaceConversion->m_page->chkBlackpointCompensation->isChecked()) conversionFlags |= KoColorConversionTransformation::BlackpointCompensation;
             if (!dlgColorSpaceConversion->m_page->chkAllowLCMSOptimization->isChecked()) conversionFlags |= KoColorConversionTransformation::NoOptimization;
             image->convertImageColorSpace(cs, (KoColorConversionTransformation::Intent)dlgColorSpaceConversion->m_intentButtonGroup.checkedId(), conversionFlags);
             QApplication::restoreOverrideCursor();
         }
     }
     delete dlgColorSpaceConversion;
 }
 
 void ColorSpaceConversion::slotLayerColorSpaceConversion()
 {
-    KisImageSP image = m_view->image().toStrongRef();
+    KisImageSP image = viewManager()->image().toStrongRef();
     if (!image) return;
 
-    KisLayerSP layer = m_view->activeLayer();
+    KisLayerSP layer = viewManager()->activeLayer();
     if (!layer) return;
 
-    DlgColorSpaceConversion * dlgColorSpaceConversion = new DlgColorSpaceConversion(m_view->mainWindow(), "ColorSpaceConversion");
+    DlgColorSpaceConversion * dlgColorSpaceConversion = new DlgColorSpaceConversion(viewManager()->mainWindow(), "ColorSpaceConversion");
     Q_CHECK_PTR(dlgColorSpaceConversion);
 
     dlgColorSpaceConversion->setCaption(i18n("Convert Current Layer From") + layer->colorSpace()->name());
     dlgColorSpaceConversion->setInitialColorSpace(layer->colorSpace());
 
     if (dlgColorSpaceConversion->exec() == QDialog::Accepted) {
         const KoColorSpace * cs = dlgColorSpaceConversion->m_page->colorSpaceSelector->currentColorSpace();
         if (cs) {
 
             QApplication::setOverrideCursor(KisCursor::waitCursor());
 
             image->undoAdapter()->beginMacro(kundo2_i18n("Convert Layer Type"));
 
             KoColorConversionTransformation::ConversionFlags conversionFlags = KoColorConversionTransformation::HighQuality;
             if (dlgColorSpaceConversion->m_page->chkBlackpointCompensation->isChecked()) conversionFlags |= KoColorConversionTransformation::BlackpointCompensation;
             if (!dlgColorSpaceConversion->m_page->chkAllowLCMSOptimization->isChecked()) conversionFlags |= KoColorConversionTransformation::NoOptimization;
             KisColorSpaceConvertVisitor visitor(image, layer->colorSpace(), cs, (KoColorConversionTransformation::Intent)dlgColorSpaceConversion->m_intentButtonGroup.checkedId(), conversionFlags);
             layer->accept(visitor);
 
             image->undoAdapter()->endMacro();
 
             QApplication::restoreOverrideCursor();
-            m_view->nodeManager()->nodesUpdated();
+            viewManager()->nodeManager()->nodesUpdated();
         }
     }
     delete dlgColorSpaceConversion;
 }
 
 #include "colorspaceconversion.moc"
diff --git a/plugins/extensions/colorspaceconversion/colorspaceconversion.h b/plugins/extensions/colorspaceconversion/colorspaceconversion.h
index 66569aaa67..d3386f806e 100644
--- a/plugins/extensions/colorspaceconversion/colorspaceconversion.h
+++ b/plugins/extensions/colorspaceconversion/colorspaceconversion.h
@@ -1,44 +1,44 @@
 /*
  * colorspaceconversion.h -- Part of Krita
  *
  * Copyright (c) 2004 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 COLORSPACECONVERSION_H
 #define COLORSPACECONVERSION_H
 
 #include <QVariant>
 
-#include <kis_view_plugin.h>
+#include <KisActionPlugin.h>
 
 /**
  * Dialog for converting between color models.
  */
-class ColorSpaceConversion : public KisViewPlugin
+class ColorSpaceConversion : public KisActionPlugin
 {
     Q_OBJECT
 public:
     ColorSpaceConversion(QObject *parent, const QVariantList &);
     ~ColorSpaceConversion() override;
 
 private Q_SLOTS:
 
     void slotImageColorSpaceConversion();
     void slotLayerColorSpaceConversion();
 };
 
 #endif // COLORSPACECONVERSION_H
diff --git a/plugins/extensions/histogram/histogram.cc b/plugins/extensions/histogram/histogram.cc
index e247804d99..2a6036ae84 100644
--- a/plugins/extensions/histogram/histogram.cc
+++ b/plugins/extensions/histogram/histogram.cc
@@ -1,70 +1,70 @@
 /*
  * histogram.h -- Part of Krita
  *
  * Copyright (c) 2004 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 "histogram.h"
 
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 #include <kpluginfactory.h>
 
 #include <kis_layer.h>
 #include <kis_paint_device.h>
 #include <kis_image.h>
 #include <KisViewManager.h>
 
 #include "dlg_histogram.h"
 #include "kis_node_manager.h"
 #include <kis_action.h>
 
 K_PLUGIN_FACTORY_WITH_JSON(HistogramFactory, "kritahistogram.json", registerPlugin<Histogram>();)
 
 Histogram::Histogram(QObject *parent, const QVariantList &)
-        : KisViewPlugin(parent)
+        : KisActionPlugin(parent)
 {
     KisAction* action  = createAction("histogram");
     connect(action,  SIGNAL(triggered()), this, SLOT(slotActivated()));
 }
 
 Histogram::~Histogram()
 {
 }
 
 void Histogram::slotActivated()
 {
-    DlgHistogram * dlgHistogram = new DlgHistogram(m_view->mainWindow(), "Histogram");
+    DlgHistogram * dlgHistogram = new DlgHistogram(viewManager()->mainWindow(), "Histogram");
 
     Q_CHECK_PTR(dlgHistogram);
 
-    KisLayerSP layer = m_view->nodeManager()->activeLayer();
+    KisLayerSP layer = viewManager()->nodeManager()->activeLayer();
     if (layer) {
         KisPaintDeviceSP dev = layer->paintDevice();
 
         if (dev) {
             dlgHistogram->setPaintDevice(dev, layer->image()->bounds());
         }
         if (dlgHistogram->exec() == QDialog::Accepted) {
             // Do nothing; this is an informational dialog
         }
     }
     delete dlgHistogram;
 }
 
 #include "histogram.moc"
 
diff --git a/plugins/extensions/histogram/histogram.h b/plugins/extensions/histogram/histogram.h
index c7fe795293..cfe286ffc3 100644
--- a/plugins/extensions/histogram/histogram.h
+++ b/plugins/extensions/histogram/histogram.h
@@ -1,39 +1,39 @@
 /*
  * histogram.h -- Part of Krita
  *
  * Copyright (c) 2004 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 HISTOGRAM_H
 #define HISTOGRAM_H
 
 #include <QVariant>
 
-#include <kis_view_plugin.h>
+#include <KisActionPlugin.h>
 
-class Histogram : public KisViewPlugin
+class Histogram : public KisActionPlugin
 {
     Q_OBJECT
 public:
     Histogram(QObject *parent, const QVariantList &);
     ~Histogram() override;
 
 private Q_SLOTS:
     void slotActivated();
 };
 
 #endif // HISTOGRAM_H
diff --git a/plugins/extensions/imagesize/imagesize.cc b/plugins/extensions/imagesize/imagesize.cc
index 83601304cf..7adb79aaa0 100644
--- a/plugins/extensions/imagesize/imagesize.cc
+++ b/plugins/extensions/imagesize/imagesize.cc
@@ -1,166 +1,166 @@
 /*
  * imagesize.cc -- Part of Krita
  *
  * Copyright (c) 2004 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 "imagesize.h"
 
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 #include <kpluginfactory.h>
 
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <kis_global.h>
 #include <kis_types.h>
 #include <KisViewManager.h>
 
 #include <kis_image_manager.h>
 #include <kis_node_manager.h>
 #include <kis_group_layer.h>
 #include <kis_selection_mask.h>
 #include <kis_selection.h>
 
 #include "dlg_imagesize.h"
 #include "dlg_canvassize.h"
 #include "dlg_layersize.h"
 #include "kis_filter_strategy.h"
 #include "kis_action.h"
 #include "kis_action_manager.h"
 
 K_PLUGIN_FACTORY_WITH_JSON(ImageSizeFactory, "kritaimagesize.json", registerPlugin<ImageSize>();)
 
 ImageSize::ImageSize(QObject *parent, const QVariantList &)
-    : KisViewPlugin(parent)
+    : KisActionPlugin(parent)
 {
     KisAction *action  = createAction("imagesize");
     connect(action, SIGNAL(triggered()), this, SLOT(slotImageSize()));
 
     action = createAction("canvassize");
     connect(action, SIGNAL(triggered()), this, SLOT(slotCanvasSize()));
 
     action = createAction("layersize");
     connect(action, SIGNAL(triggered()), this, SLOT(slotLayerSize()));
 
     action  = createAction("selectionscale");
     connect(action, SIGNAL(triggered()), this, SLOT(slotSelectionScale()));
 }
 
 ImageSize::~ImageSize()
 {
 }
 
 void ImageSize::slotImageSize()
 {
-    KisImageSP image = m_view->image().toStrongRef();
+    KisImageSP image = viewManager()->image().toStrongRef();
     if (!image) return;
 
-    DlgImageSize * dlgImageSize = new DlgImageSize(m_view->mainWindow(), image->width(), image->height(), image->yRes());
+    DlgImageSize * dlgImageSize = new DlgImageSize(viewManager()->mainWindow(), image->width(), image->height(), image->yRes());
     Q_CHECK_PTR(dlgImageSize);
     dlgImageSize->setObjectName("ImageSize");
 
     if (dlgImageSize->exec() == QDialog::Accepted) {
         qint32 w = dlgImageSize->width();
         qint32 h = dlgImageSize->height();
         double res = dlgImageSize->resolution();
 
-        m_view->imageManager()->scaleCurrentImage(QSize(w, h), res, res, dlgImageSize->filterType());
+        viewManager()->imageManager()->scaleCurrentImage(QSize(w, h), res, res, dlgImageSize->filterType());
     }
 
     delete dlgImageSize;
 }
 
 void ImageSize::slotCanvasSize()
 {
-    KisImageWSP image = m_view->image();
+    KisImageWSP image = viewManager()->image();
 
     if (!image) return;
 
-    DlgCanvasSize * dlgCanvasSize = new DlgCanvasSize(m_view->mainWindow(), image->width(), image->height(), image->yRes());
+    DlgCanvasSize * dlgCanvasSize = new DlgCanvasSize(viewManager()->mainWindow(), image->width(), image->height(), image->yRes());
     Q_CHECK_PTR(dlgCanvasSize);
 
     if (dlgCanvasSize->exec() == QDialog::Accepted) {
         qint32 width = dlgCanvasSize->width();
         qint32 height = dlgCanvasSize->height();
         qint32 xOffset = dlgCanvasSize->xOffset();
         qint32 yOffset = dlgCanvasSize->yOffset();
 
-        m_view->imageManager()->resizeCurrentImage(width, height, xOffset, yOffset);
+        viewManager()->imageManager()->resizeCurrentImage(width, height, xOffset, yOffset);
     }
     delete dlgCanvasSize;
 }
 
 void ImageSize::slotLayerSize()
 {
-    KisImageWSP image = m_view->image();
+    KisImageWSP image = viewManager()->image();
 
     if (!image) return;
 
-    KisPaintDeviceSP dev = m_view->activeLayer()->projection();
+    KisPaintDeviceSP dev = viewManager()->activeLayer()->projection();
     Q_ASSERT(dev);
     QRect rc = dev->exactBounds();
 
-    DlgLayerSize * dlgLayerSize = new DlgLayerSize(m_view->mainWindow(), "LayerSize", rc.width(), rc.height(), image->yRes());
+    DlgLayerSize * dlgLayerSize = new DlgLayerSize(viewManager()->mainWindow(), "LayerSize", rc.width(), rc.height(), image->yRes());
     Q_CHECK_PTR(dlgLayerSize);
     dlgLayerSize->setCaption(i18n("Resize Layer"));
 
     if (dlgLayerSize->exec() == QDialog::Accepted) {
         qint32 w = dlgLayerSize->width();
         qint32 h = dlgLayerSize->height();
 
-        m_view->nodeManager()->scale((double)w / ((double)(rc.width())),
+        viewManager()->nodeManager()->scale((double)w / ((double)(rc.width())),
                                      (double)h / ((double)(rc.height())),
                                      dlgLayerSize->filterType());
     }
     delete dlgLayerSize;
 }
 
 void ImageSize::slotSelectionScale()
 {
-    KisImageSP image = m_view->image();
+    KisImageSP image = viewManager()->image();
     if (!image) {
         return;
     }
-    KisLayerSP layer = m_view->activeLayer();
+    KisLayerSP layer = viewManager()->activeLayer();
 
     KIS_ASSERT_RECOVER_RETURN(image && layer);
 
     KisSelectionMaskSP selectionMask = layer->selectionMask();
     if (!selectionMask) {
         selectionMask = image->rootLayer()->selectionMask();
     }
 
     KIS_ASSERT_RECOVER_RETURN(selectionMask);
 
     QRect rc = selectionMask->selection()->selectedExactRect();
-    DlgLayerSize * dlgSize = new DlgLayerSize(m_view->mainWindow(), "SelectionScale", rc.width(), rc.height(), image->yRes());
+    DlgLayerSize * dlgSize = new DlgLayerSize(viewManager()->mainWindow(), "SelectionScale", rc.width(), rc.height(), image->yRes());
     dlgSize->setCaption(i18n("Scale Selection"));
 
     if (dlgSize->exec() == QDialog::Accepted) {
         qint32 w = dlgSize->width();
         qint32 h = dlgSize->height();
 
         image->scaleNode(selectionMask,
                          qreal(w) / rc.width(),
                          qreal(h) / rc.height(),
                          dlgSize->filterType());
     }
     delete dlgSize;
 }
 
 #include "imagesize.moc"
diff --git a/plugins/extensions/imagesize/imagesize.h b/plugins/extensions/imagesize/imagesize.h
index 740ca2c304..892fc333ee 100644
--- a/plugins/extensions/imagesize/imagesize.h
+++ b/plugins/extensions/imagesize/imagesize.h
@@ -1,42 +1,42 @@
 /*
  * imagesize.h -- Part of Krita
  *
  * Copyright (c) 2004 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 IMAGESIZE_H
 #define IMAGESIZE_H
 
 #include <QVariant>
 
-#include <kis_view_plugin.h>
+#include <KisActionPlugin.h>
 
-class ImageSize : public KisViewPlugin
+class ImageSize : public KisActionPlugin
 {
     Q_OBJECT
 public:
     ImageSize(QObject *parent, const QVariantList &);
     ~ImageSize() override;
 
 private Q_SLOTS:
 
     void slotImageSize();
     void slotCanvasSize();
     void slotLayerSize();
     void slotSelectionScale();
 };
 
 #endif // IMAGESIZE_H
diff --git a/plugins/extensions/imagesize/wdg_canvassize.ui b/plugins/extensions/imagesize/wdg_canvassize.ui
index 466f45e393..95acf5f175 100644
--- a/plugins/extensions/imagesize/wdg_canvassize.ui
+++ b/plugins/extensions/imagesize/wdg_canvassize.ui
@@ -1,643 +1,643 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgCanvasSize</class>
  <widget class="QWidget" name="WdgCanvasSize">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>395</width>
-    <height>387</height>
+    <height>413</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Canvas Size</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
     <widget class="QGroupBox" name="groupBox_2">
      <property name="title">
       <string>New Size</string>
      </property>
      <property name="flat">
       <bool>true</bool>
      </property>
      <layout class="QGridLayout" name="gridLayout_2">
       <item row="1" column="1">
        <widget class="QLabel" name="lblNewHeight">
         <property name="text">
          <string>Height:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
        </widget>
       </item>
       <item row="1" column="3">
        <widget class="QComboBox" name="heightUnit"/>
       </item>
       <item row="0" column="4" rowspan="2">
        <widget class="KoAspectButton" name="aspectRatioBtn" native="true"/>
       </item>
       <item row="0" column="1">
        <widget class="QLabel" name="lblNewWidth">
         <property name="text">
          <string>Width:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
        </widget>
       </item>
       <item row="0" column="2">
        <widget class="KisDoubleParseUnitSpinBox" name="newWidthDouble">
         <property name="decimals">
          <number>4</number>
         </property>
         <property name="minimum">
          <double>0.000100000000000</double>
         </property>
         <property name="maximum">
-         <double>10000.000000000000000</double>
+         <double>100000000.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.100000000000000</double>
         </property>
        </widget>
       </item>
       <item row="1" column="2">
        <widget class="KisDoubleParseUnitSpinBox" name="newHeightDouble">
         <property name="decimals">
          <number>4</number>
         </property>
         <property name="minimum">
          <double>0.000100000000000</double>
         </property>
         <property name="maximum">
-         <double>10000.000000000000000</double>
+         <double>100000000.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.100000000000000</double>
         </property>
        </widget>
       </item>
       <item row="1" column="0">
        <spacer name="horizontalSpacer_5">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeType">
          <enum>QSizePolicy::Fixed</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>25</width>
           <height>20</height>
          </size>
         </property>
        </spacer>
       </item>
       <item row="0" column="3">
        <widget class="QComboBox" name="widthUnit"/>
       </item>
       <item row="1" column="5">
        <spacer name="horizontalSpacer_2">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeType">
          <enum>QSizePolicy::MinimumExpanding</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>40</width>
           <height>20</height>
          </size>
         </property>
        </spacer>
       </item>
       <item row="2" column="2" colspan="4">
        <widget class="QCheckBox" name="constrainProportionsCkb">
         <property name="toolTip">
          <string>Constrain aspect ratio</string>
         </property>
         <property name="text">
          <string>Constrain proportions</string>
         </property>
         <property name="checked">
          <bool>true</bool>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="groupBox">
      <property name="title">
       <string>Offset</string>
      </property>
      <property name="flat">
       <bool>true</bool>
      </property>
      <layout class="QGridLayout" name="gridLayout">
       <item row="4" column="2">
        <spacer name="verticalSpacer">
         <property name="orientation">
          <enum>Qt::Vertical</enum>
         </property>
         <property name="sizeType">
          <enum>QSizePolicy::MinimumExpanding</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>20</width>
           <height>30</height>
          </size>
         </property>
        </spacer>
       </item>
       <item row="2" column="2">
        <spacer name="verticalSpacer_2">
         <property name="orientation">
          <enum>Qt::Vertical</enum>
         </property>
         <property name="sizeType">
          <enum>QSizePolicy::Fixed</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>20</width>
           <height>16</height>
          </size>
         </property>
        </spacer>
       </item>
       <item row="0" column="1">
        <widget class="QLabel" name="lblXOff">
         <property name="text">
          <string>X:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
        </widget>
       </item>
       <item row="0" column="2">
        <widget class="KisDoubleParseUnitSpinBox" name="xOffsetDouble">
         <property name="decimals">
          <number>4</number>
         </property>
         <property name="minimum">
          <double>-10000.000000000000000</double>
         </property>
         <property name="maximum">
          <double>10000.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.100000000000000</double>
         </property>
        </widget>
       </item>
       <item row="3" column="0">
        <spacer name="horizontalSpacer_6">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeType">
          <enum>QSizePolicy::Fixed</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>25</width>
           <height>20</height>
          </size>
         </property>
        </spacer>
       </item>
       <item row="3" column="1">
        <widget class="QLabel" name="lblAnchor">
         <property name="text">
          <string>Anchor:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTop|Qt::AlignTrailing</set>
         </property>
        </widget>
       </item>
       <item row="1" column="1">
        <widget class="QLabel" name="lblYOff">
         <property name="text">
          <string>Y:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
        </widget>
       </item>
       <item row="1" column="2">
        <widget class="KisDoubleParseUnitSpinBox" name="yOffsetDouble">
         <property name="decimals">
          <number>4</number>
         </property>
         <property name="minimum">
          <double>-10000.000000000000000</double>
         </property>
         <property name="maximum">
          <double>10000.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.100000000000000</double>
         </property>
        </widget>
       </item>
       <item row="1" column="3">
        <widget class="QComboBox" name="yOffUnit"/>
       </item>
       <item row="0" column="3">
        <widget class="QComboBox" name="xOffUnit"/>
       </item>
       <item row="3" column="3">
        <widget class="QFrame" name="previewCanvas">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="minimumSize">
          <size>
           <width>0</width>
           <height>0</height>
          </size>
         </property>
         <property name="frameShape">
          <enum>QFrame::StyledPanel</enum>
         </property>
         <property name="frameShadow">
          <enum>QFrame::Sunken</enum>
         </property>
         <layout class="QVBoxLayout" name="verticalLayout_2">
          <property name="leftMargin">
           <number>2</number>
          </property>
          <property name="topMargin">
           <number>2</number>
          </property>
          <property name="rightMargin">
           <number>2</number>
          </property>
          <property name="bottomMargin">
           <number>2</number>
          </property>
          <item>
           <widget class="KCanvasPreview" name="canvasPreview" native="true"/>
          </item>
         </layout>
        </widget>
       </item>
       <item row="3" column="2">
        <layout class="QHBoxLayout" name="horizontalLayout">
         <item>
          <layout class="QGridLayout" name="gridLayout_3">
           <property name="spacing">
            <number>0</number>
           </property>
           <item row="0" column="0">
            <widget class="QPushButton" name="topLeft">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="maximumSize">
              <size>
               <width>25</width>
               <height>25</height>
              </size>
             </property>
             <property name="text">
              <string/>
             </property>
             <property name="iconSize">
              <size>
               <width>15</width>
               <height>15</height>
              </size>
             </property>
             <property name="checkable">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item row="1" column="0">
            <widget class="QPushButton" name="middleLeft">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="maximumSize">
              <size>
               <width>25</width>
               <height>25</height>
              </size>
             </property>
             <property name="text">
              <string/>
             </property>
             <property name="iconSize">
              <size>
               <width>15</width>
               <height>15</height>
              </size>
             </property>
             <property name="checkable">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item row="2" column="0">
            <widget class="QPushButton" name="bottomLeft">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="maximumSize">
              <size>
               <width>25</width>
               <height>25</height>
              </size>
             </property>
             <property name="text">
              <string/>
             </property>
             <property name="iconSize">
              <size>
               <width>15</width>
               <height>15</height>
              </size>
             </property>
             <property name="checkable">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item row="1" column="1">
            <widget class="QPushButton" name="middleCenter">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="maximumSize">
              <size>
               <width>25</width>
               <height>25</height>
              </size>
             </property>
             <property name="text">
              <string/>
             </property>
             <property name="iconSize">
              <size>
               <width>15</width>
               <height>15</height>
              </size>
             </property>
             <property name="checkable">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item row="2" column="1">
            <widget class="QPushButton" name="bottomCenter">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="maximumSize">
              <size>
               <width>25</width>
               <height>25</height>
              </size>
             </property>
             <property name="text">
              <string/>
             </property>
             <property name="iconSize">
              <size>
               <width>15</width>
               <height>15</height>
              </size>
             </property>
             <property name="checkable">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item row="1" column="2">
            <widget class="QPushButton" name="middleRight">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="maximumSize">
              <size>
               <width>25</width>
               <height>25</height>
              </size>
             </property>
             <property name="text">
              <string/>
             </property>
             <property name="iconSize">
              <size>
               <width>15</width>
               <height>15</height>
              </size>
             </property>
             <property name="checkable">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item row="0" column="1">
            <widget class="QPushButton" name="topCenter">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="maximumSize">
              <size>
               <width>25</width>
               <height>25</height>
              </size>
             </property>
             <property name="text">
              <string/>
             </property>
             <property name="iconSize">
              <size>
               <width>15</width>
               <height>15</height>
              </size>
             </property>
             <property name="checkable">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item row="0" column="2">
            <widget class="QPushButton" name="topRight">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="maximumSize">
              <size>
               <width>25</width>
               <height>25</height>
              </size>
             </property>
             <property name="text">
              <string/>
             </property>
             <property name="iconSize">
              <size>
               <width>15</width>
               <height>15</height>
              </size>
             </property>
             <property name="checkable">
              <bool>true</bool>
             </property>
             <property name="flat">
              <bool>false</bool>
             </property>
            </widget>
           </item>
           <item row="2" column="2">
            <widget class="QPushButton" name="bottomRight">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="maximumSize">
              <size>
               <width>25</width>
               <height>25</height>
              </size>
             </property>
             <property name="text">
              <string/>
             </property>
             <property name="iconSize">
              <size>
               <width>15</width>
               <height>15</height>
              </size>
             </property>
             <property name="checkable">
              <bool>true</bool>
             </property>
            </widget>
           </item>
          </layout>
         </item>
         <item>
          <spacer name="horizontalSpacer">
           <property name="orientation">
            <enum>Qt::Horizontal</enum>
           </property>
           <property name="sizeType">
            <enum>QSizePolicy::Maximum</enum>
           </property>
           <property name="sizeHint" stdset="0">
            <size>
             <width>16</width>
             <height>20</height>
            </size>
           </property>
          </spacer>
         </item>
        </layout>
       </item>
       <item row="3" column="4">
        <spacer name="horizontalSpacer_4">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeType">
          <enum>QSizePolicy::MinimumExpanding</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>40</width>
           <height>20</height>
          </size>
         </property>
        </spacer>
       </item>
      </layout>
     </widget>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KoAspectButton</class>
    <extends>QWidget</extends>
    <header>KoAspectButton.h</header>
    <container>1</container>
   </customwidget>
+  <customwidget>
+   <class>KisDoubleParseUnitSpinBox</class>
+   <extends>QDoubleSpinBox</extends>
+   <header>kis_double_parse_unit_spin_box.h</header>
+  </customwidget>
   <customwidget>
    <class>KCanvasPreview</class>
    <extends>QWidget</extends>
    <header>kcanvaspreview.h</header>
    <container>1</container>
   </customwidget>
-  <customwidget>
-   <class>KisDoubleParseUnitSpinBox</class>
-   <extends>QDoubleSpinBox</extends>
-   <header>kis_double_parse_unit_spin_box.h</header>
-  </customwidget>
  </customwidgets>
  <tabstops>
   <tabstop>newWidthDouble</tabstop>
   <tabstop>widthUnit</tabstop>
   <tabstop>newHeightDouble</tabstop>
   <tabstop>heightUnit</tabstop>
   <tabstop>constrainProportionsCkb</tabstop>
   <tabstop>xOffsetDouble</tabstop>
   <tabstop>xOffUnit</tabstop>
   <tabstop>yOffsetDouble</tabstop>
   <tabstop>yOffUnit</tabstop>
   <tabstop>topLeft</tabstop>
   <tabstop>topCenter</tabstop>
   <tabstop>topRight</tabstop>
   <tabstop>middleLeft</tabstop>
   <tabstop>middleCenter</tabstop>
   <tabstop>middleRight</tabstop>
   <tabstop>bottomLeft</tabstop>
   <tabstop>bottomCenter</tabstop>
   <tabstop>bottomRight</tabstop>
  </tabstops>
  <resources/>
  <connections/>
 </ui>
diff --git a/plugins/extensions/imagesize/wdg_imagesize.ui b/plugins/extensions/imagesize/wdg_imagesize.ui
index 069b3737fd..6c907fa299 100644
--- a/plugins/extensions/imagesize/wdg_imagesize.ui
+++ b/plugins/extensions/imagesize/wdg_imagesize.ui
@@ -1,405 +1,405 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgImageSize</class>
  <widget class="QWidget" name="WdgImageSize">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>391</width>
-    <height>386</height>
+    <height>418</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Scale To New Size</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
     <widget class="QGroupBox" name="groupImageSize">
      <property name="title">
       <string>Pixel Dimensions</string>
      </property>
      <property name="flat">
       <bool>true</bool>
      </property>
      <layout class="QGridLayout" name="gridLayout_3">
       <item row="1" column="2">
        <widget class="KisDoubleParseUnitSpinBox" name="pixelHeightDouble">
         <property name="minimumSize">
          <size>
           <width>80</width>
           <height>0</height>
          </size>
         </property>
         <property name="decimals">
          <number>4</number>
         </property>
         <property name="minimum">
          <double>0.000100000000000</double>
         </property>
         <property name="maximum">
-         <double>10000.000000000000000</double>
+         <double>100000000.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.100000000000000</double>
         </property>
        </widget>
       </item>
       <item row="0" column="0">
        <spacer name="horizontalSpacer_2">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeType">
          <enum>QSizePolicy::Fixed</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>25</width>
           <height>20</height>
          </size>
         </property>
        </spacer>
       </item>
       <item row="0" column="1">
        <widget class="QLabel" name="lblPixelWidth">
         <property name="text">
          <string>Width:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
        </widget>
       </item>
       <item row="2" column="1">
        <widget class="QLabel" name="lblPixelFilter">
         <property name="text">
          <string>&amp;Filter:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
         <property name="buddy">
          <cstring>printWidth</cstring>
         </property>
        </widget>
       </item>
       <item row="0" column="4" rowspan="2">
        <widget class="KoAspectButton" name="pixelAspectRatioBtn" native="true">
         <property name="text" stdset="0">
          <string/>
         </property>
        </widget>
       </item>
       <item row="1" column="1">
        <widget class="QLabel" name="lblPixelHeight">
         <property name="text">
          <string>Height:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
        </widget>
       </item>
       <item row="0" column="2">
        <widget class="KisDoubleParseUnitSpinBox" name="pixelWidthDouble">
         <property name="minimumSize">
          <size>
           <width>80</width>
           <height>0</height>
          </size>
         </property>
         <property name="decimals">
          <number>4</number>
         </property>
         <property name="minimum">
          <double>0.000100000000000</double>
         </property>
         <property name="maximum">
-         <double>10000.000000000000000</double>
+         <double>100000000.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.100000000000000</double>
         </property>
        </widget>
       </item>
       <item row="1" column="5">
        <spacer name="horizontalSpacer_5">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeType">
          <enum>QSizePolicy::MinimumExpanding</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>40</width>
           <height>20</height>
          </size>
         </property>
        </spacer>
       </item>
       <item row="2" column="2" colspan="2">
        <widget class="KisCmbIDList" name="pixelFilterCmb" native="true"/>
       </item>
       <item row="0" column="3" rowspan="2">
        <widget class="QComboBox" name="pixelSizeUnit"/>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="groupPrintSize">
      <property name="title">
       <string>Print Size</string>
      </property>
      <property name="flat">
       <bool>true</bool>
      </property>
      <layout class="QGridLayout" name="gridLayout">
       <item row="1" column="1">
        <widget class="QLabel" name="lblPrintHeight">
         <property name="text">
          <string>Hei&amp;ght:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
         <property name="buddy">
          <cstring>printHeight</cstring>
         </property>
        </widget>
       </item>
       <item row="0" column="2">
        <widget class="KisDoubleParseUnitSpinBox" name="printWidth">
         <property name="minimumSize">
          <size>
           <width>80</width>
           <height>0</height>
          </size>
         </property>
         <property name="decimals">
          <number>4</number>
         </property>
         <property name="minimum">
          <double>0.000100000000000</double>
         </property>
         <property name="maximum">
-         <double>10000.000000000000000</double>
+         <double>100000000.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.100000000000000</double>
         </property>
        </widget>
       </item>
       <item row="0" column="1">
        <widget class="QLabel" name="lblPrintWidth">
         <property name="text">
          <string>Wid&amp;th:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
         <property name="buddy">
          <cstring>printWidth</cstring>
         </property>
        </widget>
       </item>
       <item row="1" column="2">
        <widget class="KisDoubleParseUnitSpinBox" name="printHeight">
         <property name="minimumSize">
          <size>
           <width>80</width>
           <height>0</height>
          </size>
         </property>
         <property name="decimals">
          <number>4</number>
         </property>
         <property name="minimum">
          <double>0.000100000000000</double>
         </property>
         <property name="maximum">
-         <double>10000.000000000000000</double>
+         <double>100000000.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.100000000000000</double>
         </property>
        </widget>
       </item>
       <item row="0" column="4" rowspan="2">
        <widget class="KoAspectButton" name="printAspectRatioBtn" native="true">
         <property name="text" stdset="0">
          <string/>
         </property>
        </widget>
       </item>
       <item row="2" column="1">
        <widget class="QLabel" name="lblResolution">
         <property name="text">
          <string>Resolution:</string>
         </property>
        </widget>
       </item>
       <item row="2" column="2">
        <widget class="KisDoubleParseSpinBox" name="printResolution">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="minimumSize">
          <size>
           <width>70</width>
           <height>0</height>
          </size>
         </property>
         <property name="decimals">
          <number>4</number>
         </property>
         <property name="minimum">
          <double>0.000100000000000</double>
         </property>
         <property name="maximum">
          <double>10000.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.100000000000000</double>
         </property>
        </widget>
       </item>
       <item row="2" column="3">
        <widget class="QComboBox" name="printResolutionUnit"/>
       </item>
       <item row="1" column="0">
        <spacer name="horizontalSpacer">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeType">
          <enum>QSizePolicy::Fixed</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>25</width>
           <height>20</height>
          </size>
         </property>
        </spacer>
       </item>
       <item row="0" column="5">
        <spacer name="horizontalSpacer_3">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeType">
          <enum>QSizePolicy::MinimumExpanding</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>40</width>
           <height>20</height>
          </size>
         </property>
        </spacer>
       </item>
       <item row="0" column="3" rowspan="2">
        <widget class="QComboBox" name="printWidthUnit"/>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <spacer name="verticalSpacer_2">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeType">
       <enum>QSizePolicy::Fixed</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>16</height>
       </size>
      </property>
     </spacer>
    </item>
    <item>
     <widget class="QCheckBox" name="constrainProportionsCkb">
      <property name="toolTip">
       <string>Constrain aspect ratio</string>
      </property>
      <property name="text">
       <string>Constrain proportions</string>
      </property>
      <property name="checked">
       <bool>true</bool>
      </property>
     </widget>
    </item>
    <item>
     <widget class="QCheckBox" name="adjustPrintSizeSeparatelyCkb">
      <property name="text">
       <string>Adjust print size separately</string>
      </property>
     </widget>
    </item>
    <item>
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeType">
       <enum>QSizePolicy::MinimumExpanding</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>30</height>
       </size>
      </property>
     </spacer>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KisCmbIDList</class>
    <extends></extends>
    <header>widgets/kis_cmb_idlist.h</header>
   </customwidget>
   <customwidget>
    <class>KoAspectButton</class>
    <extends>QWidget</extends>
    <header>KoAspectButton.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>KisDoubleParseSpinBox</class>
    <extends>QDoubleSpinBox</extends>
    <header>kis_double_parse_spin_box.h</header>
   </customwidget>
   <customwidget>
    <class>KisDoubleParseUnitSpinBox</class>
    <extends>QDoubleSpinBox</extends>
    <header>kis_double_parse_unit_spin_box.h</header>
   </customwidget>
  </customwidgets>
  <tabstops>
   <tabstop>pixelWidthDouble</tabstop>
   <tabstop>pixelSizeUnit</tabstop>
   <tabstop>pixelHeightDouble</tabstop>
   <tabstop>pixelFilterCmb</tabstop>
   <tabstop>printWidth</tabstop>
   <tabstop>printWidthUnit</tabstop>
   <tabstop>printHeight</tabstop>
   <tabstop>printResolution</tabstop>
   <tabstop>printResolutionUnit</tabstop>
   <tabstop>constrainProportionsCkb</tabstop>
   <tabstop>adjustPrintSizeSeparatelyCkb</tabstop>
  </tabstops>
  <resources/>
  <connections/>
 </ui>
diff --git a/plugins/extensions/imagesize/wdg_layersize.ui b/plugins/extensions/imagesize/wdg_layersize.ui
index 6a07d00756..5076c9a4da 100644
--- a/plugins/extensions/imagesize/wdg_layersize.ui
+++ b/plugins/extensions/imagesize/wdg_layersize.ui
@@ -1,209 +1,209 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgLayerSize</class>
  <widget class="QWidget" name="WdgLayerSize">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>374</width>
-    <height>201</height>
+    <height>212</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Layer Size</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
     <widget class="QGroupBox" name="groupNewSize">
      <property name="title">
       <string>New Size</string>
      </property>
      <property name="flat">
       <bool>true</bool>
      </property>
      <layout class="QGridLayout" name="gridLayout_3">
       <item row="0" column="4" rowspan="2">
        <widget class="KoAspectButton" name="aspectRatioBtn" native="true">
         <property name="text" stdset="0">
          <string/>
         </property>
        </widget>
       </item>
       <item row="1" column="5">
        <spacer name="horizontalSpacer_5">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeType">
          <enum>QSizePolicy::MinimumExpanding</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>40</width>
           <height>20</height>
          </size>
         </property>
        </spacer>
       </item>
       <item row="0" column="3">
        <widget class="QComboBox" name="newWidthUnit"/>
       </item>
       <item row="1" column="3">
        <widget class="QComboBox" name="newHeightUnit"/>
       </item>
       <item row="0" column="1">
        <widget class="QLabel" name="lblNewWidth">
         <property name="text">
          <string>Width:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
        </widget>
       </item>
       <item row="0" column="2">
        <widget class="KisDoubleParseUnitSpinBox" name="newWidthDouble">
         <property name="minimumSize">
          <size>
           <width>80</width>
           <height>0</height>
          </size>
         </property>
         <property name="decimals">
          <number>4</number>
         </property>
         <property name="minimum">
          <double>0.000100000000000</double>
         </property>
         <property name="maximum">
-         <double>10000.000000000000000</double>
+         <double>100000000.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.100000000000000</double>
         </property>
        </widget>
       </item>
       <item row="1" column="2">
        <widget class="KisDoubleParseUnitSpinBox" name="newHeightDouble">
         <property name="minimumSize">
          <size>
           <width>80</width>
           <height>0</height>
          </size>
         </property>
         <property name="decimals">
          <number>4</number>
         </property>
         <property name="minimum">
          <double>0.000100000000000</double>
         </property>
         <property name="maximum">
          <double>10000.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.100000000000000</double>
         </property>
        </widget>
       </item>
       <item row="2" column="2" colspan="2">
        <widget class="KisCmbIDList" name="filterCmb" native="true"/>
       </item>
       <item row="2" column="1">
        <widget class="QLabel" name="lblFilter">
         <property name="text">
          <string>Filter:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
        </widget>
       </item>
       <item row="1" column="1">
        <widget class="QLabel" name="lblNewHeight">
         <property name="text">
          <string>Height:</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
         </property>
        </widget>
       </item>
       <item row="3" column="2" colspan="4">
        <widget class="QCheckBox" name="constrainProportionsCkb">
         <property name="toolTip">
          <string>Constrain aspect ratio</string>
         </property>
         <property name="text">
          <string>Constrain proportions</string>
         </property>
         <property name="checked">
          <bool>true</bool>
         </property>
        </widget>
       </item>
       <item row="0" column="0">
        <spacer name="horizontalSpacer_2">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="sizeType">
          <enum>QSizePolicy::Fixed</enum>
         </property>
         <property name="sizeHint" stdset="0">
          <size>
           <width>25</width>
           <height>20</height>
          </size>
         </property>
        </spacer>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeType">
       <enum>QSizePolicy::MinimumExpanding</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>30</height>
       </size>
      </property>
     </spacer>
    </item>
   </layout>
  </widget>
  <customwidgets>
+  <customwidget>
+   <class>KisCmbIDList</class>
+   <extends></extends>
+   <header>widgets/kis_cmb_idlist.h</header>
+  </customwidget>
   <customwidget>
    <class>KoAspectButton</class>
    <extends>QWidget</extends>
    <header>KoAspectButton.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>KisDoubleParseUnitSpinBox</class>
    <extends>QDoubleSpinBox</extends>
    <header>kis_double_parse_unit_spin_box.h</header>
   </customwidget>
-  <customwidget>
-   <class>KisCmbIDList</class>
-   <extends></extends>
-   <header>widgets/kis_cmb_idlist.h</header>
-  </customwidget>
  </customwidgets>
  <tabstops>
   <tabstop>newWidthDouble</tabstop>
   <tabstop>newWidthUnit</tabstop>
   <tabstop>newHeightDouble</tabstop>
   <tabstop>newHeightUnit</tabstop>
   <tabstop>filterCmb</tabstop>
  </tabstops>
  <resources/>
  <connections/>
 </ui>
diff --git a/plugins/extensions/imagesplit/imagesplit.cpp b/plugins/extensions/imagesplit/imagesplit.cpp
index 526f4c8069..0316741d44 100644
--- a/plugins/extensions/imagesplit/imagesplit.cpp
+++ b/plugins/extensions/imagesplit/imagesplit.cpp
@@ -1,207 +1,207 @@
 /*
  * imagesplit.cc -- Part of Krita
  *
  * Copyright (c) 2004 Boudewijn Rempt (boud@valdyas.org)
  * Copyright (c) 2011 Srikanth Tiyyagura <srikanth.tulasiram@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "imagesplit.h"
 
 #include <QStringList>
 #include <QDir>
 #include <QStandardPaths>
 #include <QMessageBox>
 
 #include <klocalizedstring.h>
 #include <kpluginfactory.h>
 
 #include <KisImportExportManager.h>
 #include <KoFileDialog.h>
 #include <KisDocument.h>
 
 #include <KisPart.h>
 #include <kis_debug.h>
 #include <kis_types.h>
 #include <KisViewManager.h>
 #include <kis_image.h>
 #include <kis_action.h>
 #include <KisDocument.h>
 #include <kis_paint_layer.h>
 #include <kis_painter.h>
 #include <kis_paint_device.h>
 #include <KisMimeDatabase.h>
 
 #include "dlg_imagesplit.h"
 
 K_PLUGIN_FACTORY_WITH_JSON(ImagesplitFactory, "kritaimagesplit.json", registerPlugin<Imagesplit>();)
 
 Imagesplit::Imagesplit(QObject *parent, const QVariantList &)
-    : KisViewPlugin(parent)
+    : KisActionPlugin(parent)
 {
     KisAction *action  = createAction("imagesplit");
     connect(action, SIGNAL(triggered()), this, SLOT(slotImagesplit()));
 }
 
 Imagesplit::~Imagesplit()
 {
 }
 
 bool Imagesplit::saveAsImage(const QRect &imgSize, const QString &mimeType, const QString &url)
 {
-    KisImageSP image = m_view->image();
+    KisImageSP image = viewManager()->image();
 
     KisDocument *document = KisPart::instance()->createDocument();
 
     KisImageSP dst = new KisImage(document->createUndoStore(), imgSize.width(), imgSize.height(), image->colorSpace(), image->objectName());
     dst->setResolution(image->xRes(), image->yRes());
     document->setCurrentImage(dst);
 
     KisPaintLayer* paintLayer = new KisPaintLayer(dst, dst->nextLayerName(), 255);
     KisPainter gc(paintLayer->paintDevice());
     gc.bitBlt(QPoint(0, 0), image->projection(), imgSize);
 
     dst->addNode(paintLayer, KisNodeSP(0));
     dst->refreshGraph();
     document->setFileBatchMode(true);
     if (!document->exportDocumentSync(QUrl::fromLocalFile(url), mimeType.toLatin1())) {
         if (document->errorMessage().isEmpty()) {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not save\n%1", document->localFilePath()));
         } else {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not save %1\nReason: %2", document->localFilePath(), document->errorMessage()));
         }
         return false;
     }
 
     delete document;
 
     return true;
 }
 
 void Imagesplit::slotImagesplit()
 {
     // Taking the title - url from caption function and removing file extension
-    QStringList strList = ((m_view->document())->caption()).split('.');
+    QStringList strList = ((viewManager()->document())->caption()).split('.');
     QString suffix = strList.at(0);
 
     // Getting all mime types and converting them into names which are displayed at combo box
     QStringList listMimeFilter = KisImportExportManager::mimeFilter(KisImportExportManager::Export);
-    QString defaultMime = QString::fromLatin1(m_view->document()->mimeType());
+    QString defaultMime = QString::fromLatin1(viewManager()->document()->mimeType());
     int defaultMimeIndex = 0;
 
     listMimeFilter.sort();
     QStringList filteredMimeTypes;
     QStringList listFileType;
     int i = 0;
     Q_FOREACH (const QString & mimeType, listMimeFilter) {
         listFileType.append(KisMimeDatabase::descriptionForMimeType(mimeType));
         filteredMimeTypes.append(mimeType);
         if (mimeType == defaultMime) {
             defaultMimeIndex = i;
         }
         i++;
     }
 
     listMimeFilter = filteredMimeTypes;
 
     Q_ASSERT(listMimeFilter.size() == listFileType.size());
 
-    DlgImagesplit *dlgImagesplit = new DlgImagesplit(m_view, suffix, listFileType, defaultMimeIndex);
+    DlgImagesplit *dlgImagesplit = new DlgImagesplit(viewManager(), suffix, listFileType, defaultMimeIndex);
     dlgImagesplit->setObjectName("Imagesplit");
     Q_CHECK_PTR(dlgImagesplit);
 
-    KisImageWSP image = m_view->image();
+    KisImageWSP image = viewManager()->image();
 
     if (dlgImagesplit->exec() == QDialog::Accepted) {
 
         int numHorizontalLines = dlgImagesplit->horizontalLines();
         int numVerticalLines = dlgImagesplit->verticalLines();
 
         int img_width = image->width() / (numVerticalLines + 1);
         int img_height = image->height() / (numHorizontalLines + 1);
 
 
         bool stop = false;
         if (dlgImagesplit->autoSave()) {
-            KoFileDialog dialog(m_view->mainWindow(), KoFileDialog::OpenDirectory, "OpenDocument");
+            KoFileDialog dialog(viewManager()->mainWindow(), KoFileDialog::OpenDirectory, "OpenDocument");
             dialog.setCaption(i18n("Save Image on Split"));
             dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
-            QStringList mimeFilter = m_view->document()->importExportManager()->mimeFilter(KisImportExportManager::Export);
-            QString defaultMime = QString::fromLatin1(m_view->document()->mimeType());
+            QStringList mimeFilter = viewManager()->document()->importExportManager()->mimeFilter(KisImportExportManager::Export);
+            QString defaultMime = QString::fromLatin1(viewManager()->document()->mimeType());
             dialog.setMimeTypeFilters(mimeFilter, defaultMime);
 
             QUrl directory = QUrl::fromUserInput(dialog.filename());
 
             if (directory.isEmpty())
                 return;
             for (int i = 0, k = 1; i < (numVerticalLines + 1); i++) {
                 for (int j = 0; j < (numHorizontalLines + 1); j++, k++) {
                     QString mimeTypeSelected = listMimeFilter.at(dlgImagesplit->cmbIndex);
                     QString homepath = directory.toLocalFile();
                     QString suffix = KisMimeDatabase::suffixesForMimeType(mimeTypeSelected).first();
                     qDebug() << "suffix" << suffix;
                     if (suffix.startsWith("*.")) {
                         suffix = suffix.remove(0, 1);
                     }
                     qDebug() << "\tsuffix" << suffix;
                     if (!suffix.startsWith(".")) {
                         suffix = suffix.prepend('.');
                     }
                     qDebug() << "\tsuffix" << suffix;
                     QString fileName = dlgImagesplit->suffix() + '_' + QString::number(k) + suffix;
                     QString url = homepath  + '/' + fileName;
                     if (!saveAsImage(QRect((i * img_width), (j * img_height), img_width, img_height), listMimeFilter.at(dlgImagesplit->cmbIndex), url)) {
                         stop = true;
                         break;
                     }
                 }
                 if (stop) {
                     break;
                 }
             }
         }
         else {
 
             for (int i = 0; i < (numVerticalLines + 1); i++) {
                 for (int j = 0; j < (numHorizontalLines + 1); j++) {
-                    KoFileDialog dialog(m_view->mainWindow(), KoFileDialog::SaveFile, "OpenDocument");
+                    KoFileDialog dialog(viewManager()->mainWindow(), KoFileDialog::SaveFile, "OpenDocument");
                     dialog.setCaption(i18n("Save Image on Split"));
                     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
                     dialog.setMimeTypeFilters(listMimeFilter, defaultMime);
 
                     QUrl url = QUrl::fromUserInput(dialog.filename());
 
                     QString mimefilter = KisMimeDatabase::mimeTypeForFile(url.toLocalFile(), false);
 
                     if (url.isEmpty())
                         return;
                     if (!saveAsImage(QRect((i * img_width), (j * img_height), img_width, img_height), mimefilter, url.toLocalFile())) {
                         stop = true;
                         break;
                     }
                 }
                 if (stop) {
                     break;
                 }
             }
 
         }
 
     }
     delete dlgImagesplit;
 }
 
 #include "imagesplit.moc"
diff --git a/plugins/extensions/imagesplit/imagesplit.h b/plugins/extensions/imagesplit/imagesplit.h
index 09f490bf8d..3d89ae4743 100644
--- a/plugins/extensions/imagesplit/imagesplit.h
+++ b/plugins/extensions/imagesplit/imagesplit.h
@@ -1,42 +1,42 @@
 /*
  * imagesplit.h -- Part of Krita
  *
  * Copyright (c) 2004 Boudewijn Rempt (boud@valdyas.org)
  * Copyright (c) 2011 Srikanth Tiyyagura <srikanth.tulasiram@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef IMAGESPLIT_H
 #define IMAGESPLIT_H
 
 #include <QVariant>
 
 #include <QUrl>
-#include <kis_view_plugin.h>
+#include <KisActionPlugin.h>
 
-class Imagesplit : public KisViewPlugin
+class Imagesplit : public KisActionPlugin
 {
     Q_OBJECT
 public:
     Imagesplit(QObject *parent, const QVariantList &);
     ~Imagesplit() override;
 
 private Q_SLOTS:
 
     void slotImagesplit();
     bool saveAsImage(const QRect &imgSize, const QString &mimeType, const QString &url);
 };
 
 #endif // IMAGESPLIT_H
diff --git a/plugins/extensions/layergroupswitcher/layergroupswitcher.cpp b/plugins/extensions/layergroupswitcher/layergroupswitcher.cpp
index 6a316987f0..48ce8105a9 100644
--- a/plugins/extensions/layergroupswitcher/layergroupswitcher.cpp
+++ b/plugins/extensions/layergroupswitcher/layergroupswitcher.cpp
@@ -1,137 +1,137 @@
 /*
  * layergroupswitcher.cpp -- Part of Krita
  *
  * Copyright (c) 2013 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 "layergroupswitcher.h"
 
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 #include <kpluginfactory.h>
 
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <kis_group_layer.h>
 #include <kis_node.h>
 #include <kis_node_manager.h>
 #include <kis_global.h>
 #include <kis_types.h>
 #include <KisViewManager.h>
 
 #include "kis_action.h"
 
 K_PLUGIN_FACTORY_WITH_JSON(LayerGroupSwitcherFactory, "kritalayergroupswitcher.json", registerPlugin<LayerGroupSwitcher>();)
 
 LayerGroupSwitcher::LayerGroupSwitcher(QObject *parent, const QVariantList &)
-    : KisViewPlugin(parent)
+    : KisActionPlugin(parent)
 {
     KisAction *action  = new KisAction(i18n("Move into previous group"), this);
     addAction("LayerGroupSwitcher/previous", action);
     connect(action, SIGNAL(triggered()), this, SLOT(moveIntoPreviousGroup()));
 
     action = new KisAction(i18n("Move into next group"), this);
     addAction("LayerGroupSwitcher/next", action);
     connect(action, SIGNAL(triggered()), this, SLOT(moveIntoNextGroup()));
 }
 
 LayerGroupSwitcher::~LayerGroupSwitcher()
 {
 }
 
 void LayerGroupSwitcher::moveIntoNextGroup()
 {
-    KisImageSP image = m_view->image().toStrongRef();
+    KisImageSP image = viewManager()->image().toStrongRef();
     if (!image) {
         return;
     }
-    KisNodeManager *nodeManager = m_view->nodeManager();
+    KisNodeManager *nodeManager = viewManager()->nodeManager();
     KisLayerSP active = nodeManager->activeLayer();
     if (!active) {
         return;
     }
     if (active->parentLayer().data() == image->rootLayer().data()) {
         active->setVisible(false);
         nodeManager->activateNextNode();
         active = nodeManager->activeLayer();
         if (active) {
             active->setVisible(true);
         }
     }
     else if (active->parent()) {
         KisNodeSP parent = active->parent();
         if (parent) {
             int indexInGroup = active->parent()->index(active);
             nodeManager->slotNonUiActivatedNode(parent);
             parent->setVisible(false);
             nodeManager->activateNextNode();
             active = nodeManager->activeLayer();
             if (active) {
                 active->setVisible(true);
             }
             KisNodeSP child = active->at(indexInGroup);
             if (child) {
                 nodeManager->slotNonUiActivatedNode(child);
                 child->setVisible(true);
             }
         }
     }
     image->refreshGraph();
 
 }
 
 void LayerGroupSwitcher::moveIntoPreviousGroup()
 {
-    KisImageSP image = m_view->image().toStrongRef();
+    KisImageSP image = viewManager()->image().toStrongRef();
     if (!image) {
         return;
     }
-    KisNodeManager *nodeManager = m_view->nodeManager();
+    KisNodeManager *nodeManager = viewManager()->nodeManager();
     KisLayerSP active = nodeManager->activeLayer();
     if (!active) {
         return;
     }
     if (active->parentLayer().data() == image->rootLayer().data()) {
         active->setVisible(false);
         nodeManager->activatePreviousNode();
         active = nodeManager->activeLayer();
         if (active) {
             active->setVisible(true);
         }
     }
     else if (active->parent()) {
         KisNodeSP parent = active->parent();
         if (parent) {
             int indexInGroup = active->parent()->index(active);
             nodeManager->slotNonUiActivatedNode(parent);
             parent->setVisible(false);
             nodeManager->activatePreviousNode();
             active = nodeManager->activeLayer();
             if (active) {
                 active->setVisible(true);
             }
             KisNodeSP child = active->at(indexInGroup);
             if (child) {
                 nodeManager->slotNonUiActivatedNode(child);
                 child->setVisible(true);
             }
         }
     }
     image->refreshGraph();
 }
 
 #include "layergroupswitcher.moc"
diff --git a/plugins/extensions/layergroupswitcher/layergroupswitcher.h b/plugins/extensions/layergroupswitcher/layergroupswitcher.h
index 9a143955b6..fa613ff6be 100644
--- a/plugins/extensions/layergroupswitcher/layergroupswitcher.h
+++ b/plugins/extensions/layergroupswitcher/layergroupswitcher.h
@@ -1,40 +1,40 @@
 /*
  * layergroupswitcher.h -- Part of Krita
  *
  * Copyright (c) 2013 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 LAYERGROUP_SWITCHER_H
 #define LAYERGROUP_SWITCHER_H
 
 #include <QVariant>
 
-#include <kis_view_plugin.h>
+#include <KisActionPlugin.h>
 
-class LayerGroupSwitcher : public KisViewPlugin
+class LayerGroupSwitcher : public KisActionPlugin
 {
     Q_OBJECT
 public:
     LayerGroupSwitcher(QObject *parent, const QVariantList &);
     ~LayerGroupSwitcher() override;
 
 private Q_SLOTS:
 
     void moveIntoNextGroup();
     void moveIntoPreviousGroup();
 };
 
 #endif // LAYERGROUP_SWITCHER_H
diff --git a/plugins/extensions/layersplit/layersplit.cpp b/plugins/extensions/layersplit/layersplit.cpp
index 522980f5ca..f46d19d6f2 100644
--- a/plugins/extensions/layersplit/layersplit.cpp
+++ b/plugins/extensions/layersplit/layersplit.cpp
@@ -1,226 +1,226 @@
 /*
  * Copyright (C) 2014 Boudewijn Rempt <boud@valdyas.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "layersplit.h"
 
 #include <QMap>
 #include <QPointer>
 #include <QHash>
 
 #include <klocalizedstring.h>
 #include <kpluginfactory.h>
 
 #include <KoColorSpace.h>
 #include <KoChannelInfo.h>
 #include <KoColor.h>
 
 #include <kis_debug.h>
 #include <kis_types.h>
 #include <KisViewManager.h>
 #include <kis_image.h>
 #include <kis_action.h>
 #include <KisDocument.h>
 #include <kis_node.h>
 #include <kis_painter.h>
 #include <kis_paint_device.h>
 #include <kis_paint_layer.h>
 #include <kis_group_layer.h>
 #include <kis_random_accessor_ng.h>
 #include "dlg_layersplit.h"
 #include "kis_node_manager.h"
 #include "kis_node_commands_adapter.h"
 #include "kis_undo_adapter.h"
 
 #include <KoUpdater.h>
 #include <KoProgressUpdater.h>
 
 K_PLUGIN_FACTORY_WITH_JSON(LayerSplitFactory, "kritalayersplit.json", registerPlugin<LayerSplit>();)
 
 LayerSplit::LayerSplit(QObject *parent, const QVariantList &)
-    : KisViewPlugin(parent)
+    : KisActionPlugin(parent)
 {
     KisAction *action  = createAction("layersplit");
     connect(action, SIGNAL(triggered()), this, SLOT(slotLayerSplit()));
 }
 
 LayerSplit::~LayerSplit()
 {
 }
 
 
 struct Layer {
     KoColor color;
     KisPaintDeviceSP device;
     KisRandomAccessorSP accessor;
     int pixelsWritten;
 
     bool operator<(const Layer& other) const
     {
         return pixelsWritten < other.pixelsWritten;
     }
 };
 
 void LayerSplit::slotLayerSplit()
 {
     DlgLayerSplit dlg;
 
     if (dlg.exec() == QDialog::Accepted) {
 
         dlg.hide();
 
         QApplication::setOverrideCursor(Qt::WaitCursor);
 
-        QPointer<KoUpdater> updater = m_view->createUnthreadedUpdater(i18n("Split into Layers"));
+        QPointer<KoUpdater> updater = viewManager()->createUnthreadedUpdater(i18n("Split into Layers"));
 
-        KisImageSP image = m_view->image();
+        KisImageSP image = viewManager()->image();
         if (!image) return;
 
         image->lock();
 
-        KisNodeSP node = m_view->activeNode();
+        KisNodeSP node = viewManager()->activeNode();
         if (!node) return;
 
         KisPaintDeviceSP projection = node->projection();
         if (!projection) return;
 
         QList<Layer> colorMap;
 
         const KoColorSpace *cs = projection->colorSpace();
         QRect rc = image->bounds();
 
         int fuzziness = dlg.fuzziness();
 
         updater->setProgress(0);
 
         KisRandomConstAccessorSP acc = projection->createRandomConstAccessorNG(rc.x(), rc.y());
 
         for (int row = rc.y(); row < rc.height(); ++row) {
 
             for (int col = rc.x(); col < rc.width(); ++col) {
 
                 acc->moveTo(col, row);
 
                 KoColor c(cs);
                 c.setColor(acc->rawDataConst(), cs);
 
                 if (c.opacityU8() == OPACITY_TRANSPARENT_U8) {
                     continue;
                 }
 
                 if (dlg.disregardOpacity()) {
                     c.setOpacity(OPACITY_OPAQUE_U8);
                 }
 
                 bool found = false;
                 Q_FOREACH (const Layer &l, colorMap) {
                     if (fuzziness == 0) {
 
                         found = (l.color == c);
                     }
                     else {
                         quint8 match = cs->difference(l.color.data(), c.data());
                         found = (match <= fuzziness);
                     }
                     if (found) {
                         KisRandomAccessorSP dstAcc = l.accessor;
                         dstAcc->moveTo(col, row);
                         memcpy(dstAcc->rawData(), acc->rawDataConst(), cs->pixelSize());
                         const_cast<Layer*>(&l)->pixelsWritten++;
                         break;
                     }
                 }
 
                 if (!found) {
                     QString name = "";
                     if (dlg.palette()) {
                        name = dlg.palette()->closestColorName(c);
                     }
 
                     if (name.toLower() == "untitled" || name.toLower() == "none" || name.toLower() == "") {
                         name = KoColor::toQString(c);
                     }
                     Layer l;
                     l.color = c;
                     l.device = new KisPaintDevice(cs, name);
                     l.accessor = l.device->createRandomAccessorNG(col, row);
                     l.accessor->moveTo(col, row);
                     memcpy(l.accessor->rawData(), acc->rawDataConst(), cs->pixelSize());
                     l.pixelsWritten = 1;
                     colorMap << l;
                 }
             }
 
             if (updater->interrupted()) {
                 return;
             }
 
             updater->setProgress((row - rc.y()) * 100 / rc.height() - rc.y());
         }
 
         updater->setProgress(100);
 
         dbgKrita << "Created" << colorMap.size() << "layers";
 //        Q_FOREACH (const Layer &l, colorMap) {
 //            dbgKrita << "\t" << l.device->objectName() << ":" << l.pixelsWritten;
 //        }
 
         if (dlg.sortLayers()) {
             std::sort(colorMap.begin(), colorMap.end());
         }
 
         KisUndoAdapter *undo = image->undoAdapter();
         undo->beginMacro(kundo2_i18n("Split Layer"));
-        KisNodeCommandsAdapter adapter(m_view);
+        KisNodeCommandsAdapter adapter(viewManager());
 
         KisGroupLayerSP baseGroup = dynamic_cast<KisGroupLayer*>(node->parent().data());
         if (!baseGroup) {
             // Masks are never nested
             baseGroup = dynamic_cast<KisGroupLayer*>(node->parent()->parent().data());
         }
 
         if (dlg.hideOriginal()) {
             node->setVisible(false);
         }
 
         if (dlg.createBaseGroup()) {
             KisGroupLayerSP grp = new KisGroupLayer(image, i18n("Color"), OPACITY_OPAQUE_U8);
             adapter.addNode(grp, baseGroup, 1);
             baseGroup = grp;
         }
 
         Q_FOREACH (const Layer &l, colorMap) {
             KisGroupLayerSP grp = baseGroup;
             if (dlg.createSeparateGroups()) {
                 grp = new KisGroupLayer(image, l.device->objectName(), OPACITY_OPAQUE_U8);
                 adapter.addNode(grp, baseGroup, 1);
             }
             KisPaintLayerSP paintLayer = new KisPaintLayer(image, l.device->objectName(), OPACITY_OPAQUE_U8, l.device);
             adapter.addNode(paintLayer, grp, 0);
             paintLayer->setAlphaLocked(dlg.lockAlpha());
         }
 
         undo->endMacro();
         image->unlock();
         image->setModified();
    }
 
     QApplication::restoreOverrideCursor();
 }
 
 #include "layersplit.moc"
diff --git a/plugins/extensions/layersplit/layersplit.h b/plugins/extensions/layersplit/layersplit.h
index afe3461117..69b8e09306 100644
--- a/plugins/extensions/layersplit/layersplit.h
+++ b/plugins/extensions/layersplit/layersplit.h
@@ -1,40 +1,40 @@
 /*
  * Copyright (C) 2014 Boudewijn Rempt <boud@valdyas.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 #ifndef LAYERSPLIT_H
 #define LAYERSPLIT_H
 
 #include <QVariant>
 
 #include <QUrl>
-#include <kis_view_plugin.h>
+#include <KisActionPlugin.h>
 
-class LayerSplit : public KisViewPlugin
+class LayerSplit : public KisActionPlugin
 {
     Q_OBJECT
 public:
     LayerSplit(QObject *parent, const QVariantList &);
     ~LayerSplit() override;
 
 private Q_SLOTS:
 
     void slotLayerSplit();
 
 };
 
 #endif // LAYERSPLIT_H
diff --git a/plugins/extensions/metadataeditor/metadataeditor.cc b/plugins/extensions/metadataeditor/metadataeditor.cc
index f9ce456317..8504614ff6 100644
--- a/plugins/extensions/metadataeditor/metadataeditor.cc
+++ b/plugins/extensions/metadataeditor/metadataeditor.cc
@@ -1,69 +1,69 @@
 /*
  *  Copyright (c) 2007 Cyrille Berger <cberger@cberger.net>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; either version 2.1 of the License, or
  *  (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "metadataeditor.h"
 #include <stdlib.h>
 
 #include <QDialog>
 #include <QVBoxLayout>
 
 #include <kis_debug.h>
 #include <kpluginfactory.h>
 #include <klocalizedstring.h>
 
 #include "kis_config.h"
 #include "kis_cursor.h"
 #include "kis_global.h"
 #include "kis_layer.h"
 #include "kis_node_manager.h"
 #include "kis_types.h"
 #include "KisViewManager.h"
 #include "kis_action.h"
 #include "kis_image.h"
 
 #include <metadata/kis_meta_data_store.h>
 #include <metadata/kis_meta_data_entry.h>
 #include <metadata/kis_meta_data_value.h>
 #include <metadata/kis_meta_data_schema.h>
 
 #include "kis_entry_editor.h"
 #include "kis_meta_data_editor.h"
 
 K_PLUGIN_FACTORY_WITH_JSON(metadataeditorPluginFactory, "kritametadataeditor.json", registerPlugin<metadataeditorPlugin>();)
 
 metadataeditorPlugin::metadataeditorPlugin(QObject *parent, const QVariantList &)
-        : KisViewPlugin(parent)
+        : KisActionPlugin(parent)
 {
     KisAction *action  = createAction("EditLayerMetaData");
     connect(action, SIGNAL(triggered()), this, SLOT(slotEditLayerMetaData()));
 }
 
 metadataeditorPlugin::~metadataeditorPlugin()
 {
 }
 
 void metadataeditorPlugin::slotEditLayerMetaData()
 {
-    KisImageWSP image = m_view->image();
+    KisImageWSP image = viewManager()->image();
     if (!image) return;
 
-    KisMetaDataEditor editor(m_view->mainWindow(), m_view->nodeManager()->activeLayer()->metaData());
+    KisMetaDataEditor editor(viewManager()->mainWindow(), viewManager()->nodeManager()->activeLayer()->metaData());
     editor.exec();
 }
 
 #include "metadataeditor.moc"
diff --git a/plugins/extensions/metadataeditor/metadataeditor.h b/plugins/extensions/metadataeditor/metadataeditor.h
index b828285506..3035557bf8 100644
--- a/plugins/extensions/metadataeditor/metadataeditor.h
+++ b/plugins/extensions/metadataeditor/metadataeditor.h
@@ -1,45 +1,45 @@
 /*
  *  Copyright (c) 2007 Cyrille Berger <cberger@cberger.net>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; either version 2.1 of the License, or
  *  (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef _METADATAEDITOR_H_
 #define _METADATAEDITOR_H_
 
 #include <QVariant>
 
-#include <kis_view_plugin.h>
+#include <KisActionPlugin.h>
 
 namespace KisMetaData
 {
 }
 
 /**
  * Template of view plugin
  */
-class metadataeditorPlugin : public KisViewPlugin
+class metadataeditorPlugin : public KisActionPlugin
 {
     Q_OBJECT
 public:
     metadataeditorPlugin(QObject *parent, const QVariantList &);
     ~metadataeditorPlugin() override;
 
 private Q_SLOTS:
 
     void slotEditLayerMetaData();
 };
 
 #endif // metadataeditorPlugin_H
diff --git a/plugins/extensions/modify_selection/modify_selection.cc b/plugins/extensions/modify_selection/modify_selection.cc
index ac1344e6ac..94971924e3 100644
--- a/plugins/extensions/modify_selection/modify_selection.cc
+++ b/plugins/extensions/modify_selection/modify_selection.cc
@@ -1,75 +1,75 @@
 /*
  * modify_selection.cc -- Part of Krita
  *
  * Copyright (c) 2006 Michael Thaler (michael.thaler@physik.tu-muenchen.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 "modify_selection.h"
 
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 
 #include "kis_action.h"
 #include <kpluginfactory.h>
 #include <operations/kis_operation_ui_widget_factory.h>
 
 #include "dlg_grow_selection.h"
 #include "dlg_shrink_selection.h"
 #include "dlg_border_selection.h"
 #include "dlg_feather_selection.h"
 #include "modify_selection_operations.h"
 
 K_PLUGIN_FACTORY_WITH_JSON(ModifySelectionFactory, "kritamodifyselection.json", registerPlugin<ModifySelection>();)
 
 ModifySelection::ModifySelection(QObject *parent, const QVariantList &)
-        : KisViewPlugin(parent)
+        : KisActionPlugin(parent)
 {
     KisAction* action = createAction("growselection");
     action->setOperationID("growselection");
 
     addUIFactory(new KisOperationUIWidgetFactory<WdgGrowSelection>("growselection"));
     addOperation(new GrowSelectionOperation);
 
     action = createAction("shrinkselection");
     action->setOperationID("shrinkselection");
 
     addUIFactory(new KisOperationUIWidgetFactory<WdgShrinkSelection>("shrinkselection"));
     addOperation(new ShrinkSelectionOperation);
 
     action = createAction("borderselection");
     action->setOperationID("borderselection");
 
     addUIFactory(new KisOperationUIWidgetFactory<WdgBorderSelection>("borderselection"));
     addOperation(new BorderSelectionOperation);
 
     action = createAction("featherselection");
     action->setOperationID("featherselection");
 
     addUIFactory(new KisOperationUIWidgetFactory<WdgFeatherSelection>("featherselection"));
     addOperation(new FeatherSelectionOperation);
 
     action = createAction("smoothselection");
     action->setOperationID("smoothselection");
 
     addOperation(new SmoothSelectionOperation);
 }
 
 ModifySelection::~ModifySelection()
 {
 }
 
 #include "modify_selection.moc"
diff --git a/plugins/extensions/modify_selection/modify_selection.h b/plugins/extensions/modify_selection/modify_selection.h
index 500387401a..bb36bdcca7 100644
--- a/plugins/extensions/modify_selection/modify_selection.h
+++ b/plugins/extensions/modify_selection/modify_selection.h
@@ -1,35 +1,35 @@
 /*
  * modify_selection.h -- Part of Krita
  *
  * Copyright (c) 2006 Michael Thaler (michael.thaler@physik.tu-muenchen.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 MODIFY_SELECTION_H
 #define MODIFY_SELECTION_H
 
 #include <QVariant>
 
-#include <kis_view_plugin.h>
+#include <KisActionPlugin.h>
 
-class ModifySelection : public KisViewPlugin
+class ModifySelection : public KisActionPlugin
 {
     Q_OBJECT
 public:
     ModifySelection(QObject *parent, const QVariantList &);
     ~ModifySelection() override;
 };
 
 #endif // MODIFY_SELECTION_H
diff --git a/plugins/extensions/offsetimage/offsetimage.cpp b/plugins/extensions/offsetimage/offsetimage.cpp
index 8bc975bbb2..d1a38008c4 100644
--- a/plugins/extensions/offsetimage/offsetimage.cpp
+++ b/plugins/extensions/offsetimage/offsetimage.cpp
@@ -1,143 +1,143 @@
 /*
  * Copyright (c) 2013 Lukáš Tvrdý <lukast.dev@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "offsetimage.h"
 
 #include <cmath>
 
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 #include <kpluginfactory.h>
 #include <kis_icon.h>
 #include <kis_image.h>
 #include <kis_types.h>
 #include <KisViewManager.h>
 #include <kis_image_manager.h>
 #include <kis_node_manager.h>
 #include <kis_canvas_resource_provider.h>
 #include <kis_group_layer.h>
 #include <kis_image_signal_router.h>
 #include <kis_processing_applicator.h>
 #include <kis_action.h>
 #include <kis_selection.h>
 
 #include "dlg_offsetimage.h"
 #include "kis_offset_processing_visitor.h"
 
 K_PLUGIN_FACTORY_WITH_JSON(OffsetImageFactory, "kritaoffsetimage.json", registerPlugin<OffsetImage>();)
 
 OffsetImage::OffsetImage(QObject *parent, const QVariantList &)
-        : KisViewPlugin(parent)
+        : KisActionPlugin(parent)
 {
     KisAction *action  = createAction("offsetimage");
     connect(action, SIGNAL(triggered()), this, SLOT(slotOffsetImage()));
 
     action  = createAction("offsetlayer");
     connect(action, SIGNAL(triggered()), this, SLOT(slotOffsetLayer()));
 }
 
 
 OffsetImage::~OffsetImage()
 {
 }
 
 
 void OffsetImage::slotOffsetImage()
 {
-    KisImageSP image = m_view->image().toStrongRef();
+    KisImageSP image = viewManager()->image().toStrongRef();
     if (image) {
 
-        DlgOffsetImage * dlgOffsetImage = new DlgOffsetImage(m_view->mainWindow(), "OffsetImage", offsetWrapRect().size());
+        DlgOffsetImage * dlgOffsetImage = new DlgOffsetImage(viewManager()->mainWindow(), "OffsetImage", offsetWrapRect().size());
         Q_CHECK_PTR(dlgOffsetImage);
 
         KUndo2MagicString actionName = kundo2_i18n("Offset Image");
         dlgOffsetImage->setCaption(i18nc("@title:window", "Offset Image"));
 
         if (dlgOffsetImage->exec() == QDialog::Accepted) {
             QPoint offsetPoint = QPoint(dlgOffsetImage->offsetX(), dlgOffsetImage->offsetY());
             offsetImpl(actionName, image->root(), offsetPoint);
         }
         delete dlgOffsetImage;
     }
     else
     {
         dbgKrita << "KisImage not available";
     }
 }
 
 
 void OffsetImage::slotOffsetLayer()
 {
-    KisImageSP image = m_view->image().toStrongRef();
+    KisImageSP image = viewManager()->image().toStrongRef();
     if (image) {
 
-        DlgOffsetImage * dlgOffsetImage = new DlgOffsetImage(m_view->mainWindow(), "OffsetLayer", offsetWrapRect().size());
+        DlgOffsetImage * dlgOffsetImage = new DlgOffsetImage(viewManager()->mainWindow(), "OffsetLayer", offsetWrapRect().size());
         Q_CHECK_PTR(dlgOffsetImage);
 
         KUndo2MagicString actionName = kundo2_i18n("Offset Layer");
         dlgOffsetImage->setCaption(i18nc("@title:window", "Offset Layer"));
 
         if (dlgOffsetImage->exec() == QDialog::Accepted) {
             QPoint offsetPoint = QPoint(dlgOffsetImage->offsetX(), dlgOffsetImage->offsetY());
-            KisNodeSP activeNode = m_view->activeNode();
+            KisNodeSP activeNode = viewManager()->activeNode();
             offsetImpl(actionName, activeNode, offsetPoint);
         }
         delete dlgOffsetImage;
     }
     else
     {
         dbgKrita << "KisImage not available";
     }
 }
 
 void OffsetImage::offsetImpl(const KUndo2MagicString& actionName, KisNodeSP node, const QPoint& offsetPoint)
 {
     KisImageSignalVector emitSignals;
     emitSignals << ModifiedSignal;
 
-    KisProcessingApplicator applicator(m_view->image(), node,
+    KisProcessingApplicator applicator(viewManager()->image(), node,
                                        KisProcessingApplicator::RECURSIVE,
                                        emitSignals, actionName);
 
     QRect rc = offsetWrapRect();
     KisProcessingVisitorSP visitor = new KisOffsetProcessingVisitor(offsetPoint, rc);
     applicator.applyVisitor(visitor, KisStrokeJobData::CONCURRENT);
     applicator.end();
 }
 
 
 QRect OffsetImage::offsetWrapRect()
 {
     QRect offsetWrapRect;
-    if (m_view->selection())
+    if (viewManager()->selection())
     {
-        offsetWrapRect = m_view->selection()->selectedExactRect();
+        offsetWrapRect = viewManager()->selection()->selectedExactRect();
     }
     else
     {
-        KisImageSP image = m_view->image().toStrongRef();
+        KisImageSP image = viewManager()->image().toStrongRef();
         if (image) {
             offsetWrapRect = image->bounds();
         }
     }
     return offsetWrapRect;
 }
 
 
 
 #include "offsetimage.moc"
diff --git a/plugins/extensions/offsetimage/offsetimage.h b/plugins/extensions/offsetimage/offsetimage.h
index 6f6f2b6c0d..05fb79296e 100644
--- a/plugins/extensions/offsetimage/offsetimage.h
+++ b/plugins/extensions/offsetimage/offsetimage.h
@@ -1,49 +1,49 @@
 /*
  * Copyright (c) 2013 Lukáš Tvrdý <lukast.dev@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef OFFSETIMAGE_H
 #define OFFSETIMAGE_H
 
 #include <QVariant>
 
-#include <kis_view_plugin.h>
+#include <KisActionPlugin.h>
 #include <kis_types.h>
 #include <kis_node.h>
 
 class KUndo2MagicString;
 
 
-class OffsetImage : public KisViewPlugin
+class OffsetImage : public KisActionPlugin
 {
     Q_OBJECT
 public:
     OffsetImage(QObject *parent, const QVariantList &);
     ~OffsetImage() override;
 
 public Q_SLOTS:
 
     void slotOffsetImage();
     void slotOffsetLayer();
 
     void offsetImpl(const KUndo2MagicString &actionName, KisNodeSP node, const QPoint &offsetPoint);
 private:
     QRect offsetWrapRect();
 
 };
 
 #endif // OFFSETIMAGE_H
diff --git a/plugins/extensions/pykrita/plugin/kritapykrita.json b/plugins/extensions/pykrita/plugin/kritapykrita.json
index 9b13672f2a..6f22461e23 100644
--- a/plugins/extensions/pykrita/plugin/kritapykrita.json
+++ b/plugins/extensions/pykrita/plugin/kritapykrita.json
@@ -1,9 +1,9 @@
 {
     "Id": "Python Plugin Manager",
     "Type": "Service",
     "X-KDE-Library": "kritapykrita",
     "X-KDE-ServiceTypes": [
-        "Krita/ViewPlugin"
+        "Krita/ApplicationPlugin"
     ],
     "X-Krita-Version": "28"
 }
diff --git a/plugins/extensions/pykrita/plugin/plugin.cpp b/plugins/extensions/pykrita/plugin/plugin.cpp
index 207231e965..f97c9f6045 100644
--- a/plugins/extensions/pykrita/plugin/plugin.cpp
+++ b/plugins/extensions/pykrita/plugin/plugin.cpp
@@ -1,95 +1,95 @@
 /*
  * Copyright (c) 2014 Boudewijn Rempt (boud@valdyas.org)
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2 of the License.
  *
  *  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 Lesser General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "plugin.h"
 
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 #include <kpluginfactory.h>
 
 #include <kis_preference_set_registry.h>
 #include "pyqtpluginsettings.h"
 
 #include <Krita.h>
 
 K_PLUGIN_FACTORY_WITH_JSON(KritaPyQtPluginFactory, "kritapykrita.json", registerPlugin<KritaPyQtPlugin>();)
 
 KritaPyQtPlugin::KritaPyQtPlugin(QObject *parent, const QVariantList &)
-    : KisViewPlugin(parent)
+    : KisActionPlugin(parent)
     , m_autoReload(false)
 {
     qDebug() << "Loading Python plugin";
 
     PyKrita::InitResult initResult = PyKrita::initialize();
     switch (initResult) {
         case PyKrita::INIT_OK:
             break;
         case PyKrita::INIT_CANNOT_LOAD_PYTHON_LIBRARY:
             qWarning() << i18n("Cannot load Python library");
             return;
         case PyKrita::INIT_CANNOT_SET_PYTHON_PATHS:
             qWarning() << i18n("Cannot set Python paths");
             return;
         case PyKrita::INIT_CANNOT_LOAD_PYKRITA_MODULE:
             qWarning() << i18n("Cannot load built-in pykrita module");
             return;
         default:
             qWarning() << i18n("Unexpected error initializing python plugin.");
             return;
     }
 
     pluginManager = PyKrita::pluginManager();
 
     KisPreferenceSetRegistry *preferenceSetRegistry = KisPreferenceSetRegistry::instance();
     PyQtPluginSettingsFactory* settingsFactory = new PyQtPluginSettingsFactory(pluginManager);
 
     //load and save preferences
     //if something in kritarc is missing, then the default from this load function will be used and saved back to kconfig.
     //this way, cfg.readEntry() in any part won't be able to set its own default
     KisPreferenceSet* settings = settingsFactory->createPreferenceSet();
     KIS_SAFE_ASSERT_RECOVER_RETURN(settings);
     settings->loadPreferences();
     settings->savePreferences();
     delete settings;
 
     preferenceSetRegistry->add("PyQtPluginSettingsFactory", settingsFactory);
 
     // Try to import the `pykrita` module
     PyKrita::Python py = PyKrita::Python();
     PyObject* pykritaPackage = py.moduleImport("pykrita");
     pykritaPackage = py.moduleImport("krita");
 
     if (pykritaPackage) {
         dbgScript << "Loaded pykrita, now load plugins";
         pluginManager->scanPlugins();
         pluginManager->tryLoadEnabledPlugins();
         //py.functionCall("_pykritaLoaded", PyKrita::Python::PYKRITA_ENGINE);
     } else  {
         dbgScript << "Cannot load pykrita module";
     }
 
-    Q_FOREACH (Extension* ext, Krita::instance()->extensions()) {
-        ext->setup();
+    Q_FOREACH (Extension *extension, Krita::instance()->extensions()) {
+        extension->setup();
     }
 }
 
 KritaPyQtPlugin::~KritaPyQtPlugin()
 {
     PyKrita::finalize();
 }
 
 #include "plugin.moc"
diff --git a/plugins/extensions/pykrita/plugin/plugin.h b/plugins/extensions/pykrita/plugin/plugin.h
index afac770a74..f7fbe40cdd 100644
--- a/plugins/extensions/pykrita/plugin/plugin.h
+++ b/plugins/extensions/pykrita/plugin/plugin.h
@@ -1,41 +1,41 @@
 /*
  * This file is part of PyKrita, Krita' Python scripting plugin.
  *
  * Copyright (C) 2013 Alex Turbov <i.zaufi@gmail.com>
  * Copyright (C) 2014-2016 Boudewijn Rempt <boud@valdyas.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) version 3.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 #ifndef _PYQT_PLUGIN_H_
 #define _PYQT_PLUGIN_H_
 
 #include <QObject>
 
-#include <kis_view_plugin.h>
+#include <KisActionPlugin.h>
 #include "PythonPluginManager.h"
 
-class KritaPyQtPlugin : public KisViewPlugin
+class KritaPyQtPlugin : public KisActionPlugin
 {
     Q_OBJECT
 public:
     KritaPyQtPlugin(QObject *parent, const QVariantList &);
     virtual ~KritaPyQtPlugin();
 private:
     PythonPluginManager *pluginManager;
     bool m_autoReload;
 };
 
 #endif
diff --git a/plugins/extensions/pykrita/sip/krita/Action.sip b/plugins/extensions/pykrita/sip/krita/Action.sip
index 28a2b4e51d..f5f1e1c4bb 100644
--- a/plugins/extensions/pykrita/sip/krita/Action.sip
+++ b/plugins/extensions/pykrita/sip/krita/Action.sip
@@ -1,38 +1,37 @@
 class Action : QObject
 {
 %TypeHeaderCode
 #include "Action.h"
 %End
 
 public:
     explicit Action(QObject *parent /TransferThis/ = 0);
     Action(const QString &name, QAction* action, QObject *parent /TransferThis/ = 0);
     virtual ~Action();
     bool operator==(const Action &other) const;
     bool operator!=(const Action &other) const;
 public Q_SLOTS:
     QString text() const;
     void setText(QString text);
     QString name() const;
     void setName(QString value);
     bool isCheckable() const;
     void setCheckable(bool value);
     bool isChecked() const;
     void setChecked(bool value);
     QString shortcut() const;
     void setShortcut(QString value);
     bool isVisible() const;
     void setVisible(bool value);
     bool isEnabled() const;
     void setEnabled(bool value);
     void setToolTip(QString tooltip);
     QString tooltip() const;
     void trigger();
-    void setMenu(const QString menu);
-    QString menu() const;
+
 Q_SIGNALS:
     void triggered(bool);
 private:
     private:
     Action(const Action &); // Generated
 };
diff --git a/plugins/extensions/pykrita/sip/krita/Extension.sip b/plugins/extensions/pykrita/sip/krita/Extension.sip
index 78ffa9d6f0..92babb2855 100644
--- a/plugins/extensions/pykrita/sip/krita/Extension.sip
+++ b/plugins/extensions/pykrita/sip/krita/Extension.sip
@@ -1,11 +1,12 @@
 class Extension : QObject
 {
 
 %TypeHeaderCode
 #include "Extension.h"
 %End
 
 public:
     explicit Extension(QObject *parent  /TransferThis/ = 0);
     virtual void setup() = 0;
+    virtual void createActions(Window *window) = 0;
 };
diff --git a/plugins/extensions/pykrita/sip/krita/Krita.sip b/plugins/extensions/pykrita/sip/krita/Krita.sip
index 21e8f12900..1d77a00b20 100644
--- a/plugins/extensions/pykrita/sip/krita/Krita.sip
+++ b/plugins/extensions/pykrita/sip/krita/Krita.sip
@@ -1,64 +1,63 @@
 
 class Krita : QObject
 {
 %TypeHeaderCode
 #include "Krita.h"
 %End
 public:
     Krita(QObject*  parent /TransferThis/ = 0);
     virtual ~Krita();
 public Q_SLOTS:
 
     Document * activeDocument() const /Factory/;
     void setActiveDocument(Document*  value);
     bool batchmode() const;
     void setBatchmode(bool value);
     QList<Action *> actions() const /Factory/;
     Action * action(const QString & name) const;
     QList<Document *> documents() const /Factory/;
     QStringList filters() const;
     Filter * filter(const QString &name) const /Factory/;
     QStringList colorModels() const;
     QStringList colorDepths(const QString &colorModel) const;
     QStringList filterStrategies() const;
     QStringList profiles(const QString &colorModel, const QString &ColorDepth) const;
     bool addProfile(const QString &profilePath);
     Notifier * notifier() const;
     QString version() const;
     QList<View *> views() const /Factory/;
     Window * activeWindow() const /Factory/;
     QList<Window *> windows() const /Factory/;
     QMap<QString, Resource *> resources(const QString &type) const /Factory/;
     QStringList recentDocuments() const;
     Document * createDocument(int width, int height, const QString &name, const QString &colorModel, const QString &colorDepth, const QString &profile, double resolution)  /Factory/;
     QList<Extension*> extensions() /Factory/;
     Document * openDocument(const QString &filename)  /Factory/;
     Window * openWindow();
-    Action * createAction(const QString &id, const QString & text, bool addToScriptMenu = true);
     QIcon icon(QString &iconName) const;
 
     void addExtension(Extension* _extension /GetWrapper/);
 %MethodCode
         Py_BEGIN_ALLOW_THREADS
         sipCpp->addExtension(a0);
         Py_END_ALLOW_THREADS
 
         sipTransferTo(a0Wrapper, Py_None);
 %End
     void addDockWidgetFactory(DockWidgetFactoryBase* _factory /GetWrapper/);
 %MethodCode
         Py_BEGIN_ALLOW_THREADS
         sipCpp->addDockWidgetFactory(a0);
         Py_END_ALLOW_THREADS
 
         sipTransferTo(a0Wrapper, Py_None);
 %End
 
     void writeSetting(const QString &group, const QString &name, const QString &value);
     QString readSetting(const QString &group, const QString &name, const QString &defaultValue);
 
     static Krita * instance();
     static QObject * fromVariant(const QVariant & v);
 private:
     Krita(const Krita &); // Generated
 };
diff --git a/plugins/extensions/pykrita/sip/krita/Window.sip b/plugins/extensions/pykrita/sip/krita/Window.sip
index fca6cbed71..aa578cb58b 100644
--- a/plugins/extensions/pykrita/sip/krita/Window.sip
+++ b/plugins/extensions/pykrita/sip/krita/Window.sip
@@ -1,22 +1,23 @@
 class Window : QObject
 {
 %TypeHeaderCode
 #include "Window.h"
 %End
     Window(const Window & __0);
 public:
     bool operator==(const Window &other) const;
     bool operator!=(const Window &other) const;
 
 public Q_SLOTS:
     QMainWindow *qwindow() const;
     QList<View *> views() const /Factory/;
     View *addView(Document *document)  /Factory/;
     void showView(View *view);
     View *activeView() const /Factory/;
     void activate();
     void close();
+    QAction *createAction(const QString &id, const QString &text = QString(), const QString &menuLocation = QString("tools/scripts"));
 Q_SIGNALS:
     void windowClosed();
 private:
 };
diff --git a/plugins/extensions/qmic/QMic.cpp b/plugins/extensions/qmic/QMic.cpp
index a9e0f974b9..23bec70ed0 100644
--- a/plugins/extensions/qmic/QMic.cpp
+++ b/plugins/extensions/qmic/QMic.cpp
@@ -1,464 +1,464 @@
 /*
  * Copyright (c) 2017 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 "QMic.h"
 
 #include <QApplication>
 #include <QDebug>
 #include <QFileInfo>
 #include <QLocalSocket>
 #include <QBuffer>
 #include <QByteArray>
 #include <QDataStream>
 #include <QProcess>
 #include <QLocalServer>
 #include <QVBoxLayout>
 #include <QUuid>
 #include <QList>
 #include <QSharedPointer>
 #include <QMultiMap>
 #include <QSharedMemory>
 #include <QMessageBox>
 
 #include <klocalizedstring.h>
 #include <kpluginfactory.h>
 
 #include <KoDialog.h>
 #include <KoColorSpaceConstants.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorSpace.h>
 #include <KoColorModelStandardIds.h>
 #include <KoColorSpaceTraits.h>
 
 #include <KisPart.h>
 #include <KisViewManager.h>
 #include <kis_action.h>
 #include <kis_config.h>
 #include <kis_preference_set_registry.h>
 #include <kis_image.h>
 #include <kis_paint_device.h>
 #include <kis_layer.h>
 #include <kis_selection.h>
 #include <kis_paint_layer.h>
 #include <kis_algebra_2d.h>
 
 #include "kis_input_output_mapper.h"
 #include "kis_qmic_simple_convertor.h"
 #include "kis_import_qmic_processing_visitor.h"
 #include <PluginSettings.h>
 
 #include "kis_qmic_applicator.h"
 
 static const char ack[] = "ack";
 
 K_PLUGIN_FACTORY_WITH_JSON(QMicFactory, "kritaqmic.json", registerPlugin<QMic>();)
 
 QMic::QMic(QObject *parent, const QVariantList &)
-    : KisViewPlugin(parent)
+    : KisActionPlugin(parent)
     , m_gmicApplicator(0)
 {
 #ifndef Q_OS_MAC
     KisPreferenceSetRegistry *preferenceSetRegistry = KisPreferenceSetRegistry::instance();
     PluginSettingsFactory* settingsFactory = new PluginSettingsFactory();
     preferenceSetRegistry->add("QMicPluginSettingsFactory", settingsFactory);
 
     m_qmicAction = createAction("QMic");
     m_qmicAction->setActivationFlags(KisAction::ACTIVE_DEVICE);
 
     connect(m_qmicAction ,  SIGNAL(triggered()), this, SLOT(slotQMic()));
 
     m_againAction = createAction("QMicAgain");
     m_againAction->setActivationFlags(KisAction::ACTIVE_DEVICE);
     m_againAction->setEnabled(false);
     connect(m_againAction,  SIGNAL(triggered()), this, SLOT(slotQMicAgain()));
 
     m_gmicApplicator = new KisQmicApplicator();
     connect(m_gmicApplicator, SIGNAL(gmicFinished(bool, int, QString)), this, SLOT(slotGmicFinished(bool, int, QString)));
 #endif
 }
 
 QMic::~QMic()
 {
     Q_FOREACH(QSharedMemory *memorySegment, m_sharedMemorySegments) {
 //        qDebug() << "detaching" << memorySegment->key();
         memorySegment->detach();
     }
     qDeleteAll(m_sharedMemorySegments);
     m_sharedMemorySegments.clear();
 
     if (m_pluginProcess) {
         m_pluginProcess->close();
     }
 
     delete m_gmicApplicator;
     delete m_localServer;
 }
 
 void QMic::slotQMicAgain()
 {
     slotQMic(true);
 }
 
 void QMic::slotQMic(bool again)
 {
     m_qmicAction->setEnabled(false);
     m_againAction->setEnabled(false);
 
     // find the krita-gmic-qt plugin
     QString pluginPath = PluginSettings::gmicQtPath();
     if (pluginPath.isEmpty() || !QFileInfo(pluginPath).exists() || !QFileInfo(pluginPath).isFile()) {
         QMessageBox::warning(0, i18nc("@title:window", "Krita"), i18n("Krita cannot find the gmic-qt plugin."));
         return;
     }
 
     m_key = QUuid::createUuid().toString();
     m_localServer = new QLocalServer();
     m_localServer->listen(m_key);
     connect(m_localServer, SIGNAL(newConnection()), SLOT(connected()));
     m_pluginProcess = new QProcess(this);
-    connect(m_view, SIGNAL(destroyed(QObject *o)), m_pluginProcess, SLOT(terminate()));
+    connect(viewManager(), SIGNAL(destroyed(QObject *o)), m_pluginProcess, SLOT(terminate()));
     m_pluginProcess->setProcessChannelMode(QProcess::ForwardedChannels);
     connect(m_pluginProcess, SIGNAL(finished(int, QProcess::ExitStatus)), this, SLOT(pluginFinished(int,QProcess::ExitStatus)));
     connect(m_pluginProcess, SIGNAL(stateChanged(QProcess::ProcessState)), this, SLOT(pluginStateChanged(QProcess::ProcessState)));
     m_pluginProcess->start(pluginPath, QStringList() << m_key << (again ? QString(" reapply") : QString()));
 
     bool r = m_pluginProcess->waitForStarted();
     while (m_pluginProcess->waitForFinished(10)) {
         qApp->processEvents(QEventLoop::ExcludeUserInputEvents);
     }
     qDebug() << "Plugin started" << r << m_pluginProcess->state();
 }
 
 void QMic::connected()
 {
     qDebug() << "connected";
-    if (!m_view) return;
+    if (!viewManager()) return;
 
     QLocalSocket *socket = m_localServer->nextPendingConnection();
     if (!socket) { return; }
 
     while (socket->bytesAvailable() < static_cast<int>(sizeof(quint32))) {
         if (!socket->isValid()) { // stale request
             return;
         }
         socket->waitForReadyRead(1000);
     }
     QDataStream ds(socket);
 
     QByteArray msg;
     quint32 remaining;
     ds >> remaining;
     msg.resize(remaining);
     int got = 0;
     char* uMsgBuf = msg.data();
     // FIXME: Should use read transaction for Qt >= 5.7:
     //        https://doc.qt.io/qt-5/qdatastream.html#using-read-transactions
     do {
         got = ds.readRawData(uMsgBuf, remaining);
         remaining -= got;
         uMsgBuf += got;
     }
     while (remaining && got >= 0 && socket->waitForReadyRead(2000));
 
     if (got < 0) {
         qWarning() << "Message reception failed" << socket->errorString();
         delete socket;
         m_localServer->close();
         delete m_localServer;
         m_localServer = 0;
         return;
     }
 
     QString message = QString::fromUtf8(msg);
     qDebug() << "Received" << message;
 
     // Check the message: we can get three different ones
     QMultiMap<QString, QString> messageMap;
     Q_FOREACH(QString line, message.split('\n', QString::SkipEmptyParts)) {
         QList<QString> kv = line.split('=', QString::SkipEmptyParts);
         if (kv.size() == 2) {
             messageMap.insert(kv[0], kv[1]);
         }
         else {
             qWarning() << "line" << line << "is invalid.";
         }
     }
 
     if (!messageMap.contains("command")) {
         qWarning() << "Message did not contain a command";
         return;
     }
 
     int mode = 0;
     if (messageMap.contains("mode")) {
         mode = messageMap.values("mode").first().toInt();
     }
 
     QByteArray ba;
     QString messageBoxWarningText;
 
     if (messageMap.values("command").first() == "gmic_qt_get_image_size") {
-        KisSelectionSP selection = m_view->image()->globalSelection();
+        KisSelectionSP selection = viewManager()->image()->globalSelection();
 
         if (selection) {
             QRect selectionRect = selection->selectedExactRect();
             ba = QByteArray::number(selectionRect.width()) + "," + QByteArray::number(selectionRect.height());
         }
         else {
-            ba = QByteArray::number(m_view->image()->width()) + "," + QByteArray::number(m_view->image()->height());
+            ba = QByteArray::number(viewManager()->image()->width()) + "," + QByteArray::number(viewManager()->image()->height());
         }
     }
     else if (messageMap.values("command").first() == "gmic_qt_get_cropped_images") {
         // Parse the message, create the shared memory segments, and create a new message to send back and waid for ack
         QRectF cropRect(0.0, 0.0, 1.0, 1.0);
         if (!messageMap.contains("croprect") || messageMap.values("croprect").first().split(',', QString::SkipEmptyParts).size() != 4) {
             qWarning() << "gmic-qt didn't send a croprect or not a valid croprect";
         }
         else {
             QStringList cr = messageMap.values("croprect").first().split(',', QString::SkipEmptyParts);
             cropRect.setX(cr[0].toFloat());
             cropRect.setY(cr[1].toFloat());
             cropRect.setWidth(cr[2].toFloat());
             cropRect.setHeight(cr[3].toFloat());
         }
         if (!prepareCroppedImages(&ba, cropRect, mode)) {
             qWarning() << "Failed to prepare images for gmic-qt";
         }
     }
     else if (messageMap.values("command").first() == "gmic_qt_output_images") {
         // Parse the message. read the shared memory segments, fix up the current image and send an ack
         qDebug() << "gmic_qt_output_images";
         QStringList layers = messageMap.values("layer");
         m_outputMode = (OutputMode)mode;
         if (m_outputMode != IN_PLACE) {
             messageBoxWarningText = i18n("Sorry, this output mode is not implemented yet.");
             m_outputMode = IN_PLACE;
         }
         slotStartApplicator(layers);
     }
     else if (messageMap.values("command").first() == "gmic_qt_detach") {
         Q_FOREACH(QSharedMemory *memorySegment, m_sharedMemorySegments) {
             qDebug() << "detaching" << memorySegment->key() << memorySegment->isAttached();
             if (memorySegment->isAttached()) {
                 if (!memorySegment->detach()) {
                     qDebug() << "\t" << memorySegment->error() << memorySegment->errorString();
                 }
             }
         }
         qDeleteAll(m_sharedMemorySegments);
         m_sharedMemorySegments.clear();
     }
     else {
         qWarning() << "Received unknown command" << messageMap.values("command");
     }
 
     qDebug() << "Sending" << QString::fromUtf8(ba);
 
     // HACK: Make sure QDataStream does not refuse to write!
     // Proper fix: Change the above read to use read transaction
     ds.resetStatus();
     ds.writeBytes(ba.constData(), ba.length());
     // Flush the socket because we might not return to the event loop!
     if (!socket->waitForBytesWritten(2000)) {
         qWarning() << "Failed to write response:" << socket->error();
     }
 
     // Wait for the ack
     bool r = true;
     r &= socket->waitForReadyRead(2000); // wait for ack
     r &= (socket->read(qstrlen(ack)) == ack);
     if (!socket->waitForDisconnected(2000)) {
         qWarning() << "Remote not disconnected:" << socket->error();
         // Wait again
         socket->disconnectFromServer();
         if (socket->waitForDisconnected(2000)) {
             qWarning() << "Disconnect timed out:" << socket->error();
         }
     }
 
     if (!messageBoxWarningText.isEmpty()) {
         // Defer the message box to the event loop
         QTimer::singleShot(0, [messageBoxWarningText]() {
             QMessageBox::warning(KisPart::instance()->currentMainwindow(), i18nc("@title:window", "Krita"), messageBoxWarningText);
         });
     }
 }
 
 void QMic::pluginStateChanged(QProcess::ProcessState state)
 {
     qDebug() << "stateChanged" << state;
 }
 
 void QMic::pluginFinished(int exitCode, QProcess::ExitStatus exitStatus)
 {
     qDebug() << "pluginFinished" << exitCode << exitStatus;
     delete m_pluginProcess;
     m_pluginProcess = 0;
     delete m_localServer;
     m_localServer = 0;
     m_qmicAction->setEnabled(true);
     m_againAction->setEnabled(true);
 }
 
 void QMic::slotGmicFinished(bool successfully, int milliseconds, const QString &msg)
 {
     qDebug() << "slotGmicFinished();" << successfully << milliseconds << msg;
     if (successfully) {
         m_gmicApplicator->finish();
     }
     else {
         m_gmicApplicator->cancel();
         QMessageBox::warning(0, i18nc("@title:window", "Krita"), i18n("G'Mic failed, reason:") + msg);
     }
 }
 
 void QMic::slotStartApplicator(QStringList gmicImages)
 {
     qDebug() << "slotStartApplicator();" << gmicImages;
-    if (!m_view) return;
+    if (!viewManager()) return;
     // Create a vector of gmic images
 
     QVector<gmic_image<float> *> images;
 
     Q_FOREACH(const QString &image, gmicImages) {
         QStringList parts = image.split(',', QString::SkipEmptyParts);
         Q_ASSERT(parts.size() == 4);
         QString key = parts[0];
         QString layerName = QByteArray::fromHex(parts[1].toLatin1());
         int spectrum = parts[2].toInt();
         int width = parts[3].toInt();
         int height = parts[4].toInt();
 
         qDebug() << key << layerName << width << height;
 
         QSharedMemory m(key);
         if (!m.attach(QSharedMemory::ReadOnly)) {
             qWarning() << "Could not attach to shared memory area." << m.error() << m.errorString();
         }
         if (m.isAttached()) {
             if (!m.lock()) {
                 qDebug() << "Could not lock memeory segment"  << m.error() << m.errorString();
             }
             qDebug() << "Memory segment" << key << m.size() << m.constData() << m.data();
             gmic_image<float> *gimg = new gmic_image<float>();
             gimg->assign(width, height, 1, spectrum);
             gimg->name = layerName;
 
             gimg->_data = new float[width * height * spectrum * sizeof(float)];
             qDebug() << "width" << width << "height" << height << "size" << width * height * spectrum * sizeof(float) << "shared memory size" << m.size();
             memcpy(gimg->_data, m.constData(), width * height * spectrum * sizeof(float));
 
             qDebug() << "created gmic image" << gimg->name << gimg->_width << gimg->_height;
 
             if (!m.unlock()) {
                 qDebug() << "Could not unlock memeory segment"  << m.error() << m.errorString();
             }
             if (!m.detach()) {
                 qDebug() << "Could not detach from memeory segment"  << m.error() << m.errorString();
             }
             images.append(gimg);
         }
     }
 
     qDebug() << "Got" << images.size() << "gmic images";
 
     // Start the applicator
     KUndo2MagicString actionName = kundo2_i18n("Gmic filter");
-    KisNodeSP rootNode = m_view->image()->root();
-    KisInputOutputMapper mapper(m_view->image(), m_view->activeNode());
+    KisNodeSP rootNode = viewManager()->image()->root();
+    KisInputOutputMapper mapper(viewManager()->image(), viewManager()->activeNode());
     KisNodeListSP layers = mapper.inputNodes(m_inputMode);
 
-    m_gmicApplicator->setProperties(m_view->image(), rootNode, images, actionName, layers);
+    m_gmicApplicator->setProperties(viewManager()->image(), rootNode, images, actionName, layers);
     m_gmicApplicator->preview();
     m_gmicApplicator->finish();
 }
 
 bool QMic::prepareCroppedImages(QByteArray *message, QRectF &rc, int inputMode)
 {
-    if (!m_view) return false;
+    if (!viewManager()) return false;
 
-    m_view->image()->lock();
+    viewManager()->image()->lock();
 
     m_inputMode = (InputLayerMode)inputMode;
 
     qDebug() << "prepareCroppedImages()" << QString::fromUtf8(*message) << rc << inputMode;
 
-    KisInputOutputMapper mapper(m_view->image(), m_view->activeNode());
+    KisInputOutputMapper mapper(viewManager()->image(), viewManager()->activeNode());
     KisNodeListSP nodes = mapper.inputNodes(m_inputMode);
     if (nodes->isEmpty()) {
-        m_view->image()->unlock();
+        viewManager()->image()->unlock();
         return false;
     }
 
     for (int i = 0; i < nodes->size(); ++i) {
         KisNodeSP node = nodes->at(i);
         if (node && node->paintDevice()) {
             QRect cropRect;
 
-            KisSelectionSP selection = m_view->image()->globalSelection();
+            KisSelectionSP selection = viewManager()->image()->globalSelection();
 
             if (selection) {
                 cropRect = selection->selectedExactRect();
             }
             else {
-                cropRect = m_view->image()->bounds();
+                cropRect = viewManager()->image()->bounds();
             }
 
             qDebug() << "Converting node" << node->name() << cropRect;
 
             const QRectF mappedRect = KisAlgebra2D::mapToRect(cropRect).mapRect(rc);
             const QRect resultRect = mappedRect.toAlignedRect();
 
             QSharedMemory *m = new QSharedMemory(QString("key_%1").arg(QUuid::createUuid().toString()));
             m_sharedMemorySegments.append(m);
             if (!m->create(resultRect.width() * resultRect.height() * 4 * sizeof(float))) {  //buf.size())) {
                 qWarning() << "Could not create shared memory segment" << m->error() << m->errorString();
                 return false;
             }
             m->lock();
 
             gmic_image<float> img;
             img.assign(resultRect.width(), resultRect.height(), 1, 4);
             img._data = reinterpret_cast<float*>(m->data());
 
             KisQmicSimpleConvertor::convertToGmicImageFast(node->paintDevice(), &img, resultRect);
 
             message->append(m->key().toUtf8());
 
             m->unlock();
 
             message->append(",");
             message->append(node->name().toUtf8().toHex());
             message->append(",");
             message->append(QByteArray::number(resultRect.width()));
             message->append(",");
             message->append(QByteArray::number(resultRect.height()));
 
             message->append("\n");
         }
     }
 
     qDebug() << QString::fromUtf8(*message);
 
-    m_view->image()->unlock();
+    viewManager()->image()->unlock();
 
     return true;
 }
 
 
 #include "QMic.moc"
diff --git a/plugins/extensions/qmic/QMic.h b/plugins/extensions/qmic/QMic.h
index 95f9564980..f839112d03 100644
--- a/plugins/extensions/qmic/QMic.h
+++ b/plugins/extensions/qmic/QMic.h
@@ -1,69 +1,69 @@
 /*
  * Copyright (c) 2017 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 QMIC_H
 #define QMIC_H
 
 #include <QProcess>
 #include <QVariant>
 #include <QVector>
-#include <kis_view_plugin.h>
+#include <KisActionPlugin.h>
 #include <kis_types.h>
 
 #include "gmic.h"
 
 class KisAction;
 class QLocalServer;
 class QSharedMemory;
 
 class KisQmicApplicator;
 
-class QMic : public KisViewPlugin
+class QMic : public KisActionPlugin
 {
     Q_OBJECT
 public:
     QMic(QObject *parent, const QVariantList &);
     virtual ~QMic();
 
 private Q_SLOTS:
 
     void slotQMicAgain();
     void slotQMic(bool again = false);
     void connected();
     void pluginStateChanged(QProcess::ProcessState);
     void pluginFinished(int exitCode, QProcess::ExitStatus exitStatus);
     void slotGmicFinished(bool successfully, int milliseconds = -1, const QString& msg = QString());
     void slotStartApplicator(QStringList gmicImages);
 
 private:
 
     bool prepareCroppedImages(QByteArray *message, QRectF &rc, int inputMode);
 
     QProcess *m_pluginProcess {0};
     QLocalServer *m_localServer {0};
     QString m_key;
     KisAction *m_qmicAction {0};
     KisAction *m_againAction {0};
     QVector<QSharedMemory *> m_sharedMemorySegments;
     KisQmicApplicator *m_gmicApplicator {0};
     InputLayerMode m_inputMode {ACTIVE_LAYER};
     OutputMode m_outputMode {IN_PLACE};
 
 };
 
 #endif // QMic_H
diff --git a/plugins/extensions/resourcemanager/dlg_bundle_manager.cpp b/plugins/extensions/resourcemanager/dlg_bundle_manager.cpp
index 4d6bb964bc..b27a3c1d25 100644
--- a/plugins/extensions/resourcemanager/dlg_bundle_manager.cpp
+++ b/plugins/extensions/resourcemanager/dlg_bundle_manager.cpp
@@ -1,415 +1,415 @@
 /*
  *  Copyright (c) 2014 Victor Lafon metabolic.ewilan@hotmail.fr
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 #include "dlg_bundle_manager.h"
 #include "ui_wdgdlgbundlemanager.h"
 
 #include "resourcemanager.h"
 #include "dlg_create_bundle.h"
 
 #include <QListWidget>
 #include <QTreeWidget>
 #include <QListWidgetItem>
 #include <QPainter>
 #include <QPixmap>
 #include <QMessageBox>
 
 #include <kis_icon.h>
 #include "kis_action.h"
 #include <kis_resource_server_provider.h>
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 
 #define ICON_SIZE 48
 
 DlgBundleManager::DlgBundleManager(ResourceManager *resourceManager, KisActionManager* actionMgr, QWidget *parent)
     : KoDialog(parent)
     , m_page(new QWidget())
     , m_ui(new Ui::WdgDlgBundleManager)
     , m_currentBundle(0)
     , m_resourceManager(resourceManager)
 {
     setCaption(i18n("Manage Resource Bundles"));
     m_ui->setupUi(m_page);
     setMainWidget(m_page);
     resize(m_page->sizeHint());
     setButtons(Ok | Cancel);
     setDefaultButton(Ok);
 
     m_ui->listActive->setIconSize(QSize(ICON_SIZE, ICON_SIZE));
     m_ui->listActive->setSelectionMode(QAbstractItemView::SingleSelection);
     connect(m_ui->listActive, SIGNAL(currentItemChanged(QListWidgetItem*,QListWidgetItem*)), SLOT(itemSelected(QListWidgetItem*,QListWidgetItem*)));
     connect(m_ui->listActive, SIGNAL(itemClicked(QListWidgetItem*)), SLOT(itemSelected(QListWidgetItem*)));
 
     m_ui->listInactive->setIconSize(QSize(ICON_SIZE, ICON_SIZE));
     m_ui->listInactive->setSelectionMode(QAbstractItemView::SingleSelection);
     connect(m_ui->listInactive, SIGNAL(currentItemChanged(QListWidgetItem*,QListWidgetItem*)), SLOT(itemSelected(QListWidgetItem*,QListWidgetItem*)));
     connect(m_ui->listInactive, SIGNAL(itemClicked(QListWidgetItem*)), SLOT(itemSelected(QListWidgetItem*)));
 
     m_ui->bnAdd->setIcon(KisIconUtils::loadIcon("arrow-right"));
     connect(m_ui->bnAdd, SIGNAL(clicked()), SLOT(addSelected()));
 
     m_ui->bnRemove->setIcon(KisIconUtils::loadIcon("arrow-left"));
     connect(m_ui->bnRemove, SIGNAL(clicked()), SLOT(removeSelected()));
 
     m_ui->listBundleContents->setHeaderLabel(i18n("Resource"));
     m_ui->listBundleContents->setSelectionMode(QAbstractItemView::NoSelection);
 
     m_actionManager = actionMgr;
 
     refreshListData();
 
     connect(m_ui->bnEditBundle, SIGNAL(clicked()), SLOT(editBundle()));
 
     connect(m_ui->bnImportBrushes, SIGNAL(clicked()), SLOT(slotImportResource()));
     connect(m_ui->bnImportGradients, SIGNAL(clicked()), SLOT(slotImportResource()));
     connect(m_ui->bnImportPalettes, SIGNAL(clicked()), SLOT(slotImportResource()));
     connect(m_ui->bnImportPatterns, SIGNAL(clicked()), SLOT(slotImportResource()));
     connect(m_ui->bnImportPresets, SIGNAL(clicked()), SLOT(slotImportResource()));
     connect(m_ui->bnImportWorkspaces, SIGNAL(clicked()), SLOT(slotImportResource()));
     connect(m_ui->bnImportBundles, SIGNAL(clicked()), SLOT(slotImportResource()));
 
 
     connect(m_ui->createBundleButton, SIGNAL(clicked()), SLOT(slotCreateBundle()));
     connect(m_ui->deleteBackupFilesButton, SIGNAL(clicked()), SLOT(slotDeleteBackupFiles()));
     connect(m_ui->openResourceFolderButton, SIGNAL(clicked()), SLOT(slotOpenResourceFolder()));
 
 }
 
 
 void DlgBundleManager::refreshListData()
 {
     KoResourceServer<KisResourceBundle> *bundleServer = KisResourceServerProvider::instance()->resourceBundleServer();
 
     m_ui->listInactive->clear();
     m_ui->listActive->clear();
 
     Q_FOREACH (const QString &f, bundleServer->blackListedFiles()) {
         KisResourceBundle *bundle = new KisResourceBundle(f);
         bundle->load();
         if (bundle->valid()) {
             bundle->setInstalled(false);
             m_blacklistedBundles[f] = bundle;
         }
     }
     fillListWidget(m_blacklistedBundles.values(), m_ui->listInactive);
 
     Q_FOREACH (KisResourceBundle *bundle, bundleServer->resources()) {
         if (bundle->valid()) {
             m_activeBundles[bundle->filename()] = bundle;
         }
     }
     fillListWidget(m_activeBundles.values(), m_ui->listActive);
 }
 
 void DlgBundleManager::accept()
 {
     KoResourceServer<KisResourceBundle> *bundleServer = KisResourceServerProvider::instance()->resourceBundleServer();
 
     for (int i = 0; i < m_ui->listActive->count(); ++i) {
         QListWidgetItem *item = m_ui->listActive->item(i);
         QByteArray ba = item->data(Qt::UserRole).toByteArray();
         KisResourceBundle *bundle = bundleServer->resourceByMD5(ba);
         QMessageBox bundleFeedback;
         bundleFeedback.setIcon(QMessageBox::Warning);
         QString feedback = "bundlefeedback";
 
         if (!bundle) {
             // Get it from the blacklisted bundles
             Q_FOREACH (KisResourceBundle *b2, m_blacklistedBundles.values()) {
                 if (b2->md5() == ba) {
                     bundle = b2;
                     break;
                 }
             }
         }
 
         if (bundle) {
             bool isKrita3Bundle = false;
-            if (bundle->filename().contains("Krita_3_Default_Resources.bundle")) {
+            if (bundle->filename().endsWith("Krita_3_Default_Resources.bundle")) {
                 isKrita3Bundle = true;
                 KConfigGroup group = KSharedConfig::openConfig()->group("BundleHack");
                 group.writeEntry("HideKrita3Bundle", false);
             }
             else {
                 if (!bundle->isInstalled()) {
                     bundle->install();
                     //this removes the bundle from the blacklist and add it to the server without saving or putting it in front//
                     if (!bundleServer->addResource(bundle, false, false)){
 
                         feedback = i18n("Couldn't add bundle to resource server");
                         bundleFeedback.setText(feedback);
                         bundleFeedback.exec();
                     }
                     if (!isKrita3Bundle) {
                         if (!bundleServer->removeFromBlacklist(bundle)) {
                             feedback = i18n("Couldn't remove bundle from blacklist");
                             bundleFeedback.setText(feedback);
                             bundleFeedback.exec();
                         }
                     }
                 }
                 else {
                     if (!isKrita3Bundle) {
                         bundleServer->removeFromBlacklist(bundle);
                     }
                     //let's assume that bundles that exist and are installed have to be removed from the blacklist, and if they were already this returns false, so that's not a problem.
                 }
             }
         }
         else{
             QString feedback = i18n("Bundle doesn't exist!");
             bundleFeedback.setText(feedback);
             bundleFeedback.exec();
 
         }
     }
 
     for (int i = 0; i < m_ui->listInactive->count(); ++i) {
         QListWidgetItem *item = m_ui->listInactive->item(i);
         QByteArray ba = item->data(Qt::UserRole).toByteArray();
         KisResourceBundle *bundle = bundleServer->resourceByMD5(ba);
         bool isKrits3Bundle = false;
         if (bundle) {
             if (bundle->filename().contains("Krita_3_Default_Resources.bundle")) {
                 isKrits3Bundle = true;
                 KConfigGroup group = KSharedConfig::openConfig()->group("BundleHack");
                 group.writeEntry("HideKrita3Bundle", true);
             }
             if (bundle->isInstalled()) {
                 bundle->uninstall();
                 if (!isKrits3Bundle) {
                     bundleServer->removeResourceAndBlacklist(bundle);
                 }
             }
         }
     }
 
 
     KoDialog::accept();
 }
 
 void DlgBundleManager::addSelected()
 {
     Q_FOREACH (QListWidgetItem *item, m_ui->listActive->selectedItems()) {
         m_ui->listInactive->addItem(m_ui->listActive->takeItem(m_ui->listActive->row(item)));
     }
 
 }
 
 void DlgBundleManager::removeSelected()
 {
     Q_FOREACH (QListWidgetItem *item, m_ui->listInactive->selectedItems()) {
         m_ui->listActive->addItem(m_ui->listInactive->takeItem(m_ui->listInactive->row(item)));
     }
 }
 
 void DlgBundleManager::itemSelected(QListWidgetItem *current, QListWidgetItem *)
 {
     if (!current) {
         m_ui->lblName->clear();
         m_ui->lblAuthor->clear();
         m_ui->lblEmail->clear();
         m_ui->lblLicense->clear();
         m_ui->lblWebsite->clear();
         m_ui->lblDescription->clear();
         m_ui->lblCreated->clear();
         m_ui->lblUpdated->clear();
         m_ui->lblPreview->setPixmap(QPixmap::fromImage(QImage()));
         m_ui->listBundleContents->clear();
         m_ui->bnEditBundle->setEnabled(false);
         m_currentBundle = 0;
     }
     else {
 
         QByteArray ba = current->data(Qt::UserRole).toByteArray();
         KoResourceServer<KisResourceBundle> *bundleServer = KisResourceServerProvider::instance()->resourceBundleServer();
         KisResourceBundle *bundle = bundleServer->resourceByMD5(ba);
 
         if (!bundle) {
             // Get it from the blacklisted bundles
             Q_FOREACH (KisResourceBundle *b2, m_blacklistedBundles.values()) {
                 if (b2->md5() == ba) {
                     bundle = b2;
                     break;
                 }
             }
         }
 
 
         if (bundle) {
 
             m_currentBundle = bundle;
             m_ui->bnEditBundle->setEnabled(true);
 
             m_ui->lblName->setText(bundle->name());
             m_ui->lblAuthor->setText(bundle->getMeta("author"));
             m_ui->lblEmail->setText(bundle->getMeta("email"));
             m_ui->lblLicense->setText(bundle->getMeta("license"));
             m_ui->lblWebsite->setText(bundle->getMeta("website"));
             m_ui->lblDescription->setPlainText(bundle->getMeta("description"));
             m_ui->lblCreated->setText(bundle->getMeta("created"));
             m_ui->lblUpdated->setText(bundle->getMeta("updated"));
             m_ui->lblPreview->setPixmap(QPixmap::fromImage(bundle->image().scaled(128, 128, Qt::KeepAspectRatio, Qt::SmoothTransformation)));
             m_ui->listBundleContents->clear();
 
             Q_FOREACH (const QString & resType, bundle->resourceTypes()) {
 
                 QTreeWidgetItem *toplevel = new QTreeWidgetItem();
                 if (resType == "gradients") {
                     toplevel->setText(0, i18n("Gradients"));
                 }
                 else if (resType  == "patterns") {
                     toplevel->setText(0, i18n("Patterns"));
                 }
                 else if (resType  == "brushes") {
                     toplevel->setText(0, i18n("Brushes"));
                 }
                 else if (resType  == "palettes") {
                     toplevel->setText(0, i18n("Palettes"));
                 }
                 else if (resType  == "workspaces") {
                     toplevel->setText(0, i18n("Workspaces"));
                 }
                 else if (resType  == "paintoppresets") {
                     toplevel->setText(0, i18n("Brush Presets"));
                 }
 
                 m_ui->listBundleContents->addTopLevelItem(toplevel);
 
                 Q_FOREACH (const KoResource *res, bundle->resources(resType)) {
                     if (res) {
                         QTreeWidgetItem *i = new QTreeWidgetItem();
                         i->setIcon(0, QIcon(QPixmap::fromImage(res->image())));
                         i->setText(0, res->name());
                         toplevel->addChild(i);
                     }
                 }
             }
         }
         else {
             m_currentBundle = 0;
         }
     }
 }
 
 void DlgBundleManager::itemSelected(QListWidgetItem *current)
 {
     itemSelected(current, 0);
 }
 
 void DlgBundleManager::editBundle()
 {
     if (m_currentBundle) {
         DlgCreateBundle dlg(m_currentBundle);
         m_activeBundles.remove(m_currentBundle->filename());
         m_currentBundle = 0;
         if (dlg.exec() != QDialog::Accepted) {
             return;
         }
         m_currentBundle = m_resourceManager->saveBundle(dlg);
         refreshListData();
     }
 }
 
 void DlgBundleManager::fillListWidget(QList<KisResourceBundle *> bundles, QListWidget *w)
 {
     w->setIconSize(QSize(ICON_SIZE, ICON_SIZE));
     w->setSelectionMode(QAbstractItemView::MultiSelection);
 
     Q_FOREACH (KisResourceBundle *bundle, bundles) {
         QPixmap pixmap(ICON_SIZE, ICON_SIZE);
         pixmap.fill(Qt::gray);
         if (!bundle->image().isNull()) {
             QImage scaled = bundle->image().scaled(ICON_SIZE, ICON_SIZE, Qt::KeepAspectRatio, Qt::SmoothTransformation);
             int x = (ICON_SIZE - scaled.width()) / 2;
             int y = (ICON_SIZE - scaled.height()) / 2;
             QPainter gc(&pixmap);
             gc.drawImage(x, y, scaled);
             gc.end();
         }
 
         QListWidgetItem *item = new QListWidgetItem(pixmap, bundle->name());
         item->setData(Qt::UserRole, bundle->md5());
         w->addItem(item);
     }
 }
 
 
 void DlgBundleManager::slotImportResource()
 {
     if (m_actionManager) {
         QObject *button = sender();
         QString buttonName = button->objectName();
         KisAction *action = 0;
         if (buttonName == "bnImportBundles") {
             action = m_actionManager->actionByName("import_bundles");
         }
         else if (buttonName == "bnImportBrushes") {
             action = m_actionManager->actionByName("import_brushes");
         }
         else if (buttonName == "bnImportGradients") {
             action = m_actionManager->actionByName("import_gradients");
         }
         else if (buttonName == "bnImportPalettes") {
             action = m_actionManager->actionByName("import_palettes");
         }
         else if (buttonName == "bnImportPatterns") {
             action = m_actionManager->actionByName("import_patterns");
         }
         else if (buttonName == "bnImportPresets") {
             action = m_actionManager->actionByName("import_presets");
         }
         else if (buttonName == "bnImportWorkspaces") {
             action = m_actionManager->actionByName("import_workspaces");
         }
         else {
             warnUI << "Unhandled bundle manager import button " << buttonName;
             return;
         }
 
         action->trigger();
         refreshListData();
     }
 }
 
 void DlgBundleManager::slotCreateBundle() {
 
     if (m_actionManager) {
         KisAction *action = m_actionManager->actionByName("create_bundle");
         action->trigger();
         refreshListData();
     }
 }
 
 void DlgBundleManager::slotDeleteBackupFiles() {
 
     if (m_actionManager) {
         KisAction *action = m_actionManager->actionByName("edit_blacklist_cleanup");
         action->trigger();
     }
 }
 
 void DlgBundleManager::slotOpenResourceFolder() {
 
     if (m_actionManager) {
         KisAction *action = m_actionManager->actionByName("open_resources_directory");
         action->trigger();
     }
 }
 
diff --git a/plugins/extensions/resourcemanager/resourcemanager.cpp b/plugins/extensions/resourcemanager/resourcemanager.cpp
index 5953a79c1d..20fc0b9837 100644
--- a/plugins/extensions/resourcemanager/resourcemanager.cpp
+++ b/plugins/extensions/resourcemanager/resourcemanager.cpp
@@ -1,328 +1,328 @@
 /*
  * resourcemanager.cc -- Part of Krita
  *
  * Copyright (c) 2004 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 "resourcemanager.h"
 
 #include <QDir>
 #include <QFileInfo>
 #include <QTimer>
 #include <QThread>
 
 #include <QMessageBox>
 #include <QGlobalStatic>
 #include <QStandardPaths>
 
 #include <klocalizedstring.h>
 #include <KoResourcePaths.h>
 #include <kpluginfactory.h>
 
 #include <KoFileDialog.h>
 #include <resources/KoResource.h>
 #include <KoResourceServer.h>
 #include <KoResourceServerProvider.h>
 
 #include <kis_debug.h>
 #include <kis_action.h>
 #include <KisViewManager.h>
 #include <kis_resource_server_provider.h>
 #include <kis_workspace_resource.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <kis_brush_server.h>
 #include <kis_paintop_settings.h>
 #include "dlg_bundle_manager.h"
 #include "dlg_create_bundle.h"
 #include <KisPaintopSettingsIds.h>
 #include "krita_container_utils.h"
 
 class ResourceManager::Private {
 
 public:
 
     Private()
     {
         brushServer = KisBrushServer::instance()->brushServer(false);
         paintopServer = KisResourceServerProvider::instance()->paintOpPresetServer(false);
         gradientServer = KoResourceServerProvider::instance()->gradientServer(false);
         patternServer = KoResourceServerProvider::instance()->patternServer(false);
         paletteServer = KoResourceServerProvider::instance()->paletteServer(false);
         workspaceServer = KisResourceServerProvider::instance()->workspaceServer(false);
     }
 
     KisBrushResourceServer* brushServer;
     KisPaintOpPresetResourceServer * paintopServer;
     KoResourceServer<KoAbstractGradient>* gradientServer;
     KoResourceServer<KoPattern> *patternServer;
     KoResourceServer<KoColorSet>* paletteServer;
     KoResourceServer<KisWorkspaceResource>* workspaceServer;
 
 };
 
 K_PLUGIN_FACTORY_WITH_JSON(ResourceManagerFactory, "kritaresourcemanager.json", registerPlugin<ResourceManager>();)
 
 ResourceManager::ResourceManager(QObject *parent, const QVariantList &)
-    : KisViewPlugin(parent)
+    : KisActionPlugin(parent)
     , d(new Private())
 {
     KisAction *action = new KisAction(i18n("Import Bundles..."), this);
     addAction("import_bundles", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotImportBundles()));
 
     action = new KisAction(i18n("Import Brushes..."), this);
     addAction("import_brushes", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotImportBrushes()));
 
     action = new KisAction(i18n("Import Gradients..."), this);
     addAction("import_gradients", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotImportGradients()));
 
     action = new KisAction(i18n("Import Palettes..."), this);
     addAction("import_palettes", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotImportPalettes()));
 
     action = new KisAction(i18n("Import Patterns..."), this);
     addAction("import_patterns", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotImportPatterns()));
 
     action = new KisAction(i18n("Import Presets..."), this);
     addAction("import_presets", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotImportPresets()));
 
     action = new KisAction(i18n("Import Workspaces..."), this);
     addAction("import_workspaces", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotImportWorkspaces()));
 
     action = new KisAction(i18n("Create Resource Bundle..."), this);
     addAction("create_bundle", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotCreateBundle()));
 
     action = new KisAction(i18n("Manage Resources..."), this);
     addAction("manage_bundles", action);
     connect(action, SIGNAL(triggered()), this, SLOT(slotManageBundles()));
 
 }
 
 ResourceManager::~ResourceManager()
 {
 }
 
 void ResourceManager::slotCreateBundle()
 {
     DlgCreateBundle dlgCreateBundle;
     if (dlgCreateBundle.exec() != QDialog::Accepted) {
         return;
     }
     saveBundle(dlgCreateBundle);
 }
 
 KisResourceBundle *ResourceManager::saveBundle(const DlgCreateBundle &dlgCreateBundle)
 {
     QString bundlePath =  dlgCreateBundle.saveLocation() + "/" + dlgCreateBundle.bundleName() + ".bundle";
 
     KisResourceBundle *newBundle = new KisResourceBundle(bundlePath);
 
     newBundle->addMeta("name", dlgCreateBundle.bundleName());
     newBundle->addMeta("author", dlgCreateBundle.authorName());
     newBundle->addMeta("email", dlgCreateBundle.email());
     newBundle->addMeta("license", dlgCreateBundle.license());
     newBundle->addMeta("website", dlgCreateBundle.website());
     newBundle->addMeta("description", dlgCreateBundle.description());
     newBundle->setThumbnail(dlgCreateBundle.previewImage());
 
     QStringList res = dlgCreateBundle.selectedBrushes();
     Q_FOREACH (const QString &r, res) {
         KoResource *res = d->brushServer->resourceByFilename(r).data();
         newBundle->addResource("kis_brushes", res->filename(), d->brushServer->assignedTagsList(res), res->md5());
     }
 
     res = dlgCreateBundle.selectedGradients();
     Q_FOREACH (const QString &r, res) {
         KoResource *res = d->gradientServer->resourceByFilename(r);
         newBundle->addResource("ko_gradients", res->filename(), d->gradientServer->assignedTagsList(res), res->md5());
     }
 
     res = dlgCreateBundle.selectedPalettes();
     Q_FOREACH (const QString &r, res) {
         KoResource *res = d->paletteServer->resourceByFilename(r);
         newBundle->addResource("ko_palettes", res->filename(), d->paletteServer->assignedTagsList(res), res->md5());
     }
 
     res = dlgCreateBundle.selectedPatterns();
     Q_FOREACH (const QString &r, res) {
         KoResource *res = d->patternServer->resourceByFilename(r);
         newBundle->addResource("ko_patterns", res->filename(), d->patternServer->assignedTagsList(res), res->md5());
     }
 
     res = dlgCreateBundle.selectedPresets();
     Q_FOREACH (const QString &r, res) {
         KisPaintOpPresetSP preset = d->paintopServer->resourceByFilename(r);
         KoResource *res = preset.data();
         newBundle->addResource("kis_paintoppresets", res->filename(), d->paintopServer->assignedTagsList(res), res->md5());
         KisPaintOpSettingsSP settings = preset->settings();
 
         QStringList requiredFiles = settings->getStringList(KisPaintOpUtils::RequiredBrushFilesListTag);
         requiredFiles << settings->getString(KisPaintOpUtils::RequiredBrushFileTag);
         KritaUtils::makeContainerUnique(requiredFiles);
 
         Q_FOREACH (const QString &brushFile, requiredFiles) {
             KisBrush *brush = d->brushServer->resourceByFilename(brushFile).data();
             if (brush) {
                 newBundle->addResource("kis_brushes", brushFile, d->brushServer->assignedTagsList(brush), brush->md5());
             } else {
                 qWarning() << "There is no brush with name" << brushFile;
             }
         }
     }
 
     res = dlgCreateBundle.selectedWorkspaces();
     Q_FOREACH (const QString &r, res) {
         KoResource *res = d->workspaceServer->resourceByFilename(r);
         newBundle->addResource("kis_workspaces", res->filename(), d->workspaceServer->assignedTagsList(res), res->md5());
     }
 
     newBundle->addMeta("fileName", bundlePath);
     newBundle->addMeta("created", QDate::currentDate().toString("dd/MM/yyyy"));
 
     if (!newBundle->save()) {
-        QMessageBox::critical(m_view->mainWindow(), i18nc("@title:window", "Krita"), i18n("Could not create the new bundle."));
+        QMessageBox::critical(viewManager()->mainWindow(), i18nc("@title:window", "Krita"), i18n("Could not create the new bundle."));
     }
     else {
         newBundle->setValid(true);
         if (QDir(KisResourceServerProvider::instance()->resourceBundleServer()->saveLocation()) != QDir(QFileInfo(bundlePath).path())) {
             newBundle->setFilename(KisResourceServerProvider::instance()->resourceBundleServer()->saveLocation() + "/" + dlgCreateBundle.bundleName() + ".bundle");
         }
         if (KisResourceServerProvider::instance()->resourceBundleServer()->resourceByName(newBundle->name())) {
             KisResourceServerProvider::instance()->resourceBundleServer()->removeResourceFromServer(
                         KisResourceServerProvider::instance()->resourceBundleServer()->resourceByName(newBundle->name()));
         }
         KisResourceServerProvider::instance()->resourceBundleServer()->addResource(newBundle, true);
         newBundle->load();
     }
 
     return newBundle;
 }
 
 void ResourceManager::slotManageBundles()
 {
-    DlgBundleManager* dlg = new DlgBundleManager(this, m_view->actionManager());
+    DlgBundleManager* dlg = new DlgBundleManager(this, viewManager()->actionManager());
     if (dlg->exec() != QDialog::Accepted) {
         return;
     }
 }
 
 QStringList ResourceManager::importResources(const QString &title, const QStringList &mimes) const
 {
-    KoFileDialog dialog(m_view->mainWindow(), KoFileDialog::OpenFiles, "krita_resources");
+    KoFileDialog dialog(viewManager()->mainWindow(), KoFileDialog::OpenFiles, "krita_resources");
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::HomeLocation));
     dialog.setCaption(title);
     dialog.setMimeTypeFilters(mimes);
     return dialog.filenames();
 }
 
 void ResourceManager::slotImportBrushes()
 {
     QStringList resources = importResources(i18n("Import Brushes"), QStringList() << "image/x-gimp-brush"
                                    << "image/x-gimp-x-gimp-brush-animated"
                                    << "image/x-adobe-brushlibrary"
                                    << "image/png"
                                    << "image/svg+xml");
     Q_FOREACH (const QString &res, resources) {
         d->brushServer->importResourceFile(res);
     }
 }
 
 void ResourceManager::slotImportPresets()
 {
     QStringList resources = importResources(i18n("Import Presets"), QStringList() << "application/x-krita-paintoppreset");
     Q_FOREACH (const QString &res, resources) {
         d->paintopServer->importResourceFile(res);
     }
 }
 
 void ResourceManager::slotImportGradients()
 {
     QStringList resources = importResources(i18n("Import Gradients"), QStringList() << "image/svg+xml"
                                    << "application/x-gimp-gradient"
                                    << "applicaition/x-karbon-gradient");
     Q_FOREACH (const QString &res, resources) {
         d->gradientServer->importResourceFile(res);
     }
 }
 
 void ResourceManager::slotImportBundles()
 {
     QStringList resources = importResources(i18n("Import Bundles"), QStringList() << "application/x-krita-bundle");
     Q_FOREACH (const QString &res, resources) {
         KisResourceBundle *bundle = KisResourceServerProvider::instance()->resourceBundleServer()->createResource(res);
         bundle->load();
         if (bundle->valid()) {
             if (!bundle->install()) {
                 QMessageBox::warning(0, i18nc("@title:window", "Krita"), i18n("Could not install the resources for bundle %1.").arg(res));
             }
         }
         else {
             QMessageBox::warning(0, i18nc("@title:window", "Krita"), i18n("Could not load bundle %1.").arg(res));
         }
 
         QFileInfo fi(res);
         QString newFilename = KisResourceServerProvider::instance()->resourceBundleServer()->saveLocation() + fi.baseName() + bundle->defaultFileExtension();
         QFileInfo fileInfo(newFilename);
 
         int i = 1;
         while (fileInfo.exists()) {
             fileInfo.setFile(KisResourceServerProvider::instance()->resourceBundleServer()->saveLocation() + fi.baseName() + QString("%1").arg(i) + bundle->defaultFileExtension());
             i++;
         }
         bundle->setFilename(fileInfo.filePath());
         QFile::copy(res, newFilename);
         KisResourceServerProvider::instance()->resourceBundleServer()->addResource(bundle, false);
     }
 }
 
 void ResourceManager::slotImportPatterns()
 {
     QStringList resources = importResources(i18n("Import Patterns"), QStringList() << "image/png"
                                    << "image/svg+xml"
                                    << "application/x-gimp-pattern"
                                    << "image/jpeg"
                                    << "image/tiff"
                                    << "image/bmp"
                                    << "image/xpg");
     Q_FOREACH (const QString &res, resources) {
         d->patternServer->importResourceFile(res);
     }
 }
 
 void ResourceManager::slotImportPalettes()
 {
     QStringList resources = importResources(i18n("Import Palettes"), QStringList() << "image/x-gimp-color-palette");
     Q_FOREACH (const QString &res, resources) {
         d->paletteServer->importResourceFile(res);
     }
 }
 
 void ResourceManager::slotImportWorkspaces()
 {
     QStringList resources = importResources(i18n("Import Workspaces"), QStringList() << "application/x-krita-workspace");
     Q_FOREACH (const QString &res, resources) {
         d->workspaceServer->importResourceFile(res);
     }
 }
 
 #include "resourcemanager.moc"
diff --git a/plugins/extensions/resourcemanager/resourcemanager.h b/plugins/extensions/resourcemanager/resourcemanager.h
index 11ae3373c1..968fed07a0 100644
--- a/plugins/extensions/resourcemanager/resourcemanager.h
+++ b/plugins/extensions/resourcemanager/resourcemanager.h
@@ -1,63 +1,63 @@
 /*
  * resourcemanager.h -- Part of Krita
  *
  * Copyright (c) 2014 Boudewijn Rempt (boud@valdyas.org)
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef RESOURCEMANAGER_H
 #define RESOURCEMANAGER_H
 
 #include <QVariant>
 #include <QStringList>
 #include <QString>
 
 #include <KoResourceServer.h>
 
-#include <kis_view_plugin.h>
+#include <KisActionPlugin.h>
 #include "KisResourceBundle.h"
 
 #include "dlg_create_bundle.h"
 
-class ResourceManager : public KisViewPlugin
+class ResourceManager : public KisActionPlugin
 {
     Q_OBJECT
 public:
     ResourceManager(QObject *parent, const QVariantList &);
     ~ResourceManager() override;
     KisResourceBundle *saveBundle(const DlgCreateBundle &dlgCreateBundle);
 
 private Q_SLOTS:
     void slotCreateBundle();
     void slotManageBundles();
 
     void slotImportBrushes();
     void slotImportGradients();
     void slotImportPalettes();
     void slotImportPatterns();
     void slotImportPresets();
     void slotImportWorkspaces();
     void slotImportBundles();
 
 
 private:
 
     QStringList importResources(const QString &title, const QStringList &mimes) const;
 
     class Private;
     QScopedPointer<Private> d;
 };
 
 #endif // RESOURCEMANAGER_H
diff --git a/plugins/extensions/rotateimage/rotateimage.cc b/plugins/extensions/rotateimage/rotateimage.cc
index 77a9e73c05..97dd9bdeca 100644
--- a/plugins/extensions/rotateimage/rotateimage.cc
+++ b/plugins/extensions/rotateimage/rotateimage.cc
@@ -1,148 +1,148 @@
 /*
  * rotateimage.cc -- Part of Krita
  *
  * Copyright (c) 2004 Michael Thaler <michael.thaler@physik.tu-muenchen.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 "rotateimage.h"
 
 #include <math.h>
 
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 #include <kpluginfactory.h>
 #include <kis_icon.h>
 #include <kundo2magicstring.h>
 #include <kis_image.h>
 #include <kis_types.h>
 #include <KisViewManager.h>
 #include <kis_image_manager.h>
 #include <kis_node_manager.h>
 #include <kis_canvas_resource_provider.h>
 #include <kis_group_layer.h>
 #include <kis_action.h>
 
 #include "dlg_rotateimage.h"
 
 K_PLUGIN_FACTORY_WITH_JSON(RotateImageFactory, "kritarotateimage.json", registerPlugin<RotateImage>();)
 
 RotateImage::RotateImage(QObject *parent, const QVariantList &)
-        : KisViewPlugin(parent)
+        : KisActionPlugin(parent)
 {
 
     KisAction *action  = createAction("rotateimage");
     connect(action, SIGNAL(triggered()), this, SLOT(slotRotateImage()));
 
     action  = createAction("rotateImageCW90");
     connect(action, SIGNAL(triggered()), this, SLOT(slotRotateImage90()));
 
     action  = createAction("rotateImage180");
     connect(action, SIGNAL(triggered()), this, SLOT(slotRotateImage180()));
 
     action  = createAction("rotateImageCCW90");
     connect(action, SIGNAL(triggered()), this, SLOT(slotRotateImage270()));
 
     action  = createAction("mirrorImageHorizontal");
     connect(action, SIGNAL(triggered()), this, SLOT(slotMirrorImageHorizontal()));
 
     action  = createAction("mirrorImageVertical");
     connect(action, SIGNAL(triggered()), this, SLOT(slotMirrorImageVertical()));
 
     action  = createAction("rotatelayer");
     connect(action, SIGNAL(triggered()), this, SLOT(slotRotateLayer()));
 
     action  = createAction("rotateLayer180");
-    connect(action, SIGNAL(triggered()), m_view->nodeManager(), SLOT(rotate180()));
+    connect(action, SIGNAL(triggered()), viewManager()->nodeManager(), SLOT(rotate180()));
 
     action  = createAction("rotateLayerCW90");
-    connect(action, SIGNAL(triggered()), m_view->nodeManager(), SLOT(rotateRight90()));
+    connect(action, SIGNAL(triggered()), viewManager()->nodeManager(), SLOT(rotateRight90()));
 
     action  = createAction("rotateLayerCCW90");
-    connect(action, SIGNAL(triggered()), m_view->nodeManager(), SLOT(rotateLeft90()));
+    connect(action, SIGNAL(triggered()), viewManager()->nodeManager(), SLOT(rotateLeft90()));
 }
 
 RotateImage::~RotateImage()
 {
 }
 
 void RotateImage::slotRotateImage()
 {
-    KisImageWSP image = m_view->image();
+    KisImageWSP image = viewManager()->image();
 
     if (!image) return;
 
-    DlgRotateImage * dlgRotateImage = new DlgRotateImage(m_view->mainWindow(), "RotateImage");
+    DlgRotateImage * dlgRotateImage = new DlgRotateImage(viewManager()->mainWindow(), "RotateImage");
     Q_CHECK_PTR(dlgRotateImage);
 
     dlgRotateImage->setCaption(i18n("Rotate Image"));
 
     if (dlgRotateImage->exec() == QDialog::Accepted) {
         double angle = dlgRotateImage->angle() * M_PI / 180;
-        m_view->imageManager()->rotateCurrentImage(angle);
+        viewManager()->imageManager()->rotateCurrentImage(angle);
     }
     delete dlgRotateImage;
 }
 
 void RotateImage::slotRotateImage90()
 {
-    m_view->imageManager()->rotateCurrentImage(M_PI / 2);
+    viewManager()->imageManager()->rotateCurrentImage(M_PI / 2);
 }
 
 void RotateImage::slotRotateImage180()
 {
-    m_view->imageManager()->rotateCurrentImage(M_PI);
+    viewManager()->imageManager()->rotateCurrentImage(M_PI);
 }
 
 void RotateImage::slotRotateImage270()
 {
-    m_view->imageManager()->rotateCurrentImage(- M_PI / 2 + M_PI*2);
+    viewManager()->imageManager()->rotateCurrentImage(- M_PI / 2 + M_PI*2);
 }
 
 void RotateImage::slotMirrorImageVertical()
 {
-    KisImageWSP image = m_view->image();
+    KisImageWSP image = viewManager()->image();
     if (!image) return;
-    m_view->nodeManager()->mirrorNode(image->rootLayer(), kundo2_i18n("Mirror Image Vertically"), Qt::Vertical);
+    viewManager()->nodeManager()->mirrorNode(image->rootLayer(), kundo2_i18n("Mirror Image Vertically"), Qt::Vertical);
 }
 
 void RotateImage::slotMirrorImageHorizontal()
 {
-    KisImageWSP image = m_view->image();
+    KisImageWSP image = viewManager()->image();
     if (!image) return;
-    m_view->nodeManager()->mirrorNode(image->rootLayer(), kundo2_i18n("Mirror Image Horizontally"), Qt::Horizontal);
+    viewManager()->nodeManager()->mirrorNode(image->rootLayer(), kundo2_i18n("Mirror Image Horizontally"), Qt::Horizontal);
 }
 
 void RotateImage::slotRotateLayer()
 {
-    KisImageWSP image = m_view->image();
+    KisImageWSP image = viewManager()->image();
 
     if (!image) return;
 
-    DlgRotateImage * dlgRotateImage = new DlgRotateImage(m_view->mainWindow(), "RotateLayer");
+    DlgRotateImage * dlgRotateImage = new DlgRotateImage(viewManager()->mainWindow(), "RotateLayer");
     Q_CHECK_PTR(dlgRotateImage);
 
     dlgRotateImage->setCaption(i18n("Rotate Layer"));
 
     if (dlgRotateImage->exec() == QDialog::Accepted) {
         double angle = dlgRotateImage->angle() * M_PI / 180;
-        m_view->nodeManager()->rotate(angle);
+        viewManager()->nodeManager()->rotate(angle);
 
     }
     delete dlgRotateImage;
 }
 
 #include "rotateimage.moc"
diff --git a/plugins/extensions/rotateimage/rotateimage.h b/plugins/extensions/rotateimage/rotateimage.h
index 60a610245b..b0e88dcb23 100644
--- a/plugins/extensions/rotateimage/rotateimage.h
+++ b/plugins/extensions/rotateimage/rotateimage.h
@@ -1,45 +1,45 @@
 /*
  * rotateimage.h -- Part of Krita
  *
  * Copyright (c) 2004 Michael Thaler (michael.thaler@physik.tu-muenchen.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 ROTATEIMAGE_H
 #define ROTATEIMAGE_H
 
 #include <QVariant>
 
-#include <kis_view_plugin.h>
+#include <KisActionPlugin.h>
 
-class RotateImage : public KisViewPlugin
+class RotateImage : public KisActionPlugin
 {
     Q_OBJECT
 public:
     RotateImage(QObject *parent, const QVariantList &);
     ~RotateImage() override;
 
 private Q_SLOTS:
 
     void slotRotateImage();
     void slotRotateImage90();
     void slotRotateImage180();
     void slotRotateImage270();
     void slotMirrorImageVertical();
     void slotMirrorImageHorizontal();
     void slotRotateLayer();
 };
 
 #endif // ROTATEIMAGE_H
diff --git a/plugins/extensions/separate_channels/kis_channel_separator.cc b/plugins/extensions/separate_channels/kis_channel_separator.cc
index 2f49bafccd..66b9f7c6b3 100644
--- a/plugins/extensions/separate_channels/kis_channel_separator.cc
+++ b/plugins/extensions/separate_channels/kis_channel_separator.cc
@@ -1,272 +1,272 @@
 /*
  * This file is part of Krita
  *
  * Copyright (c) 2005 Michael Thaler <michael.thaler@physik.tu-muenchen.de>
  *
  * ported from Gimp, Copyright (C) 1997 Eiichi Takamori <taka@ma1.seikyou.ne.jp>
  * original pixelize.c for GIMP 0.54 by Tracy Scott
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_channel_separator.h"
 
 #include <limits.h>
 #include <stdlib.h>
 #include <vector>
 
 #include <QStandardPaths>
 
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 #include <kpluginfactory.h>
 
 
 #include <KisImportExportManager.h>
 #include <KoUpdater.h>
 #include <KoFileDialog.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoChannelInfo.h>
 #include <KoColorModelStandardIds.h>
 
 #include <KisDocument.h>
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <kis_paint_layer.h>
 #include <kis_group_layer.h>
 #include <kis_transaction.h>
 #include <kis_undo_adapter.h>
 #include <kis_global.h>
 #include <kis_types.h>
 #include "kis_iterator_ng.h"
 #include <KisPart.h>
 #include <KisViewManager.h>
 #include <kis_paint_device.h>
 #include <kis_node_manager.h>
 #include <kis_node_commands_adapter.h>
 #include <KisMimeDatabase.h>
 
 KisChannelSeparator::KisChannelSeparator(KisViewManager * view)
-        : m_view(view)
+        : m_viewManager(view)
 {
 }
 
 void KisChannelSeparator::separate(KoUpdater * progressUpdater, enumSepAlphaOptions alphaOps, enumSepSource sourceOps, enumSepOutput outputOps, bool downscale, bool toColor)
 {
-    KisImageSP image = m_view->image();
+    KisImageSP image = m_viewManager->image();
     if (!image) return;
 
     KisPaintDeviceSP src;
 
     // Use the flattened image, if required
     switch (sourceOps) {
     case ALL_LAYERS:
         // the content will be locked later
         src = image->projection();
         break;
     case CURRENT_LAYER:
-        src = m_view->activeDevice();
+        src = m_viewManager->activeDevice();
         break;
     default:
         break;
     }
 
     if (!src) return;
 
     progressUpdater->setProgress(1);
 
     const KoColorSpace * dstCs = 0;
 
     quint32 numberOfChannels = src->channelCount();
     const KoColorSpace * srcCs  = src->colorSpace();
     QList<KoChannelInfo *> channels = srcCs->channels();
     vKisPaintDeviceSP layers;
 
     QList<KoChannelInfo *>::const_iterator begin = channels.constBegin();
     QList<KoChannelInfo *>::const_iterator end = channels.constEnd();
 
     QRect rect = src->exactBounds();
 
     image->lock();
     int i = 0;
     for (QList<KoChannelInfo *>::const_iterator it = begin; it != end; ++it) {
 
         KoChannelInfo * ch = (*it);
 
         if (ch->channelType() == KoChannelInfo::ALPHA && alphaOps != CREATE_ALPHA_SEPARATION) {
             continue;
         }
 
         qint32 channelSize = ch->size();
         qint32 channelPos = ch->pos();
         qint32 destSize = 1;
 
         KisPaintDeviceSP dev;
         if (toColor) {
             // We don't downscale if we separate to color channels
             dev = new KisPaintDevice(srcCs);
         } else {
             if (channelSize == 1 || downscale) {
                 dev = new KisPaintDevice(KoColorSpaceRegistry::instance()->colorSpace(GrayAColorModelID.id(), Integer8BitsColorDepthID.id(), 0));
             } else {
                 dev = new KisPaintDevice(KoColorSpaceRegistry::instance()->colorSpace(GrayAColorModelID.id(), Integer16BitsColorDepthID.id(), 0));
                 destSize = 2;
             }
         }
 
         dstCs = dev->colorSpace();
 
         layers.push_back(dev);
 
         KisHLineConstIteratorSP srcIt = src->createHLineConstIteratorNG(rect.x(), rect.y(), rect.width());
         KisHLineIteratorSP dstIt = dev->createHLineIteratorNG(rect.x(), rect.y(), rect.width());
 
         for (qint32 row = 0; row < rect.height(); ++row) {
             do {
                 if (toColor) {
                     dstCs->singleChannelPixel(dstIt->rawData(), srcIt->oldRawData(), channelPos);
 
                     if (alphaOps == COPY_ALPHA_TO_SEPARATIONS) {
                         //dstCs->setAlpha(dstIt->rawData(), srcIt->oldRawData()[srcAlphaPos], 1);
                         dstCs->setOpacity(dstIt->rawData(), srcCs->opacityU8(srcIt->oldRawData()), 1);
                     } else {
                         dstCs->setOpacity(dstIt->rawData(), OPACITY_OPAQUE_U8, 1);
                     }
                 } else {
 
                     // To grayscale
 
                     // Decide whether we need downscaling
                     if (channelSize == 1 && destSize == 1) {
 
                         // Both 8-bit channels
                         dstIt->rawData()[0] = srcIt->oldRawData()[channelPos];
 
                         if (alphaOps == COPY_ALPHA_TO_SEPARATIONS) {
                             dstCs->setOpacity(dstIt->rawData(), srcCs->opacityU8(srcIt->oldRawData()), 1);
                         } else {
                             dstCs->setOpacity(dstIt->rawData(), OPACITY_OPAQUE_U8, 1);
                         }
                     } else if (channelSize == 2 && destSize == 2) {
 
                         // Both 16-bit
                         dstIt->rawData()[0] = srcIt->oldRawData()[channelPos];
                         dstIt->rawData()[1] = srcIt->oldRawData()[channelPos + 1];
 
                         if (alphaOps == COPY_ALPHA_TO_SEPARATIONS) {
                             dstCs->setOpacity(dstIt->rawData(), srcCs->opacityU8(srcIt->oldRawData()), 1);
                         } else {
                             dstCs->setOpacity(dstIt->rawData(), OPACITY_OPAQUE_U8, 1);
                         }
                     } else if (channelSize != 1 && destSize == 1) {
                         // Downscale
                         memset(dstIt->rawData(), srcCs->scaleToU8(srcIt->oldRawData(), channelPos), 1);
 
                         // XXX: Do alpha
                         dstCs->setOpacity(dstIt->rawData(), OPACITY_OPAQUE_U8, 1);
                     } else if (channelSize != 2 && destSize == 2) {
                         // Upscale
                         dstIt->rawData()[0] = srcCs->scaleToU8(srcIt->oldRawData(), channelPos);
 
                         // XXX: Do alpha
                         dstCs->setOpacity(dstIt->rawData(), OPACITY_OPAQUE_U8, 1);
 
                     }
                 }
 
             } while (dstIt->nextPixel() && srcIt->nextPixel());
             dstIt->nextRow();
             srcIt->nextRow();
         }
         ++i;
 
         progressUpdater->setProgress((i * 100) / numberOfChannels);
         if (progressUpdater->interrupted()) {
             break;
         }
     }
 
     vKisPaintDeviceSP_it deviceIt = layers.begin();
 
     progressUpdater->setProgress(100);
 
     if (!progressUpdater->interrupted()) {
 
         KisUndoAdapter * undo = image->undoAdapter();
         if (outputOps == TO_LAYERS) {
             undo->beginMacro(kundo2_i18n("Separate Image"));
         }
 
         // Flatten the image if required
         switch (sourceOps) {
         case(ALL_LAYERS):
             image->flatten();
             break;
         default:
             break;
         }
-        KisNodeCommandsAdapter adapter(m_view);
+        KisNodeCommandsAdapter adapter(m_viewManager);
 
         for (QList<KoChannelInfo *>::const_iterator it = begin; it != end; ++it) {
 
             KoChannelInfo * ch = (*it);
 
             if (ch->channelType() == KoChannelInfo::ALPHA && alphaOps != CREATE_ALPHA_SEPARATION) {
                 // Don't make an separate separation of the alpha channel if the user didn't ask for it.
                 continue;
             }
 
             if (outputOps == TO_LAYERS) {
                 KisPaintLayerSP l = KisPaintLayerSP(new KisPaintLayer(image.data(), ch->name(), OPACITY_OPAQUE_U8, *deviceIt));
                 adapter.addNode(l.data(), image->rootLayer(), 0);
             }
             else {
-                KoFileDialog dialog(m_view->mainWindow(), KoFileDialog::SaveFile, "OpenDocument");
+                KoFileDialog dialog(m_viewManager->mainWindow(), KoFileDialog::SaveFile, "OpenDocument");
                 dialog.setCaption(i18n("Export Layer") + '(' + ch->name() + ')');
                 dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
                 dialog.setMimeTypeFilters(KisImportExportManager::mimeFilter(KisImportExportManager::Export));
                 QUrl url = QUrl::fromUserInput(dialog.filename());
 
                 if (url.isEmpty())
                     return;
 
                 const QString mimeType = KisMimeDatabase::mimeTypeForFile(url.toLocalFile(), false);
 
                 KisPaintLayerSP l = KisPaintLayerSP(new KisPaintLayer(image.data(), ch->name(), OPACITY_OPAQUE_U8, *deviceIt));
                 QRect r = l->exactBounds();
 
                 KisDocument *d = KisPart::instance()->createDocument();
 
                 KisImageWSP dst = KisImageWSP(new KisImage(d->createUndoStore(), r.width(), r.height(), (*deviceIt)->colorSpace(), l->name()));
                 d->setCurrentImage(dst);
                 dst->addNode(l->clone().data(), dst->rootLayer());
 
                 d->exportDocumentSync(url, mimeType.toLatin1());
 
                 delete d;
 
             }
 
             ++deviceIt;
         }
 
         if (outputOps == TO_LAYERS) {
             undo->endMacro();
         }
         image->unlock();
         image->setModified();
     }
 }
diff --git a/plugins/extensions/separate_channels/kis_channel_separator.h b/plugins/extensions/separate_channels/kis_channel_separator.h
index 1f6e9135e6..12ff238835 100644
--- a/plugins/extensions/separate_channels/kis_channel_separator.h
+++ b/plugins/extensions/separate_channels/kis_channel_separator.h
@@ -1,61 +1,61 @@
 /*
  * This file is part of the KDE project
  *
  * Copyright (c) Michael Thaler <michael.thaler@physik.tu-muenchen.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_CHANNEL_SEPARATOR_H_
 #define _KIS_CHANNEL_SEPARATOR_H_
 
 class KoUpdater;
 class KisViewManager;
 
 enum enumSepAlphaOptions {
     COPY_ALPHA_TO_SEPARATIONS = 0,
     DISCARD_ALPHA = 1,
     CREATE_ALPHA_SEPARATION = 2
 };
 
 
 enum enumSepSource {
     CURRENT_LAYER = 0,
     ALL_LAYERS = 1,
     VISIBLE_LAYERS = 2
 };
 
 enum enumSepOutput {
     TO_LAYERS = 0,
     TO_IMAGES = 1
 };
 
 class KisChannelSeparator
 {
 
 public:
 
     KisChannelSeparator(KisViewManager * view);
     virtual ~KisChannelSeparator() {}
 
     void separate(KoUpdater * progress, enumSepAlphaOptions alphaOps, enumSepSource sourceOps, enumSepOutput outputOps, bool downscale, bool toColor);
 
 private:
 
-    KisViewManager * m_view;
+    KisViewManager *m_viewManager;
 
 };
 
 #endif
diff --git a/plugins/extensions/separate_channels/kis_separate_channels_plugin.cc b/plugins/extensions/separate_channels/kis_separate_channels_plugin.cc
index ece1e7c064..545d1ffb71 100644
--- a/plugins/extensions/separate_channels/kis_separate_channels_plugin.cc
+++ b/plugins/extensions/separate_channels/kis_separate_channels_plugin.cc
@@ -1,99 +1,99 @@
 /*
  * This file is part of the KDE project
  *
  * Copyright (c) 2005 Michael Thaler <michael.thaler@physik.tu-muenchen.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_separate_channels_plugin.h"
 
 #include <QApplication>
 
 #include <klocalizedstring.h>
 #include <kis_debug.h>
 #include <kpluginfactory.h>
 
 #include <KoProgressUpdater.h>
 #include <KoUpdater.h>
 #include <KoColorSpace.h>
 
 #include <KisViewManager.h>
 #include <kis_types.h>
 #include <kis_image.h>
 #include <kis_paint_device.h>
 #include <kis_layer.h>
 #include <kis_statusbar.h>
 #include <kis_node_manager.h>
 #include <widgets/kis_progress_widget.h>
 #include <kis_action.h>
 
 #include "kis_channel_separator.h"
 #include "dlg_separate.h"
 
 K_PLUGIN_FACTORY_WITH_JSON(KisSeparateChannelsPluginFactory, "kritaseparatechannels.json", registerPlugin<KisSeparateChannelsPlugin>();)
 
 KisSeparateChannelsPlugin::KisSeparateChannelsPlugin(QObject *parent, const QVariantList &)
-    : KisViewPlugin(parent)
+    : KisActionPlugin(parent)
 {
     KisAction *action  = createAction("separate");
     connect(action, SIGNAL(triggered(bool)), SLOT(slotSeparate()));
 }
 
 KisSeparateChannelsPlugin::~KisSeparateChannelsPlugin()
 {
 }
 
 void KisSeparateChannelsPlugin::slotSeparate()
 {
-    KisImageSP image = m_view->image();
+    KisImageSP image = viewManager()->image();
     if (!image) return;
 
-    KisLayerSP l = m_view->nodeManager()->activeLayer();
+    KisLayerSP l = viewManager()->nodeManager()->activeLayer();
     if (!l) return;
 
     KisPaintDeviceSP dev = l->paintDevice();
     if (!dev) return;
 
     DlgSeparate * dlgSeparate = new DlgSeparate(dev->colorSpace()->name(),
-                                                image->colorSpace()->name(), m_view->mainWindow(), "Separate");
+                                                image->colorSpace()->name(), viewManager()->mainWindow(), "Separate");
     Q_CHECK_PTR(dlgSeparate);
 
     dlgSeparate->setCaption(i18n("Separate Image"));
 
     // If we're 8-bits, disable the downscale option
     if (dev->pixelSize() == dev->channelCount()) {
         dlgSeparate->enableDownscale(false);
     }
 
     if (dlgSeparate->exec() == QDialog::Accepted) {
 
         QApplication::setOverrideCursor(Qt::BusyCursor);
 
-        KisChannelSeparator separator(m_view);
-        separator.separate(m_view->createUnthreadedUpdater(i18n("Separate Image")),
+        KisChannelSeparator separator(viewManager());
+        separator.separate(viewManager()->createUnthreadedUpdater(i18n("Separate Image")),
                            dlgSeparate->getAlphaOptions(),
                            dlgSeparate->getSource(),
                            dlgSeparate->getOutput(),
                            dlgSeparate->getDownscale(),
                            dlgSeparate->getToColor());
         QApplication::restoreOverrideCursor();
     }
 
     delete dlgSeparate;
 
 }
 
 #include "kis_separate_channels_plugin.moc"
diff --git a/plugins/extensions/separate_channels/kis_separate_channels_plugin.h b/plugins/extensions/separate_channels/kis_separate_channels_plugin.h
index f9e9e2019e..0f8c4c65f8 100644
--- a/plugins/extensions/separate_channels/kis_separate_channels_plugin.h
+++ b/plugins/extensions/separate_channels/kis_separate_channels_plugin.h
@@ -1,39 +1,39 @@
 /*
  * This file is part of Krita
  *
  * Copyright (c) Michael Thaler <michael.thaler@physik.tu-muenchen.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_SEPARATE_CHANNELS_PLUGIN_H_
 #define _KIS_SEPARATE_CHANNELS_PLUGIN_H_
 
 #include <QVariant>
 
-#include <kis_view_plugin.h>
+#include <KisActionPlugin.h>
 
-class KisSeparateChannelsPlugin : public KisViewPlugin
+class KisSeparateChannelsPlugin : public KisActionPlugin
 {
     Q_OBJECT
 public:
     KisSeparateChannelsPlugin(QObject *parent, const QVariantList &);
     ~KisSeparateChannelsPlugin() override;
 
 private Q_SLOTS:
 
     void slotSeparate();
 };
 
 #endif
diff --git a/plugins/extensions/shearimage/shearimage.cc b/plugins/extensions/shearimage/shearimage.cc
index abdbd1239f..ff009807d2 100644
--- a/plugins/extensions/shearimage/shearimage.cc
+++ b/plugins/extensions/shearimage/shearimage.cc
@@ -1,89 +1,89 @@
 /*
  * shearimage.cc -- Part of Krita
  *
  * Copyright (c) 2004 Michael Thaler <michael.thaler@physik.tu-muenchen.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 "shearimage.h"
 
 #include <klocalizedstring.h>
 #include <kpluginfactory.h>
 
 #include <kis_image.h>
 #include <KisViewManager.h>
 #include <kis_node_manager.h>
 #include <kis_image_manager.h>
 #include <kis_action.h>
 
 #include "dlg_shearimage.h"
 
 K_PLUGIN_FACTORY_WITH_JSON(ShearImageFactory, "kritashearimage.json", registerPlugin<ShearImage>();)
 
 ShearImage::ShearImage(QObject *parent, const QVariantList &)
-        : KisViewPlugin(parent)
+    : KisActionPlugin(parent)
 {
     KisAction *action = createAction("shearimage");
     connect(action,  SIGNAL(triggered()), this, SLOT(slotShearImage()));
 
     action = createAction("shearlayer");
     connect(action,  SIGNAL(triggered()), this, SLOT(slotShearLayer()));
 }
 
 ShearImage::~ShearImage()
 {
 }
 
 void ShearImage::slotShearImage()
 {
-    KisImageWSP image = m_view->image();
+    KisImageWSP image = viewManager()->image();
 
     if (!image) return;
 
-    DlgShearImage * dlgShearImage = new DlgShearImage(m_view->mainWindow(), "ShearImage");
+    DlgShearImage * dlgShearImage = new DlgShearImage(viewManager()->mainWindow(), "ShearImage");
     Q_CHECK_PTR(dlgShearImage);
 
     dlgShearImage->setCaption(i18n("Shear Image"));
 
     if (dlgShearImage->exec() == QDialog::Accepted) {
         qint32 angleX = dlgShearImage->angleX();
         qint32 angleY = dlgShearImage->angleY();
-        m_view->imageManager()->shearCurrentImage(angleX, angleY);
+        viewManager()->imageManager()->shearCurrentImage(angleX, angleY);
     }
     delete dlgShearImage;
 }
 
 void ShearImage::slotShearLayer()
 {
-    KisImageWSP image = m_view->image();
+    KisImageWSP image = viewManager()->image();
 
     if (!image) return;
 
-    DlgShearImage * dlgShearImage = new DlgShearImage(m_view->mainWindow(), "ShearLayer");
+    DlgShearImage * dlgShearImage = new DlgShearImage(viewManager()->mainWindow(), "ShearLayer");
     Q_CHECK_PTR(dlgShearImage);
 
     dlgShearImage->setCaption(i18n("Shear Layer"));
 
     if (dlgShearImage->exec() == QDialog::Accepted) {
         qint32 angleX = dlgShearImage->angleX();
         qint32 angleY = dlgShearImage->angleY();
-        m_view->nodeManager()->shear(angleX, angleY);
+        viewManager()->nodeManager()->shear(angleX, angleY);
 
     }
     delete dlgShearImage;
 }
 
 #include "shearimage.moc"
diff --git a/plugins/extensions/shearimage/shearimage.h b/plugins/extensions/shearimage/shearimage.h
index d9d1f8b5f8..4948724513 100644
--- a/plugins/extensions/shearimage/shearimage.h
+++ b/plugins/extensions/shearimage/shearimage.h
@@ -1,40 +1,40 @@
 /*
  * shearimage.h -- Part of Krita
  *
  * Copyright (c) 2004 Michael Thaler (michael.thaler@physik.tu-muenchen.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 SHEARIMAGE_H
 #define SHEARIMAGE_H
 
 #include <QVariant>
 
-#include <kis_view_plugin.h>
+#include <KisActionPlugin.h>
 
-class ShearImage : public KisViewPlugin
+class ShearImage : public KisActionPlugin
 {
     Q_OBJECT
 public:
     ShearImage(QObject *parent, const QVariantList &);
     ~ShearImage() override;
 
 private Q_SLOTS:
 
     void slotShearImage();
     void slotShearLayer();
 };
 
 #endif // SHEARIMAGE_H
diff --git a/plugins/extensions/waveletdecompose/waveletdecompose.cpp b/plugins/extensions/waveletdecompose/waveletdecompose.cpp
index ce52f85e66..364b81a23d 100644
--- a/plugins/extensions/waveletdecompose/waveletdecompose.cpp
+++ b/plugins/extensions/waveletdecompose/waveletdecompose.cpp
@@ -1,158 +1,158 @@
 /*
  * Copyright (C) 2016 Miroslav Talasek <miroslav.talasek@seznam.cz>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "waveletdecompose.h"
 
 #include <QMap>
 #include <QPointer>
 #include <QHash>
 
 #include <klocalizedstring.h>
 #include <kpluginfactory.h>
 
 #include <KoColorSpace.h>
 #include <KoChannelInfo.h>
 #include <KoColor.h>
 
 #include <kis_debug.h>
 #include <kis_types.h>
 #include <KisViewManager.h>
 #include <kis_image.h>
 #include <kis_wavelet_kernel.h>
 #include <kis_action.h>
 #include <KisDocument.h>
 #include <kis_node.h>
 #include <kis_painter.h>
 #include <kis_paint_device.h>
 #include <kis_paint_layer.h>
 #include <kis_group_layer.h>
 #include <kis_random_accessor_ng.h>
 #include "dlg_waveletdecompose.h"
 #include "kis_node_manager.h"
 #include "kis_node_commands_adapter.h"
 #include "kis_undo_adapter.h"
 
 #include <KoUpdater.h>
 #include <KoProgressUpdater.h>
 
 
 
 K_PLUGIN_FACTORY_WITH_JSON(WaveletDecomposeFactory, "kritawaveletdecompose.json", registerPlugin<WaveletDecompose>();)
 
 WaveletDecompose::WaveletDecompose(QObject *parent, const QVariantList &)
-    : KisViewPlugin(parent)
+    : KisActionPlugin(parent)
 {
     KisAction *action  = createAction("waveletdecompose");
     connect(action, SIGNAL(triggered()), this, SLOT(slotWaveletDecompose()));
 }
 
 WaveletDecompose::~WaveletDecompose()
 {
 }
 
 void WaveletDecompose::slotWaveletDecompose()
 {
-    DlgWaveletDecompose dlg(m_view->mainWindow(), "WaveletDecompose");
+    DlgWaveletDecompose dlg(viewManager()->mainWindow(), "WaveletDecompose");
         
     if (dlg.exec() == QDialog::Accepted) {
 
         QApplication::setOverrideCursor(Qt::WaitCursor);
 
-        QPointer<KoUpdater> updater = m_view->createUnthreadedUpdater(i18n("Wavelet Decompose"));
+        QPointer<KoUpdater> updater = viewManager()->createUnthreadedUpdater(i18n("Wavelet Decompose"));
 
-        KisImageSP image = m_view->image();
+        KisImageSP image = viewManager()->image();
         if (!image) return;
 
-        if (!m_view->blockUntilOperationsFinished(image)) return;
+        if (!viewManager()->blockUntilOperationsFinished(image)) return;
 
         image->barrierLock();
 
         KisPaintDeviceSP projection = new KisPaintDevice(*(image->projection()), false, 0);
         if (!projection) return;
        
         const KoColorSpace *cs = projection->colorSpace();
 
         const KoCompositeOp* op = cs->compositeOp(COMPOSITE_GRAIN_EXTRACT);
         
         int scales = dlg.scales();
         
         QList<KisPaintDeviceSP> results;
         const QBitArray flags(0);
         
         QRect rc = image->bounds();
         
         KisPaintDeviceSP original = projection;
         
         //main loop
         for(int level = 0; level < scales; ++level){
         
             //copy original
             KisPaintDeviceSP blur = new KisPaintDevice(*original, false, 0);
            
             //blur it
             KisWaveletKernel::applyWavelet(blur, rc, 1 << level, 1 << level, flags, 0);
        
             //do grain extract blur from original
             KisPainter painter(original);
             painter.setCompositeOp(op);
             painter.bitBlt(0, 0, blur, 0, 0, rc.width(), rc.height());
             painter.end();
         
             //original is new scale and blur is new original
             results << original;
             original = blur;
             updater->setProgress((level * 100) / scales);
         }
         //add new layers
         KisUndoAdapter *undo = image->undoAdapter();
         undo->beginMacro(kundo2_i18n("Wavelet decompose"));
         
-        KisNodeCommandsAdapter adapter(m_view);
+        KisNodeCommandsAdapter adapter(viewManager());
         
         KisGroupLayerSP baseGroup = image->rootLayer();
 
         //add layer goup              
         KisGroupLayerSP grp = new KisGroupLayer(image, i18n("Wavelet decompose"), OPACITY_OPAQUE_U8);
         adapter.addNode(grp, baseGroup, baseGroup->lastChild());
         baseGroup = grp;
 
         //add scales
         int i = 1;
         const KoCompositeOp* op2 = cs->compositeOp(COMPOSITE_GRAIN_MERGE);
         Q_FOREACH (const KisPaintDeviceSP &l, results) {
             KisPaintLayerSP paintLayer = new KisPaintLayer(image, QStringLiteral("Scale %1").arg(i), OPACITY_OPAQUE_U8, l);
             adapter.addNode(paintLayer, baseGroup, 0);
             adapter.setCompositeOp(paintLayer, op2);
             ++i;
         }
 
         //add residual
         KisPaintLayerSP paintLayer = new KisPaintLayer(image, "Residual", OPACITY_OPAQUE_U8, original);
         adapter.addNode(paintLayer, baseGroup, 0);
         
         undo->endMacro();
         updater->setProgress(100);
         image->unlock();
         image->setModified();
     }
         
     QApplication::restoreOverrideCursor();
 }
 
 #include "waveletdecompose.moc"
diff --git a/plugins/extensions/waveletdecompose/waveletdecompose.h b/plugins/extensions/waveletdecompose/waveletdecompose.h
index 9456ca7044..e9aa86159d 100644
--- a/plugins/extensions/waveletdecompose/waveletdecompose.h
+++ b/plugins/extensions/waveletdecompose/waveletdecompose.h
@@ -1,40 +1,40 @@
 /*
  * Copyright (C) 2016 Miroslav Talasek <miroslav.talasek@seznam.cz>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 #ifndef WAVELETDECOMPOSE_H
 #define WAVELETDECOMPOSE_H
 
 #include <QVariant>
 
 #include <QUrl>
-#include <kis_view_plugin.h>
+#include <KisActionPlugin.h>
 
-class WaveletDecompose : public KisViewPlugin
+class WaveletDecompose : public KisActionPlugin
 {
     Q_OBJECT
 public:
     WaveletDecompose(QObject *parent, const QVariantList &);
     ~WaveletDecompose() override;
 
 private Q_SLOTS:
 
     void slotWaveletDecompose();
 
 };
 
 #endif // WAVELETDECOMPOSE_H
diff --git a/plugins/impex/png/kis_png_export.cc b/plugins/impex/png/kis_png_export.cc
index f11d32b899..11b3600d93 100644
--- a/plugins/impex/png/kis_png_export.cc
+++ b/plugins/impex/png/kis_png_export.cc
@@ -1,242 +1,230 @@
 /*
  *  Copyright (c) 2005 Cyrille Berger <cberger@cberger.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "kis_png_export.h"
 
 #include <QCheckBox>
 #include <QSlider>
 #include <QApplication>
 
 #include <kpluginfactory.h>
 
 #include <KoColorSpace.h>
 #include <KisImportExportManager.h>
 #include <KoColorProfile.h>
 #include <KoColorModelStandardIds.h>
 #include <KoColorSpaceRegistry.h>
 
 #include <KisExportCheckRegistry.h>
 
 #include <kis_properties_configuration.h>
 #include <kis_paint_device.h>
 #include <KisDocument.h>
 #include <kis_image.h>
 #include <kis_paint_layer.h>
 #include <kis_group_layer.h>
 #include <kis_config.h>
 #include <kis_properties_configuration.h>
 #include <metadata/kis_meta_data_store.h>
 #include <metadata/kis_meta_data_filter_registry_model.h>
 #include <metadata/kis_exif_info_visitor.h>
 #include "kis_png_converter.h"
 #include <kis_iterator_ng.h>
 
 K_PLUGIN_FACTORY_WITH_JSON(KisPNGExportFactory, "krita_png_export.json", registerPlugin<KisPNGExport>();)
 
 KisPNGExport::KisPNGExport(QObject *parent, const QVariantList &) : KisImportExportFilter(parent)
 {
 }
 
 KisPNGExport::~KisPNGExport()
 {
 }
 
-bool hasVisibleWidgets()
-{
-    QWidgetList wl = QApplication::allWidgets();
-    Q_FOREACH (QWidget* w, wl) {
-        if (w->isVisible() && strcmp(w->metaObject()->className(), "QDesktopWidget")) {
-            dbgFile << "Widget " << w << " " << w->objectName() << " " << w->metaObject()->className() << " is visible";
-            return true;
-        }
-    }
-    return false;
-}
-
 KisImportExportFilter::ConversionStatus KisPNGExport::convert(KisDocument *document, QIODevice *io,  KisPropertiesConfigurationSP configuration)
 {
     KisImageSP image = document->savingImage();
 
     KisPNGOptions options;
 
     options.alpha = configuration->getBool("alpha", true);
     options.interlace = configuration->getBool("interlaced", false);
     options.compression = configuration->getInt("compression", 3);
     options.tryToSaveAsIndexed = configuration->getBool("indexed", false);
     KoColor c(KoColorSpaceRegistry::instance()->rgb8());
     c.fromQColor(Qt::white);
     options.transparencyFillColor = configuration->getColor("transparencyFillcolor", c).toQColor();
     options.saveSRGBProfile = configuration->getBool("saveSRGBProfile", false);
     options.forceSRGB = configuration->getBool("forceSRGB", true);
     options.storeAuthor = configuration->getBool("storeAuthor", false);
     options.storeMetaData = configuration->getBool("storeMetaData", false);
 
     vKisAnnotationSP_it beginIt = image->beginAnnotations();
     vKisAnnotationSP_it endIt = image->endAnnotations();
 
     KisExifInfoVisitor eIV;
     eIV.visit(image->rootLayer().data());
     KisMetaData::Store *eI = 0;
     if (eIV.countPaintLayer() == 1) {
         eI = eIV.exifInfo();
     }
     if (eI) {
         KisMetaData::Store* copy = new KisMetaData::Store(*eI);
         eI = copy;
     }
 
     KisPNGConverter pngConverter(document);
 
     KisImageBuilder_Result res = pngConverter.buildFile(io, image->bounds(), image->xRes(), image->yRes(), image->projection(), beginIt, endIt, options, eI);
 
     if (res == KisImageBuilder_RESULT_OK) {
         delete eI;
         return KisImportExportFilter::OK;
     }
 
     delete eI;
     dbgFile << " Result =" << res;
     return KisImportExportFilter::InternalError;
 }
 
 KisPropertiesConfigurationSP KisPNGExport::defaultConfiguration(const QByteArray &, const QByteArray &) const
 {
     KisPropertiesConfigurationSP cfg = new KisPropertiesConfiguration();
     cfg->setProperty("alpha", true);
     cfg->setProperty("indexed", false);
     cfg->setProperty("compression", 3);
     cfg->setProperty("interlaced", false);
 
     KoColor fill_color(KoColorSpaceRegistry::instance()->rgb8());
     fill_color = KoColor();
     fill_color.fromQColor(Qt::white);
     QVariant v;
     v.setValue(fill_color);
 
     cfg->setProperty("transparencyFillcolor", v);
     cfg->setProperty("saveSRGBProfile", false);
     cfg->setProperty("forceSRGB", true);
     cfg->setProperty("storeMetaData", false);
     cfg->setProperty("storeAuthor", false);
 
     return cfg;
 }
 
 KisConfigWidget *KisPNGExport::createConfigurationWidget(QWidget *parent, const QByteArray &, const QByteArray &) const
 {
     return new KisWdgOptionsPNG(parent);
 }
 
 void KisPNGExport::initializeCapabilities()
 {
     addCapability(KisExportCheckRegistry::instance()->get("sRGBProfileCheck")->create(KisExportCheckBase::SUPPORTED));
     QList<QPair<KoID, KoID> > supportedColorModels;
     supportedColorModels << QPair<KoID, KoID>()
             << QPair<KoID, KoID>(RGBAColorModelID, Integer8BitsColorDepthID)
             << QPair<KoID, KoID>(RGBAColorModelID, Integer16BitsColorDepthID)
             << QPair<KoID, KoID>(GrayAColorModelID, Integer8BitsColorDepthID)
             << QPair<KoID, KoID>(GrayAColorModelID, Integer16BitsColorDepthID);
     addSupportedColorModels(supportedColorModels, "PNG");
 }
 
 void KisWdgOptionsPNG::setConfiguration(const KisPropertiesConfigurationSP cfg)
 {
     // the export manager should have prepared some info for us!
     KIS_SAFE_ASSERT_RECOVER_NOOP(cfg->hasProperty(KisImportExportFilter::ImageContainsTransparencyTag));
     KIS_SAFE_ASSERT_RECOVER_NOOP(cfg->hasProperty(KisImportExportFilter::ColorModelIDTag));
     KIS_SAFE_ASSERT_RECOVER_NOOP(cfg->hasProperty(KisImportExportFilter::sRGBTag));
 
     const bool isThereAlpha = cfg->getBool(KisImportExportFilter::ImageContainsTransparencyTag);
 
     alpha->setChecked(cfg->getBool("alpha", isThereAlpha));
 
     bnTransparencyFillColor->setEnabled(!alpha->isChecked());
 
     if (cfg->getString(KisImportExportFilter::ColorModelIDTag) == RGBAColorModelID.id()) {
         tryToSaveAsIndexed->setVisible(true);
         if (alpha->isChecked()) {
             tryToSaveAsIndexed->setChecked(false);
         }
         else {
             tryToSaveAsIndexed->setChecked(cfg->getBool("indexed", false));
         }
     }
     else {
         tryToSaveAsIndexed->setVisible(false);
     }
     interlacing->setChecked(cfg->getBool("interlaced", false));
     compressionLevel->setValue(cfg->getInt("compression", 3));
     compressionLevel->setRange(1, 9, 0);
 
     tryToSaveAsIndexed->setVisible(!isThereAlpha);
 
     const bool sRGB = cfg->getBool(KisImportExportFilter::sRGBTag, false);
 
-    chkSRGB->setEnabled(sRGB);
+    //chkSRGB->setEnabled(sRGB);
     chkSRGB->setChecked(cfg->getBool("saveSRGBProfile", true));
 
-    chkForceSRGB->setEnabled(!sRGB);
+    //chkForceSRGB->setEnabled(!sRGB);
     chkForceSRGB->setChecked(cfg->getBool("forceSRGB", false));
 
     chkAuthor->setChecked(cfg->getBool("storeAuthor", false));
     chkMetaData->setChecked(cfg->getBool("storeMetaData", false));
 
     KoColor background(KoColorSpaceRegistry::instance()->rgb8());
     background.fromQColor(Qt::white);
     bnTransparencyFillColor->setDefaultColor(background);
     bnTransparencyFillColor->setColor(cfg->getColor("transparencyFillcolor", background));
 }
 
 KisPropertiesConfigurationSP KisWdgOptionsPNG::configuration() const
 {
 
     KisPropertiesConfigurationSP cfg(new KisPropertiesConfiguration());
 
     bool alpha = this->alpha->isChecked();
     bool interlace = interlacing->isChecked();
     int compression = (int)compressionLevel->value();
     bool tryToSaveAsIndexed = this->tryToSaveAsIndexed->isChecked();
     bool saveSRGB = chkSRGB->isChecked();
     bool forceSRGB = chkForceSRGB->isChecked();
     bool storeAuthor = chkAuthor->isChecked();
     bool storeMetaData = chkMetaData->isChecked();
 
     QVariant transparencyFillcolor;
     transparencyFillcolor.setValue(bnTransparencyFillColor->color());
 
     cfg->setProperty("alpha", alpha);
     cfg->setProperty("indexed", tryToSaveAsIndexed);
     cfg->setProperty("compression", compression);
     cfg->setProperty("interlaced", interlace);
     cfg->setProperty("transparencyFillcolor", transparencyFillcolor);
     cfg->setProperty("saveSRGBProfile", saveSRGB);
     cfg->setProperty("forceSRGB", forceSRGB);
     cfg->setProperty("storeAuthor", storeAuthor);
     cfg->setProperty("storeMetaData", storeMetaData);
 
     return cfg;
 }
 
 void KisWdgOptionsPNG::on_alpha_toggled(bool checked)
 {
     bnTransparencyFillColor->setEnabled(!checked);
 }
 
 #include "kis_png_export.moc"
 
diff --git a/plugins/impex/video/kis_video_export.cpp b/plugins/impex/video/kis_video_export.cpp
index 4c6a0ec609..06379a8a68 100644
--- a/plugins/impex/video/kis_video_export.cpp
+++ b/plugins/impex/video/kis_video_export.cpp
@@ -1,134 +1,136 @@
 /*
  *  Copyright (c) 2016 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "kis_video_export.h"
 
 #include <QCheckBox>
 #include <QSlider>
 #include <QMessageBox>
 
 #include <kpluginfactory.h>
 #include <QFileInfo>
 #include <QApplication>
 
 #include <kis_debug.h>
 #include <KisImportExportManager.h>
 #include <KoColorSpaceConstants.h>
 #include <KoDialog.h>
 #include "KisPart.h"
 #include <KisDocument.h>
 #include <kis_image.h>
 #include <kis_group_layer.h>
 #include <kis_paint_layer.h>
 #include <kis_paint_device.h>
 #include <kis_config.h>
 #include <kis_cursor_override_hijacker.h>
 
 #include "video_saver.h"
 #include "video_export_options_dialog.h"
 
 
 
 
 K_PLUGIN_FACTORY_WITH_JSON(KisVideoExportFactory, "krita_video_export.json", registerPlugin<KisVideoExport>();)
 
 KisVideoExport::KisVideoExport(QObject *parent, const QVariantList &) : KisImportExportFilter(parent)
 {
 }
 
 KisVideoExport::~KisVideoExport()
 {
 }
 
 KisImportExportFilter::ConversionStatus KisVideoExport::convert(KisDocument *document, QIODevice */*io*/,  KisPropertiesConfigurationSP configuration)
 {
     QString ffmpegPath = configuration->getString("ffmpeg_path");
     if (ffmpegPath.isEmpty()) {
         KisConfig cfg;
         ffmpegPath = cfg.customFFMpegPath();
         if (ffmpegPath.isEmpty()) {
             const QString warningMessage =
                     i18n("Could not find \'ffmpeg\' binary. Saving to video formats is impossible.");
 
             if (!batchMode()) {
                 QMessageBox::critical(KisPart::instance()->currentMainwindow(),
                                       i18n("Video Export Error"),
                                       warningMessage);
             }
             else {
                 qWarning() << warningMessage;
             }
             return KisImportExportFilter::UsageError;
         }
     }
 
     VideoSaver videoSaver(document, ffmpegPath, batchMode());
 
 
     KisImageBuilder_Result res = videoSaver.encode(filename(), configuration);
 
     if (res == KisImageBuilder_RESULT_OK) {
         return KisImportExportFilter::OK;
     }
     else if (res == KisImageBuilder_RESULT_CANCEL) {
         return KisImportExportFilter::ProgressCancelled;
     }
     else {
         document->setErrorMessage(i18n("FFMpeg failed to convert the image sequence. Check the logfile in your output directory for more information."));
     }
 
     return KisImportExportFilter::InternalError;
 }
 
 KisPropertiesConfigurationSP KisVideoExport::defaultConfiguration(const QByteArray &from, const QByteArray &to) const
 {
     Q_UNUSED(from);
     Q_ASSERT(!to.isEmpty());
 
     KisPropertiesConfigurationSP cfg(new KisPropertiesConfiguration());
 
     cfg->setProperty("h264PresetIndex", 5);
     cfg->setProperty("h264ConstantRateFactor", 23);
-    cfg->setProperty("h264ProfileIndex", 4);
+    // This was 4, 'high422', but Windows media player cannot play this profile, so
+    // lets default to 'baseline' instead.
+    cfg->setProperty("h264ProfileIndex", 0);
     cfg->setProperty("h264TuneIndex", 1);
     cfg->setProperty("TheoraBitrate", 5000);
     cfg->setProperty("CustomLineValue", "");
 
     if (to == "video/ogg") {
         cfg->setProperty("CodecIndex", VideoExportOptionsDialog::CODEC_THEORA);
     }
     else if (to == "video/x-matroska" || to == "video/mp4") {
         cfg->setProperty("CodecIndex", VideoExportOptionsDialog::CODEC_H264);
     }
     cfg->setProperty("mimetype", to);
 
     return cfg;
 }
 
 KisConfigWidget *KisVideoExport::createConfigurationWidget(QWidget *parent, const QByteArray &from, const QByteArray &to) const
 {
     Q_UNUSED(from);
     KisConfigWidget *w = 0;
     if (to != "image/gif") {
         w = new VideoExportOptionsDialog(parent);
     }
     return w;
 }
 
 #include "kis_video_export.moc"
diff --git a/plugins/impex/video/video_export_options_dialog.cpp b/plugins/impex/video/video_export_options_dialog.cpp
index 968b6c6efe..4dc7b5a362 100644
--- a/plugins/impex/video/video_export_options_dialog.cpp
+++ b/plugins/impex/video/video_export_options_dialog.cpp
@@ -1,252 +1,252 @@
 /*
  *  Copyright (c) 2016 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "video_export_options_dialog.h"
 #include "ui_video_export_options_dialog.h"
 
 #include <KoID.h>
 
 #include <ksharedconfig.h>
 #include <kconfiggroup.h>
 
 
 struct VideoExportOptionsDialog::Private
 {
     Private() {
         presets << KoID("ultrafast", i18nc("h264 preset name, check simplescreenrecorder for standard translations", "ultrafast"));
         presets << KoID("superfast", i18nc("h264 preset name, check simplescreenrecorder for standard translations", "superfast"));
         presets << KoID("veryfast", i18nc("h264 preset name, check simplescreenrecorder for standard translations", "veryfast"));
         presets << KoID("faster", i18nc("h264 preset name, check simplescreenrecorder for standard translations", "faster"));
         presets << KoID("fast", i18nc("h264 preset name, check simplescreenrecorder for standard translations", "fast"));
         presets << KoID("medium", i18nc("h264 preset name, check simplescreenrecorder for standard translations", "medium"));
         presets << KoID("slow", i18nc("h264 preset name, check simplescreenrecorder for standard translations", "slow"));
         presets << KoID("slower", i18nc("h264 preset name, check simplescreenrecorder for standard translations", "slower"));
         presets << KoID("veryslow", i18nc("h264 preset name, check simplescreenrecorder for standard translations", "veryslow"));
         presets << KoID("placebo", i18nc("h264 preset name, check simplescreenrecorder for standard translations", "placebo"));
 
         profiles << KoID("baseline", i18nc("h264 profile name, check simplescreenrecorder for standard translations", "baseline"));
         profiles << KoID("main", i18nc("h264 profile name, check simplescreenrecorder for standard translations", "main"));
         profiles << KoID("high", i18nc("h264 profile name, check simplescreenrecorder for standard translations", "high"));
         profiles << KoID("high10", i18nc("h264 profile name, check simplescreenrecorder for standard translations", "high10"));
         profiles << KoID("high422", i18nc("h264 profile name, check simplescreenrecorder for standard translations", "high422"));
         profiles << KoID("high444", i18nc("h264 profile name, check simplescreenrecorder for standard translations", "high444"));
 
         tunes << KoID("film", i18nc("h264 tune option name, check simplescreenrecorder for standard translations", "film"));
         tunes << KoID("animation", i18nc("h264 tune option name, check simplescreenrecorder for standard translations", "animation"));
         tunes << KoID("grain", i18nc("h264 tune option name, check simplescreenrecorder for standard translations", "grain"));
         tunes << KoID("stillimage", i18nc("h264 tune option name, check simplescreenrecorder for standard translations", "stillimage"));
         tunes << KoID("psnr", i18nc("h264 tune option name, check simplescreenrecorder for standard translations", "psnr"));
         tunes << KoID("ssim", i18nc("h264 tune option name, check simplescreenrecorder for standard translations", "ssim"));
         tunes << KoID("fastdecode", i18nc("h264 tune option name, check simplescreenrecorder for standard translations", "fastdecode"));
         tunes << KoID("zerolatency", i18nc("h264 tune option name, check simplescreenrecorder for standard translations", "zerolatency"));
     }
 
     QVector<KoID> presets;
     int defaultPreset;
     int defaultBitrate;
     int defaultConstantRateFactor;
 
     QVector<KoID> profiles;
     int defaultProfile;
 
     QVector<KoID> tunes;
     int defaultTune;
 
     QString defaultCustomLine;
     QString currentCustomLine;
 
     void updateDefaultCustomLine()
     {
         defaultCustomLine = currentCustomLine;
     }
 
 };
 
 
 VideoExportOptionsDialog::VideoExportOptionsDialog(QWidget *parent) :
     KisConfigWidget(parent),
     ui(new Ui::VideoExportOptionsDialog),
     m_d(new Private)
 {
     ui->setupUi(this);
 
     ui->intConstantRateFactor->setRange(0, 51);
     ui->intConstantRateFactor->setValue(m_d->defaultConstantRateFactor);
 
     Q_FOREACH (const KoID &preset, m_d->presets) {
         ui->cmbPreset->insertItem(ui->cmbPreset->count(), preset.name());
     }
     ui->cmbPreset->setCurrentIndex(m_d->defaultPreset);
 
     Q_FOREACH (const KoID &profile, m_d->profiles) {
         ui->cmbProfile->insertItem(ui->cmbProfile->count(), profile.name());
     }
     ui->cmbProfile->setCurrentIndex(m_d->defaultProfile);
 
     Q_FOREACH (const KoID &tune, m_d->tunes) {
         ui->cmbTune->insertItem(ui->cmbTune->count(), tune.name());
     }
     ui->cmbTune->setCurrentIndex(m_d->defaultTune);
 
     ui->intBitrate->setRange(10, 50000);
     ui->intBitrate->setValue(5000);
     ui->intBitrate->setSuffix(i18nc("kilo-bits-per-second, video bitrate suffix", "kbps"));
 
     connect(ui->cmbCodec, SIGNAL(currentIndexChanged(int)), ui->stackedWidget, SLOT(setCurrentIndex(int)));
 
     ui->cmbCodec->setCurrentIndex(0);
     ui->cmbCodec->setEnabled(false);
 
     // TODO: temporarily hidden! Some combinations of 'tune' and
     //       'profile' options make ffmpeg generate empty file.
     //       We should not let the user shoot into his own foot!
     ui->cmbTune->setVisible(false);
     ui->lblTune->setVisible(false);
 
     ui->chkCustomLine->setChecked(!m_d->defaultCustomLine.isEmpty());
     slotCustomLineToggled(!m_d->defaultCustomLine.isEmpty());
     connect(ui->chkCustomLine, SIGNAL(toggled(bool)), SLOT(slotCustomLineToggled(bool)));
     connect(ui->txtCustomLine, SIGNAL(editingFinished()), SLOT(slotSaveCustomLine()));
     connect(ui->btnResetCustomLine, SIGNAL(clicked()), SLOT(slotResetCustomLine()));
 }
 
 VideoExportOptionsDialog::~VideoExportOptionsDialog()
 {
     delete ui;
 }
 
 KisPropertiesConfigurationSP VideoExportOptionsDialog::configuration() const
 {
     KisPropertiesConfigurationSP cfg(new KisPropertiesConfiguration());
 
     cfg->setProperty("h264PresetIndex", ui->cmbPreset->currentIndex());
     cfg->setProperty("h264ConstantRateFactor", ui->intConstantRateFactor->value());
     cfg->setProperty("h264ProfileIndex", ui->cmbProfile->currentIndex());
     cfg->setProperty("h264TuneIndex", ui->cmbTune->currentIndex());
     cfg->setProperty("TheoraBitrate", ui->intBitrate->value());
     cfg->setProperty("CustomLineValue", ui->txtCustomLine->text());
     cfg->setProperty("customUserOptions", customUserOptions().join(' '));
 
     return cfg;
 }
 
 void VideoExportOptionsDialog::slotCustomLineToggled(bool value)
 {
     m_d->updateDefaultCustomLine();
     QString customLine = m_d->defaultCustomLine;
 
     if (customLine.isEmpty() && value) {
         customLine = generateCustomLine().join(" ");
     } else if (!value) {
         customLine = QString();
     }
 
     ui->txtCustomLine->setText(customLine);
 
     ui->stackedWidget->setEnabled(!value);
     ui->txtCustomLine->setEnabled(value);
     ui->btnResetCustomLine->setEnabled(value);
 }
 
 void VideoExportOptionsDialog::slotResetCustomLine()
 {
     ui->txtCustomLine->setText(generateCustomLine().join(" "));
     slotSaveCustomLine();
 }
 
 void VideoExportOptionsDialog::slotSaveCustomLine()
 {
     m_d->currentCustomLine = ui->txtCustomLine->text();
 }
 
 void VideoExportOptionsDialog::setCodec(CodecIndex index)
 {
     ui->cmbCodec->setCurrentIndex(int(index));
 }
 
 QStringList VideoExportOptionsDialog::customUserOptions() const
 {
     return ui->chkCustomLine->isChecked() ?
         ui->txtCustomLine->text().split(" ", QString::SkipEmptyParts) :
                 generateCustomLine();
 }
 
 void VideoExportOptionsDialog::setConfiguration(const KisPropertiesConfigurationSP cfg)
 {
     m_d->defaultPreset = cfg->getInt("h264PresetIndex", 5);
     ui->cmbPreset->setCurrentIndex(m_d->defaultPreset);
     m_d->defaultConstantRateFactor = cfg->getInt("h264ConstantRateFactor", 23);
     ui->intConstantRateFactor->setValue(m_d->defaultConstantRateFactor);
-    m_d->defaultProfile = cfg->getInt("h264ProfileIndex", 4);
+    m_d->defaultProfile = cfg->getInt("h264ProfileIndex", 0);
     ui->cmbProfile->setCurrentIndex(m_d->defaultProfile);
     m_d->defaultTune = cfg->getInt("h264TuneIndex", 1);
     ui->cmbTune->setCurrentIndex(m_d->defaultTune);
     m_d->defaultBitrate = cfg->getInt("TheoraBitrate", 5000);
     ui->intBitrate->setValue(m_d->defaultBitrate);
 
     m_d->defaultCustomLine = cfg->getString("CustomLineValue", QString());
     ui->txtCustomLine->setText(m_d->defaultCustomLine);
 
     if (!m_d->defaultCustomLine.isEmpty()) {
         m_d->currentCustomLine = m_d->defaultCustomLine;
         ui->chkCustomLine->setChecked(true);
     }
 
     ui->chkCustomLine->setChecked(!m_d->defaultCustomLine.isEmpty());
     slotCustomLineToggled(!m_d->defaultCustomLine.isEmpty());
 
     if (cfg->hasProperty("CodecIndex")) {
         setCodec((VideoExportOptionsDialog::CodecIndex)cfg->getInt("CodecIndex"));
     }
     if (cfg->getString("mimetype") == "video/ogg") {
         ui->cmbCodec->setEnabled(false);
     }
 }
 
 QStringList VideoExportOptionsDialog::generateCustomLine() const
 {
     QStringList options;
 
     if (ui->cmbCodec->currentIndex() == int(CODEC_H264)) {
         options << "-crf" << QString::number(ui->intConstantRateFactor->value());
 
         const int presetIndex = ui->cmbPreset->currentIndex();
         //qDebug() << "presetIndex" << presetIndex << m_d->presets;
         options << "-preset" << m_d->presets[presetIndex].id();
 
         const int profileIndex = ui->cmbProfile->currentIndex();
         options << "-profile" << m_d->profiles[profileIndex].id();
 
         if (m_d->profiles[profileIndex].id() == "high422") {
             options << "-pix_fmt" << "yuv422p";
         } else if (m_d->profiles[profileIndex].id() == "high444") {
             options << "-pix_fmt" << "yuv444p";
         } else {
             options << "-pix_fmt" << "yuv420p";
         }
 
         // Disabled! see the comment in c-tor!
         //const int tuneIndex = ui->cmbTune->currentIndex();
         //options << "-tune" << m_d->tunes[tuneIndex].id();
 
     } else if (ui->cmbCodec->currentIndex() == int(CODEC_THEORA)) {
         options << "-b" << QString::number(ui->intBitrate->value()) + "k";
     }
 
     return options;
 }
diff --git a/plugins/python/assignprofiledialog/assignprofiledialog.py b/plugins/python/assignprofiledialog/assignprofiledialog.py
index 1b3f2c7ddc..c4b92bec31 100644
--- a/plugins/python/assignprofiledialog/assignprofiledialog.py
+++ b/plugins/python/assignprofiledialog/assignprofiledialog.py
@@ -1,56 +1,59 @@
 '''
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 '''
 import sys
 from PyQt5.QtGui import *
 from PyQt5.QtWidgets import *
 from krita import *
 
 
 class AssignProfileDialog(Extension):
 
     def __init__(self, parent):
         super().__init__(parent)
 
     def assignProfile(self):
         doc = Application.activeDocument()
         if doc == None:
             QMessageBox.information(Application.activeWindow().qwindow(), "Assign Profile", "There is no active document.")
             return
 
         self.dialog = QDialog(Application.activeWindow().qwindow())
 
         self.cmbProfile = QComboBox(self.dialog)
         for profile in sorted(Application.profiles(doc.colorModel(), doc.colorDepth())):
             self.cmbProfile.addItem(profile)
 
         vbox = QVBoxLayout(self.dialog)
         vbox.addWidget(self.cmbProfile)
         self.buttonBox = QDialogButtonBox(self.dialog)
         self.buttonBox.setOrientation(QtCore.Qt.Horizontal)
         self.buttonBox.setStandardButtons(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
         self.buttonBox.accepted.connect(self.dialog.accept)
         self.buttonBox.accepted.connect(self.accept)
         self.buttonBox.rejected.connect(self.dialog.reject)
         vbox.addWidget(self.buttonBox)
         self.dialog.show()
         self.dialog.activateWindow()
         self.dialog.exec_()
 
     def accept(self):
         doc = Application.activeDocument()
         doc.setColorProfile(self.cmbProfile.currentText())
 
     def setup(self):
-        action = Application.createAction("assing_profile_to_image", "Assign Profile to Image")
+        pass
+    
+    def createActions(self, window):
+        action = window.createAction("assing_profile_to_image", "Assign Profile to Image")
         action.triggered.connect(self.assignProfile)
 
 Scripter.addExtension(AssignProfileDialog(Application))
diff --git a/plugins/python/colorspace/colorspace.py b/plugins/python/colorspace/colorspace.py
index 39d0cd5bb3..938326960b 100644
--- a/plugins/python/colorspace/colorspace.py
+++ b/plugins/python/colorspace/colorspace.py
@@ -1,31 +1,34 @@
 '''
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 '''
 import krita
 from colorspace import uicolorspace
 
 
 class ColorSpaceExtension(krita.Extension):
 
     def __init__(self, parent):
         super(ColorSpaceExtension, self).__init__(parent)
 
     def setup(self):
-        action = krita.Krita.instance().createAction("color_space", "Color Space")
+        pass
+    
+    def createActions(self, window):
+        action = window.createAction("color_space", "Color Space")
         action.setToolTip("Plugin to change color space to selected documents")
         action.triggered.connect(self.initialize)
 
     def initialize(self):
         self.uicolorspace = uicolorspace.UIColorSpace()
         self.uicolorspace.initialize()
 
 
 Scripter.addExtension(ColorSpaceExtension(krita.Krita.instance()))
diff --git a/plugins/python/comics_project_management_tools/README.html b/plugins/python/comics_project_management_tools/README.html
index 7e12f51205..92c2cbdd92 100644
--- a/plugins/python/comics_project_management_tools/README.html
+++ b/plugins/python/comics_project_management_tools/README.html
@@ -1,266 +1,266 @@
 <!DOCTYPE html>
 
 <html>
 <head><title>Comics Project Management Tools Plugin Manual</title>
 <style>
 
 body
 {
     margin:0 auto;
     max-width: 800px;
     min-width: 300px;
     padding: 1em;
 }
 
 h1
 {
     text-align:center;
 }
 
 h2
 {
     text-align:center;
     text-decoration:underline;
     padding-bottom:1em;
 }
 
 h3
 {
     text-align:center;
     font-style:italic;
     padding-bottom:1em;
 }
 
 dt
 {
     font-weight:700;
 }
 
 img
 {
     margin:0 auto;
     display:block;
 }
 
 </style>
 </head>
 <body>
 <h1 id="comics-project-management-tools">Comics Project Management Tools</h1>
 <h3>Version 2</h3>
 <p>This is the Comics Project Management Tools python plugin for Krita.</p>
 <p>CPMT aims to simplify comics creation by:</p>
 <ul>
 <li>Giving the artist a way to organize and quickly access their pages.</li>
 <li>Helping the artist(s) deal with the boring bits meta data bits of a comic project by giving a meta-data editor that gives suggestions, explanation and occasionally a dab of humor.</li>
 <li>Making export set-and-forget type of affair where a single click can export to multiple formats with proper meta-data.</li>
 </ul>
 <p>Export-wise, CPMT aims to support:</p>
 <dl>
 <dt>Advanced Comic Book Format</dt>
 <dd>An open comics format that has detailed markup as well as support for translations.
 </dd>
 <dt>CBZ</dt>
 <dd>the most popular comic file format, with the following meta-data schemes:
     <ul>
         <li>ACBF - as above.</li>
         <li>CoMet.xml</li>
         <li>ComicBookInfo (Spec is unclear so not 100% certain)</li>
         <li> ComicInfo.xml(Comic Rack)</li>
     </ul>
 </dd>
 <dt>Epub</dt>
 <dd>The epub publishing format. Not the most ideal format for handling comics, but most readers can open epub.
 </dd>
 </dl>
 
 <h2 id="toc">Table of Contents:</h2>
 
 <ol class="toc">
 <li><a href="#usage---quick-start-guide">Usage - quick-start guide</a></li>
 <li>
     <a href="#usage---meta-data">Usage - Meta Data</a>
         <ol>
             <li><a href="#adding-extra-auto-completion-keys.">Adding extra auto-completion keys.</a></li>
             <li><a href="#the-author-list">The Author list</a></li>
         </ol>
 </li>
 <li><a href="#usage---pages">Usage - Pages</a></li>
 <ol><li><a href="#comicviewer">The Comic Viewer</a></li></ol>
 <li><a href="#usage---copy-location">Usage - Copy Location</a></li>
 <li>
     <a href="#usage---export">Usage - Export</a>
         <ol>
             <li><a href="#acbf">ACBF</a></li>
         </ol>
 </li>
 </ol>
 
 
 <h2 id="usage---quick-start-guide">Usage - quick-start guide:</h2>
 <p>First, get the comic manager docker(settings &rarr; dockers &rarr; comic Management Docker). There, select <em>New Project</em>.</p>
 <p>It will show a dialog asking for:</p>
 <dl>
 <dt>The project directory.</dt>
 <dd>This is where everything will be written to.
 </dd>
 <dt>Concept</dt>
 <dd>so a simple sentence explaining what you want to write the comic about. This concept is just for you.
 </dd>
 <dt>Project name.</dt>
 <dd>This is not the title, but more of a code name which will be used to create pages. For the impatient artist there is even a generator that produces code names.
 </dd>
 <dt>Language</dt>
 <dd>The main language, used for all the meta data. By default set to the system locale.
 </dd>
 <dt>Make a new directory with the project name.</dt>
 <dd>Whether to make a new project directory inside the selected directory. This allows you to have a generic comics directory that you always select and that CPMT will make directories named with the project name inside.
 </dd>
 <dt>Pages</dt>
 <dd>The name for the directory to store the pages. This is where new pages are placed.
 </dd>
 <dt>Export</dt>
 <dd>The name for the directory to store the export. This is where the comic will be exported to.
 </dd>
 <dt>Templates</dt>
 <dd>The name for the directory to store the template. This is where the page templates get stored.
 </dd>
 <dt>Translations</dt>
 <dd>The translations directory is where the POT file will be stored and where the exporter searches for translation(PO) files.</dd>
 </dl>
 <p>It will also allow you to edit meta data if you'd want already, but this is not mandatory.</p>
 <p>Then after you finish, select <em>Open Project</em>, go to the location where you have stored your comics project. There should be a &ldquo;comicsConfig.json&rdquo; file there, next to the new folders for the pages, templates and export. Open that.</p>
 <p>Now, click <em>Add Page</em> to add your first page. You will get a dialog asking for the template. Here you can generate one, or import one. CPMT will remember this as the default one.</p>
 <p>Double click the new page to open in Krita.</p>
 <p>The second column in the docker allows you to see the &ldquo;subject&rdquo; line in the document info if it's filled in.</p>
 <p>You can press the arrow next to <em>Add Page</em> to get more features, like <em>Add Existing Page</em>, <em>Remove Page</em>, or <em>Batch Resize</em>.</p>
 <h2 id="usage---meta-data">Usage - Meta Data</h2>
 <p>You can edit the meta data by clicking the dropdown next to <em>Project Settings</em> and selecting <em>Meta Data</em>.</p>
 <p>There's quite a few fields here, because there's quite a few different types of meta data. Hover over the fields to get an idea of what needs to be typed.</p>
 <p>The meta data is intended to be filled out over the course of the project, so don't worry too much if you cannot instantly think of what a certain entry should be.</p>
 <p>The meta data fields have auto completion wherever sensible. You can add your own meta data fields as noted in the following section:</p>
 <h3 id="adding-extra-auto-completion-keys.">Adding extra auto-completion keys.</h3>
 <p>First, you need to go to project settings, and there point the extra keys to a folder where extra keys can be found.</p>
 <p>It will search that extra folder for the following folders:</p>
 <ul>
 <li>key_genre</li>
 <li>key_format</li>
 <li>key_rating</li>
 <li>key_characters</li>
 <li>key_author_roles</li>
 <li>key_other</li>
 </ul>
 <p>You can add extra auto-completion keys by adding a text file with each new key on a separate line to one of the &ldquo;key&rdquo; folders. The name of the text file doesn't matter. This way you can add characters by universe, or archive specific keywords by archive name.</p>
 <p>So for example, the following file has three superhero names on different lines, nothing more, nothing less.</p>
 <pre><code> Spider-Man
  Hawkeye
  Jean Grey</code></pre>
 <p>When you then store it as marvel.txt put into the directory &ldquo;key_characters&rdquo;, Krita will use the names from the list as suggestion for the character field in the meta-data.</p>
 <p>The exception is the key_ratings, which uses CSV files, using the top row to determine the title, and then has the rating in the first column, and the description on the second. This allows the description to show up as tool-tips.</p>
 <h3 id="the-author-list">The Author list</h3>
 <p>The author list is a table containing all the authors of the project. It allows a distinction between given, family, middle and nickname, as well as role, email and homepage.</p>
 <p>You can rearrange the author list by drag and dropping the number at the left, as well as adding and removing authors.</p>
 <p>Adding an author will always add &ldquo;John Doe&rdquo;. You can double click the names and cells to change their contents. For the role, there are auto completion keys, so to encourage using standardized ways to describe their roles.</p>
 <p>In the main docker, there's an option under the pages actions called <em>Scrape Authors</em>, this will make the comics project docker search the pages in the pages list for author info and append that to the author list. It will not attempt to check for duplicates, so be sure to the list afterwards.</p>
 <h2 id="usage---project-settings">Usage - Project Settings</h2>
 <p>The project settings allows you to change all the technical details of the project:</p>
 <ul>
 <li>the project name</li>
 <li>the concept</li>
 <li>the location of pages, export and templates</li>
 <li>the default template.</li>
 <li>the location of the extra auto-completion keys(see metadata)</li>
 </ul>
 <h2 id="usage---pages">Usage - Pages</h2>
 <p>There's several other things you can do with pages. You can either access these feature by clicking the drop-down next to <em>Add Page</em> or right-clicking the pages list.</p>
 <dt>Adding pages</dt>
 <dd>You can add pages by pressing the <em>Add Page</em> button. The first time you press this, it'll ask for a template. After you create or select a template it will use this as the default. You can set the default in the project settings.
 </dd>
 <dt>Adding pages from template:</dt>
 <dd>Adding pages from a template will always give the template dialog. This will allow you to have several different templates in the templates directory(it will show all the kra files in the templates directory), so that you can have spread, coverpages and other pages at your finger tips. The create template dialog will allow you to make a simple two layer image with a white background, and rulers for the bleeds and guides. Import template will copy selected templates to the template directory, keeping all the necessary files inside the comics project.
 </dd>
 <dt>Remove a page</dt>
 <dd>This allows you to remove the selected page in the list from the pages list. It does NOT delete the page from the disk.
 </dd>
 <dt>Adding existing pages</dt>
 <dd>This is for when you wish to add existing pages, either because you removed the page from the list, or because you already have a project going and wish to add the pages to the list.
 </dd>
 <dt>Batch Resize</dt>
 <dd>This will show a window with resize options. After selecting the right options, all the pages will be resized as such. A progress dialog will pop up showing you which pages have been done and how long it will take based on the passed time.
 </dd>
 <dt>View Page in Window</dt>
 <dd>This will call up the comic viewer.</dd>
 <dt>Scrape Authors</dt>
 <dd>This searches all the files from the pages list for author information and adds that to the author list. It will not check for copies, so you will need to clean up the author list yourself.</dd>
 <dt>Scrape Text for Translations</dt>
 <dd>This triggers a script that will go over each page and take out certain text information it can find. It will use the 'text layer keys' in the export dialog to determine whether a vector layer's text ought to be considered. Then, when done, it will put the text it found into a POT file, together with translatable meta-data, like the comic title, and will save it in the translations folder. The POT file can then be used by translators(using something like PO edit) to create a PO file. The CPMT can in turn use the PO files in the creation of ACBF files which'll embed the translations.</dd>
 <dt>Rearranging pages</dt>
-<dd>You can rearrange pages by moving the number on the left of the page up or down.
+<dd>You can rearrange pages by drag and dropping the pages themselves.
 </dd>
 <h3 id="comicviewer">The Comic Viewer</h3>
 <p>When you rightclick the pages, or press the down button next to <span style="font-style: italic;">Add Page</span>, There's the option <span style="font-style: italic;">View page in window.</span>This will pop up a comic viewer, which is each page's mergedimage.png file(that is a preview of all visible layers merged), and you can flip through them. This is so that you can have a quick reference for a single page in the event your other referencing tools cannot open kra files.</p>
 <dl>
 <dt>First, Last</dt>
 <dd>These will set the viewer to the last or first page in the comic. The hotkeys for these are <kbd>Home</kbd> and <kbd>End</kbd> respectively. These buttons will switch position based on the reading direction configured for the comic.</dd>
 <dt>Previous, Next</dt>
 <dd>These buttons allow you to switch spaces. The hotkeys for these are <kbd>&larr;</kbd> and <kbd>&rarr;</kbd> respectively. You can also use <kbd>Space</kbd> to switch to the next page. These buttons will switch position based on the reading direction configured for the comic.</dd>
 <dt>Spread, single</dt>
 <dd>This button will allow you to switch to single or spread mode.</dd>
 </dl>
 <p>You can also run the comic viewer standalone:</p>
 <pre><code>python3 comics_project_page_viewer.py /path/to/your/comicConfig.json</code></pre>
 <h2 id="usage---copy-location">Usage - Copy Location</h2>
 <p>Copy location, the button underneath the export button, allows you to copy the current project location to clipboard. Just press it, and paste somewhere else. This is useful when using multiple programs and reference tools and you just want to quickly navigate to the project directory.</p>
 <h2 id="usage---export">Usage - Export</h2>
 <p>CPMT will not allow export without any export methods set.</p>
 <p>You can configure the export settings by going to the drop-down next to <em>Project Settings</em> and selecting <em>Export Settings</em>.</p>
 <p>Here you can define...</p>
 <ul>
 <li>how much a page needs to be cropped</li>
 <li>which layers to remove by layer color-label</li>
 <li>to which formats to export, in what file-format and how to resize.</li>
 </ul>
 <p>Once you've done that, press export. Krita will pop up a progress bar for you with the estimated time and progress, so you can estimate how long you will have to wait.</p>
 <p>CPMT will store the resized files and meta data in separate folders in the export folder. This is so that you can perform optimization methods afterwards and update everything quickly.</p>
 <h3 id="acbf">ACBF</h3>
 <p>ACBF is the advanced comic book format. It is a metadata file that can hold extra data like panels and text, and can even store translations for the text.</p>
 <p>When you generate a CBZ file, the ACBF file will be generated alongside of it. There's in fact two ACBF files being generated: The one in the metadata folder is the ACBF file as it is inside the CBZ. The other ACBF file, next to the CBZ is the standalonefile. This file has the pages embedded, but there's currently fewer viewers who can read it.</p>
 <p>ACBF has a set amount of genres it can cover. This is the default list of genre auto completion keys. Genres outside that will be put into the extra keywords list for ACBF. On top of that, it does allow defining a match to this genre. To set a match to a genre, write a number in brackets indicating how much it matches this genre. So for example &ldquo;Horror(60), Science Fiction(40)&rdquo;will have Horror set to 60% and Science Fiction set to 40%. These values are normalized. So if you put in &ldquo;Romance(550), Fantasy(650)&rdquo;it will ensure that the two values will become percentages, leading to Romance being set to 46% and Fantasy set to 54%.</p>
 <p>The CPMT has some support for frames and text export. If you name a vector layer &ldquo;text&rdquo; or &ldquo;panels&rdquo; it will search those for shapes. The shapes that are text nodes will be added to the ACBF file as a text in the main language of the comic, using the bounding box of the text-shape. The shapes that aren't text will have their bounding boxes used as frames. The order of frames and text is determined by the shape z-order in Krita, with the bottom shape being the first and the top shape being the last. You can customize these layer selection keys in the export settings dialog.</p>
 <p>The CPMT also support translations. ACBF will use the PO files stored in the translations folder. In the export dialog, you can configure whether you want translation comments to be embeded. Then, if there's translation comments in the PO file, ACBF will put those in the reference section and add a link to the line with the translation comment. Translations will have translator note headers. You can configure these in the export, and they will also be put into the POT file when it is generated so they may be translated.</p>
 <p>Finally, there's the styles and the text type. You can configure the styles in the export settings dialog tab for acbf. The exporter will use the configuration and alignment to automatically figure out the text-type in the export.</p>
 <ul>
 <li>Text that is justified will use the &ldquo;formal&rdquo;type. There's no method to currently make justified text, so this won't trigger until then</li>
 <li>Text that is centered will have it's font family compared to the existing styles and their font-families. If it finds a match that will be the type</li>
 <li>Text that is neither will be marked with &ldquo;commentary&rdquo;, that is, it is considered a narrative caption.</li>
 </ul>
 <p>To fine tune the export to ACBF, you can go to file&rarr;document Information and add the following keywords:</p>
 <dl>
 <dt>acbf_title</dt>
 <dd>this will flag this page to be used as a table of contents bookmark inside ACBF. The content mark will use the &ldquo;title&rdquo; value in the document information to create a bookmark in the project language.
 </dd>
 <dt>acbf_none</dt>
 <dd>Sets the page transition value to &ldquo;none&rdquo; explicitly.
 </dd>
 <dt>acbf_fade</dt>
 <dd>Sets the page transitio to fade. Viewers that support it will fade to black into this page.
 </dd>
 <dt>acbf_blend</dt>
 <dd>Sets the page transition to blend. Viewers that support it will fade the previous page to this one.
 </dd>
 <dt>acbf_horizontal</dt>
 <dd>Sets the page transition to scroll_right. Viewers that support it will scroll right to a new page.
 </dd>
 <dt>acbf_vertical</dt>
 <dd>Sets the page transition to scroll_down. Viewers that support it will scroll down to a new page.
 </dd>
 </dl>
 <h2>Version History</h2>
 <p>Because the comic project management tools are bundled with Krita you could argue that you can identify them that way, but here is a history anyway, so you can check what has changed.</p>
 <dl>
 <dt>Version 2</dt>
-<dd>90% ACBF support, with improved handling of text, translation support, new keys for genres and author roles, style sheets, text-type recognition, database ref, and background color support. The Comic Page viewer has been fully rewritten to handle flipping through the pages as well as made possible to be run standalone.</dd>
+<dd>90% ACBF support, with improved handling of text, translation support, new keys for genres and author roles, style sheets, text-type recognition, database ref, and background color support. The Comic Page viewer has been fully rewritten to handle flipping through the pages as well as made possible to be run standalone. Furthermore, the comic page viewer has gotten its own dedicated item delegate, meaning the page metadata is drawn nicely and drag and drop is less fiddly.</dd>
 <dt>Version 1 (Krita 4.0)</dt>
 <dd>The initial tools, with project management, page management, meta data management complete with autocompletion keys, copy-location, export to epub, tiff, cbz, and export to zipfile info, ComicInfo.xml and CoMet.xml, and for ACBF support for panels, text and basic metadata. Other features include batch resize, page templates, and author data scraping.</dd>
 </dl>
 </body>
 </html>
diff --git a/plugins/python/comics_project_management_tools/comics_project_manager_docker.py b/plugins/python/comics_project_management_tools/comics_project_manager_docker.py
index 4e9cd0869c..db36d508c3 100644
--- a/plugins/python/comics_project_management_tools/comics_project_manager_docker.py
+++ b/plugins/python/comics_project_management_tools/comics_project_manager_docker.py
@@ -1,798 +1,919 @@
 """
 Copyright (c) 2017 Wolthera van Hövell tot Westerflier <griffinvalley@gmail.com>
 
 This file is part of the Comics Project Management Tools(CPMT).
 
 CPMT 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 3 of the License, or
 (at your option) any later version.
 
 CPMT 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 the CPMT.  If not, see <http://www.gnu.org/licenses/>.
 """
 
 """
 This is a docker that helps you organise your comics project.
 """
 import sys
 import json
 import os
 import zipfile  # quick reading of documents
 import shutil
+import enum
+from math import floor
 import xml.etree.ElementTree as ET
-from PyQt5.QtCore import QElapsedTimer, QSize, Qt
-from PyQt5.QtGui import QStandardItem, QStandardItemModel, QImage, QIcon, QPixmap, QFontMetrics
-from PyQt5.QtWidgets import QHBoxLayout, QVBoxLayout, QTableView, QToolButton, QMenu, QAction, QPushButton, QSpacerItem, QSizePolicy, QWidget, QAbstractItemView, QProgressDialog, QDialog, QFileDialog, QDialogButtonBox, qApp, QSplitter, QSlider, QLabel
+from PyQt5.QtCore import QElapsedTimer, QSize, Qt, QRect
+from PyQt5.QtGui import QStandardItem, QStandardItemModel, QImage, QIcon, QPixmap, QFontMetrics, QPainter, QPalette, QFont
+from PyQt5.QtWidgets import QHBoxLayout, QVBoxLayout, QListView, QToolButton, QMenu, QAction, QPushButton, QSpacerItem, QSizePolicy, QWidget, QAbstractItemView, QProgressDialog, QDialog, QFileDialog, QDialogButtonBox, qApp, QSplitter, QSlider, QLabel, QStyledItemDelegate, QStyle
 import math
 from krita import *
 from . import comics_metadata_dialog, comics_exporter, comics_export_dialog, comics_project_setup_wizard, comics_template_dialog, comics_project_settings_dialog, comics_project_page_viewer, comics_project_translation_scraper
 
 """
 A very simple class so we can have a label that is single line, but doesn't force the
 widget size to be bigger.
 This is used by the project name.
 """
 
 
 class Elided_Text_Label(QLabel):
     mainText = str()
 
     def __init__(self, parent=None):
         super(QLabel, self).__init__(parent)
         self.setMinimumWidth(self.fontMetrics().width("..."))
         self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
 
     def setMainText(self, text=str()):
         self.mainText = text
         self.elideText()
 
     def elideText(self):
         self.setText(self.fontMetrics().elidedText(self.mainText, Qt.ElideRight, self.width()))
 
     def resizeEvent(self, event):
         self.elideText()
 
+class CPE(enum.IntEnum):
+    TITLE = Qt.DisplayRole
+    URL = Qt.UserRole + 1
+    KEYWORDS = Qt.UserRole+2
+    DESCRIPTION = Qt.UserRole+3
+    LASTEDIT = Qt.UserRole+4
+    EDITOR = Qt.UserRole+5
+    IMAGE = Qt.DecorationRole
+
+class comic_page_delegate(QStyledItemDelegate):
+
+    def __init__(self, parent=None):
+        super(QStyledItemDelegate, self).__init__(parent)
+
+    def paint(self, painter, option, index):
+        
+        if (index.isValid() == False):
+            return
+        painter.save()
+        painter.setOpacity(0.6)
+        if(option.state & QStyle.State_Selected):
+            painter.fillRect(option.rect, option.palette.highlight())
+        if (option.state & QStyle.State_MouseOver):
+            painter.setOpacity(0.25)
+            painter.fillRect(option.rect, option.palette.highlight())
+        painter.setOpacity(1.0)
+        painter.setFont(option.font)
+        metrics = QFontMetrics(option.font)
+        regular = QFont(option.font)
+        italics = QFont(option.font)
+        italics.setItalic(True)
+        icon = QIcon(index.data(CPE.IMAGE))
+        rect = option.rect
+        margin = 4
+        decoratonSize = QSize(option.decorationSize)
+        imageSize = icon.actualSize(option.decorationSize)
+        leftSideThumbnail = (decoratonSize.width()-imageSize.width())/2
+        if (rect.width() < decoratonSize.width()):
+            leftSideThumbnail = max(0, (rect.width()-imageSize.width())/2)
+        topSizeThumbnail = ((rect.height()-imageSize.height())/2)+rect.top()
+        painter.drawImage(QRect(leftSideThumbnail, topSizeThumbnail, imageSize.width(), imageSize.height()), icon.pixmap(imageSize).toImage())
+        
+        labelWidth = rect.width()-decoratonSize.width()-(margin*3)
+        
+        if (decoratonSize.width()+(margin*2)< rect.width()):
+        
+            textRect = QRect(decoratonSize.width()+margin, margin+rect.top(), labelWidth, metrics.height())
+            textTitle = metrics.elidedText(str(index.row()+1)+". "+index.data(CPE.TITLE), Qt.ElideRight, labelWidth)
+            painter.drawText(textRect, Qt.TextWordWrap, textTitle)
+            
+            if rect.height()/(metrics.lineSpacing()+margin) > 5 or index.data(CPE.KEYWORDS) is not None:
+                painter.setOpacity(0.6)
+                textRect = QRect(textRect.left(), textRect.bottom()+margin, labelWidth, metrics.height())
+                if textRect.bottom() < rect.bottom():
+                    textKeyWords = index.data(CPE.KEYWORDS)
+                    if textKeyWords == None:
+                        textKeyWords = i18n("No keywords")
+                        painter.setOpacity(0.3)
+                        painter.setFont(italics)
+                    textKeyWords = metrics.elidedText(textKeyWords, Qt.ElideRight, labelWidth)
+                    painter.drawText(textRect, Qt.TextWordWrap, textKeyWords)
+            
+            painter.setFont(regular)
+            
+            if rect.height()/(metrics.lineSpacing()+margin) > 3:
+                painter.setOpacity(0.6)
+                textRect = QRect(textRect.left(), textRect.bottom()+margin, labelWidth, metrics.height())
+                if textRect.bottom()+metrics.height() < rect.bottom():
+                    textLastEdit = index.data(CPE.LASTEDIT)
+                    if textLastEdit is None:
+                        textLastEdit = i18n("No last edit timestamp")
+                    if index.data(CPE.EDITOR) is not None:
+                        textLastEdit += " - " + index.data(CPE.EDITOR)
+                    if (index.data(CPE.LASTEDIT) is None) and (index.data(CPE.EDITOR) is None):
+                        painter.setOpacity(0.3)
+                        painter.setFont(italics)
+                    textLastEdit = metrics.elidedText(textLastEdit, Qt.ElideRight, labelWidth)
+                    painter.drawText(textRect, Qt.TextWordWrap, textLastEdit)
+            
+            painter.setFont(regular)
+            
+            descRect = QRect(textRect.left(), textRect.bottom()+margin, labelWidth, (rect.bottom()-margin) - (textRect.bottom()+margin))
+            if textRect.bottom()+metrics.height() < rect.bottom():
+                textRect.setBottom(textRect.bottom()+(margin/2))
+                textRect.setLeft(textRect.left()-(margin/2))
+                painter.setOpacity(0.4)
+                painter.drawLine(textRect.bottomLeft(), textRect.bottomRight())
+                painter.setOpacity(1.0)
+                textDescription = index.data(CPE.DESCRIPTION)
+                if textDescription is None:
+                    textDescription = i18n("No description")
+                    painter.setOpacity(0.3)
+                    painter.setFont(italics)
+                linesTotal = floor(descRect.height()/metrics.lineSpacing())
+                if linesTotal == 1:
+                    textDescription = metrics.elidedText(textDescription, Qt.ElideRight, labelWidth)
+                    painter.drawText(descRect, Qt.TextWordWrap, textDescription)
+                else:
+                    descRect.setHeight(linesTotal*metrics.lineSpacing())
+                    totalDescHeight = metrics.boundingRect(descRect, Qt.TextWordWrap, textDescription).height()
+                    if totalDescHeight>descRect.height():
+                        if totalDescHeight-metrics.lineSpacing()>descRect.height():
+                            painter.setOpacity(0.5)
+                            painter.drawText(descRect, Qt.TextWordWrap, textDescription)
+                            descRect.setHeight((linesTotal-1)*metrics.lineSpacing())
+                            painter.drawText(descRect, Qt.TextWordWrap, textDescription)
+                            descRect.setHeight((linesTotal-2)*metrics.lineSpacing())
+                            painter.drawText(descRect, Qt.TextWordWrap, textDescription)
+                        else:
+                            painter.setOpacity(0.75)
+                            painter.drawText(descRect, Qt.TextWordWrap, textDescription)
+                            descRect.setHeight((linesTotal-1)*metrics.lineSpacing())
+                            painter.drawText(descRect, Qt.TextWordWrap, textDescription)
+                    else:
+                        painter.drawText(descRect, Qt.TextWordWrap, textDescription)
+            
+            painter.setFont(regular)
+        
+        painter.restore()
+
 
 """
 This is a Krita docker called 'Comics Manager'.
 
 It allows people to create comics project files, load those files, add pages, remove pages, move pages, manage the metadata,
 and finally export the result.
 
 The logic behind this docker is that it is very easy to get lost in a comics project due to the massive amount of files.
 By having a docker that gives the user quick access to the pages and also allows them to do all of the meta-stuff, like
 meta data, but also reordering the pages, the chaos of managing the project should take up less time, and more time can be focussed on actual writing and drawing.
 """
 
 
 class comics_project_manager_docker(DockWidget):
     setupDictionary = {}
     stringName = i18n("Comics Manager")
     projecturl = None
 
     def __init__(self):
         super().__init__()
         self.setWindowTitle(self.stringName)
 
         # Setup layout:
         base = QHBoxLayout()
         widget = QWidget()
         widget.setLayout(base)
         baseLayout = QSplitter()
         base.addWidget(baseLayout)
         self.setWidget(widget)
         buttonLayout = QVBoxLayout()
         buttonBox = QWidget()
         buttonBox.setLayout(buttonLayout)
         baseLayout.addWidget(buttonBox)
 
         # Comic page list and pages model
-        self.comicPageList = QTableView()
-        self.comicPageList.verticalHeader().setSectionsMovable(True)
-        self.comicPageList.verticalHeader().setDragEnabled(True)
-        self.comicPageList.verticalHeader().setDragDropMode(QAbstractItemView.InternalMove)
+        self.comicPageList = QListView()
+        self.comicPageList.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+        self.comicPageList.setDragEnabled(True)
+        self.comicPageList.setDragDropMode(QAbstractItemView.InternalMove)
         self.comicPageList.setAcceptDrops(True)
-        self.comicPageList.horizontalHeader().setStretchLastSection(True)
+        self.comicPageList.setItemDelegate(comic_page_delegate())
         self.pagesModel = QStandardItemModel()
         self.comicPageList.doubleClicked.connect(self.slot_open_page)
         self.comicPageList.setIconSize(QSize(128, 128))
         # self.comicPageList.itemDelegate().closeEditor.connect(self.slot_write_description)
         self.pagesModel.layoutChanged.connect(self.slot_write_config)
         self.pagesModel.rowsInserted.connect(self.slot_write_config)
         self.pagesModel.rowsRemoved.connect(self.slot_write_config)
-        self.comicPageList.verticalHeader().sectionMoved.connect(self.slot_write_config)
+        self.pagesModel.rowsMoved.connect(self.slot_write_config)
         self.comicPageList.setModel(self.pagesModel)
         pageBox = QWidget()
         pageBox.setLayout(QVBoxLayout())
         zoomSlider = QSlider(Qt.Horizontal, None)
         zoomSlider.setRange(1, 8)
         zoomSlider.setValue(4)
         zoomSlider.setTickInterval(1)
         zoomSlider.setMinimumWidth(10)
         zoomSlider.valueChanged.connect(self.slot_scale_thumbnails)
         self.projectName = Elided_Text_Label()
         pageBox.layout().addWidget(self.projectName)
         pageBox.layout().addWidget(zoomSlider)
         pageBox.layout().addWidget(self.comicPageList)
         baseLayout.addWidget(pageBox)
 
         self.btn_project = QToolButton()
         self.btn_project.setPopupMode(QToolButton.MenuButtonPopup)
         self.btn_project.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
         menu_project = QMenu()
         self.action_new_project = QAction(i18n("New Project"), self)
         self.action_new_project.triggered.connect(self.slot_new_project)
         self.action_load_project = QAction(i18n("Open Project"), self)
         self.action_load_project.triggered.connect(self.slot_open_config)
         menu_project.addAction(self.action_new_project)
         menu_project.addAction(self.action_load_project)
         self.btn_project.setMenu(menu_project)
         self.btn_project.setDefaultAction(self.action_load_project)
         buttonLayout.addWidget(self.btn_project)
 
         # Settings dropdown with actions for the different settings menus.
         self.btn_settings = QToolButton()
         self.btn_settings.setPopupMode(QToolButton.MenuButtonPopup)
         self.btn_settings.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
         self.action_edit_project_settings = QAction(i18n("Project Settings"), self)
         self.action_edit_project_settings.triggered.connect(self.slot_edit_project_settings)
         self.action_edit_meta_data = QAction(i18n("Meta Data"), self)
         self.action_edit_meta_data.triggered.connect(self.slot_edit_meta_data)
         self.action_edit_export_settings = QAction(i18n("Export Settings"), self)
         self.action_edit_export_settings.triggered.connect(self.slot_edit_export_settings)
         menu_settings = QMenu()
         menu_settings.addAction(self.action_edit_project_settings)
         menu_settings.addAction(self.action_edit_meta_data)
         menu_settings.addAction(self.action_edit_export_settings)
         self.btn_settings.setDefaultAction(self.action_edit_project_settings)
         self.btn_settings.setMenu(menu_settings)
         buttonLayout.addWidget(self.btn_settings)
         self.btn_settings.setDisabled(True)
 
         # Add page drop down with different page actions.
         self.btn_add_page = QToolButton()
         self.btn_add_page.setPopupMode(QToolButton.MenuButtonPopup)
         self.btn_add_page.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
 
         self.action_add_page = QAction(i18n("Add Page"), self)
         self.action_add_page.triggered.connect(self.slot_add_new_page_single)
         self.action_add_template = QAction(i18n("Add Page From Template"), self)
         self.action_add_template.triggered.connect(self.slot_add_new_page_from_template)
         self.action_add_existing = QAction(i18n("Add Existing Pages"), self)
         self.action_add_existing.triggered.connect(self.slot_add_page_from_url)
         self.action_remove_selected_page = QAction(i18n("Remove Page"), self)
         self.action_remove_selected_page.triggered.connect(self.slot_remove_selected_page)
         self.action_resize_all_pages = QAction(i18n("Batch Resize"), self)
         self.action_resize_all_pages.triggered.connect(self.slot_batch_resize)
         self.btn_add_page.setDefaultAction(self.action_add_page)
         self.action_show_page_viewer = QAction(i18n("View Page In Window"), self)
         self.action_show_page_viewer.triggered.connect(self.slot_show_page_viewer)
         self.action_scrape_authors = QAction(i18n("Scrape Author Info"), self)
         self.action_scrape_authors.setToolTip(i18n("Search for author information in documents and add it to the author list. This doesn't check for duplicates."))
         self.action_scrape_authors.triggered.connect(self.slot_scrape_author_list)
         self.action_scrape_translations = QAction(i18n("Scrape Text for Translation"), self)
         self.action_scrape_translations.triggered.connect(self.slot_scrape_translations)
         actionList = []
         menu_page = QMenu()
         actionList.append(self.action_add_page)
         actionList.append(self.action_add_template)
         actionList.append(self.action_add_existing)
         actionList.append(self.action_remove_selected_page)
         actionList.append(self.action_resize_all_pages)
         actionList.append(self.action_show_page_viewer)
         actionList.append(self.action_scrape_authors)
         actionList.append(self.action_scrape_translations)
         menu_page.addActions(actionList)
         self.btn_add_page.setMenu(menu_page)
         buttonLayout.addWidget(self.btn_add_page)
         self.btn_add_page.setDisabled(True)
 
         self.comicPageList.setContextMenuPolicy(Qt.ActionsContextMenu)
         self.comicPageList.addActions(actionList)
 
         # Export button that... exports.
         self.btn_export = QPushButton(i18n("Export Comic"))
         self.btn_export.clicked.connect(self.slot_export)
         buttonLayout.addWidget(self.btn_export)
         self.btn_export.setDisabled(True)
 
         self.btn_project_url = QPushButton(i18n("Copy Location"))
         self.btn_project_url.setToolTip(i18n("Copies the path of the project to the clipboard. Useful for quickly copying to a file manager or the like."))
         self.btn_project_url.clicked.connect(self.slot_copy_project_url)
         self.btn_project_url.setDisabled(True)
         buttonLayout.addWidget(self.btn_project_url)
 
         self.page_viewer_dialog = comics_project_page_viewer.comics_project_page_viewer()
 
         Application.notifier().imageSaved.connect(self.slot_check_for_page_update)
 
         buttonLayout.addItem(QSpacerItem(0, 0, QSizePolicy.Minimum, QSizePolicy.MinimumExpanding))
 
     """
     Open the config file and load the json file into a dictionary.
     """
 
     def slot_open_config(self):
         self.path_to_config = QFileDialog.getOpenFileName(caption=i18n("Please select the json comic config file."), filter=str(i18n("json files") + "(*.json)"))[0]
         if os.path.exists(self.path_to_config) is True:
             configFile = open(self.path_to_config, "r", newline="", encoding="utf-16")
             self.setupDictionary = json.load(configFile)
             self.projecturl = os.path.dirname(str(self.path_to_config))
             configFile.close()
             self.load_config()
     """
     Further config loading.
     """
 
     def load_config(self):
         self.projectName.setMainText(text=str(self.setupDictionary["projectName"]))
         self.fill_pages()
         self.btn_settings.setEnabled(True)
         self.btn_add_page.setEnabled(True)
         self.btn_export.setEnabled(True)
         self.btn_project_url.setEnabled(True)
 
     """
     Fill the pages model with the pages from the pages list.
     """
 
     def fill_pages(self):
         self.loadingPages = True
         self.pagesModel.clear()
-        self.pagesModel.setHorizontalHeaderLabels([i18n("Page"), i18n("Description")])
         pagesList = []
         if "pages" in self.setupDictionary.keys():
             pagesList = self.setupDictionary["pages"]
         progress = QProgressDialog()
         progress.setMinimum(0)
         progress.setMaximum(len(pagesList))
         progress.setWindowTitle(i18n("Loading pages..."))
         for url in pagesList:
             absurl = os.path.join(self.projecturl, url)
             if (os.path.exists(absurl)):
                 #page = Application.openDocument(absurl)
                 page = zipfile.ZipFile(absurl, "r")
                 thumbnail = QImage.fromData(page.read("preview.png"))
                 pageItem = QStandardItem()
                 dataList = self.get_description_and_title(page.read("documentinfo.xml"))
                 if (dataList[0].isspace() or len(dataList[0]) < 1):
                     dataList[0] = os.path.basename(url)
                 pageItem.setText(dataList[0].replace("_", " "))
                 pageItem.setDragEnabled(True)
                 pageItem.setDropEnabled(False)
                 pageItem.setEditable(False)
                 pageItem.setIcon(QIcon(QPixmap.fromImage(thumbnail)))
+                pageItem.setData(dataList[1], role = CPE.DESCRIPTION)
+                pageItem.setData(url, role = CPE.URL)
+                pageItem.setData(dataList[2], role = CPE.KEYWORDS)
+                pageItem.setData(dataList[3], role = CPE.LASTEDIT)
+                pageItem.setData(dataList[4], role = CPE.EDITOR)
                 pageItem.setToolTip(url)
                 page.close()
-                description = QStandardItem()
-                description.setText(dataList[1])
-                description.setEditable(False)
-                listItem = []
-                listItem.append(pageItem)
-                listItem.append(description)
-                self.pagesModel.appendRow(listItem)
-                self.comicPageList.resizeRowsToContents()
-                self.comicPageList.setColumnWidth(0, 200)
-                self.comicPageList.setColumnWidth(1, 256)
+                self.pagesModel.appendRow(pageItem)
                 progress.setValue(progress.value() + 1)
         progress.setValue(len(pagesList))
         self.loadingPages = False
     """
     Function that is triggered by the zoomSlider
     Resizes the thumbnails.
     """
 
     def slot_scale_thumbnails(self, multiplier=4):
         self.comicPageList.setIconSize(QSize(multiplier * 32, multiplier * 32))
-        self.comicPageList.resizeRowsToContents()
 
     """
     Function that takes the documentinfo.xml and parses it for the title, subject and abstract tags,
     to get the title and description.
     
     @returns a stringlist with the name on 0 and the description on 1.
     """
 
     def get_description_and_title(self, string):
         xmlDoc = ET.fromstring(string)
         calligra = str("{http://www.calligra.org/DTD/document-info}")
         name = ""
         if ET.iselement(xmlDoc[0].find(calligra + 'title')):
             name = xmlDoc[0].find(calligra + 'title').text
             if name is None:
                 name = " "
         desc = ""
         if ET.iselement(xmlDoc[0].find(calligra + 'subject')):
             desc = xmlDoc[0].find(calligra + 'subject').text
         if desc is None or desc.isspace() or len(desc) < 1:
             if ET.iselement(xmlDoc[0].find(calligra + 'abstract')):
-                desc = str(xmlDoc[0].find(calligra + 'abstract').text)
-                if desc.startswith("<![CDATA["):
-                    desc = desc[len("<![CDATA["):]
-                if desc.startswith("]]>"):
-                    desc = desc[:-len("]]>")]
-        return [name, desc]
+                desc = xmlDoc[0].find(calligra + 'abstract').text
+                if desc is not None:
+                    if desc.startswith("<![CDATA["):
+                        desc = desc[len("<![CDATA["):]
+                    if desc.startswith("]]>"):
+                        desc = desc[:-len("]]>")]
+        keywords = ""
+        if ET.iselement(xmlDoc[0].find(calligra + 'keyword')):
+            keywords = xmlDoc[0].find(calligra + 'keyword').text
+        date = ""
+        if ET.iselement(xmlDoc[0].find(calligra + 'date')):
+            date = xmlDoc[0].find(calligra + 'date').text
+        author = []
+        if ET.iselement(xmlDoc[1].find(calligra + 'creator-first-name')):
+            string = xmlDoc[1].find(calligra + 'creator-first-name').text
+            if string is not None:
+                author.append(string)
+        if ET.iselement(xmlDoc[1].find(calligra + 'creator-last-name')):
+            string = xmlDoc[1].find(calligra + 'creator-last-name').text
+            if string is not None:
+                author.append(string)
+        if ET.iselement(xmlDoc[1].find(calligra + 'full-name')):
+            string = xmlDoc[1].find(calligra + 'full-name').text
+            if string is not None:
+                author.append(string)
+            
+        return [name, desc, keywords, date, " ".join(author)]
 
     """
     Scrapes authors from the author data in the document info and puts them into the author list.
     Doesn't check for duplicates.
     """
 
     def slot_scrape_author_list(self):
         listOfAuthors = []
         if "authorList" in self.setupDictionary.keys():
             listOfAuthors = self.setupDictionary["authorList"]
         if "pages" in self.setupDictionary.keys():
             for relurl in self.setupDictionary["pages"]:
                 absurl = os.path.join(self.projecturl, relurl)
                 page = zipfile.ZipFile(absurl, "r")
                 xmlDoc = ET.fromstring(page.read("documentinfo.xml"))
                 calligra = str("{http://www.calligra.org/DTD/document-info}")
                 authorelem = xmlDoc.find(calligra + 'author')
                 author = {}
                 if ET.iselement(authorelem.find(calligra + 'full-name')):
                     author["nickname"] = str(authorelem.find(calligra + 'full-name').text)
 
                 if ET.iselement(authorelem.find(calligra + 'creator-first-name')):
                     author["first-name"] = str(authorelem.find(calligra + 'creator-first-name').text)
 
                 if ET.iselement(authorelem.find(calligra + 'initial')):
                     author["initials"] = str(authorelem.find(calligra + 'initial').text)
 
                 if ET.iselement(authorelem.find(calligra + 'creator-last-name')):
                     author["last-name"] = str(authorelem.find(calligra + 'creator-last-name').text)
 
                 if ET.iselement(authorelem.find(calligra + 'email')):
                     author["email"] = str(authorelem.find(calligra + 'email').text)
 
                 if ET.iselement(authorelem.find(calligra + 'contact')):
                     contact = authorelem.find(calligra + 'contact')
                     contactMode = contact.get("type")
                     if contactMode == "email":
                         author["email"] = str(contact.text)
                     if contactMode == "homepage":
                         author["homepage"] = str(contact.text)
 
                 if ET.iselement(authorelem.find(calligra + 'position')):
                     author["role"] = str(authorelem.find(calligra + 'position').text)
                 listOfAuthors.append(author)
                 page.close()
         self.setupDictionary["authorList"] = listOfAuthors
 
     """
     Edit the general project settings like the project name, concept, pages location, export location, template location, metadata
     """
 
     def slot_edit_project_settings(self):
         dialog = comics_project_settings_dialog.comics_project_details_editor(self.projecturl)
         dialog.setConfig(self.setupDictionary, self.projecturl)
 
         if dialog.exec_() == QDialog.Accepted:
             self.setupDictionary = dialog.getConfig(self.setupDictionary)
             self.slot_write_config()
-            self.setWindowTitle(self.stringName + ": " + str(self.setupDictionary["projectName"]))
+            self.projectName.setMainText(str(self.setupDictionary["projectName"]))
 
     """
     This allows users to select existing pages and add them to the pages list. The pages are currently not copied to the pages folder. Useful for existing projects.
     """
 
     def slot_add_page_from_url(self):
         # get the pages.
         urlList = QFileDialog.getOpenFileNames(caption=i18n("Which existing pages to add?"), directory=self.projecturl, filter=str(i18n("Krita files") + "(*.kra)"))[0]
 
         # get the existing pages list.
         pagesList = []
         if "pages" in self.setupDictionary.keys():
             pagesList = self.setupDictionary["pages"]
 
         # And add each url in the url list to the pages list and the model.
         for url in urlList:
             if self.projecturl not in urlList:
                 newUrl = os.path.join(self.projecturl, self.setupDictionary["pagesLocation"], os.path.basename(url))
                 shutil.move(url, newUrl)
                 url = newUrl
             relative = os.path.relpath(url, self.projecturl)
             if url not in pagesList:
                 page = zipfile.ZipFile(url, "r")
                 thumbnail = QImage.fromData(page.read("preview.png"))
                 dataList = self.get_description_and_title(page.read("documentinfo.xml"))
                 if (dataList[0].isspace() or len(dataList[0]) < 1):
                     dataList[0] = os.path.basename(url)
                 newPageItem = QStandardItem()
                 newPageItem.setIcon(QIcon(QPixmap.fromImage(thumbnail)))
                 newPageItem.setDragEnabled(True)
                 newPageItem.setDropEnabled(False)
                 newPageItem.setEditable(False)
                 newPageItem.setText(dataList[0].replace("_", " "))
+                newPageItem.setData(dataList[1], role = CPE.DESCRIPTION)
+                newPageItem.setData(relative, role = CPE.URL)
+                newPageItem.setData(dataList[2], role = CPE.KEYWORDS)
+                newPageItem.setData(dataList[3], role = CPE.LASTEDIT)
+                newPageItem.setData(dataList[4], role = CPE.EDITOR)
                 newPageItem.setToolTip(relative)
                 page.close()
-                description = QStandardItem()
-                description.setText(dataList[1])
-                description.setEditable(False)
-                listItem = []
-                listItem.append(newPageItem)
-                listItem.append(description)
-                self.pagesModel.appendRow(listItem)
-                self.comicPageList.resizeRowsToContents()
+                self.pagesModel.appendRow(newPageItem)
 
     """
     Remove the selected page from the list of pages. This does not remove it from disk(far too dangerous).
     """
 
     def slot_remove_selected_page(self):
         index = self.comicPageList.currentIndex()
         self.pagesModel.removeRow(index.row())
 
     """
     This function adds a new page from the default template. If there's no default template, or the file does not exist, it will 
     show the create/import template dialog. It will remember the selected item as the default template.
     """
 
     def slot_add_new_page_single(self):
         templateUrl = "templatepage"
         templateExists = False
 
         if "singlePageTemplate" in self.setupDictionary.keys():
             templateUrl = self.setupDictionary["singlePageTemplate"]
         if os.path.exists(os.path.join(self.projecturl, templateUrl)):
             templateExists = True
 
         if templateExists is False:
             if "templateLocation" not in self.setupDictionary.keys():
                 self.setupDictionary["templateLocation"] = os.path.relpath(QFileDialog.getExistingDirectory(caption=i18n("Where are the templates located?"), options=QFileDialog.ShowDirsOnly), self.projecturl)
 
             templateDir = os.path.join(self.projecturl, self.setupDictionary["templateLocation"])
             template = comics_template_dialog.comics_template_dialog(templateDir)
 
             if template.exec_() == QDialog.Accepted:
                 templateUrl = os.path.relpath(template.url(), self.projecturl)
                 self.setupDictionary["singlePageTemplate"] = templateUrl
         if os.path.exists(os.path.join(self.projecturl, templateUrl)):
             self.add_new_page(templateUrl)
 
     """
     This function always asks for a template showing the new template window. This allows users to have multiple different
     templates created for back covers, spreads, other and have them accesible, while still having the convenience of a singular
     "add page" that adds a default.
     """
 
     def slot_add_new_page_from_template(self):
         if "templateLocation" not in self.setupDictionary.keys():
             self.setupDictionary["templateLocation"] = os.path.relpath(QFileDialog.getExistingDirectory(caption=i18n("Where are the templates located?"), options=QFileDialog.ShowDirsOnly), self.projecturl)
 
         templateDir = os.path.join(self.projecturl, self.setupDictionary["templateLocation"])
         template = comics_template_dialog.comics_template_dialog(templateDir)
 
         if template.exec_() == QDialog.Accepted:
             templateUrl = os.path.relpath(template.url(), self.projecturl)
             self.add_new_page(templateUrl)
 
     """
     This is the actual function that adds the template using the template url.
     It will attempt to name the new page projectName+number.
     """
 
     def add_new_page(self, templateUrl):
 
         # check for page list and or location.
         pagesList = []
         if "pages" in self.setupDictionary.keys():
             pagesList = self.setupDictionary["pages"]
         if not "pageNumber" in self.setupDictionary.keys():
             self.setupDictionary['pageNumber'] = 0
 
         if (str(self.setupDictionary["pagesLocation"]).isspace()):
             self.setupDictionary["pagesLocation"] = os.path.relpath(QFileDialog.getExistingDirectory(caption=i18n("Where should the pages go?"), options=QFileDialog.ShowDirsOnly), self.projecturl)
 
         # Search for the possible name.
         extraUnderscore = str()
         if str(self.setupDictionary["projectName"])[-1].isdigit():
             extraUnderscore = "_"
         self.setupDictionary['pageNumber'] += 1
         pageName = str(self.setupDictionary["projectName"]).replace(" ", "_") + extraUnderscore + str(format(self.setupDictionary['pageNumber'], "03d"))
         url = os.path.join(str(self.setupDictionary["pagesLocation"]), pageName + ".kra")
 
         # open the page by opening the template and resaving it, or just opening it.
         absoluteUrl = os.path.join(self.projecturl, url)
         if (os.path.exists(absoluteUrl)):
             newPage = Application.openDocument(absoluteUrl)
         else:
             booltemplateExists = os.path.exists(os.path.join(self.projecturl, templateUrl))
             if booltemplateExists is False:
                 templateUrl = os.path.relpath(QFileDialog.getOpenFileName(caption=i18n("Which image should be the basis the new page?"), directory=self.projecturl, filter=str(i18n("Krita files") + "(*.kra)"))[0], self.projecturl)
             newPage = Application.openDocument(os.path.join(self.projecturl, templateUrl))
             newPage.waitForDone()
             newPage.setFileName(absoluteUrl)
             newPage.setName(pageName.replace("_", " "))
             newPage.save()
             newPage.waitForDone()
 
         # Get out the extra data for the standard item.
         newPageItem = QStandardItem()
         newPageItem.setIcon(QIcon(QPixmap.fromImage(newPage.thumbnail(256, 256))))
         newPageItem.setDragEnabled(True)
         newPageItem.setDropEnabled(False)
         newPageItem.setEditable(False)
         newPageItem.setText(pageName.replace("_", " "))
+        newPageItem.setData("", role = CPE.DESCRIPTION)
+        newPageItem.setData(url, role = CPE.URL)
+        newPageItem.setData("", role = CPE.KEYWORDS)
+        newPageItem.setData("", role = CPE.LASTEDIT)
+        newPageItem.setData("", role = CPE.EDITOR)
         newPageItem.setToolTip(url)
 
         # close page document.
         while os.path.exists(absoluteUrl) is False:
             qApp.processEvents()
 
         newPage.close()
 
         # add item to page.
-        description = QStandardItem()
-        description.setText(str(""))
-        description.setEditable(False)
-        listItem = []
-        listItem.append(newPageItem)
-        listItem.append(description)
-        self.pagesModel.appendRow(listItem)
-        self.comicPageList.resizeRowsToContents()
-        self.comicPageList.resizeColumnToContents(0)
+        self.pagesModel.appendRow(newPageItem)
 
     """
     Write to the json configuratin file.
     This also checks the current state of the pages list.
     """
 
     def slot_write_config(self):
 
         # Don't load when the pages are still being loaded, otherwise we'll be overwriting our own pages list.
         if (self.loadingPages is False):
             print("CPMT: writing comic configuration...")
 
             # Generate a pages list from the pagesmodel.
-            # Because we made the drag-and-drop use the tableview header, we need to first request the logicalIndex
-            # for the visualIndex, and then request the items for the logical index in the pagesmodel.
-            # After that, we rename the verticalheader to have the appropriate numbers it will have when reloading.
             pagesList = []
-            listOfHeaderLabels = []
-            for i in range(self.pagesModel.rowCount()):
-                listOfHeaderLabels.append(str(i+1))
             for i in range(self.pagesModel.rowCount()):
-                iLogical = max(0, self.comicPageList.verticalHeader().logicalIndex(i))
-                if i >= self.comicPageList.verticalHeader().count():
-                    iLogical = i
-                index = self.pagesModel.index(iLogical, 0)
-                if index.isValid() is False:
-                    index = self.pagesModel.index(i, 0)
-                url = str(self.pagesModel.data(index, role=Qt.ToolTipRole))
+                index = self.pagesModel.index(i, 0)
+                url = str(self.pagesModel.data(index, role=CPE.URL))
                 if url not in pagesList:
                     pagesList.append(url)
-                listOfHeaderLabels[iLogical] = str(i+1)
-            self.pagesModel.setVerticalHeaderLabels(listOfHeaderLabels)
-            self.comicPageList.verticalHeader().update()
             self.setupDictionary["pages"] = pagesList
 
             # Save to our json file.
             configFile = open(self.path_to_config, "w", newline="", encoding="utf-16")
             json.dump(self.setupDictionary, configFile, indent=4, sort_keys=True, ensure_ascii=False)
             configFile.close()
             print("CPMT: done")
 
     """
     Open a page in the pagesmodel in Krita.
     """
 
     def slot_open_page(self, index):
         if index.column() is 0:
             # Get the absolute url from the relative one in the pages model.
-            absoluteUrl = os.path.join(self.projecturl, str(self.pagesModel.data(index, role=Qt.ToolTipRole)))
+            absoluteUrl = os.path.join(self.projecturl, str(self.pagesModel.data(index, role=CPE.URL)))
 
             # Make sure the page exists.
             if os.path.exists(absoluteUrl):
                 page = Application.openDocument(absoluteUrl)
 
                 # Set the title to the filename if it was empty. It looks a bit neater.
                 if page.name().isspace or len(page.name()) < 1:
                     page.setName(str(self.pagesModel.data(index, role=Qt.DisplayRole)).replace("_", " "))
 
                 # Add views for the document so the user can use it.
                 Application.activeWindow().addView(page)
                 Application.setActiveDocument(page)
             else:
                 print("CPMT: The page cannot be opened because the file doesn't exist:", absoluteUrl)
 
     """
     Call up the metadata editor dialog. Only when the dialog is "Accepted" will the metadata be saved.
     """
 
     def slot_edit_meta_data(self):
         dialog = comics_metadata_dialog.comic_meta_data_editor()
 
         dialog.setConfig(self.setupDictionary)
         if (dialog.exec_() == QDialog.Accepted):
             self.setupDictionary = dialog.getConfig(self.setupDictionary)
             self.slot_write_config()
 
     """
     An attempt at making the description editable from the comic pages list. It is currently not working because ZipFile
     has no overwrite mechanism, and I don't have the energy to write one yet.
     """
 
     def slot_write_description(self, index):
 
         for row in range(self.pagesModel.rowCount()):
             index = self.pagesModel.index(row, 1)
             indexUrl = self.pagesModel.index(row, 0)
-            absoluteUrl = os.path.join(self.projecturl, str(self.pagesModel.data(indexUrl, role=Qt.ToolTipRole)))
+            absoluteUrl = os.path.join(self.projecturl, str(self.pagesModel.data(indexUrl, role=CPE.URL)))
             page = zipfile.ZipFile(absoluteUrl, "a")
             xmlDoc = ET.ElementTree()
             ET.register_namespace("", "http://www.calligra.org/DTD/document-info")
             location = os.path.join(self.projecturl, "documentinfo.xml")
             xmlDoc.parse(location)
             xmlroot = ET.fromstring(page.read("documentinfo.xml"))
             calligra = "{http://www.calligra.org/DTD/document-info}"
             aboutelem = xmlroot.find(calligra + 'about')
             if ET.iselement(aboutelem.find(calligra + 'subject')):
                 desc = aboutelem.find(calligra + 'subject')
                 desc.text = self.pagesModel.data(index, role=Qt.EditRole)
                 xmlstring = ET.tostring(xmlroot, encoding='unicode', method='xml', short_empty_elements=False)
                 page.writestr(zinfo_or_arcname="documentinfo.xml", data=xmlstring)
                 for document in Application.documents():
                     if str(document.fileName()) == str(absoluteUrl):
                         document.setDocumentInfo(xmlstring)
             page.close()
 
     """
     Calls up the export settings dialog. Only when accepted will the configuration be written.
     """
 
     def slot_edit_export_settings(self):
         dialog = comics_export_dialog.comic_export_setting_dialog()
         dialog.setConfig(self.setupDictionary)
 
         if (dialog.exec_() == QDialog.Accepted):
             self.setupDictionary = dialog.getConfig(self.setupDictionary)
             self.slot_write_config()
 
     """
     Export the comic. Won't work without export settings set.
     """
 
     def slot_export(self):
         exporter = comics_exporter.comicsExporter()
         exporter.set_config(self.setupDictionary, self.projecturl)
         exportSuccess = exporter.export()
         if exportSuccess:
             print("CPMT: Export success! The files have been written to the export folder!")
 
     """
     Calls up the comics project setup wizard so users can create a new json file with the basic information.
     """
 
     def slot_new_project(self):
         setup = comics_project_setup_wizard.ComicsProjectSetupWizard()
         setup.showDialog()
     """
     This is triggered by any document save.
     It checks if the given url in in the pages list, and if so,
     updates the appropriate page thumbnail.
     This helps with the management of the pages, because the user
     will be able to see the thumbnails as a todo for the whole comic,
     giving a good overview over whether they still need to ink, color or
     the like for a given page, and it thus also rewards the user whenever
     they save.
     """
 
     def slot_check_for_page_update(self, url):
         if "pages" in self.setupDictionary.keys():
             relUrl = os.path.relpath(url, self.projecturl)
             if relUrl in self.setupDictionary["pages"]:
                 index = self.pagesModel.index(self.setupDictionary["pages"].index(relUrl), 0)
-                index2 = self.pagesModel.index(index.row(), 1)
                 if index.isValid():
                     pageItem = self.pagesModel.itemFromIndex(index)
                     page = zipfile.ZipFile(url, "r")
                     dataList = self.get_description_and_title(page.read("documentinfo.xml"))
                     if (dataList[0].isspace() or len(dataList[0]) < 1):
                         dataList[0] = os.path.basename(url)
                     thumbnail = QImage.fromData(page.read("preview.png"))
                     pageItem.setIcon(QIcon(QPixmap.fromImage(thumbnail)))
                     pageItem.setText(dataList[0])
+                    pageItem.setData(dataList[1], role = CPE.DESCRIPTION)
+                    pageItem.setData(url, role = CPE.URL)
+                    pageItem.setData(dataList[2], role = CPE.KEYWORDS)
+                    pageItem.setData(dataList[3], role = CPE.LASTEDIT)
+                    pageItem.setData(dataList[4], role = CPE.EDITOR)
                     self.pagesModel.setItem(index.row(), index.column(), pageItem)
-                    self.pagesModel.setData(index2, str(dataList[1]), Qt.DisplayRole)
 
     """
     Resize all the pages in the pages list.
     It will show a dialog with the options for resizing. Then, it will try to pop up a progress dialog while resizing.
     The progress dialog shows the remaining time and pages.
     """
 
     def slot_batch_resize(self):
         dialog = QDialog()
         dialog.setWindowTitle(i18n("Risize all pages."))
         buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
         buttons.accepted.connect(dialog.accept)
         buttons.rejected.connect(dialog.reject)
         sizesBox = comics_export_dialog.comic_export_resize_widget("Scale", batch=True, fileType=False)
         exporterSizes = comics_exporter.sizesCalculator()
         dialog.setLayout(QVBoxLayout())
         dialog.layout().addWidget(sizesBox)
         dialog.layout().addWidget(buttons)
 
         if dialog.exec_() == QDialog.Accepted:
             progress = QProgressDialog(i18n("Resizing pages..."), str(), 0, len(self.setupDictionary["pages"]))
             progress.setWindowTitle(i18n("Resizing pages."))
             progress.setCancelButton(None)
             timer = QElapsedTimer()
             timer.start()
             config = {}
             config = sizesBox.get_config(config)
             for p in range(len(self.setupDictionary["pages"])):
                 absoluteUrl = os.path.join(self.projecturl, self.setupDictionary["pages"][p])
                 progress.setValue(p)
                 timePassed = timer.elapsed()
                 if (p > 0):
                     timeEstimated = (len(self.setupDictionary["pages"]) - p) * (timePassed / p)
                     passedString = str(int(timePassed / 60000)) + ":" + format(int(timePassed / 1000), "02d") + ":" + format(timePassed % 1000, "03d")
                     estimatedString = str(int(timeEstimated / 60000)) + ":" + format(int(timeEstimated / 1000), "02d") + ":" + format(int(timeEstimated % 1000), "03d")
                     progress.setLabelText(str(i18n("{pages} of {pagesTotal} done. \nTime passed: {passedString}:\n Estimated:{estimated}")).format(pages=p, pagesTotal=len(self.setupDictionary["pages"]), passedString=passedString, estimated=estimatedString))
                     qApp.processEvents()
                 if os.path.exists(absoluteUrl):
                     doc = Application.openDocument(absoluteUrl)
                     listScales = exporterSizes.get_scale_from_resize_config(config["Scale"], [doc.width(), doc.height(), doc.resolution(), doc.resolution()])
                     doc.scaleImage(listScales[0], listScales[1], listScales[2], listScales[3], "bicubic")
                     doc.waitForDone()
                     doc.save()
                     doc.waitForDone()
                     doc.close()
 
     def slot_show_page_viewer(self):
         index = int(self.comicPageList.currentIndex().row())
         self.page_viewer_dialog.load_comic(self.path_to_config)
         self.page_viewer_dialog.go_to_page_index(index)
         self.page_viewer_dialog.show()
 
     """
     Function to copy the current project location into the clipboard.
     This is useful for users because they'll be able to use that url to quickly
     move to the project location in outside applications.
     """
 
     def slot_copy_project_url(self):
         if self.projecturl is not None:
             clipboard = qApp.clipboard()
             clipboard.setText(str(self.projecturl))
 
     """
     Scrape text files with the textlayer keys for text, and put those in a POT
     file. This makes it possible to handle translations.
     """
 
     def slot_scrape_translations(self):
         translationFolder = self.setupDictionary.get("translationLocation", "translations")
         fullTranslationPath = os.path.join(self.projecturl, translationFolder)
         os.makedirs(fullTranslationPath, exist_ok=True)
         textLayersToSearch = self.setupDictionary.get("textLayerNames", ["text"])
 
         scraper = comics_project_translation_scraper.translation_scraper(self.projecturl, translationFolder, textLayersToSearch, self.setupDictionary["projectName"])
         # Run text scraper.
         language = self.setupDictionary.get("language", "en")
         metadata = {}
         metadata["title"] = self.setupDictionary.get("title", "")
         metadata["summary"] = self.setupDictionary.get("summary", "")
         metadata["keywords"] = ", ".join(self.setupDictionary.get("otherKeywords", [""]))
         metadata["transnotes"] = self.setupDictionary.get("translatorHeader", "Translator's Notes")
         scraper.start(self.setupDictionary["pages"], language, metadata)
     """
     This is required by the dockwidget class, otherwise unused.
     """
 
     def canvasChanged(self, canvas):
         pass
 
 
 """
 Add docker to program
 """
 Application.addDockWidgetFactory(DockWidgetFactory("comics_project_manager_docker", DockWidgetFactoryBase.DockRight, comics_project_manager_docker))
diff --git a/plugins/python/documenttools/documenttools.py b/plugins/python/documenttools/documenttools.py
index 5bede48f4c..9432c9309e 100644
--- a/plugins/python/documenttools/documenttools.py
+++ b/plugins/python/documenttools/documenttools.py
@@ -1,31 +1,34 @@
 '''
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 '''
 import krita
 from documenttools import uidocumenttools
 
 
 class DocumentToolsExtension(krita.Extension):
 
     def __init__(self, parent):
         super(DocumentToolsExtension, self).__init__(parent)
 
     def setup(self):
-        action = krita.Krita.instance().createAction("document_tools", "Document Tools")
+        pass
+    
+    def createActions(self, window):
+        action = window.createAction("document_tools", "Document Tools")
         action.setToolTip("Plugin to manipulate properties of selected documents")
         action.triggered.connect(self.initialize)
 
     def initialize(self):
         self.uidocumenttools = uidocumenttools.UIDocumentTools()
         self.uidocumenttools.initialize()
 
 
 Scripter.addExtension(DocumentToolsExtension(krita.Krita.instance()))
diff --git a/plugins/python/exportlayers/exportlayers.py b/plugins/python/exportlayers/exportlayers.py
index f98ffa155a..de0b65af49 100644
--- a/plugins/python/exportlayers/exportlayers.py
+++ b/plugins/python/exportlayers/exportlayers.py
@@ -1,31 +1,34 @@
 '''
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 '''
 import krita
 from exportlayers import uiexportlayers
 
 
 class ExportLayersExtension(krita.Extension):
 
     def __init__(self, parent):
         super(ExportLayersExtension, self).__init__(parent)
 
     def setup(self):
-        action = krita.Krita.instance().createAction("export_layers", "Export Layers")
+        pass
+    
+    def createActions(self, window):
+        action = window.createAction("export_layers", "Export Layers")
         action.setToolTip("Plugin to export layers from a document")
         action.triggered.connect(self.initialize)
 
     def initialize(self):
         self.uiexportlayers = uiexportlayers.UIExportLayers()
         self.uiexportlayers.initialize()
 
 
 Scripter.addExtension(ExportLayersExtension(krita.Krita.instance()))
diff --git a/plugins/python/filtermanager/filtermanager.py b/plugins/python/filtermanager/filtermanager.py
index dfc7d76582..0e9e3fd8d5 100644
--- a/plugins/python/filtermanager/filtermanager.py
+++ b/plugins/python/filtermanager/filtermanager.py
@@ -1,31 +1,34 @@
 '''
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 '''
 import krita
 from filtermanager import uifiltermanager
 
 
 class FilterManagerExtension(krita.Extension):
 
     def __init__(self, parent):
         super(FilterManagerExtension, self).__init__(parent)
 
     def setup(self):
-        action = krita.Krita.instance().createAction("filter_manager", "Filter Manager")
+        pass
+    
+    def createActions(self, window):
+        action = window.createAction("filter_manager", "Filter Manager")
         action.setToolTip("Plugin to filters management")
         action.triggered.connect(self.initialize)
 
     def initialize(self):
         self.uifiltermanager = uifiltermanager.UIFilterManager()
         self.uifiltermanager.initialize()
 
 
 Scripter.addExtension(FilterManagerExtension(krita.Krita.instance()))
diff --git a/plugins/python/hello/hello.py b/plugins/python/hello/hello.py
index e4966c6599..bd31a90068 100644
--- a/plugins/python/hello/hello.py
+++ b/plugins/python/hello/hello.py
@@ -1,86 +1,88 @@
 '''
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 '''
 """
 This is a simple example of a Python script for Krita.
 It demonstrates how to set up a custom extension and a custom docker!
 """
 
 from PyQt5.QtCore import qDebug
 from PyQt5.QtWidgets import QWidget, QLabel, QMessageBox
 from krita import Krita, Extension, DockWidget, DockWidgetFactory, DockWidgetFactoryBase
 
 
 def hello():
     """
     Show a test message box.
     """
     QMessageBox.information(QWidget(), i18n("Test"), i18n("Hello! This is Krita version %s") % Application.version())
 
 
 class HelloExtension(Extension):
     """
     HelloExtension is a small example extension demonstrating basic Python scripting support in Krita!
     """
 
     def __init__(self, parent):
         """
         Standard Krita Python extension constructor.
         Most of the initialization happens in :func:`setup`
 
         :param parent: Parent widget
         :type parent: :class:`QWidget` or None
         """
         super().__init__(parent)
 
     def setup(self):
+        pass
+
+    def createActions(self, window):
         """
         This is where most of the setup takes place!
         """
-        #qDebug("Hello Setup")
-        action = Krita.instance().createAction("hello_python", "hello", False)
+        action = window.createAction("hello_python", "hello")
         action.triggered.connect(hello)
 
 
 # Initialize and add the extension
 Scripter.addExtension(HelloExtension(Krita.instance()))
 
 
 class HelloDocker(DockWidget):
     """
     The HelloDocker is an example of a simple Python-based docker.
     """
 
     def __init__(self):
         """
         Constructs an instance of HelloDocker and the widget it contains
         """
         super().__init__()
 
         # The window title is also used in the Docker menu,
         # so it should be set to something sensible!
         self.setWindowTitle("HelloDocker")
         label = QLabel("Hello", self)
         self.setWidget(label)
         self._label = label
 
     def canvasChanged(self, canvas):
         """
         Override canvasChanged from :class:`DockWidget`.
         This gets called when the canvas changes.
         You can also access the active canvas via :func:`DockWidget.canvas`
         Parameter `canvas` can be null if the last document is closed
         """
         self._label.setText("HelloDocker: canvas changed")
 
 
 # Register the docker so Krita can use it!
 Application.addDockWidgetFactory(DockWidgetFactory("hello", DockWidgetFactoryBase.DockRight, HelloDocker))
diff --git a/plugins/python/highpass/highpass.py b/plugins/python/highpass/highpass.py
index 24aec83f34..a5a92a24da 100644
--- a/plugins/python/highpass/highpass.py
+++ b/plugins/python/highpass/highpass.py
@@ -1,127 +1,130 @@
 '''
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 '''
 import sys
 from PyQt5.QtGui import *
 from PyQt5.QtWidgets import *
 from krita import *
 
 
 class HighpassExtension(Extension):
 
     def __init__(self, parent):
         super().__init__(parent)
 
     def setup(self):
-        action = Application.createAction("high_pass_filter", "High Pass")
+        pass
+    
+    def createActions(self, window):
+        action = window.createAction("high_pass_filter", "High Pass")
         action.triggered.connect(self.showDialog)
 
     def showDialog(self):
         doc = Application.activeDocument()
         if doc == None:
             QMessageBox.information(Application.activeWindow().qwindow(), "Highpass Filter", "There is no active image.")
             return
 
         self.dialog = QDialog(Application.activeWindow().qwindow())
 
         self.intRadius = QSpinBox()
         self.intRadius.setValue(10)
         self.intRadius.setRange(2, 200)
 
         self.cmbMode = QComboBox()
         self.cmbMode.addItems(["Color", "Preserve DC", "Greyscale", "Greyscale, Apply Chroma", "Redrobes"])
         self.keepOriginal = QCheckBox("Keep Original Layer")
         self.keepOriginal.setChecked(True)
         form = QFormLayout()
         form.addRow("Filter Radius", self.intRadius)
         form.addRow("Mode", self.cmbMode)
         form.addRow("", self.keepOriginal)
 
         self.buttonBox = QDialogButtonBox(self.dialog)
         self.buttonBox.setOrientation(QtCore.Qt.Horizontal)
         self.buttonBox.setStandardButtons(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
         self.buttonBox.accepted.connect(self.dialog.accept)
         self.buttonBox.accepted.connect(self.highpass)
         self.buttonBox.rejected.connect(self.dialog.reject)
 
         vbox = QVBoxLayout(self.dialog)
         vbox.addLayout(form)
         vbox.addWidget(self.buttonBox)
 
         self.dialog.show()
         self.dialog.activateWindow()
         self.dialog.exec_()
 
     def highpass(self):
         # XXX: Start undo macro
         image = Application.activeDocument()
         original = image.activeNode()
         working_layer = original
 
         # We can only highpass on paint layers
         if self.keepOriginal.isChecked() or original.type() != "paintlayer":
             working_layer = image.createNode("working", "paintlayer")
             working_layer.setColorSpace(original.colorModel(), original.colorSpace(), original.profile())
             working_layer.writeBytes(original.readBytes(0, 0, image.width(), image.height()),
                                      0, 0, image.width(), image.height())
             original.parentNode().addChildNode(working_layer, original)  # XXX: Unimplemented
 
         image.setActiveNode(working_layer)
         colors_layer = None
 
         # if keeping colors
         if self.cmbMode.currentIndex() == 1 or self.cmbMode.currentIndex() == 3:
             colors_layer = working_layer.duplicate()  # XXX: Unimplemented
             colors_layer.setName("colors")
             original.parentNode().addChildNode(working_layer, colors_layer)  # XXX: Unimplemented
 
         # if greyscale, desature
         if (self.cmbMode.currentIndex() == 2 or self.cmbMode.currentIndex() == 3):
             filter = Application.filter("desaturate")
             filter.apply(working_layer, 0, 0, image.width(), image.height())
 
         # Duplicate on top and blur
         blur_layer = working_layer.duplicate()
         blur_layer.setName("blur")
         original.parentNode().addChildNode(blur_layer, working_layer)  # XXX: Unimplemented
 
         # blur
         filter = Application.filter("gaussian blur")
         filter_configuration = filter.configuration()
         filter_configuration.setProperty("horizRadius", self.intRadius.value())
         filter_configuration.setProperty("vertRadius", self.intRadius.value())
         filter_configuration.setProperty("lockAspect", true)
         filter.setConfiguration(filter_configuration)
         filter.apply(blur_layer, 0, 0, image.width(), image.height())
 
         if self.cmbMode.currentIndex() <= 3:
             blur_layer.setBlendingMode("grain_extract")
             working_layer = image.mergeDown(blur_layer)
 
             # if preserve chroma, change set the mode to value and merge down with the layer we kept earlier.
             if self.cmbMode.currentIndex() == 3:
                 working_layer.setBlendingMode("value")
                 working_layer = image.mergeDown(working_layer)
 
             # if preserve DC, change set the mode to overlay and merge down with the average colour of the layer we kept earlier.
             if self.cmbMode.currentIndex() == 1:
                 # get the average color of the entire image
                 # clear the colors layer to the given color
                 working_layer = image.mergeDown(working_layer)
 
         else:  # Mode == 4, RedRobes
             image.setActiveNode(blur_layer)
             # Get the average color of the input layer
             # copy the solid colour layer
             # copy the blurred layer
         # XXX: End undo macro
 
 Scripter.addExtension(HighpassExtension(Krita.instance()))
diff --git a/plugins/python/scripter/scripter.py b/plugins/python/scripter/scripter.py
index 5f2a3a2f67..2653fe788e 100644
--- a/plugins/python/scripter/scripter.py
+++ b/plugins/python/scripter/scripter.py
@@ -1,42 +1,45 @@
 """
 Copyright (c) 2017 Eliakin Costa <eliakim170@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 """
 from PyQt5.QtWidgets import QDialog
 from PyQt5.QtCore import QSettings, QStandardPaths
 from krita import *
 from scripter import uicontroller, documentcontroller, debugcontroller
 
 
 class ScripterExtension(Extension):
 
     def __init__(self, parent):
         super().__init__(parent)
 
     def setup(self):
-        action = Krita.instance().createAction("python_scripter", "Scripter")
+        pass
+    
+    def createActions(self, window):
+        action = window.createAction("python_scripter", "Scripter")
         action.triggered.connect(self.initialize)
 
     def initialize(self):
         configPath = QStandardPaths.writableLocation(QStandardPaths.GenericConfigLocation)
         self.settings = QSettings(configPath + '/krita-scripterrc', QSettings.IniFormat)
         self.uicontroller = uicontroller.UIController()
         self.documentcontroller = documentcontroller.DocumentController()
         self.debugcontroller = debugcontroller.DebugController(self)
         self.uicontroller.initialize(self)
 
 
 Krita.instance().addExtension(ScripterExtension(Krita.instance()))
diff --git a/plugins/python/tenbrushes/tenbrushes.py b/plugins/python/tenbrushes/tenbrushes.py
index aa280bcf39..d21c66a6fb 100644
--- a/plugins/python/tenbrushes/tenbrushes.py
+++ b/plugins/python/tenbrushes/tenbrushes.py
@@ -1,71 +1,69 @@
 '''
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 '''
 import krita
 from tenbrushes import uitenbrushes
 
 
 class TenBrushesExtension(krita.Extension):
 
     def __init__(self, parent):
         super(TenBrushesExtension, self).__init__(parent)
 
         self.actions = []
         self.buttons = []
         self.selectedPresets = []
 
     def setup(self):
-        action = Application.createAction("ten_brushes", "Ten Brushes")
+        self.readSettings()
+        
+    def createActions(self, window):
+        action = window.createAction("ten_brushes", "Ten Brushes")
         action.setToolTip("Assign ten brush presets to ten shortcuts.")
         action.triggered.connect(self.initialize)
-
-        self.readSettings()
-        self.loadActions()
+        self.loadActions(window)
 
     def initialize(self):
         self.uitenbrushes = uitenbrushes.UITenBrushes()
         self.uitenbrushes.initialize(self)
 
     def readSettings(self):
         self.selectedPresets = Application.readSetting("", "tenbrushes", "").split(',')
 
     def writeSettings(self):
         presets = []
 
         for index, button in enumerate(self.buttons):
             self.actions[index].preset = button.preset
             presets.append(button.preset)
         Application.writeSetting("", "tenbrushes", ','.join(map(str, presets)))
 
-    def loadActions(self):
+    def loadActions(self, window):
         allPresets = Application.resources("preset")
 
         for index, item in enumerate(['1', '2', '3', '4', '5', '6', '7', '8', '9', '0']):
-            action = Application.createAction("activate_preset_" + item, "Activate Brush Preset " + item)
-            action.setMenu("None")
+            action = window.createAction("activate_preset_" + item, "Activate Brush Preset " + item, "")
             action.triggered.connect(self.activatePreset)
-            
-            
 
             if index < len(self.selectedPresets) and self.selectedPresets[index] in allPresets:
                 action.preset = self.selectedPresets[index]
             else:
                 action.preset = None
 
             self.actions.append(action)
 
     def activatePreset(self):
         allPresets = Application.resources("preset")
         if Application.activeWindow() and len(Application.activeWindow().views()) > 0 and self.sender().preset in allPresets:
             Application.activeWindow().views()[0].activateResource(allPresets[self.sender().preset])
 
 
 Scripter.addExtension(TenBrushesExtension(Application))
diff --git a/plugins/python/tenscripts/tenscripts.py b/plugins/python/tenscripts/tenscripts.py
index 100edaa40c..b556580aae 100644
--- a/plugins/python/tenscripts/tenscripts.py
+++ b/plugins/python/tenscripts/tenscripts.py
@@ -1,84 +1,84 @@
 '''
 This script is licensed CC 0 1.0, so that you can learn from it.
 
 ------ CC 0 1.0 ---------------
 
 The person who associated a work with this deed has dedicated the work to the public domain by waiving all of his or her rights to the work worldwide under copyright law, including all related and neighboring rights, to the extent allowed by law.
 
 You can copy, modify, distribute and perform the work, even for commercial purposes, all without asking permission.
 
 https://creativecommons.org/publicdomain/zero/1.0/legalcode
 '''
 from PyQt5.QtWidgets import QMessageBox
 import krita
 from tenscripts import uitenscripts
 import importlib
 
 
 class TenScriptsExtension(krita.Extension):
 
     def __init__(self, parent):
        super(TenScriptsExtension, self).__init__(parent)
 
        self.actions = []
        self.scripts = []
 
     def setup(self):
-        action = Application.createAction("ten_scripts", "Ten Scripts")
+        self.readSettings()
+        
+    def createActions(self, window):
+        action = window.createAction("ten_scripts", "Ten Scripts")
         action.setToolTip("Assign ten scripts to ten shortcuts.")
         action.triggered.connect(self.initialize)
-
-        self.readSettings()
-        self.loadActions()
+        self.loadActions(window)
 
     def initialize(self):
         self.uitenscripts = uitenscripts.UITenScripts()
         self.uitenscripts.initialize(self)
 
     def readSettings(self):
         self.scripts = Application.readSetting("tenscripts", "scripts", "").split(',')
 
     def writeSettings(self):
         saved_scripts = self.uitenscripts.saved_scripts()
 
         for index, script in enumerate(saved_scripts):
             self.actions[index].script = script
 
         Application.writeSetting("tenscripts", "scripts", ','.join(map(str, saved_scripts)))
 
-    def loadActions(self):
+    def loadActions(self, window):
         for index, item in enumerate(['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']):
-            action = Application.createAction("execute_script_" + item, "Execute Script " + item)
+            action = window.createAction("execute_script_" + item, "Execute Script " + item, "")
             action.script = None
-            action.setMenu("None")
             action.triggered.connect(self._executeScript)
 
             if index < len(self.scripts):
                 action.script = self.scripts[index]
 
             self.actions.append(action)
 
     def _executeScript(self):
         script = self.sender().script
         if script:
             try:
                 spec = importlib.util.spec_from_file_location("users_script", script)
                 users_module = importlib.util.module_from_spec(spec)
                 spec.loader.exec_module(users_module)
                 
                 if hasattr(users_module, 'main') and callable(users_module.main):
                     users_module.main()
 
                 self.showMessage('script {0} executed'.format(self.sender().script))
             except Exception as e:
                 self.showMessage(str(e))
         else:
             self.showMessage("You didn't assign a script to that action")
 
     def showMessage(self, message):
         self.msgBox  = QMessageBox(Application.activeWindow().qwindow())
         self.msgBox.setText(message)
         self.msgBox.exec_()
 
 
 Scripter.addExtension(TenScriptsExtension(Application))
diff --git a/plugins/tools/selectiontools/kis_tool_select_similar.cc b/plugins/tools/selectiontools/kis_tool_select_similar.cc
index eabdeb3da1..9bec9d60ec 100644
--- a/plugins/tools/selectiontools/kis_tool_select_similar.cc
+++ b/plugins/tools/selectiontools/kis_tool_select_similar.cc
@@ -1,189 +1,189 @@
 /*
  *  Copyright (c) 1999 Matthias Elter <me@kde.org>
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2005 Boudewijn Rempt <boud@valdyas.org>
  *  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.
  */
 
 #include "kis_tool_select_similar.h"
 
 #include <QLabel>
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 
 #include <ksharedconfig.h>
 
 #include <KoColorSpace.h>
 
 #include <kis_cursor.h>
 #include <KoPointerEvent.h>
 #include <kis_selection_options.h>
 #include <kis_paint_device.h>
 #include "kis_canvas2.h"
 #include <kis_pixel_selection.h>
 #include "kis_selection_tool_helper.h"
 #include "kis_slider_spin_box.h"
 #include "kis_iterator_ng.h"
 #include "kis_image.h"
 
-void selectByColor(KisPaintDeviceSP dev, KisPixelSelectionSP selection, const quint8 * c, int fuzziness, const QRect & rc)
+void selectByColor(KisPaintDeviceSP dev, KisPixelSelectionSP selection, const quint8 *c, int fuzziness, const QRect & rc)
 {
     if (rc.isEmpty()) {
         return;
     }
     // XXX: Multithread this!
     qint32 x, y, w, h;
     x = rc.x();
     y = rc.y();
     w = rc.width();
     h = rc.height();
 
     const KoColorSpace * cs = dev->colorSpace();
 
     KisHLineConstIteratorSP hiter = dev->createHLineConstIteratorNG(x, y, w);
     KisHLineIteratorSP selIter = selection->createHLineIteratorNG(x, y, w);
 
     for (int row = y; row < y + h; ++row) {
         do {
             //if (dev->colorSpace()->hasAlpha())
             //    opacity = dev->colorSpace()->alpha(hiter->rawData());
             if (fuzziness == 1) {
                 if (memcmp(c, hiter->oldRawData(), cs->pixelSize()) == 0) {
                     *(selIter->rawData()) = MAX_SELECTED;
                 }
             }
             else {
                 quint8 match = cs->difference(c, hiter->oldRawData());
                 if (match <= fuzziness) {
                     *(selIter->rawData()) = MAX_SELECTED;
                 }
             }
         }
         while (hiter->nextPixel() && selIter->nextPixel());
         hiter->nextRow();
         selIter->nextRow();
     }
 
 }
 
 
 KisToolSelectSimilar::KisToolSelectSimilar(KoCanvasBase * canvas)
     : KisToolSelect(canvas,
                     KisCursor::load("tool_similar_selection_cursor.png", 6, 6),
                     i18n("Similar Color Selection")),
       m_fuzziness(20)
 {
     connect(&m_widgetHelper, &KisSelectionToolConfigWidgetHelper::selectionActionChanged,
             this, &KisToolSelectSimilar::setSelectionAction);
 }
 
 void KisToolSelectSimilar::activate(ToolActivation toolActivation, const QSet<KoShape*> &shapes)
 {
     KisTool::activate(toolActivation, shapes);
     m_configGroup =  KSharedConfig::openConfig()->group(toolId());
 }
 
 void KisToolSelectSimilar::beginPrimaryAction(KoPointerEvent *event)
 {
     KisToolSelectBase::beginPrimaryAction(event);
     KisPaintDeviceSP dev;
 
     if (!currentNode() ||
         !(dev = currentNode()->projection()) ||
         !currentNode()->visible() ||
         !selectionEditable()) {
 
         event->ignore();
         return;
     }
 
     QPointF pos = convertToPixelCoord(event);
 
     KisCanvas2 * kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     KIS_ASSERT_RECOVER_RETURN(kisCanvas);
 
     QApplication::setOverrideCursor(KisCursor::waitCursor());
 
     KoColor c;
     dev->pixel(pos.x(), pos.y(), &c);
 
     // XXX we should make this configurable: "allow to select transparent"
     // if (opacity > OPACITY_TRANSPARENT)
     KisPixelSelectionSP tmpSel = KisPixelSelectionSP(new KisPixelSelection());
 
     QRect rc;
     if (dev->colorSpace()->difference(c.data(), dev->defaultPixel().data()) <= m_fuzziness) {
         rc = image()->bounds();
     } else {
         rc = dev->exactBounds();
     }
     selectByColor(dev, tmpSel, c.data(), m_fuzziness, rc);
 
     tmpSel->invalidateOutlineCache();
     KisSelectionToolHelper helper(kisCanvas, kundo2_i18n("Select Similar Color"));
     helper.selectPixelSelection(tmpSel, selectionAction());
 
     QApplication::restoreOverrideCursor();
 
 }
 
 void KisToolSelectSimilar::slotSetFuzziness(int fuzziness)
 {
     m_fuzziness = fuzziness;
     m_configGroup.writeEntry("fuzziness", fuzziness);
 }
 
 QWidget* KisToolSelectSimilar::createOptionWidget()
 {
     KisToolSelectBase::createOptionWidget();
     KisSelectionOptions *selectionWidget = selectionOptionWidget();
     selectionWidget->disableAntiAliasSelectionOption();
     selectionWidget->disableSelectionModeOption();
 
     QHBoxLayout* fl = new QHBoxLayout();
     QLabel * lbl = new QLabel(i18n("Fuzziness: "), selectionWidget);
     fl->addWidget(lbl);
 
     KisSliderSpinBox* input = new KisSliderSpinBox(selectionWidget);
     input->setObjectName("fuzziness");
     input->setRange(0, 200);
     input->setSingleStep(10);
     fl->addWidget(input);
     connect(input, SIGNAL(valueChanged(int)), this, SLOT(slotSetFuzziness(int)));
 
     QVBoxLayout* l = dynamic_cast<QVBoxLayout*>(selectionWidget->layout());
     Q_ASSERT(l);
     l->insertLayout(1, fl);
 
     // load setting from config
     input->setValue(m_configGroup.readEntry("fuzziness", 20));
     return selectionWidget;
 }
 
 void KisToolSelectSimilar::setSelectionAction(int action)
 {
     changeSelectionAction(action);
 }
 
 QMenu* KisToolSelectSimilar::popupActionsMenu()
 {
     KisCanvas2 * kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     Q_ASSERT(kisCanvas);
 
 
     return KisSelectionToolHelper::getSelectionContextMenu(kisCanvas);
 }
diff --git a/plugins/tools/tool_transform2/kis_tool_transform_config_widget.cpp b/plugins/tools/tool_transform2/kis_tool_transform_config_widget.cpp
index 96b1c93024..ba0ff8d8da 100644
--- a/plugins/tools/tool_transform2/kis_tool_transform_config_widget.cpp
+++ b/plugins/tools/tool_transform2/kis_tool_transform_config_widget.cpp
@@ -1,1283 +1,1289 @@
 /*
  *  Copyright (c) 2013 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_tool_transform_config_widget.h"
 
 #include <kis_icon.h>
 #include "rotation_icons.h"
 #include "kis_canvas2.h"
 #include <QSignalMapper>
 #include "kis_liquify_properties.h"
 
 #include "KisMainWindow.h"
 #include "KisViewManager.h"
 #include "kis_transform_utils.h"
 
 
 template<typename T> inline T sign(T x) {
     return x > 0 ? 1 : x == (T)0 ? 0 : -1;
 }
 
 const int KisToolTransformConfigWidget::DEFAULT_POINTS_PER_LINE = 3;
 
 
 KisToolTransformConfigWidget::KisToolTransformConfigWidget(TransformTransactionProperties *transaction, KisCanvas2 *canvas, bool workRecursively, QWidget *parent)
     : QWidget(parent),
       m_transaction(transaction),
       m_notificationsBlocked(0),
       m_uiSlotsBlocked(0),
       m_configChanged(false)
 {
     setupUi(this);
     showDecorationsBox->setIcon(KisIconUtils::loadIcon("krita_tool_transform"));
     chkWorkRecursively->setIcon(KisIconUtils::loadIcon("krita_tool_transform_recursive"));
     flipXButton->setIcon(KisIconUtils::loadIcon("transform_icons_mirror_x"));
     flipYButton->setIcon(KisIconUtils::loadIcon("transform_icons_mirror_y"));
     rotateCWButton->setIcon(KisIconUtils::loadIcon("transform_icons_rotate_cw"));
     rotateCCWButton->setIcon(KisIconUtils::loadIcon("transform_icons_rotate_ccw"));
 
     chkWorkRecursively->setChecked(workRecursively);
     connect(chkWorkRecursively, SIGNAL(toggled(bool)), this, SIGNAL(sigRestartTransform()));
 
     // Init Filter  combo
     cmbFilter->setIDList(KisFilterStrategyRegistry::instance()->listKeys());
     cmbFilter->setCurrent("Bicubic");
     cmbFilter->setToolTip(i18nc("@info:tooltip",
                                 "<p>Select filtering mode:\n"
                                 "<ul>"
                                 "<li><b>Bilinear</b> for areas with uniform color to avoid artifacts</li>"
                                 "<li><b>Bicubic</b> for smoother results</li>"
                                 "<li><b>Lanczos3</b> for sharp results. May produce aerials.</li>"
                                 "</ul></p>"));
     connect(cmbFilter, SIGNAL(activated(const KoID &)),
             this, SLOT(slotFilterChanged(const KoID &)));
 
     // Init Warp Type combo
     cmbWarpType->insertItem(KisWarpTransformWorker::AFFINE_TRANSFORM,i18n("Default (Affine)"));
     cmbWarpType->insertItem(KisWarpTransformWorker::RIGID_TRANSFORM,i18n("Strong (Rigid)"));
     cmbWarpType->insertItem(KisWarpTransformWorker::SIMILITUDE_TRANSFORM,i18n("Strongest (Similitude)"));
     cmbWarpType->setCurrentIndex(KisWarpTransformWorker::AFFINE_TRANSFORM);
     connect(cmbWarpType, SIGNAL(currentIndexChanged(int)), this, SLOT(slotWarpTypeChanged(int)));
 
     // Init Rotation Center buttons
     m_handleDir[0] = QPointF(1, 0);
     m_handleDir[1] = QPointF(1, -1);
     m_handleDir[2] = QPointF(0, -1);
     m_handleDir[3] = QPointF(-1, -1);
     m_handleDir[4] = QPointF(-1, 0);
     m_handleDir[5] = QPointF(-1, 1);
     m_handleDir[6] = QPointF(0, 1);
     m_handleDir[7] = QPointF(1, 1);
     m_handleDir[8] = QPointF(0, 0); // also add the center
 
     m_rotationCenterButtons = new QButtonGroup(0);
     // we set the ids to match m_handleDir
     m_rotationCenterButtons->addButton(middleRightButton, 0);
     m_rotationCenterButtons->addButton(topRightButton, 1);
     m_rotationCenterButtons->addButton(middleTopButton, 2);
     m_rotationCenterButtons->addButton(topLeftButton, 3);
     m_rotationCenterButtons->addButton(middleLeftButton, 4);
     m_rotationCenterButtons->addButton(bottomLeftButton, 5);
     m_rotationCenterButtons->addButton(middleBottomButton, 6);
     m_rotationCenterButtons->addButton(bottomRightButton, 7);
     m_rotationCenterButtons->addButton(centerButton, 8);
 
     QToolButton *nothingSelected = new QToolButton(0);
     nothingSelected->setCheckable(true);
     nothingSelected->setAutoExclusive(true);
     nothingSelected->hide(); // a convenient button for when no button is checked in the group
     m_rotationCenterButtons->addButton(nothingSelected, 9);
 
 
     // initialize values for free transform sliders
     shearXBox->setSuffix(i18n(" px"));
     shearYBox->setSuffix(i18n(" px"));
     shearXBox->setRange(-5.0, 5.0, 2);
     shearYBox->setRange(-5.0, 5.0, 2);
     shearXBox->setSingleStep(0.01);
     shearYBox->setSingleStep(0.01);
     shearXBox->setValue(0.0);
     shearYBox->setValue(0.0);
 
 
     translateXBox->setSuffix(i18n(" px"));
     translateYBox->setSuffix(i18n(" px"));
     translateXBox->setRange(-10000, 10000);
     translateYBox->setRange(-10000, 10000);
 
 
     scaleXBox->setSuffix("%");
     scaleYBox->setSuffix("%");
     scaleXBox->setRange(-10000, 10000);
     scaleYBox->setRange(-10000, 10000);
     scaleXBox->setValue(100.0);
     scaleYBox->setValue(100.0);
 
     m_scaleRatio = 1.0;
 
     aXBox->setSuffix(QChar(Qt::Key_degree));
     aYBox->setSuffix(QChar(Qt::Key_degree));
     aZBox->setSuffix(QChar(Qt::Key_degree));
     aXBox->setRange(0.0, 360.0, 2);
     aYBox->setRange(0.0, 360.0, 2);
     aZBox->setRange(0.0, 360.0, 2);
     aXBox->setValue(0.0);
     aYBox->setValue(0.0);
     aZBox->setValue(0.0);
     aXBox->setSingleStep(1.0);
     aYBox->setSingleStep(1.0);
     aZBox->setSingleStep(1.0);
 
 
 
 
     connect(m_rotationCenterButtons, SIGNAL(buttonPressed(int)), this, SLOT(slotRotationCenterChanged(int)));
     connect(btnTransformAroundPivotPoint, SIGNAL(clicked(bool)), this, SLOT(slotTransformAroundRotationCenter(bool)));
 
     // Init Free Transform Values
     connect(scaleXBox, SIGNAL(valueChanged(int)), this, SLOT(slotSetScaleX(int)));
     connect(scaleYBox, SIGNAL(valueChanged(int)), this, SLOT(slotSetScaleY(int)));
     connect(shearXBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetShearX(qreal)));
     connect(shearYBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetShearY(qreal)));
     connect(translateXBox, SIGNAL(valueChanged(int)), this, SLOT(slotSetTranslateX(int)));
     connect(translateYBox, SIGNAL(valueChanged(int)), this, SLOT(slotSetTranslateY(int)));
     connect(aXBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetAX(qreal)));
     connect(aYBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetAY(qreal)));
     connect(aZBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetAZ(qreal)));
     connect(aspectButton, SIGNAL(keepAspectRatioChanged(bool)), this, SLOT(slotSetKeepAspectRatio(bool)));
     connect(flipXButton, SIGNAL(clicked(bool)), this, SLOT(slotFlipX()));
     connect(flipYButton, SIGNAL(clicked(bool)), this, SLOT(slotFlipY()));
     connect(rotateCWButton, SIGNAL(clicked(bool)), this, SLOT(slotRotateCW()));
     connect(rotateCCWButton, SIGNAL(clicked(bool)), this, SLOT(slotRotateCCW()));
 
     // toggle visibility of different free buttons
     connect(freeMoveRadioButton, SIGNAL(clicked(bool)), SLOT(slotTransformAreaVisible(bool)));
     connect(freeRotationRadioButton, SIGNAL(clicked(bool)), SLOT(slotTransformAreaVisible(bool)));
     connect(freeScaleRadioButton, SIGNAL(clicked(bool)), SLOT(slotTransformAreaVisible(bool)));
     connect(freeShearRadioButton, SIGNAL(clicked(bool)), SLOT(slotTransformAreaVisible(bool)));
 
     // only first group for free transform
     rotationGroup->hide();
     moveGroup->show();
     scaleGroup->hide();
     shearGroup->hide();
 
 
 
     // Init Warp Transform Values
     alphaBox->setSingleStep(0.1);
     alphaBox->setRange(0, 10, 1);
 
     connect(alphaBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetWarpAlpha(qreal)));
     connect(densityBox, SIGNAL(valueChanged(int)), this, SLOT(slotSetWarpDensity(int)));
 
     connect(defaultRadioButton, SIGNAL(clicked(bool)), this, SLOT(slotWarpDefaultPointsButtonClicked(bool)));
     connect(customRadioButton, SIGNAL(clicked(bool)), this, SLOT(slotWarpCustomPointsButtonClicked(bool)));
     connect(lockUnlockPointsButton, SIGNAL(clicked()), this, SLOT(slotWarpLockPointsButtonClicked()));
     connect(resetPointsButton, SIGNAL(clicked()), this, SLOT(slotWarpResetPointsButtonClicked()));
 
     // Init Cage Transform Values
     cageTransformButtonGroup->setId(cageAddEditRadio, 0); // we need to set manually since Qt Designer generates negative by default
     cageTransformButtonGroup->setId(cageDeformRadio, 1);
     connect(cageTransformButtonGroup, SIGNAL(buttonClicked(int)), this, SLOT(slotCageOptionsChanged(int)));
 
     // Init Liquify Transform Values
     liquifySizeSlider->setRange(KisLiquifyProperties::minSize(),
                                 KisLiquifyProperties::maxSize(), 2);
     liquifySizeSlider->setExponentRatio(4);
     liquifySizeSlider->setValue(60.0);
     connect(liquifySizeSlider, SIGNAL(valueChanged(qreal)), this, SLOT(liquifySizeChanged(qreal)));
     liquifySizeSlider->setToolTip(i18nc("@info:tooltip", "Size of the deformation brush"));
 
     liquifyAmountSlider->setRange(0.0, 1.0, 2);
     liquifyAmountSlider->setValue(0.05);
     connect(liquifyAmountSlider, SIGNAL(valueChanged(qreal)), this, SLOT(liquifyAmountChanged(qreal)));
     liquifyAmountSlider->setToolTip(i18nc("@info:tooltip", "Amount of the deformation you get"));
 
     liquifyFlowSlider->setRange(0.0, 1.0, 2);
     liquifyFlowSlider->setValue(1.0);
     connect(liquifyFlowSlider, SIGNAL(valueChanged(qreal)), this, SLOT(liquifyFlowChanged(qreal)));
     liquifyFlowSlider->setToolTip(i18nc("@info:tooltip", "When in non-buildup mode, shows how fast the deformation limit is reached."));
 
     buidupModeComboBox->setCurrentIndex(0); // set to build-up mode by default
     connect(buidupModeComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(liquifyBuildUpChanged(int)));
     buidupModeComboBox->setToolTip(i18nc("@info:tooltip", "Switch between Build Up and Wash mode of painting. Build Up mode adds deformations one on top of the other without any limits. Wash mode gradually deforms the piece to the selected deformation level."));
 
     liquifySpacingSlider->setRange(0.0, 3.0, 2);
     liquifySizeSlider->setExponentRatio(3);
     liquifySpacingSlider->setSingleStep(0.01);
     liquifySpacingSlider->setValue(0.2);
     connect(liquifySpacingSlider, SIGNAL(valueChanged(qreal)), this, SLOT(liquifySpacingChanged(qreal)));
     liquifySpacingSlider->setToolTip(i18nc("@info:tooltip", "Space between two sequential applications of the deformation"));
 
     liquifySizePressureBox->setChecked(true);
     connect(liquifySizePressureBox, SIGNAL(toggled(bool)), this, SLOT(liquifySizePressureChanged(bool)));
     liquifySizePressureBox->setToolTip(i18nc("@info:tooltip", "Scale <b>Size</b> value according to current stylus pressure"));
 
     liquifyAmountPressureBox->setChecked(true);
     connect(liquifyAmountPressureBox, SIGNAL(toggled(bool)), this, SLOT(liquifyAmountPressureChanged(bool)));
     liquifyAmountPressureBox->setToolTip(i18nc("@info:tooltip", "Scale <b>Amount</b> value according to current stylus pressure"));
 
     liquifyReverseDirectionChk->setChecked(false);
     connect(liquifyReverseDirectionChk, SIGNAL(toggled(bool)), this, SLOT(liquifyReverseDirectionChanged(bool)));
     liquifyReverseDirectionChk->setToolTip(i18nc("@info:tooltip", "Reverse direction of the current deformation tool"));
 
     QSignalMapper *liquifyModeMapper = new QSignalMapper(this);
     connect(liquifyMove, SIGNAL(toggled(bool)), liquifyModeMapper, SLOT(map()));
     connect(liquifyScale, SIGNAL(toggled(bool)), liquifyModeMapper, SLOT(map()));
     connect(liquifyRotate, SIGNAL(toggled(bool)), liquifyModeMapper, SLOT(map()));
     connect(liquifyOffset, SIGNAL(toggled(bool)), liquifyModeMapper, SLOT(map()));
     connect(liquifyUndo, SIGNAL(toggled(bool)), liquifyModeMapper, SLOT(map()));
     liquifyModeMapper->setMapping(liquifyMove, (int)KisLiquifyProperties::MOVE);
     liquifyModeMapper->setMapping(liquifyScale, (int)KisLiquifyProperties::SCALE);
     liquifyModeMapper->setMapping(liquifyRotate, (int)KisLiquifyProperties::ROTATE);
     liquifyModeMapper->setMapping(liquifyOffset, (int)KisLiquifyProperties::OFFSET);
     liquifyModeMapper->setMapping(liquifyUndo, (int)KisLiquifyProperties::UNDO);
     connect(liquifyModeMapper, SIGNAL(mapped(int)), SLOT(slotLiquifyModeChanged(int)));
 
     liquifyMove->setToolTip(i18nc("@info:tooltip", "Move: drag the image along the brush stroke"));
     liquifyScale->setToolTip(i18nc("@info:tooltip", "Scale: grow/shrink image under cursor"));
     liquifyRotate->setToolTip(i18nc("@info:tooltip", "Rotate: twirl image under cursor"));
     liquifyOffset->setToolTip(i18nc("@info:tooltip", "Offset: shift the image to the right of the stroke direction"));
     liquifyUndo->setToolTip(i18nc("@info:tooltip", "Undo: erase actions of other tools"));
 
     // Connect all edit boxes to the Editing Finished signal
     connect(densityBox, SIGNAL(editingFinished()), this, SLOT(notifyEditingFinished()));
 
 
 
     // Connect other widget (not having editingFinished signal) to
     // the same slot. From Qt 4.6 onwards the sequence of the signal
     // delivery is definite.
     connect(cmbFilter, SIGNAL(activated(const KoID &)), this, SLOT(notifyEditingFinished()));
     connect(cmbWarpType, SIGNAL(currentIndexChanged(int)), this, SLOT(notifyEditingFinished()));
     connect(m_rotationCenterButtons, SIGNAL(buttonPressed(int)), this, SLOT(notifyEditingFinished()));
     connect(aspectButton, SIGNAL(keepAspectRatioChanged(bool)), this, SLOT(notifyEditingFinished()));
     connect(defaultRadioButton, SIGNAL(clicked(bool)), this, SLOT(notifyEditingFinished()));
     connect(customRadioButton, SIGNAL(clicked(bool)), this, SLOT(notifyEditingFinished()));
     connect(lockUnlockPointsButton, SIGNAL(clicked()), this, SLOT(notifyEditingFinished()));
     connect(resetPointsButton, SIGNAL(clicked()), this, SLOT(notifyEditingFinished()));
 
     // Liquify
     //
     // liquify brush options do not affect the image directly and are not
     // saved to undo, so we don't emit notifyEditingFinished() for them
 
     // Connect Apply/Reset buttons
     connect(buttonBox, SIGNAL(clicked(QAbstractButton *)), this, SLOT(slotButtonBoxClicked(QAbstractButton *)));
 
     // Mode switch buttons
     connect(freeTransformButton, SIGNAL(clicked(bool)), this, SLOT(slotSetFreeTransformModeButtonClicked(bool)));
     connect(warpButton, SIGNAL(clicked(bool)), this, SLOT(slotSetWarpModeButtonClicked(bool)));
     connect(cageButton, SIGNAL(clicked(bool)), this, SLOT(slotSetCageModeButtonClicked(bool)));
     connect(perspectiveTransformButton, SIGNAL(clicked(bool)), this, SLOT(slotSetPerspectiveModeButtonClicked(bool)));
     connect(liquifyButton, SIGNAL(clicked(bool)), this, SLOT(slotSetLiquifyModeButtonClicked(bool)));
 
     // Connect Decorations switcher
     connect(showDecorationsBox, SIGNAL(toggled(bool)), canvas, SLOT(updateCanvas()));
 
     tooBigLabelWidget->hide();
 
     connect(canvas->viewManager()->mainWindow(), SIGNAL(themeChanged()), SLOT(slotUpdateIcons()), Qt::UniqueConnection);
     slotUpdateIcons();
 }
 
 void KisToolTransformConfigWidget::slotUpdateIcons()
 {
     freeTransformButton->setIcon(KisIconUtils::loadIcon("transform_icons_main"));
     warpButton->setIcon(KisIconUtils::loadIcon("transform_icons_warp"));
     cageButton->setIcon(KisIconUtils::loadIcon("transform_icons_cage"));
     perspectiveTransformButton->setIcon(KisIconUtils::loadIcon("transform_icons_perspective"));
     liquifyButton->setIcon(KisIconUtils::loadIcon("transform_icons_liquify_main"));
 
     liquifyMove->setIcon(KisIconUtils::loadIcon("transform_icons_liquify_move"));
     liquifyScale->setIcon(KisIconUtils::loadIcon("transform_icons_liquify_resize"));
     liquifyRotate->setIcon(KisIconUtils::loadIcon("transform_icons_liquify_rotate"));
     liquifyOffset->setIcon(KisIconUtils::loadIcon("transform_icons_liquify_offset"));
     liquifyUndo->setIcon(KisIconUtils::loadIcon("transform_icons_liquify_erase"));
 
 
 
     middleRightButton->setIcon(KisIconUtils::loadIcon("arrow-right"));
     topRightButton->setIcon(KisIconUtils::loadIcon("arrow-topright"));
     middleTopButton->setIcon(KisIconUtils::loadIcon("arrow-up"));
     topLeftButton->setIcon(KisIconUtils::loadIcon("arrow-topleft"));
     middleLeftButton->setIcon(KisIconUtils::loadIcon("arrow-left"));
     bottomLeftButton->setIcon(KisIconUtils::loadIcon("arrow-downleft"));
     middleBottomButton->setIcon(KisIconUtils::loadIcon("arrow-down"));
     bottomRightButton->setIcon(KisIconUtils::loadIcon("arrow-downright"));
 
     btnTransformAroundPivotPoint->setIcon(KisIconUtils::loadIcon("pivot-point"));
 
 
     // pressure icons
     liquifySizePressureBox->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure"));
     liquifyAmountPressureBox->setIcon(KisIconUtils::loadIcon("transform_icons_penPressure"));
 }
 
 double KisToolTransformConfigWidget::radianToDegree(double rad)
 {
     double piX2 = 2 * M_PI;
 
     if (rad < 0 || rad >= piX2) {
         rad = fmod(rad, piX2);
         if (rad < 0) {
             rad += piX2;
         }
     }
 
     return (rad * 360. / piX2);
 }
 
 double KisToolTransformConfigWidget::degreeToRadian(double degree)
 {
     if (degree < 0. || degree >= 360.) {
         degree = fmod(degree, 360.);
         if (degree < 0)
             degree += 360.;
     }
 
     return (degree * M_PI / 180.);
 }
 
 void KisToolTransformConfigWidget::updateLiquifyControls()
 {
     blockUiSlots();
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     const bool useWashMode = props->useWashMode();
 
     liquifySizeSlider->setValue(props->size());
     liquifyAmountSlider->setValue(props->amount());
     liquifyFlowSlider->setValue(props->flow());
     buidupModeComboBox->setCurrentIndex(useWashMode);
 
     liquifySpacingSlider->setValue(props->spacing());
     liquifySizePressureBox->setChecked(props->sizeHasPressure());
     liquifyAmountPressureBox->setChecked(props->amountHasPressure());
     liquifyReverseDirectionChk->setChecked(props->reverseDirection());
 
 
     KisLiquifyProperties::LiquifyMode mode =
         static_cast<KisLiquifyProperties::LiquifyMode>(props->mode());
 
     bool canInverseDirection =
         mode != KisLiquifyProperties::UNDO;
 
     bool canUseWashMode = mode != KisLiquifyProperties::UNDO;
 
     liquifyReverseDirectionChk->setEnabled(canInverseDirection);
     liquifyFlowSlider->setEnabled(canUseWashMode && useWashMode);
     buidupModeComboBox->setEnabled(canUseWashMode);
 
     const qreal maxAmount = canUseWashMode ? 5.0 : 1.0;
     liquifyAmountSlider->setRange(0.0, maxAmount, 2);
 
     unblockUiSlots();
 }
 
 void KisToolTransformConfigWidget::slotLiquifyModeChanged(int value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     KisLiquifyProperties::LiquifyMode mode =
         static_cast<KisLiquifyProperties::LiquifyMode>(value);
 
     if (mode == props->mode()) return;
 
     props->setMode(mode);
     props->loadMode();
 
     updateLiquifyControls();
 
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::liquifySizeChanged(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setSize(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::liquifyAmountChanged(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setAmount(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::liquifyFlowChanged(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setFlow(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::liquifyBuildUpChanged(int value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setUseWashMode(value); // 0 == build up mode / 1 == wash mode
 
     notifyConfigChanged();
 
     // we need to enable/disable flow slider
     updateLiquifyControls();
 }
 
 void KisToolTransformConfigWidget::liquifySpacingChanged(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setSpacing(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::liquifySizePressureChanged(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setSizeHasPressure(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::liquifyAmountPressureChanged(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setAmountHasPressure(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::liquifyReverseDirectionChanged(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     KisLiquifyProperties *props =
         config->liquifyProperties();
 
     props->setReverseDirection(value);
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::updateConfig(const ToolTransformArgs &config)
 {
     blockUiSlots();
 
     if (config.mode() == ToolTransformArgs::FREE_TRANSFORM ||
         config.mode() == ToolTransformArgs::PERSPECTIVE_4POINT) {
 
         quickTransformGroup->setEnabled(config.mode() == ToolTransformArgs::FREE_TRANSFORM);
 
         stackedWidget->setCurrentIndex(0);
 
         bool freeTransformIsActive = config.mode() == ToolTransformArgs::FREE_TRANSFORM;
 
         if (freeTransformIsActive)
         {
             freeTransformButton->setChecked(true);
         }
         else
         {
             perspectiveTransformButton->setChecked(true);
         }
 
         aXBox->setEnabled(freeTransformIsActive);
         aYBox->setEnabled(freeTransformIsActive);
         aZBox->setEnabled(freeTransformIsActive);
         freeRotationRadioButton->setEnabled(freeTransformIsActive);
 
         scaleXBox->setValue(config.scaleX() * 100.);
         scaleYBox->setValue(config.scaleY() * 100.);
         shearXBox->setValue(config.shearX());
         shearYBox->setValue(config.shearY());
 
         const QPointF anchorPoint = config.originalCenter() + config.rotationCenterOffset();
         const KisTransformUtils::MatricesPack m(config);
         const QPointF anchorPointView = m.finalTransform().map(anchorPoint);
 
         translateXBox->setValue(anchorPointView.x());
         translateYBox->setValue(anchorPointView.y());
 
         aXBox->setValue(radianToDegree(config.aX()));
         aYBox->setValue(radianToDegree(config.aY()));
         aZBox->setValue(radianToDegree(config.aZ()));
         aspectButton->setKeepAspectRatio(config.keepAspectRatio());
         cmbFilter->setCurrent(config.filterId());
 
         QPointF pt = m_transaction->currentConfig()->rotationCenterOffset();
         pt.rx() /= m_transaction->originalHalfWidth();
         pt.ry() /= m_transaction->originalHalfHeight();
 
         for (int i = 0; i < 9; i++) {
             if (qFuzzyCompare(m_handleDir[i].x(), pt.x()) &&
                 qFuzzyCompare(m_handleDir[i].y(), pt.y())) {
 
                 m_rotationCenterButtons->button(i)->setChecked(true);
                 break;
             }
         }
 
         btnTransformAroundPivotPoint->setChecked(config.transformAroundRotationCenter());
 
     } else if (config.mode() == ToolTransformArgs::WARP) {
 
         stackedWidget->setCurrentIndex(1);
         warpButton->setChecked(true);
 
         if (config.defaultPoints()) {
             densityBox->setValue(std::sqrt(config.numPoints()));
         }
 
         cmbWarpType->setCurrentIndex((int)config.warpType());
         defaultRadioButton->setChecked(config.defaultPoints());
         customRadioButton->setChecked(!config.defaultPoints());
         densityBox->setEnabled(config.defaultPoints());
         customWarpWidget->setEnabled(!config.defaultPoints());
 
         updateLockPointsButtonCaption();
 
     } else if (config.mode() == ToolTransformArgs::CAGE) {
 
         // default UI options
         resetUIOptions();
 
         // we need at least 3 point before we can start actively deforming
         if (config.origPoints().size() >= 3)
         {
             cageTransformDirections->setText(i18n("Switch between editing and deforming cage"));
             cageAddEditRadio->setVisible(true);
             cageDeformRadio->setVisible(true);
 
             // update to correct radio button
             if (config.isEditingTransformPoints())
                 cageAddEditRadio->setChecked(true);
             else
                  cageDeformRadio->setChecked(true);
 
         }
 
     } else if (config.mode() == ToolTransformArgs::LIQUIFY) {
 
         stackedWidget->setCurrentIndex(3);
         liquifyButton->setChecked(true);
 
         const KisLiquifyProperties *props =
             config.liquifyProperties();
 
         switch (props->mode()) {
         case KisLiquifyProperties::MOVE:
             liquifyMove->setChecked(true);
             break;
         case KisLiquifyProperties::SCALE:
             liquifyScale->setChecked(true);
             break;
         case KisLiquifyProperties::ROTATE:
             liquifyRotate->setChecked(true);
             break;
         case KisLiquifyProperties::OFFSET:
             liquifyOffset->setChecked(true);
             break;
         case KisLiquifyProperties::UNDO:
             liquifyUndo->setChecked(true);
             break;
         case KisLiquifyProperties::N_MODES:
             qFatal("Unsupported mode");
         }
 
         updateLiquifyControls();
     }
 
     unblockUiSlots();
 }
 
 void KisToolTransformConfigWidget::updateLockPointsButtonCaption()
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     if (config->isEditingTransformPoints()) {
         lockUnlockPointsButton->setText(i18n("Lock Points"));
     } else {
         lockUnlockPointsButton->setText(i18n("Unlock Points"));
     }
 }
 
 void KisToolTransformConfigWidget::setApplyResetDisabled(bool disabled)
 {
     QAbstractButton *applyButton = buttonBox->button(QDialogButtonBox::Apply);
     QAbstractButton *resetButton = buttonBox->button(QDialogButtonBox::Reset);
 
     Q_ASSERT(applyButton);
     Q_ASSERT(resetButton);
 
     applyButton->setDisabled(disabled);
     resetButton->setDisabled(disabled);
 }
 
 void KisToolTransformConfigWidget::resetRotationCenterButtons()
 {
     int checkedId = m_rotationCenterButtons->checkedId();
 
     if (checkedId >= 0 && checkedId <= 8) {
         // uncheck the current checked button
         m_rotationCenterButtons->button(9)->setChecked(true);
     }
 }
 
 bool KisToolTransformConfigWidget::workRecursively() const
 {
     return chkWorkRecursively->isChecked();
 }
 
 void KisToolTransformConfigWidget::setTooBigLabelVisible(bool value)
 {
     tooBigLabelWidget->setVisible(value);
 }
 
 bool KisToolTransformConfigWidget::showDecorations() const
 {
     return showDecorationsBox->isChecked();
 }
 
 void KisToolTransformConfigWidget::blockNotifications()
 {
     m_notificationsBlocked++;
 }
 
 void KisToolTransformConfigWidget::unblockNotifications()
 {
     m_notificationsBlocked--;
 }
 
 void KisToolTransformConfigWidget::notifyConfigChanged()
 {
     if (!m_notificationsBlocked) {
         emit sigConfigChanged();
     }
     m_configChanged = true;
 }
 
 void KisToolTransformConfigWidget::blockUiSlots()
 {
     m_uiSlotsBlocked++;
 }
 
 void KisToolTransformConfigWidget::unblockUiSlots()
 {
     m_uiSlotsBlocked--;
 }
 
 void KisToolTransformConfigWidget::notifyEditingFinished()
 {
     if (m_uiSlotsBlocked || m_notificationsBlocked || !m_configChanged) return;
 
     emit sigEditingFinished();
     m_configChanged = false;
 }
 
 
 void KisToolTransformConfigWidget::resetUIOptions()
 {
     // reset tool states since we are done (probably can encapsulate this later)
     ToolTransformArgs *config = m_transaction->currentConfig();
     if (config->mode() == ToolTransformArgs::CAGE)
     {
         cageAddEditRadio->setVisible(false);
         cageAddEditRadio->setChecked(true);
         cageDeformRadio->setVisible(false);
         cageTransformDirections->setText(i18n("Create 3 points on the canvas to begin"));
 
         // ensure we are on the right options view
         stackedWidget->setCurrentIndex(2);
     }
 
 
 
 }
 
 void KisToolTransformConfigWidget::slotButtonBoxClicked(QAbstractButton *button)
 {
     QAbstractButton *applyButton = buttonBox->button(QDialogButtonBox::Apply);
     QAbstractButton *resetButton = buttonBox->button(QDialogButtonBox::Reset);
 
     resetUIOptions();
 
     if (button == applyButton) {
         emit sigApplyTransform();
     }
     else if (button == resetButton) {
         emit sigResetTransform();
     }
 
 }
 
 void KisToolTransformConfigWidget::slotSetFreeTransformModeButtonClicked(bool value)
 {
     if (!value) return;
 
     lblTransformType->setText(freeTransformButton->toolTip());
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setMode(ToolTransformArgs::FREE_TRANSFORM);
     emit sigResetTransform();
 }
 
 void KisToolTransformConfigWidget::slotSetWarpModeButtonClicked(bool value)
 {
     if (!value) return;
 
     lblTransformType->setText(warpButton->toolTip());
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setMode(ToolTransformArgs::WARP);
     emit sigResetTransform();
 }
 
 void KisToolTransformConfigWidget::slotSetCageModeButtonClicked(bool value)
 {
     if (!value) return;
 
     lblTransformType->setText(cageButton->toolTip());
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setMode(ToolTransformArgs::CAGE);
     emit sigResetTransform();
 }
 
 void KisToolTransformConfigWidget::slotSetLiquifyModeButtonClicked(bool value)
 {
     if (!value) return;
 
     lblTransformType->setText(liquifyButton->toolTip());
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setMode(ToolTransformArgs::LIQUIFY);
     emit sigResetTransform();
 }
 
 void KisToolTransformConfigWidget::slotSetPerspectiveModeButtonClicked(bool value)
 {
     if (!value) return;
 
     lblTransformType->setText(perspectiveTransformButton->toolTip());
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setMode(ToolTransformArgs::PERSPECTIVE_4POINT);
     emit sigResetTransform();
 }
 
 void KisToolTransformConfigWidget::slotFilterChanged(const KoID &filterId)
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setFilterId(filterId.id());
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::slotRotationCenterChanged(int index)
 {
     if (m_uiSlotsBlocked) return;
 
     if (index >= 0 && index <= 8) {
         ToolTransformArgs *config = m_transaction->currentConfig();
 
         double i = m_handleDir[index].x();
         double j = m_handleDir[index].y();
 
         config->setRotationCenterOffset(QPointF(i * m_transaction->originalHalfWidth(),
                                                 j * m_transaction->originalHalfHeight()));
 
         notifyConfigChanged();
         updateConfig(*config);
     }
 }
 
 void KisToolTransformConfigWidget::slotTransformAroundRotationCenter(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setTransformAroundRotationCenter(value);
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetScaleX(int value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setScaleX(value / 100.);
     }
 
     if (config->keepAspectRatio()) {
 
         blockNotifications();
          int calculatedValue = int( value/ m_scaleRatio );
 
         scaleYBox->blockSignals(true);
         scaleYBox->setValue(calculatedValue);
-        config->setScaleY(calculatedValue / 100.);
+        {
+            KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
+            config->setScaleY(calculatedValue / 100.);
+        }
         scaleYBox->blockSignals(false);
 
         unblockNotifications();
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetScaleY(int value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setScaleY(value / 100.);
     }
 
     if (config->keepAspectRatio()) {
         blockNotifications();
         int calculatedValue = int(m_scaleRatio * value);
         scaleXBox->blockSignals(true);
         scaleXBox->setValue(calculatedValue);
-        config->setScaleX(calculatedValue / 100.);
+        {
+            KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
+            config->setScaleX(calculatedValue / 100.);
+        }
         scaleXBox->blockSignals(false);
         unblockNotifications();
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetShearX(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setShearX((double)value);
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetShearY(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setShearY((double)value);
     }
 
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetTranslateX(int value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     const QPointF anchorPoint = config->originalCenter() + config->rotationCenterOffset();
     const KisTransformUtils::MatricesPack m(*config);
 
     const QPointF anchorPointView = m.finalTransform().map(anchorPoint);
     const QPointF newAnchorPointView(value, anchorPointView.y());
     config->setTransformedCenter(config->transformedCenter() + newAnchorPointView - anchorPointView);
 
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::slotSetTranslateY(int value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     const QPointF anchorPoint = config->originalCenter() + config->rotationCenterOffset();
     const KisTransformUtils::MatricesPack m(*config);
 
     const QPointF anchorPointView = m.finalTransform().map(anchorPoint);
     const QPointF newAnchorPointView(anchorPointView.x(), value);
     config->setTransformedCenter(config->transformedCenter() + newAnchorPointView - anchorPointView);
 
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::slotSetAX(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setAX(degreeToRadian((double)value));
     }
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetAY(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setAY(degreeToRadian((double)value));
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetAZ(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setAZ(degreeToRadian((double)value));
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotFlipX()
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setScaleX(config->scaleX() * -1);
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotFlipY()
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setScaleY(config->scaleY() * -1);
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotRotateCW()
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setAZ(normalizeAngle(config->aZ() + M_PI_2));
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotRotateCCW()
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     {
         KisTransformUtils::AnchorHolder keeper(config->transformAroundRotationCenter(), config);
         config->setAZ(normalizeAngle(config->aZ() - M_PI_2));
     }
 
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 
 // change free transform setting we want to alter (all radio buttons call this)
 void KisToolTransformConfigWidget::slotTransformAreaVisible(bool value)
 {
     Q_UNUSED(value);
 
     //QCheckBox sender = (QCheckBox)(*)(QObject::sender());
     QString senderName = QObject::sender()->objectName();
 
 
     // only show setting with what we have selected
     rotationGroup->hide();
     shearGroup->hide();
     scaleGroup->hide();
     moveGroup->hide();
 
 
     if ("freeMoveRadioButton" == senderName)
     {
         moveGroup->show();
     }
     else  if ("freeShearRadioButton" == senderName)
     {
         shearGroup->show();
     }
     else if ("freeScaleRadioButton" == senderName)
     {
         scaleGroup->show();
     }
     else
     {
         rotationGroup->show();
     }
 
 }
 
 void KisToolTransformConfigWidget::slotSetKeepAspectRatio(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setKeepAspectRatio(value);
 
     if (value) {
        blockNotifications();
        int tmpXScaleBox = scaleXBox->value();
        int tmpYScaleBox = scaleYBox->value();
        m_scaleRatio = (tmpXScaleBox / (double) tmpYScaleBox);
        unblockNotifications();
     }
 
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::slotSetWarpAlpha(qreal value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     config->setAlpha((double)value);
     notifyConfigChanged();
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotSetWarpDensity(int value)
 {
     if (m_uiSlotsBlocked) return;
     setDefaultWarpPoints(value);
 }
 
 void KisToolTransformConfigWidget::setDefaultWarpPoints(int pointsPerLine)
 {
     if (pointsPerLine < 0) {
         pointsPerLine = DEFAULT_POINTS_PER_LINE;
     }
 
     int nbPoints = pointsPerLine * pointsPerLine;
     QVector<QPointF> origPoints(nbPoints);
     QVector<QPointF> transfPoints(nbPoints);
     qreal gridSpaceX, gridSpaceY;
 
     if (nbPoints == 1) {
         //there is actually no grid
         origPoints[0] = m_transaction->originalCenterGeometric();
         transfPoints[0] = m_transaction->originalCenterGeometric();
     }
     else if (nbPoints > 1) {
         gridSpaceX = m_transaction->originalRect().width() / (pointsPerLine - 1);
         gridSpaceY = m_transaction->originalRect().height() / (pointsPerLine - 1);
         double y = m_transaction->originalRect().top();
         for (int i = 0; i < pointsPerLine; ++i) {
             double x = m_transaction->originalRect().left();
             for (int j = 0 ; j < pointsPerLine; ++j) {
                 origPoints[i * pointsPerLine + j] = QPointF(x, y);
                 transfPoints[i * pointsPerLine + j] = QPointF(x, y);
                 x += gridSpaceX;
             }
             y += gridSpaceY;
         }
     }
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     config->setDefaultPoints(nbPoints > 0);
     config->setPoints(origPoints, transfPoints);
 
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::activateCustomWarpPoints(bool enabled)
 {
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     densityBox->setEnabled(!enabled);
     customWarpWidget->setEnabled(enabled);
 
     if (!enabled) {
         config->setEditingTransformPoints(false);
         setDefaultWarpPoints(densityBox->value());
     } else {
         config->setEditingTransformPoints(true);
         setDefaultWarpPoints(0);
     }
 
     updateLockPointsButtonCaption();
 }
 
 void KisToolTransformConfigWidget::slotWarpDefaultPointsButtonClicked(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     activateCustomWarpPoints(!value);
 }
 
 void KisToolTransformConfigWidget::slotWarpCustomPointsButtonClicked(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     activateCustomWarpPoints(value);
 }
 
 void KisToolTransformConfigWidget::slotWarpResetPointsButtonClicked()
 {
     if (m_uiSlotsBlocked) return;
 
     activateCustomWarpPoints(true);
 }
 
 void KisToolTransformConfigWidget::slotWarpLockPointsButtonClicked()
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->setEditingTransformPoints(!config->isEditingTransformPoints());
 
     if (config->isEditingTransformPoints()) {
         // reinit the transf points to their original value
         ToolTransformArgs *config = m_transaction->currentConfig();
         int nbPoints = config->origPoints().size();
         for (int i = 0; i < nbPoints; ++i) {
             config->transfPoint(i) = config->origPoint(i);
         }
     }
 
     updateLockPointsButtonCaption();
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::slotWarpTypeChanged(int index)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
 
     switch (index) {
     case KisWarpTransformWorker::AFFINE_TRANSFORM:
     case KisWarpTransformWorker::SIMILITUDE_TRANSFORM:
     case KisWarpTransformWorker::RIGID_TRANSFORM:
         config->setWarpType((KisWarpTransformWorker::WarpType)index);
         break;
     default:
         config->setWarpType(KisWarpTransformWorker::RIGID_TRANSFORM);
         break;
     }
 
     notifyConfigChanged();
 }
 
 void KisToolTransformConfigWidget::slotCageOptionsChanged(int value)
 {
     if ( value == 0)
     {
         slotEditCagePoints(true);
     }
     else
     {
         slotEditCagePoints(false);
     }
 
     notifyEditingFinished();
 }
 
 void KisToolTransformConfigWidget::slotEditCagePoints(bool value)
 {
     if (m_uiSlotsBlocked) return;
 
     ToolTransformArgs *config = m_transaction->currentConfig();
     config->refTransformedPoints() = config->origPoints();
 
     config->setEditingTransformPoints(value);
     notifyConfigChanged();
 }