diff --git a/libs/flake/CMakeLists.txt b/libs/flake/CMakeLists.txt
index c63e0821b8..aef106e243 100644
--- a/libs/flake/CMakeLists.txt
+++ b/libs/flake/CMakeLists.txt
@@ -1,225 +1,226 @@
 project(kritaflake)
 
 include_directories(
     ${CMAKE_SOURCE_DIR}/libs/flake/commands
     ${CMAKE_SOURCE_DIR}/libs/flake/tools
     ${CMAKE_SOURCE_DIR}/libs/flake/svg
     ${CMAKE_BINARY_DIR}/libs/flake
 )
 
 add_subdirectory(styles)
 add_subdirectory(tests)
 
 set(kritaflake_SRCS
     KoGradientHelper.cpp
     KoFlake.cpp
     KoCanvasBase.cpp
     KoResourceManager_p.cpp
     KoDerivedResourceConverter.cpp
+    KoResourceUpdateMediator.cpp
     KoCanvasResourceManager.cpp
     KoDocumentResourceManager.cpp
     KoCanvasObserverBase.cpp
     KoCanvasSupervisor.cpp
     KoDockFactoryBase.cpp
     KoDockRegistry.cpp
     KoDataCenterBase.cpp
     KoInsets.cpp
     KoPathShape.cpp
     KoPathPoint.cpp
     KoPathSegment.cpp
     KoSelection.cpp
     KoShape.cpp
     KoShapeAnchor.cpp
     KoShapeBasedDocumentBase.cpp
     KoShapeApplicationData.cpp
     KoShapeContainer.cpp
     KoShapeContainerModel.cpp
     KoShapeContainerDefaultModel.cpp
     KoShapeGroup.cpp
     KoShapeManagerPaintingStrategy.cpp
     KoShapeManager.cpp
     KoShapePaintingContext.cpp
     KoFrameShape.cpp
     KoUnavailShape.cpp
     KoMarkerData.cpp
     KoMarker.cpp
     KoMarkerCollection.cpp
     KoMarkerSharedLoadingData.cpp
     KoToolBase.cpp
     KoCanvasController.cpp
     KoCanvasControllerWidget.cpp
     KoCanvasControllerWidgetViewport_p.cpp
     KoShapeRegistry.cpp
     KoDeferredShapeFactoryBase.cpp
     KoToolFactoryBase.cpp
     KoPathShapeFactory.cpp
     KoShapeFactoryBase.cpp
     KoShapeUserData.cpp
     KoParameterShape.cpp
     KoPointerEvent.cpp
     KoShapeController.cpp
     KoToolSelection.cpp
     KoShapeLayer.cpp
     KoPostscriptPaintDevice.cpp
     KoInputDevice.cpp
     KoToolManager_p.cpp
     KoToolManager.cpp
     KoToolRegistry.cpp
     KoToolProxy.cpp
     KoShapeSavingContext.cpp
     KoShapeLoadingContext.cpp
     KoLoadingShapeUpdater.cpp
     KoPathShapeLoader.cpp
     KoShapeStrokeModel.cpp
     KoShapeStroke.cpp
     KoShapeBackground.cpp
     KoColorBackground.cpp
     KoGradientBackground.cpp
     KoOdfGradientBackground.cpp
     KoHatchBackground.cpp
     KoPatternBackground.cpp
     KoShapeConfigWidgetBase.cpp
     KoDrag.cpp
     KoDragOdfSaveHelper.cpp
     KoShapeOdfSaveHelper.cpp
     KoShapePaste.cpp
     KoConnectionPoint.cpp
     KoConnectionShape.cpp
     KoConnectionShapeLoadingUpdater.cpp
     KoConnectionShapeFactory.cpp
     KoConnectionShapeConfigWidget.cpp
     KoSnapGuide.cpp
     KoSnapProxy.cpp
     KoSnapStrategy.cpp
     KoSnapData.cpp
     KoShapeShadow.cpp
     KoSharedLoadingData.cpp
     KoSharedSavingData.cpp
     KoViewConverter.cpp
     KoInputDeviceHandler.cpp
     KoInputDeviceHandlerEvent.cpp
     KoInputDeviceHandlerRegistry.cpp
     KoImageData.cpp
     KoImageData_p.cpp
     KoImageCollection.cpp
     KoOdfWorkaround.cpp
     KoFilterEffect.cpp
     KoFilterEffectStack.cpp
     KoFilterEffectFactoryBase.cpp
     KoFilterEffectRegistry.cpp
     KoFilterEffectConfigWidgetBase.cpp
     KoFilterEffectRenderContext.cpp
     KoFilterEffectLoadingContext.cpp
     KoTextShapeDataBase.cpp
     KoTosContainer.cpp
     KoTosContainerModel.cpp
     KoClipPath.cpp
     KoCurveFit.cpp
     commands/KoShapeGroupCommand.cpp
     commands/KoShapeAlignCommand.cpp
     commands/KoShapeBackgroundCommand.cpp
     commands/KoShapeCreateCommand.cpp
     commands/KoShapeDeleteCommand.cpp
     commands/KoShapeDistributeCommand.cpp
     commands/KoShapeLockCommand.cpp
     commands/KoShapeMoveCommand.cpp
     commands/KoShapeShearCommand.cpp
     commands/KoShapeSizeCommand.cpp
     commands/KoShapeStrokeCommand.cpp
     commands/KoShapeUngroupCommand.cpp
     commands/KoShapeReorderCommand.cpp
     commands/KoShapeKeepAspectRatioCommand.cpp
     commands/KoPathBaseCommand.cpp
     commands/KoPathPointMoveCommand.cpp
     commands/KoPathControlPointMoveCommand.cpp
     commands/KoPathPointTypeCommand.cpp
     commands/KoPathPointRemoveCommand.cpp
     commands/KoPathPointInsertCommand.cpp
     commands/KoPathSegmentBreakCommand.cpp
     commands/KoPathBreakAtPointCommand.cpp
     commands/KoPathSegmentTypeCommand.cpp
     commands/KoPathCombineCommand.cpp
     commands/KoSubpathRemoveCommand.cpp
     commands/KoSubpathJoinCommand.cpp
     commands/KoParameterHandleMoveCommand.cpp
     commands/KoParameterToPathCommand.cpp
     commands/KoShapeTransformCommand.cpp
     commands/KoPathFillRuleCommand.cpp
     commands/KoConnectionShapeTypeCommand.cpp
     commands/KoShapeShadowCommand.cpp
     commands/KoPathReverseCommand.cpp
     commands/KoShapeRenameCommand.cpp
     commands/KoShapeRunAroundCommand.cpp
     commands/KoPathPointMergeCommand.cpp
     commands/KoShapeTransparencyCommand.cpp
     commands/KoShapeClipCommand.cpp
     commands/KoShapeUnclipCommand.cpp
     commands/KoPathShapeMarkerCommand.cpp
     commands/KoShapeConnectionChangeCommand.cpp
     tools/KoCreateShapeStrategy.cpp
     tools/KoPathToolFactory.cpp
     tools/KoPathTool.cpp
     tools/KoPathToolSelection.cpp
     tools/KoPathToolHandle.cpp
     tools/PathToolOptionWidget.cpp
     tools/KoPathPointRubberSelectStrategy.cpp
     tools/KoPathPointMoveStrategy.cpp
     tools/KoPathConnectionPointStrategy.cpp
     tools/KoPathControlPointMoveStrategy.cpp
     tools/KoParameterChangeStrategy.cpp
     tools/KoZoomTool.cpp
     tools/KoZoomToolFactory.cpp
     tools/KoZoomToolWidget.cpp
     tools/KoZoomStrategy.cpp
     tools/KoPanTool.cpp
     tools/KoPanToolFactory.cpp
     tools/KoInteractionTool.cpp
     tools/KoInteractionStrategy.cpp
     tools/KoCreateShapesTool.cpp
     tools/KoCreateShapesToolFactory.cpp
     tools/KoShapeRubberSelectStrategy.cpp
     tools/KoPathSegmentChangeStrategy.cpp
     svg/KoShapePainter.cpp
     svg/SvgUtil.cpp
     svg/SvgGraphicContext.cpp
     svg/SvgSavingContext.cpp
     svg/SvgWriter.cpp
     svg/SvgStyleWriter.cpp
     svg/SvgShape.cpp
     svg/SvgParser.cpp
     svg/SvgStyleParser.cpp
     svg/SvgGradientHelper.cpp
     svg/SvgPatternHelper.cpp
     svg/SvgFilterHelper.cpp
     svg/SvgCssHelper.cpp
     svg/SvgClipPathHelper.cpp
     svg/SvgLoadingContext.cpp
     svg/SvgShapeFactory.cpp
 
     FlakeDebug.cpp
 )
 
 ki18n_wrap_ui(kritaflake_SRCS
     tools/PathToolOptionWidgetBase.ui
     KoConnectionShapeConfigWidget.ui
     tools/KoZoomToolWidget.ui
 )
 
 add_library(kritaflake SHARED ${kritaflake_SRCS})
 generate_export_header(kritaflake BASE_NAME kritaflake)
 
 target_include_directories(kritaflake
     PUBLIC
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/commands>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/tools>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/svg>
 )
 
 target_link_libraries(kritaflake kritapigment kritawidgetutils kritaodf kritaundo2 KF5::WidgetsAddons Qt5::Svg)
 target_link_libraries(kritaflake LINK_INTERFACE_LIBRARIES kritapigment kritawidgetutils kritaodf kritaundo2 KF5::WidgetsAddons )
 
 set_target_properties(kritaflake PROPERTIES
     VERSION ${GENERIC_KRITA_LIB_VERSION} SOVERSION ${GENERIC_KRITA_LIB_SOVERSION}
 )
 
 install(TARGETS kritaflake  ${INSTALL_TARGETS_DEFAULT_ARGS})
diff --git a/libs/flake/KoCanvasResourceManager.cpp b/libs/flake/KoCanvasResourceManager.cpp
index da7b047f2e..45f2189de4 100644
--- a/libs/flake/KoCanvasResourceManager.cpp
+++ b/libs/flake/KoCanvasResourceManager.cpp
@@ -1,182 +1,197 @@
 /*
    Copyright (c) 2006 Boudewijn Rempt (boud@valdyas.org)
    Copyright (C) 2007, 2010 Thomas Zander <zander@kde.org>
    Copyright (c) 2008 Carlos Licea <carlos.licea@kdemail.net>
    Copyright (c) 2011 Jan Hambrecht <jaham@gmx.net>
 
    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 "KoCanvasResourceManager.h"
 
 #include <QVariant>
 #include <FlakeDebug.h>
 
 #include "KoShape.h"
 #include "KoShapeStroke.h"
 #include "KoResourceManager_p.h"
 #include <KoColorSpaceRegistry.h>
 
 class Q_DECL_HIDDEN KoCanvasResourceManager::Private
 {
 public:
     KoResourceManager manager;
 };
 
 KoCanvasResourceManager::KoCanvasResourceManager(QObject *parent)
         : QObject(parent),
         d(new Private())
 {
     const KoColorSpace* cs = KoColorSpaceRegistry::instance()->rgb8();
     setForegroundColor(KoColor(Qt::black, cs));
     setBackgroundColor(KoColor(Qt::white, cs));
     setResource(ApplicationSpeciality, NoSpecial);
 
     connect(&d->manager, &KoResourceManager::resourceChanged,
             this, &KoCanvasResourceManager::canvasResourceChanged);
 }
 
 KoCanvasResourceManager::~KoCanvasResourceManager()
 {
     delete d;
 }
 
 void KoCanvasResourceManager::setResource(int key, const QVariant &value)
 {
     d->manager.setResource(key, value);
 }
 
 QVariant KoCanvasResourceManager::resource(int key) const
 {
     return d->manager.resource(key);
 }
 
 void KoCanvasResourceManager::setResource(int key, const KoColor &color)
 {
     QVariant v;
     v.setValue(color);
     setResource(key, v);
 }
 
 void KoCanvasResourceManager::setResource(int key, KoShape *shape)
 {
     QVariant v;
     v.setValue(shape);
     setResource(key, v);
 }
 
 void KoCanvasResourceManager::setResource(int key, const KoUnit &unit)
 {
     QVariant v;
     v.setValue(unit);
     setResource(key, v);
 }
 
 KoColor KoCanvasResourceManager::koColorResource(int key) const
 {
     return d->manager.koColorResource(key);
 }
 
 void KoCanvasResourceManager::setForegroundColor(const KoColor &color)
 {
     setResource(ForegroundColor, color);
 }
 
 KoColor KoCanvasResourceManager::foregroundColor() const
 {
     return koColorResource(ForegroundColor);
 }
 
 void KoCanvasResourceManager::setBackgroundColor(const KoColor &color)
 {
     setResource(BackgroundColor, color);
 }
 
 KoColor KoCanvasResourceManager::backgroundColor() const
 {
     return koColorResource(BackgroundColor);
 }
 
 KoShape *KoCanvasResourceManager::koShapeResource(int key) const
 {
     return d->manager.koShapeResource(key);
 }
 
 KoUnit KoCanvasResourceManager::unitResource(int key) const
 {
     return resource(key).value<KoUnit>();
 }
 
 
 void KoCanvasResourceManager::setActiveStroke(const KoShapeStroke &stroke)
 {
     QVariant v;
     v.setValue(stroke);
     setResource(ActiveStroke, v);
 }
 
 KoShapeStroke KoCanvasResourceManager::activeStroke() const
 {
     if (!d->manager.hasResource(ActiveStroke)) {
         KoShapeStroke empty;
         return empty;
     }
     return resource(ActiveStroke).value<KoShapeStroke>();
 }
 
 bool KoCanvasResourceManager::boolResource(int key) const
 {
     return d->manager.boolResource(key);
 }
 
 int KoCanvasResourceManager::intResource(int key) const
 {
     return d->manager.intResource(key);
 }
 
 QString KoCanvasResourceManager::stringResource(int key) const
 {
     return d->manager.stringResource(key);
 }
 
 QSizeF KoCanvasResourceManager::sizeResource(int key) const
 {
     return d->manager.sizeResource(key);
 }
 
 bool KoCanvasResourceManager::hasResource(int key) const
 {
     return d->manager.hasResource(key);
 }
 
 void KoCanvasResourceManager::clearResource(int key)
 {
     d->manager.clearResource(key);
 }
 
 void KoCanvasResourceManager::addDerivedResourceConverter(KoDerivedResourceConverterSP converter)
 {
     d->manager.addDerivedResourceConverter(converter);
 }
 
 bool KoCanvasResourceManager::hasDerivedResourceConverter(int key)
 {
     return d->manager.hasDerivedResourceConverter(key);
 }
 
 void KoCanvasResourceManager::removeDerivedResourceConverter(int key)
 {
     d->manager.removeDerivedResourceConverter(key);
 }
+
+void KoCanvasResourceManager::addResourceUpdateMediator(KoResourceUpdateMediatorSP mediator)
+{
+    d->manager.addResourceUpdateMediator(mediator);
+}
+
+bool KoCanvasResourceManager::hasResourceUpdateMediator(int key)
+{
+    return d->manager.hasResourceUpdateMediator(key);
+}
+
+void KoCanvasResourceManager::removeResourceUpdateMediator(int key)
+{
+    d->manager.removeResourceUpdateMediator(key);
+}
diff --git a/libs/flake/KoCanvasResourceManager.h b/libs/flake/KoCanvasResourceManager.h
index 96fc90bd03..9060cdb3d1 100644
--- a/libs/flake/KoCanvasResourceManager.h
+++ b/libs/flake/KoCanvasResourceManager.h
@@ -1,271 +1,288 @@
 /*
    Copyright (c) 2006, 2011 Boudewijn Rempt (boud@valdyas.org)
    Copyright (C) 2007, 2009, 2010 Thomas Zander <zander@kde.org>
    Copyright (c) 2008 Carlos Licea <carlos.licea@kdemail.net>
 
    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 KO_CANVASRESOURCEMANAGER_H
 #define KO_CANVASRESOURCEMANAGER_H
 
 #include <QObject>
 
 #include "kritaflake_export.h"
 #include "KoDerivedResourceConverter.h"
+#include "KoResourceUpdateMediator.h"
 
 class KoShape;
 class KoShapeStroke;
 class KoColor;
 class KoUnit;
 
 class QVariant;
 class QSizeF;
 
 /**
  * The KoCanvasResourceManager contains a set of per-canvas
  * properties, like current foreground color, current background
  * color and more. All tools belonging to the current canvas are
  * notified when a Resource changes (is set).
  *
  * The manager can contain all sorts of variable types and there are accessors
  * for the most common ones.  All variables are always stored inside a QVariant
  * instance internally and you can always just use the resource() method to get
  * that directly.
  * The way to store arbitairy data objects that are stored as pointers you can use
  * the following code snippets;
  * @code
  *  QVariant variant;
  *  variant.setValue<void*>(textShapeData->document());
  *  resourceManager->setResource(KoText::CurrentTextDocument, variant);
  *  // and get it out again.
  *  QVariant var = resourceManager->resource(KoText::CurrentTextDocument);
  *  document = static_cast<QTextDocument*>(var.value<void*>());
  * @endcode
  */
 class KRITAFLAKE_EXPORT KoCanvasResourceManager : public QObject
 {
     Q_OBJECT
 
 public:
 
     /**
      * This enum holds identifiers to the resources that can be stored in here.
      */
     enum CanvasResource {
         ForegroundColor,    ///< The active forground color selected for this canvas.
         BackgroundColor,    ///< The active background color selected for this canvas.
         ActiveStroke,       ///< The active stroke selected for this canvas
         PageSize,           ///< The size of the (current) page in postscript points.
         Unit,               ///< The unit of this canvas
         CurrentPage,        ///< The current page number
         ActiveStyleType,    ///< the actual active style type see KoFlake::StyleType for valid values
         ActiveRange,        ///< The area where the rulers should show white
         ShowTextShapeOutlines,     ///< Paint of text shape outlines ?
         ShowFormattingCharacters,  ///< Paint of formatting characters ?
         ShowTableBorders,  ///< Paint of table borders (when not really there) ?
         ShowSectionBounds, ///< Paint of sections bounds ?
         ShowInlineObjectVisualization, ///< paint a different  background for inline objects
         ApplicationSpeciality, ///< Special features and limitations of the application
         KarbonStart = 1000,      ///< Base number for Karbon specific values.
         KexiStart = 2000,        ///< Base number for Kexi specific values.
         FlowStart = 3000,        ///< Base number for Flow specific values.
         PlanStart = 4000,        ///< Base number for Plan specific values.
         StageStart = 5000,       ///< Base number for Stage specific values.
         KritaStart = 6000,       ///< Base number for Krita specific values.
         SheetsStart = 7000,      ///< Base number for Sheets specific values.
         WordsStart = 8000,       ///< Base number for Words specific values.
         KoPageAppStart = 9000    ///< Base number for KoPageApp specific values.
     };
 
     enum ApplicationSpecial {
         NoSpecial = 0,
         NoAdvancedText = 1
     };
 
     /**
      * Constructor.
      * @param parent the parent QObject, used for memory management.
      */
     explicit KoCanvasResourceManager(QObject *parent = 0);
     virtual ~KoCanvasResourceManager();
 
 public Q_SLOTS:
     /**
      * Set a resource of any type.
      * @param key the integer key
      * @param value the new value for the key.
      * @see KoCanvasResourceManager::CanvasResource
      */
     void setResource(int key, const QVariant &value);
 
     /**
      * Set a resource of type KoColor.
      * @param key the integer key
      * @param color the new value for the key.
      * @see KoCanvasResourceManager::CanvasResource
      */
     void setResource(int key, const KoColor &color);
 
     /**
      * Set a resource of type KoShape*.
      * @param key the integer key
      * @param id the new value for the key.
      * @see KoCanvasResourceManager::CanvasResource
      */
     void setResource(int key, KoShape *shape);
 
     /**
      * Set a resource of type KoUnit
      * @param key the integer key
      * @param id the new value for the key.
      * @see KoCanvasResourceManager::CanvasResource
      */
     void setResource(int key, const KoUnit &unit);
 
 public:
     /**
      * Returns a qvariant containing the specified resource or a standard one if the
      * specified resource does not exist.
      * @param key the key
      * @see KoCanvasResourceManager::CanvasResource
      */
     QVariant resource(int key) const;
 
     /**
      * Set the foregroundColor resource.
      * @param color the new foreground color
      */
     void setForegroundColor(const KoColor &color);
 
     /**
      * Return the foregroundColor
      */
     KoColor foregroundColor() const;
 
     /**
      * Set the backgroundColor resource.
      * @param color the new background color
      */
     void setBackgroundColor(const KoColor &color);
     /**
      * Return the backgroundColor
      */
     KoColor backgroundColor() const;
 
     /// Sets the stroke resource
     void setActiveStroke(const KoShapeStroke &stroke);
 
     /// Returns the stroke resource
     KoShapeStroke activeStroke() const;
 
     /**
      * Return the resource determined by param key as a boolean.
      * @param key the indentifying key for the resource
      * @see KoCanvasResourceManager::CanvasResource
      */
     bool boolResource(int key) const;
 
     /**
      * Return the resource determined by param key as an integer.
      * @param key the indentifying key for the resource
      * @see KoCanvasResourceManager::CanvasResource
      */
     int intResource(int key) const;
 
     /**
      * Return the resource determined by param key as a KoColor.
      * @param key the indentifying key for the resource
      * @see KoCanvasResourceManager::CanvasResource
      */
     KoColor koColorResource(int key) const;
 
     /**
      * Return the resource determined by param key as a pointer to a KoShape.
      * @param key the indentifying key for the resource
      * @see KoCanvasResourceManager::CanvasResource
      */
     KoShape *koShapeResource(int key) const;
 
     /**
      * Return the resource determined by param key as a QString .
      * @param key the indentifying key for the resource
      * @see KoCanvasResourceManager::CanvasResource
      */
     QString stringResource(int key) const;
 
     /**
      * Return the resource determined by param key as a QSizeF.
      * @param key the indentifying key for the resource
      * @see KoCanvasResourceManager::CanvasResource
      */
     QSizeF sizeResource(int key) const;
 
     /**
      * Return the resource determined by param key as a KoUnit.
      * @param key the indentifying key for the resource
      * @see KoCanvasResourceManager::CanvasResource
      */
     KoUnit unitResource(int key) const;
 
     /**
      * Returns true if there is a resource set with the requested key.
      * @param key the indentifying key for the resource
      * @see KoCanvasResourceManager::CanvasResource
      */
     bool hasResource(int key) const;
 
     /**
      * Remove the resource with @p key from the provider.
      * @param key the key that will be used to remove the resource
      * There will be a signal emitted with a variable that will return true on QVariable::isNull();
      * @see KoCanvasResourceManager::CanvasResource
      */
     void clearResource(int key);
 
     /**
      * @see KoReosurceManager::addDerivedResourceConverter()
      */
     void addDerivedResourceConverter(KoDerivedResourceConverterSP converter);
 
     /**
      * @see KoReosurceManager::hasDerivedResourceConverter()
      */
     bool hasDerivedResourceConverter(int key);
 
     /**
      * @see KoReosurceManager::removeDerivedResourceConverter()
      */
     void removeDerivedResourceConverter(int key);
 
+    /**
+     * @see KoReosurceManager::addResourceUpdateMediator
+     */
+    void addResourceUpdateMediator(KoResourceUpdateMediatorSP mediator);
+
+    /**
+     * @see KoReosurceManager::hasResourceUpdateMediator
+     */
+    bool hasResourceUpdateMediator(int key);
+
+    /**
+
+     * @see KoReosurceManager::removeResourceUpdateMediator
+     */
+    void removeResourceUpdateMediator(int key);
+
 Q_SIGNALS:
     /**
      * This signal is emitted every time a resource is set that is either
      * new or different from the previous set value.
      * @param key the indentifying key for the resource
      * @param value the variants new value.
      * @see KoCanvasResourceManager::CanvasResource
      */
     void canvasResourceChanged(int key, const QVariant &value);
 
 private:
     KoCanvasResourceManager(const KoCanvasResourceManager&);
     KoCanvasResourceManager& operator=(const KoCanvasResourceManager&);
 
     class Private;
     Private *const d;
 };
 
 #endif
diff --git a/libs/flake/KoDerivedResourceConverter.cpp b/libs/flake/KoDerivedResourceConverter.cpp
index 1ae9f1c111..93b59c88d0 100644
--- a/libs/flake/KoDerivedResourceConverter.cpp
+++ b/libs/flake/KoDerivedResourceConverter.cpp
@@ -1,52 +1,93 @@
 /*
  *  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 "KoDerivedResourceConverter.h"
 
 #include "QVariant"
-
+#include "kis_assert.h"
 
 struct KoDerivedResourceConverter::Private
 {
     Private(int _key, int _sourceKey)
         : key(_key), sourceKey(_sourceKey) {}
 
     int key;
     int sourceKey;
+
+    QVariant lastKnownValue;
 };
 
 
 KoDerivedResourceConverter::KoDerivedResourceConverter(int key, int sourceKey)
     : m_d(new Private(key, sourceKey))
 {
 }
 
 KoDerivedResourceConverter::~KoDerivedResourceConverter()
 {
 }
 
 int KoDerivedResourceConverter::key() const
 {
     return m_d->key;
 }
 
 int KoDerivedResourceConverter::sourceKey() const
 {
     return m_d->sourceKey;
 }
 
+bool KoDerivedResourceConverter::notifySourceChanged(const QVariant &sourceValue)
+{
+    const QVariant newValue = fromSource(sourceValue);
+
+    const bool valueChanged = m_d->lastKnownValue != newValue;
+    m_d->lastKnownValue = newValue;
+
+    return valueChanged;
+}
+
+QVariant KoDerivedResourceConverter::readFromSource(const QVariant &sourceValue)
+{
+    const QVariant result = fromSource(sourceValue);
+
+    KIS_SAFE_ASSERT_RECOVER_NOOP(m_d->lastKnownValue.isNull() ||
+                                 result == m_d->lastKnownValue);
+
+    m_d->lastKnownValue = result;
+
+    return m_d->lastKnownValue;
+}
+
+QVariant KoDerivedResourceConverter::writeToSource(const QVariant &value,
+                                                   const QVariant &sourceValue,
+                                                   bool *changed)
+{
+    if (changed) {
+        *changed = m_d->lastKnownValue != value;
+    }
+
+    QVariant newSourceValue = sourceValue;
+
+    if (*changed || value != fromSource(sourceValue)) {
+        m_d->lastKnownValue = value;
+        newSourceValue = toSource(value, sourceValue);
+    }
+
+    return newSourceValue;
+}
diff --git a/libs/flake/KoDerivedResourceConverter.h b/libs/flake/KoDerivedResourceConverter.h
index ffffbc212d..8cf03b9f34 100644
--- a/libs/flake/KoDerivedResourceConverter.h
+++ b/libs/flake/KoDerivedResourceConverter.h
@@ -1,71 +1,79 @@
 /*
  *  Copyright (c) 2016 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KO_DERIVED_RESOURCE_CONVERTER_H
 #define __KO_DERIVED_RESOURCE_CONVERTER_H
 
 #include <QScopedPointer>
 #include <QSharedPointer>
 #include "kritaflake_export.h"
 
 class QVariant;
 
 /**
  * \class KoDerivedResourceConverter
  *
  * Defines the abstraction of a derived resource. It should be
  * uploaded to the KoResourceManager during loading phase. The manager
  * will use it to convert values to/from the source resource.
  */
 
 class KRITAFLAKE_EXPORT KoDerivedResourceConverter
 {
 public:
     /**
      * \param key the unique id of the resource defined by this
      *            converter
      *
      * \param sourceKey the id of the parent resource, i.e. where the
      *                  values are really loaded/saved.
      */
     KoDerivedResourceConverter(int key, int sourceKey);
     virtual ~KoDerivedResourceConverter();
 
     int key() const;
     int sourceKey() const;
 
+    QVariant readFromSource(const QVariant &value);
+    QVariant writeToSource(const QVariant &value,
+                           const QVariant &sourceValue,
+                           bool *changed);
+
+    virtual bool notifySourceChanged(const QVariant &sourceValue);
+
+protected:
     /**
      * Converts the \p value of the source resource into the space of
      * the "derived" resource. E.g. preset -> opacity.
      */
     virtual QVariant fromSource(const QVariant &value) = 0;
 
     /**
      * Converts the value of the "derived" resource into the space of the
      * original ("source") resource. E.g. opacity -> preset.
      */
     virtual QVariant toSource(const QVariant &value, const QVariant &sourceValue) = 0;
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 typedef QSharedPointer<KoDerivedResourceConverter> KoDerivedResourceConverterSP;
 
 #endif /* __KO_DERIVED_RESOURCE_CONVERTER_H */
diff --git a/libs/flake/KoResourceManager_p.cpp b/libs/flake/KoResourceManager_p.cpp
index ad8b11d50f..eeca376054 100644
--- a/libs/flake/KoResourceManager_p.cpp
+++ b/libs/flake/KoResourceManager_p.cpp
@@ -1,196 +1,239 @@
 /*
    Copyright (c) 2006, 2011 Boudewijn Rempt (boud@valdyas.org)
    Copyright (C) 2007, 2010 Thomas Zander <zander@kde.org>
    Copyright (c) 2008 Carlos Licea <carlos.licea@kdemail.net>
    Copyright (c) 2011 Jan Hambrecht <jaham@gmx.net>
 
    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 "KoResourceManager_p.h"
 
 #include <QVariant>
 #include <FlakeDebug.h>
 
 #include "KoShape.h"
+#include "kis_assert.h"
+#include "kis_debug.h"
 
-void KoResourceManager::setResource(int key, const QVariant &value)
+void KoResourceManager::slotResourceInternalsChanged(int key)
 {
-    QVariant realValue = value;
-    int realKey = key;
-    QVariant currentValue = m_resources.value(key, QVariant());
+    KIS_SAFE_ASSERT_RECOVER_RETURN(m_resources.contains(key));
+    notifyDerivedResourcesChanged(key, m_resources[key]);
+}
 
+void KoResourceManager::setResource(int key, const QVariant &value)
+{
     KoDerivedResourceConverterSP converter =
         m_derivedResources.value(key, KoDerivedResourceConverterSP());
 
     if (converter) {
-        realKey = converter->sourceKey();
-        currentValue = m_resources.value(realKey, QVariant());
-        realValue = converter->toSource(value, currentValue);
-    }
+        const int sourceKey = converter->sourceKey();
+        const QVariant oldSourceValue = m_resources.value(sourceKey, QVariant());
+
+        bool valueChanged = false;
+        const QVariant newSourceValue = converter->writeToSource(value, oldSourceValue, &valueChanged);
+
+        if (valueChanged) {
+            notifyResourceChanged(key, value);
+        }
+
+        if (oldSourceValue != newSourceValue) {
+            m_resources[sourceKey] = newSourceValue;
+            notifyResourceChanged(sourceKey, newSourceValue);
+        }
 
-    if (m_resources.contains(realKey)) {
-        if (!converter && currentValue == realValue)
-            return;
-        m_resources[realKey] = realValue;
     } else {
-        m_resources.insert(realKey, realValue);
-    }
+        const QVariant oldValue = m_resources.value(key, QVariant());
+        m_resources[key] = value;
 
-    notifyResourceChanged(key, value);
+        if (m_updateMediators.contains(key)) {
+            m_updateMediators[key]->connectResource(value);
+        }
+
+        if (oldValue != value) {
+            notifyResourceChanged(key, value);
+        }
+    }
 }
 
 void KoResourceManager::notifyResourceChanged(int key, const QVariant &value)
 {
     emit resourceChanged(key, value);
+    notifyDerivedResourcesChanged(key, value);
+}
 
+void KoResourceManager::notifyDerivedResourcesChanged(int key, const QVariant &value)
+{
     QMultiHash<int, KoDerivedResourceConverterSP>::const_iterator it = m_derivedFromSource.constFind(key);
     QMultiHash<int, KoDerivedResourceConverterSP>::const_iterator end = m_derivedFromSource.constEnd();
 
     while (it != end && it.key() == key) {
         KoDerivedResourceConverterSP converter = it.value();
-        notifyResourceChanged(converter->key(), converter->fromSource(value));
+
+        if (converter->notifySourceChanged(value)) {
+            notifyResourceChanged(converter->key(), converter->readFromSource(value));
+        }
+
         it++;
     }
 }
 
 QVariant KoResourceManager::resource(int key) const
 {
     KoDerivedResourceConverterSP converter =
         m_derivedResources.value(key, KoDerivedResourceConverterSP());
 
     const int realKey = converter ? converter->sourceKey() : key;
     QVariant value = m_resources.value(realKey, QVariant());
 
-    return converter ? converter->fromSource(value) : value;
+    return converter ? converter->readFromSource(value) : value;
 }
 
 void KoResourceManager::setResource(int key, const KoColor &color)
 {
     QVariant v;
     v.setValue(color);
     setResource(key, v);
 }
 
 void KoResourceManager::setResource(int key, KoShape *shape)
 {
     QVariant v;
     v.setValue(shape);
     setResource(key, v);
 }
 
 void KoResourceManager::setResource(int key, const KoUnit &unit)
 {
     QVariant v;
     v.setValue(unit);
     setResource(key, v);
 }
 
 KoColor KoResourceManager::koColorResource(int key) const
 {
     if (! m_resources.contains(key)) {
         KoColor empty;
         return empty;
     }
     return resource(key).value<KoColor>();
 }
 
 KoShape *KoResourceManager::koShapeResource(int key) const
 {
     if (! m_resources.contains(key))
         return 0;
 
     return resource(key).value<KoShape *>();
 }
 
 
 KoUnit KoResourceManager::unitResource(int key) const
 {
     return resource(key).value<KoUnit>();
 }
 
 bool KoResourceManager::boolResource(int key) const
 {
     if (! m_resources.contains(key))
         return false;
     return m_resources[key].toBool();
 }
 
 int KoResourceManager::intResource(int key) const
 {
     if (! m_resources.contains(key))
         return 0;
     return m_resources[key].toInt();
 }
 
 QString KoResourceManager::stringResource(int key) const
 {
     if (! m_resources.contains(key)) {
         QString empty;
         return empty;
     }
     return qvariant_cast<QString>(resource(key));
 }
 
 QSizeF KoResourceManager::sizeResource(int key) const
 {
     if (! m_resources.contains(key)) {
         QSizeF empty;
         return empty;
     }
     return qvariant_cast<QSizeF>(resource(key));
 }
 
 bool KoResourceManager::hasResource(int key) const
 {
     KoDerivedResourceConverterSP converter =
         m_derivedResources.value(key, KoDerivedResourceConverterSP());
 
     const int realKey = converter ? converter->sourceKey() : key;
     return m_resources.contains(realKey);
 }
 
 void KoResourceManager::clearResource(int key)
 {
     // we cannot remove a derived resource
     if (m_derivedResources.contains(key)) return;
 
     if (m_resources.contains(key)) {
         m_resources.remove(key);
         notifyResourceChanged(key, QVariant());
     }
 }
 
 void KoResourceManager::addDerivedResourceConverter(KoDerivedResourceConverterSP converter)
 {
-    Q_ASSERT(!m_derivedResources.contains(converter->key()));
+    KIS_SAFE_ASSERT_RECOVER_NOOP(!m_derivedResources.contains(converter->key()));
 
     m_derivedResources.insert(converter->key(), converter);
     m_derivedFromSource.insertMulti(converter->sourceKey(), converter);
 }
 
 bool KoResourceManager::hasDerivedResourceConverter(int key)
 {
     return m_derivedResources.contains(key);
 }
 
 void KoResourceManager::removeDerivedResourceConverter(int key)
 {
     Q_ASSERT(m_derivedResources.contains(key));
 
     KoDerivedResourceConverterSP converter = m_derivedResources.value(key);
     m_derivedResources.remove(key);
     m_derivedFromSource.remove(converter->sourceKey(), converter);
 }
+
+void KoResourceManager::addResourceUpdateMediator(KoResourceUpdateMediatorSP mediator)
+{
+    KIS_SAFE_ASSERT_RECOVER_NOOP(!m_updateMediators.contains(mediator->key()));
+    m_updateMediators.insert(mediator->key(), mediator);
+    connect(mediator.data(), SIGNAL(sigResourceChanged(int)), SLOT(slotResourceInternalsChanged(int)));
+}
+
+bool KoResourceManager::hasResourceUpdateMediator(int key)
+{
+    return m_updateMediators.contains(key);
+}
+
+void KoResourceManager::removeResourceUpdateMediator(int key)
+{
+    KIS_SAFE_ASSERT_RECOVER_RETURN(m_updateMediators.contains(key));
+    m_updateMediators.remove(key);
+}
diff --git a/libs/flake/KoResourceManager_p.h b/libs/flake/KoResourceManager_p.h
index d58fc52b9d..98afb0d582 100644
--- a/libs/flake/KoResourceManager_p.h
+++ b/libs/flake/KoResourceManager_p.h
@@ -1,192 +1,220 @@
 /*
    Copyright (c) 2006, 2011 Boudewijn Rempt (boud@valdyas.org)
    Copyright (C) 2007, 2009, 2010 Thomas Zander <zander@kde.org>
    Copyright (c) 2008 Carlos Licea <carlos.licea@kdemail.net>
 
    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 KO_RESOURCEMANAGER_P_H
 #define KO_RESOURCEMANAGER_P_H
 
 #include <QObject>
 #include <QSizeF>
 #include <QHash>
 
 #include "kritaflake_export.h"
 #include <KoColor.h>
 #include <KoUnit.h>
 #include "KoDerivedResourceConverter.h"
+#include "KoResourceUpdateMediator.h"
+
 
 class KoShape;
 class QVariant;
 
 class KRITAFLAKE_EXPORT KoResourceManager : public QObject
 {
     Q_OBJECT
 public:
 
     KoResourceManager() {}
 
     /**
      * Set a resource of any type.
      * @param key the integer key
      * @param value the new value for the key.
      * @see KoCanvasResourceManager::CanvasResource KoDocumentResourceManager::DocumentResource
      */
     void setResource(int key, const QVariant &value);
 
     /**
      * Set a resource of type KoColor.
      * @param key the integer key
      * @param color the new value for the key.
      * @see KoCanvasResourceManager::CanvasResource KoDocumentResourceManager::DocumentResource
      */
     void setResource(int key, const KoColor &color);
 
     /**
      * Set a resource of type KoShape*.
      * @param key the integer key
      * @param id the new value for the key.
      * @see KoCanvasResourceManager::CanvasResource KoDocumentResourceManager::DocumentResource
      */
     void setResource(int key, KoShape *shape);
 
     /**
      * Set a resource of type KoUnit
      * @param key the integer key
      * @param id the new value for the key.
      * @see KoCanvasResourceManager::CanvasResource KoDocumentResourceManager::DocumentResource
      */
     void setResource(int key, const KoUnit &unit);
 
     /**
      * Returns a qvariant containing the specified resource or a standard one if the
      * specified resource does not exist.
      * @param key the key
      * @see KoCanvasResourceManager::CanvasResource KoDocumentResourceManager::DocumentResource
      */
     QVariant resource(int key) const;
 
     /**
      * Return the resource determined by param key as a boolean.
      * @param key the indentifying key for the resource
      * @see KoCanvasResourceManager::CanvasResource KoDocumentResourceManager::DocumentResource
      */
     bool boolResource(int key) const;
 
     /**
      * Return the resource determined by param key as an integer.
      * @param key the indentifying key for the resource
      * @see KoCanvasResourceManager::CanvasResource KoDocumentResourceManager::DocumentResource
      */
     int intResource(int key) const;
 
     /**
      * Return the resource determined by param key as a KoColor.
      * @param key the indentifying key for the resource
      * @see KoCanvasResourceManager::CanvasResource KoDocumentResourceManager::DocumentResource
      */
     KoColor koColorResource(int key) const;
 
     /**
      * Return the resource determined by param key as a pointer to a KoShape.
      * @param key the indentifying key for the resource
      * @see KoCanvasResourceManager::CanvasResource KoDocumentResourceManager::DocumentResource
      */
     KoShape *koShapeResource(int key) const;
 
     /**
      * Return the resource determined by param key as a QString .
      * @param key the indentifying key for the resource
      * @see KoCanvasResourceManager::CanvasResource KoDocumentResourceManager::DocumentResource
      */
     QString stringResource(int key) const;
 
     /**
      * Return the resource determined by param key as a QSizeF.
      * @param key the indentifying key for the resource
      * @see KoCanvasResourceManager::CanvasResource KoDocumentResourceManager::DocumentResource
      */
     QSizeF sizeResource(int key) const;
 
     /**
      * Return the resource determined by param key as a KoUnit.
      * @param key the indentifying key for the resource
      * @see KoCanvasResourceManager::CanvasResource KoDocumentResourceManager::DocumentResource
      */
     KoUnit unitResource(int key) const;
 
     /**
      * Returns true if there is a resource set with the requested key.
      * @param key the indentifying key for the resource
      * @see KoCanvasResourceManager::CanvasResource KoDocumentResourceManager::DocumentResource
      */
     bool hasResource(int key) const;
 
     /**
      * Remove the resource with @p key from the provider.
      * @param key the key that will be used to remove the resource
      * @see KoCanvasResourceManager::CanvasResource KoDocumentResourceManager::DocumentResource
      */
     void clearResource(int key);
 
     /**
-     * Some of the resources may be "derive" from the other. For
+     * Some of the resources may be "derived" from the others. For
      * example opacity, composite op and erase mode properties are
      * contained inside a paintop preset, so we need not create a
      * separate resource for them. Instead we created a derived resource,
      * that loads/saves values from/to another resource, but has its own
      * "resource changed" signal (via a different key).
      *
      * When a parent resource changes, the resource manager emits
-     * update signals for all its derived resources. 
+     * update signals for all its derived resources.
      */
     void addDerivedResourceConverter(KoDerivedResourceConverterSP converter);
 
     /**
      * @return true if the resource with \p key is a derived resource
      *         (has a converter installed)
      *
      * @see addDerivedResourceConverter()
      */
     bool hasDerivedResourceConverter(int key);
 
     /**
      * Removes a derived resource converter. If you rty to add a
      * resource with \p key it will be treated as a usual resource.
      *
      * @see addDerivedResourceConverter()
      */
     void removeDerivedResourceConverter(int key);
 
+    /**
+     * Some resources can "mutate", that is they value doesn't change
+     * (a pointer), whereas the contents changes. But we should still
+     * notify all the derived resources subscribers that the resource
+     * has changed. For that purpose we use a special mediator class
+     * that connects the resource (which is not a QObject at all) and
+     * the resource manager controls that connection.
+     */
+    void addResourceUpdateMediator(KoResourceUpdateMediatorSP mediator);
+
+    /**
+     * \see addResourceUpdateMediator()
+     */
+    bool hasResourceUpdateMediator(int key);
+
+    /**
+     * \see addResourceUpdateMediator()
+     */
+    void removeResourceUpdateMediator(int key);
+
 Q_SIGNALS:
     void resourceChanged(int key, const QVariant &value);
 
 private:
     void notifyResourceChanged(int key, const QVariant &value);
+    void notifyDerivedResourcesChanged(int key, const QVariant &value);
+
+private Q_SLOTS:
+    void slotResourceInternalsChanged(int key);
 
 private:
     KoResourceManager(const KoResourceManager&);
     KoResourceManager& operator=(const KoResourceManager&);
 
     QHash<int, QVariant> m_resources;
 
     QHash<int, KoDerivedResourceConverterSP> m_derivedResources;
     QMultiHash<int, KoDerivedResourceConverterSP> m_derivedFromSource;
+
+    QHash<int, KoResourceUpdateMediatorSP> m_updateMediators;
 };
 
 #endif
 
diff --git a/libs/flake/KoDerivedResourceConverter.cpp b/libs/flake/KoResourceUpdateMediator.cpp
similarity index 62%
copy from libs/flake/KoDerivedResourceConverter.cpp
copy to libs/flake/KoResourceUpdateMediator.cpp
index 1ae9f1c111..1a641be458 100644
--- a/libs/flake/KoDerivedResourceConverter.cpp
+++ b/libs/flake/KoResourceUpdateMediator.cpp
@@ -1,52 +1,41 @@
 /*
  *  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 "KoDerivedResourceConverter.h"
+#include "KoResourceUpdateMediator.h"
 
-#include "QVariant"
 
-
-struct KoDerivedResourceConverter::Private
+struct KoResourceUpdateMediator::Private
 {
-    Private(int _key, int _sourceKey)
-        : key(_key), sourceKey(_sourceKey) {}
-
+    Private(int _key) : key(_key) {}
     int key;
-    int sourceKey;
 };
 
 
-KoDerivedResourceConverter::KoDerivedResourceConverter(int key, int sourceKey)
-    : m_d(new Private(key, sourceKey))
+KoResourceUpdateMediator::KoResourceUpdateMediator(int key)
+    : m_d(new Private(key))
 {
 }
 
-KoDerivedResourceConverter::~KoDerivedResourceConverter()
+KoResourceUpdateMediator::~KoResourceUpdateMediator()
 {
 }
 
-int KoDerivedResourceConverter::key() const
+int KoResourceUpdateMediator::key() const
 {
     return m_d->key;
 }
-
-int KoDerivedResourceConverter::sourceKey() const
-{
-    return m_d->sourceKey;
-}
-
diff --git a/libs/flake/KoResourceUpdateMediator.h b/libs/flake/KoResourceUpdateMediator.h
new file mode 100644
index 0000000000..602df7443d
--- /dev/null
+++ b/libs/flake/KoResourceUpdateMediator.h
@@ -0,0 +1,57 @@
+/*
+ *  Copyright (c) 2016 Dmitry Kazakov <dimula73@gmail.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __KO_RESOURCE_UPDATE_MEDIATOR_H
+#define __KO_RESOURCE_UPDATE_MEDIATOR_H
+
+#include <QScopedPointer>
+#include <QSharedPointer>
+#include "kritaflake_export.h"
+
+/**
+ * A special mediator class that connects the resource and the
+ * resource manager.  The resource manager connects to a
+ * sigResourceChanged() changed and when a resource changes, the
+ * manager calls connectResource() for this resource. After that, the
+ * mediator should notify the manager about every change that happens
+ * to the resource by emitting the corresponding signal.
+ *
+ * There is only one mediator for one type (key) of the resource.
+ */
+
+class KRITAFLAKE_EXPORT KoResourceUpdateMediator : public QObject
+{
+    Q_OBJECT
+public:
+    KoResourceUpdateMediator(int key);
+    virtual ~KoResourceUpdateMediator();
+
+    int key() const;
+    virtual void connectResource(QVariant sourceResource) = 0;
+
+Q_SIGNALS:
+    void sigResourceChanged(int key);
+
+private:
+    struct Private;
+    const QScopedPointer<Private> m_d;
+};
+
+typedef QSharedPointer<KoResourceUpdateMediator> KoResourceUpdateMediatorSP;
+
+#endif /* __KO_RESOURCE_UPDATE_MEDIATOR_H */
diff --git a/libs/flake/tests/TestResourceManager.cpp b/libs/flake/tests/TestResourceManager.cpp
index 9f9d2b5bf5..bd31773b43 100644
--- a/libs/flake/tests/TestResourceManager.cpp
+++ b/libs/flake/tests/TestResourceManager.cpp
@@ -1,144 +1,389 @@
 /* This file is part of the KDE project
    Copyright (C) 2008 Thorsten Zachmann <zachmann@kde.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 "TestResourceManager.h"
 
 #include "KoCanvasResourceManager.h"
 #include "KoResourceManager_p.h"
 #include "KoPathShape.h"
 #include "KoUnit.h"
 #include <QSignalSpy>
 #include <QTest>
 
+#include "kis_debug.h"
+
 void TestResourceManager::koShapeResource()
 {
     KoPathShape * shape = new KoPathShape();
     int key = 9001;
 
     KoCanvasResourceManager rp( 0 );
     rp.setResource( key, shape );
     QVERIFY( shape == rp.koShapeResource( key ) );
 }
 
 void TestResourceManager::testUnitChanged()
 {
     KoCanvasResourceManager rm(0);
     QSignalSpy spy(&rm, SIGNAL(canvasResourceChanged(int, const QVariant &)));
 
     KoUnit a;
     rm.setResource(KoCanvasResourceManager::Unit, a);
     QCOMPARE(spy.count(), 1);
 
     KoUnit b(KoUnit::Millimeter);
     rm.setResource(KoCanvasResourceManager::Unit, b);
     QCOMPARE(spy.count(), 2);
 }
 
 #include "kis_global.h"
 
 struct DerivedResource : public KoDerivedResourceConverter
 {
     DerivedResource(int key, int sourceKey) : KoDerivedResourceConverter(key, sourceKey) {}
 
     QVariant fromSource(const QVariant &value) {
         return value.toInt() + 10;
     }
 
     QVariant toSource(const QVariant &value, const QVariant &sourceValue) {
         Q_UNUSED(sourceValue);
         return value.toInt() - 10;
     }
 };
 
 void TestResourceManager::testConverters()
 {
     KoResourceManager m;
 
     const int key1 = 1;
     const int key2 = 2;
     const int derivedKey = 3;
 
     m.setResource(key1, 1);
     m.setResource(key2, 2);
 
     QCOMPARE(m.resource(key1).toInt(), 1);
     QCOMPARE(m.resource(key2).toInt(), 2);
     QVERIFY(!m.hasResource(derivedKey));
 
     m.addDerivedResourceConverter(toQShared(new DerivedResource(derivedKey, key2)));
 
     QCOMPARE(m.resource(derivedKey).toInt(), 12);
     QVERIFY(m.hasResource(derivedKey));
 
     m.setResource(derivedKey, 15);
 
     QCOMPARE(m.resource(key2).toInt(), 5);
     QCOMPARE(m.resource(derivedKey).toInt(), 15);
 
     QVERIFY(m.hasResource(derivedKey));
     m.clearResource(derivedKey);
     QVERIFY(m.hasResource(derivedKey));
     m.clearResource(key2);
     QVERIFY(!m.hasResource(derivedKey));
 }
 
 void TestResourceManager::testDerivedChanged()
 {
     // const int key1 = 1;
     const int key2 = 2;
     const int derivedKey = 3;
     const int otherDerivedKey = 4;
 
     KoCanvasResourceManager m(0);
     m.addDerivedResourceConverter(toQShared(new DerivedResource(derivedKey, key2)));
     m.addDerivedResourceConverter(toQShared(new DerivedResource(otherDerivedKey, key2)));
 
     m.setResource(derivedKey, 15);
 
     QCOMPARE(m.resource(key2).toInt(), 5);
     QCOMPARE(m.resource(derivedKey).toInt(), 15);
 
     QSignalSpy spy(&m, SIGNAL(canvasResourceChanged(int, const QVariant &)));
 
     m.setResource(derivedKey, 16);
 
-    QCOMPARE(spy.count(), 1);
+    QCOMPARE(spy.count(), 3);
     QList<QVariant> args;
 
     args = spy[0];
     QCOMPARE(args[0].toInt(), derivedKey);
     QCOMPARE(args[1].toInt(), 16);
 
+    args = spy[1];
+    QCOMPARE(args[0].toInt(), key2);
+    QCOMPARE(args[1].toInt(), 6);
+
+    args = spy[2];
+    QCOMPARE(args[0].toInt(), otherDerivedKey);
+    QCOMPARE(args[1].toInt(), 16);
+
+    spy.clear();
+
     m.setResource(key2, 7);
-    QCOMPARE(spy.count(), 4);
+    QCOMPARE(spy.count(), 3);
 
-    args = spy[1];
+    args = spy[0];
     QCOMPARE(args[0].toInt(), key2);
     QCOMPARE(args[1].toInt(), 7);
 
-    args = spy[2];
+    args = spy[1];
     QCOMPARE(args[0].toInt(), otherDerivedKey);
     QCOMPARE(args[1].toInt(), 17);
 
-    args = spy[3];
+    args = spy[2];
     QCOMPARE(args[0].toInt(), derivedKey);
     QCOMPARE(args[1].toInt(), 17);
 }
 
+struct ComplexResource {
+    QHash<int, QVariant> m_resources;
+};
+
+typedef QSharedPointer<ComplexResource> ComplexResourceSP;
+Q_DECLARE_METATYPE(ComplexResourceSP);
+
+struct ComplexConverter : public KoDerivedResourceConverter
+{
+    ComplexConverter(int key, int sourceKey) : KoDerivedResourceConverter(key, sourceKey) {}
+
+    QVariant fromSource(const QVariant &value) {
+        KIS_ASSERT(value.canConvert<ComplexResourceSP>());
+        ComplexResourceSP res = value.value<ComplexResourceSP>();
+
+        return res->m_resources[key()];
+    }
+
+    QVariant toSource(const QVariant &value, const QVariant &sourceValue) {
+        KIS_ASSERT(sourceValue.canConvert<ComplexResourceSP>());
+        ComplexResourceSP res = sourceValue.value<ComplexResourceSP>();
+
+        res->m_resources[key()] = value;
+        return QVariant::fromValue(res);
+    }
+};
+
+struct ComplexMediator : public KoResourceUpdateMediator
+{
+    ComplexMediator(int key) : KoResourceUpdateMediator(key) {}
+
+    void connectResource(QVariant sourceResource) {
+        m_res = sourceResource;
+    }
+
+    void forceNotify() {
+        emit sigResourceChanged(key());
+    }
+
+    QVariant m_res;
+};
+typedef QSharedPointer<ComplexMediator> ComplexMediatorSP;
+
+void TestResourceManager::testComplexResource()
+{
+    const int key = 2;
+    const int complex1 = 3;
+    const int complex2 = 4;
+
+    KoCanvasResourceManager m(0);
+    m.addDerivedResourceConverter(toQShared(new ComplexConverter(complex1, key)));
+    m.addDerivedResourceConverter(toQShared(new ComplexConverter(complex2, key)));
+
+    ComplexMediatorSP mediator(new ComplexMediator(key));
+    m.addResourceUpdateMediator(mediator);
+
+    QSignalSpy spy(&m, SIGNAL(canvasResourceChanged(int, const QVariant &)));
+
+    ComplexResourceSP r1(new ComplexResource());
+    r1->m_resources[complex1] = 10;
+    r1->m_resources[complex2] = 20;
+
+    ComplexResourceSP r2(new ComplexResource());
+    r2->m_resources[complex1] = 15;
+    r2->m_resources[complex2] = 25;
+
+
+    // ####################################################
+    // Initial assignment
+    // ####################################################
+    m.setResource(key, QVariant::fromValue(r1));
+
+    QCOMPARE(mediator->m_res.value<ComplexResourceSP>(), r1);
+    QCOMPARE(m.resource(key).value<ComplexResourceSP>(), r1);
+    QCOMPARE(m.resource(complex1).toInt(), 10);
+    QCOMPARE(m.resource(complex2).toInt(), 20);
+
+    QCOMPARE(spy[0][0].toInt(), key);
+    QCOMPARE(spy[0][1].value<ComplexResourceSP>(), r1);
+    QCOMPARE(spy[1][0].toInt(), complex2);
+    QCOMPARE(spy[1][1].toInt(), 20);
+    QCOMPARE(spy[2][0].toInt(), complex1);
+    QCOMPARE(spy[2][1].toInt(), 10);
+    spy.clear();
+
+    // ####################################################
+    // Change the whole resource
+    // ####################################################
+    m.setResource(key, QVariant::fromValue(r2));
+
+    QCOMPARE(mediator->m_res.value<ComplexResourceSP>(), r2);
+    QCOMPARE(m.resource(key).value<ComplexResourceSP>(), r2);
+    QCOMPARE(m.resource(complex1).toInt(), 15);
+    QCOMPARE(m.resource(complex2).toInt(), 25);
+
+    QCOMPARE(spy[0][0].toInt(), key);
+    QCOMPARE(spy[0][1].value<ComplexResourceSP>(), r2);
+    QCOMPARE(spy[1][0].toInt(), complex2);
+    QCOMPARE(spy[1][1].toInt(), 25);
+    QCOMPARE(spy[2][0].toInt(), complex1);
+    QCOMPARE(spy[2][1].toInt(), 15);
+    spy.clear();
+
+    // ####################################################
+    // Change a derived resource
+    // ####################################################
+    m.setResource(complex1, 16);
+
+    QCOMPARE(mediator->m_res.value<ComplexResourceSP>(), r2);
+    QCOMPARE(m.resource(key).value<ComplexResourceSP>(), r2);
+    QCOMPARE(m.resource(complex1).toInt(), 16);
+    QCOMPARE(m.resource(complex2).toInt(), 25);
+
+    QCOMPARE(spy[0][0].toInt(), complex1);
+    QCOMPARE(spy[0][1].toInt(), 16);
+    spy.clear();
+
+    // ####################################################
+    // Change another derived resource
+    // ####################################################
+    m.setResource(complex2, 26);
+
+    QCOMPARE(mediator->m_res.value<ComplexResourceSP>(), r2);
+    QCOMPARE(m.resource(key).value<ComplexResourceSP>(), r2);
+    QCOMPARE(m.resource(complex1).toInt(), 16);
+    QCOMPARE(m.resource(complex2).toInt(), 26);
+
+    QCOMPARE(spy[0][0].toInt(), complex2);
+    QCOMPARE(spy[0][1].toInt(), 26);
+    spy.clear();
+
+    // ####################################################
+    // Switch back the whole source resource
+    // ####################################################
+    m.setResource(key, QVariant::fromValue(r1));
+
+    QCOMPARE(mediator->m_res.value<ComplexResourceSP>(), r1);
+    QCOMPARE(m.resource(key).value<ComplexResourceSP>(), r1);
+    QCOMPARE(m.resource(complex1).toInt(), 10);
+    QCOMPARE(m.resource(complex2).toInt(), 20);
+
+    QCOMPARE(spy[0][0].toInt(), key);
+    QCOMPARE(spy[0][1].value<ComplexResourceSP>(), r1);
+    QCOMPARE(spy[1][0].toInt(), complex2);
+    QCOMPARE(spy[1][1].toInt(), 20);
+    QCOMPARE(spy[2][0].toInt(), complex1);
+    QCOMPARE(spy[2][1].toInt(), 10);
+    spy.clear();
+
+    // ####################################################
+    // The value keep unchanged case!
+    // ####################################################
+    m.setResource(complex1, 10);
+
+    QCOMPARE(mediator->m_res.value<ComplexResourceSP>(), r1);
+    QCOMPARE(m.resource(key).value<ComplexResourceSP>(), r1);
+    QCOMPARE(m.resource(complex1).toInt(), 10);
+    QCOMPARE(m.resource(complex2).toInt(), 20);
+
+    QCOMPARE(spy.size(), 0);
+    spy.clear();
+
+    // ####################################################
+    // While switching a complex resource one derived value
+    // is kept unchanged
+    // ####################################################
+    r2->m_resources[complex1] = 10;
+    m.setResource(key, QVariant::fromValue(r2));
+
+    QCOMPARE(mediator->m_res.value<ComplexResourceSP>(), r2);
+    QCOMPARE(m.resource(key).value<ComplexResourceSP>(), r2);
+    QCOMPARE(m.resource(complex1).toInt(), 10);
+    QCOMPARE(m.resource(complex2).toInt(), 26);
+
+    QCOMPARE(spy[0][0].toInt(), key);
+    QCOMPARE(spy[0][1].value<ComplexResourceSP>(), r2);
+    QCOMPARE(spy[1][0].toInt(), complex2);
+    QCOMPARE(spy[1][1].toInt(), 26);
+    spy.clear();
+
+    // ####################################################
+    // No devived values are changed!
+    // ####################################################
+    *r1 = *r2;
+    m.setResource(key, QVariant::fromValue(r1));
+
+    QCOMPARE(mediator->m_res.value<ComplexResourceSP>(), r1);
+    QCOMPARE(m.resource(key).value<ComplexResourceSP>(), r1);
+    QCOMPARE(m.resource(complex1).toInt(), 10);
+    QCOMPARE(m.resource(complex2).toInt(), 26);
+
+    QCOMPARE(spy[0][0].toInt(), key);
+    QCOMPARE(spy[0][1].value<ComplexResourceSP>(), r1);
+    spy.clear();
+
+    // ####################################################
+    // Try to set the same pointer. No signals emitted!
+    // ####################################################
+    m.setResource(key, QVariant::fromValue(r1));
+
+    QCOMPARE(mediator->m_res.value<ComplexResourceSP>(), r1);
+    QCOMPARE(m.resource(key).value<ComplexResourceSP>(), r1);
+    QCOMPARE(m.resource(complex1).toInt(), 10);
+    QCOMPARE(m.resource(complex2).toInt(), 26);
+
+    QCOMPARE(spy.size(), 0);
+    spy.clear();
+
+
+    // ####################################################
+    // Internals 'officially' changed, but the values not
+    // ####################################################
+    mediator->forceNotify();
+
+    QCOMPARE(spy.size(), 0);
+    spy.clear();
+
+    // ####################################################
+    // We changed the values, but didn't notify anyone :)
+    // ####################################################
+    r1->m_resources[complex1] = 11;
+    r1->m_resources[complex2] = 21;
+
+    mediator->forceNotify();
+
+    QCOMPARE(spy[0][0].toInt(), complex2);
+    QCOMPARE(spy[0][1].toInt(), 21);
+    QCOMPARE(spy[1][0].toInt(), complex1);
+    QCOMPARE(spy[1][1].toInt(), 11);
+    spy.clear();
+}
+
+
 QTEST_MAIN(TestResourceManager)
diff --git a/libs/flake/tests/TestResourceManager.h b/libs/flake/tests/TestResourceManager.h
index a0ef6826ae..947361db43 100644
--- a/libs/flake/tests/TestResourceManager.h
+++ b/libs/flake/tests/TestResourceManager.h
@@ -1,35 +1,36 @@
 /* This file is part of the KDE project
    Copyright (C) 2008 Thorsten Zachmann <zachmann@kde.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 TESTRESOURCEMANAGER_H
 #define TESTRESOURCEMANAGER_H
 
 #include <QObject>
 
 class TestResourceManager : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void koShapeResource();
     void testUnitChanged();
     void testConverters();
     void testDerivedChanged();
+    void testComplexResource();
 };
 
 #endif // TESTRESOURCEMANAGER_H
diff --git a/libs/global/kis_global.h b/libs/global/kis_global.h
index af079e3217..785cd338bf 100644
--- a/libs/global/kis_global.h
+++ b/libs/global/kis_global.h
@@ -1,282 +1,323 @@
 /*
  *  Copyright (c) 2000 Matthias Elter <elter@kde.org>
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.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 KISGLOBAL_H_
 #define KISGLOBAL_H_
 
 #include <limits.h>
 
 #include <KoConfig.h>
 #include "kis_assert.h"
 
 #include <QPoint>
 #include <QPointF>
 
 const quint8 quint8_MAX = UCHAR_MAX;
 const quint16 quint16_MAX = 65535;
 
 const qint32 qint32_MAX = (2147483647);
 const qint32 qint32_MIN = (-2147483647 - 1);
 
 const quint8 MAX_SELECTED = UCHAR_MAX;
 const quint8 MIN_SELECTED = 0;
 const quint8 SELECTION_THRESHOLD = 1;
 
 enum OutlineStyle {
     OUTLINE_NONE = 0,
     OUTLINE_CIRCLE,
     OUTLINE_FULL,
     OUTLINE_TILT,
     OUTLINE_COLOR,
 
     N_OUTLINE_STYLE_SIZE
 };
 
 enum CursorStyle {
     CURSOR_STYLE_NO_CURSOR = 0,
     CURSOR_STYLE_TOOLICON,
     CURSOR_STYLE_POINTER,
     CURSOR_STYLE_SMALL_ROUND,
     CURSOR_STYLE_CROSSHAIR,
     CURSOR_STYLE_TRIANGLE_RIGHTHANDED,
     CURSOR_STYLE_TRIANGLE_LEFTHANDED,
     CURSOR_STYLE_BLACK_PIXEL,
     CURSOR_STYLE_WHITE_PIXEL,
 
     N_CURSOR_STYLE_SIZE
 };
 
 enum OldCursorStyle {
     OLD_CURSOR_STYLE_TOOLICON = 0,
     OLD_CURSOR_STYLE_CROSSHAIR = 1,
     OLD_CURSOR_STYLE_POINTER = 2,
 
     OLD_CURSOR_STYLE_OUTLINE = 3,
 
     OLD_CURSOR_STYLE_NO_CURSOR = 4,
     OLD_CURSOR_STYLE_SMALL_ROUND = 5,
 
     OLD_CURSOR_STYLE_OUTLINE_CENTER_DOT = 6,
     OLD_CURSOR_STYLE_OUTLINE_CENTER_CROSS = 7,
 
     OLD_CURSOR_STYLE_TRIANGLE_RIGHTHANDED = 8,
     OLD_CURSOR_STYLE_TRIANGLE_LEFTHANDED = 9,
 
     OLD_CURSOR_STYLE_OUTLINE_TRIANGLE_RIGHTHANDED = 10,
     OLD_CURSOR_STYLE_OUTLINE_TRIANGLE_LEFTHANDED = 11
 };
 
 /*
  * Most wacom pads have 512 levels of pressure; Qt only supports 256, and even
  * this is downscaled to 127 levels because the line would be too jittery, and
  * the amount of masks take too much memory otherwise.
  */
 const qint32 PRESSURE_LEVELS = 127;
 const double PRESSURE_MIN = 0.0;
 const double PRESSURE_MAX = 1.0;
 const double PRESSURE_DEFAULT = PRESSURE_MAX;
 const double PRESSURE_THRESHOLD = 5.0 / 255.0;
 
 // copy of lcms.h
 #define INTENT_PERCEPTUAL                 0
 #define INTENT_RELATIVE_COLORIMETRIC      1
 #define INTENT_SATURATION                 2
 #define INTENT_ABSOLUTE_COLORIMETRIC      3
 
 #include <cmath>
 #include <QPointF>
 
 #ifndef M_PI
 #define M_PI 3.14159265358979323846
 #endif
 
 
 // converts \p a to [0, 2 * M_PI) range
 inline qreal normalizeAngle(qreal a) {
     if (a < 0.0) {
         a = 2 * M_PI + fmod(a, 2 * M_PI);
     }
 
     return a > 2 * M_PI ? fmod(a, 2 * M_PI) : a;
 }
 
 // converts \p a to [0, 360.0) range
 inline qreal normalizeAngleDegrees(qreal a) {
     if (a < 0.0) {
         a = 360.0 + fmod(a, 360.0);
     }
 
     return a > 360.0 ? fmod(a, 360.0) : a;
 }
 
 inline qreal shortestAngularDistance(qreal a, qreal b) {
     qreal dist = fmod(qAbs(a - b), 2 * M_PI);
     if (dist > M_PI) dist = 2 * M_PI - dist;
 
     return dist;
 }
 
 inline qreal incrementInDirection(qreal a, qreal inc, qreal direction) {
     qreal b1 = a + inc;
     qreal b2 = a - inc;
 
     qreal d1 = shortestAngularDistance(b1, direction);
     qreal d2 = shortestAngularDistance(b2, direction);
 
     return d1 < d2 ? b1 : b2;
 }
 
 template<typename PointType>
 inline PointType snapToClosestAxis(PointType P) {
     if (qAbs(P.x()) < qAbs(P.y())) {
         P.setX(0);
     } else {
         P.setY(0);
     }
     return P;
 }
 
 template<typename T>
 inline T pow2(const T& x) {
     return x * x;
 }
 
 template<typename T>
 inline T kisDegreesToRadians(T degrees) {
     return degrees * M_PI / 180.0;
 }
 
 template<typename T>
 inline T kisRadiansToDegrees(T radians) {
     return radians * 180.0 / M_PI;
 }
 
 template<class T, typename U>
 inline T kisGrowRect(const T &rect, U offset) {
     return rect.adjusted(-offset, -offset, offset, offset);
 }
 
 inline qreal kisDistance(const QPointF &pt1, const QPointF &pt2) {
     return std::sqrt(pow2(pt1.x() - pt2.x()) + pow2(pt1.y() - pt2.y()));
 }
 
 inline qreal kisSquareDistance(const QPointF &pt1, const QPointF &pt2) {
     return pow2(pt1.x() - pt2.x()) + pow2(pt1.y() - pt2.y());
 }
 
 #include <QLineF>
 
 inline qreal kisDistanceToLine(const QPointF &m, const QLineF &line)
 {
     const QPointF &p1 = line.p1();
     const QPointF &p2 = line.p2();
 
     qreal distance = 0;
 
     if (qFuzzyCompare(p1.x(), p2.x())) {
         distance = qAbs(m.x() - p2.x());
     } else if (qFuzzyCompare(p1.y(), p2.y())) {
         distance = qAbs(m.y() - p2.y());
     } else {
         qreal A = 1;
         qreal B = - (p1.x() - p2.x()) / (p1.y() - p2.y());
         qreal C = - p1.x() - B * p1.y();
 
         distance = qAbs(A * m.x() + B * m.y() + C) / std::sqrt(pow2(A) + pow2(B));
     }
 
     return distance;
 }
 
 inline QPointF kisProjectOnVector(const QPointF &base, const QPointF &v)
 {
     const qreal prod = base.x() * v.x() + base.y() * v.y();
     const qreal lengthSq = pow2(base.x()) + pow2(base.y());
     qreal coeff = prod / lengthSq;
 
     return coeff * base;
 }
 
 #include <QRect>
 
 inline QRect kisEnsureInRect(QRect rc, const QRect &bounds)
 {
     if(rc.right() > bounds.right()) {
         rc.translate(bounds.right() - rc.right(), 0);
     }
 
     if(rc.left() < bounds.left()) {
         rc.translate(bounds.left() - rc.left(), 0);
     }
 
     if(rc.bottom() > bounds.bottom()) {
         rc.translate(0, bounds.bottom() - rc.bottom());
     }
 
     if(rc.top() < bounds.top()) {
         rc.translate(0, bounds.top() - rc.top());
     }
 
     return rc;
 }
 
 #include <QSharedPointer>
 
 template <class T>
 inline QSharedPointer<T> toQShared(T* ptr) {
     return QSharedPointer<T>(ptr);
 }
 
 template <class A, template <class C> class List>
 List<QSharedPointer<A>> listToQShared(const List<A*> list) {
     List<QSharedPointer<A>> newList;
     Q_FOREACH(A* value, list) {
         newList.append(toQShared(value));
     }
     return newList;
 }
 
+
+/**
+ * Convert a list of strong pointers into a list of weak pointers
+ */
+template <template <class> class Container, class T>
+Container<QWeakPointer<T>> listStrongToWeak(const Container<QSharedPointer<T>> &containter)
+{
+    Container<QWeakPointer<T> > result;
+    Q_FOREACH (QSharedPointer<T> v, containter) {
+        result << v;
+    }
+    return result;
+}
+
+/**
+ * Convert a list of weak pointers into a list of strong pointers
+ *
+ * WARNING: By default, uses "all or nothing" rule. If at least one of
+ *          the weak pointers is invalid, returns an *empty* list!
+ *          Even though some other pointer can still be converted
+ *          correctly.
+ */
+template <template <class> class Container, class T>
+    Container<QSharedPointer<T> > listWeakToStrong(const Container<QWeakPointer<T>> &containter,
+                                                   bool allOrNothing = true)
+{
+    Container<QSharedPointer<T> > result;
+    Q_FOREACH (QWeakPointer<T> v, containter) {
+        QSharedPointer<T> strong(v);
+        if (!strong && allOrNothing) {
+            result.clear();
+            return result;
+        }
+
+        if (strong) {
+            result << strong;
+        }
+    }
+    return result;
+}
+
 /**
  * A special wrapper object that converts Qt-style mutexes and locks
  * into an object that supports Std's (and Boost's) "Lockable"
  * concept. Basically, it converts tryLock() into try_lock() to comply
  * with the syntax.
  */
 
 template <class T>
 struct StdLockableWrapper {
     StdLockableWrapper(T *lock) : m_lock(lock) {}
 
     void lock() {
         m_lock->lock();
     }
 
     bool try_lock() {
         return m_lock->tryLock();
     }
 
     void unlock() {
         m_lock->unlock();
     }
 
 private:
     T *m_lock;
 };
 
 #endif // KISGLOBAL_H_
 
diff --git a/libs/image/CMakeLists.txt b/libs/image/CMakeLists.txt
index 4a29534bf7..9c3821a9ff 100644
--- a/libs/image/CMakeLists.txt
+++ b/libs/image/CMakeLists.txt
@@ -1,382 +1,383 @@
 add_subdirectory( tests )
 
 add_subdirectory( tiles3 )
 
 include_directories(
     ${CMAKE_CURRENT_BINARY_DIR}
     ${CMAKE_CURRENT_SOURCE_DIR}/metadata
     ${CMAKE_CURRENT_SOURCE_DIR}/3rdparty
     ${CMAKE_CURRENT_SOURCE_DIR}/brushengine
     ${CMAKE_CURRENT_SOURCE_DIR}/commands
     ${CMAKE_CURRENT_SOURCE_DIR}/commands_new
     ${CMAKE_CURRENT_SOURCE_DIR}/filter
     ${CMAKE_CURRENT_SOURCE_DIR}/floodfill
     ${CMAKE_CURRENT_SOURCE_DIR}/generator
     ${CMAKE_CURRENT_SOURCE_DIR}/layerstyles
     ${CMAKE_CURRENT_SOURCE_DIR}/processing
     ${CMAKE_CURRENT_SOURCE_DIR}/recorder
 
     ${CMAKE_SOURCE_DIR}/sdk/tests
 )
 
 include_directories(SYSTEM
     ${EIGEN3_INCLUDE_DIR}
     ${Boost_INCLUDE_DIRS}
 )
 
 if(FFTW3_FOUND)
   include_directories(${FFTW3_INCLUDE_DIR})
 endif()
 
 if(HAVE_VC)
   include_directories(SYSTEM ${Vc_INCLUDE_DIR} ${Qt5Core_INCLUDE_DIRS} ${Qt5Gui_INCLUDE_DIRS})
   ko_compile_for_all_implementations(__per_arch_circle_mask_generator_objs kis_brush_mask_applicator_factories.cpp)
 else()
   set(__per_arch_circle_mask_generator_objs kis_brush_mask_applicator_factories.cpp)
 endif()
 
 set(kritaimage_LIB_SRCS
     tiles3/kis_tile.cc
     tiles3/kis_tile_data.cc
     tiles3/kis_tile_data_store.cc
     tiles3/kis_tile_data_pooler.cc
     tiles3/kis_tiled_data_manager.cc
     tiles3/kis_memento_manager.cc
     tiles3/kis_hline_iterator.cpp
     tiles3/kis_vline_iterator.cpp
     tiles3/kis_random_accessor.cc
     tiles3/swap/kis_abstract_compression.cpp
     tiles3/swap/kis_lzf_compression.cpp
     tiles3/swap/kis_abstract_tile_compressor.cpp
     tiles3/swap/kis_legacy_tile_compressor.cpp
     tiles3/swap/kis_tile_compressor_2.cpp
     tiles3/swap/kis_chunk_allocator.cpp
     tiles3/swap/kis_memory_window.cpp
     tiles3/swap/kis_swapped_data_store.cpp
     tiles3/swap/kis_tile_data_swapper.cpp
    kis_distance_information.cpp
    kis_painter.cc
    kis_progress_updater.cpp
    brushengine/kis_paint_information.cc
    brushengine/kis_random_source.cpp
    brushengine/kis_stroke_random_source.cpp
    brushengine/kis_paintop.cc
    brushengine/kis_paintop_factory.cpp
    brushengine/kis_paintop_preset.cpp
    brushengine/kis_paintop_registry.cc
    brushengine/kis_paintop_settings.cpp
    brushengine/kis_paintop_settings_update_proxy.cpp
    brushengine/kis_locked_properties.cc
    brushengine/kis_locked_properties_proxy.cpp
    brushengine/kis_locked_properties_server.cpp
    brushengine/kis_paintop_config_widget.cpp
    brushengine/kis_uniform_paintop_property.cpp
+   brushengine/kis_standard_uniform_properties_factory.cpp
    commands/kis_deselect_global_selection_command.cpp
    commands/kis_image_change_layers_command.cpp
    commands/kis_image_command.cpp
    commands/kis_image_set_projection_color_space_command.cpp
    commands/kis_image_layer_add_command.cpp
    commands/kis_image_layer_move_command.cpp
    commands/kis_image_layer_remove_command.cpp
    commands/kis_image_layer_remove_command_impl.cpp
    commands/kis_image_lock_command.cpp
    commands/kis_layer_command.cpp
    commands/kis_node_command.cpp
    commands/kis_node_compositeop_command.cpp
    commands/kis_node_opacity_command.cpp
    commands/kis_node_property_list_command.cpp
    commands/kis_reselect_global_selection_command.cpp
    commands/kis_set_global_selection_command.cpp
    commands_new/kis_saved_commands.cpp
    commands_new/kis_processing_command.cpp
    commands_new/kis_image_resize_command.cpp
    commands_new/kis_image_set_resolution_command.cpp
    commands_new/kis_node_move_command2.cpp
    commands_new/kis_set_layer_style_command.cpp
    commands_new/kis_selection_move_command2.cpp
    commands_new/kis_update_command.cpp
    commands_new/kis_switch_current_time_command.cpp
    commands_new/kis_change_projection_color_command.cpp
    commands_new/kis_activate_selection_mask_command.cpp
    processing/kis_do_nothing_processing_visitor.cpp
    processing/kis_simple_processing_visitor.cpp
    processing/kis_crop_processing_visitor.cpp
    processing/kis_crop_selections_processing_visitor.cpp
    processing/kis_transform_processing_visitor.cpp
    processing/kis_mirror_processing_visitor.cpp
    filter/kis_filter.cc
    filter/kis_filter_configuration.cc
    filter/kis_color_transformation_configuration.cc
    filter/kis_filter_registry.cc
    filter/kis_color_transformation_filter.cc
    generator/kis_generator.cpp
    generator/kis_generator_layer.cpp
    generator/kis_generator_registry.cpp
    floodfill/kis_fill_interval_map.cpp
    floodfill/kis_scanline_fill.cpp
    kis_adjustment_layer.cc
    kis_selection_based_layer.cpp
    kis_node_filter_interface.cpp
    kis_base_accessor.cpp
    kis_base_node.cpp
    kis_base_processor.cpp
    kis_bookmarked_configuration_manager.cc
    kis_clone_info.cpp
    kis_clone_layer.cpp
    kis_colorspace_convert_visitor.cpp
    kis_config_widget.cpp
    kis_convolution_kernel.cc
    kis_convolution_painter.cc
    kis_gaussian_kernel.cpp
    kis_cubic_curve.cpp
    kis_default_bounds.cpp
    kis_default_bounds_base.cpp
    kis_effect_mask.cc
    kis_fast_math.cpp
    kis_fill_painter.cc
    kis_filter_mask.cpp
    kis_filter_strategy.cc
    kis_transform_mask.cpp
    kis_transform_mask_params_interface.cpp
    kis_recalculate_transform_mask_job.cpp
    kis_recalculate_generator_layer_job.cpp
    kis_transform_mask_params_factory_registry.cpp
    kis_safe_transform.cpp
    kis_gradient_painter.cc
    kis_gradient_shape_strategy.cpp
    kis_cached_gradient_shape_strategy.cpp
    kis_polygonal_gradient_shape_strategy.cpp
    kis_iterator_ng.cpp
    kis_async_merger.cpp
    kis_merge_walker.cc
    kis_updater_context.cpp
    kis_update_job_item.cpp
    kis_stroke_strategy_undo_command_based.cpp
    kis_simple_stroke_strategy.cpp
    kis_stroke_job_strategy.cpp
    kis_stroke_strategy.cpp
    kis_stroke.cpp
    kis_strokes_queue.cpp
    kis_simple_update_queue.cpp
    kis_update_scheduler.cpp
    kis_queues_progress_updater.cpp
    kis_composite_progress_proxy.cpp
    kis_sync_lod_cache_stroke_strategy.cpp
    kis_lod_capable_layer_offset.cpp
    kis_update_time_monitor.cpp
    kis_group_layer.cc
    kis_count_visitor.cpp
    kis_histogram.cc
    kis_image_interfaces.cpp
    kis_image_animation_interface.cpp
    kis_time_range.cpp
    kis_node_graph_listener.cpp
    kis_image.cc
    kis_image_signal_router.cpp
    kis_image_config.cpp
    kis_projection_updates_filter.cpp
    kis_suspend_projection_updates_stroke_strategy.cpp
    kis_regenerate_frame_stroke_strategy.cpp
    kis_crop_saved_extra_data.cpp
    kis_signal_compressor.cpp
    kis_signal_compressor_with_param.cpp
    kis_thread_safe_signal_compressor.cpp
    kis_acyclic_signal_connector.cpp
    kis_timed_signal_threshold.cpp
    kis_layer.cc
    kis_indirect_painting_support.cpp
    kis_abstract_projection_plane.cpp
    kis_layer_projection_plane.cpp
    kis_command_utils.cpp
    kis_layer_utils.cpp
    kis_mask_projection_plane.cpp
    kis_projection_leaf.cpp
    kis_mask.cc
    kis_base_mask_generator.cpp
    kis_rect_mask_generator.cpp
    kis_circle_mask_generator.cpp
    kis_gauss_circle_mask_generator.cpp
    kis_gauss_rect_mask_generator.cpp
    ${__per_arch_circle_mask_generator_objs}
    kis_curve_circle_mask_generator.cpp
    kis_curve_rect_mask_generator.cpp
    kis_math_toolbox.cpp
    kis_memory_statistics_server.cpp
    kis_name_server.cpp
    kis_node.cpp
    kis_node_facade.cpp
    kis_node_progress_proxy.cpp
    kis_busy_progress_indicator.cpp
    kis_node_visitor.cpp
    kis_paint_device.cc
    kis_paint_device_debug_utils.cpp
    kis_fixed_paint_device.cpp
    kis_paint_layer.cc
    kis_perspective_math.cpp
    kis_pixel_selection.cpp
    kis_processing_information.cpp
    kis_properties_configuration.cc
    kis_random_accessor_ng.cpp
    kis_random_generator.cc
    kis_random_sub_accessor.cpp
    kis_wrapped_random_accessor.cpp
    kis_selection.cc
    kis_selection_mask.cpp
    kis_update_outline_job.cpp
    kis_update_selection_job.cpp
    kis_serializable_configuration.cc
    kis_transaction_data.cpp
    kis_transform_worker.cc
    kis_perspectivetransform_worker.cpp
    bsplines/kis_bspline_1d.cpp
    bsplines/kis_bspline_2d.cpp
    bsplines/kis_nu_bspline_2d.cpp
    kis_warptransform_worker.cc
    kis_cage_transform_worker.cpp
    kis_liquify_transform_worker.cpp
    kis_green_coordinates_math.cpp
    kis_algebra_2d.cpp
    kis_transparency_mask.cc
    kis_undo_store.cpp
    kis_undo_stores.cpp
    kis_undo_adapter.cpp
    kis_surrogate_undo_adapter.cpp
    kis_legacy_undo_adapter.cpp
    kis_post_execution_undo_adapter.cpp
    kis_processing_visitor.cpp
    kis_processing_applicator.cpp
    krita_utils.cpp
    kis_outline_generator.cpp
    kis_layer_composition.cpp
    kis_selection_filters.cpp
    KisProofingConfiguration.h
    metadata/kis_meta_data_entry.cc
    metadata/kis_meta_data_filter.cc
    metadata/kis_meta_data_filter_p.cc
    metadata/kis_meta_data_filter_registry.cc
    metadata/kis_meta_data_filter_registry_model.cc
    metadata/kis_meta_data_io_backend.cc
    metadata/kis_meta_data_merge_strategy.cc
    metadata/kis_meta_data_merge_strategy_p.cc
    metadata/kis_meta_data_merge_strategy_registry.cc
    metadata/kis_meta_data_parser.cc
    metadata/kis_meta_data_schema.cc
    metadata/kis_meta_data_schema_registry.cc
    metadata/kis_meta_data_store.cc
    metadata/kis_meta_data_type_info.cc
    metadata/kis_meta_data_validator.cc
    metadata/kis_meta_data_value.cc
    recorder/kis_action_recorder.cc
    recorder/kis_macro.cc
    recorder/kis_macro_player.cc
    recorder/kis_node_query_path.cc
    recorder/kis_play_info.cc
    recorder/kis_recorded_action.cc
    recorder/kis_recorded_action_factory_registry.cc
    recorder/kis_recorded_action_load_context.cpp
    recorder/kis_recorded_action_save_context.cpp
    recorder/kis_recorded_filter_action.cpp
    recorder/kis_recorded_fill_paint_action.cpp
    recorder/kis_recorded_node_action.cc
    recorder/kis_recorded_paint_action.cpp
    recorder/kis_recorded_path_paint_action.cpp
    recorder/kis_recorded_shape_paint_action.cpp
 
    kis_keyframe.cpp
    kis_keyframe_channel.cpp
    kis_scalar_keyframe_channel.cpp
    kis_raster_keyframe_channel.cpp
    kis_onion_skin_compositor.cpp
    kis_onion_skin_cache.cpp
    kis_idle_watcher.cpp
 
    kis_psd_layer_style.cpp
    kis_layer_properties_icons.cpp
 
    layerstyles/kis_multiple_projection.cpp
    layerstyles/kis_layer_style_filter.cpp
    layerstyles/kis_layer_style_filter_environment.cpp
    layerstyles/kis_layer_style_filter_projection_plane.cpp
    layerstyles/kis_layer_style_projection_plane.cpp
    layerstyles/kis_ls_drop_shadow_filter.cpp
    layerstyles/kis_ls_satin_filter.cpp
    layerstyles/kis_ls_stroke_filter.cpp
    layerstyles/kis_ls_bevel_emboss_filter.cpp
    layerstyles/kis_ls_overlay_filter.cpp
    layerstyles/kis_ls_utils.cpp
    layerstyles/gimp_bump_map.cpp
 )
 
 set(einspline_SRCS
    3rdparty/einspline/bspline_create.cpp
    3rdparty/einspline/bspline_data.cpp
    3rdparty/einspline/multi_bspline_create.cpp
    3rdparty/einspline/nubasis.cpp
    3rdparty/einspline/nubspline_create.cpp
    3rdparty/einspline/nugrid.cpp
 )
 
 add_library(kritaimage SHARED ${kritaimage_LIB_SRCS} ${einspline_SRCS})
 generate_export_header(kritaimage BASE_NAME kritaimage)
 
 target_link_libraries(kritaimage 
     PUBLIC
         kritaversion 
         kritawidgets 
         kritaglobal kritapsd 
         kritaodf kritapigment 
         kritaundo2 
         kritawidgetutils 
         Qt5::Concurrent
 )
 
 target_link_libraries(kritaimage PUBLIC ${Boost_SYSTEM_LIBRARY})
 
 if(OPENEXR_FOUND)
   target_link_libraries(kritaimage PUBLIC ${OPENEXR_LIBRARIES})
 endif()
 
 if(FFTW3_FOUND)
   target_link_libraries(kritaimage PRIVATE ${FFTW3_LIBRARIES})
 endif()
 
 if(HAVE_VC)
   target_link_libraries(kritaimage PUBLIC ${Vc_LIBRARIES})
   if (NOT PACKAGERS_BUILD)
       set_property(TARGET kritaimage APPEND PROPERTY COMPILE_OPTIONS "${Vc_ARCHITECTURE_FLAGS}")
   endif()
 endif()
 
 if (NOT GSL_FOUND)
   message (WARNING "KRITA WARNING! No GNU Scientific Library was found! Krita's Shaped Gradients might be non-normalized! Please install GSL library.")
 else ()
   target_link_libraries(kritaimage PRIVATE ${GSL_LIBRARIES} ${GSL_CBLAS_LIBRARIES})
 endif ()
 
 target_include_directories(kritaimage
     PUBLIC
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/brushengine>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/filter>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/generator>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/layerstyles>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/metadata>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/processing>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/recorder>
 )
 
 set_target_properties(kritaimage PROPERTIES
     VERSION ${GENERIC_KRITA_LIB_VERSION} SOVERSION ${GENERIC_KRITA_LIB_SOVERSION}
 )
 install(TARGETS kritaimage  ${INSTALL_TARGETS_DEFAULT_ARGS})
 
 ########### install schemas #############
 install( FILES
     metadata/schemas/dc.schema
     metadata/schemas/exif.schema
     metadata/schemas/tiff.schema
     metadata/schemas/mkn.schema
     metadata/schemas/xmp.schema
     metadata/schemas/xmpmm.schema
     metadata/schemas/xmprights.schema
 
     DESTINATION ${DATA_INSTALL_DIR}/krita/metadata/schemas)
diff --git a/libs/image/brushengine/kis_paintop_config_widget.cpp b/libs/image/brushengine/kis_paintop_config_widget.cpp
index ea7fc80ea5..2fbc63100b 100644
--- a/libs/image/brushengine/kis_paintop_config_widget.cpp
+++ b/libs/image/brushengine/kis_paintop_config_widget.cpp
@@ -1,76 +1,95 @@
 /*
  *  Copyright (c) 2008 Boudewijn Rempt <boud@valdyas.org>
  *  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_paintop_config_widget.h"
 
 #include <brushengine/kis_paintop_settings.h>
 
 KisPaintOpConfigWidget::KisPaintOpConfigWidget(QWidget * parent, Qt::WFlags f)
     : KisConfigWidget(parent, f, 10),
-      m_userAllowedLod(true)
+      m_userAllowedLod(true),
+      m_isInsideUpdateCall(0)
 {
 }
 
 KisPaintOpConfigWidget::~KisPaintOpConfigWidget() {
 }
 
+void KisPaintOpConfigWidget::writeConfigurationSafe(KisPropertiesConfiguration *config) const
+{
+    if (m_isInsideUpdateCall) return;
+
+    m_isInsideUpdateCall++;
+    writeConfiguration(config);
+    m_isInsideUpdateCall--;
+}
+
+void KisPaintOpConfigWidget::setConfigurationSafe(const KisPropertiesConfiguration *config)
+{
+    if (m_isInsideUpdateCall) return;
+
+    m_isInsideUpdateCall++;
+    setConfiguration(config);
+    m_isInsideUpdateCall--;
+}
+
 void KisPaintOpConfigWidget::writeConfiguration(KisPropertiesConfiguration *config) const {
     KisPaintOpSettings::setLodUserAllowed(config, m_userAllowedLod);
 }
 
 void KisPaintOpConfigWidget::setConfiguration(const KisPropertiesConfiguration * config) {
     m_userAllowedLod = KisPaintOpSettings::isLodUserAllowed(config);
     emit sigUserChangedLodAvailability(m_userAllowedLod);
 }
 
 void KisPaintOpConfigWidget::setImage(KisImageWSP image) {
     m_image = image;
 }
 
 void KisPaintOpConfigWidget::setNode(KisNodeWSP node) {
     m_node = node;
 }
 
 void KisPaintOpConfigWidget::changePaintOpSize(qreal x, qreal y) {
     Q_UNUSED(x);
     Q_UNUSED(y);
 }
 
 QSizeF KisPaintOpConfigWidget::paintOpSize() const {
     return QSizeF(1.0, 1.0);
 }
 
 bool KisPaintOpConfigWidget::presetIsValid() {
     return true;
 }
 
 bool KisPaintOpConfigWidget::supportScratchBox() {
     return true;
 }
 
 void KisPaintOpConfigWidget::slotUserChangedLodAvailability(bool value) {
     m_userAllowedLod = value;
     emit sigConfigurationItemChanged();
 }
 
 void KisPaintOpConfigWidget::coldInitExternalLodAvailabilityWidget()
 {
     emit sigUserChangedLodAvailability(m_userAllowedLod);
     emit sigConfigurationItemChanged();
 }
diff --git a/libs/image/brushengine/kis_paintop_config_widget.h b/libs/image/brushengine/kis_paintop_config_widget.h
index db1cab4ead..f1d3a3f944 100644
--- a/libs/image/brushengine/kis_paintop_config_widget.h
+++ b/libs/image/brushengine/kis_paintop_config_widget.h
@@ -1,95 +1,102 @@
 /*
  *  Copyright (c) 2008 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_CONFIG_WIDGET_H_
 #define KIS_PAINTOP_CONFIG_WIDGET_H_
 
 #include "kritaimage_export.h"
 
 #include "kis_config_widget.h"
 #include "kis_image.h"
 #include <kis_debug.h>
 
 class KisPaintopLodLimitations;
 
 /**
  * Base class for widgets that are used to edit and display paintop settings.
  */
 class KRITAIMAGE_EXPORT KisPaintOpConfigWidget : public KisConfigWidget
 {
     Q_OBJECT
 
 public:
     KisPaintOpConfigWidget(QWidget * parent = 0, Qt::WFlags f = 0);
     virtual ~KisPaintOpConfigWidget();
 
+    void writeConfigurationSafe(KisPropertiesConfiguration *config) const;
+    void setConfigurationSafe(const KisPropertiesConfiguration *config);
+
+protected:
     /**
      * Write the settings in this widget to the given properties
      * configuration, which is cleared first.
      */
     virtual void writeConfiguration(KisPropertiesConfiguration *config) const;
     virtual void setConfiguration(const KisPropertiesConfiguration * config);
+public:
 
     virtual KisPaintopLodLimitations lodLimitations() const = 0;
 
     virtual void setImage(KisImageWSP image);
     virtual void setNode(KisNodeWSP node);
 
     /**
      * @see KisPaintOpSettings::changePaintOpSize(qreal x, qreal y)
      */
     virtual void changePaintOpSize(qreal x, qreal y);
 
     /**
      * @see KisPaintOpSettings::paintOpSize()
      */
     virtual QSizeF paintOpSize() const;
 
     /**
      * This is true for all of the paintop widget except for the Custom brush tab in the Brush tip dialog
      */
     virtual bool presetIsValid();
 
     /**
      * Some paintops are more complicated and require full canvas with layers, projections and KisImage etc.
      * Example is duplicate paintop. In this case simple canvas like scratchbox does not work.
      * Every paintop supports the scratchbox by default, override and return false if paintop does not.
      */
     virtual bool supportScratchBox();
 
 
     /**
      * This call makes KisPaintOpConfigWidget emit
      * sigUserChangedLodAvailability() signal with the current
      * availability value
      */
     void coldInitExternalLodAvailabilityWidget();
 
 public Q_SLOTS:
     void slotUserChangedLodAvailability(bool value);
 
 Q_SIGNALS:
     void sigUserChangedLodAvailability(bool value);
 
 protected:
     KisImageWSP m_image;
     KisNodeWSP m_node;
     bool m_userAllowedLod;
+
+    mutable int m_isInsideUpdateCall;
 };
 
 #endif
diff --git a/libs/image/brushengine/kis_paintop_preset.cpp b/libs/image/brushengine/kis_paintop_preset.cpp
index 26ff1cc83d..389ad3bd63 100644
--- a/libs/image/brushengine/kis_paintop_preset.cpp
+++ b/libs/image/brushengine/kis_paintop_preset.cpp
@@ -1,345 +1,393 @@
 /* This file is part of the KDE project
  * Copyright (C) Boudewijn Rempt <boud@valdyas.org>, (C) 2008
  * Copyright (C) Sven Langkamp <sven.langkamp@gmail.com>, (C) 2009
  *
  * 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 <brushengine/kis_paintop_preset.h>
 
 #include <QFile>
 #include <QSize>
 #include <QImage>
 #include <QImageWriter>
 #include <QImageReader>
 #include <QDomDocument>
 #include <QBuffer>
 
 #include <brushengine/kis_paintop_settings.h>
 #include "kis_paintop_registry.h"
 #include "kis_painter.h"
 #include <brushengine/kis_paint_information.h>
 #include "kis_paint_device.h"
 #include "kis_image.h"
+#include "kis_paintop_settings_update_proxy.h"
+#include <brushengine/kis_paintop_config_widget.h>
 
 #include <KoStore.h>
 
 struct Q_DECL_HIDDEN KisPaintOpPreset::Private {
     Private()
         : settings(0),
           dirtyPreset(false)
     {
     }
 
     KisPaintOpSettingsSP settings;
     bool dirtyPreset;
-
+    QScopedPointer<KisPaintopSettingsUpdateProxy> updateProxy;
 };
 
 
 KisPaintOpPreset::KisPaintOpPreset()
     : KoResource(QString())
     , m_d(new Private)
 {
 }
 
 KisPaintOpPreset::KisPaintOpPreset(const QString & fileName)
     : KoResource(fileName)
     , m_d(new Private)
 {
 }
 
 KisPaintOpPreset::~KisPaintOpPreset()
 {
     delete m_d;
 }
 
 KisPaintOpPresetSP KisPaintOpPreset::clone() const
 {
     KisPaintOpPresetSP preset = new KisPaintOpPreset();
 
     if (settings()) {
         preset->setSettings(settings()); // the settings are cloned inside!
     }
     preset->setPresetDirty(isPresetDirty());
     // only valid if we could clone the settings
     preset->setValid(settings());
 
     preset->setPaintOp(paintOp());
     preset->setName(name());
     preset->setImage(image());
     preset->settings()->setPreset(KisPaintOpPresetWSP(preset));
 
     Q_ASSERT(preset->valid());
 
     return preset;
 }
 void KisPaintOpPreset::setPresetDirty(bool value)
 {
     m_d->dirtyPreset = value;
+
+    if (m_d->updateProxy && m_d->dirtyPreset != value) {
+        m_d->updateProxy->notifySettingsChanged();
+    }
 }
 bool KisPaintOpPreset::isPresetDirty() const
 {
     return m_d->dirtyPreset;
 }
 
 void KisPaintOpPreset::setPaintOp(const KoID & paintOp)
 {
     Q_ASSERT(m_d->settings);
     m_d->settings->setProperty("paintop", paintOp.id());
 }
 
 KoID KisPaintOpPreset::paintOp() const
 {
     Q_ASSERT(m_d->settings);
     return KoID(m_d->settings->getString("paintop"), name());
 }
 
+void KisPaintOpPreset::setOptionsWidget(KisPaintOpConfigWidget* widget)
+{
+    if (m_d->settings) {
+        m_d->settings->setOptionsWidget(widget);
+
+        if (widget) {
+            widget->setConfigurationSafe(m_d->settings);
+        }
+    }
+}
+
 void KisPaintOpPreset::setSettings(KisPaintOpSettingsSP settings)
 {
     Q_ASSERT(settings);
     Q_ASSERT(!settings->getString("paintop", "").isEmpty());
 
     DirtyStateSaver dirtyStateSaver(this);
 
+    KisPaintOpConfigWidget *oldOptionsWidget = 0;
+
     if (m_d->settings) {
+        oldOptionsWidget = m_d->settings->optionsWidget();
+        m_d->settings->setOptionsWidget(0);
         m_d->settings->setPreset(0);
         m_d->settings = 0;
     }
 
     if (settings) {
         m_d->settings = settings->clone();
         m_d->settings->setPreset(KisPaintOpPresetWSP(this));
+
+        if (oldOptionsWidget) {
+            m_d->settings->setOptionsWidget(oldOptionsWidget);
+            oldOptionsWidget->setConfigurationSafe(m_d->settings);
+        }
     }
 
     setValid(m_d->settings);
+
+    if (m_d->updateProxy) {
+        m_d->updateProxy->notifyUniformPropertiesChanged();
+        m_d->updateProxy->notifySettingsChanged();
+    }
 }
 
 KisPaintOpSettingsSP KisPaintOpPreset::settings() const
 {
     Q_ASSERT(m_d->settings);
     Q_ASSERT(!m_d->settings->getString("paintop", "").isEmpty());
 
     return m_d->settings;
 }
 
 bool KisPaintOpPreset::load()
 {
     dbgImage << "Load preset " << filename();
     setValid(false);
 
     if (filename().isEmpty()) {
         return false;
     }
 
     QIODevice *dev = 0;
     QByteArray ba;
 
     if (filename().startsWith("bundle://")) {
         QString bn = filename().mid(9);
         int pos = bn.lastIndexOf(":");
         QString fn = bn.right(bn.size() - pos - 1);
         bn = bn.left(pos);
 
         QScopedPointer<KoStore> resourceStore(KoStore::createStore(bn, KoStore::Read, "application/x-krita-resourcebundle", KoStore::Zip));
         if (!resourceStore || resourceStore->bad()) {
             warnKrita << "Could not open store on bundle" << bn;
             return false;
         }
 
         if (resourceStore->isOpen()) resourceStore->close();
 
         if (!resourceStore->open(fn)) {
             warnKrita << "Could not open preset" << fn << "in bundle" << bn;
             return false;
         }
 
         ba = resourceStore->device()->readAll();
         dev = new QBuffer(&ba);
 
         resourceStore->close();
     }
     else {
 
         dev = new QFile(filename());
         if (dev->size() == 0)
         {
             delete dev;
             return false;
         }
 
         if (!dev->open(QIODevice::ReadOnly)) {
             warnKrita << "Can't open file " << filename();
             delete dev;
             return false;
         }
     }
 
     bool res = loadFromDevice(dev);
     delete dev;
 
     setValid(res);
     setPresetDirty(false);
     return res;
 
 }
 
 bool KisPaintOpPreset::loadFromDevice(QIODevice *dev)
 {
 
     QImageReader reader(dev, "PNG");
 
     QString version = reader.text("version");
     QString preset = reader.text("preset");
 
     dbgImage << version;
 
     if (version != "2.2") {
         return false;
     }
 
     QImage img;
     if (!reader.read(&img)) {
         dbgImage << "Fail to decode PNG";
         return false;
     }
 
     //Workaround for broken presets
     //Presets was saved with nested cdata section
     preset.replace("<curve><![CDATA[", "<curve>");
     preset.replace("]]></curve>", "</curve>");
 
     QDomDocument doc;
     if (!doc.setContent(preset)) {
         return false;
     }
 
     fromXML(doc.documentElement());
 
     if (!m_d->settings) {
         return false;
     }
 
     setValid(true);
     setImage(img);
 
     return true;
 }
 
 bool KisPaintOpPreset::save()
 {
 
     if (filename().isEmpty())
         return false;
 
     QString paintopid = m_d->settings->getString("paintop", "");
 
     if (paintopid.isEmpty())
         return false;
 
     QFile f(filename());
     f.open(QFile::WriteOnly);
 
     return saveToDevice(&f);
 }
 
 void KisPaintOpPreset::toXML(QDomDocument& doc, QDomElement& elt) const
 {
     QString paintopid = m_d->settings->getString("paintop", "");
 
     elt.setAttribute("paintopid", paintopid);
     elt.setAttribute("name", name());
 
     // sanitize the settings
     bool hasTexture = m_d->settings->getBool("Texture/Pattern/Enabled");
     if (!hasTexture) {
         Q_FOREACH (const QString & key, m_d->settings->getProperties().keys()) {
             if (key.startsWith("Texture") && key != "Texture/Pattern/Enabled") {
                 m_d->settings->removeProperty(key);
             }
         }
     }
 
     m_d->settings->toXML(doc, elt);
 }
 
 void KisPaintOpPreset::fromXML(const QDomElement& presetElt)
 {
     setName(presetElt.attribute("name"));
     QString paintopid = presetElt.attribute("paintopid");
 
     if (paintopid.isEmpty()) {
         dbgImage << "No paintopid attribute";
         setValid(false);
         return;
     }
 
     if (KisPaintOpRegistry::instance()->get(paintopid) == 0) {
         dbgImage << "No paintop " << paintopid;
         setValid(false);
         return;
     }
 
     KoID id(paintopid, "");
 
     KisPaintOpSettingsSP settings = KisPaintOpRegistry::instance()->settings(id);
     if (!settings) {
         setValid(false);
         warnKrita << "Could not load settings for preset" << paintopid;
         return;
     }
 
     settings->fromXML(presetElt);
     // sanitize the settings
     bool hasTexture = settings->getBool("Texture/Pattern/Enabled");
     if (!hasTexture) {
         Q_FOREACH (const QString & key, settings->getProperties().keys()) {
             if (key.startsWith("Texture") && key != "Texture/Pattern/Enabled") {
                 settings->removeProperty(key);
             }
         }
     }
     setSettings(settings);
 
 }
 
 bool KisPaintOpPreset::saveToDevice(QIODevice *dev) const
 {
     QImageWriter writer(dev, "PNG");
 
     QDomDocument doc;
     QDomElement root = doc.createElement("Preset");
     toXML(doc, root);
     doc.appendChild(root);
 
     writer.setText("version", "2.2");
     writer.setText("preset", doc.toString());
 
     QImage img;
 
     if (image().isNull()) {
         img = QImage(1, 1, QImage::Format_RGB32);
     } else {
         img = image();
     }
 
     m_d->dirtyPreset = false;
 
     KoResource::saveToDevice(dev);
 
     return writer.write(img);
 
 }
 
+KisPaintopSettingsUpdateProxy* KisPaintOpPreset::updateProxy() const
+{
+    if (!m_d->updateProxy) {
+        m_d->updateProxy.reset(new KisPaintopSettingsUpdateProxy());
+    }
+    return m_d->updateProxy.data();
+}
+
+KisPaintopSettingsUpdateProxy* KisPaintOpPreset::updateProxyNoCreate() const
+{
+    return m_d->updateProxy.data();
+}
+
+QList<KisUniformPaintOpPropertySP> KisPaintOpPreset::uniformProperties()
+{
+    return m_d->settings->uniformProperties();
+}
diff --git a/libs/image/brushengine/kis_paintop_preset.h b/libs/image/brushengine/kis_paintop_preset.h
index 0b0fd93047..9213db29d2 100644
--- a/libs/image/brushengine/kis_paintop_preset.h
+++ b/libs/image/brushengine/kis_paintop_preset.h
@@ -1,114 +1,124 @@
 /* This file is part of the KDE project
  * Copyright (C) Boudewijn Rempt <boud@valdyas.org>, (C) 2008
  *
  * 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_PAINTOP_PRESET_H
 #define KIS_PAINTOP_PRESET_H
 
 #include <resources/KoResource.h>
 #include "KoID.h"
 
 #include "kis_types.h"
 #include "kis_shared.h"
 #include "kritaimage_export.h"
+#include <brushengine/kis_uniform_paintop_property.h>
 
+class KisPaintopSettingsUpdateProxy;
+class KisPaintOpConfigWidget;
 
 /**
  * A KisPaintOpPreset contains a particular set of settings
  * associated with a paintop, like brush, paintopsettings.
  * A new property in this class is to make it dirty. That means the
  * user can now temporarily save any tweaks in the Preset throughout
  * the session. The Dirty Preset setting/unsetting is handled by KisPaintOpPresetSettings
  */
 class KRITAIMAGE_EXPORT KisPaintOpPreset : public KoResource, public KisShared
 {
 public:
 
     KisPaintOpPreset();
 
     KisPaintOpPreset(const QString& filename);
 
     ~KisPaintOpPreset();
 
     KisPaintOpPresetSP clone() const;
 
     /// set the id of the paintop plugin
     void setPaintOp(const KoID & paintOp);
 
     /// return the id of the paintop plugin
     KoID paintOp() const;
 
     /// replace the current settings object with the specified settings
     void setSettings(KisPaintOpSettingsSP settings);
     void setOriginalSettings(KisPaintOpSettingsSP originalSettings);
 
     /// return the settings that define this paintop preset
     KisPaintOpSettingsSP settings() const;
     KisPaintOpSettingsSP originalSettings() const;
 
     bool load();
     bool loadFromDevice(QIODevice *dev);
 
     bool save();
     bool saveToDevice(QIODevice* dev) const;
 
     void toXML(QDomDocument& doc, QDomElement& elt) const;
 
     void fromXML(const QDomElement& elt);
 
     bool removable() const {
         return true;
     }
 
     QString defaultFileExtension() const {
         return ".kpp";
     }
     void setPresetDirty(bool value);
 
     bool isPresetDirty() const;
 
     /**
      * Never use manual save/restore calls to
      * isPresetDirty()/setPresetDirty()! They will lead to
      * hard-to-tack-down bugs when the dirty state will not be
      * restored on jumps like 'return', 'break' or exception.
      */
     class DirtyStateSaver {
     public:
         DirtyStateSaver(KisPaintOpPreset *preset)
             : m_preset(preset), m_isDirty(preset->isPresetDirty())
         {
         }
 
         ~DirtyStateSaver() {
             m_preset->setPresetDirty(m_isDirty);
         }
 
     private:
         KisPaintOpPreset *m_preset;
         bool m_isDirty;
     };
 
+    void setOptionsWidget(KisPaintOpConfigWidget *widget);
+
+    KisPaintopSettingsUpdateProxy* updateProxy() const;
+    KisPaintopSettingsUpdateProxy* updateProxyNoCreate() const;
+
+    QList<KisUniformPaintOpPropertySP> uniformProperties();
+
 private:
 
     struct Private;
     Private * const m_d;
 };
 
 Q_DECLARE_METATYPE(KisPaintOpPresetSP)
 
 #endif
diff --git a/libs/image/brushengine/kis_paintop_settings.cpp b/libs/image/brushengine/kis_paintop_settings.cpp
index 0741f57cb5..9157f8e080 100644
--- a/libs/image/brushengine/kis_paintop_settings.cpp
+++ b/libs/image/brushengine/kis_paintop_settings.cpp
@@ -1,398 +1,396 @@
 /*
  *  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 <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>
+
 
 struct Q_DECL_HIDDEN KisPaintOpSettings::Private {
     Private() : disableDirtyNotifications(false) {}
 
     QPointer<KisPaintOpConfigWidget> settingsWidget;
     QString modelName;
     KisPaintOpPresetWSP preset;
-    QScopedPointer<KisPaintopSettingsUpdateProxy> updateProxy;
-    QList<KisUniformPaintOpPropertySP> uniformProperties;
+    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 {
+        return preset ? preset->updateProxyNoCreate() : 0;
+    }
+
+    KisPaintopSettingsUpdateProxy* updateProxyCreate() const {
+        return preset ? preset->updateProxy() : 0;
+    }
 };
 
 
 KisPaintOpSettings::KisPaintOpSettings()
     : d(new Private)
 {
     d->preset = 0;
 }
 
 KisPaintOpSettings::~KisPaintOpSettings()
 {
 }
 
 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 &pos, Qt::KeyboardModifiers modifiers, KisNodeWSP currentNode)
 {
     Q_UNUSED(pos);
     Q_UNUSED(modifiers);
     Q_UNUSED(currentNode);
     setRandomOffset();
     return true; // ignore the event by default
 }
 void KisPaintOpSettings::setRandomOffset()
 {
     srand(time(0));
     bool isRandomOffsetX = KisPropertiesConfiguration::getBool("Texture/Pattern/isRandomOffsetX");
     bool isRandomOffsetY = KisPropertiesConfiguration::getBool("Texture/Pattern/isRandomOffsetY");
     int offsetX = KisPropertiesConfiguration::getInt("Texture/Pattern/OffsetX");
     int offsetY = KisPropertiesConfiguration::getInt("Texture/Pattern/OffsetY");
     if (KisPropertiesConfiguration::getBool("Texture/Pattern/Enabled")) {
         if (isRandomOffsetX) {
             offsetX = rand() % KisPropertiesConfiguration::getInt("Texture/Pattern/MaximumOffsetX");
 
             KisPropertiesConfiguration::setProperty("Texture/Pattern/OffsetX", offsetX);
             offsetX = KisPropertiesConfiguration::getInt("Texture/Pattern/OffsetX");
 
         }
 
         if (isRandomOffsetY) {
             offsetY = rand() % KisPropertiesConfiguration::getInt("Texture/Pattern/MaximumOffsetY");
             KisPropertiesConfiguration::setProperty("Texture/Pattern/OffsetY", offsetY);
             offsetY = KisPropertiesConfiguration::getInt("Texture/Pattern/OffsetY");
         }
     }
 }
 
 
 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::activate()
 {
 }
 
-void KisPaintOpSettings::changePaintOpSize(qreal x, qreal y)
-{
-    if (!d->settingsWidget.isNull()) {
-        d->settingsWidget.data()->changePaintOpSize(x, y);
-        d->settingsWidget.data()->writeConfiguration(this);
-    }
-}
-
-
-QSizeF KisPaintOpSettings::paintOpSize() const
-{
-    if (!d->settingsWidget.isNull()) {
-        return d->settingsWidget.data()->paintOpSize();
-    }
-    return QSizeF(1.0, 1.0);
-}
-
 void KisPaintOpSettings::setPaintOpOpacity(qreal value)
 {
     setProperty("OpacityValue", value);
 }
 
 void KisPaintOpSettings::setPaintOpFlow(qreal value)
 {
     setProperty("FlowValue", value);
 }
 
 void KisPaintOpSettings::setPaintOpCompositeOp(const QString &value)
 {
     setProperty("CompositeOp", value);
 }
 
 qreal KisPaintOpSettings::paintOpOpacity() const
 {
     return getDouble("OpacityValue", 1.0);
 }
 
 qreal KisPaintOpSettings::paintOpFlow() const
 {
     return getDouble("FlowValue", 1.0);
 }
 
+void KisPaintOpSettings::setPaintOpSize(qreal value)
+{
+    if (d->settingsWidget) {
+        const qreal sizeDiff = value - paintOpSize();
+
+        {
+            KisSignalsBlocker b(d->settingsWidget);
+            d->settingsWidget.data()->setConfigurationSafe(this);
+            d->settingsWidget.data()->changePaintOpSize(sizeDiff, 0);
+        }
+        d->settingsWidget.data()->writeConfigurationSafe(this);
+    }
+}
+
+qreal KisPaintOpSettings::paintOpSize() const
+{
+    qreal size = 1.0;
+
+    if (d->settingsWidget) {
+        size = d->settingsWidget.data()->paintOpSize().width();
+    }
+
+    return size;
+}
+
 QString KisPaintOpSettings::paintOpCompositeOp() const
 {
     return getString("CompositeOp", COMPOSITE_OVER);
 }
 
 void KisPaintOpSettings::setEraserMode(bool value)
 {
     setProperty("EraserMode", value);
 }
 
 bool KisPaintOpSettings::eraserMode() const
 {
     return getBool("EraserMode", false);
 }
 
 QString KisPaintOpSettings::effectivePaintOpCompositeOp() const
 {
     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");
 }
 
 
 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;
 }
 
 QPainterPath KisPaintOpSettings::brushOutline(const KisPaintInformation &info, OutlineMode mode) const
 {
     QPainterPath path;
     if (mode == CursorIsOutline || mode == CursorIsCircleOutline || mode == CursorTiltOutline) {
         path = ellipseOutline(10, 10, 1.0, 0);
         
         if (mode == CursorTiltOutline) {
             QPainterPath tiltLine;
             QLineF tiltAngle(QPointF(0.0,0.0), QPointF(0.0,3.0));
             tiltAngle.setLength(50.0 * (1 - info.tiltElevation(info, 60.0, 60.0, true)));
             tiltAngle.setAngle((360.0 - fmod(KisPaintInformation::tiltDirection(info, true) * 360.0 + 270.0, 360.0))-2.0);
             tiltLine.moveTo(tiltAngle.p1());
             tiltLine.lineTo(tiltAngle.p2());
             tiltAngle.setAngle((360.0 - fmod(KisPaintInformation::tiltDirection(info, true) * 360.0 + 270.0, 360.0))+2.0);
             tiltLine.lineTo(tiltAngle.p2());
             tiltLine.lineTo(tiltAngle.p1());
             path.addPath(tiltLine);
         }
 
         path.translate(info.pos());
     }
 
     return path;
 }
 
 QPainterPath KisPaintOpSettings::ellipseOutline(qreal width, qreal height, qreal scale, qreal rotation) const
 {
     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;
 }
 
 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 && this->preset()) {
 
         this->preset()->setPresetDirty(true);
     }
 
     KisPropertiesConfiguration::setProperty(name, value);
     onPropertyChanged();
 }
 
 
 void KisPaintOpSettings::onPropertyChanged()
 {
-    if (d->updateProxy) {
-        d->updateProxy->notifySettingsChanged();
+    KisPaintopSettingsUpdateProxy *proxy = d->updateProxyNoCreate();
+
+    if (proxy) {
+        proxy->notifySettingsChanged();
     }
 }
 
 bool KisPaintOpSettings::isLodUserAllowed(const KisPropertiesConfiguration *config)
 {
     return config->getBool("lodUserAllowed", true);
 }
 
 void KisPaintOpSettings::setLodUserAllowed(KisPropertiesConfiguration *config, bool value)
 {
     config->setProperty("lodUserAllowed", value);
 }
 
-KisPaintopSettingsUpdateProxy* KisPaintOpSettings::updateProxy() const
-{
-    if (!d->updateProxy) {
-        d->updateProxy.reset(new KisPaintopSettingsUpdateProxy());
-    }
-    return d->updateProxy.data();
-}
-
-#include "kis_callback_based_paintop_property.h"
-#include "kis_slider_based_paintop_property.h"
+#include "kis_standard_uniform_properties_factory.h"
 
 QList<KisUniformPaintOpPropertySP> KisPaintOpSettings::uniformProperties()
 {
-    if (0 && d->uniformProperties.isEmpty()) {
-        typedef KisCallbackBasedPaintopProperty<KisIntSliderBasedPaintOpProperty> IntSliderProp;
-        typedef KisCallbackBasedPaintopProperty<KisDoubleSliderBasedPaintOpProperty> DoubleSliderProp;
-
-        DoubleSliderProp *prop =
-            new DoubleSliderProp(DoubleSliderProp::Double,
-                                 "opacity",
-                                 i18n("Opacity"),
-                                 this, 0);
-        prop->setRange(0.0, 1.0);
-        prop->setSingleStep(0.01);
-
-        prop->setReadCallback(
-            [](KisUniformPaintOpProperty *prop) {
-                prop->setValue(prop->settings()->paintOpOpacity());
-            });
-        prop->setWriteCallback(
-            [](KisUniformPaintOpProperty *prop) {
-                prop->settings()->setPaintOpOpacity(prop->value().toReal());
-            });
-
-        QObject::connect(updateProxy(), SIGNAL(sigSettingsChanged()), prop, SLOT(requestReadValue()));
-        prop->requestReadValue();
-        d->uniformProperties.append(toQShared(prop));
+    QList<KisUniformPaintOpPropertySP> props =
+        listWeakToStrong(d->uniformProperties);
+
+
+    if (props.isEmpty()) {
+        using namespace KisStandardUniformPropertiesFactory;
+
+        props.append(createProperty(opacity, this, d->updateProxyCreate()));
+        props.append(createProperty(size, this, d->updateProxyCreate()));
+        props.append(createProperty(flow, this, d->updateProxyCreate()));
+
+        d->uniformProperties = listStrongToWeak(props);
     }
 
-    return d->uniformProperties;
+    return props;
 }
diff --git a/libs/image/brushengine/kis_paintop_settings.h b/libs/image/brushengine/kis_paintop_settings.h
index e7bb954bdf..35b871875a 100644
--- a/libs/image/brushengine/kis_paintop_settings.h
+++ b/libs/image/brushengine/kis_paintop_settings.h
@@ -1,271 +1,264 @@
 /*
  *  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_shared.h"
 #include "kis_properties_configuration.h"
 #include <brushengine/kis_paint_information.h>
 #include <brushengine/kis_uniform_paintop_property.h>
 
 
 
 class KisPaintOpConfigWidget;
 class KisPaintopSettingsUpdateProxy;
 
 /**
  * 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 KisShared
 {
 
 public:
 
     KisPaintOpSettings();
 
     virtual ~KisPaintOpSettings();
 
     /**
      *
      */
     virtual 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 &pos, Qt::KeyboardModifiers modifiers, KisNodeWSP currentNode);
 
     /**
      * 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();
 
     /**
      * Clone the current settings object. Override this if your settings instance doesn't
      * store everything as properties.
      */
     virtual KisPaintOpSettingsSP clone() const;
 
     /**
      * @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.
      */
     virtual bool isAirbrushing() const {
         return false;
     }
 
     /**
     * If this paintop deposit the paint even when not moving, the tool needs to know the rate of it in miliseconds
     */
     virtual int rate() const {
         return 100;
     }
 
     /**
      * 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) const;
 
     /**
     * Useful for simple elliptical brush outline.
     */
     QPainterPath ellipseOutline(qreal width, qreal height, qreal scale, qreal rotation) const;
 
-    /**
-     * The behaviour might be different per paintop. Most of the time
-     * the brush diameter is increased by x pixels, y ignored
-     *
-     * @param x is add to the diameter or radius (according the paintop)
-     *  It might be also negative, to decrease the value of the brush diameter/radius.
-     *  x is in pixels
-     * @param y is unused, it supposed to be used to change some different attribute
-     * of the brush like softness or density
-     */
-    virtual void changePaintOpSize(qreal x, qreal y);
-
-    /**
-     * @return The width and the height of the brush mask/dab in pixels
-     */
-    virtual QSizeF paintOpSize() const;
-
     /**
      * 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() const;
 
     /**
      * @return flow saved in the properties
      */
     qreal paintOpFlow() const;
 
     /**
      * @return composite mode saved in the properties
      */
     QString paintOpCompositeOp() const;
 
+    /**
+     * Set paintop size directly in the properties
+     */
+    void setPaintOpSize(qreal value);
+
+    /**
+     * @return size saved in the properties
+     */
+    qreal paintOpSize() const;
+
     void setEraserMode(bool value);
     bool eraserMode() const;
 
     qreal savedEraserSize() const;
     void setSavedEraserSize(qreal value);
     qreal savedBrushSize() const;
     void setSavedBrushSize(qreal value);
 
     QString effectivePaintOpCompositeOp() const;
 
     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);
 
-    KisPaintopSettingsUpdateProxy* updateProxy() const;
     virtual QList<KisUniformPaintOpPropertySP> uniformProperties();
 
     static bool isLodUserAllowed(const KisPropertiesConfiguration *config);
     static void setLodUserAllowed(KisPropertiesConfiguration *config, bool value);
 
-protected:
     /**
     * @return the option widget of the paintop (can be 0 is no option widgets is set)
     */
     KisPaintOpConfigWidget* optionsWidget() 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/brushengine/kis_paintop_settings_update_proxy.cpp b/libs/image/brushengine/kis_paintop_settings_update_proxy.cpp
index d1ed5719ce..421e23b3d3 100644
--- a/libs/image/brushengine/kis_paintop_settings_update_proxy.cpp
+++ b/libs/image/brushengine/kis_paintop_settings_update_proxy.cpp
@@ -1,44 +1,49 @@
 /*
  *  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_paintop_settings_update_proxy.h"
 
 #include "kis_signal_compressor.h"
 
 
 struct KisPaintopSettingsUpdateProxy::Private
 {
     Private() : updatesCompressor(100, KisSignalCompressor::FIRST_ACTIVE) {}
     KisSignalCompressor updatesCompressor;
 };
 
 KisPaintopSettingsUpdateProxy::KisPaintopSettingsUpdateProxy(QObject *parent)
     : QObject(parent),
       m_d(new Private)
 {
     connect(&m_d->updatesCompressor, SIGNAL(timeout()), SIGNAL(sigSettingsChanged()));
 }
 
 KisPaintopSettingsUpdateProxy::~KisPaintopSettingsUpdateProxy()
 {
 }
 
 void KisPaintopSettingsUpdateProxy::notifySettingsChanged()
 {
     m_d->updatesCompressor.start();
 }
+
+void KisPaintopSettingsUpdateProxy::notifyUniformPropertiesChanged()
+{
+    emit sigUniformPropertiesChanged();
+}
diff --git a/libs/image/brushengine/kis_paintop_settings_update_proxy.h b/libs/image/brushengine/kis_paintop_settings_update_proxy.h
index 8336ee5afa..bcaf996dec 100644
--- a/libs/image/brushengine/kis_paintop_settings_update_proxy.h
+++ b/libs/image/brushengine/kis_paintop_settings_update_proxy.h
@@ -1,44 +1,46 @@
 /*
  *  Copyright (c) 2016 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KIS_PAINTOP_SETTINGS_UPDATE_PROXY_H
 #define __KIS_PAINTOP_SETTINGS_UPDATE_PROXY_H
 
 #include <QScopedPointer>
 #include <QObject>
 
 
 class KisPaintopSettingsUpdateProxy : public QObject
 {
     Q_OBJECT
 
 public:
     KisPaintopSettingsUpdateProxy(QObject *parent = 0);
     ~KisPaintopSettingsUpdateProxy();
 
     void notifySettingsChanged();
+    void notifyUniformPropertiesChanged();
 
 Q_SIGNALS:
     void sigSettingsChanged();
+    void sigUniformPropertiesChanged();
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 #endif /* __KIS_PAINTOP_SETTINGS_UPDATE_PROXY_H */
diff --git a/libs/image/brushengine/kis_slider_based_paintop_property.h b/libs/image/brushengine/kis_slider_based_paintop_property.h
index 0d7780be8d..0ca7325476 100644
--- a/libs/image/brushengine/kis_slider_based_paintop_property.h
+++ b/libs/image/brushengine/kis_slider_based_paintop_property.h
@@ -1,107 +1,112 @@
 /*
  *  Copyright (c) 2016 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KIS_SLIDER_BASED_PAINTOP_PROPERTY_H
 #define __KIS_SLIDER_BASED_PAINTOP_PROPERTY_H
 
 #include <QScopedPointer>
 #include "kis_uniform_paintop_property.h"
 
 
 template <typename T>
 class KisSliderBasedPaintOpProperty : public KisUniformPaintOpProperty
 {
 public:
     KisSliderBasedPaintOpProperty(Type type,
                                   const QString &id,
                                   const QString &name,
                                   KisPaintOpSettingsSP settings,
                                   QObject *parent)
         : KisUniformPaintOpProperty(type, id, name, settings, parent),
         m_min(T(0)),
         m_max(T(100)),
         m_singleStep(T(1)),
         m_pageStep(T(10)),
         m_exponentRatio(1.0),
         m_decimals(2)
     {
     }
 
     T min() const {
         return m_min;
     }
     T max() const {
         return m_max;
     }
     void setRange(T min, T max) {
         m_min = min;
         m_max = max;
     }
 
     T singleStep() const {
         return m_singleStep;
     }
     void setSingleStep(T value) {
         m_singleStep = value;
     }
 
     T pageStep() const {
         return m_pageStep;
     }
     void setPageStep(T value) {
         m_pageStep = value;
     }
 
     qreal exponentRatio() const {
         return m_exponentRatio;
     }
     void setExponentRatio(qreal value) {
         m_exponentRatio = value;
     }
 
     int decimals() const {
         return m_decimals;
     }
     void setDecimals(int value) {
         m_decimals = value;
     }
 
     QString suffix() const {
         return m_suffix;
     }
     void setSuffix(QString value) {
         m_suffix = value;
     }
 
 
 private:
     T m_min;
     T m_max;
 
     T m_singleStep;
     T m_pageStep;
     qreal m_exponentRatio;
 
     int m_decimals;
     QString m_suffix;
 };
 
 typedef KisSliderBasedPaintOpProperty<int> KisIntSliderBasedPaintOpProperty;
 typedef KisSliderBasedPaintOpProperty<qreal> KisDoubleSliderBasedPaintOpProperty;
 
+#include "kis_callback_based_paintop_property.h"
+
+typedef KisCallbackBasedPaintopProperty<KisIntSliderBasedPaintOpProperty> KisIntSliderBasedPaintOpPropertyCallback;
+typedef KisCallbackBasedPaintopProperty<KisDoubleSliderBasedPaintOpProperty> KisDoubleSliderBasedPaintOpPropertyCallback;
+
 #endif /* __KIS_SLIDER_BASED_PAINTOP_PROPERTY_H */
diff --git a/libs/image/brushengine/kis_standard_uniform_properties_factory.cpp b/libs/image/brushengine/kis_standard_uniform_properties_factory.cpp
new file mode 100644
index 0000000000..839f303f00
--- /dev/null
+++ b/libs/image/brushengine/kis_standard_uniform_properties_factory.cpp
@@ -0,0 +1,123 @@
+/*
+ *  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_standard_uniform_properties_factory.h"
+
+#include "kis_slider_based_paintop_property.h"
+#include "kis_paintop_settings.h"
+#include "kis_paintop_settings_update_proxy.h"
+
+namespace KisStandardUniformPropertiesFactory {
+
+    KisUniformPaintOpPropertySP createProperty(const KoID &id,
+                                               KisPaintOpSettingsSP settings,
+                                               KisPaintopSettingsUpdateProxy *updateProxy)
+    {
+        return createProperty(id.id(), settings, updateProxy);
+    }
+
+    KisUniformPaintOpPropertySP createProperty(const QString &id,
+                                               KisPaintOpSettingsSP settings,
+                                               KisPaintopSettingsUpdateProxy *updateProxy)
+    {
+        KisUniformPaintOpPropertySP result;
+
+
+        if (id == size.id()) {
+            KisDoubleSliderBasedPaintOpPropertyCallback *prop =
+                new KisDoubleSliderBasedPaintOpPropertyCallback(
+                    KisDoubleSliderBasedPaintOpPropertyCallback::Double,
+                    "size",
+                    i18n("Size"),
+                    settings, 0);
+
+            prop->setRange(0, 1000);
+            prop->setDecimals(2);
+            prop->setSingleStep(1);
+            prop->setExponentRatio(3.0);
+            prop->setSuffix(i18n(" px"));
+
+            prop->setReadCallback(
+                [](KisUniformPaintOpProperty *prop) {
+                    prop->setValue(prop->settings()->paintOpSize());
+                });
+            prop->setWriteCallback(
+                [](KisUniformPaintOpProperty *prop) {
+                    prop->settings()->setPaintOpSize(prop->value().toReal());
+                });
+
+            QObject::connect(updateProxy, SIGNAL(sigSettingsChanged()), prop, SLOT(requestReadValue()));
+            prop->requestReadValue();
+            result = toQShared(prop);
+        } else if (id == opacity.id()) {
+            KisDoubleSliderBasedPaintOpPropertyCallback *prop =
+                new KisDoubleSliderBasedPaintOpPropertyCallback(
+                    KisDoubleSliderBasedPaintOpPropertyCallback::Double,
+                    opacity.id(),
+                    opacity.name(),
+                    settings, 0);
+
+            prop->setRange(0.0, 1.0);
+            prop->setSingleStep(0.01);
+
+            prop->setReadCallback(
+                [](KisUniformPaintOpProperty *prop) {
+                    prop->setValue(prop->settings()->paintOpOpacity());
+                });
+            prop->setWriteCallback(
+                [](KisUniformPaintOpProperty *prop) {
+                    prop->settings()->setPaintOpOpacity(prop->value().toReal());
+                });
+
+            QObject::connect(updateProxy, SIGNAL(sigSettingsChanged()), prop, SLOT(requestReadValue()));
+            prop->requestReadValue();
+            result = toQShared(prop);
+        } else if (id == flow.id()) {
+            KisDoubleSliderBasedPaintOpPropertyCallback *prop =
+                new KisDoubleSliderBasedPaintOpPropertyCallback(
+                    KisDoubleSliderBasedPaintOpPropertyCallback::Double,
+                    flow.id(),
+                    flow.name(),
+                    settings, 0);
+
+            prop->setRange(0.0, 1.0);
+            prop->setSingleStep(0.01);
+
+            prop->setReadCallback(
+                [](KisUniformPaintOpProperty *prop) {
+                    prop->setValue(prop->settings()->paintOpFlow());
+                });
+            prop->setWriteCallback(
+                [](KisUniformPaintOpProperty *prop) {
+                    prop->settings()->setPaintOpFlow(prop->value().toReal());
+                });
+
+            QObject::connect(updateProxy, SIGNAL(sigSettingsChanged()), prop, SLOT(requestReadValue()));
+            prop->requestReadValue();
+            result = toQShared(prop);
+        } else if (id == angle.id()) {
+        } else if (id == spacing.id()) {
+        }
+
+        if (!result) {
+            KIS_SAFE_ASSERT_RECOVER_NOOP(0 && "Unknown Uniform property id!");
+        }
+
+        return result;
+    }
+}
diff --git a/libs/image/brushengine/kis_standard_uniform_properties_factory.h b/libs/image/brushengine/kis_standard_uniform_properties_factory.h
new file mode 100644
index 0000000000..6025a947e1
--- /dev/null
+++ b/libs/image/brushengine/kis_standard_uniform_properties_factory.h
@@ -0,0 +1,44 @@
+/*
+ *  Copyright (c) 2016 Dmitry Kazakov <dimula73@gmail.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __KIS_STANDARD_UNIFORM_PROPERTIES_FACTORY_H
+#define __KIS_STANDARD_UNIFORM_PROPERTIES_FACTORY_H
+
+#include <KoID.h>
+
+#include "kis_uniform_paintop_property.h"
+
+class KisPaintopSettingsUpdateProxy;
+
+namespace KisStandardUniformPropertiesFactory
+{
+    static const KoID size("size", i18n("Size"));
+    static const KoID opacity("opacity", i18n("Opacity"));
+    static const KoID flow("flow", i18n("Flow"));
+    static const KoID angle("angle", i18n("Angle"));
+    static const KoID spacing("spacing", i18n("Spacing"));
+
+    KisUniformPaintOpPropertySP createProperty(const KoID &id,
+                                               KisPaintOpSettingsSP settings,
+                                               KisPaintopSettingsUpdateProxy *updateProxy);
+    KisUniformPaintOpPropertySP createProperty(const QString &id,
+                                               KisPaintOpSettingsSP settings,
+                                               KisPaintopSettingsUpdateProxy *updateProxy);
+}
+
+#endif /* __KIS_STANDARD_UNIFORM_PROPERTIES_FACTORY_H */
diff --git a/libs/image/brushengine/kis_uniform_paintop_property.cpp b/libs/image/brushengine/kis_uniform_paintop_property.cpp
index c767873ea8..21a2fb9373 100644
--- a/libs/image/brushengine/kis_uniform_paintop_property.cpp
+++ b/libs/image/brushengine/kis_uniform_paintop_property.cpp
@@ -1,118 +1,118 @@
 /*
  *  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_uniform_paintop_property.h"
 
 #include <QVariant>
 #include "kis_debug.h"
 #include "kis_paintop_settings.h"
 
 struct KisUniformPaintOpProperty::Private
 {
     Private(Type _type,
             const QString &_id,
             const QString &_name,
             KisPaintOpSettingsSP _settings)
         : type(_type),
           id(_id),
           name(_name),
           settings(_settings),
           isReadingValue(false) {}
 
     Type type;
     QString id;
     QString name;
 
     QVariant value;
 
+    KisPaintOpSettingsSP settings;
     bool isReadingValue;
-    KisWeakSharedPtr<KisPaintOpSettings> settings;
 };
 
 KisUniformPaintOpProperty::KisUniformPaintOpProperty(Type type,
                                                      const QString &id,
                                                      const QString &name,
                                                      KisPaintOpSettingsSP settings,
                                                      QObject *parent)
     : QObject(parent),
       m_d(new Private(type, id, name, settings))
 {
 }
 
 KisUniformPaintOpProperty::~KisUniformPaintOpProperty()
 {
 }
 
 QString KisUniformPaintOpProperty::id() const
 {
     return m_d->id;
 }
 
 QString KisUniformPaintOpProperty::name() const
 {
     return m_d->name;
 }
 
 KisUniformPaintOpProperty::Type KisUniformPaintOpProperty::type() const
 {
     return m_d->type;
 }
 
 QVariant KisUniformPaintOpProperty::value() const
 {
     return m_d->value;
 }
 
 QWidget *KisUniformPaintOpProperty::createPropertyWidget()
 {
     return 0;
 }
 
 void KisUniformPaintOpProperty::setValue(const QVariant &value)
 {
     if (m_d->value == value) return;
     m_d->value = value;
 
     emit valueChanged(value);
 
     if (!m_d->isReadingValue) {
         writeValueImpl();
     }
 }
 
 void KisUniformPaintOpProperty::requestReadValue()
 {
     m_d->isReadingValue = true;
     readValueImpl();
     m_d->isReadingValue = false;
 }
 
 KisPaintOpSettingsSP KisUniformPaintOpProperty::settings()
 {
     // correct conversion weak-to-strong shared pointer
     return m_d->settings ? m_d->settings : 0;
 }
 
 void KisUniformPaintOpProperty::readValueImpl()
 {
 }
 
 void KisUniformPaintOpProperty::writeValueImpl()
 {
 }
 
diff --git a/libs/image/kis_signal_auto_connection.h b/libs/image/kis_signal_auto_connection.h
index b9dd59a6e1..60a32dfb07 100644
--- a/libs/image/kis_signal_auto_connection.h
+++ b/libs/image/kis_signal_auto_connection.h
@@ -1,131 +1,133 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KIS_SIGNAL_AUTO_CONNECTOR_H
 #define __KIS_SIGNAL_AUTO_CONNECTOR_H
 
 #include <QObject>
 #include <QPointer>
+#include <QVector>
+
 
 /**
  * A special wrapper class that represents a connection between two QObject objects.
  * It creates the connection on the construction and disconnects it on destruction.
  *
  * WARNING: never use QScopedPointer::reset() for updating the
  *          connection like:
  *
  * QScopedPointer<KisSignalAutoConnection> conn;
  * ...
  * void Something::setCanvas(KoCanvasBase * canvas) {
  *     conn.reset(new KisSignalAutoConnection(...));
  * }
  *
  * The object stored in a scoped pointer will be destructed *after*
  * the new object created which will cause you object to become
  * disconnected.
  *
  * Intead use two-stage updates:
  * conn.reset();
  * conn.reset(new KisSignalAutoConnection(...));
  */
 class KisSignalAutoConnection
 {
 public:
     /**
      * Creates a connection object and starts the requested connection
      */
     inline KisSignalAutoConnection(const QObject *sender, const char *signal,
                                   const QObject *receiver, const char *method,
                                   Qt::ConnectionType type = Qt::AutoConnection)
         : m_sender(const_cast<QObject*>(sender)),
           m_signal(signal),
           m_receiver(const_cast<QObject*>(receiver)),
           m_method(method)
     {
         QObject::connect(m_sender, m_signal, m_receiver, m_method, type);
     }
     inline ~KisSignalAutoConnection()
     {
         if (!m_sender.isNull() && !m_receiver.isNull()) {
             QObject::disconnect(m_sender, m_signal, m_receiver, m_method);
         }
     }
 
 private:
     KisSignalAutoConnection(const KisSignalAutoConnection &rhs);
 
 private:
     QPointer<QObject> m_sender;
     const char *m_signal;
     QPointer<QObject> m_receiver;
     const char *m_method;
 };
 
 typedef QSharedPointer<KisSignalAutoConnection> KisSignalAutoConnectionSP;
 
 
 /**
  * A class to store multiple connections and to be able to stop all of
  * them at once. It is handy when you need to reconnect some other
  * object to the current manager. Then you just call
  * connectionsStore.clear() and then call addConnection() again to
  * recreate them.
  */
 class KisSignalAutoConnectionsStore
 {
 public:
     /**
      * Connects \p sender to \p reciever with a connection of type \p type.
      * The connection is saved into the store so can be reset later with clear()
      *
      * \see addUniqueConnection()
      */
     inline void addConnection(const QObject *sender, const char *signal,
                               const QObject *receiver, const char *method,
                               Qt::ConnectionType type = Qt::AutoConnection)
     {
         m_connections.append(KisSignalAutoConnectionSP(
                                  new KisSignalAutoConnection(sender, signal,
                                                              receiver, method, type)));
     }
 
     /**
      * Convenience override for addConnection() that creates a unique connection
      *
      * \see addConnection()
      */
     inline void addUniqueConnection(const QObject *sender, const char *signal,
                                     const QObject *receiver, const char *method)
     {
         m_connections.append(KisSignalAutoConnectionSP(
                                  new KisSignalAutoConnection(sender, signal,
                                                              receiver, method, Qt::UniqueConnection)));
     }
 
     /**
      * Disconnects all the stored connections and removes them from the store
      */
     inline void clear() {
         m_connections.clear();
     }
 
 private:
     QVector<KisSignalAutoConnectionSP> m_connections;
 };
 
 #endif /* __KIS_SIGNAL_AUTO_CONNECTOR_H */
diff --git a/libs/ui/KisViewManager.cpp b/libs/ui/KisViewManager.cpp
index bf410d71e0..4cfc936128 100644
--- a/libs/ui/KisViewManager.cpp
+++ b/libs/ui/KisViewManager.cpp
@@ -1,1250 +1,1253 @@
 /*
  *  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>
  *
  *  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 <QDesktopServices>
 #include <QDesktopWidget>
 #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 "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 "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_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 "kis_painting_assistants_manager.h"
 #include <kis_paint_layer.h>
 #include "kis_paintop_box.h"
 #include <brushengine/kis_paintop_preset.h>
 #include "KisPart.h"
 #include "KisPrintJob.h"
 #include "kis_progress_widget.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 "kra/kis_kra_loader.h"
 #include "widgets/kis_floating_message.h"
 #include "kis_signal_auto_connection.h"
 #include "kis_icon_utils.h"
 #include "kis_guides_manager.h"
 #include "kis_derived_resources.h"
 
 
 class BlockingUserInputEventFilter : public QObject
 {
     bool eventFilter(QObject *watched, QEvent *event)
     {
         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, 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)
         , mainWindow(0)
         , showFloatingMessage(true)
         , currentImageView(0)
         , canvasResourceProvider(_q)
         , canvasResourceManager()
         , guiUpdateCompressor(30, KisSignalCompressor::POSTPONE, _q)
         , mirrorManager(_q)
         , inputManager(_q)
         , actionAuthor(0)
     {
         canvasResourceManager.addDerivedResourceConverter(toQShared(new KisCompositeOpResourceConverter));
         canvasResourceManager.addDerivedResourceConverter(toQShared(new KisEffectiveCompositeOpResourceConverter));
         canvasResourceManager.addDerivedResourceConverter(toQShared(new KisOpacityResourceConverter));
+        canvasResourceManager.addDerivedResourceConverter(toQShared(new KisFlowResourceConverter));
+        canvasResourceManager.addDerivedResourceConverter(toQShared(new KisSizeResourceConverter));
         canvasResourceManager.addDerivedResourceConverter(toQShared(new KisLodAvailabilityResourceConverter));
         canvasResourceManager.addDerivedResourceConverter(toQShared(new KisEraserModeResourceConverter));
+        canvasResourceManager.addResourceUpdateMediator(toQShared(new KisPresetUpdateMediator));
     }
 
 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;
 
     KisControlFrame controlFrame;
     KisNodeManager nodeManager;
     KisImageManager imageManager;
     KisGridManager gridManager;
     KisCanvasControlsManager canvasControlsManager;
     KisPaintingAssistantsManager 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;
     KSelectAction *actionAuthor; // Select action for author profile.
 
     QByteArray canvasState;
 };
 
 
 KisViewManager::KisViewManager(QWidget *parent, KActionCollection *_actionCollection)
     : d(new KisViewManagerPrivate(this, 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->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()));
 
     KisInputProfileManager::instance()->loadProfiles();
 
     KisConfig cfg;
     d->showFloatingMessage = cfg.showCanvasMessages();
 
 }
 
 
 KisViewManager::~KisViewManager()
 {
     KisConfig cfg;
     if (resourceProvider() && resourceProvider()->currentPreset()) {
         cfg.writeEntry("LastPreset", resourceProvider()->currentPreset()->name());
     }
     cfg.writeEntry("baseLength", KoResourceItemChooserSync::instance()->baseLength());
 
     delete d;
 }
 
 KActionCollection *KisViewManager::actionCollection() const
 {
     return d->actionCollection;
 }
 
 void KisViewManager::slotViewAdded(KisView *view)
 {
     d->inputManager.addTrackedCanvas(view->canvasBase());
 
     if (viewCount() == 0) {
         d->statusBar.showAllStatusBarItems();
     }
 }
 
 void KisViewManager::slotViewRemoved(KisView *view)
 {
     d->inputManager.removeTrackedCanvas(view->canvasBase());
 
     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->disconnect(this);
         }
         d->currentImageView->canvasController()->proxyObject->disconnect(&d->statusBar);
         d->viewConnections.clear();
     }
 
     // Restore the last used brush preset
     if (first) {
         KisConfig cfg;
         KisPaintOpPresetResourceServer * rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
         QString lastPreset = cfg.readEntry("LastPreset", QString("Basic_tip_default"));
         KisPaintOpPresetSP preset = rserver->resourceByName(lastPreset);
         if (!preset) {
             preset = rserver->resourceByName("Basic_tip_default");
         }
 
         if (!preset) {
             preset = rserver->resources().first();
         }
         if (preset) {
             paintOpBox()->restoreResource(preset.data());
         }
 
     }
 
     d->softProof->setChecked(view->softProofing());
     d->gamutCheck->setChecked(view->gamutCheck());
 
     QPointer<KisView>imageView = qobject_cast<KisView*>(view);
 
     if (imageView) {
         // Wait for the async image to have loaded
         KisDocument* doc = view->document();
         //        connect(canvasController()->proxyObject, SIGNAL(documentMousePositionChanged(QPointF)), d->statusBar, SLOT(documentMousePositionChanged(QPointF)));
 
         d->currentImageView = imageView;
         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)) );
 
         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->actionManager.updateGUI();
 
     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(
         view->zoomManager()->zoomController(),
         SIGNAL(zoomChanged(KoZoomMode::Mode,qreal)),
         resourceProvider(), SLOT(slotOnScreenResolutionChanged()));
 
     resourceProvider()->slotImageSizeChanged();
     resourceProvider()->slotOnScreenResolutionChanged();
 }
 
 
 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();
 }
 
 KoProgressUpdater* KisViewManager::createProgressUpdater(KoProgressUpdater::Mode mode)
 {
     return new KisProgressUpdater(d->statusBar.progress(), document()->progressProxy(), mode);
 }
 
 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()));
 
     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();
 
 }
 
 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());
 
 }
 
 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;
 }
 
 KisPaintingAssistantsManager* KisViewManager::paintingAssistantsManager() const
 {
     return &d->paintingAssistantsManager;
 }
 
 KisDocument *KisViewManager::document() const
 {
     if (d->currentImageView && d->currentImageView->document()) {
         return d->currentImageView->document();
     }
     return 0;
 }
 
 int KisViewManager::viewCount() const
 {
     KisMainWindow *mw  = qobject_cast<KisMainWindow*>(d->mainWindow);
     if (mw) {
         return mw->viewCount();
     }
     return 0;
 }
 
 void KisViewManager::slotCreateTemplate()
 {
     if (!document()) return;
     KisTemplateCreateDia::createTemplate( QStringLiteral("templates/"), ".kra", document(), mainWindow());
 }
 
 void KisViewManager::slotCreateCopy()
 {
     if (!document()) return;
     KisDocument *doc = KisPart::instance()->createDocument();
 
     QString name = document()->documentInfo()->aboutInfo("name");
     if (name.isEmpty()) {
         name = document()->url().toLocalFile();
     }
     name = i18n("%1 (Copy)", name);
     doc->documentInfo()->setAboutInfo("title", name);
     KisImageWSP image = document()->image();
     KisImageSP newImage = new KisImage(doc->createUndoStore(), image->width(), image->height(), image->colorSpace(), name);
     newImage->setRootLayer(dynamic_cast<KisGroupLayer*>(image->rootLayer()->clone().data()));
     doc->setCurrentImage(newImage);
     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;
 
     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 {
         // ...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()->setFileBatchMode(false);
 
     if (mainWindow()) {
         mainWindow()->updateCaption();
     }
 
 }
 
 void KisViewManager::slotSaveIncrementalBackup()
 {
     if (!document()) 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));
 
         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()->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 (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"));
         action->setCheckable(true);
         if (action && action->isChecked() == toggled) {
             action->setChecked(!toggled);
         }
     }
 
     if (cfg.hideTitlebarFullscreen() && !cfg.fullscreenMode()) {
         if(toggled) {
             main->setWindowState( main->windowState() | Qt::WindowFullScreen);
         } else {
             main->setWindowState( main->windowState() & ~Qt::WindowFullScreen);
         }
     }
 
     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()) {
         appAuthorGroup.writeEntry("active-profile", "");
     } else if (profileName == i18nc("choice for author profile", "Anonymous")) {
         appAuthorGroup.writeEntry("active-profile", "anonymous");
     } 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(i18n("Default Author Profile"));
     d->actionAuthor->addAction(i18nc("choice for author profile", "Anonymous"));
 
     KConfigGroup authorGroup(KoGlobal::calligraConfig(), "Author");
     QStringList profiles = authorGroup.readEntry("profile-names", QStringList());
     Q_FOREACH (const QString &profile , profiles) {
         d->actionAuthor->addAction(profile);
     }
 
     KConfigGroup appAuthorGroup(KoGlobal::calligraConfig(), "Author");
     QString profileName = appAuthorGroup.readEntry("active-profile", "");
 
     if (profileName == "anonymous") {
         d->actionAuthor->setCurrentItem(1);
     } else if (profiles.contains(profileName)) {
         d->actionAuthor->setCurrentAction(profileName);
     } else {
         d->actionAuthor->setCurrentItem(0);
     }
 }
 
 
diff --git a/libs/ui/brushhud/kis_brush_hud.cpp b/libs/ui/brushhud/kis_brush_hud.cpp
index 697c5d90f3..065857b744 100644
--- a/libs/ui/brushhud/kis_brush_hud.cpp
+++ b/libs/ui/brushhud/kis_brush_hud.cpp
@@ -1,169 +1,196 @@
 /*
  *  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_brush_hud.h"
 
 #include <QVBoxLayout>
 #include <QPointer>
 #include <QLabel>
 #include <QPainter>
 #include <QPaintEvent>
 #include <QScrollArea>
 #include <QEvent>
 
 #include "kis_uniform_paintop_property.h"
 #include "kis_slider_based_paintop_property.h"
 #include "kis_uniform_paintop_property_widget.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_paintop_preset.h"
 #include "kis_paintop_settings.h"
 #include "kis_signal_auto_connection.h"
+#include "kis_paintop_settings_update_proxy.h"
 
 #include "kis_debug.h"
 
 
 struct KisBrushHud::Private
 {
     QPointer<QLabel> lblPresetName;
     QPointer<QWidget> wdgProperties;
     QPointer<QScrollArea> wdgPropertiesArea;
     QPointer<QVBoxLayout> propertiesLayout;
 
     KisCanvasResourceProvider *provider;
 
     KisSignalAutoConnectionsStore connections;
+    KisSignalAutoConnectionsStore presetConnections;
 
     KisPaintOpPresetSP currentPreset;
 };
 
 KisBrushHud::KisBrushHud(KisCanvasResourceProvider *provider, QWidget *parent)
     : QWidget(parent, Qt::FramelessWindowHint),
       m_d(new Private)
 {
     m_d->provider = provider;
 
     QVBoxLayout *layout = new QVBoxLayout(this);
     m_d->lblPresetName = new QLabel("<Preset Name>", this);
     layout->addWidget(m_d->lblPresetName);
 
     m_d->wdgPropertiesArea = new QScrollArea(this);
     m_d->wdgPropertiesArea->setAlignment(Qt::AlignLeft | Qt::AlignTop);
     m_d->wdgPropertiesArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
 
     m_d->wdgPropertiesArea->setWidgetResizable(true);
 
     m_d->wdgProperties = new QWidget(this);
     m_d->propertiesLayout = new QVBoxLayout(this);
     m_d->propertiesLayout->setSpacing(0);
     m_d->propertiesLayout->setContentsMargins(0, 0, 22, 0);
     m_d->propertiesLayout->setSizeConstraint(QLayout::SetMinAndMaxSize);
 
     // not adding any widgets until explicitly requested
 
     m_d->wdgProperties->setLayout(m_d->propertiesLayout);
     m_d->wdgPropertiesArea->setWidget(m_d->wdgProperties);
     layout->addWidget(m_d->wdgPropertiesArea);
 
     setLayout(layout);
     setCursor(Qt::ArrowCursor);
 }
 
 KisBrushHud::~KisBrushHud()
 {
 }
 
+void KisBrushHud::slotReloadProperties()
+{
+    m_d->presetConnections.clear();
+    clearProperties();
+    updateProperties();
+}
+
+void KisBrushHud::clearProperties() const
+{
+    Q_FOREACH (QWidget *w, m_d->wdgProperties->findChildren<QWidget*>()) {
+        w->deleteLater();
+    }
+    m_d->currentPreset.clear();
+}
+
 void KisBrushHud::updateProperties()
 {
     KisPaintOpPresetSP preset = m_d->provider->currentPreset();
     KisPaintOpSettingsSP settings = preset->settings();
 
     if (preset == m_d->currentPreset) return;
-    m_d->currentPreset = preset;
 
-    Q_FOREACH (QWidget *w, m_d->wdgProperties->findChildren<QWidget*>()) {
-        w->deleteLater();
-    }
+    m_d->presetConnections.clear();
+    clearProperties();
+
+    m_d->currentPreset = preset;
+    m_d->presetConnections.addConnection(
+        m_d->currentPreset->updateProxy(), SIGNAL(sigUniformPropertiesChanged()),
+        this, SLOT(slotReloadProperties()));
 
     m_d->lblPresetName->setText(preset->name());
 
     QList<KisUniformPaintOpPropertySP> properties = settings->uniformProperties();
     Q_FOREACH(auto property, properties) {
         QWidget *w = 0;
 
         if (property->type() == KisUniformPaintOpProperty::Int) {
             w = new KisUniformPaintOpPropertyIntSlider(property, m_d->wdgProperties);
         } else if (property->type() == KisUniformPaintOpProperty::Double) {
             w = new KisUniformPaintOpPropertyDoubleSlider(property, m_d->wdgProperties);
         }
 
         if (w) {
             w->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
             m_d->propertiesLayout->addWidget(w);
         }
     }
 }
 
 void KisBrushHud::showEvent(QShowEvent *event)
 {
     m_d->connections.clear();
     m_d->connections.addUniqueConnection(
         m_d->provider->resourceManager(), SIGNAL(canvasResourceChanged(int, QVariant)),
         this, SLOT(slotCanvasResourceChanged(int, QVariant)));
 
+    updateProperties();
+
     QWidget::showEvent(event);
 }
 
 void KisBrushHud::hideEvent(QHideEvent *event)
 {
     m_d->connections.clear();
     QWidget::hideEvent(event);
+
+    clearProperties();
 }
 
 void KisBrushHud::slotCanvasResourceChanged(int key, const QVariant &resource)
 {
-    if (key != KisCanvasResourceProvider::CurrentPaintOpPreset) return;
-    updateProperties();
+    Q_UNUSED(resource);
+
+    if (key == KisCanvasResourceProvider::CurrentPaintOpPreset) {
+        updateProperties();
+    }
 }
 
 void KisBrushHud::paintEvent(QPaintEvent *event)
 {
     QColor bgColor = palette().color(QPalette::Window);
 
     QPainter painter(this);
     painter.fillRect(rect() & event->rect(), bgColor);
     painter.end();
 
     QWidget::paintEvent(event);
 }
 
 bool KisBrushHud::event(QEvent *event)
 {
     switch (event->type()) {
     case QEvent::TabletPress:
     case QEvent::TabletMove:
     case QEvent::TabletRelease:
     case QEvent::MouseButtonPress:
     case QEvent::MouseMove:
     case QEvent::MouseButtonRelease:
     case QEvent::Wheel:
         event->accept();
         return true;
     }
 
     return QWidget::event(event);
 }
diff --git a/libs/ui/brushhud/kis_brush_hud.h b/libs/ui/brushhud/kis_brush_hud.h
index 077b6c838a..08ae1d497e 100644
--- a/libs/ui/brushhud/kis_brush_hud.h
+++ b/libs/ui/brushhud/kis_brush_hud.h
@@ -1,50 +1,54 @@
 /*
  *  Copyright (c) 2016 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KIS_BRUSH_HUD_H
 #define __KIS_BRUSH_HUD_H
 
 #include <QScopedPointer>
 #include <QWidget>
 
 class KisCanvasResourceProvider;
 
 class KisBrushHud : public QWidget
 {
     Q_OBJECT
 public:
     KisBrushHud(KisCanvasResourceProvider *provider, QWidget *parent);
     ~KisBrushHud();
 
     void updateProperties();
 
 protected:
     void paintEvent(QPaintEvent *event);
     bool event(QEvent *event);
     void showEvent(QShowEvent *event);
     void hideEvent(QHideEvent *event);
 
 private Q_SLOTS:
     void slotCanvasResourceChanged(int key, const QVariant &resource);
+    void slotReloadProperties();
+
+private:
+    void clearProperties() const;
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 #endif /* __KIS_BRUSH_HUD_H */
diff --git a/libs/ui/kis_canvas_resource_provider.cpp b/libs/ui/kis_canvas_resource_provider.cpp
index 54f97da4ae..84a4ba7ea9 100644
--- a/libs/ui/kis_canvas_resource_provider.cpp
+++ b/libs/ui/kis_canvas_resource_provider.cpp
@@ -1,524 +1,544 @@
 /*
  *  Copyright (c) 2006 Boudewijn Rempt  <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "kis_canvas_resource_provider.h"
 
 #include <QImage>
 #include <QPainter>
 
 #include <KoCanvasBase.h>
 #include <KoID.h>
 #include <KoColorModelStandardIds.h>
 #include <KoColorProfile.h>
 #include <resources/KoAbstractGradient.h>
 #include <KoCompositeOpRegistry.h>
 #include <KoResourceServerProvider.h>
 #include <resources/KoStopGradient.h>
 #include <KoColorSpaceRegistry.h>
 
 #include <resources/KoPattern.h>
 #include <kis_paint_device.h>
 #include <filter/kis_filter_configuration.h>
 #include <kis_image.h>
 #include <kis_group_layer.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <brushengine/kis_paintop_settings.h>
 #include "kis_favorite_resource_manager.h"
 
 #include "kis_config.h"
 #include "KisViewManager.h"
 #include "canvas/kis_canvas2.h"
 
 KisCanvasResourceProvider::KisCanvasResourceProvider(KisViewManager * view)
     : m_view(view)
 {
     m_fGChanged = true;
     m_enablefGChange = true;    // default to true, so that colour history is working without popup palette
 }
 
 KisCanvasResourceProvider::~KisCanvasResourceProvider()
 {
     disconnect(); // in case Qt gets confused
 }
 
 KoCanvasResourceManager* KisCanvasResourceProvider::resourceManager()
 {
     return m_resourceManager;
 }
 
 void KisCanvasResourceProvider::setResourceManager(KoCanvasResourceManager *resourceManager)
 {
     m_resourceManager = resourceManager;
 
     QVariant v;
     v.setValue(KoColor(Qt::black, KoColorSpaceRegistry::instance()->rgb8()));
     m_resourceManager->setResource(KoCanvasResourceManager::ForegroundColor, v);
 
     v.setValue(KoColor(Qt::white, KoColorSpaceRegistry::instance()->rgb8()));
     m_resourceManager->setResource(KoCanvasResourceManager::BackgroundColor, v);
 
     setCurrentCompositeOp(COMPOSITE_OVER);
 
     setMirrorHorizontal(false);
     setMirrorVertical(false);
 
     m_resourceManager->setResource(HdrExposure, 0.0);
     m_resourceManager->setResource(HdrGamma, 1.0);
     m_resourceManager->setResource(EffectiveZoom, 1.0);
 
     connect(m_resourceManager, SIGNAL(canvasResourceChanged(int,QVariant)),
             this, SLOT(slotCanvasResourceChanged(int,QVariant)));
 
     m_resourceManager->setResource(KoCanvasResourceManager::ApplicationSpeciality, KoCanvasResourceManager::NoAdvancedText);
 }
 
 
 KoCanvasBase * KisCanvasResourceProvider::canvas() const
 {
     return m_view->canvasBase();
 }
 
 KoColor KisCanvasResourceProvider::bgColor() const
 {
     return m_resourceManager->resource(KoCanvasResourceManager::BackgroundColor).value<KoColor>();
 }
 
 KoColor KisCanvasResourceProvider::fgColor() const
 {
     return m_resourceManager->resource(KoCanvasResourceManager::ForegroundColor).value<KoColor>();
 }
 
 float KisCanvasResourceProvider::HDRExposure() const
 {
     return static_cast<float>(m_resourceManager->resource(HdrExposure).toDouble());
 }
 
 void KisCanvasResourceProvider::setHDRExposure(float exposure)
 {
     m_resourceManager->setResource(HdrExposure, static_cast<double>(exposure));
 }
 
 float KisCanvasResourceProvider::HDRGamma() const
 {
     return static_cast<float>(m_resourceManager->resource(HdrGamma).toDouble());
 }
 
 void KisCanvasResourceProvider::setHDRGamma(float gamma)
 {
     m_resourceManager->setResource(HdrGamma, static_cast<double>(gamma));
 }
 
 
 KoPattern * KisCanvasResourceProvider::currentPattern() const
 {
     if (m_resourceManager->hasResource(CurrentPattern)) {
         return m_resourceManager->resource(CurrentPattern).value<KoPattern*>();
     }
     else {
         return 0;
     }
 }
 
 KisFilterConfiguration * KisCanvasResourceProvider::currentGeneratorConfiguration() const
 {
     return m_resourceManager->resource(CurrentGeneratorConfiguration).value<KisFilterConfiguration*>();
 }
 
 
 KoAbstractGradient* KisCanvasResourceProvider::currentGradient() const
 {
     if (m_resourceManager->hasResource(CurrentGradient)) {
         return m_resourceManager->resource(CurrentGradient).value<KoAbstractGradient*>();
     }
     else {
         return 0;
     }
 }
 
 KisImageWSP KisCanvasResourceProvider::currentImage() const
 {
     return m_view->image();
 }
 
 KisNodeSP KisCanvasResourceProvider::currentNode() const
 {
     return m_view->activeNode();
 }
 
 KisPaintOpPresetSP KisCanvasResourceProvider::currentPreset() const
 {
     KisPaintOpPresetSP preset = m_resourceManager->resource(CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
     return preset;
 }
 
 void KisCanvasResourceProvider::setPaintOpPreset(const KisPaintOpPresetSP preset)
 {
     Q_ASSERT(preset->valid());
     Q_ASSERT(!preset->paintOp().id().isEmpty());
     Q_ASSERT(preset->settings());
     if (!preset) return;
 
     dbgUI << "setPaintOpPreset" << preset->paintOp();
 
     QVariant v;
     v.setValue(preset);
     m_resourceManager->setResource(CurrentPaintOpPreset, v);
 }
 
 KisPaintOpPresetSP KisCanvasResourceProvider::previousPreset() const
 {
     KisPaintOpPresetSP preset = m_resourceManager->resource(PreviousPaintOpPreset).value<KisPaintOpPresetSP>();
     return preset;
 }
 
 void KisCanvasResourceProvider::setPreviousPaintOpPreset(const KisPaintOpPresetSP preset)
 {
     Q_ASSERT(preset->valid());
     Q_ASSERT(!preset->paintOp().id().isEmpty());
     Q_ASSERT(preset->settings());
     if (!preset) return;
 
     dbgUI << "setPreviousPaintOpPreset" << preset->paintOp();
 
     QVariant v;
     v.setValue(preset);
     m_resourceManager->setResource(PreviousPaintOpPreset, v);
 }
 
 void KisCanvasResourceProvider::slotPatternActivated(KoResource * res)
 {
     KoPattern *pattern = dynamic_cast<KoPattern*>(res);
     QVariant v;
     v.setValue<KoPattern*>(pattern);
     m_resourceManager->setResource(CurrentPattern, v);
     emit sigPatternChanged(pattern);
 }
 
 void KisCanvasResourceProvider::slotGeneratorConfigurationActivated(KisFilterConfiguration * res)
 {
     KisFilterConfiguration * generatorConfiguration = dynamic_cast<KisFilterConfiguration*>(res);
     QVariant v;
     v.setValue<KisFilterConfiguration*>(generatorConfiguration);
     m_resourceManager->setResource(CurrentGeneratorConfiguration, v);
 }
 
 void KisCanvasResourceProvider::slotGradientActivated(KoResource *res)
 {
 
     KoAbstractGradient * gradient = dynamic_cast<KoAbstractGradient*>(res);
     QVariant v;
     v.setValue<KoAbstractGradient*>(gradient);
     m_resourceManager->setResource(CurrentGradient, v);
     emit sigGradientChanged(gradient);
 }
 
 
 void KisCanvasResourceProvider::setBGColor(const KoColor& c)
 {
     QVariant v;
     v.setValue(c);
     m_resourceManager->setResource(KoCanvasResourceManager::BackgroundColor, v);
     emit sigBGColorChanged(c);
 }
 
 void KisCanvasResourceProvider::setFGColor(const KoColor& c)
 {
     m_fGChanged = true;
 
     QVariant v;
     v.setValue(c);
     m_resourceManager->setResource(KoCanvasResourceManager::ForegroundColor, v);
     emit sigFGColorChanged(c);
 }
 
 void KisCanvasResourceProvider::slotSetFGColor(const KoColor& c)
 {
     setFGColor(c);
 }
 
 void KisCanvasResourceProvider::slotSetBGColor(const KoColor& c)
 {
     setBGColor(c);
 }
 
 void KisCanvasResourceProvider::slotNodeActivated(const KisNodeSP node)
 {
     QVariant v;
     v.setValue(KisNodeWSP(node));
     m_resourceManager->setResource(CurrentKritaNode, v);
     emit sigNodeChanged(currentNode());
 }
 
 
 void KisCanvasResourceProvider::slotImageSizeChanged()
 {
     if (KisImageWSP image = m_view->image()) {
         float fw = image->width() / image->xRes();
         float fh = image->height() / image->yRes();
 
         QSizeF postscriptSize(fw, fh);
         m_resourceManager->setResource(KoCanvasResourceManager::PageSize, postscriptSize);
     }
 }
 
 void KisCanvasResourceProvider::slotOnScreenResolutionChanged()
 {
     KisImageWSP image = m_view->image();
     KisCanvas2 *canvas = m_view->canvasBase();
 
     if(!image || !canvas) return;
 
     qreal zoomX, zoomY;
     canvas->coordinatesConverter()->zoom(&zoomX, &zoomY);
 
     qreal scaleX = zoomX / image->xRes();
     qreal scaleY = zoomY / image->yRes();
 
     emit sigOnScreenResolutionChanged(scaleX, scaleY);
 }
 
 void KisCanvasResourceProvider::slotCanvasResourceChanged(int key, const QVariant & res)
 {
     if(key == KoCanvasResourceManager::ForegroundColor || key == KoCanvasResourceManager::BackgroundColor) {
         KoAbstractGradient* resource = KoResourceServerProvider::instance()->gradientServer()->resources()[0];
         KoStopGradient* stopGradient = dynamic_cast<KoStopGradient*>(resource);
         if(stopGradient) {
             QList<KoGradientStop> stops;
             stops << KoGradientStop(0.0, fgColor()) << KoGradientStop(1.0,  KoColor(QColor(0, 0, 0, 0), fgColor().colorSpace()));
             stopGradient->setStops(stops);
             KoResourceServerProvider::instance()->gradientServer()->updateResource(resource);
         }
         resource = KoResourceServerProvider::instance()->gradientServer()->resources()[1];
         stopGradient = dynamic_cast<KoStopGradient*>(resource);
         if(stopGradient) {
             QList<KoGradientStop> stops;
             stops << KoGradientStop(0.0, fgColor()) << KoGradientStop(1.0, bgColor());
             stopGradient->setStops(stops);
             KoResourceServerProvider::instance()->gradientServer()->updateResource(resource);
         }
     }
     switch (key) {
     case(KoCanvasResourceManager::ForegroundColor):
         m_fGChanged = true;
         emit sigFGColorChanged(res.value<KoColor>());
         break;
     case(KoCanvasResourceManager::BackgroundColor):
         emit sigBGColorChanged(res.value<KoColor>());
         break;
     case(CurrentPattern):
         emit sigPatternChanged(static_cast<KoPattern *>(res.value<void *>()));
         break;
     case(CurrentGradient):
         emit sigGradientChanged(static_cast<KoAbstractGradient *>(res.value<void *>()));
         break;
     case(CurrentKritaNode) :
         emit sigNodeChanged(currentNode());
         break;
     case (Opacity):
     {
         emit sigOpacityChanged(res.toDouble());
     }
     default:
         ;
         // Do nothing
     };
 }
 
 void KisCanvasResourceProvider::setCurrentCompositeOp(const QString& compositeOp)
 {
     m_resourceManager->setResource(CurrentCompositeOp,
                                    QVariant::fromValue(compositeOp));
 }
 
 QString KisCanvasResourceProvider::currentCompositeOp() const
 {
     return m_resourceManager->resource(CurrentCompositeOp).value<QString>();
 }
 
 bool KisCanvasResourceProvider::eraserMode() const
 {
     return m_resourceManager->resource(EraserMode).toBool();
 }
 
 void KisCanvasResourceProvider::setEraserMode(bool value)
 {
     m_resourceManager->setResource(EraserMode,
                                    QVariant::fromValue(value));
 }
 
 void KisCanvasResourceProvider::slotPainting()
 {
     if (m_fGChanged && m_enablefGChange) {
         emit sigFGColorUsed(fgColor());
         m_fGChanged = false;
     }
 }
 
 void KisCanvasResourceProvider::slotResetEnableFGChange(bool b)
 {
     m_enablefGChange = b;
 }
 
 QList<QPointer<KisAbstractPerspectiveGrid> > KisCanvasResourceProvider::perspectiveGrids() const
 {
     return m_perspectiveGrids;
 }
 
 void KisCanvasResourceProvider::addPerspectiveGrid(KisAbstractPerspectiveGrid* grid)
 {
     m_perspectiveGrids.append(grid);
 }
 
 void KisCanvasResourceProvider::removePerspectiveGrid(KisAbstractPerspectiveGrid* grid)
 {
     m_perspectiveGrids.removeOne(grid);
 }
 
 void KisCanvasResourceProvider::clearPerspectiveGrids()
 {
     m_perspectiveGrids.clear();
 }
 
 void KisCanvasResourceProvider::setMirrorHorizontal(bool mirrorHorizontal)
 {
     m_resourceManager->setResource(MirrorHorizontal, mirrorHorizontal);
     emit mirrorModeChanged();
 }
 
 bool KisCanvasResourceProvider::mirrorHorizontal() const
 {
     return m_resourceManager->resource(MirrorHorizontal).toBool();
 }
 
 void KisCanvasResourceProvider::setMirrorVertical(bool mirrorVertical)
 {
     m_resourceManager->setResource(MirrorVertical, mirrorVertical);
     emit mirrorModeChanged();
 }
 
 bool KisCanvasResourceProvider::mirrorVertical() const
 {
     return m_resourceManager->resource(MirrorVertical).toBool();
 }
 
 void KisCanvasResourceProvider::setMirrorHorizontalLock(bool isLocked)
 {
     m_resourceManager->setResource(MirrorHorizontalLock, isLocked);
     emit mirrorModeChanged();
 }
 
 bool KisCanvasResourceProvider::mirrorHorizontalLock() {
      return m_resourceManager->resource(MirrorHorizontalLock).toBool();
 }
 
 void KisCanvasResourceProvider::setMirrorVerticalLock(bool isLocked)
 {
     m_resourceManager->setResource(MirrorVerticalLock, isLocked);
     emit mirrorModeChanged();
 }
 
 
 
 bool KisCanvasResourceProvider::mirrorVerticalHideDecorations() {
      return m_resourceManager->resource(MirrorVerticalHideDecorations).toBool();
 }
 
 void KisCanvasResourceProvider::setMirrorVerticalHideDecorations(bool hide)
 {
     m_resourceManager->setResource(MirrorVerticalHideDecorations, hide);
     emit mirrorModeChanged();
 }
 
 
 bool KisCanvasResourceProvider::mirrorHorizontalHideDecorations() {
      return m_resourceManager->resource(MirrorHorizontalHideDecorations).toBool();
 }
 
 void KisCanvasResourceProvider::setMirrorHorizontalHideDecorations(bool hide)
 {
     m_resourceManager->setResource(MirrorHorizontalHideDecorations, hide);
     emit mirrorModeChanged();
 }
 
 
 bool KisCanvasResourceProvider::mirrorVerticalLock() {
      return m_resourceManager->resource(MirrorVerticalLock).toBool();
 }
 
 void KisCanvasResourceProvider::mirrorVerticalMoveCanvasToCenter() {
      emit moveMirrorVerticalCenter();
 }
 
 void KisCanvasResourceProvider::mirrorHorizontalMoveCanvasToCenter() {
      emit moveMirrorHorizontalCenter();
 }
 
 
 
 void KisCanvasResourceProvider::setOpacity(qreal opacity)
 {
     m_resourceManager->setResource(Opacity, opacity);
 }
 
 qreal KisCanvasResourceProvider::opacity() const
 {
     return m_resourceManager->resource(Opacity).toReal();
 }
 
+void KisCanvasResourceProvider::setFlow(qreal flow)
+{
+    m_resourceManager->setResource(Flow, flow);
+}
+
+qreal KisCanvasResourceProvider::flow() const
+{
+    return m_resourceManager->resource(Flow).toReal();
+}
+
+void KisCanvasResourceProvider::setSize(qreal size)
+{
+    m_resourceManager->setResource(Size, size);
+}
+
+qreal KisCanvasResourceProvider::size() const
+{
+    return m_resourceManager->resource(Size).toReal();
+}
+
 void KisCanvasResourceProvider::setSelectionAction(int action)
 {
     m_resourceManager->setResource(SelectionAction, action);
     emit sigSelectionActionChanged(action);
 }
 
 int KisCanvasResourceProvider::selectionAction()
 {
     return m_resourceManager->resource(SelectionAction).toInt();
 }
 
 void KisCanvasResourceProvider::setSelectionMode(int mode)
 {
     m_resourceManager->setResource(SelectionMode, mode);
     emit sigSelectionModeChanged(mode);
 }
 
 int KisCanvasResourceProvider::selectionMode()
 {
     return m_resourceManager->resource(SelectionMode).toInt();
 }
 
 
 void KisCanvasResourceProvider::setGlobalAlphaLock(bool lock)
 {
     m_resourceManager->setResource(GlobalAlphaLock, lock);
 }
 
 bool KisCanvasResourceProvider::globalAlphaLock() const
 {
     return m_resourceManager->resource(GlobalAlphaLock).toBool();
 }
 
 void KisCanvasResourceProvider::notifyLoadingWorkspace(KisWorkspaceResource* workspace)
 {
     emit sigLoadingWorkspace(workspace);
 }
 
 void KisCanvasResourceProvider::notifySavingWorkspace(KisWorkspaceResource* workspace)
 {
     emit sigSavingWorkspace(workspace);
 }
 
diff --git a/libs/ui/kis_canvas_resource_provider.h b/libs/ui/kis_canvas_resource_provider.h
index 9ec14d6db6..a219beab27 100644
--- a/libs/ui/kis_canvas_resource_provider.h
+++ b/libs/ui/kis_canvas_resource_provider.h
@@ -1,239 +1,247 @@
 /*
  *  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,
         CurrentImage,
         CurrentKritaNode,
         CurrentPaintOpPreset,
         CurrentGeneratorConfiguration,
         CurrentCompositeOp,
         CurrentEffectiveCompositeOp,
         LodAvailability,
         EraserMode,
         MirrorHorizontal,
         MirrorVertical,
         MirrorHorizontalLock,
         MirrorVerticalLock,
         MirrorVerticalHideDecorations,
         MirrorHorizontalHideDecorations,
         MirrorAxesCenter,
         Opacity,
+        Flow,
+        Size,
         HdrGamma,
         GlobalAlphaLock,
         PreviousPaintOpPreset,
         EffectiveZoom, ///<-Used only by painting tools for non-displaying purposes
         PresetAllowsLod,
         SelectionAction,
         SelectionMode
     };
 
 
     KisCanvasResourceProvider(KisViewManager * view);
     ~KisCanvasResourceProvider();
 
     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);
 
     KisFilterConfiguration* currentGeneratorConfiguration() const;
 
     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;
 
 
     ///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 slotGeneratorConfigurationActivated(KisFilterConfiguration * generatorConfiguration);
     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_derived_resources.cpp b/libs/ui/kis_derived_resources.cpp
index 147a6b1722..07f887b2b8 100644
--- a/libs/ui/kis_derived_resources.cpp
+++ b/libs/ui/kis_derived_resources.cpp
@@ -1,153 +1,238 @@
 /*
  *  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_derived_resources.h"
 
+#include "kis_signal_auto_connection.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_paintop_preset.h"
 #include "kis_paintop_settings.h"
+#include "kis_paintop_settings_update_proxy.h"
+
+struct KisPresetUpdateMediator::Private
+{
+    KisSignalAutoConnectionsStore connections;
+};
+
+KisPresetUpdateMediator::KisPresetUpdateMediator()
+    : KoResourceUpdateMediator(KisCanvasResourceProvider::CurrentPaintOpPreset),
+      m_d(new Private)
+{
+}
+
+KisPresetUpdateMediator::~KisPresetUpdateMediator()
+{
+}
+
+void KisPresetUpdateMediator::connectResource(QVariant sourceResource)
+{
+    KisPaintOpPresetSP preset = sourceResource.value<KisPaintOpPresetSP>();
+    if (!preset) return;
+
+    m_d->connections.clear();
+    m_d->connections.addUniqueConnection(
+        preset->updateProxy(),
+        SIGNAL(sigSettingsChanged()),
+        this,
+        SLOT(slotSettingsChanged()));
+}
+
+void KisPresetUpdateMediator::slotSettingsChanged()
+{
+    emit sigResourceChanged(key());
+}
 
 
 /*********************************************************************/
 /*          KisCompositeOpResourceConverter                          */
 /*********************************************************************/
 
 
 KisCompositeOpResourceConverter::KisCompositeOpResourceConverter()
     : KoDerivedResourceConverter(KisCanvasResourceProvider::CurrentCompositeOp,
                                  KisCanvasResourceProvider::CurrentPaintOpPreset)
 {
 }
 
 QVariant KisCompositeOpResourceConverter::fromSource(const QVariant &value)
 {
     KisPaintOpPresetSP preset = value.value<KisPaintOpPresetSP>();
     return preset ? preset->settings()->paintOpCompositeOp() : QVariant();
 }
 
 QVariant KisCompositeOpResourceConverter::toSource(const QVariant &value, const QVariant &sourceValue)
 {
     KisPaintOpPresetSP preset = sourceValue.value<KisPaintOpPresetSP>();
     if (!preset) return sourceValue;
 
     preset->settings()->setPaintOpCompositeOp(value.toString());
     return QVariant::fromValue(preset);
 }
 
 /*********************************************************************/
 /*          KisEffectiveCompositeOpResourceConverter                 */
 /*********************************************************************/
 
 
 KisEffectiveCompositeOpResourceConverter::KisEffectiveCompositeOpResourceConverter()
     : KoDerivedResourceConverter(KisCanvasResourceProvider::CurrentEffectiveCompositeOp,
                                  KisCanvasResourceProvider::CurrentPaintOpPreset)
 {
 }
 
 QVariant KisEffectiveCompositeOpResourceConverter::fromSource(const QVariant &value)
 {
     KisPaintOpPresetSP preset = value.value<KisPaintOpPresetSP>();
     return preset ? preset->settings()->effectivePaintOpCompositeOp() : QVariant();
 }
 
 QVariant KisEffectiveCompositeOpResourceConverter::toSource(const QVariant &value, const QVariant &sourceValue)
 {
     Q_UNUSED(value);
 
     // WARNING: we don't save that!
     KisPaintOpPresetSP preset = sourceValue.value<KisPaintOpPresetSP>();
     if (!preset) return sourceValue;
 
     return QVariant::fromValue(preset);
 }
 
 /*********************************************************************/
 /*          KisOpacityResourceConverter                              */
 /*********************************************************************/
 
 KisOpacityResourceConverter::KisOpacityResourceConverter()
     : KoDerivedResourceConverter(KisCanvasResourceProvider::Opacity,
                                  KisCanvasResourceProvider::CurrentPaintOpPreset)
 {
 }
 
 QVariant KisOpacityResourceConverter::fromSource(const QVariant &value)
 {
     KisPaintOpPresetSP preset = value.value<KisPaintOpPresetSP>();
     return preset ? preset->settings()->paintOpOpacity() : QVariant();
 }
 
 QVariant KisOpacityResourceConverter::toSource(const QVariant &value, const QVariant &sourceValue)
 {
     KisPaintOpPresetSP preset = sourceValue.value<KisPaintOpPresetSP>();
     if (!preset) return sourceValue;
 
     preset->settings()->setPaintOpOpacity(value.toReal());
     return QVariant::fromValue(preset);
 }
 
+/*********************************************************************/
+/*          KisFlowResourceConverter                              */
+/*********************************************************************/
+
+KisFlowResourceConverter::KisFlowResourceConverter()
+    : KoDerivedResourceConverter(KisCanvasResourceProvider::Flow,
+                                 KisCanvasResourceProvider::CurrentPaintOpPreset)
+{
+}
+
+QVariant KisFlowResourceConverter::fromSource(const QVariant &value)
+{
+    KisPaintOpPresetSP preset = value.value<KisPaintOpPresetSP>();
+    return preset ? preset->settings()->paintOpFlow() : QVariant();
+}
+
+QVariant KisFlowResourceConverter::toSource(const QVariant &value, const QVariant &sourceValue)
+{
+    KisPaintOpPresetSP preset = sourceValue.value<KisPaintOpPresetSP>();
+    if (!preset) return sourceValue;
+
+    preset->settings()->setPaintOpFlow(value.toReal());
+    return QVariant::fromValue(preset);
+}
+
+/*********************************************************************/
+/*          KisSizeResourceConverter                              */
+/*********************************************************************/
+
+KisSizeResourceConverter::KisSizeResourceConverter()
+    : KoDerivedResourceConverter(KisCanvasResourceProvider::Size,
+                                 KisCanvasResourceProvider::CurrentPaintOpPreset)
+{
+}
+
+QVariant KisSizeResourceConverter::fromSource(const QVariant &value)
+{
+    KisPaintOpPresetSP preset = value.value<KisPaintOpPresetSP>();
+    return preset ? preset->settings()->paintOpSize() : QVariant();
+}
+
+QVariant KisSizeResourceConverter::toSource(const QVariant &value, const QVariant &sourceValue)
+{
+    KisPaintOpPresetSP preset = sourceValue.value<KisPaintOpPresetSP>();
+    if (!preset) return sourceValue;
+
+    preset->settings()->setPaintOpSize(value.toReal());
+    return QVariant::fromValue(preset);
+}
+
 /*********************************************************************/
 /*          KisLodAvailabilityResourceConverter                      */
 /*********************************************************************/
 
 KisLodAvailabilityResourceConverter::KisLodAvailabilityResourceConverter()
     : KoDerivedResourceConverter(KisCanvasResourceProvider::LodAvailability,
                                  KisCanvasResourceProvider::CurrentPaintOpPreset)
 {
 }
 
 QVariant KisLodAvailabilityResourceConverter::fromSource(const QVariant &value)
 {
     KisPaintOpPresetSP preset = value.value<KisPaintOpPresetSP>();
     return preset ? KisPaintOpSettings::isLodUserAllowed(preset->settings()) : QVariant();
 }
 
 QVariant KisLodAvailabilityResourceConverter::toSource(const QVariant &value, const QVariant &sourceValue)
 {
     KisPaintOpPresetSP preset = sourceValue.value<KisPaintOpPresetSP>();
     if (!preset) return sourceValue;
 
     KisPaintOpSettings::setLodUserAllowed(preset->settings().data(), value.toBool());
     return QVariant::fromValue(preset);
 }
 
 /*********************************************************************/
 /*          KisEraserModeResourceConverter                           */
 /*********************************************************************/
 
 KisEraserModeResourceConverter::KisEraserModeResourceConverter()
     : KoDerivedResourceConverter(KisCanvasResourceProvider::EraserMode,
                                  KisCanvasResourceProvider::CurrentPaintOpPreset)
 {
 }
 
 QVariant KisEraserModeResourceConverter::fromSource(const QVariant &value)
 {
     KisPaintOpPresetSP preset = value.value<KisPaintOpPresetSP>();
     return preset ? preset->settings()->eraserMode() : QVariant();
 }
 
 QVariant KisEraserModeResourceConverter::toSource(const QVariant &value, const QVariant &sourceValue)
 {
     KisPaintOpPresetSP preset = sourceValue.value<KisPaintOpPresetSP>();
     if (!preset) return sourceValue;
 
     preset->settings()->setEraserMode(value.toBool());
     return QVariant::fromValue(preset);
 }
diff --git a/libs/ui/kis_derived_resources.h b/libs/ui/kis_derived_resources.h
index 6e905b5ae9..d5e775f4de 100644
--- a/libs/ui/kis_derived_resources.h
+++ b/libs/ui/kis_derived_resources.h
@@ -1,72 +1,107 @@
 /*
  *  Copyright (c) 2016 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KIS_DERIVED_RESOURCES_H
 #define __KIS_DERIVED_RESOURCES_H
 
 #include "KoDerivedResourceConverter.h"
+#include "KoResourceUpdateMediator.h"
+#include <QScopedPointer>
 
+class KisPresetUpdateMediator : public KoResourceUpdateMediator
+{
+    Q_OBJECT
+public:
+    KisPresetUpdateMediator();
+    ~KisPresetUpdateMediator();
+    void connectResource(QVariant sourceResource);
+
+private Q_SLOTS:
+    void slotSettingsChanged();
+
+private:
+    struct Private;
+    const QScopedPointer<Private> m_d;
+};
 
 class KisCompositeOpResourceConverter : public KoDerivedResourceConverter
 {
 public:
     KisCompositeOpResourceConverter();
 
     QVariant fromSource(const QVariant &value);
     QVariant toSource(const QVariant &value, const QVariant &sourceValue);
 };
 
 class KisEffectiveCompositeOpResourceConverter : public KoDerivedResourceConverter
 {
 public:
     KisEffectiveCompositeOpResourceConverter();
 
     QVariant fromSource(const QVariant &value);
     QVariant toSource(const QVariant &value, const QVariant &sourceValue);
 };
 
-class KisOpacityResourceConverter : public KoDerivedResourceConverter
+class KisOpacityResourceConverter : public KoDerivedResourceConverter, public QObject
 {
 public:
     KisOpacityResourceConverter();
 
     QVariant fromSource(const QVariant &value);
     QVariant toSource(const QVariant &value, const QVariant &sourceValue);
 };
 
+class KisFlowResourceConverter : public KoDerivedResourceConverter, public QObject
+{
+public:
+    KisFlowResourceConverter();
+
+    QVariant fromSource(const QVariant &value);
+    QVariant toSource(const QVariant &value, const QVariant &sourceValue);
+};
+
+class KisSizeResourceConverter : public KoDerivedResourceConverter, public QObject
+{
+public:
+    KisSizeResourceConverter();
+
+    QVariant fromSource(const QVariant &value);
+    QVariant toSource(const QVariant &value, const QVariant &sourceValue);
+};
+
 class KisLodAvailabilityResourceConverter : public KoDerivedResourceConverter
 {
 public:
     KisLodAvailabilityResourceConverter();
 
     QVariant fromSource(const QVariant &value);
     QVariant toSource(const QVariant &value, const QVariant &sourceValue);
 };
 
 class KisEraserModeResourceConverter : public KoDerivedResourceConverter
 {
 public:
     KisEraserModeResourceConverter();
 
     QVariant fromSource(const QVariant &value);
     QVariant toSource(const QVariant &value, const QVariant &sourceValue);
 };
 
 
 
 #endif /* __KIS_DERIVED_RESOURCES_H */
diff --git a/libs/ui/kis_paintop_box.cc b/libs/ui/kis_paintop_box.cc
index a64c033205..34a9ca7f12 100644
--- a/libs/ui/kis_paintop_box.cc
+++ b/libs/ui/kis_paintop_box.cc
@@ -1,1207 +1,1193 @@
 /*
  *  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 <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 "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_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_presetUpdateCompressor(200, KisSignalCompressor::FIRST_ACTIVE)
 {
     Q_ASSERT(view != 0);
 
 
     setObjectName(name);
     KisConfig cfg;
     m_dirtyPresetsEnabled = cfg.useDirtyPresets();
     m_eraserBrushSizeEnabled = cfg.useEraserBrushSize();
 
     KAcceleratorManager::setNoAccel(this);
 
     setWindowTitle(i18n("Painter's Toolchest"));
 
     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 KisPopupButton(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();
 
     KisAction* hideCanvasDecorationsX = m_viewManager->actionManager()->createAction("mirrorX-hideDecorations");
     hideCanvasDecorationsX->setCheckable(true);
     hideCanvasDecorationsX->setText(i18n("Hide Mirror Line"));
     toolbarMenuXMirror->addAction(hideCanvasDecorationsX);
 
     KisAction* lockActionX = m_viewManager->actionManager()->createAction("mirrorX-lock");
     lockActionX->setText(i18n("Lock"));
     lockActionX->setCheckable(true);
     toolbarMenuXMirror->addAction(lockActionX);
 
     KisAction* moveToCenterActionX = m_viewManager->actionManager()->createAction("mirrorX-moveToCenter");
     moveToCenterActionX->setCheckable(false);
     moveToCenterActionX->setText(i18n("Move to Canvas Center"));
     toolbarMenuXMirror->addAction(moveToCenterActionX);
 
 
 
     // mirror tool options for the Y Mirror
     QMenu *toolbarMenuYMirror = new QMenu();
 
     KisAction* hideCanvasDecorationsY = m_viewManager->actionManager()->createAction("mirrorY-hideDecorations");
     hideCanvasDecorationsY->setCheckable(true);
     hideCanvasDecorationsY->setText(i18n("Hide Mirror Line"));
     toolbarMenuYMirror->addAction(hideCanvasDecorationsY);
 
 
     KisAction* lockActionY = m_viewManager->actionManager()->createAction("mirrorY-lock");
     lockActionY->setText(i18n("Lock"));
     lockActionY->setCheckable(true);
     toolbarMenuYMirror->addAction(lockActionY);
 
     KisAction* moveToCenterActionY = m_viewManager->actionManager()->createAction("mirrorY-moveToCenter");
     moveToCenterActionY->setCheckable(false);
     moveToCenterActionY->setText(i18n("Move to Canvas Center"));
     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, 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("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_presetsPopup = new KisPaintOpPresetsPopup(m_resourceProvider);
     m_brushEditorPopupButton->setPopupWidget(m_presetsPopup);
     m_presetsPopup->switchDetached(false);
     connect(m_viewManager->mainWindow(), SIGNAL(themeChanged()), m_presetsPopup, SLOT(updateThemedIcons()));
 
     m_presetsChooserPopup = new KisPaintOpPresetsChooserPopup();
     m_presetsChooserPopup->setFixedSize(500, 600);
     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(savePresetClicked())                , SLOT(slotSaveActivePreset()));
     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_presetsChooserPopup, SIGNAL(resourceSelected(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)));
 
 
     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(sigOpacityChanged(qreal)), SLOT(slotOpacityChanged(qreal)));
     connect(m_viewManager->resourceProvider(), SIGNAL(sigFGColorChanged(KoColor)), SLOT(slotUnsetEraseMode()));
 
     m_favoriteResourceManager = new KisFavoriteResourceManager(this);
     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());
 }
 
 KisPaintopBox::~KisPaintopBox()
 {
     KisConfig cfg;
     QMapIterator<TabletToolID, TabletToolData> iter(m_tabletToolMap);
     while (iter.hasNext()) {
         iter.next();
         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 it is global to the application, not owned by the view
     m_presetsPopup->setPaintOpSettingsWidget(0);
     qDeleteAll(m_paintopOptionWidgets);
     delete m_favoriteResourceManager;
 
     for (int i = 0; i < 3; ++i) {
         delete m_sliderChooser[i];
     }
 }
 
 void KisPaintopBox::restoreResource(KoResource* resource)
 {
     KisPaintOpPreset* preset = dynamic_cast<KisPaintOpPreset*>(resource);
     if (preset) {
         setCurrentPaintop(preset->paintOp(), 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)
 {
     KisPaintOpPreset* preset = dynamic_cast<KisPaintOpPreset*>(resource);
     if (preset) {
         if (!preset->settings()->isLoadable())
             return;
 
         setCurrentPaintopAndReload(preset->paintOp(), preset);
         m_presetsPopup->setPresetImage(preset->image());
         m_presetsPopup->resourceSelected(resource);
     }
 }
 
 void KisPaintopBox::setCurrentPaintopAndReload(const KoID& paintop, KisPaintOpPresetSP preset)
 {
     if (!m_dirtyPresetsEnabled) {
         KisSignalsBlocker blocker(m_optionWidget);
         if (!preset->load()) {
             warnKrita << "failed to load the preset.";
         }
     }
 
     setCurrentPaintop(paintop, preset);
 }
 
 void KisPaintopBox::setCurrentPaintop(const KoID& paintop, KisPaintOpPresetSP preset)
 {
     if (m_resourceProvider->currentPreset()) {
 
         m_resourceProvider->setPreviousPaintOpPreset(m_resourceProvider->currentPreset());
 
         if (m_optionWidget) {
             m_optionWidget->disconnect(this);
             m_optionWidget->hide();
         }
 
         m_paintOpPresetMap[m_resourceProvider->currentPreset()->paintOp()] = m_resourceProvider->currentPreset();
         m_tabletToolMap[m_currTabletToolID].preset = m_resourceProvider->currentPreset();
         m_tabletToolMap[m_currTabletToolID].paintOpID = m_resourceProvider->currentPreset()->paintOp();
     }
 
     preset = (!preset) ? activePreset(paintop) : preset;
     Q_ASSERT(preset && preset->settings());
 
-    m_resourceProvider->setPaintOpPreset(preset);
-
     if (!m_paintopOptionWidgets.contains(paintop))
         m_paintopOptionWidgets[paintop] = KisPaintOpRegistry::instance()->get(paintop.id())->createConfigWidget(this);
 
     m_optionWidget = m_paintopOptionWidgets[paintop];
 
-    preset->settings()->setOptionsWidget(m_optionWidget);
+    preset->setOptionsWidget(m_optionWidget);
 
     m_optionWidget->setImage(m_viewManager->image());
     m_optionWidget->setNode(m_viewManager->activeNode());
-    m_optionWidget->setConfiguration(preset->settings());
 
     m_presetsPopup->setPaintOpSettingsWidget(m_optionWidget);
 
+    m_resourceProvider->setPaintOpPreset(preset);
+
     Q_ASSERT(m_optionWidget && m_presetSelectorPopupButton);
-    m_presetConnections.addUniqueConnection(
-        preset->settings()->updateProxy(), SIGNAL(sigSettingsChanged()),
-        this, SLOT(slotGuiChangedCurrentPreset()));
+
+    connect(m_optionWidget, SIGNAL(sigConfigurationUpdated()), this, SLOT(slotGuiChangedCurrentPreset()));
+    connect(&m_presetUpdateCompressor, SIGNAL(timeout()), this, SLOT(slotUpdateOptionsWidget()));
+
     connect(m_optionWidget, SIGNAL(sigSaveLockedConfig(KisPropertiesConfiguration*)), this, SLOT(slotSaveLockedOptionToPreset(KisPropertiesConfiguration*)));
     connect(m_optionWidget, SIGNAL(sigDropLockedConfig(KisPropertiesConfiguration*)), this, SLOT(slotDropLockedOption(KisPropertiesConfiguration*)));
 
 
     // load the current brush engine icon for the brush editor toolbar button
     KisPaintOpFactory* paintOp = KisPaintOpRegistry::instance()->get(paintop.id());
     QString pixFilename = KoResourcePaths::findResource("kis_images", paintOp->pixmap());
 
     m_brushEditorPopupButton->setIcon(QIcon(pixFilename));
     m_presetsPopup->setCurrentPaintOp(paintop.id());
 
     if (m_presetsPopup->currentPaintOp() != 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";
     }
 
-    /**
-     * We will get more update signals from the configuration widgets
-     * but they might be delayed by some internal deferring timers,
-     * so just call the slot directly
-     */
-    slotUpdatePreset();
+    m_presetConnections.clear();
+
+    // preset -> compressor
+    m_presetConnections.addConnection(
+        preset->updateProxy(), SIGNAL(sigSettingsChanged()),
+        &m_presetUpdateCompressor, SLOT(start()));
+}
+
+void KisPaintopBox::slotUpdateOptionsWidget()
+{
+    KisPaintOpPresetSP preset = m_resourceProvider->currentPreset();
+
+    KIS_SAFE_ASSERT_RECOVER_RETURN(preset);
+    KIS_SAFE_ASSERT_RECOVER_RETURN(m_optionWidget);
+
+    m_optionWidget->setConfigurationSafe(preset->settings().data());
+    m_presetsPopup->resourceSelected(preset.data());
+    m_presetsPopup->updateViewSettings();
+
 }
 
 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_resourceProvider->currentPreset()->settings()->setPaintOpCompositeOp(compositeOpID);
-            m_optionWidget->setConfiguration(m_resourceProvider->currentPreset()->settings().data());
-            m_resourceProvider->setCurrentCompositeOp(compositeOpID);
             m_currCompositeOpID = compositeOpID;
         }
     }
 }
 
 void KisPaintopBox::setWidgetState(int flags)
 {
     if (flags & (ENABLE_COMPOSITEOP | DISABLE_COMPOSITEOP)) {
         m_cmbCompositeOp->setEnabled(flags & ENABLE_COMPOSITEOP);
         m_eraseModeButton->setEnabled(flags & ENABLE_COMPOSITEOP);
     }
 
     if (flags & (ENABLE_PRESETS | DISABLE_PRESETS)) {
         m_presetSelectorPopupButton->setEnabled(flags & ENABLE_PRESETS);
         m_brushEditorPopupButton->setEnabled(flags & ENABLE_PRESETS);
     }
 
     for (int i = 0; i < 3; ++i) {
         if (flags & (ENABLE_OPACITY | DISABLE_OPACITY))
             m_sliderChooser[i]->getWidget("opacity")->setEnabled(flags & ENABLE_OPACITY);
 
         if (flags & (ENABLE_FLOW | DISABLE_FLOW))
             m_sliderChooser[i]->getWidget("flow")->setEnabled(flags & ENABLE_FLOW);
 
         if (flags & (ENABLE_SIZE | DISABLE_SIZE))
             m_sliderChooser[i]->getWidget("size")->setEnabled(flags & ENABLE_SIZE);
     }
 }
 
 void KisPaintopBox::setSliderValue(const QString& sliderID, qreal value)
 {
     for (int i = 0; i < 3; ++i) {
         KisDoubleSliderSpinBox* slider = m_sliderChooser[i]->getWidget<KisDoubleSliderSpinBox>(sliderID);
         KisSignalsBlocker b(slider);
         slider->setValue(value);
     }
 }
 
 void KisPaintopBox::slotSetPaintop(const QString& paintOpId)
 {
     if (KisPaintOpRegistry::instance()->get(paintOpId) != 0) {
         KoID id(paintOpId, KisPaintOpRegistry::instance()->get(paintOpId)->name());
         setCurrentPaintop(id);
     }
 }
 
 void KisPaintopBox::slotInputDeviceChanged(const KoInputDevice& inputDevice)
 {
     TabletToolMap::iterator toolData = m_tabletToolMap.find(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()), "Eraser_circle"));
         }
         else {
             preset = rserver->resourceByName(cfg.readEntry<QString>(QString("LastPreset_%1").arg(inputDevice.uniqueTabletId()), "Basic_tip_default"));
         }
         if (!preset) {
             preset = rserver->resourceByName("Basic_tip_default");
         }
         if (preset) {
             setCurrentPaintop(preset->paintOp(), preset);
         }
     }
     else {
         setCurrentPaintop(toolData->paintOpID, toolData->preset);
     }
 
     m_currTabletToolID = TabletToolID(inputDevice);
 }
 
 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());
         }
         m_presetsChooserPopup->canvasResourceChanged(preset.data(), preset);
 
-        if (m_resourceProvider->currentCompositeOp() != m_currCompositeOpID) {
-            updateCompositeOp(m_resourceProvider->currentCompositeOp());
+        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());
         }
 
         sender()->blockSignals(false);
     }
 }
 
 void KisPaintopBox::slotSaveActivePreset()
 {
     KisPaintOpPresetSP curPreset = m_resourceProvider->currentPreset();
 
     if (!curPreset)
         return;
 
     m_favoriteResourceManager->setBlockUpdates(true);
 
     KisPaintOpPresetSP newPreset = curPreset->clone();
     KisPaintOpPresetResourceServer * rServer = KisResourceServerProvider::instance()->paintOpPresetServer();
     QString saveLocation = rServer->saveLocation();
     QString presetName = m_presetsPopup->getPresetName();
     QString presetFilename = saveLocation + presetName + newPreset->defaultFileExtension();
 
     QStringList tags;
     KisPaintOpPresetSP resource = rServer->resourceByName(presetName);
     if (resource) {
 
         tags = rServer->assignedTagsList(resource.data());
         rServer->removeResourceAndBlacklist(resource);
 
     }
 
     newPreset->setImage(m_presetsPopup->cutOutOverlay());
     newPreset->setFilename(presetFilename);
     newPreset->setName(presetName);
     newPreset->setPresetDirty(false);
 
     rServer->addResource(newPreset);
     Q_FOREACH (const QString & tag, tags) {
         rServer->addTag(newPreset.data(), tag);
     }
 
     // HACK ALERT! the server does not notify the observers
     // automatically, so we need to call theupdate manually!
     rServer->tagCategoryMembersChanged();
 
     restoreResource(newPreset.data());
 
     m_favoriteResourceManager->setBlockUpdates(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->currentPreset()->settings()->paintOpSize().width());
+    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);
     }
 
-    {
-        const bool newEraseMode = m_resourceProvider->eraserMode();
-        if (m_eraseAction->isChecked() != newEraseMode) {
-            KisSignalsBlocker b(m_eraseAction, m_eraseModeButton);
-            m_eraseAction->setChecked(newEraseMode);
-            m_eraseModeButton->setChecked(newEraseMode);
-        }
-    }
-
     m_blockUpdate = false;
 }
 
 void KisPaintopBox::slotSetupDefaultPreset()
 {
     KisPaintOpPresetSP preset = defaultPreset(m_resourceProvider->currentPreset()->paintOp());
-    preset->settings()->setOptionsWidget(m_optionWidget);
-    m_optionWidget->setConfiguration(preset->settings());
-    m_optionWidget->writeConfiguration(const_cast<KisPaintOpSettings*>(preset->settings().data()));
+    preset->setOptionsWidget(m_optionWidget);
+    m_resourceProvider->setPaintOpPreset(preset);
 }
 
 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);
 
-    KisPaintOpSettingsSP settings = m_resourceProvider->currentPreset()->settings();
-    m_optionWidget->setConfiguration(settings.data());
-
     if (oldEraserMode != checked && m_eraserBrushSizeEnabled) {
-        const qreal currentSize = m_sliderChooser[0]->getWidget<KisDoubleSliderSpinBox>("size")->value();
+        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 updateSize = checked ? settings->savedEraserSize() : settings->savedBrushSize();
-        m_sliderChooser[0]->getWidget<KisDoubleSliderSpinBox>("size")->setValue(updateSize);
-        m_sliderChooser[1]->getWidget<KisDoubleSliderSpinBox>("size")->setValue(updateSize);
-        m_sliderChooser[2]->getWidget<KisDoubleSliderSpinBox>("size")->setValue(updateSize);
+        qreal newSize = checked ? settings->savedEraserSize() : settings->savedBrushSize();
+        m_resourceProvider->setSize(newSize);
     }
 }
 
 void KisPaintopBox::slotSetCompositeMode(int index)
 {
     Q_UNUSED(index);
-
-    if (m_resourceProvider->currentPreset()->settings()->hasProperty("CompositeOp")) {
-        QString compositeOp = m_cmbCompositeOp->selectedCompositeOp().id();
-        updateCompositeOp(compositeOp);
-    }
+    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);
 
-    m_optionWidget->writeConfiguration(const_cast<KisPaintOpSettings*>(m_resourceProvider->currentPreset()->settings().data()));
     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
-        qreal sizeDiff = size - m_resourceProvider->currentPreset()->settings()->paintOpSize().width();
-        m_resourceProvider->currentPreset()->settings()->changePaintOpSize(sizeDiff, 0);
+        // TODO: why?!
+
+        m_resourceProvider->setSize(size);
+        m_resourceProvider->setOpacity(opacity);
+        m_resourceProvider->setFlow(flow);
 
-        m_resourceProvider->currentPreset()->settings()->setPaintOpOpacity(opacity);
-        m_resourceProvider->currentPreset()->settings()->setPaintOpFlow(flow);
 
         KisLockedPropertiesProxy *propertiesProxy = KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(m_resourceProvider->currentPreset()->settings());
         propertiesProxy->setProperty("OpacityValue", opacity);
         propertiesProxy->setProperty("FlowValue", flow);
         delete propertiesProxy;
-
-        m_optionWidget->setConfiguration(m_resourceProvider->currentPreset()->settings().data());
+    } else {
+        m_resourceProvider->setOpacity(opacity);
     }
 
-    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 | ENABLE_SIZE | ENABLE_FLOW);
             slotUpdatePreset();
             m_presetsEnabled = true;
         } else {
             setWidgetState(DISABLE_PRESETS | DISABLE_SIZE | DISABLE_FLOW);
             m_presetsEnabled = false;
         }
     } else setWidgetState(DISABLE_ALL);
 }
 
-void KisPaintopBox::slotOpacityChanged(qreal opacity)
-{
-    if (m_blockUpdate || !m_optionWidget) return;
-    m_blockUpdate = true;
-
-    for (int i = 0; i < 3; ++i) {
-        KisDoubleSliderSpinBox *opacitySlider = m_sliderChooser[i]->getWidget<KisDoubleSliderSpinBox>("opacity");
-        KisSignalsBlocker b(opacitySlider);
-        opacitySlider->setValue(opacity);
-    }
-    if (m_presetsEnabled) {
-        m_resourceProvider->currentPreset()->settings()->setPaintOpOpacity(opacity);
-        m_optionWidget->setConfiguration(m_resourceProvider->currentPreset()->settings().data());
-    }
-    m_blockUpdate = false;
-}
-
 void KisPaintopBox::slotPreviousFavoritePreset()
 {
     if (!m_favoriteResourceManager) return;
 
     int i = 0;
     Q_FOREACH (KisPaintOpPresetSP preset, m_favoriteResourceManager->favoritePresetList()) {
         if (m_resourceProvider->currentPreset() && m_resourceProvider->currentPreset()->name() == preset->name()) {
             if (i > 0) {
                 m_favoriteResourceManager->slotChangeActivePaintop(i - 1);
             } else {
                 m_favoriteResourceManager->slotChangeActivePaintop(m_favoriteResourceManager->numFavoritePresets() - 1);
             }
             return;
         }
         i++;
     }
 
 }
 
 void KisPaintopBox::slotNextFavoritePreset()
 {
     if (!m_favoriteResourceManager) return;
 
     int i = 0;
     Q_FOREACH (KisPaintOpPresetSP preset, m_favoriteResourceManager->favoritePresetList()) {
         if (m_resourceProvider->currentPreset()->name() == preset->name()) {
             if (i < m_favoriteResourceManager->numFavoritePresets() - 1) {
                 m_favoriteResourceManager->slotChangeActivePaintop(i + 1);
             } else {
                 m_favoriteResourceManager->slotChangeActivePaintop(0);
             }
             return;
         }
         i++;
     }
 }
 
 void KisPaintopBox::slotSwitchToPreviousPreset()
 {
     if (m_resourceProvider->previousPreset()) {
         setCurrentPaintop(m_resourceProvider->previousPreset()->paintOp(), m_resourceProvider->previousPreset());
     }
 }
 
 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::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();
-        preset->settings()->setOptionsWidget(m_optionWidget);
-        m_optionWidget->setConfiguration(preset->settings());
-        m_presetsPopup->resourceSelected(preset.data());
     }
-    slotUpdatePreset();
 }
 void KisPaintopBox::slotGuiChangedCurrentPreset() // Called only when UI is changed and not when preset is changed
 {
-    m_optionWidget->writeConfiguration(const_cast<KisPaintOpSettings*>(m_resourceProvider->currentPreset()->settings().data()));
-    slotUpdatePreset();
+    m_optionWidget->writeConfigurationSafe(const_cast<KisPaintOpSettings*>(m_resourceProvider->currentPreset()->settings().data()));
 
-    m_presetsPopup->resourceSelected(m_resourceProvider->currentPreset().data());
-    m_presetsPopup->updateViewSettings();
+    //m_presetsPopup->resourceSelected(m_resourceProvider->currentPreset().data());
+
+    // TODO!!!!!!!!
+    //m_presetsPopup->updateViewSettings();
 }
 void KisPaintopBox::slotSaveLockedOptionToPreset(KisPropertiesConfiguration* 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(KisPropertiesConfiguration* 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");
             }
 
         }
-        m_optionWidget->setConfiguration(preset->settings());
     }
 
-    slotUpdatePreset();
+    //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::slotUpdateSelectionIcon()
 {
     m_hMirrorAction->setIcon(KisIconUtils::loadIcon("symmetry-horizontal"));
     m_vMirrorAction->setIcon(KisIconUtils::loadIcon("symmetry-vertical"));
 
     KisConfig cfg;
     if (!cfg.toolOptionsInDocker()) {
         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"));
 }
 
 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_paintop_box.h b/libs/ui/kis_paintop_box.h
index 00c26bd702..aa01ec03a8 100644
--- a/libs/ui/kis_paintop_box.h
+++ b/libs/ui/kis_paintop_box.h
@@ -1,249 +1,249 @@
 /*
  *  kis_paintop_box.h - part of KImageShop/Krayon/Krita
  *
  *  Copyright (c) 2004-2008 Boudewijn Rempt (boud@valdyas.org)
  *  Copyright (C) 2011      Silvio Heinrich <plassy@web.de>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_PAINTOP_BOX_H_
 #define KIS_PAINTOP_BOX_H_
 
 #include <QMap>
 #include <QWidget>
 #include <QList>
 
 
 #include <KoID.h>
 #include <KoInputDevice.h>
 
 #include <kis_types.h>
 #include <brushengine/kis_paintop_settings.h>
 #include <brushengine/kis_locked_properties_proxy.h>
 #include <brushengine/kis_locked_properties_server.h>
 #include <brushengine/kis_locked_properties.h>
 #include "kritaui_export.h"
 #include "kis_signal_auto_connection.h"
+#include "kis_signal_compressor.h"
+
 
 
 class QToolButton;
 class QString;
 class QHBoxLayout;
 
 class KoColorSpace;
 class KoResource;
 class KoCanvasController;
 
 class KisViewManager;
 class KisCanvasResourceProvider;
 class KisPopupButton;
 class KisToolOptionsPopup;
 class KisPaintOpPresetsPopup;
 class KisPaintOpPresetsChooserPopup;
 class KisPaintOpConfigWidget;
 class KisCompositeOpComboBox;
 class KisWidgetChooser;
 class KisFavoriteResourceManager;
 class KisAction;
 
 /**
  * This widget presents all paintops that a user can paint with.
  * Paintops represent real-world tools or the well-known Shoup
  * computer equivalents that do nothing but change color.
  *
  * To incorporate the dirty preset functionality and locked settings
  * the following slots are added
  *  void slotReloadPreset();
     void slotGuiChangedCurrentPreset();
     void slotSaveLockedOptionToPreset(KisPropertiesConfiguration* p);
     void slotDropLockedOption(KisPropertiesConfiguration* p);
     void slotDirtyPresetToggled(bool);
     Everytime a value is changed in a preset, the preset is made dirty through the onChange() function.
     For Locked Settings however, a changed Locked Setting will not cause a preset to become dirty. That is
     becuase it borrows its values from the KisLockedPropertiesServer.
     Hence the dirty state of the Preset is kept consistent before and after a writeConfiguration operation in  most cases.
  * XXX: When we have a lot of paintops, replace the listbox
  * with a table, and for every category a combobox.
  *
  * XXX: instead of text, use pretty pictures.
  */
 class KRITAUI_EXPORT KisPaintopBox : public QWidget
 {
     Q_OBJECT
 
     enum {
         ENABLE_PRESETS      = 0x0001,
         DISABLE_PRESETS     = 0x0002,
         ENABLE_COMPOSITEOP  = 0x0004,
         DISABLE_COMPOSITEOP = 0x0008,
         ENABLE_OPACITY      = 0x0010,
         DISABLE_OPACITY     = 0x0020,
         ENABLE_FLOW         = 0x0040,
         DISABLE_FLOW        = 0x0080,
         ENABLE_SIZE         = 0x0100,
         DISABLE_SIZE        = 0x0200,
         ENABLE_ALL          = 0x5555,
         DISABLE_ALL         = 0xAAAA
     };
 
 public:
 
     KisPaintopBox(KisViewManager* view, QWidget* parent, const char* name);
     ~KisPaintopBox();
 
     void restoreResource(KoResource* resource);
     /**
      * Update the option widgets to the argument ones, removing the currently set widgets.
      */
     void newOptionWidgets(const QList<QPointer<QWidget> > & optionWidgetList);
 
     KisFavoriteResourceManager *favoriteResourcesManager() { return m_favoriteResourceManager; }
 
 public Q_SLOTS:
 
     void slotColorSpaceChanged(const KoColorSpace* colorSpace);
     void slotInputDeviceChanged(const KoInputDevice & inputDevice);
     void slotCanvasResourceChanged(int key, const QVariant& v);
     void resourceSelected(KoResource* resource);
 
 private:
 
     void setCurrentPaintop(const KoID& paintop, KisPaintOpPresetSP preset = 0);
     void setCurrentPaintopAndReload(const KoID& paintop, KisPaintOpPresetSP preset);
 
     KisPaintOpPresetSP defaultPreset(const KoID& paintOp);
     KisPaintOpPresetSP activePreset(const KoID& paintOp);
     void updateCompositeOp(QString compositeOpID);
     void setWidgetState(int flags);
     void setSliderValue(const QString& sliderID, qreal value);
     void sliderChanged(int n);
 
 private Q_SLOTS:
 
     void slotSaveActivePreset();
     void slotUpdatePreset();
     void slotSetupDefaultPreset();
     void slotNodeChanged(const KisNodeSP node);
     void slotToggleEraseMode(bool checked);
     void slotSetCompositeMode(int index);
     void slotSetPaintop(const QString& paintOpId);
     void slotHorizontalMirrorChanged(bool value);
     void slotVerticalMirrorChanged(bool value);
     void slotSlider1Changed();
     void slotSlider2Changed();
     void slotSlider3Changed();
     void slotToolChanged(KoCanvasController* canvas, int toolId);
-    void slotOpacityChanged(qreal);
     void slotPreviousFavoritePreset();
     void slotNextFavoritePreset();
     void slotSwitchToPreviousPreset();
     void slotUnsetEraseMode();
     void slotToggleAlphaLockMode(bool);
 
     void slotReloadPreset();
     void slotGuiChangedCurrentPreset();
     void slotSaveLockedOptionToPreset(KisPropertiesConfiguration* p);
     void slotDropLockedOption(KisPropertiesConfiguration* p);
     void slotDirtyPresetToggled(bool);
     void slotEraserBrushSizeToggled(bool);    
     void slotUpdateSelectionIcon();
 
     void slotLockXMirrorToggle(bool);
     void slotLockYMirrorToggle(bool);
     void slotMoveToCenterMirrorX();
     void slotMoveToCenterMirrorY();
     void slotHideDecorationMirrorX(bool);
     void slotHideDecorationMirrorY(bool);
 
-
+    void slotUpdateOptionsWidget();
 
 private:
     KisCanvasResourceProvider*          m_resourceProvider;
     QHBoxLayout*                        m_layout;
     QWidget*                            m_paintopWidget;
     KisPaintOpConfigWidget*             m_optionWidget;
     KisPopupButton*                     m_toolOptionsPopupButton;
     KisPopupButton*                     m_brushEditorPopupButton;
     KisPopupButton*                     m_presetSelectorPopupButton;
     KisCompositeOpComboBox*             m_cmbCompositeOp;
     QToolButton*                        m_eraseModeButton;
     QToolButton*                        m_alphaLockButton;
     QToolButton*                        m_hMirrorButton;
     QToolButton*                        m_vMirrorButton;
     KisToolOptionsPopup*                m_toolOptionsPopup;
     KisPaintOpPresetsPopup*             m_presetsPopup;
     KisPaintOpPresetsChooserPopup*      m_presetsChooserPopup;
     KisViewManager*                     m_viewManager;
     KisPopupButton*                     m_workspaceWidget;
     KisWidgetChooser*                   m_sliderChooser[3];
     QMap<KoID, KisPaintOpConfigWidget*> m_paintopOptionWidgets;
     KisFavoriteResourceManager*         m_favoriteResourceManager;
     QToolButton*                        m_reloadButton;
     KisAction*                          m_eraseAction;
     KisAction*                          m_reloadAction;
 
     QString             m_currCompositeOpID;
     KisNodeWSP          m_previousNode;
 
     KisAction* m_hMirrorAction;
     KisAction* m_vMirrorAction;
 
-    KisSignalAutoConnectionsStore m_presetConnections;
-
     struct TabletToolID {
         TabletToolID(const KoInputDevice& dev) {
             uniqueID = dev.uniqueTabletId();
             // Only the eraser is special, and we don't look at Cursor
             pointer = QTabletEvent::Pen;
             if (dev.pointer() == QTabletEvent::Eraser) {
                 pointer = QTabletEvent::Eraser;
             }
         }
 
         bool operator == (const TabletToolID& id) const {
             return pointer == id.pointer && uniqueID == id.uniqueID;
         }
 
         bool operator < (const TabletToolID& id) const {
             if (uniqueID == id.uniqueID)
                 return pointer < id.pointer;
             return uniqueID < id.uniqueID;
         }
 
         QTabletEvent::PointerType  pointer;
         qint64                     uniqueID;
     };
 
     struct TabletToolData {
         KoID               paintOpID;
         KisPaintOpPresetSP preset;
     };
 
     typedef QMap<TabletToolID, TabletToolData> TabletToolMap;
     typedef QMap<KoID, KisPaintOpPresetSP>     PaintOpPresetMap;
 
     TabletToolMap    m_tabletToolMap;
     PaintOpPresetMap m_paintOpPresetMap;
     TabletToolID     m_currTabletToolID;
     bool             m_presetsEnabled;
     bool             m_blockUpdate;
     bool             m_dirtyPresetsEnabled;
     bool             m_eraserBrushSizeEnabled;
 
-
+    KisSignalAutoConnectionsStore m_presetConnections;
+    KisSignalCompressor m_presetUpdateCompressor;
 };
 
 #endif //KIS_PAINTOP_BOX_H_
diff --git a/libs/ui/recorder/kis_recorded_paint_action_editor.cc b/libs/ui/recorder/kis_recorded_paint_action_editor.cc
index d336a2efd2..00816b3354 100644
--- a/libs/ui/recorder/kis_recorded_paint_action_editor.cc
+++ b/libs/ui/recorder/kis_recorded_paint_action_editor.cc
@@ -1,176 +1,176 @@
 /*
  *  Copyright (c) 2010 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_recorded_paint_action_editor.h"
 
 #include <QLabel>
 #include <QGridLayout>
 
 #include <KoColor.h>
 #include <KoColorPopupAction.h>
 
 
 #include "recorder/kis_recorded_paint_action.h"
 #include <brushengine/kis_paintop_preset.h>
 #include <brushengine/kis_paintop_registry.h>
 #include <brushengine/kis_paintop_config_widget.h>
 
 #include "ui_wdgpaintactioneditor.h"
 #include <KoColorSpaceRegistry.h>
 #include <KoResourcePaths.h>
 #include "kis_node_query_path_editor.h"
 #include <recorder/kis_node_query_path.h>
 
 KisRecordedPaintActionEditor::KisRecordedPaintActionEditor(QWidget* parent, KisRecordedAction* action) : QWidget(parent),
         m_action(dynamic_cast<KisRecordedPaintAction*>(action)),
         m_actionEditor(new Ui_WdgPaintActionEditor),
         m_configWidget(0)
 {
     Q_ASSERT(m_action);
     m_actionEditor->setupUi(this);
 
     // Setup paint color editor
     m_paintColorPopup = new KoColorPopupAction(this);
     m_paintColorPopup->setCurrentColor(m_action->paintColor());
     m_actionEditor->paintColor->setDefaultAction(m_paintColorPopup);
     connect(m_paintColorPopup, SIGNAL(colorChanged(const KoColor &)),
             this, SLOT(configurationUpdated()));
 
     // Setup background color editor
     m_backgroundColorPopup = new KoColorPopupAction(this);
     m_backgroundColorPopup->setCurrentColor(m_action->backgroundColor());
     m_actionEditor->backgroundColor->setDefaultAction(m_backgroundColorPopup);
     connect(m_backgroundColorPopup, SIGNAL(colorChanged(const KoColor &)),
             this, SLOT(configurationUpdated()));
 
     // Setup opacity
     m_actionEditor->opacity->setValue(m_action->opacity() * 100.0);
     connect(m_actionEditor->opacity, SIGNAL(valueChanged(int)), SLOT(configurationUpdated()));
 
     // Setup paint ops
 
     QList<KoID> keys = KisPaintOpRegistry::instance()->listKeys();
     Q_FOREACH (const KoID& paintopId, keys) {
         QString pixmapName = KisPaintOpRegistry::instance()->pixmap(paintopId);
 
         QPixmap pm;
         if (!pixmapName.isEmpty()) {
             QString fname = KoResourcePaths::findResource("kis_images", pixmapName);
             pm = QPixmap(fname);
         }
 
 
         if (pm.isNull()) {
             pm = QPixmap(16, 16);
             pm.fill();
         }
 
         m_actionEditor->paintOps->addItem(QIcon(pm), paintopId.name());
         m_paintops.append(paintopId.id());
     }
     connect(m_actionEditor->paintOps, SIGNAL(activated(int)), SLOT(paintOpChanged(int)));
 
     // Setup configuration widget for paint op settings
     m_gridLayout = new QGridLayout(m_actionEditor->frmOptionWidgetContainer);
     setPaintOpPreset();
     m_actionEditor->paintOps->setCurrentIndex(m_paintops.indexOf(m_action->paintOpPreset()->paintOp().id()));
     m_paintOpsToPreset[m_action->paintOpPreset()->paintOp().id()] = m_action->paintOpPreset();
     connect(m_actionEditor->wdgPresetChooser, SIGNAL(resourceSelected(KoResource*)), SLOT(resourceSelected(KoResource*)));
 
     // Setup the query path editor
     m_actionEditor->nodeQueryPathEditor->setNodeQueryPath(m_action->nodeQueryPath());
     connect(m_actionEditor->nodeQueryPathEditor, SIGNAL(nodeQueryPathChanged()), SLOT(nodeQueryPathChanged()));
     
 }
 
 KisRecordedPaintActionEditor::~KisRecordedPaintActionEditor()
 {
     delete m_actionEditor;
 }
 
 void KisRecordedPaintActionEditor::configurationUpdated()
 {
-    m_configWidget->writeConfiguration(const_cast<KisPaintOpSettings*>(m_action->paintOpPreset()->settings().data()));
+    m_configWidget->writeConfigurationSafe(const_cast<KisPaintOpSettings*>(m_action->paintOpPreset()->settings().data()));
 
     m_action->setPaintColor(m_paintColorPopup->currentKoColor());
     m_action->setBackgroundColor(m_backgroundColorPopup->currentKoColor());
     m_action->setOpacity(m_actionEditor->opacity->value() / qreal(100.0));
 
     emit(actionEdited());
 }
 
 void KisRecordedPaintActionEditor::paintOpChanged(int index)
 {
     QString id = m_paintops[index];
     KisPaintOpPresetSP preset = m_paintOpsToPreset[id];
     if (!preset) {
         preset = KisPaintOpRegistry::instance()->defaultPreset(KoID(id, ""));
         m_paintOpsToPreset[id] = preset;
     }
     m_action->setPaintOpPreset(preset);
     setPaintOpPreset();
 }
 
 void KisRecordedPaintActionEditor::resourceSelected(KoResource* resource)
 {
     KisPaintOpPresetSP preset = static_cast<KisPaintOpPreset*>(resource);
 
     m_paintOpsToPreset[preset->paintOp().id()] = preset;
     m_action->setPaintOpPreset(preset);
     setPaintOpPreset();
 }
 
 void KisRecordedPaintActionEditor::nodeQueryPathChanged()
 {
     m_action->setNodeQueryPath(m_actionEditor->nodeQueryPathEditor->nodeQueryPath());
     emit(actionEdited());
 }
 
 
 void KisRecordedPaintActionEditor::setPaintOpPreset()
 {
     delete m_configWidget;
     m_configWidget = KisPaintOpRegistry::instance()->get(m_action->paintOpPreset()->paintOp().id())->createConfigWidget(m_actionEditor->frmOptionWidgetContainer);
     if (m_configWidget) {
         m_gridLayout->addWidget(m_configWidget);
         //TODO use default configuration instead?
         //m_configWidget->setConfiguration(m_action->paintOpPreset()->settings());
         connect(m_configWidget, SIGNAL(sigConfigurationUpdated()), SLOT(configurationUpdated()));
     } else {
         m_gridLayout->addWidget(new QLabel(i18n("No configuration option."), this));
     }
 }
 
 KisRecordedPaintActionEditorFactory::KisRecordedPaintActionEditorFactory()
 {
 }
 
 KisRecordedPaintActionEditorFactory::~KisRecordedPaintActionEditorFactory()
 {
 }
 
 QWidget* KisRecordedPaintActionEditorFactory::createEditor(QWidget* parent, KisRecordedAction* action) const
 {
     return new KisRecordedPaintActionEditor(parent, action);
 }
 
 bool KisRecordedPaintActionEditorFactory::canEdit(const KisRecordedAction* action) const
 {
     return dynamic_cast<const KisRecordedPaintAction*>(action);
 }
 
diff --git a/libs/ui/tests/CMakeLists.txt b/libs/ui/tests/CMakeLists.txt
index 7219220ac3..360f310537 100644
--- a/libs/ui/tests/CMakeLists.txt
+++ b/libs/ui/tests/CMakeLists.txt
@@ -1,261 +1,267 @@
 set( EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR} )
 
 #add_subdirectory(scratchpad)
 include_directories(${CMAKE_SOURCE_DIR}/libs/image/metadata 
                     ${CMAKE_SOURCE_DIR}/sdk/tests )
 
 
 macro_add_unittest_definitions()
 
 ########### next target ###############
 
 set(kis_node_model_test_SRCS kis_node_model_test.cpp modeltest.cpp )
 kde4_add_broken_unit_test(kis_node_model_test TESTNAME krita-ui-kis_node_model_test  ${kis_node_model_test_SRCS})
 target_link_libraries(kis_node_model_test    kritaui Qt5::Test)
 
 ########### next target ###############
 
 set(kis_image_view_converter_test_SRCS kis_image_view_converter_test.cpp )
 kde4_add_unit_test(KisImageViewConverterTest TESTNAME krita-ui-KisImageViewConverterTest  ${kis_image_view_converter_test_SRCS})
 target_link_libraries(KisImageViewConverterTest    kritaui Qt5::Test)
 
 ########### next target ###############
 
 set(kis_shape_controller_test_SRCS kis_shape_controller_test.cpp kis_dummies_facade_base_test.cpp)
 kde4_add_broken_unit_test(kis_shape_controller_test TESTNAME krita-ui-kis_shape_controller_test  ${kis_shape_controller_test_SRCS})
 target_link_libraries(kis_shape_controller_test    kritaimage kritaui Qt5::Test)
 
 ########### next target ###############
 
 set(squeezedcombobox_test_SRCS squeezedcombobox_test.cpp )
 kde4_add_unit_test(squeezedcombobox_test TESTNAME krita-ui-squeezedcombobox_test  ${squeezedcombobox_test_SRCS})
 target_link_libraries(squeezedcombobox_test   kritaui Qt5::Test)
 
 ########### next target ###############
 
 set(kis_prescaled_projection_test_SRCS kis_prescaled_projection_test.cpp )
 kde4_add_broken_unit_test(KisPrescaledProjectionTest TESTNAME krita-ui-kis_prescaled_projection_test ${kis_prescaled_projection_test_SRCS})
 target_link_libraries(KisPrescaledProjectionTest   kritaui Qt5::Test)
 
 ########### next target ###############
 
 set(kis_kra_loader_test_SRCS kis_kra_loader_test.cpp )
 kde4_add_broken_unit_test(KisKraLoaderTest TESTNAME krita-ui-KisKraLoaderTest ${kis_kra_loader_test_SRCS})
 target_link_libraries(KisKraLoaderTest   kritaimage kritaui Qt5::Test)
 
 ########### next target ###############
 
 set(kis_kra_saver_test_SRCS kis_kra_saver_test.cpp )
 kde4_add_broken_unit_test(KisKraSaverTest TESTNAME krita-ui-KisKraSaverTest ${kis_kra_saver_test_SRCS})
 target_link_libraries(KisKraSaverTest   kritaimage kritaui Qt5::Test)
 
 
 ########### next target ###############
 
 set(kis_kra_savexml_visitor_test_SRCS kis_kra_savexml_visitor_test.cpp )
 kde4_add_unit_test(KisKraSaveXmlVisitorTest TESTNAME krita-ui-KisKraSaveXmlVisitorTest ${kis_kra_savexml_visitor_test_SRCS})
 target_link_libraries(KisKraSaveXmlVisitorTest   kritaimage kritaui Qt5::Test)
 
 ########### next target ###############
 
 set(kis_shape_selection_test_SRCS kis_shape_selection_test.cpp )
 
 kde4_add_unit_test(KisShapeSelectionTest TESTNAME krita-ui-ShapeSelectionTest ${kis_shape_selection_test_SRCS})
 
 target_link_libraries(KisShapeSelectionTest   kritaimage kritaui Qt5::Test)
 
 ########### next target ###############
 
 set(kis_exiv2_test_SRCS kis_exiv2_test.cpp )
 kde4_add_broken_unit_test(KisExiv2Test TESTNAME krita-ui-KisExiv2Test ${kis_exiv2_test_SRCS})
 target_link_libraries(KisExiv2Test   kritaimage kritaui Qt5::Test)
 
 ########### next target ###############
 
 set(kis_recorded_action_editor_test_SRCS kis_recorded_action_editor_test.cpp )
 kde4_add_unit_test(KisRecordedActionEditorTest TESTNAME krita-ui-KisRecordedActionEditor ${kis_recorded_action_editor_test_SRCS})
 target_link_libraries(KisRecordedActionEditorTest   kritaimage kritaui Qt5::Test)
 
 ########### next target ###############
 
 set(kis_doc2_test_SRCS kis_doc2_test.cpp )
 kde4_add_unit_test(KisDoc2Test TESTNAME krita-ui-KisDoc2Test  ${kis_doc2_test_SRCS})
 target_link_libraries(KisDoc2Test    kritaui kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_coordinates_converter_test_SRCS kis_coordinates_converter_test.cpp )
 kde4_add_unit_test(KisCoordinatesConverterTest TESTNAME krita-ui-KisCoordinatesConverterTest  ${kis_coordinates_converter_test_SRCS})
 target_link_libraries(KisCoordinatesConverterTest    kritaui kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_clipboard_test_SRCS kis_clipboard_test.cpp )
 kde4_add_broken_unit_test(KisClipboardTest TESTNAME krita-ui-KisClipboardTest  ${kis_clipboard_test_SRCS})
 target_link_libraries(KisClipboardTest    kritaui kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(freehand_stroke_test_SRCS freehand_stroke_test.cpp ${CMAKE_SOURCE_DIR}/sdk/tests/stroke_testing_utils.cpp)
 kde4_add_broken_unit_test(FreehandStrokeTest TESTNAME krita-ui-FreehandStrokeTest  ${freehand_stroke_test_SRCS})
 target_link_libraries(FreehandStrokeTest    kritaui kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(fill_processing_visitor_test_SRCS fill_processing_visitor_test.cpp ${CMAKE_SOURCE_DIR}/sdk/tests/stroke_testing_utils.cpp)
 kde4_add_broken_unit_test(FillProcessingVisitorTest TESTNAME krita-ui-FillProcessingVisitorTest  ${fill_processing_visitor_test_SRCS})
 target_link_libraries(FillProcessingVisitorTest kritaui kritaimage Qt5::Test)
 
 
 ########### next target ###############
 
 set(filter_stroke_test_SRCS filter_stroke_test.cpp ../../../sdk/tests/stroke_testing_utils.cpp)
 kde4_add_broken_unit_test(FilterStrokeTest TESTNAME krita-ui-FilterStrokeTest  ${filter_stroke_test_SRCS})
 target_link_libraries(FilterStrokeTest    kritaui kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_selection_manager_test_SRCS kis_selection_manager_test.cpp)
 kde4_add_broken_unit_test(KisSelectionManagerTest TESTNAME krita-ui-KisSelectionManagerTest  ${kis_selection_manager_test_SRCS})
 target_link_libraries(KisSelectionManagerTest    kritaui kritaimage Qt5::Test)
 #set_tests_properties(krita-ui-KisSelectionManagerTest PROPERTIES TIMEOUT 300)
 
 ########### next target ###############
 
 set(kis_selection_decoration_test_SRCS kis_selection_decoration_test.cpp ../../../sdk/tests/stroke_testing_utils.cpp)
 kde4_add_unit_test(KisSelectionDecorationTest TESTNAME krita-ui-KisSelectionDecorationTest  ${kis_selection_decoration_test_SRCS})
 target_link_libraries(KisSelectionDecorationTest    kritaui kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_node_manager_test_SRCS kis_node_manager_test.cpp)
 kde4_add_broken_unit_test(KisNodeManagerTest TESTNAME krita-ui-KisNodeManagerTest  ${kis_node_manager_test_SRCS})
 target_link_libraries(KisNodeManagerTest    kritaui kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_node_dummies_graph_test_SRCS kis_node_dummies_graph_test.cpp ../../../sdk/tests/testutil.cpp)
 kde4_add_unit_test(KisNodeDummiesGraphTest TESTNAME krita-ui-KisNodeDummiesGraphTest  ${kis_node_dummies_graph_test_SRCS})
 target_link_libraries(KisNodeDummiesGraphTest    kritaui kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_node_shapes_graph_test_SRCS kis_node_shapes_graph_test.cpp ../../../sdk/tests/testutil.cpp)
 kde4_add_unit_test(KisNodeShapesGraphTest TESTNAME krita-ui-KisNodeShapesGraphTest  ${kis_node_shapes_graph_test_SRCS})
 target_link_libraries(KisNodeShapesGraphTest    kritaui kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_dummies_facade_test_SRCS kis_dummies_facade_test.cpp kis_dummies_facade_base_test.cpp ../../../sdk/tests/testutil.cpp)
 kde4_add_broken_unit_test(KisDummiesFacadeTest TESTNAME krita-ui-KisDummiesFacadeTest  ${kis_dummies_facade_test_SRCS})
 target_link_libraries(KisDummiesFacadeTest    kritaui kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_model_index_converter_test_SRCS kis_model_index_converter_test.cpp ../../../sdk/tests/testutil.cpp)
 kde4_add_unit_test(KisModelIndexConverterTest TESTNAME krita-ui-KisModelIndexConverterTest  ${kis_model_index_converter_test_SRCS})
 target_link_libraries(KisModelIndexConverterTest    kritaui kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_zoom_and_pan_test_SRCS kis_zoom_and_pan_test.cpp ../../../sdk/tests/testutil.cpp)
 kde4_add_broken_unit_test(KisZoomAndPanTest TESTNAME krita-ui-KisZoomAndPanTest  ${kis_zoom_and_pan_test_SRCS})
 target_link_libraries(KisZoomAndPanTest    kritaui kritaimage Qt5::Test)
 #set_tests_properties(krita-ui-KisZoomAndPanTest PROPERTIES TIMEOUT 300)
 
 ########### next target ###############
 
 # set(kis_input_manager_test_SRCS kis_input_manager_test.cpp ../../sdk/tests/testutil.cpp)
 # kde4_add_unit_test(KisInputManagerTest TESTNAME krita-ui-KisInputManagerTest  ${kis_input_manager_test_SRCS})
 # target_link_libraries(KisInputManagerTest    kritaui kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_action_manager_test_SRCS kis_action_manager_test.cpp )
 kde4_add_broken_unit_test(KisActionManagerTest TESTNAME krita-ui-KisActionManagerTest  ${kis_action_manager_test_SRCS})
 target_link_libraries(KisActionManagerTest    kritaui kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_categories_mapper_test_SRCS kis_categories_mapper_test.cpp testing_categories_mapper.cpp)
 kde4_add_broken_unit_test(KisCategoriesMapperTest TESTNAME krita-ui-KisCategoriesMapperTest  ${kis_categories_mapper_test_SRCS})
 target_link_libraries(KisCategoriesMapperTest    kritaui kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_categorized_list_model_test_SRCS kis_categorized_list_model_test.cpp modeltest.cpp)
 kde4_add_unit_test(KisCategorizedListModelTest TESTNAME krita-ui-KisCategorizedListModelTest  ${kis_categorized_list_model_test_SRCS})
 target_link_libraries(KisCategorizedListModelTest    kritaui kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_resource_server_provider_test_SRCS kis_resource_server_provider_test.cpp modeltest.cpp)
 kde4_add_unit_test(KisResourceServerProviderTest TESTNAME krita-ui-KisResourceServerProviderTest  ${kis_resource_server_provider_test_SRCS})
 target_link_libraries(KisResourceServerProviderTest    kritaui kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_file_layer_test_SRCS kis_file_layer_test.cpp )
 kde4_add_unit_test(KisFileLayerTest TESTNAME krita-ui-KisFileLayerTest  ${kis_file_layer_test_SRCS})
 target_link_libraries(KisFileLayerTest    kritaui kritaimage Qt5::Test)
 
 ########### next target ###############
 
 set(kis_asl_layer_style_serializer_test_SRCS kis_asl_layer_style_serializer_test.cpp )
 kde4_add_broken_unit_test(KisAslLayerStyleSerializerTest TESTNAME krita-ui-KisAslLayerStyleSerializerTest ${kis_asl_layer_style_serializer_test_SRCS})
 target_link_libraries(KisAslLayerStyleSerializerTest kritaui kritaimage ${QT_QTTEST_LIBRARY})
 
 ########### next target ###############
 
 set(kis_node_juggler_compressed_test_SRCS kis_node_juggler_compressed_test.cpp  ../../../sdk/tests/testutil.cpp)
 kde4_add_unit_test(KisNodeJugglerCompressedTest TESTNAME krita-image-BaseNodeTest ${kis_node_juggler_compressed_test_SRCS})
 target_link_libraries(KisNodeJugglerCompressedTest kritaimage kritaui Qt5::Test)
 
 ########### next target ###############
 
 set(kis_node_view_test_SRCS kis_node_view_test.cpp  ../../../sdk/tests/testutil.cpp)
 qt5_add_resources(kis_node_view_test_SRCS ${krita_QRCS})
 kde4_add_unit_test(KisNodeViewTest TESTNAME krita-image-BaseNodeTest ${kis_node_view_test_SRCS})
 target_link_libraries(KisNodeViewTest kritaimage kritaui Qt5::Test)
 
 ########### next target ###############
 
 set(kis_multinode_property_test_SRCS kis_multinode_property_test.cpp)
 kde4_add_unit_test(KisMultinodePropertyTest TESTNAME krita-image-BaseNodeTest ${kis_multinode_property_test_SRCS})
 target_link_libraries(KisMultinodePropertyTest kritaimage kritaui Qt5::Test)
 
 ########### next target ###############
 
 set(kis_grid_config_test_SRCS kis_grid_config_test.cpp)
 kde4_add_unit_test(KisGridConfigTest TESTNAME krita-image-BaseNodeTest ${kis_grid_config_test_SRCS})
 target_link_libraries(KisGridConfigTest kritaui Qt5::Test)
 
 ########### next target ###############
 
 set(kis_animation_exporter_test_SRCS kis_animation_exporter_test.cpp )
 kde4_add_broken_unit_test(KisAnimationExporterTest TESTNAME kritaui-animation_exporter_test ${kis_animation_exporter_test_SRCS})
 target_link_libraries(KisAnimationExporterTest kritaui kritaimage ${QT_QTTEST_LIBRARY})
 
 ########### next target ###############
 
 set(kis_animation_importer_test_SRCS kis_animation_importer_test.cpp )
 kde4_add_broken_unit_test(KisAnimationImporterTest TESTNAME kritaui-animation_importer_test ${kis_animation_importer_test_SRCS})
 target_link_libraries(KisAnimationImporterTest kritaui kritaimage ${QT_QTTEST_LIBRARY})
 
 ########### next target ###############
 
 set(kis_animation_frame_cache_test_SRCS kis_animation_frame_cache_test.cpp )
 kde4_add_broken_unit_test(KisAnimationFrameCacheTest TESTNAME kritaui-animation_frame_cache_test ${kis_animation_frame_cache_test_SRCS})
 target_link_libraries(KisAnimationFrameCacheTest kritaui kritaimage ${QT_QTTEST_LIBRARY})
 
 ########### next target ###############
 
 set(ResourceBundleTest_SRCS ResourceBundleTest.cpp)
 kde4_add_broken_unit_test(ResourceBundleTest TESTNAME krita-resourcemanager-ResourceBundleTest ${ResourceBundleTest_SRCS})
 target_link_libraries(ResourceBundleTest kritaui kritalibbrush kritalibpaintop Qt5::Test )
 
 ########### next target ###############
 
 set(kis_stabilized_events_sampler_test_SRCS kis_stabilized_events_sampler_test.cpp)
 kde4_add_unit_test(KisStabilizedEventsSamplerTest TESTNAME krita-ui-StabilizedEventsSamplerTest ${kis_stabilized_events_sampler_test_SRCS})
 target_link_libraries(KisStabilizedEventsSamplerTest kritaui Qt5::Test)
+
+########### next target ###############
+
+set(kis_derived_resources_test_SRCS kis_derived_resources_test.cpp)
+kde4_add_unit_test(KisDerivedResourcesTest TESTNAME krita-ui-DerivedResourcesTest ${kis_derived_resources_test_SRCS})
+target_link_libraries(KisDerivedResourcesTest kritaui Qt5::Test)
diff --git a/libs/ui/tests/kis_derived_resources_test.cpp b/libs/ui/tests/kis_derived_resources_test.cpp
new file mode 100644
index 0000000000..a19198426e
--- /dev/null
+++ b/libs/ui/tests/kis_derived_resources_test.cpp
@@ -0,0 +1,106 @@
+/*
+ *  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_derived_resources_test.h"
+
+#include <QTest>
+#include <brushengine/kis_paintop_preset.h>
+
+#include <QApplication>
+
+#include <KoCanvasResourceManager.h>
+
+#include "kis_canvas_resource_provider.h"
+#include <util.h>
+#include <KisMainWindow.h>
+#include <KisDocument.h>
+#include <KisPart.h>
+#include <KisView.h>
+#include <KisViewManager.h>
+#include <kis_paintop_settings.h>
+
+
+#include "testutil.h"
+
+
+
+void KisDerivedResourcesTest::test()
+{
+    KisDocument* doc = createEmptyDocument();
+    KisMainWindow* mainWindow = KisPart::instance()->createMainWindow();
+    QPointer<KisView> view = new KisView(doc, mainWindow->resourceManager(), mainWindow->actionCollection(), mainWindow);
+    KisViewManager *viewManager = new KisViewManager(mainWindow, mainWindow->actionCollection());
+    KoCanvasResourceManager *manager = viewManager->resourceProvider()->resourceManager();
+
+    QApplication::processEvents();
+
+    QString presetFileName = "autobrush_300px.kpp";
+
+    QVariant i;
+
+    KisPaintOpPresetSP preset;
+    if (!presetFileName.isEmpty()) {
+        QString fullFileName = TestUtil::fetchDataFileLazy(presetFileName);
+        preset = new KisPaintOpPreset(fullFileName);
+        bool presetValid = preset->load();
+        Q_ASSERT(presetValid); Q_UNUSED(presetValid);
+
+        i.setValue(preset);
+
+    }
+
+    QVERIFY(i.isValid());
+
+    QSignalSpy spy(manager, SIGNAL(canvasResourceChanged(int, const QVariant &)));
+
+    manager->setResource(KisCanvasResourceProvider::CurrentPaintOpPreset, i);
+
+    QCOMPARE(spy[0][0].toInt(), (int)KisCanvasResourceProvider::CurrentPaintOpPreset);
+    QCOMPARE(spy[0][1].value<KisPaintOpPresetSP>(), preset);
+
+    QCOMPARE(spy[1][0].toInt(), (int)KisCanvasResourceProvider::EraserMode);
+    QCOMPARE(spy[1][1].toBool(), false);
+
+    QCOMPARE(spy[2][0].toInt(), (int)KisCanvasResourceProvider::LodAvailability);
+    QCOMPARE(spy[2][1].toBool(), true);
+
+    QCOMPARE(spy[3][0].toInt(), (int)KisCanvasResourceProvider::Opacity);
+    QCOMPARE(spy[3][1].toDouble(), 1.0);
+
+    QCOMPARE(spy[4][0].toInt(), (int)KisCanvasResourceProvider::CurrentEffectiveCompositeOp);
+    QCOMPARE(spy[4][1].toString(), COMPOSITE_OVER);
+
+    spy.clear();
+
+    preset->settings()->setPaintOpOpacity(0.8);
+
+    QCOMPARE(spy.size(), 1);
+    QCOMPARE(spy[0][0].toInt(), (int)KisCanvasResourceProvider::Opacity);
+    QCOMPARE(spy[0][1].toDouble(), 0.8);
+    spy.clear();
+
+
+    mainWindow->hide();
+    QApplication::processEvents();
+
+    delete view;
+    delete doc;
+    delete mainWindow;
+}
+
+QTEST_MAIN(KisDerivedResourcesTest)
diff --git a/libs/image/brushengine/kis_paintop_settings_update_proxy.h b/libs/ui/tests/kis_derived_resources_test.h
similarity index 62%
copy from libs/image/brushengine/kis_paintop_settings_update_proxy.h
copy to libs/ui/tests/kis_derived_resources_test.h
index 8336ee5afa..813c9821ec 100644
--- a/libs/image/brushengine/kis_paintop_settings_update_proxy.h
+++ b/libs/ui/tests/kis_derived_resources_test.h
@@ -1,44 +1,31 @@
 /*
  *  Copyright (c) 2016 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
-#ifndef __KIS_PAINTOP_SETTINGS_UPDATE_PROXY_H
-#define __KIS_PAINTOP_SETTINGS_UPDATE_PROXY_H
+#ifndef __KIS_DERIVED_RESOURCES_TEST_H
+#define __KIS_DERIVED_RESOURCES_TEST_H
 
-#include <QScopedPointer>
-#include <QObject>
+#include <QtTest/QtTest>
 
-
-class KisPaintopSettingsUpdateProxy : public QObject
+class KisDerivedResourcesTest : public QObject
 {
     Q_OBJECT
-
-public:
-    KisPaintopSettingsUpdateProxy(QObject *parent = 0);
-    ~KisPaintopSettingsUpdateProxy();
-
-    void notifySettingsChanged();
-
-Q_SIGNALS:
-    void sigSettingsChanged();
-
-private:
-    struct Private;
-    const QScopedPointer<Private> m_d;
+private Q_SLOTS:
+    void test();
 };
 
-#endif /* __KIS_PAINTOP_SETTINGS_UPDATE_PROXY_H */
+#endif /* __KIS_DERIVED_RESOURCES_TEST_H */
diff --git a/libs/ui/tool/kis_tool_freehand.cc b/libs/ui/tool/kis_tool_freehand.cc
index 9db40f76cf..23f19ec06c 100644
--- a/libs/ui/tool/kis_tool_freehand.cc
+++ b/libs/ui/tool/kis_tool_freehand.cc
@@ -1,431 +1,433 @@
 /*
  *  kis_tool_freehand.cc - part of Krita
  *
  *  Copyright (c) 2003-2007 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2004 Bart Coppens <kde@bartcoppens.be>
  *  Copyright (c) 2007,2008,2010 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2009 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 "kis_tool_freehand.h"
 
 #include <QPainter>
 #include <QRect>
 #include <QThreadPool>
 
 #include <kis_icon.h>
 #include <KoPointerEvent.h>
 #include <KoViewConverter.h>
 #include <KoCanvasController.h>
 
 //pop up palette
 #include <kis_canvas_resource_provider.h>
 
 // Krita/image
 #include <kis_layer.h>
 #include <kis_paint_layer.h>
 #include <kis_painter.h>
 #include <brushengine/kis_paintop.h>
 #include <kis_selection.h>
 #include <brushengine/kis_paintop_preset.h>
 
 
 // Krita/ui
 #include "kis_abstract_perspective_grid.h"
 #include "kis_config.h"
 #include "canvas/kis_canvas2.h"
 #include "kis_cursor.h"
 #include <KisViewManager.h>
 #include <kis_painting_assistants_decoration.h>
 #include "kis_painting_information_builder.h"
 #include "kis_tool_freehand_helper.h"
 #include "kis_recording_adapter.h"
 #include "strokes/freehand_stroke.h"
 
 
 KisToolFreehand::KisToolFreehand(KoCanvasBase * canvas, const QCursor & cursor, const KUndo2MagicString &transactionText)
     : KisToolPaint(canvas, cursor),
       m_paintopBasedPickingInAction(false)
 {
     m_assistant = false;
     m_magnetism = 1.0;
     m_only_one_assistant = true;
 
     setSupportOutline(true);
     setMaskSyntheticEvents(true); // Disallow mouse events from finger presses.
 
     m_infoBuilder = new KisToolFreehandPaintingInformationBuilder(this);
     m_recordingAdapter = new KisRecordingAdapter();
     m_helper = new KisToolFreehandHelper(m_infoBuilder, transactionText, m_recordingAdapter);
 
     connect(m_helper, SIGNAL(requestExplicitUpdateOutline()),
             SLOT(explicitUpdateOutline()));
 }
 
 KisToolFreehand::~KisToolFreehand()
 {
     delete m_helper;
     delete m_recordingAdapter;
     delete m_infoBuilder;
 }
 
 KisSmoothingOptionsSP KisToolFreehand::smoothingOptions() const
 {
     return m_helper->smoothingOptions();
 }
 
 void KisToolFreehand::resetCursorStyle()
 {
     KisConfig cfg;
 
     switch (cfg.newCursorStyle()) {
     case CURSOR_STYLE_NO_CURSOR:
         useCursor(KisCursor::blankCursor());
         break;
     case CURSOR_STYLE_POINTER:
         useCursor(KisCursor::arrowCursor());
         break;
     case CURSOR_STYLE_SMALL_ROUND:
         useCursor(KisCursor::roundCursor());
         break;
     case CURSOR_STYLE_CROSSHAIR:
         useCursor(KisCursor::crossCursor());
         break;
     case CURSOR_STYLE_TRIANGLE_RIGHTHANDED:
         useCursor(KisCursor::triangleRightHandedCursor());
         break;
     case CURSOR_STYLE_TRIANGLE_LEFTHANDED:
         useCursor(KisCursor::triangleLeftHandedCursor());
         break;
     case CURSOR_STYLE_BLACK_PIXEL:
         useCursor(KisCursor::pixelBlackCursor());
         break;
     case CURSOR_STYLE_WHITE_PIXEL:
         useCursor(KisCursor::pixelWhiteCursor());
         break;
     case CURSOR_STYLE_TOOLICON:
     default:
         KisToolPaint::resetCursorStyle();
         break;
     }
 }
 
 KisPaintingInformationBuilder* KisToolFreehand::paintingInformationBuilder() const
 {
     return m_infoBuilder;
 }
 
 KisRecordingAdapter* KisToolFreehand::recordingAdapter() const
 {
     return m_recordingAdapter;
 }
 
 void KisToolFreehand::resetHelper(KisToolFreehandHelper *helper)
 {
     delete m_helper;
     m_helper = helper;
 }
 
 int KisToolFreehand::flags() const
 {
     return KisTool::FLAG_USES_CUSTOM_COMPOSITEOP|KisTool::FLAG_USES_CUSTOM_PRESET;
 }
 
 void KisToolFreehand::activate(ToolActivation activation, const QSet<KoShape*> &shapes)
 {
     KisToolPaint::activate(activation, shapes);
 }
 
 void KisToolFreehand::deactivate()
 {
     if (mode() == PAINT_MODE) {
         endStroke();
         setMode(KisTool::HOVER_MODE);
     }
     KisToolPaint::deactivate();
 }
 
 void KisToolFreehand::initStroke(KoPointerEvent *event)
 {
     setCurrentNodeLocked(true);
 
     m_helper->initPaint(event, canvas()->resourceManager(),
                         image(),
                         currentNode(),
                         image().data(),
                         image()->postExecutionUndoAdapter());
 }
 
 void KisToolFreehand::doStroke(KoPointerEvent *event)
 {
     //set canvas information here?//
     KisCanvas2 *canvas2 = dynamic_cast<KisCanvas2 *>(canvas());
     if (canvas2) {
         m_helper->setCanvasHorizontalMirrorState(canvas2->xAxisMirrored());
         m_helper->setCanvasRotation(canvas2->rotationAngle());
     }
     m_helper->paint(event);
 }
 
 void KisToolFreehand::endStroke()
 {
     m_helper->endPaint();
     setCurrentNodeLocked(false);
 }
 
 bool KisToolFreehand::primaryActionSupportsHiResEvents() const
 {
     return true;
 }
 
 void KisToolFreehand::beginPrimaryAction(KoPointerEvent *event)
 {
     // FIXME: workaround for the Duplicate Op
     tryPickByPaintOp(event, PickFgImage);
 
     requestUpdateOutline(event->point, event);
 
     NodePaintAbility paintability = nodePaintAbility();
     if (!nodeEditable() || paintability != PAINT) {
         if(paintability == KisToolPaint::VECTOR){
             KisCanvas2 * kiscanvas = static_cast<KisCanvas2*>(canvas());
             QString message = i18n("The brush tool cannot paint on this layer.  Please select a paint layer or mask.");
             kiscanvas->viewManager()->showFloatingMessage(message, koIcon("object-locked"));
         }
         event->ignore();
 
         return;
     }
 
     setMode(KisTool::PAINT_MODE);
 
     KisCanvas2 *canvas2 = dynamic_cast<KisCanvas2 *>(canvas());
     if (canvas2) {
         canvas2->viewManager()->disableControls();
     }
 
     initStroke(event);
 }
 
 void KisToolFreehand::continuePrimaryAction(KoPointerEvent *event)
 {
     CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
 
     requestUpdateOutline(event->point, event);
 
     /**
      * Actual painting
      */
     doStroke(event);
 }
 
 void KisToolFreehand::endPrimaryAction(KoPointerEvent *event)
 {
     Q_UNUSED(event);
     CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
 
     endStroke();
 
     if (m_assistant && static_cast<KisCanvas2*>(canvas())->paintingAssistantsDecoration()) {
         static_cast<KisCanvas2*>(canvas())->paintingAssistantsDecoration()->endStroke();
     }
 
     notifyModified();
     KisCanvas2 *canvas2 = dynamic_cast<KisCanvas2 *>(canvas());
     if (canvas2) {
         canvas2->viewManager()->enableControls();
     }
 
     setMode(KisTool::HOVER_MODE);
 }
 
 bool KisToolFreehand::tryPickByPaintOp(KoPointerEvent *event, AlternateAction action)
 {
     if (action != PickFgNode && action != PickFgImage) return false;
 
     /**
      * FIXME: we need some better way to implement modifiers
      * for a paintop level. This method is used in DuplicateOp only!
      */
     QPointF pos = adjustPosition(event->point, event->point);
     qreal perspective = 1.0;
     Q_FOREACH (const QPointer<KisAbstractPerspectiveGrid> grid, static_cast<KisCanvas2*>(canvas())->viewManager()->resourceProvider()->perspectiveGrids()) {
         if (grid && grid->contains(pos)) {
             perspective = grid->distance(pos);
             break;
         }
     }
     if (!currentPaintOpPreset()) {
         return false;
     }
     bool paintOpIgnoredEvent = currentPaintOpPreset()->settings()->
         mousePressEvent(KisPaintInformation(convertToPixelCoord(event->point),
                                             pressureToCurve(event->pressure()),
                                             event->xTilt(), event->yTilt(),
                                             event->rotation(),
                                             event->tangentialPressure(),
                                             perspective, 0, 0),
                         event->modifiers(),
                         currentNode());
     return !paintOpIgnoredEvent;
 }
 
 void KisToolFreehand::activateAlternateAction(AlternateAction action)
 {
     if (action != ChangeSize) {
         KisToolPaint::activateAlternateAction(action);
         return;
     }
 
     useCursor(KisCursor::blankCursor());
     setOutlineEnabled(true);
 }
 
 void KisToolFreehand::deactivateAlternateAction(AlternateAction action)
 {
     if (action != ChangeSize) {
         KisToolPaint::deactivateAlternateAction(action);
         return;
     }
 
     resetCursorStyle();
     setOutlineEnabled(false);
 }
 
 void KisToolFreehand::beginAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     if (tryPickByPaintOp(event, action)) {
         m_paintopBasedPickingInAction = true;
         return;
     }
 
     if (action != ChangeSize) {
         KisToolPaint::beginAlternateAction(event, action);
         return;
     }
 
     setMode(GESTURE_MODE);
     m_initialGestureDocPoint = event->point;
     m_initialGestureGlobalPoint = QCursor::pos();
 
     m_lastDocumentPoint = event->point;
 }
 
 void KisToolFreehand::continueAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     if (tryPickByPaintOp(event, action) || m_paintopBasedPickingInAction) return;
 
     if (action != ChangeSize) {
         KisToolPaint::continueAlternateAction(event, action);
         return;
     }
 
     QPointF lastWidgetPosition = convertDocumentToWidget(m_lastDocumentPoint);
     QPointF actualWidgetPosition = convertDocumentToWidget(event->point);
 
     QPointF offset = actualWidgetPosition - lastWidgetPosition;
 
     /**
      * view pixels != widget pixels, but we do this anyway, we only
      * need to scale the gesture down, not rotate or anything
      */
     QPointF scaledOffset = canvas()->viewConverter()->viewToDocument(offset);
 
     if (qRound(scaledOffset.x()) != 0) {
-        currentPaintOpPreset()->settings()->changePaintOpSize(scaledOffset.x(), scaledOffset.y());
+        KisPaintOpSettingsSP settings = currentPaintOpPreset()->settings();
+        const qreal newSize = settings->paintOpSize() + scaledOffset.x();
+        settings->setPaintOpSize(newSize);
         requestUpdateOutline(m_initialGestureDocPoint, 0);
 
         m_lastDocumentPoint = event->point;
     }
 }
 
 void KisToolFreehand::endAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     if (tryPickByPaintOp(event, action) || m_paintopBasedPickingInAction) {
         m_paintopBasedPickingInAction = false;
         return;
     }
 
     if (action != ChangeSize) {
         KisToolPaint::endAlternateAction(event, action);
         return;
     }
 
     QCursor::setPos(m_initialGestureGlobalPoint);
     requestUpdateOutline(m_initialGestureDocPoint, 0);
 
     setMode(HOVER_MODE);
 }
 
 bool KisToolFreehand::wantsAutoScroll() const
 {
     return false;
 }
 
 void KisToolFreehand::setAssistant(bool assistant)
 {
     m_assistant = assistant;
 }
 
 void KisToolFreehand::setOnlyOneAssistantSnap(bool assistant)
 {
     m_only_one_assistant = assistant;
 }
 
 QPointF KisToolFreehand::adjustPosition(const QPointF& point, const QPointF& strokeBegin)
 {
     if (m_assistant && static_cast<KisCanvas2*>(canvas())->paintingAssistantsDecoration()) {
         static_cast<KisCanvas2*>(canvas())->paintingAssistantsDecoration()->setOnlyOneAssistantSnap(m_only_one_assistant);
         QPointF ap = static_cast<KisCanvas2*>(canvas())->paintingAssistantsDecoration()->adjustPosition(point, strokeBegin);
         return (1.0 - m_magnetism) * point + m_magnetism * ap;
     }
     return point;
 }
 
 qreal KisToolFreehand::calculatePerspective(const QPointF &documentPoint)
 {
     qreal perspective = 1.0;
     Q_FOREACH (const QPointer<KisAbstractPerspectiveGrid> grid, static_cast<KisCanvas2*>(canvas())->viewManager()->resourceProvider()->perspectiveGrids()) {
         if (grid && grid->contains(documentPoint)) {
             perspective = grid->distance(documentPoint);
             break;
         }
     }
     return perspective;
 }
 
 void KisToolFreehand::explicitUpdateOutline()
 {
     requestUpdateOutline(m_outlineDocPoint, 0);
 }
 
 QPainterPath KisToolFreehand::getOutlinePath(const QPointF &documentPos,
                                              const KoPointerEvent *event,
                                              KisPaintOpSettings::OutlineMode outlineMode)
 {
     QPointF imagePos = currentImage()->documentToPixel(documentPos);
 
     if (currentPaintOpPreset())
         return m_helper->paintOpOutline(imagePos,
                                         event,
                                         currentPaintOpPreset()->settings(),
                                         outlineMode);
     else
         return QPainterPath();
 }
 
 
diff --git a/libs/ui/tool/kis_tool_paint.cc b/libs/ui/tool/kis_tool_paint.cc
index 8f99784fa4..27147a937c 100644
--- a/libs/ui/tool/kis_tool_paint.cc
+++ b/libs/ui/tool/kis_tool_paint.cc
@@ -1,775 +1,772 @@
 /*
  *  Copyright (c) 2003-2009 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2015 Moritz Molch <kde@moritzmolch.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_tool_paint.h"
 
 #include <algorithm>
 
 #include <QWidget>
 #include <QRect>
 #include <QLayout>
 #include <QLabel>
 #include <QPushButton>
 #include <QWhatsThis>
 #include <QCheckBox>
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 #include <QGridLayout>
 #include <QKeyEvent>
 #include <QEvent>
 #include <QVariant>
 #include <QAction>
 #include <kis_debug.h>
 #include <QPoint>
 
 #include <kis_debug.h>
 #include <klocalizedstring.h>
 #include <kactioncollection.h>
 #include <QAction>
 
 #include <kis_icon.h>
 #include <KoShape.h>
 #include <KoCanvasResourceManager.h>
 #include <KoColorSpace.h>
 #include <KoPointerEvent.h>
 #include <KoColor.h>
 #include <KoCanvasBase.h>
 #include <KoCanvasController.h>
 
 #include <kis_types.h>
 #include <kis_global.h>
 #include <kis_image.h>
 #include <kis_paint_device.h>
 #include <kis_layer.h>
 #include <KisViewManager.h>
 #include <kis_canvas2.h>
 #include <kis_cubic_curve.h>
 #include "kis_display_color_converter.h"
 
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_cursor.h"
 #include "widgets/kis_cmb_composite.h"
 #include "widgets/kis_slider_spin_box.h"
 #include "kis_canvas_resource_provider.h"
 #include <recorder/kis_recorded_paint_action.h>
 #include "kis_tool_utils.h"
 #include <brushengine/kis_paintop.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <kis_action_manager.h>
 #include <kis_action.h>
 #include "strokes/kis_color_picker_stroke_strategy.h"
 
 
 KisToolPaint::KisToolPaint(KoCanvasBase * canvas, const QCursor & cursor)
     : KisTool(canvas, cursor),
       m_showColorPreview(false),
       m_colorPreviewShowComparePlate(false),
       m_colorPickerDelayTimer(),
       m_isOutlineEnabled(true)
 {
     m_specialHoverModifier = false;
     m_optionsWidgetLayout = 0;
 
     m_opacity = OPACITY_OPAQUE_U8;
 
     updateTabletPressureSamples();
 
     m_supportOutline = false;
 
     {
         const int maxSize = 1000;
 
         int brushSize = 1;
         do {
             m_standardBrushSizes.push_back(brushSize);
             int increment = qMax(1, int(std::ceil(qreal(brushSize) / 15)));
             brushSize += increment;
         } while (brushSize < maxSize);
 
         m_standardBrushSizes.push_back(maxSize);
     }
 
     KisCanvas2 * kiscanvas = dynamic_cast<KisCanvas2*>(canvas);
     KisActionManager *actionManager = kiscanvas->viewManager()->actionManager();
 
     // XXX: Perhaps a better place for these?
     if (!actionManager->actionByName("increase_brush_size")) {
         KisAction *increaseBrushSize = new KisAction(i18n("Increase Brush Size"));
         increaseBrushSize->setShortcut(Qt::Key_BracketRight);
         actionManager->addAction("increase_brush_size", increaseBrushSize);
     }
 
     if (!actionManager->actionByName("decrease_brush_size")) {
         KisAction *decreaseBrushSize = new KisAction(i18n("Decrease Brush Size"));
         decreaseBrushSize->setShortcut(Qt::Key_BracketLeft);
         actionManager->addAction("decrease_brush_size", decreaseBrushSize);
     }
 
     addAction("increase_brush_size", dynamic_cast<QAction *>(actionManager->actionByName("increase_brush_size")));
     addAction("decrease_brush_size", dynamic_cast<QAction *>(actionManager->actionByName("decrease_brush_size")));
 
     if (kiscanvas && kiscanvas->viewManager()) {
         connect(this, SIGNAL(sigPaintingFinished()), kiscanvas->viewManager()->resourceProvider(), SLOT(slotPainting()));
     }
 
     m_colorPickerDelayTimer.setSingleShot(true);
     connect(&m_colorPickerDelayTimer, SIGNAL(timeout()), this, SLOT(activatePickColorDelayed()));
 
     using namespace std::placeholders; // For _1 placeholder
     std::function<void(PickingJob)> callback =
         std::bind(&KisToolPaint::addPickerJob, this, _1);
     m_colorPickingCompressor.reset(
         new PickingCompressor(100, callback, KisSignalCompressor::FIRST_ACTIVE));
 }
 
 
 KisToolPaint::~KisToolPaint()
 {
 }
 
 int KisToolPaint::flags() const
 {
     return KisTool::FLAG_USES_CUSTOM_COMPOSITEOP;
 }
 
 void KisToolPaint::canvasResourceChanged(int key, const QVariant& v)
 {
     KisTool::canvasResourceChanged(key, v);
 
     switch(key) {
     case(KisCanvasResourceProvider::Opacity):
         setOpacity(v.toDouble());
         break;
     default: //nothing
         break;
     }
 
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(resetCursorStyle()), Qt::UniqueConnection);
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(updateTabletPressureSamples()), Qt::UniqueConnection);
 
 }
 
 
 void KisToolPaint::activate(ToolActivation toolActivation, const QSet<KoShape*> &shapes)
 {
     if (currentPaintOpPreset()) emit statusTextChanged(currentPaintOpPreset()->name());
     KisTool::activate(toolActivation, shapes);
     connect(actions().value("increase_brush_size"), SIGNAL(triggered()), SLOT(increaseBrushSize()), Qt::UniqueConnection);
     connect(actions().value("decrease_brush_size"), SIGNAL(triggered()), SLOT(decreaseBrushSize()), Qt::UniqueConnection);
 }
 
 void KisToolPaint::deactivate()
 {
     disconnect(actions().value("increase_brush_size"), 0, this, 0);
     disconnect(actions().value("decrease_brush_size"), 0, this, 0);
     KisTool::deactivate();
 }
 
 QPainterPath KisToolPaint::tryFixBrushOutline(const QPainterPath &originalOutline)
 {
     KisConfig cfg;
     if (cfg.newOutlineStyle() == OUTLINE_NONE) return originalOutline;
 
     const qreal minThresholdSize = cfg.outlineSizeMinimum();
 
     /**
      * If the brush outline is bigger than the canvas itself (which
      * would make it invisible for a user in most of the cases) just
      * add a cross in the center of it
      */
 
     QSize widgetSize = canvas()->canvasWidget()->size();
     const int maxThresholdSum = widgetSize.width() + widgetSize.height();
 
     QPainterPath outline = originalOutline;
     QRectF boundingRect = outline.boundingRect();
     const qreal sum = boundingRect.width() + boundingRect.height();
 
     QPointF center = boundingRect.center();
 
     if (sum > maxThresholdSum) {
         const int hairOffset = 7;
 
         outline.moveTo(center.x(), center.y() - hairOffset);
         outline.lineTo(center.x(), center.y() + hairOffset);
 
         outline.moveTo(center.x() - hairOffset, center.y());
         outline.lineTo(center.x() + hairOffset, center.y());
     } else if (sum < minThresholdSize && !outline.isEmpty()) {
         outline = QPainterPath();
         outline.addEllipse(center, 0.5 * minThresholdSize, 0.5 * minThresholdSize);
     }
 
     return outline;
 }
 
 void KisToolPaint::paint(QPainter &gc, const KoViewConverter &converter)
 {
     Q_UNUSED(converter);
 
     QPainterPath path = tryFixBrushOutline(pixelToView(m_currentOutline));
     paintToolOutline(&gc, path);
 
     if (m_showColorPreview) {
         QRectF viewRect = converter.documentToView(m_oldColorPreviewRect);
         gc.fillRect(viewRect, m_colorPreviewCurrentColor);
 
         if (m_colorPreviewShowComparePlate) {
             QRectF baseColorRect = viewRect.translated(viewRect.width(), 0);
             gc.fillRect(baseColorRect, m_colorPreviewBaseColor);
         }
     }
 }
 
 void KisToolPaint::setMode(ToolMode mode)
 {
     if(this->mode() == KisTool::PAINT_MODE &&
             mode != KisTool::PAINT_MODE) {
 
         // Let's add history information about recently used colors
         emit sigPaintingFinished();
     }
 
     KisTool::setMode(mode);
 }
 
 void KisToolPaint::activatePickColor(AlternateAction action)
 {
     m_showColorPreview = true;
 
     requestUpdateOutline(m_outlineDocPoint, 0);
 
     int resource = colorPreviewResourceId(action);
     KoColor color = canvas()->resourceManager()->koColorResource(resource);
 
     KisCanvas2 * kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     KIS_ASSERT_RECOVER_RETURN(kisCanvas);
 
     m_colorPreviewCurrentColor = kisCanvas->displayColorConverter()->toQColor(color);
 
     if (!m_colorPreviewBaseColor.isValid()) {
         m_colorPreviewBaseColor = m_colorPreviewCurrentColor;
     }
 }
 
 void KisToolPaint::deactivatePickColor(AlternateAction action)
 {
     Q_UNUSED(action);
 
     m_showColorPreview = false;
     m_oldColorPreviewRect = QRect();
     m_oldColorPreviewUpdateRect = QRect();
     m_colorPreviewCurrentColor = QColor();
 }
 
 void KisToolPaint::pickColorWasOverridden()
 {
     m_colorPreviewShowComparePlate = false;
     m_colorPreviewBaseColor = QColor();
 }
 
 void KisToolPaint::activateAlternateAction(AlternateAction action)
 {
     switch (action) {
     case PickFgNode:
     case PickBgNode:
     case PickFgImage:
     case PickBgImage:
         delayedAction = action;
         m_colorPickerDelayTimer.start(100);
     default:
         pickColorWasOverridden();
         KisTool::activateAlternateAction(action);
     };
 }
 
 void KisToolPaint::activatePickColorDelayed()
 {
     switch (delayedAction) {
         case PickFgNode:
         useCursor(KisCursor::pickerLayerForegroundCursor());
         activatePickColor(delayedAction);
         break;
     case PickBgNode:
         useCursor(KisCursor::pickerLayerBackgroundCursor());
         activatePickColor(delayedAction);
         break;
     case PickFgImage:
         useCursor(KisCursor::pickerImageForegroundCursor());
         activatePickColor(delayedAction);
         break;
     case PickBgImage:
         useCursor(KisCursor::pickerImageBackgroundCursor());
         activatePickColor(delayedAction);
         break;
     default:
         break;
     };
 
     repaintDecorations();
 
 }
 
 bool KisToolPaint::isPickingAction(AlternateAction action) {
     return action == PickFgNode ||
         action == PickBgNode ||
         action == PickFgImage ||
         action == PickBgImage;
 }
 
 void KisToolPaint::deactivateAlternateAction(AlternateAction action)
 {
     if (!isPickingAction(action)) {
         KisTool::deactivateAlternateAction(action);
         return;
     }
 
     delayedAction = KisTool::NONE;
     m_colorPickerDelayTimer.stop();
 
     resetCursorStyle();
     deactivatePickColor(action);
 }
 
 void KisToolPaint::addPickerJob(const PickingJob &pickingJob)
 {
     /**
      * The actual picking is delayed by a compressor, so we can get this
      * event when the stroke is already closed
      */
     if (!m_pickerStrokeId) return;
 
     KIS_ASSERT_RECOVER_RETURN(isPickingAction(pickingJob.action));
 
     const QPoint imagePoint = image()->documentToIntPixel(pickingJob.documentPixel);
     const bool fromCurrentNode = pickingJob.action == PickFgNode || pickingJob.action == PickBgNode;
     m_pickingResource = colorPreviewResourceId(pickingJob.action);
 
     KisPaintDeviceSP device = fromCurrentNode ?
         currentNode()->projection() : image()->projection();
 
     image()->addJob(m_pickerStrokeId,
                     new KisColorPickerStrokeStrategy::Data(device, imagePoint));
 }
 
 void KisToolPaint::beginAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     if (isPickingAction(action)) {
         KIS_ASSERT_RECOVER_RETURN(!m_pickerStrokeId);
         setMode(SECONDARY_PAINT_MODE);
 
         KisColorPickerStrokeStrategy *strategy = new KisColorPickerStrokeStrategy();
         connect(strategy, &KisColorPickerStrokeStrategy::sigColorUpdated,
                 this, &KisToolPaint::slotColorPickingFinished);
 
         m_pickerStrokeId = image()->startStroke(strategy);
         m_colorPickingCompressor->start(PickingJob(event->point, action));
         requestUpdateOutline(event->point, event);
     } else {
         KisTool::beginAlternateAction(event, action);
     }
 }
 
 void KisToolPaint::continueAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     if (isPickingAction(action)) {
         KIS_ASSERT_RECOVER_RETURN(m_pickerStrokeId);
         m_colorPickingCompressor->start(PickingJob(event->point, action));
         requestUpdateOutline(event->point, event);
     } else {
         KisTool::continueAlternateAction(event, action);
     }
 }
 
 void KisToolPaint::endAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     if (isPickingAction(action)) {
         KIS_ASSERT_RECOVER_RETURN(m_pickerStrokeId);
         image()->endStroke(m_pickerStrokeId);
         m_pickerStrokeId.clear();
         requestUpdateOutline(event->point, event);
         setMode(HOVER_MODE);
     } else {
         KisTool::endAlternateAction(event, action);
     }
 }
 
 int KisToolPaint::colorPreviewResourceId(AlternateAction action)
 {
     bool toForegroundColor = action == PickFgNode || action == PickFgImage;
     int resource = toForegroundColor ?
         KoCanvasResourceManager::ForegroundColor : KoCanvasResourceManager::BackgroundColor;
 
     return resource;
 }
 
 void KisToolPaint::slotColorPickingFinished(const KoColor &color)
 {
     canvas()->resourceManager()->setResource(m_pickingResource, color);
 
     if (!m_showColorPreview) return;
 
     KisCanvas2 * kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     KIS_ASSERT_RECOVER_RETURN(kisCanvas);
     QColor previewColor = kisCanvas->displayColorConverter()->toQColor(color);
 
     m_colorPreviewShowComparePlate = true;
     m_colorPreviewCurrentColor = previewColor;
 
     requestUpdateOutline(m_outlineDocPoint, 0);
 }
 
 void KisToolPaint::mousePressEvent(KoPointerEvent *event)
 {
     KisTool::mousePressEvent(event);
     if (mode() == KisTool::HOVER_MODE) {
         requestUpdateOutline(event->point, event);
     }
 }
 
 void KisToolPaint::mouseMoveEvent(KoPointerEvent *event)
 {
     KisTool::mouseMoveEvent(event);
     if (mode() == KisTool::HOVER_MODE) {
         requestUpdateOutline(event->point, event);
     }
 }
 
 void KisToolPaint::mouseReleaseEvent(KoPointerEvent *event)
 {
     KisTool::mouseReleaseEvent(event);
     if (mode() == KisTool::HOVER_MODE) {
         requestUpdateOutline(event->point, event);
     }
 }
 
 QWidget * KisToolPaint::createOptionWidget()
 {
     QWidget * optionWidget = new QWidget();
     optionWidget->setObjectName(toolId());
 
     QVBoxLayout* verticalLayout = new QVBoxLayout(optionWidget);
     verticalLayout->setObjectName("KisToolPaint::OptionWidget::VerticalLayout");
     verticalLayout->setContentsMargins(0,0,0,0);
     verticalLayout->setSpacing(1);
 
     // See https://bugs.kde.org/show_bug.cgi?id=316896
     QWidget *specialSpacer = new QWidget(optionWidget);
     specialSpacer->setObjectName("SpecialSpacer");
     specialSpacer->setFixedSize(0, 0);
     verticalLayout->addWidget(specialSpacer);
     verticalLayout->addWidget(specialSpacer);
 
     m_optionsWidgetLayout = new QGridLayout();
     m_optionsWidgetLayout->setColumnStretch(1, 1);
 
     verticalLayout->addLayout(m_optionsWidgetLayout);
     m_optionsWidgetLayout->setContentsMargins(0,0,0,0);
     m_optionsWidgetLayout->setSpacing(1);
 
     if (!quickHelp().isEmpty()) {
         QPushButton* push = new QPushButton(KisIconUtils::loadIcon("help-contents"), QString(), optionWidget);
         connect(push, SIGNAL(clicked()), this, SLOT(slotPopupQuickHelp()));
 
         QHBoxLayout* hLayout = new QHBoxLayout(optionWidget);
         hLayout->addWidget(push);
         hLayout->addItem(new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Fixed));
         verticalLayout->addLayout(hLayout);
     }
 
     return optionWidget;
 }
 
 QWidget* findLabelWidget(QGridLayout *layout, QWidget *control)
 {
     QWidget *result = 0;
 
     int index = layout->indexOf(control);
 
     int row, col, rowSpan, colSpan;
     layout->getItemPosition(index, &row, &col, &rowSpan, &colSpan);
 
     if (col > 0) {
         QLayoutItem *item = layout->itemAtPosition(row, col - 1);
 
         if (item) {
             result = item->widget();
         }
     } else {
         QLayoutItem *item = layout->itemAtPosition(row, col + 1);
         if (item) {
             result = item->widget();
         }
     }
 
     return result;
 }
 
 void KisToolPaint::showControl(QWidget *control, bool value)
 {
     control->setVisible(value);
     QWidget *label = findLabelWidget(m_optionsWidgetLayout, control);
     if (label) {
         label->setVisible(value);
     }
 }
 
 void KisToolPaint::enableControl(QWidget *control, bool value)
 {
     control->setEnabled(value);
     QWidget *label = findLabelWidget(m_optionsWidgetLayout, control);
     if (label) {
         label->setEnabled(value);
     }
 }
 
 void KisToolPaint::addOptionWidgetLayout(QLayout *layout)
 {
     Q_ASSERT(m_optionsWidgetLayout != 0);
     int rowCount = m_optionsWidgetLayout->rowCount();
     m_optionsWidgetLayout->addLayout(layout, rowCount, 0, 1, 2);
 }
 
 
 void KisToolPaint::addOptionWidgetOption(QWidget *control, QWidget *label)
 {
     Q_ASSERT(m_optionsWidgetLayout != 0);
     if (label) {
         m_optionsWidgetLayout->addWidget(label, m_optionsWidgetLayout->rowCount(), 0);
         m_optionsWidgetLayout->addWidget(control, m_optionsWidgetLayout->rowCount() - 1, 1);
     }
     else {
         m_optionsWidgetLayout->addWidget(control, m_optionsWidgetLayout->rowCount(), 0, 1, 2);
     }
 }
 
 
 void KisToolPaint::setOpacity(qreal opacity)
 {
     m_opacity = quint8(opacity * OPACITY_OPAQUE_U8);
 }
 
 const KoCompositeOp* KisToolPaint::compositeOp()
 {
     if (currentNode()) {
         KisPaintDeviceSP device = currentNode()->paintDevice();
         if (device) {
             QString op = canvas()->resourceManager()->resource(KisCanvasResourceProvider::CurrentCompositeOp).toString();
             return device->colorSpace()->compositeOp(op);
         }
     }
     return 0;
 }
 
 void KisToolPaint::slotPopupQuickHelp()
 {
     QWhatsThis::showText(QCursor::pos(), quickHelp());
 }
 
 void KisToolPaint::updateTabletPressureSamples()
 {
     KisConfig cfg;
     KisCubicCurve curve;
     curve.fromString(cfg.pressureTabletCurve());
     m_pressureSamples = curve.floatTransfer(LEVEL_OF_PRESSURE_RESOLUTION + 1);
 }
 
 void KisToolPaint::setupPaintAction(KisRecordedPaintAction* action)
 {
     KisTool::setupPaintAction(action);
     action->setOpacity(m_opacity / qreal(255.0));
     const KoCompositeOp* op = compositeOp();
     if (op) {
         action->setCompositeOp(op->id());
     }
 }
 
 KisToolPaint::NodePaintAbility KisToolPaint::nodePaintAbility()
 {
     KisNodeSP node = currentNode();
     if (!node || node->systemLocked()) {
         return NONE;
     }
     if (node->inherits("KisShapeLayer")) {
         return VECTOR;
     }
     if (node->paintDevice()) {
         return PAINT;
     }
     return NONE;
 }
 
 void KisToolPaint::activatePrimaryAction()
 {
     pickColorWasOverridden();
     setOutlineEnabled(true);
     KisTool::activatePrimaryAction();
 }
 
 void KisToolPaint::deactivatePrimaryAction()
 {
     setOutlineEnabled(false);
     KisTool::deactivatePrimaryAction();
 }
 
 bool KisToolPaint::isOutlineEnabled() const
 {
     return m_isOutlineEnabled;
 }
 
 void KisToolPaint::setOutlineEnabled(bool value)
 {
     m_isOutlineEnabled = value;
     requestUpdateOutline(m_outlineDocPoint, 0);
 }
 
 void KisToolPaint::increaseBrushSize()
 {
-    qreal paintopSize = currentPaintOpPreset()->settings()->paintOpSize().width();
+    qreal paintopSize = currentPaintOpPreset()->settings()->paintOpSize();
 
     std::vector<int>::iterator result =
         std::upper_bound(m_standardBrushSizes.begin(),
                          m_standardBrushSizes.end(),
                          qRound(paintopSize));
 
     int newValue = result != m_standardBrushSizes.end() ? *result : m_standardBrushSizes.back();
 
-    qreal increment = newValue - paintopSize;
-
-    currentPaintOpPreset()->settings()->changePaintOpSize(increment, 0);
+    currentPaintOpPreset()->settings()->setPaintOpSize(newValue);
     requestUpdateOutline(m_outlineDocPoint, 0);
 }
 
 void KisToolPaint::decreaseBrushSize()
 {
-    qreal paintopSize = currentPaintOpPreset()->settings()->paintOpSize().width();
+    qreal paintopSize = currentPaintOpPreset()->settings()->paintOpSize();
 
     std::vector<int>::reverse_iterator result =
         std::upper_bound(m_standardBrushSizes.rbegin(),
                          m_standardBrushSizes.rend(),
                          (int)paintopSize,
                          std::greater<int>());
 
     int newValue = result != m_standardBrushSizes.rend() ? *result : m_standardBrushSizes.front();
-    qreal decrement = newValue - paintopSize;
 
-    currentPaintOpPreset()->settings()->changePaintOpSize(decrement, 0);
+    currentPaintOpPreset()->settings()->setPaintOpSize(newValue);
     requestUpdateOutline(m_outlineDocPoint, 0);
 }
 
 QRectF KisToolPaint::colorPreviewDocRect(const QPointF &outlineDocPoint)
 {
     if (!m_showColorPreview) return QRect();
 
     KisConfig cfg;
 
     const QRectF colorPreviewViewRect = cfg.colorPreviewRect();
     const QRectF colorPreviewDocumentRect = canvas()->viewConverter()->viewToDocument(colorPreviewViewRect);
 
     return colorPreviewDocumentRect.translated(outlineDocPoint);
 }
 
 void KisToolPaint::requestUpdateOutline(const QPointF &outlineDocPoint, const KoPointerEvent *event)
 {
     if (!m_supportOutline) return;
 
     KisConfig cfg;
     KisPaintOpSettings::OutlineMode outlineMode;
     outlineMode = KisPaintOpSettings::CursorNoOutline;
 
     if (isOutlineEnabled() &&
         (mode() == KisTool::GESTURE_MODE ||
          ((cfg.newOutlineStyle() == OUTLINE_FULL ||
            cfg.newOutlineStyle() == OUTLINE_CIRCLE ||
            cfg.newOutlineStyle() == OUTLINE_TILT ||
            cfg.newOutlineStyle() == OUTLINE_COLOR ) &&
           ((mode() == HOVER_MODE) ||
            (mode() == PAINT_MODE && cfg.showOutlineWhilePainting()))))) { // lisp forever!
 
         if(cfg.newOutlineStyle() == OUTLINE_CIRCLE) {
             outlineMode = KisPaintOpSettings::CursorIsCircleOutline;
         } else if(cfg.newOutlineStyle() == OUTLINE_TILT) {
             outlineMode = KisPaintOpSettings::CursorTiltOutline;
         } else if(cfg.newOutlineStyle() == OUTLINE_COLOR) {
             outlineMode = KisPaintOpSettings::CursorColorOutline;
         } else {
             outlineMode = KisPaintOpSettings::CursorIsOutline;
         }
     }
 
     m_outlineDocPoint = outlineDocPoint;
     m_currentOutline = getOutlinePath(m_outlineDocPoint, event, outlineMode);
 
     QRectF outlinePixelRect = m_currentOutline.boundingRect();
     QRectF outlineDocRect = currentImage()->pixelToDocument(outlinePixelRect);
 
     // This adjusted call is needed as we paint with a 3 pixel wide brush and the pen is outside the bounds of the path
     // Pen uses view coordinates so we have to zoom the document value to match 2 pixel in view coordiates
     // See BUG 275829
     qreal zoomX;
     qreal zoomY;
     canvas()->viewConverter()->zoom(&zoomX, &zoomY);
     qreal xoffset = 2.0/zoomX;
     qreal yoffset = 2.0/zoomY;
 
     if (!outlineDocRect.isEmpty()) {
         outlineDocRect.adjust(-xoffset,-yoffset,xoffset,yoffset);
     }
 
     QRectF colorPreviewDocRect = this->colorPreviewDocRect(m_outlineDocPoint);
     QRectF colorPreviewDocUpdateRect;
     if (!colorPreviewDocRect.isEmpty()) {
         colorPreviewDocUpdateRect.adjust(-xoffset,-yoffset,xoffset,yoffset);
     }
 
     if (!m_oldColorPreviewUpdateRect.isEmpty()) {
         canvas()->updateCanvas(m_oldColorPreviewUpdateRect);
     }
 
     if (!m_oldOutlineRect.isEmpty()) {
         canvas()->updateCanvas(m_oldOutlineRect);
     }
 
     if (!outlineDocRect.isEmpty()) {
         canvas()->updateCanvas(outlineDocRect);
     }
 
     if (!colorPreviewDocUpdateRect.isEmpty()) {
         canvas()->updateCanvas(colorPreviewDocUpdateRect);
     }
 
     m_oldOutlineRect = outlineDocRect;
     m_oldColorPreviewRect = colorPreviewDocRect;
     m_oldColorPreviewUpdateRect = colorPreviewDocUpdateRect;
 }
 
 QPainterPath KisToolPaint::getOutlinePath(const QPointF &documentPos,
                                           const KoPointerEvent *event,
                                           KisPaintOpSettings::OutlineMode outlineMode)
 {
     Q_UNUSED(event);
 
     QPointF imagePos = currentImage()->documentToPixel(documentPos);
     QPainterPath path = currentPaintOpPreset()->settings()->
         brushOutline(KisPaintInformation(imagePos), outlineMode);
 
     return path;
 }
 
diff --git a/libs/ui/widgets/kis_paintop_presets_popup.cpp b/libs/ui/widgets/kis_paintop_presets_popup.cpp
index 566507c82a..d19cecae81 100644
--- a/libs/ui/widgets/kis_paintop_presets_popup.cpp
+++ b/libs/ui/widgets/kis_paintop_presets_popup.cpp
@@ -1,409 +1,411 @@
 /* This file is part of the KDE project
  * Copyright (C) 2008 Boudewijn Rempt <boud@valdyas.org>
  * Copyright (C) 2010 Lukáš Tvrdý <lukast.dev@gmail.com>
  * Copyright (C) 2011 Silvio Heinrich <plassy@web.de>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU 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 "widgets/kis_paintop_presets_popup.h"
 
 #include <QList>
 #include <QComboBox>
 #include <QHBoxLayout>
 #include <QToolButton>
 #include <QGridLayout>
 #include <QFont>
 #include <QMenu>
 #include <QAction>
 #include <QShowEvent>
 #include <QFontDatabase>
 
 #include <kconfig.h>
 #include <klocalizedstring.h>
 
 #include <KoDockRegistry.h>
 
 #include <kis_icon.h>
 #include <kis_icon.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <brushengine/kis_paintop_config_widget.h>
 #include <kis_canvas_resource_provider.h>
 #include <widgets/kis_preset_chooser.h>
 #include <widgets/kis_preset_selector_strip.h>
 
 #include <ui_wdgpaintopsettings.h>
 #include <kis_node.h>
 #include "kis_config.h"
 
 #include "kis_resource_server_provider.h"
 #include "kis_lod_availability_widget.h"
 
 #include "kis_signal_auto_connection.h"
 
 
 struct KisPaintOpPresetsPopup::Private
 {
 
 public:
 
     Ui_WdgPaintOpSettings uiWdgPaintOpPresetSettings;
     QGridLayout *layout;
     KisPaintOpConfigWidget *settingsWidget;
     QFont smallFont;
     KisCanvasResourceProvider *resourceProvider;
     bool detached;
     bool ignoreHideEvents;
     QSize minimumSettingsWidgetSize;
     QRect detachedGeometry;
 
     KisSignalAutoConnectionsStore widgetConnections;
 };
 
 KisPaintOpPresetsPopup::KisPaintOpPresetsPopup(KisCanvasResourceProvider * resourceProvider, QWidget * parent)
     : QWidget(parent)
     , m_d(new Private())
 {
     setObjectName("KisPaintOpPresetsPopup");
     setFont(KoDockRegistry::dockFont());
 
     m_d->resourceProvider = resourceProvider;
 
     m_d->uiWdgPaintOpPresetSettings.setupUi(this);
 
     m_d->layout = new QGridLayout(m_d->uiWdgPaintOpPresetSettings.frmOptionWidgetContainer);
     m_d->layout->setSizeConstraint(QLayout::SetFixedSize);
 
     m_d->uiWdgPaintOpPresetSettings.scratchPad->setupScratchPad(resourceProvider, Qt::white);
     m_d->uiWdgPaintOpPresetSettings.scratchPad->setCutoutOverlayRect(QRect(25, 25, 200, 200));
     m_d->uiWdgPaintOpPresetSettings.fillLayer->setIcon(KisIconUtils::loadIcon("document-new"));
     m_d->uiWdgPaintOpPresetSettings.fillLayer->hide();
     m_d->uiWdgPaintOpPresetSettings.fillGradient->setIcon(KisIconUtils::loadIcon("krita_tool_gradient"));
     m_d->uiWdgPaintOpPresetSettings.fillSolid->setIcon(KisIconUtils::loadIcon("krita_tool_color_fill"));
     m_d->uiWdgPaintOpPresetSettings.eraseScratchPad->setIcon(KisIconUtils::loadIcon("edit-delete"));
     m_d->uiWdgPaintOpPresetSettings.paintPresetIcon->setIcon(KisIconUtils::loadIcon("krita_tool_freehand"));
 
     connect(m_d->uiWdgPaintOpPresetSettings.eraseScratchPad, SIGNAL(clicked()),
             m_d->uiWdgPaintOpPresetSettings.scratchPad, SLOT(fillDefault()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.fillLayer, SIGNAL(clicked()),
             m_d->uiWdgPaintOpPresetSettings.scratchPad, SLOT(fillLayer()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.fillGradient, SIGNAL(clicked()),
             m_d->uiWdgPaintOpPresetSettings.scratchPad, SLOT(fillGradient()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.fillSolid, SIGNAL(clicked()),
             m_d->uiWdgPaintOpPresetSettings.scratchPad, SLOT(fillBackground()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.paintPresetIcon, SIGNAL(clicked()),
             m_d->uiWdgPaintOpPresetSettings.scratchPad, SLOT(paintPresetImage()));
 
     m_d->settingsWidget = 0;
     setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed));
 
     connect(m_d->uiWdgPaintOpPresetSettings.bnSave, SIGNAL(clicked()),
             this, SIGNAL(savePresetClicked()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.reload, SIGNAL(clicked()),
             this, SIGNAL(reloadPresetClicked()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.bnDefaultPreset, SIGNAL(clicked()),
             this, SIGNAL(defaultPresetClicked()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.dirtyPresetCheckBox, SIGNAL(toggled(bool)),
             this, SIGNAL(dirtyPresetToggled(bool)));
 
     connect(m_d->uiWdgPaintOpPresetSettings.eraserBrushSizeCheckBox, SIGNAL(toggled(bool)),
             this, SIGNAL(eraserBrushSizeToggled(bool)));
 
     connect(m_d->uiWdgPaintOpPresetSettings.bnDefaultPreset, SIGNAL(clicked()),
             m_d->uiWdgPaintOpPresetSettings.txtPreset, SLOT(clear()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.txtPreset, SIGNAL(textChanged(QString)),
             SLOT(slotWatchPresetNameLineEdit()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.paintopList, SIGNAL(activated(QString)),
             this, SIGNAL(paintopActivated(QString)));
 
     connect(m_d->uiWdgPaintOpPresetSettings.presetWidget->smallPresetChooser, SIGNAL(resourceSelected(KoResource*)),
             this, SIGNAL(signalResourceSelected(KoResource*)));
 
     connect(m_d->uiWdgPaintOpPresetSettings.bnSave, SIGNAL(clicked()),
             m_d->uiWdgPaintOpPresetSettings.presetWidget->smallPresetChooser, SLOT(updateViewSettings()));
 
     connect(m_d->uiWdgPaintOpPresetSettings.reload, SIGNAL(clicked()),
             m_d->uiWdgPaintOpPresetSettings.presetWidget->smallPresetChooser, SLOT(updateViewSettings()));
 
     KisConfig cfg;
     m_d->detached = !cfg.paintopPopupDetached();
     m_d->ignoreHideEvents = false;
     m_d->minimumSettingsWidgetSize = QSize(0, 0);
     m_d->uiWdgPaintOpPresetSettings.presetWidget->setVisible(cfg.presetStripVisible());
     m_d->uiWdgPaintOpPresetSettings.scratchpadControls->setVisible(cfg.scratchpadVisible());
     m_d->detachedGeometry = QRect(100, 100, 0, 0);
     m_d->uiWdgPaintOpPresetSettings.dirtyPresetCheckBox->setChecked(cfg.useDirtyPresets());
     m_d->uiWdgPaintOpPresetSettings.eraserBrushSizeCheckBox->setChecked(cfg.useEraserBrushSize());
 
     m_d->uiWdgPaintOpPresetSettings.wdgLodAvailability->setCanvasResourceManager(resourceProvider->resourceManager());
 }
 
 
 KisPaintOpPresetsPopup::~KisPaintOpPresetsPopup()
 {
     if (m_d->settingsWidget) {
         m_d->layout->removeWidget(m_d->settingsWidget);
         m_d->settingsWidget->hide();
         m_d->settingsWidget->setParent(0);
         m_d->settingsWidget = 0;
     }
     delete m_d;
 }
 
 void KisPaintOpPresetsPopup::setPaintOpSettingsWidget(QWidget * widget)
 {
     if (m_d->settingsWidget) {
         m_d->layout->removeWidget(m_d->settingsWidget);
         m_d->uiWdgPaintOpPresetSettings.frmOptionWidgetContainer->updateGeometry();
     }
     m_d->layout->update();
     updateGeometry();
 
     m_d->widgetConnections.clear();
     m_d->settingsWidget = 0;
 
     if (widget) {
 
         m_d->settingsWidget = dynamic_cast<KisPaintOpConfigWidget*>(widget);
         KIS_ASSERT_RECOVER_RETURN(m_d->settingsWidget);
 
         if (m_d->settingsWidget->supportScratchBox()) {
             showScratchPad();
         } else {
             hideScratchPad();
         }
 
         m_d->widgetConnections.addConnection(m_d->uiWdgPaintOpPresetSettings.wdgLodAvailability, SIGNAL(sigUserChangedLodAvailability(bool)),
                                              m_d->settingsWidget, SLOT(slotUserChangedLodAvailability(bool)));
         m_d->widgetConnections.addConnection(m_d->settingsWidget, SIGNAL(sigUserChangedLodAvailability(bool)),
                                              m_d->uiWdgPaintOpPresetSettings.wdgLodAvailability, SLOT(slotUserChangedLodAvailability(bool)));
         m_d->widgetConnections.addConnection(m_d->settingsWidget, SIGNAL(sigConfigurationItemChanged()),
                                              this, SLOT(slotUpdateLodAvailability()));
 
         m_d->settingsWidget->coldInitExternalLodAvailabilityWidget();
 
 
         widget->setFont(m_d->smallFont);
 
         QSize hint = widget->sizeHint();
         m_d->minimumSettingsWidgetSize = QSize(qMax(hint.width(), m_d->minimumSettingsWidgetSize.width()),
                                                qMax(hint.height(), m_d->minimumSettingsWidgetSize.height()));
         widget->setMinimumSize(m_d->minimumSettingsWidgetSize);
         m_d->layout->addWidget(widget);
 
         m_d->layout->update();
         widget->show();
 
     }
 }
 
 void KisPaintOpPresetsPopup::slotUpdateLodAvailability()
 {
     if (!m_d->settingsWidget) return;
 
     KisPaintopLodLimitations l = m_d->settingsWidget->lodLimitations();
     m_d->uiWdgPaintOpPresetSettings.wdgLodAvailability->setLimitations(l);
 }
 
 void KisPaintOpPresetsPopup::slotWatchPresetNameLineEdit()
 {
     QString text = m_d->uiWdgPaintOpPresetSettings.txtPreset->text();
 
     KisPaintOpPresetResourceServer * rServer = KisResourceServerProvider::instance()->paintOpPresetServer();
     bool overwrite = rServer->resourceByName(text) != 0;
 
     KisPaintOpPresetSP preset = m_d->resourceProvider->currentPreset();
 
     bool btnSaveAvailable = preset->valid() &&
         (preset->isPresetDirty() | !overwrite);
 
     QString btnText = overwrite ? i18n("Overwrite Preset") : i18n("Save to Presets");
 
     m_d->uiWdgPaintOpPresetSettings.bnSave->setText(btnText);
     m_d->uiWdgPaintOpPresetSettings.bnSave->setEnabled(btnSaveAvailable);
 
     m_d->uiWdgPaintOpPresetSettings.reload->setVisible(true);
     m_d->uiWdgPaintOpPresetSettings.reload->setEnabled(btnSaveAvailable && overwrite);
 
     QFont font = m_d->uiWdgPaintOpPresetSettings.txtPreset->font();
     font.setItalic(btnSaveAvailable);
     m_d->uiWdgPaintOpPresetSettings.txtPreset->setFont(font);
 }
 
 QString KisPaintOpPresetsPopup::getPresetName() const
 {
     return m_d->uiWdgPaintOpPresetSettings.txtPreset->text();
 }
 
 QImage KisPaintOpPresetsPopup::cutOutOverlay()
 {
     return m_d->uiWdgPaintOpPresetSettings.scratchPad->cutoutOverlay();
 }
 
 void KisPaintOpPresetsPopup::contextMenuEvent(QContextMenuEvent *e)
 {
+    Q_UNUSED(e);
+
 #if 0
     QMenu menu(this);
     QAction* action = menu.addAction(m_d->detached ? i18n("Attach to Toolbar") : i18n("Detach from Toolbar"));
     connect(action, SIGNAL(triggered()), this, SLOT(switchDetached()));
     QAction* showPresetStrip = menu.addAction(i18n("Show Preset Strip"));
     showPresetStrip->setCheckable(true);
     showPresetStrip->setChecked(m_d->uiWdgPaintOpPresetSettings.presetWidget->isVisible());
     connect(showPresetStrip, SIGNAL(triggered(bool)), this, SLOT(slotSwitchPresetStrip(bool)));
     QAction* showScratchPad = menu.addAction(i18n("Show Scratchpad"));
     showScratchPad->setCheckable(true);
     showScratchPad->setChecked(m_d->uiWdgPaintOpPresetSettings.scratchPad->isVisible());
     connect(showScratchPad, SIGNAL(triggered(bool)), this, SLOT(slotSwitchScratchpad(bool)));
     menu.exec(e->globalPos());
 #endif
 }
 
 void KisPaintOpPresetsPopup::switchDetached(bool show)
 {
     if (parentWidget()) {
 
         m_d->detached = !m_d->detached;
 
         if (m_d->detached) {
             m_d->ignoreHideEvents = true;
             parentWidget()->setWindowFlags(Qt::Tool);
             m_d->uiWdgPaintOpPresetSettings.scratchpadControls->setVisible(false);
             if (show) {
                 parentWidget()->show();
             }
             m_d->ignoreHideEvents = false;
         }
         else {
             parentWidget()->setWindowFlags(Qt::Popup);
             KisConfig cfg;
             m_d->uiWdgPaintOpPresetSettings.scratchpadControls->setVisible(cfg.scratchpadVisible());
             parentWidget()->hide();
         }
 
         KisConfig cfg;
         cfg.setPaintopPopupDetached(m_d->detached);
     }
 }
 
 void KisPaintOpPresetsPopup::hideScratchPad()
 {
     m_d->uiWdgPaintOpPresetSettings.scratchPad->setEnabled(false);
     m_d->uiWdgPaintOpPresetSettings.fillGradient->setEnabled(false);
     m_d->uiWdgPaintOpPresetSettings.fillSolid->setEnabled(false);
     m_d->uiWdgPaintOpPresetSettings.eraseScratchPad->setEnabled(false);
 }
 
 void KisPaintOpPresetsPopup::showScratchPad()
 {
     m_d->uiWdgPaintOpPresetSettings.scratchPad->setEnabled(true);
     m_d->uiWdgPaintOpPresetSettings.fillGradient->setEnabled(true);
     m_d->uiWdgPaintOpPresetSettings.fillSolid->setEnabled(true);
     m_d->uiWdgPaintOpPresetSettings.eraseScratchPad->setEnabled(true);
 }
 
 void KisPaintOpPresetsPopup::resourceSelected(KoResource* resource)
 {
     m_d->uiWdgPaintOpPresetSettings.txtPreset->setText(resource->name());
     slotWatchPresetNameLineEdit();
 }
 
 void KisPaintOpPresetsPopup::setPaintOpList(const QList< KisPaintOpFactory* >& list)
 {
    m_d->uiWdgPaintOpPresetSettings.paintopList->setPaintOpList(list);
 }
 
 void KisPaintOpPresetsPopup::setCurrentPaintOp(const QString& paintOpId)
 {
     m_d->uiWdgPaintOpPresetSettings.paintopList->setCurrent(paintOpId);
     m_d->uiWdgPaintOpPresetSettings.presetWidget->setPresetFilter(paintOpId);
 }
 
 QString KisPaintOpPresetsPopup::currentPaintOp()
 {
     return m_d->uiWdgPaintOpPresetSettings.paintopList->currentItem();
 }
 
 void KisPaintOpPresetsPopup::setPresetImage(const QImage& image)
 {
     m_d->uiWdgPaintOpPresetSettings.scratchPad->setPresetImage(image);
 }
 
 void KisPaintOpPresetsPopup::hideEvent(QHideEvent *event)
 {
     if (m_d->ignoreHideEvents) {
         return;
     }
     if (m_d->detached) {
         m_d->detachedGeometry = window()->geometry();
     }
     QWidget::hideEvent(event);
 }
 
 void KisPaintOpPresetsPopup::showEvent(QShowEvent *)
 {
     if (m_d->detached) {
         window()->setGeometry(m_d->detachedGeometry);
     }
 }
 
 void KisPaintOpPresetsPopup::resizeEvent(QResizeEvent* event)
 {
     QWidget::resizeEvent(event);
     emit sizeChanged();
 }
 
 bool KisPaintOpPresetsPopup::detached() const
 {
     return m_d->detached;
 }
 
 void KisPaintOpPresetsPopup::slotSwitchPresetStrip(bool visible)
 {
     m_d->uiWdgPaintOpPresetSettings.presetWidget->setVisible(visible);
     KisConfig cfg;
     cfg.setPresetStripVisible(visible);
 }
 
 void KisPaintOpPresetsPopup::slotSwitchScratchpad(bool visible)
 {
     m_d->uiWdgPaintOpPresetSettings.scratchpadControls->setVisible(visible);
     KisConfig cfg;
     cfg.setScratchpadVisible(visible);
 }
 
 void KisPaintOpPresetsPopup::updateViewSettings()
 {
     m_d->uiWdgPaintOpPresetSettings.presetWidget->smallPresetChooser->updateViewSettings();
 }
 
 void KisPaintOpPresetsPopup::updateThemedIcons()
  {
     m_d->uiWdgPaintOpPresetSettings.fillLayer->setIcon(KisIconUtils::loadIcon("document-new"));
     m_d->uiWdgPaintOpPresetSettings.fillLayer->hide();
     m_d->uiWdgPaintOpPresetSettings.fillGradient->setIcon(KisIconUtils::loadIcon("krita_tool_gradient"));
     m_d->uiWdgPaintOpPresetSettings.fillSolid->setIcon(KisIconUtils::loadIcon("krita_tool_color_fill"));
     m_d->uiWdgPaintOpPresetSettings.eraseScratchPad->setIcon(KisIconUtils::loadIcon("edit-delete"));
     m_d->uiWdgPaintOpPresetSettings.paintPresetIcon->setIcon(KisIconUtils::loadIcon("krita_tool_freehand"));
 }
diff --git a/plugins/paintops/defaultpaintops/duplicate/kis_duplicateop_settings.cpp b/plugins/paintops/defaultpaintops/duplicate/kis_duplicateop_settings.cpp
index 2f7de74b60..fb2fac9eff 100644
--- a/plugins/paintops/defaultpaintops/duplicate/kis_duplicateop_settings.cpp
+++ b/plugins/paintops/defaultpaintops/duplicate/kis_duplicateop_settings.cpp
@@ -1,178 +1,164 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2004-2008 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2004 Clarence Dang <dang@kde.org>
  *  Copyright (c) 2004 Adrian Page <adrian@pagenet.plus.com>
  *  Copyright (c) 2004 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_duplicateop_settings.h"
 #include "kis_duplicateop_option.h"
 #include "kis_duplicateop_settings_widget.h"
 
 #include <QDomElement>
 #include <QDomDocument>
 
 #include <KoPointerEvent.h>
 #include <KoCompositeOpRegistry.h>
 
 #include <kis_image.h>
 #include <kis_brush_option_widget.h>
 #include <kis_paintop_settings_widget.h>
 #include <kis_pressure_darken_option.h>
 #include <kis_pressure_opacity_option.h>
 #include <kis_pressure_size_option.h>
 #include <kis_paint_action_type_option.h>
 #include <kis_dom_utils.h>
 
 KisDuplicateOpSettings::KisDuplicateOpSettings()
     : m_isOffsetNotUptodate(false)
 {
 }
 
 KisDuplicateOpSettings::~KisDuplicateOpSettings()
 {
 }
 
 bool KisDuplicateOpSettings::paintIncremental()
 {
     return false;
 }
 
 QString KisDuplicateOpSettings::indirectPaintingCompositeOp() const
 {
     return COMPOSITE_COPY;
 }
 
 QPointF KisDuplicateOpSettings::offset() const
 {
     return m_offset;
 }
 
 QPointF KisDuplicateOpSettings::position() const
 {
     return m_position;
 }
 
 bool KisDuplicateOpSettings::mousePressEvent(const KisPaintInformation &info, Qt::KeyboardModifiers modifiers, KisNodeWSP currentNode)
 {
     bool ignoreEvent = true;
 
     if (modifiers & Qt::ControlModifier) {
         if (!m_sourceNode || !(modifiers & Qt::AltModifier)) {
             m_sourceNode = currentNode;
         }
         m_position = info.pos();
         m_isOffsetNotUptodate = true;
         ignoreEvent = false;
     }
     else {
         if (m_isOffsetNotUptodate) {
             m_offset = info.pos() - m_position;
             m_isOffsetNotUptodate = false;
         }
         ignoreEvent = true;
     }
 
     return ignoreEvent;
 }
 
 KisNodeWSP KisDuplicateOpSettings::sourceNode() const
 {
     return m_sourceNode;
 }
 
 void KisDuplicateOpSettings::activate()
 {
 }
 
 void KisDuplicateOpSettings::fromXML(const QDomElement& elt)
 {
     // First, call the parent class fromXML to make sure all the
     // properties are saved to the map
     KisPaintOpSettings::fromXML(elt);
 
     m_offset.setX(KisDomUtils::toDouble(elt.attribute("OffsetX", "0.0")));
     m_offset.setY(KisDomUtils::toDouble(elt.attribute("OffsetY", "0.0")));
     m_isOffsetNotUptodate = false;
 }
 
 void KisDuplicateOpSettings::toXML(QDomDocument& doc, QDomElement& rootElt) const
 {
     // Then call the parent class fromXML
     KisPropertiesConfiguration::toXML(doc, rootElt);
 
     rootElt.setAttribute("OffsetX", QString::number(m_offset.x()));
     rootElt.setAttribute("OffsetY", QString::number(m_offset.y()));
 }
 
 
 KisPaintOpSettingsSP KisDuplicateOpSettings::clone() const
 {
     KisPaintOpSettingsSP setting = KisBrushBasedPaintOpSettings::clone();
     KisDuplicateOpSettings* s = dynamic_cast<KisDuplicateOpSettings*>(setting.data());
     s->m_offset = m_offset;
     s->m_isOffsetNotUptodate = m_isOffsetNotUptodate;
     s->m_position = m_position;
 
     return setting;
 }
 
 QPainterPath KisDuplicateOpSettings::brushOutline(const KisPaintInformation &info, OutlineMode mode) const
 {
     QPainterPath path;
 
     // clone tool should always show an outline
     path = KisBrushBasedPaintOpSettings::brushOutlineImpl(info, mode, 1.0, true);
 
     QPainterPath copy(path);
     QRectF rect2 = copy.boundingRect();
     if (m_isOffsetNotUptodate || !getBool(DUPLICATE_MOVE_SOURCE_POINT)) {
         copy.translate(m_position - info.pos());
     }
     else {
         copy.translate(-m_offset);
     }
 
     path.addPath(copy);
 
     qreal dx = rect2.width() / 4.0;
     qreal dy = rect2.height() / 4.0;
     rect2.adjust(dx, dy, -dx, -dy);
 
     path.moveTo(rect2.topLeft());
     path.lineTo(rect2.bottomRight());
 
     path.moveTo(rect2.topRight());
     path.lineTo(rect2.bottomLeft());
 
     return path;
 }
-
-#include "kis_curve_option_uniform_property.h"
-#include "kis_pressure_opacity_option.h"
-
-QList<KisUniformPaintOpPropertySP> KisDuplicateOpSettings::uniformProperties()
-{
-    QList<KisUniformPaintOpPropertySP> baseProperties = KisPaintOpSettings::uniformProperties();
-
-    baseProperties << toQShared(
-        new KisCurveOptionUniformProperty(
-            i18n("Opacity"), new KisPressureOpacityOption(), this, 0));
-
-    return baseProperties;
-}
diff --git a/plugins/paintops/defaultpaintops/duplicate/kis_duplicateop_settings.h b/plugins/paintops/defaultpaintops/duplicate/kis_duplicateop_settings.h
index 80e74e9446..7ee846d5ee 100644
--- a/plugins/paintops/defaultpaintops/duplicate/kis_duplicateop_settings.h
+++ b/plugins/paintops/defaultpaintops/duplicate/kis_duplicateop_settings.h
@@ -1,68 +1,66 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2004-2008 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2004 Clarence Dang <dang@kde.org>
  *  Copyright (c) 2004 Adrian Page <adrian@pagenet.plus.com>
  *  Copyright (c) 2004 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.
  */
 
 #ifndef KIS_DUPLICATEOP_SETTINGS_H_
 #define KIS_DUPLICATEOP_SETTINGS_H_
 
 #include <kis_brush_based_paintop_settings.h>
 #include <kis_types.h>
 #include <QPointF>
 
 class QDomElement;
 class KisDuplicateOpSettings : public KisBrushBasedPaintOpSettings
 {
 
 public:
     using KisPaintOpSettings::fromXML;
     using KisPaintOpSettings::toXML;
 
     KisDuplicateOpSettings();
 
     virtual ~KisDuplicateOpSettings();
     bool paintIncremental();
     QString indirectPaintingCompositeOp() const;
 
     QPointF offset() const;
     QPointF position() const;
     virtual bool mousePressEvent(const KisPaintInformation& pos, Qt::KeyboardModifiers modifiers, KisNodeWSP currentNode);
     void activate();
 
     void fromXML(const QDomElement& elt);
     void toXML(QDomDocument& doc, QDomElement& rootElt) const;
 
     KisPaintOpSettingsSP clone() const;
     QPainterPath brushOutline(const KisPaintInformation &info, OutlineMode mode) const;
 
     KisNodeWSP sourceNode() const;
 
-    QList<KisUniformPaintOpPropertySP> uniformProperties();
-
 public:
 
     QPointF m_offset;
     bool m_isOffsetNotUptodate;
     QPointF m_position; // Give the position of the last alt-click
     KisNodeWSP m_sourceNode;
 };
 
 
 #endif // KIS_DUPLICATEOP_SETTINGS_H_
diff --git a/plugins/paintops/libpaintop/kis_curve_option_uniform_property.cpp b/plugins/paintops/libpaintop/kis_curve_option_uniform_property.cpp
index 846fec0aa5..9904e685db 100644
--- a/plugins/paintops/libpaintop/kis_curve_option_uniform_property.cpp
+++ b/plugins/paintops/libpaintop/kis_curve_option_uniform_property.cpp
@@ -1,58 +1,63 @@
 /*
  *  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_curve_option_uniform_property.h"
 
 #include "kis_curve_option.h"
 #include "kis_paintop_settings.h"
+#include "kis_paintop_preset.h"
 #include "kis_paintop_settings_update_proxy.h"
 
 
 KisCurveOptionUniformProperty::KisCurveOptionUniformProperty(const QString &name,
                                                              KisCurveOption *option,
                                                              KisPaintOpSettingsSP settings,
                                                              QObject *parent)
     : KisDoubleSliderBasedPaintOpProperty(Double,
                                           name,
                                           option->name(),
                                           settings,
                                           parent),
       m_option(option)
 {
     setRange(option->minValue(), option->maxValue());
     setSingleStep(0.01);
 
-    connect(settings->updateProxy(), SIGNAL(sigSettingsChanged()), this, SLOT(requestReadValue()));
+    KisPaintOpPresetSP preset = settings->preset();
+
+    KIS_SAFE_ASSERT_RECOVER_RETURN(preset);
+    connect(preset->updateProxy(), SIGNAL(sigSettingsChanged()), this, SLOT(requestReadValue()));
+
     requestReadValue();
 }
 
 KisCurveOptionUniformProperty::~KisCurveOptionUniformProperty()
 {
 }
 
 void KisCurveOptionUniformProperty::readValueImpl()
 {
     m_option->readOptionSetting(settings().data());
     setValue(m_option->value());
 }
 
 void KisCurveOptionUniformProperty::writeValueImpl()
 {
     m_option->setValue(value().toReal());
     m_option->writeOptionSetting(settings().data());
 }