diff --git a/libs/image/brushengine/kis_paintop_utils.h b/libs/image/brushengine/kis_paintop_utils.h
index fc176f9262..c1416b017a 100644
--- a/libs/image/brushengine/kis_paintop_utils.h
+++ b/libs/image/brushengine/kis_paintop_utils.h
@@ -1,199 +1,199 @@
 /*
  *  Copyright (c) 2014 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KIS_PAINTOP_UTILS_H
 #define __KIS_PAINTOP_UTILS_H
 
 #include "kis_global.h"
 #include "kis_paint_information.h"
 
 namespace KisPaintOpUtils {
 
 template <class PaintOp>
 bool paintFan(PaintOp &op,
               const KisPaintInformation &pi1,
               const KisPaintInformation &pi2,
               KisDistanceInformation *currentDistance,
               qreal fanCornersStep)
 {
     const qreal angleStep = fanCornersStep;
     const qreal initialAngle = currentDistance->lastDrawingAngle();
     const qreal finalAngle = pi2.drawingAngleSafe(*currentDistance);
     const qreal fullDistance = shortestAngularDistance(initialAngle,
                                                        finalAngle);
     qreal lastAngle = initialAngle;
 
     int i = 0;
 
     while (shortestAngularDistance(lastAngle, finalAngle) > angleStep) {
         lastAngle = incrementInDirection(lastAngle, angleStep, finalAngle);
 
         qreal t = angleStep * i++ / fullDistance;
 
         QPointF pt = pi1.pos() + t * (pi2.pos() - pi1.pos());
         KisPaintInformation pi = KisPaintInformation::mix(pt, t, pi1, pi2);
         pi.overrideDrawingAngle(lastAngle);
         pi.paintAt(op, currentDistance);
     }
 
     return i;
 }
 
 
 template <class PaintOp>
 void paintLine(PaintOp &op,
                const KisPaintInformation &pi1,
                const KisPaintInformation &pi2,
                KisDistanceInformation *currentDistance,
                bool fanCornersEnabled,
                qreal fanCornersStep)
 {
     QPointF end = pi2.pos();
     qreal endTime = pi2.currentTime();
 
     KisPaintInformation pi = pi1;
     qreal t = 0.0;
 
     while ((t = currentDistance->getNextPointPosition(pi.pos(), end, pi.currentTime(), endTime)) >= 0.0) {
-        pi = KisPaintInformation::mix(pt, t, pi, pi2);
+        pi = KisPaintInformation::mix(t, pi, pi2);
 
         if (fanCornersEnabled &&
             currentDistance->hasLastPaintInformation()) {
 
             paintFan(op,
                      currentDistance->lastPaintInformation(),
                      pi,
                      currentDistance,
                      fanCornersStep);
         }
 
         /**
          * A bit complicated part to ensure the registration
          * of the distance information is done in right order
          */
         pi.paintAt(op, currentDistance);
     }
 }
 
 /**
  * A special class containing the previous position of the cursor for
  * the sake of painting the outline of the paint op. The main purpose
  * of this class is to ensure that the saved point does not equal to
  * the current one, which would cause a outline flicker. To echieve
  * this the class stores two previosly requested points instead of the
  * last one.
  */
 class PositionHistory
 {
 public:
     /**
      * \return the previously used point, which is guaranteed not to
      *         be equal to \p pt and updates the history if needed
      */
     QPointF pushThroughHistory(const QPointF &pt) {
         QPointF result;
         const qreal pointSwapThreshold = 7.0;
 
         /**
          * We check x *and* y separately, because events generated by
          * a mouse device tend to come separately for x and y offsets.
          * Efficienty generating the 'stairs' pattern.
          */
         if (qAbs(pt.x() - m_second.x()) > pointSwapThreshold &&
             qAbs(pt.y() - m_second.y()) > pointSwapThreshold) {
 
             result = m_second;
             m_first = m_second;
             m_second = pt;
         } else {
             result = m_first;
         }
 
         return result;
     }
 
 private:
     QPointF m_first;
     QPointF m_second;
 };
 
 bool checkSizeTooSmall(qreal scale, qreal width, qreal height)
 {
     return scale * width < 0.01 || scale * height < 0.01;
 }
 
 inline qreal calcAutoSpacing(qreal value, qreal coeff)
 {
     return coeff * (value < 1.0 ? value : sqrt(value));
 }
 
 QPointF calcAutoSpacing(const QPointF &pt, qreal coeff, qreal lodScale)
 {
     const qreal invLodScale = 1.0 / lodScale;
     const QPointF lod0Point = invLodScale * pt;
 
     return lodScale * QPointF(calcAutoSpacing(lod0Point.x(), coeff), calcAutoSpacing(lod0Point.y(), coeff));
 }
 
 KisSpacingInformation effectiveSpacing(qreal dabWidth,
                                        qreal dabHeight,
                                        qreal extraScale,
                                        bool isotropicSpacing,
                                        qreal rotation,
                                        bool axesFlipped,
                                        qreal spacingVal,
                                        bool autoSpacingActive,
                                        qreal autoSpacingCoeff,
                                        bool timedSpacingEnabled,
                                        qreal timedSpacingInterval,
                                        qreal lodScale)
 {
     QPointF spacing;
 
     if (!isotropicSpacing) {
         if (autoSpacingActive) {
             spacing = calcAutoSpacing(QPointF(dabWidth, dabHeight), autoSpacingCoeff, lodScale);
         } else {
             spacing = QPointF(dabWidth, dabHeight);
             spacing *= spacingVal;
         }
     }
     else {
         qreal significantDimension = qMax(dabWidth, dabHeight);
         if (autoSpacingActive) {
             significantDimension = calcAutoSpacing(significantDimension, autoSpacingCoeff);
         } else {
             significantDimension *= spacingVal;
         }
         spacing = QPointF(significantDimension, significantDimension);
         rotation = 0.0;
         axesFlipped = false;
     }
 
     spacing *= extraScale;
 
     if (timedSpacingEnabled) {
         return KisSpacingInformation(spacing, rotation, axesFlipped, timedSpacingInterval);
     } else {
         return KisSpacingInformation(spacing, rotation, axesFlipped);
     }
 }
 
 }
 
 #endif /* __KIS_PAINTOP_UTILS_H */
diff --git a/libs/image/kis_distance_information.cpp b/libs/image/kis_distance_information.cpp
index 150b9f2c4e..fb63bca545 100644
--- a/libs/image/kis_distance_information.cpp
+++ b/libs/image/kis_distance_information.cpp
@@ -1,315 +1,316 @@
 /*
  *  Copyright (c) 2010 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2013 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include <kis_distance_information.h>
 #include <brushengine/kis_paint_information.h>
 #include "kis_debug.h"
 #include <QtCore/qmath.h>
 #include <QVector2D>
 #include <QTransform>
 #include "kis_algebra_2d.h"
 
 #include "kis_lod_transform.h"
 
 
 struct Q_DECL_HIDDEN KisDistanceInformation::Private {
-    Private() : lastDabInfoValid(false),
+    Private() :
+        accumDistance(),
+        accumTime(0.0),
+        lastDabInfoValid(false),
         lastPaintInfoValid(false),
         lockedDrawingAngle(0.0),
         hasLockedDrawingAngle(false),
-        totalDistance(0.0),
-        accumDistance(),
-        accumTime(0.0) {}
+        totalDistance(0.0) {}
 
     QPointF accumDistance;
     qreal accumTime;
     KisSpacingInformation spacing;
     QPointF lastPosition;
     qreal lastTime;
     bool lastDabInfoValid;
 
     KisPaintInformation lastPaintInformation;
     qreal lastAngle;
     bool lastPaintInfoValid;
 
     qreal lockedDrawingAngle;
     bool hasLockedDrawingAngle;
     qreal totalDistance;
 };
 
 KisDistanceInformation::KisDistanceInformation()
     : m_d(new Private)
 {
 }
 
 KisDistanceInformation::KisDistanceInformation(const QPointF &lastPosition,
                                                qreal lastTime)
     : m_d(new Private)
 {
     m_d->lastPosition = lastPosition;
     m_d->lastTime = lastTime;
 
     m_d->lastDabInfoValid = true;
 }
 
 KisDistanceInformation::KisDistanceInformation(const KisDistanceInformation &rhs)
     : m_d(new Private(*rhs.m_d))
 {
 
 }
 
 KisDistanceInformation::KisDistanceInformation(const KisDistanceInformation &rhs, int levelOfDetail)
     : m_d(new Private(*rhs.m_d))
 {
     KIS_ASSERT_RECOVER_NOOP(!m_d->lastPaintInfoValid &&
                             "The distance information "
                             "should be cloned before the "
                             "actual painting is started");
 
     KisLodTransform t(levelOfDetail);
     m_d->lastPosition = t.map(m_d->lastPosition);
 }
 
 KisDistanceInformation& KisDistanceInformation::operator=(const KisDistanceInformation &rhs)
 {
     *m_d = *rhs.m_d;
     return *this;
 }
 
 void KisDistanceInformation::overrideLastValues(const QPointF &lastPosition, qreal lastTime)
 {
     m_d->lastPosition = lastPosition;
     m_d->lastTime = lastTime;
 
     m_d->lastDabInfoValid = true;
 }
 
 KisDistanceInformation::~KisDistanceInformation()
 {
     delete m_d;
 }
 
 const KisSpacingInformation& KisDistanceInformation::currentSpacing() const
 {
     return m_d->spacing;
 }
 
 bool KisDistanceInformation::hasLastDabInformation() const
 {
     return m_d->lastDabInfoValid;
 }
 
 QPointF KisDistanceInformation::lastPosition() const
 {
     return m_d->lastPosition;
 }
 
 qreal KisDistanceInformation::lastTime() const
 {
     return m_d->lastTime;
 }
 
 qreal KisDistanceInformation::lastDrawingAngle() const
 {
     return m_d->lastAngle;
 }
 
 bool KisDistanceInformation::hasLastPaintInformation() const
 {
     return m_d->lastPaintInfoValid;
 }
 
 const KisPaintInformation& KisDistanceInformation::lastPaintInformation() const
 {
     return m_d->lastPaintInformation;
 }
 
 bool KisDistanceInformation::isStarted() const
 {
     return m_d->lastPaintInfoValid;
 }
 
 void KisDistanceInformation::registerPaintedDab(const KisPaintInformation &info,
                                                 const KisSpacingInformation &spacing)
 {
     m_d->totalDistance += KisAlgebra2D::norm(info.pos() - m_d->lastPosition);
 
     m_d->lastAngle = info.drawingAngleSafe(*this);
     m_d->lastPaintInformation = info;
     m_d->lastPaintInfoValid = true;
 
     m_d->lastPosition = info.pos();
     m_d->lastTime = info.currentTime();
     m_d->lastDabInfoValid = true;
 
     m_d->spacing = spacing;
 }
 
 qreal KisDistanceInformation::getNextPointPosition(const QPointF &start,
                                                    const QPointF &end,
                                                    qreal startTime,
                                                    qreal endTime)
 {
     // Compute interpolation factor based on distance.
     qreal spaceFactor = m_d->spacing.isIsotropic() ?
         getNextPointPositionIsotropic(start, end) :
         getNextPointPositionAnisotropic(start, end);
 
     // Compute interpolation factor based on time.
-    qreal timeFactor = getNextPointPositionTemporal(startTime, endTime);
+    qreal timeFactor = getNextPointPositionTimed(startTime, endTime);
 
     // Return the distance-based or time-based factor, whichever is smallest.
     if (spaceFactor < 0.0) {
         return timeFactor;
     } else if (timeFactor < 0.0) {
         return spaceFactor;
     } else {
         return qMin(spaceFactor, timeFactor);
     }
 }
 
 qreal KisDistanceInformation::getNextPointPositionIsotropic(const QPointF &start,
                                                             const QPointF &end)
 {
     qreal distance = m_d->accumDistance.x();
     qreal spacing = qMax(qreal(0.5), m_d->spacing.spacing().x());
 
     if (start == end) {
         return -1;
     }
 
     qreal dragVecLength = QVector2D(end - start).length();
     qreal nextPointDistance = spacing - distance;
 
     qreal t;
 
     if (nextPointDistance <= dragVecLength) {
         t = nextPointDistance / dragVecLength;
         resetAccumulators();
     } else {
         t = -1;
         m_d->accumDistance.rx() += dragVecLength;
     }
 
     return t;
 }
 
 qreal KisDistanceInformation::getNextPointPositionAnisotropic(const QPointF &start,
                                                               const QPointF &end)
 {
     if (start == end) {
         return -1;
     }
 
     qreal a_rev = 1.0 / qMax(qreal(0.5), m_d->spacing.spacing().x());
     qreal b_rev = 1.0 / qMax(qreal(0.5), m_d->spacing.spacing().y());
 
     qreal x = m_d->accumDistance.x();
     qreal y = m_d->accumDistance.y();
 
     static const qreal eps = 2e-3; // < 0.2 deg
 
     qreal currentRotation = m_d->spacing.rotation();
     if (m_d->spacing.coordinateSystemFlipped()) {
         currentRotation = 2 * M_PI - currentRotation;
     }
 
     QPointF diff = end - start;
 
     if (currentRotation > eps) {
         QTransform rot;
         // since the ellipse is symmetrical, the sign
         // of rotation doesn't matter
         rot.rotateRadians(currentRotation);
         diff = rot.map(diff);
     }
 
     qreal dx = qAbs(diff.x());
     qreal dy = qAbs(diff.y());
 
     qreal alpha = pow2(dx * a_rev) + pow2(dy * b_rev);
     qreal beta = x * dx * a_rev * a_rev + y * dy * b_rev * b_rev;
     qreal gamma = pow2(x * a_rev) + pow2(y * b_rev) - 1;
 
     qreal D_4 = pow2(beta) - alpha * gamma;
 
     qreal t = -1.0;
 
     if (D_4 >= 0) {
         qreal k = (-beta + qSqrt(D_4)) / alpha;
 
         if (k >= 0.0 && k <= 1.0) {
             t = k;
             resetAccumulators();
         } else {
             m_d->accumDistance += KisAlgebra2D::abs(diff);
         }
     } else {
         warnKrita << "BUG: No solution for elliptical spacing equation has been found. This shouldn't have happened.";
     }
 
     return t;
 }
 
 qreal KisDistanceInformation::getNextPointPositionTimed(qreal startTime,
                                                         qreal endTime)
 {
     // If start time is not before end time, or if timed spacing is disabled, do not interpolate.
     if (!(startTime < endTime) || !m_d->spacing.isTimedSpacingEnabled()) {
         return -1.0;
     }
 
     qreal newAccumTime = m_d->accumTime + endTime - startTime;
 
     if (newAccumTime >= m_d->spacing.timedSpacingInterval()) {
         resetAccumulators();
         return m_d->spacing.timedSpacingInterval() / newAccumTime;
     }
     else {
         m_d->accumTime = newAccumTime;
         return -1.0;
     }
 }
 
 void KisDistanceInformation::resetAccumulators()
 {
     m_d->accumDistance = QPointF();
     m_d->accumTime = 0.0;
 }
 
 bool KisDistanceInformation::hasLockedDrawingAngle() const
 {
     return m_d->hasLockedDrawingAngle;
 }
 
 qreal KisDistanceInformation::lockedDrawingAngle() const
 {
     return m_d->lockedDrawingAngle;
 }
 
 void KisDistanceInformation::setLockedDrawingAngle(qreal angle)
 {
     m_d->hasLockedDrawingAngle = true;
     m_d->lockedDrawingAngle = angle;
 }
 
 qreal KisDistanceInformation::scalarDistanceApprox() const
 {
     return m_d->totalDistance;
 }
diff --git a/libs/ui/tool/kis_tool_freehand.cc b/libs/ui/tool/kis_tool_freehand.cc
index d843c15b94..5003601098 100644
--- a/libs/ui/tool/kis_tool_freehand.cc
+++ b/libs/ui/tool/kis_tool_freehand.cc
@@ -1,457 +1,457 @@
 /*
  *  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 <QApplication>
 #include <QDesktopWidget>
 
 #include <Eigen/Core>
 
 #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"
 
 using namespace std::placeholders; // For _1 placeholder
 
 
 KisToolFreehand::KisToolFreehand(KoCanvasBase * canvas, const QCursor & cursor, const KUndo2MagicString &transactionText)
     : KisToolPaint(canvas, cursor),
       m_paintopBasedPickingInAction(false),
       m_brushResizeCompressor(200, std::bind(&KisToolFreehand::slotDoResizeBrush, this, _1))
 {
     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)
 {
     m_helper->initPaint(event, canvas()->resourceManager(),
                         image(),
                         currentNode(),
                         image().data());
 }
 
 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);
+    m_helper->paintEvent(event);
 }
 
 void KisToolFreehand::endStroke()
 {
     m_helper->endPaint();
 }
 
 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;
     m_lastPaintOpSize = currentPaintOpPreset()->settings()->paintOpSize();
 }
 
 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;
 
     KisCanvas2 *canvas2 = dynamic_cast<KisCanvas2 *>(canvas());
     QRect screenRect = QApplication::desktop()->screenGeometry();
 
     qreal scaleX = 0;
     qreal scaleY = 0;
     canvas2->coordinatesConverter()->imageScale(&scaleX, &scaleY);
 
     const qreal maxBrushSize = KisConfig().readEntry("maximumBrushSize", 1000);
     const qreal effectiveMaxDragSize = 0.5 * screenRect.width();
     const qreal effectiveMaxBrushSize = qMin(maxBrushSize, effectiveMaxDragSize / scaleX);
 
     const qreal scaleCoeff = effectiveMaxBrushSize / effectiveMaxDragSize;
     const qreal sizeDiff = scaleCoeff * offset.x() ;
 
     if (qAbs(sizeDiff) > 0.01) {
         KisPaintOpSettingsSP settings = currentPaintOpPreset()->settings();
         const qreal newSize = qBound(0.01, m_lastPaintOpSize + sizeDiff, maxBrushSize);
 
         settings->setPaintOpSize(newSize);
         requestUpdateOutline(m_initialGestureDocPoint, 0);
         //m_brushResizeCompressor.start(newSize);
 
         m_lastDocumentPoint = event->point;
         m_lastPaintOpSize = newSize;
     }
 }
 
 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;
 }
 
 void KisToolFreehand::slotDoResizeBrush(qreal newSize)
 {
     KisPaintOpSettingsSP settings = currentPaintOpPreset()->settings();
 
     settings->setPaintOpSize(newSize);
     requestUpdateOutline(m_initialGestureDocPoint, 0);
 
 }
 
 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_freehand_helper.cpp b/libs/ui/tool/kis_tool_freehand_helper.cpp
index c44f72d2c2..e1d1810e50 100644
--- a/libs/ui/tool/kis_tool_freehand_helper.cpp
+++ b/libs/ui/tool/kis_tool_freehand_helper.cpp
@@ -1,937 +1,937 @@
 /*
  *  Copyright (c) 2011 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_tool_freehand_helper.h"
 
 #include <QTimer>
 #include <QQueue>
 
 #include <klocalizedstring.h>
 
 #include <KoPointerEvent.h>
 #include <KoCanvasResourceManager.h>
 
 #include <kis_distance_information.h>
 #include "kis_painting_information_builder.h"
 #include "kis_recording_adapter.h"
 #include "kis_image.h"
 #include "kis_painter.h"
 #include <brushengine/kis_paintop_preset.h>
 #include <brushengine/kis_paintop_utils.h>
 
 #include "kis_update_time_monitor.h"
 #include "kis_stabilized_events_sampler.h"
 #include "KisStabilizerDelayedPaintHelper.h"
 #include "kis_config.h"
 
 
 #include <math.h>
 
 //#define DEBUG_BEZIER_CURVES
 
 // Factor by which to scale the airbrush timer's interval if we want it to be faster than the actual
 // airbrushing rate.
 const qreal FAST_AIRBRUSH_TIMER_FACTOR = 0.7;
 
 struct KisToolFreehandHelper::Private
 {
     KisPaintingInformationBuilder *infoBuilder;
     KisRecordingAdapter *recordingAdapter;
     KisStrokesFacade *strokesFacade;
 
     KUndo2MagicString transactionText;
 
     bool haveTangent;
     QPointF previousTangent;
 
     bool hasPaintAtLeastOnce;
 
     QTime strokeTime;
     QTimer strokeTimeoutTimer;
 
     QVector<PainterInfo*> painterInfos;
     KisResourcesSnapshotSP resources;
     KisStrokeId strokeId;
 
     KisPaintInformation previousPaintInformation;
     KisPaintInformation olderPaintInformation;
 
     KisSmoothingOptionsSP smoothingOptions;
 
     // Timer used to generate paint updates periodically even without input events. This is only
     // used for paintops that depend on timely updates even when the cursor is not moving, e.g. for
     // airbrushing effects.
     QTimer airbrushingTimer;
 
     QList<KisPaintInformation> history;
     QList<qreal> distanceHistory;
 
     KisPaintOpUtils::PositionHistory lastOutlinePos;
 
     // Stabilizer data
     QQueue<KisPaintInformation> stabilizerDeque;
     QTimer stabilizerPollTimer;
     KisStabilizedEventsSampler stabilizedSampler;
     KisStabilizerDelayedPaintHelper stabilizerDelayedPaintHelper;
 
     int canvasRotation;
     bool canvasMirroredH;
 
     KisPaintInformation
     getStabilizedPaintInfo(const QQueue<KisPaintInformation> &queue,
                            const KisPaintInformation &lastPaintInfo);
 
     qreal effectiveSmoothnessDistance() const;
 };
 
 
 KisToolFreehandHelper::KisToolFreehandHelper(KisPaintingInformationBuilder *infoBuilder,
                                              const KUndo2MagicString &transactionText,
                                              KisRecordingAdapter *recordingAdapter,
                                              KisSmoothingOptions *smoothingOptions)
     : m_d(new Private())
 {
     m_d->infoBuilder = infoBuilder;
     m_d->recordingAdapter = recordingAdapter;
     m_d->transactionText = transactionText;
     m_d->smoothingOptions = KisSmoothingOptionsSP(
                 smoothingOptions ? smoothingOptions : new KisSmoothingOptions());
     m_d->canvasRotation = 0;
 
     m_d->strokeTimeoutTimer.setSingleShot(true);
     connect(&m_d->strokeTimeoutTimer, SIGNAL(timeout()), SLOT(finishStroke()));
     connect(&m_d->airbrushingTimer, SIGNAL(timeout()), SLOT(doAirbrushing()));
     connect(&m_d->stabilizerPollTimer, SIGNAL(timeout()), SLOT(stabilizerPollAndPaint()));
 
     m_d->stabilizerDelayedPaintHelper.setPaintLineCallback(
                 [this](const KisPaintInformation &pi1, const KisPaintInformation &pi2) {
                     paintLine(pi1, pi2);
                 });
     m_d->stabilizerDelayedPaintHelper.setUpdateOutlineCallback(
                 [this]() {
                     emit requestExplicitUpdateOutline();
                 });
 }
 
 KisToolFreehandHelper::~KisToolFreehandHelper()
 {
     delete m_d;
 }
 
 void KisToolFreehandHelper::setSmoothness(KisSmoothingOptionsSP smoothingOptions)
 {
     m_d->smoothingOptions = smoothingOptions;
 }
 
 KisSmoothingOptionsSP KisToolFreehandHelper::smoothingOptions() const
 {
     return m_d->smoothingOptions;
 }
 
 QPainterPath KisToolFreehandHelper::paintOpOutline(const QPointF &savedCursorPos,
                                                    const KoPointerEvent *event,
                                                    const KisPaintOpSettingsSP globalSettings,
                                                    KisPaintOpSettings::OutlineMode mode) const
 {
     KisPaintOpSettingsSP settings = globalSettings;
     KisPaintInformation info = m_d->infoBuilder->hover(savedCursorPos, event);
     info.setCanvasRotation(m_d->canvasRotation);
     info.setCanvasHorizontalMirrorState( m_d->canvasMirroredH );
     KisDistanceInformation distanceInfo(m_d->lastOutlinePos.pushThroughHistory(savedCursorPos), 0);
 
     if (!m_d->painterInfos.isEmpty()) {
         settings = m_d->resources->currentPaintOpPreset()->settings();
         if (m_d->stabilizerDelayedPaintHelper.running() &&
                 m_d->stabilizerDelayedPaintHelper.hasLastPaintInformation()) {
             info = m_d->stabilizerDelayedPaintHelper.lastPaintInformation();
         } else {
             info = m_d->previousPaintInformation;
         }
 
         /**
          * When LoD mode is active it may happen that the helper has
          * already started a stroke, but it painted noting, because
          * all the work is being calculated by the scaled-down LodN
          * stroke. So at first we try to fetch the data from the lodN
          * stroke ("buddy") and then check if there is at least
          * something has been painted with this distance information
          * object.
          */
         KisDistanceInformation *buddyDistance =
             m_d->painterInfos.first()->buddyDragDistance();
 
         if (buddyDistance) {
             /**
              * Tiny hack alert: here we fetch the distance information
              * directly from the LodN stroke. Ideally, we should
              * upscale its data, but here we just override it with our
              * local copy of the coordinates.
              */
             distanceInfo = *buddyDistance;
             distanceInfo.overrideLastValues(m_d->lastOutlinePos.pushThroughHistory(savedCursorPos), 0);
 
         } else if (m_d->painterInfos.first()->dragDistance->isStarted()) {
             distanceInfo = *m_d->painterInfos.first()->dragDistance;
         }
     }
 
     KisPaintInformation::DistanceInformationRegistrar registrar =
         info.registerDistanceInformation(&distanceInfo);
 
     QPainterPath outline = settings->brushOutline(info, mode);
 
 
 
     if (m_d->resources &&
         m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::STABILIZER &&
         m_d->smoothingOptions->useDelayDistance()) {
 
         const qreal R = m_d->smoothingOptions->delayDistance() /
             m_d->resources->effectiveZoom();
 
         outline.addEllipse(info.pos(), R, R);
     }
 
     return outline;
 }
 
 void KisToolFreehandHelper::initPaint(KoPointerEvent *event,
                                       KoCanvasResourceManager *resourceManager,
                                       KisImageWSP image, KisNodeSP currentNode,
                                       KisStrokesFacade *strokesFacade,
                                       KisNodeSP overrideNode,
                                       KisDefaultBoundsBaseSP bounds)
 {
     KisPaintInformation pi =
         m_d->infoBuilder->startStroke(event, elapsedStrokeTime(), resourceManager);
 
     initPaintImpl(pi,
                   resourceManager,
                   image,
                   currentNode,
                   strokesFacade,
                   overrideNode,
                   bounds);
 }
 
 bool KisToolFreehandHelper::isRunning() const
 {
     return m_d->strokeId;
 }
 
 void KisToolFreehandHelper::initPaintImpl(const KisPaintInformation &previousPaintInformation,
                                           KoCanvasResourceManager *resourceManager,
                                           KisImageWSP image,
                                           KisNodeSP currentNode,
                                           KisStrokesFacade *strokesFacade,
                                           KisNodeSP overrideNode,
                                           KisDefaultBoundsBaseSP bounds)
 {
     Q_UNUSED(overrideNode);
 
     m_d->strokesFacade = strokesFacade;
 
     m_d->haveTangent = false;
     m_d->previousTangent = QPointF();
 
     m_d->hasPaintAtLeastOnce = false;
 
     m_d->strokeTime.start();
 
     m_d->previousPaintInformation = previousPaintInformation;
 
     createPainters(m_d->painterInfos,
                    m_d->previousPaintInformation.pos(),
                    m_d->previousPaintInformation.currentTime());
 
     m_d->resources = new KisResourcesSnapshot(image,
                                               currentNode,
                                               resourceManager,
                                               bounds);
 
     if(overrideNode) {
         m_d->resources->setCurrentNode(overrideNode);
     }
 
     if(m_d->recordingAdapter) {
         m_d->recordingAdapter->startStroke(image, m_d->resources);
     }
 
     KisStrokeStrategy *stroke =
         new FreehandStrokeStrategy(m_d->resources->needsIndirectPainting(),
                                    m_d->resources->indirectPaintingCompositeOp(),
                                    m_d->resources, m_d->painterInfos, m_d->transactionText);
 
     m_d->strokeId = m_d->strokesFacade->startStroke(stroke);
 
     m_d->history.clear();
     m_d->distanceHistory.clear();
 
     if(m_d->resources->needsAirbrushing()) {
         m_d->airbrushingTimer.setInterval(computeAirbrushTimerInterval());
         m_d->airbrushingTimer.start();
     }
 
     if (m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::STABILIZER) {
         stabilizerStart(m_d->previousPaintInformation);
     }
 }
 
 void KisToolFreehandHelper::paintBezierSegment(KisPaintInformation pi1, KisPaintInformation pi2,
                                                QPointF tangent1, QPointF tangent2)
 {
     if (tangent1.isNull() || tangent2.isNull()) return;
 
     const qreal maxSanePoint = 1e6;
 
     QPointF controlTarget1;
     QPointF controlTarget2;
 
     // Shows the direction in which control points go
     QPointF controlDirection1 = pi1.pos() + tangent1;
     QPointF controlDirection2 = pi2.pos() - tangent2;
 
     // Lines in the direction of the control points
     QLineF line1(pi1.pos(), controlDirection1);
     QLineF line2(pi2.pos(), controlDirection2);
 
     // Lines to check whether the control points lay on the opposite
     // side of the line
     QLineF line3(controlDirection1, controlDirection2);
     QLineF line4(pi1.pos(), pi2.pos());
 
     QPointF intersection;
     if (line3.intersect(line4, &intersection) == QLineF::BoundedIntersection) {
         qreal controlLength = line4.length() / 2;
 
         line1.setLength(controlLength);
         line2.setLength(controlLength);
 
         controlTarget1 = line1.p2();
         controlTarget2 = line2.p2();
     } else {
         QLineF::IntersectType type = line1.intersect(line2, &intersection);
 
         if (type == QLineF::NoIntersection ||
             intersection.manhattanLength() > maxSanePoint) {
 
             intersection = 0.5 * (pi1.pos() + pi2.pos());
 //            dbgKrita << "WARINING: there is no intersection point "
 //                     << "in the basic smoothing algoriths";
         }
 
         controlTarget1 = intersection;
         controlTarget2 = intersection;
     }
 
     // shows how near to the controlTarget the value raises
     qreal coeff = 0.8;
 
     qreal velocity1 = QLineF(QPointF(), tangent1).length();
     qreal velocity2 = QLineF(QPointF(), tangent2).length();
 
     if (velocity1 == 0.0 || velocity2 == 0.0) {
         velocity1 = 1e-6;
         velocity2 = 1e-6;
         warnKrita << "WARNING: Basic Smoothing: Velocity is Zero! Please report a bug:" << ppVar(velocity1) << ppVar(velocity2);
     }
 
     qreal similarity = qMin(velocity1/velocity2, velocity2/velocity1);
 
     // the controls should not differ more than 50%
     similarity = qMax(similarity, qreal(0.5));
 
     // when the controls are symmetric, their size should be smaller
     // to avoid corner-like curves
     coeff *= 1 - qMax(qreal(0.0), similarity - qreal(0.8));
 
     Q_ASSERT(coeff > 0);
 
 
     QPointF control1;
     QPointF control2;
 
     if (velocity1 > velocity2) {
         control1 = pi1.pos() * (1.0 - coeff) + coeff * controlTarget1;
         coeff *= similarity;
         control2 = pi2.pos() * (1.0 - coeff) + coeff * controlTarget2;
     } else {
         control2 = pi2.pos() * (1.0 - coeff) + coeff * controlTarget2;
         coeff *= similarity;
         control1 = pi1.pos() * (1.0 - coeff) + coeff * controlTarget1;
     }
 
     paintBezierCurve(pi1,
                      control1,
                      control2,
                      pi2);
 }
 
 qreal KisToolFreehandHelper::Private::effectiveSmoothnessDistance() const
 {
     const qreal effectiveSmoothnessDistance =
         !smoothingOptions->useScalableDistance() ?
         smoothingOptions->smoothnessDistance() :
         smoothingOptions->smoothnessDistance() / resources->effectiveZoom();
 
     return effectiveSmoothnessDistance;
 }
 
 void KisToolFreehandHelper::paintEvent(KoPointerEvent *event)
 {
     KisPaintInformation info =
             m_d->infoBuilder->continueStroke(event,
                                              elapsedStrokeTime());
     info.setCanvasRotation( m_d->canvasRotation );
     info.setCanvasHorizontalMirrorState( m_d->canvasMirroredH );
 
     KisUpdateTimeMonitor::instance()->reportMouseMove(info.pos());
 
     paint(info);
 }
 
-void KisToolFreehandHelper::paint(const KisPaintInformation &info)
+void KisToolFreehandHelper::paint(KisPaintInformation &info)
 {
     /**
      * Smooth the coordinates out using the history and the
      * distance. This is a heavily modified version of an algo used in
      * Gimp and described in https://bugs.kde.org/show_bug.cgi?id=281267 and
      * http://www24.atwiki.jp/sigetch_2007/pages/17.html.  The main
      * differences are:
      *
      * 1) It uses 'distance' instead of 'velocity', since time
      *    measurements are too unstable in realworld environment
      *
      * 2) There is no 'Quality' parameter, since the number of samples
      *    is calculated automatically
      *
      * 3) 'Tail Aggressiveness' is used for controling the end of the
      *    stroke
      *
      * 4) The formila is a little bit different: 'Distance' parameter
      *    stands for $3 \Sigma$
      */
     if (m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::WEIGHTED_SMOOTHING
         && m_d->smoothingOptions->smoothnessDistance() > 0.0) {
 
         { // initialize current distance
             QPointF prevPos;
 
             if (!m_d->history.isEmpty()) {
                 const KisPaintInformation &prevPi = m_d->history.last();
                 prevPos = prevPi.pos();
             } else {
                 prevPos = m_d->previousPaintInformation.pos();
             }
 
             qreal currentDistance = QVector2D(info.pos() - prevPos).length();
             m_d->distanceHistory.append(currentDistance);
         }
 
         m_d->history.append(info);
 
         qreal x = 0.0;
         qreal y = 0.0;
 
         if (m_d->history.size() > 3) {
             const qreal sigma = m_d->effectiveSmoothnessDistance() / 3.0; // '3.0' for (3 * sigma) range
 
             qreal gaussianWeight = 1 / (sqrt(2 * M_PI) * sigma);
             qreal gaussianWeight2 = sigma * sigma;
             qreal distanceSum = 0.0;
             qreal scaleSum = 0.0;
             qreal pressure = 0.0;
             qreal baseRate = 0.0;
 
             Q_ASSERT(m_d->history.size() == m_d->distanceHistory.size());
 
             for (int i = m_d->history.size() - 1; i >= 0; i--) {
                 qreal rate = 0.0;
 
                 const KisPaintInformation nextInfo = m_d->history.at(i);
                 double distance = m_d->distanceHistory.at(i);
                 Q_ASSERT(distance >= 0.0);
 
                 qreal pressureGrad = 0.0;
                 if (i < m_d->history.size() - 1) {
                     pressureGrad = nextInfo.pressure() - m_d->history.at(i + 1).pressure();
 
                     const qreal tailAgressiveness = 40.0 * m_d->smoothingOptions->tailAggressiveness();
 
                     if (pressureGrad > 0.0 ) {
                         pressureGrad *= tailAgressiveness * (1.0 - nextInfo.pressure());
                         distance += pressureGrad * 3.0 * sigma; // (3 * sigma) --- holds > 90% of the region
                     }
                 }
 
                 if (gaussianWeight2 != 0.0) {
                     distanceSum += distance;
                     rate = gaussianWeight * exp(-distanceSum * distanceSum / (2 * gaussianWeight2));
                 }
 
                 if (m_d->history.size() - i == 1) {
                     baseRate = rate;
                 } else if (baseRate / rate > 100) {
                     break;
                 }
 
                 scaleSum += rate;
                 x += rate * nextInfo.pos().x();
                 y += rate * nextInfo.pos().y();
 
                 if (m_d->smoothingOptions->smoothPressure()) {
                     pressure += rate * nextInfo.pressure();
                 }
             }
 
             if (scaleSum != 0.0) {
                 x /= scaleSum;
                 y /= scaleSum;
 
                 if (m_d->smoothingOptions->smoothPressure()) {
                     pressure /= scaleSum;
                 }
             }
 
             if ((x != 0.0 && y != 0.0) || (x == info.pos().x() && y == info.pos().y())) {
                 info.setPos(QPointF(x, y));
                 if (m_d->smoothingOptions->smoothPressure()) {
                     info.setPressure(pressure);
                 }
                 m_d->history.last() = info;
             }
         }
     }
 
     if (m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::SIMPLE_SMOOTHING
         || m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::WEIGHTED_SMOOTHING)
     {
         // Now paint between the coordinates, using the bezier curve interpolation
         if (!m_d->haveTangent) {
             m_d->haveTangent = true;
             m_d->previousTangent =
                 (info.pos() - m_d->previousPaintInformation.pos()) /
                 qMax(qreal(1.0), info.currentTime() - m_d->previousPaintInformation.currentTime());
         } else {
             QPointF newTangent = (info.pos() - m_d->olderPaintInformation.pos()) /
                 qMax(qreal(1.0), info.currentTime() - m_d->olderPaintInformation.currentTime());
 
             paintBezierSegment(m_d->olderPaintInformation, m_d->previousPaintInformation,
                                m_d->previousTangent, newTangent);
 
             m_d->previousTangent = newTangent;
         }
         m_d->olderPaintInformation = m_d->previousPaintInformation;
         m_d->strokeTimeoutTimer.start(100);
     }
     else if (m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::NO_SMOOTHING){
         paintLine(m_d->previousPaintInformation, info);
     }
 
     if (m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::STABILIZER) {
         m_d->stabilizedSampler.addEvent(info);
     } else {
         m_d->previousPaintInformation = info;
     }
 
     if(m_d->airbrushingTimer.isActive()) {
         m_d->airbrushingTimer.start();
     }
 }
 
 void KisToolFreehandHelper::endPaint()
 {
     if (!m_d->hasPaintAtLeastOnce) {
         paintAt(m_d->previousPaintInformation);
     } else if (m_d->smoothingOptions->smoothingType() != KisSmoothingOptions::NO_SMOOTHING) {
         finishStroke();
     }
     m_d->strokeTimeoutTimer.stop();
 
     if(m_d->airbrushingTimer.isActive()) {
         m_d->airbrushingTimer.stop();
     }
 
     if (m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::STABILIZER) {
         stabilizerEnd();
     }
 
     /**
      * There might be some timer events still pending, so
      * we should cancel them. Use this flag for the purpose.
      * Please note that we are not in MT here, so no mutex
      * is needed
      */
     m_d->painterInfos.clear();
 
     m_d->strokesFacade->endStroke(m_d->strokeId);
     m_d->strokeId.clear();
 
     if(m_d->recordingAdapter) {
         m_d->recordingAdapter->endStroke();
     }
 }
 
 void KisToolFreehandHelper::cancelPaint()
 {
     if (!m_d->strokeId) return;
 
     m_d->strokeTimeoutTimer.stop();
 
     if (m_d->airbrushingTimer.isActive()) {
         m_d->airbrushingTimer.stop();
     }
 
     if (m_d->stabilizerPollTimer.isActive()) {
         m_d->stabilizerPollTimer.stop();
     }
 
     if (m_d->stabilizerDelayedPaintHelper.running()) {
         m_d->stabilizerDelayedPaintHelper.cancel();
     }
 
     // see a comment in endPaint()
     m_d->painterInfos.clear();
 
     m_d->strokesFacade->cancelStroke(m_d->strokeId);
     m_d->strokeId.clear();
 
     if(m_d->recordingAdapter) {
         //FIXME: not implemented
         //m_d->recordingAdapter->cancelStroke();
     }
 }
 
 int KisToolFreehandHelper::elapsedStrokeTime() const
 {
     return m_d->strokeTime.elapsed();
 }
 
 void KisToolFreehandHelper::stabilizerStart(KisPaintInformation firstPaintInfo)
 {
     // FIXME: Ugly hack, this is no a "distance" in any way
     int sampleSize = qRound(m_d->effectiveSmoothnessDistance());
     sampleSize = qMax(3, sampleSize);
 
     // Fill the deque with the current value repeated until filling the sample
     m_d->stabilizerDeque.clear();
     for (int i = sampleSize; i > 0; i--) {
         m_d->stabilizerDeque.enqueue(firstPaintInfo);
     }
 
     // Poll and draw regularly
     KisConfig cfg;
     int stabilizerSampleSize = cfg.stabilizerSampleSize();
     m_d->stabilizerPollTimer.setInterval(stabilizerSampleSize);
     m_d->stabilizerPollTimer.start();
 
     int delayedPaintInterval = cfg.stabilizerDelayedPaintInterval();
     if (delayedPaintInterval < stabilizerSampleSize) {
         m_d->stabilizerDelayedPaintHelper.start(delayedPaintInterval, firstPaintInfo);
     }
 
     m_d->stabilizedSampler.clear();
     m_d->stabilizedSampler.addEvent(firstPaintInfo);
 }
 
 KisPaintInformation
 KisToolFreehandHelper::Private::getStabilizedPaintInfo(const QQueue<KisPaintInformation> &queue,
                                                        const KisPaintInformation &lastPaintInfo)
 {
     KisPaintInformation result(lastPaintInfo);
 
     if (queue.size() > 1) {
         QQueue<KisPaintInformation>::const_iterator it = queue.constBegin();
         QQueue<KisPaintInformation>::const_iterator end = queue.constEnd();
 
         /**
          * The first point is going to be overridden by lastPaintInfo, skip it.
          */
         it++;
         int i = 2;
 
         if (smoothingOptions->stabilizeSensors()) {
             while (it != end) {
                 qreal k = qreal(i - 1) / i; // coeff for uniform averaging
                 result = KisPaintInformation::mix(k, *it, result);
                 it++;
                 i++;
             }
         } else{
             while (it != end) {
                 qreal k = qreal(i - 1) / i; // coeff for uniform averaging
                 result = KisPaintInformation::mixOnlyPosition(k, *it, result);
                 it++;
                 i++;
             }
         }
     }
 
     return result;
 }
 
 void KisToolFreehandHelper::stabilizerPollAndPaint()
 {
     KisStabilizedEventsSampler::iterator it;
     KisStabilizedEventsSampler::iterator end;
     std::tie(it, end) = m_d->stabilizedSampler.range();
     QVector<KisPaintInformation> delayedPaintTodoItems;
 
     for (; it != end; ++it) {
         KisPaintInformation sampledInfo = *it;
 
         bool canPaint = true;
 
         if (m_d->smoothingOptions->useDelayDistance()) {
             const qreal R = m_d->smoothingOptions->delayDistance() /
                     m_d->resources->effectiveZoom();
 
             QPointF diff = sampledInfo.pos() - m_d->previousPaintInformation.pos();
             qreal dx = sqrt(pow2(diff.x()) + pow2(diff.y()));
 
             canPaint = dx > R;
         }
 
         if (canPaint) {
             KisPaintInformation newInfo =
                     m_d->getStabilizedPaintInfo(m_d->stabilizerDeque, sampledInfo);
 
             if (m_d->stabilizerDelayedPaintHelper.running()) {
                 delayedPaintTodoItems.append(newInfo);
             } else {
                 paintLine(m_d->previousPaintInformation, newInfo);
             }
             m_d->previousPaintInformation = newInfo;
 
             // Push the new entry through the queue
             m_d->stabilizerDeque.dequeue();
             m_d->stabilizerDeque.enqueue(sampledInfo);
         } else if (m_d->stabilizerDeque.head().pos() != m_d->previousPaintInformation.pos()) {
 
             QQueue<KisPaintInformation>::iterator it = m_d->stabilizerDeque.begin();
             QQueue<KisPaintInformation>::iterator end = m_d->stabilizerDeque.end();
 
             while (it != end) {
                 *it = m_d->previousPaintInformation;
                 ++it;
             }
         }
     }
 
     m_d->stabilizedSampler.clear();
 
     if (m_d->stabilizerDelayedPaintHelper.running()) {
         m_d->stabilizerDelayedPaintHelper.update(delayedPaintTodoItems);
     } else {
         emit requestExplicitUpdateOutline();
     }
 }
 
 void KisToolFreehandHelper::stabilizerEnd()
 {
     // Stop the timer
     m_d->stabilizerPollTimer.stop();
 
     // Finish the line
     if (m_d->smoothingOptions->finishStabilizedCurve()) {
         // Process all the existing events first
         stabilizerPollAndPaint();
 
         // Draw the finish line with pending events and a time override
         m_d->stabilizedSampler.addFinishingEvent(m_d->stabilizerDeque.size());
         stabilizerPollAndPaint();
     }
 
     if (m_d->stabilizerDelayedPaintHelper.running()) {
         m_d->stabilizerDelayedPaintHelper.end();
     }
 }
 
 const KisPaintOp* KisToolFreehandHelper::currentPaintOp() const
 {
     return !m_d->painterInfos.isEmpty() ? m_d->painterInfos.first()->painter->paintOp() : 0;
 }
 
 void KisToolFreehandHelper::finishStroke()
 {
     if (m_d->haveTangent) {
         m_d->haveTangent = false;
 
         QPointF newTangent = (m_d->previousPaintInformation.pos() - m_d->olderPaintInformation.pos()) /
             (m_d->previousPaintInformation.currentTime() - m_d->olderPaintInformation.currentTime());
 
         paintBezierSegment(m_d->olderPaintInformation,
                            m_d->previousPaintInformation,
                            m_d->previousTangent,
                            newTangent);
     }
 }
 
 void KisToolFreehandHelper::doAirbrushing()
 {
     if(!m_d->painterInfos.isEmpty()) {
         // Add a new painting update at a point identical to the previous one, except for the time
         // and speed information.
         const KisPaintInformation &prevPaint = m_d->previousPaintInformation;
         KisPaintInformation nextPaint(prevPaint.pos(),
                                       prevPaint.pressure(),
                                       prevPaint.xTilt(),
                                       prevPaint.yTilt(),
                                       prevPaint.rotation(),
                                       prevPaint.tangentialPressure(),
                                       prevPaint.perspective(),
                                       elapsedStrokeTime(),
                                       0.0);
         // If the paintop can control the airbrush timing itself, treat the new point as a direct
         // continuation of the stroke. Otherwise, try to force a dab to be painted immediately.
         if (m_d->resources->isAirbrushRateControlled()) {
             paint(nextPaint);
         }
         else {
             paintAt(nextPaint);
         }
     }
 }
 
 int KisToolFreehandHelper::computeAirbrushTimerInterval() const
 {
     // If the paintop is controlling the airbrush timing, we might be able to get better
     // responsiveness by setting the tool's airbrush timer to update faster than the desired rate.
     // If the paintop is not controlling the timing, the tool needs to make its updates happen as
     // close as possible to the desired rate.
     qreal realInterval = m_d->resources->airbrushingInterval();
     if (m_d->resources->isAirbrushRateControlled()) {
         realInterval *= FAST_AIRBRUSH_TIMER_FACTOR;
     }
 
     return qMax(1, qFloor(realInterval));
 }
 
 void KisToolFreehandHelper::paintAt(int painterInfoId,
                                     const KisPaintInformation &pi)
 {
     m_d->hasPaintAtLeastOnce = true;
     m_d->strokesFacade->addJob(m_d->strokeId,
                                new FreehandStrokeStrategy::Data(m_d->resources->currentNode(),
                                                                 painterInfoId, pi));
 
     if(m_d->recordingAdapter) {
         m_d->recordingAdapter->addPoint(pi);
     }
 }
 
 void KisToolFreehandHelper::paintLine(int painterInfoId,
                                       const KisPaintInformation &pi1,
                                       const KisPaintInformation &pi2)
 {
     m_d->hasPaintAtLeastOnce = true;
     m_d->strokesFacade->addJob(m_d->strokeId,
                                new FreehandStrokeStrategy::Data(m_d->resources->currentNode(),
                                                                 painterInfoId, pi1, pi2));
 
     if(m_d->recordingAdapter) {
         m_d->recordingAdapter->addLine(pi1, pi2);
     }
 }
 
 void KisToolFreehandHelper::paintBezierCurve(int painterInfoId,
                                              const KisPaintInformation &pi1,
                                              const QPointF &control1,
                                              const QPointF &control2,
                                              const KisPaintInformation &pi2)
 {
 #ifdef DEBUG_BEZIER_CURVES
     KisPaintInformation tpi1;
     KisPaintInformation tpi2;
 
     tpi1 = pi1;
     tpi2 = pi2;
 
     tpi1.setPressure(0.3);
     tpi2.setPressure(0.3);
 
     paintLine(tpi1, tpi2);
 
     tpi1.setPressure(0.6);
     tpi2.setPressure(0.3);
 
     tpi1.setPos(pi1.pos());
     tpi2.setPos(control1);
     paintLine(tpi1, tpi2);
 
     tpi1.setPos(pi2.pos());
     tpi2.setPos(control2);
     paintLine(tpi1, tpi2);
 #endif
 
     m_d->hasPaintAtLeastOnce = true;
     m_d->strokesFacade->addJob(m_d->strokeId,
                                new FreehandStrokeStrategy::Data(m_d->resources->currentNode(),
                                                                 painterInfoId,
                                                                 pi1, control1, control2, pi2));
 
     if(m_d->recordingAdapter) {
         m_d->recordingAdapter->addCurve(pi1, control1, control2, pi2);
     }
 }
 
 void KisToolFreehandHelper::createPainters(QVector<PainterInfo*> &painterInfos,
                                            const QPointF &lastPosition,
                                            int lastTime)
 {
     painterInfos << new PainterInfo(lastPosition, lastTime);
 }
 
 void KisToolFreehandHelper::paintAt(const KisPaintInformation &pi)
 {
     paintAt(0, pi);
 }
 
 void KisToolFreehandHelper::paintLine(const KisPaintInformation &pi1,
                                       const KisPaintInformation &pi2)
 {
     paintLine(0, pi1, pi2);
 }
 
 void KisToolFreehandHelper::paintBezierCurve(const KisPaintInformation &pi1,
                                              const QPointF &control1,
                                              const QPointF &control2,
                                              const KisPaintInformation &pi2)
 {
     paintBezierCurve(0, pi1, control1, control2, pi2);
 }
 
 int KisToolFreehandHelper::canvasRotation()
 {
     return m_d->canvasRotation;
 }
 
 void KisToolFreehandHelper::setCanvasRotation(int rotation)
 {
    m_d->canvasRotation = rotation;
 }
 bool KisToolFreehandHelper::canvasMirroredH()
 {
     return m_d->canvasMirroredH;
 }
 
 void KisToolFreehandHelper::setCanvasHorizontalMirrorState(bool mirrored)
 {
    m_d->canvasMirroredH = mirrored;
 }
 
diff --git a/libs/ui/tool/kis_tool_freehand_helper.h b/libs/ui/tool/kis_tool_freehand_helper.h
index 360fe40bd9..b6bf87ef54 100644
--- a/libs/ui/tool/kis_tool_freehand_helper.h
+++ b/libs/ui/tool/kis_tool_freehand_helper.h
@@ -1,154 +1,154 @@
 /*
  *  Copyright (c) 2011 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KIS_TOOL_FREEHAND_HELPER_H
 #define __KIS_TOOL_FREEHAND_HELPER_H
 
 #include <QObject>
 
 #include "kis_types.h"
 #include "kritaui_export.h"
 #include <brushengine/kis_paint_information.h>
 #include "kis_default_bounds.h"
 #include <brushengine/kis_paintop_settings.h>
 #include "kis_smoothing_options.h"
 #include "strokes/freehand_stroke.h"
 
 class KoPointerEvent;
 class KoCanvasResourceManager;
 class KisPaintingInformationBuilder;
 class KisRecordingAdapter;
 class KisStrokesFacade;
 class KisPostExecutionUndoAdapter;
 class KisPaintOp;
 
 
 class KRITAUI_EXPORT KisToolFreehandHelper : public QObject
 {
     Q_OBJECT
 
 protected:
 
     typedef FreehandStrokeStrategy::PainterInfo PainterInfo;
 
 public:
 
     KisToolFreehandHelper(KisPaintingInformationBuilder *infoBuilder,
                           const KUndo2MagicString &transactionText = KUndo2MagicString(),
                           KisRecordingAdapter *recordingAdapter = 0,
                           KisSmoothingOptions *smoothingOptions = 0);
     ~KisToolFreehandHelper();
 
     void setSmoothness(KisSmoothingOptionsSP smoothingOptions);
     KisSmoothingOptionsSP smoothingOptions() const;
 
     bool isRunning() const;
 
     void initPaint(KoPointerEvent *event,
                    KoCanvasResourceManager *resourceManager,
                    KisImageWSP image,
                    KisNodeSP currentNode,
                    KisStrokesFacade *strokesFacade,
                    KisNodeSP overrideNode = 0,
                    KisDefaultBoundsBaseSP bounds = 0);
     void paintEvent(KoPointerEvent *event);
-    void paint(const KisPaintInformation &info);
     void endPaint();
 
     const KisPaintOp* currentPaintOp() const;
     QPainterPath paintOpOutline(const QPointF &savedCursorPos,
                                 const KoPointerEvent *event,
                                 const KisPaintOpSettingsSP globalSettings,
                                 KisPaintOpSettings::OutlineMode mode) const;
     int canvasRotation();
     void setCanvasRotation(int rotation = 0);
     bool canvasMirroredH();
     void setCanvasHorizontalMirrorState (bool mirrored = false);
 Q_SIGNALS:
     /**
      * The signal is emitted when the outline should be updated
      * explicitly by the tool. Used by Stabilizer option, because it
      * paints on internal timer events instead of the on every paint()
      * event
      */
     void requestExplicitUpdateOutline();
 
 protected:
     void cancelPaint();
     int elapsedStrokeTime() const;
 
     void initPaintImpl(const KisPaintInformation &previousPaintInformation,
                        KoCanvasResourceManager *resourceManager,
                        KisImageWSP image,
                        KisNodeSP node,
                        KisStrokesFacade *strokesFacade,
                        KisNodeSP overrideNode = 0,
                        KisDefaultBoundsBaseSP bounds = 0);
 
 protected:
 
     virtual void createPainters(QVector<PainterInfo*> &painterInfos,
                                 const QPointF &lastPosition,
                                 int lastTime);
 
     // lo-level methods for painting primitives
 
     void paintAt(int painterInfoId, const KisPaintInformation &pi);
 
     void paintLine(int painterInfoId,
                    const KisPaintInformation &pi1,
                    const KisPaintInformation &pi2);
 
     void paintBezierCurve(int painterInfoId,
                           const KisPaintInformation &pi1,
                           const QPointF &control1,
                           const QPointF &control2,
                           const KisPaintInformation &pi2);
 
     // hi-level methods for painting primitives
 
     virtual void paintAt(const KisPaintInformation &pi);
 
     virtual void paintLine(const KisPaintInformation &pi1,
                            const KisPaintInformation &pi2);
 
     virtual void paintBezierCurve(const KisPaintInformation &pi1,
                                   const QPointF &control1,
                                   const QPointF &control2,
                                   const KisPaintInformation &pi2);
 
 private:
+    void paint(KisPaintInformation &info);
     void paintBezierSegment(KisPaintInformation pi1, KisPaintInformation pi2,
                                                    QPointF tangent1, QPointF tangent2);
 
     void stabilizerStart(KisPaintInformation firstPaintInfo);
     void stabilizerEnd();
     int computeAirbrushTimerInterval() const;
 
 private Q_SLOTS:
 
     void finishStroke();
     void doAirbrushing();
     void stabilizerPollAndPaint();
 
 private:
     struct Private;
     Private * const m_d;
 };
 
 #endif /* __KIS_TOOL_FREEHAND_HELPER_H */
diff --git a/libs/ui/widgets/kis_scratch_pad.cpp b/libs/ui/widgets/kis_scratch_pad.cpp
index 89d7dce416..c039eb94c9 100644
--- a/libs/ui/widgets/kis_scratch_pad.cpp
+++ b/libs/ui/widgets/kis_scratch_pad.cpp
@@ -1,469 +1,469 @@
 /* This file is part of the KDE project
  * Copyright 2010 (C) Boudewijn Rempt <boud@valdyas.org>
  * Copyright 2011 (C) Dmitry Kazakov <dimula73@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 #include "kis_scratch_pad.h"
 
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QMutex>
 
 #include <KoColorSpace.h>
 #include <KoColorProfile.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoPointerEvent.h>
 #include <resources/KoAbstractGradient.h>
 
 #include <kis_cursor.h>
 #include <kis_tool_utils.h>
 #include <kis_paint_layer.h>
 #include <kis_paint_device.h>
 #include <kis_gradient_painter.h>
 #include <kis_default_bounds.h>
 #include <kis_canvas_resource_provider.h>
 
 #include "kis_config.h"
 #include "kis_image.h"
 #include "kis_undo_stores.h"
 #include "kis_update_scheduler.h"
 #include "kis_post_execution_undo_adapter.h"
 #include "kis_scratch_pad_event_filter.h"
 #include "kis_painting_information_builder.h"
 #include "kis_tool_freehand_helper.h"
 #include "kis_image_patch.h"
 #include "kis_canvas_widget_base.h"
 #include "kis_layer_projection_plane.h"
 #include "kis_node_graph_listener.h"
 
 
 class KisScratchPadNodeListener : public KisNodeGraphListener
 {
 public:
     KisScratchPadNodeListener(KisScratchPad *scratchPad)
         : m_scratchPad(scratchPad)
     {
     }
 
     void requestProjectionUpdate(KisNode *node, const QRect& rect, bool resetAnimationCache) override {
         KisNodeGraphListener::requestProjectionUpdate(node, rect, resetAnimationCache);
 
         QMutexLocker locker(&m_lock);
         m_scratchPad->imageUpdated(rect);
     }
 
 private:
     KisScratchPad *m_scratchPad;
     QMutex m_lock;
 };
 
 
 class KisScratchPadDefaultBounds : public KisDefaultBounds
 {
 public:
 
     KisScratchPadDefaultBounds(KisScratchPad *scratchPad)
         : m_scratchPad(scratchPad)
     {
     }
 
     ~KisScratchPadDefaultBounds() override {}
 
     QRect bounds() const override {
         return m_scratchPad->imageBounds();
     }
 
 private:
     Q_DISABLE_COPY(KisScratchPadDefaultBounds)
 
     KisScratchPad *m_scratchPad;
 };
 
 
 KisScratchPad::KisScratchPad(QWidget *parent)
     : QWidget(parent)
     , m_toolMode(HOVERING)
     , m_paintLayer(0)
     , m_displayProfile(0)
     , m_resourceProvider(0)
 {
     setAutoFillBackground(false);
 
     m_cursor = KisCursor::load("tool_freehand_cursor.png", 5, 5);
     setCursor(m_cursor);
 
     KisConfig cfg;
     QImage checkImage = KisCanvasWidgetBase::createCheckersImage(cfg.checkSize());
     m_checkBrush = QBrush(checkImage);
 
 
     // We are not supposed to use updates here,
     // so just set the listener to null
     m_updateScheduler = new KisUpdateScheduler(0);
     m_undoStore = new KisSurrogateUndoStore();
     m_undoAdapter = new KisPostExecutionUndoAdapter(m_undoStore, m_updateScheduler);
     m_nodeListener = new KisScratchPadNodeListener(this);
 
     connect(this, SIGNAL(sigUpdateCanvas(QRect)), SLOT(slotUpdateCanvas(QRect)), Qt::QueuedConnection);
 
     // filter will be deleted by the QObject hierarchy
     m_eventFilter = new KisScratchPadEventFilter(this);
 
     m_infoBuilder = new KisPaintingInformationBuilder();
     m_helper = new KisToolFreehandHelper(m_infoBuilder);
 
     m_scaleBorderWidth = 1;
 }
 
 KisScratchPad::~KisScratchPad() {
     delete m_helper;
     delete m_infoBuilder;
 
     delete m_undoAdapter;
     delete m_undoStore;
     delete m_updateScheduler;
     delete m_nodeListener;
 }
 
 KisScratchPad::Mode KisScratchPad::modeFromButton(Qt::MouseButton button) const
 {
     return
         button == Qt::NoButton ? HOVERING :
         button == Qt::MidButton ? PANNING :
         button == Qt::RightButton ? PICKING :
         PAINTING;
 }
 
 void KisScratchPad::pointerPress(KoPointerEvent *event)
 {
     if (m_toolMode != HOVERING) return;
 
     m_toolMode = modeFromButton(event->button());
 
     if (m_toolMode == PAINTING) {
         beginStroke(event);
         event->accept();
     }
     else if (m_toolMode == PANNING) {
         beginPan(event);
         event->accept();
     }
     else if (m_toolMode == PICKING) {
         pick(event);
         event->accept();
     }
 }
 
 void KisScratchPad::pointerRelease(KoPointerEvent *event)
 {
     if (modeFromButton(event->button()) != m_toolMode) return;
 
     if (m_toolMode == PAINTING) {
         endStroke(event);
         m_toolMode = HOVERING;
         event->accept();
     }
     else if (m_toolMode == PANNING) {
         endPan(event);
         m_toolMode = HOVERING;
         event->accept();
     }
     else if (m_toolMode == PICKING) {
         event->accept();
         m_toolMode = HOVERING;
     }
 }
 
 void KisScratchPad::pointerMove(KoPointerEvent *event)
 {
     if (m_toolMode == PAINTING) {
         doStroke(event);
         event->accept();
     }
     else if (m_toolMode == PANNING) {
         doPan(event);
         event->accept();
     }
     else if (m_toolMode == PICKING) {
         pick(event);
         event->accept();
     }
 }
 
 void KisScratchPad::beginStroke(KoPointerEvent *event)
 {
     KoCanvasResourceManager *resourceManager = m_resourceProvider->resourceManager();
 
     m_helper->initPaint(event,
                         resourceManager,
                         0,
                         0,
                         m_updateScheduler,
                         m_paintLayer,
                         m_paintLayer->paintDevice()->defaultBounds());
 }
 
 void KisScratchPad::doStroke(KoPointerEvent *event)
 {
-    m_helper->paint(event);
+    m_helper->paintEvent(event);
 }
 
 void KisScratchPad::endStroke(KoPointerEvent *event)
 {
     Q_UNUSED(event);
     m_helper->endPaint();
 }
 
 void KisScratchPad::beginPan(KoPointerEvent *event)
 {
     setCursor(QCursor(Qt::ClosedHandCursor));
     m_panDocPoint = event->point;
 }
 
 void KisScratchPad::doPan(KoPointerEvent *event)
 {
     QPointF docOffset = event->point - m_panDocPoint;
 
     m_translateTransform.translate(-docOffset.x(), -docOffset.y());
     updateTransformations();
     update();
 }
 
 void KisScratchPad::endPan(KoPointerEvent *event)
 {
     Q_UNUSED(event);
     setCursor(m_cursor);
 }
 
 void KisScratchPad::pick(KoPointerEvent *event)
 {
     KoColor color;
     if (KisToolUtils::pick(m_paintLayer->projection(), event->point.toPoint(), &color)) {
         emit colorSelected(color);
     }
 }
 
 void KisScratchPad::setOnScreenResolution(qreal scaleX, qreal scaleY)
 {
     m_scaleBorderWidth = BORDER_SIZE(qMax(scaleX, scaleY));
 
     m_scaleTransform = QTransform::fromScale(scaleX, scaleY);
     updateTransformations();
     update();
 }
 
 QTransform KisScratchPad::documentToWidget() const
 {
     return m_translateTransform.inverted() * m_scaleTransform;
 }
 
 QTransform KisScratchPad::widgetToDocument() const
 {
     return m_scaleTransform.inverted() * m_translateTransform;
 }
 
 void KisScratchPad::updateTransformations()
 {
     m_eventFilter->setWidgetToDocumentTransform(widgetToDocument());
 }
 
 QRect KisScratchPad::imageBounds() const
 {
     return widgetToDocument().mapRect(rect());
 }
 
 void KisScratchPad::imageUpdated(const QRect &rect)
 {
     emit sigUpdateCanvas(documentToWidget().mapRect(QRectF(rect)).toAlignedRect());
 }
 
 void KisScratchPad::slotUpdateCanvas(const QRect &rect)
 {
     update(rect);
 }
 
 void KisScratchPad::paintEvent ( QPaintEvent * event ) {
     if(!m_paintLayer) return;
 
     QRectF imageRect = widgetToDocument().mapRect(QRectF(event->rect()));
 
     QRect alignedImageRect =
         imageRect.adjusted(-m_scaleBorderWidth, -m_scaleBorderWidth,
                            m_scaleBorderWidth, m_scaleBorderWidth).toAlignedRect();
 
     QPointF offset = alignedImageRect.topLeft();
 
     m_paintLayer->projectionPlane()->recalculate(alignedImageRect, m_paintLayer);
     KisPaintDeviceSP projection = m_paintLayer->projection();
 
     QImage image = projection->convertToQImage(m_displayProfile,
                                                alignedImageRect.x(),
                                                alignedImageRect.y(),
                                                alignedImageRect.width(),
                                                alignedImageRect.height(),
                                                KoColorConversionTransformation::internalRenderingIntent(),
                                                KoColorConversionTransformation::internalConversionFlags());
 
     QPainter gc(this);
     gc.fillRect(event->rect(), m_checkBrush);
 
     gc.setRenderHints(QPainter::SmoothPixmapTransform);
     gc.drawImage(QRectF(event->rect()), image, imageRect.translated(-offset));
 
     QBrush brush(Qt::lightGray);
     QPen pen(brush, 1, Qt::DotLine);
     gc.setPen(pen);
     if (m_cutoutOverlay.isValid()) {
         gc.drawRect(m_cutoutOverlay);
     }
 
     if(!isEnabled()) {
         QColor color(Qt::lightGray);
         color.setAlphaF(0.5);
         QBrush disabledBrush(color);
         gc.fillRect(event->rect(), disabledBrush);
     }
     gc.end();
 }
 
 void KisScratchPad::setupScratchPad(KisCanvasResourceProvider* resourceProvider,
                                     const QColor &defaultColor)
 {
     m_resourceProvider = resourceProvider;
     KisConfig cfg;
     setDisplayProfile(cfg.displayProfile(QApplication::desktop()->screenNumber(this)));
     connect(m_resourceProvider, SIGNAL(sigDisplayProfileChanged(const KoColorProfile*)),
             SLOT(setDisplayProfile(const KoColorProfile*)));
 
     connect(m_resourceProvider, SIGNAL(sigOnScreenResolutionChanged(qreal,qreal)),
             SLOT(setOnScreenResolution(qreal,qreal)));
     connect(this, SIGNAL(colorSelected(const KoColor&)),
             m_resourceProvider, SLOT(slotSetFGColor(const KoColor&)));
 
     m_defaultColor = KoColor(defaultColor, KoColorSpaceRegistry::instance()->rgb8());
 
     KisPaintDeviceSP paintDevice =
         new KisPaintDevice(m_defaultColor.colorSpace(), "scratchpad");
 
     m_paintLayer = new KisPaintLayer(0, "ScratchPad", OPACITY_OPAQUE_U8, paintDevice);
     m_paintLayer->setGraphListener(m_nodeListener);
     m_paintLayer->paintDevice()->setDefaultBounds(new KisScratchPadDefaultBounds(this));
 
     fillDefault();
 }
 
 void KisScratchPad::setCutoutOverlayRect(const QRect& rc)
 {
     m_cutoutOverlay = rc;
 }
 
 QImage KisScratchPad::cutoutOverlay() const
 {
     if(!m_paintLayer) return QImage();
     KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
     QRect rc = widgetToDocument().mapRect(m_cutoutOverlay);
     QImage rawImage = paintDevice->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height(), KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
 
     QImage scaledImage = rawImage.scaled(m_cutoutOverlay.size(),
                                          Qt::IgnoreAspectRatio,
                                          Qt::SmoothTransformation);
 
     return scaledImage;
 }
 
 void KisScratchPad::setPresetImage(const QImage& image)
 {
     m_presetImage = image;
 }
 
 void KisScratchPad::paintPresetImage()
 {
     if(!m_paintLayer) return;
     KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
     QRect overlayRect = widgetToDocument().mapRect(m_cutoutOverlay);
     QRect imageRect(QPoint(), overlayRect.size());
 
     QImage scaledImage = m_presetImage.scaled(overlayRect.size(),
                                               Qt::IgnoreAspectRatio,
                                               Qt::SmoothTransformation);
 
     KisPaintDeviceSP device = new KisPaintDevice(paintDevice->colorSpace());
     device->convertFromQImage(scaledImage, 0);
 
     KisPainter painter(paintDevice);
     painter.bitBlt(overlayRect.topLeft(), device, imageRect);
     update();
 }
 
 void KisScratchPad::setDisplayProfile(const KoColorProfile *colorProfile)
 {
     if (colorProfile) {
         m_displayProfile = colorProfile;
         QWidget::update();
     }
 }
 
 void KisScratchPad::fillDefault()
 {
     if(!m_paintLayer) return;
     KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
     paintDevice->setDefaultPixel(m_defaultColor);
     paintDevice->clear();
     update();
 }
 
 void KisScratchPad::fillGradient()
 {
     if(!m_paintLayer) return;
     KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
     KoAbstractGradient* gradient = m_resourceProvider->currentGradient();
     QRect gradientRect = widgetToDocument().mapRect(rect());
 
     paintDevice->clear();
 
     KisGradientPainter painter(paintDevice);
 
     painter.setGradient(gradient);
     painter.setGradientShape(KisGradientPainter::GradientShapeLinear);
     painter.paintGradient(gradientRect.topLeft(),
                           gradientRect.bottomRight(),
                           KisGradientPainter::GradientRepeatNone,
                           0.2, false,
                           gradientRect.left(), gradientRect.top(),
                           gradientRect.width(), gradientRect.height());
 
     update();
 }
 
 void KisScratchPad::fillBackground()
 {
     if(!m_paintLayer) return;
     KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
     paintDevice->setDefaultPixel(m_resourceProvider->bgColor());
     paintDevice->clear();
     update();
 }
 
 void KisScratchPad::fillLayer()
 {
     // TODO
 }
diff --git a/plugins/paintops/deform/kis_deform_paintop_settings.cpp b/plugins/paintops/deform/kis_deform_paintop_settings.cpp
index 9ad5d88697..7503c78ea8 100644
--- a/plugins/paintops/deform/kis_deform_paintop_settings.cpp
+++ b/plugins/paintops/deform/kis_deform_paintop_settings.cpp
@@ -1,245 +1,245 @@
 /*
  *  Copyright (c) 2008,2009,2010 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_deform_paintop_settings.h>
 #include <kis_deform_paintop_settings_widget.h>
 
 #include <kis_brush_size_option.h>
 
 #include <kis_airbrush_option.h>
 #include <kis_deform_option.h>
 
 struct KisDeformPaintOpSettings::Private
 {
     QList<KisUniformPaintOpPropertyWSP> uniformProperties;
 };
 
 KisDeformPaintOpSettings::KisDeformPaintOpSettings()
     : KisOutlineGenerationPolicy<KisPaintOpSettings>(KisCurrentOutlineFetcher::SIZE_OPTION |
                                                      KisCurrentOutlineFetcher::ROTATION_OPTION),
     m_d(new Private)
 {
 }
 
 KisDeformPaintOpSettings::~KisDeformPaintOpSettings()
 {
 }
 
 void KisDeformPaintOpSettings::setPaintOpSize(qreal value)
 {
     BrushSizeOption option;
     option.readOptionSetting(this);
     option.brush_diameter = value;
     option.writeOptionSetting(this);
 }
 
 qreal KisDeformPaintOpSettings::paintOpSize() const
 {
     BrushSizeOption option;
     option.readOptionSetting(this);
     return option.brush_diameter;
 }
 
 bool KisDeformPaintOpSettings::paintIncremental()
 {
     return true;
 }
 
 bool KisDeformPaintOpSettings::isAirbrushing() const
 {
     // version 2.3
     if (hasProperty(AIRBRUSH_ENABLED)) {
         return getBool(AIRBRUSH_ENABLED);
     }
     else {
         return getBool(DEFORM_USE_MOVEMENT_PAINT);
     }
 }
 
 qreal KisDeformPaintOpSettings::airbrushInterval() const
 {
     if (hasProperty(AIRBRUSH_RATE)) {
         return getInt(AIRBRUSH_RATE);
     }
     else {
-        return KisPaintOpSettings::rate();
+        return KisPaintOpSettings::airbrushInterval();
     }
 }
 
 QPainterPath KisDeformPaintOpSettings::brushOutline(const KisPaintInformation &info, OutlineMode mode)
 {
     QPainterPath path;
     if (mode == CursorIsOutline || mode == CursorIsCircleOutline || mode == CursorTiltOutline) {
         qreal width = getInt(BRUSH_DIAMETER);
         qreal height = getInt(BRUSH_DIAMETER) * getDouble(BRUSH_ASPECT);
         path = ellipseOutline(width, height, getDouble(BRUSH_SCALE), getDouble(BRUSH_ROTATION));
 
         QPainterPath tiltLine;
         QLineF tiltAngle(QPointF(0.0,0.0), QPointF(0.0,width));
         tiltAngle.setLength(qMax(width*0.5, 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))-3.0);
         tiltLine.moveTo(tiltAngle.p1());
         tiltLine.lineTo(tiltAngle.p2());
         tiltAngle.setAngle((360.0 - fmod(KisPaintInformation::tiltDirection(info, true) * 360.0 + 270.0, 360.0))+3.0);
         tiltLine.lineTo(tiltAngle.p2());
         tiltLine.lineTo(tiltAngle.p1());
 
 
         path = outlineFetcher()->fetchOutline(info, this, path);
 
         if (mode == CursorTiltOutline) {
             QPainterPath tiltLine = makeTiltIndicator(info, QPointF(0.0, 0.0), width * 0.5, 3.0);
             path.addPath(outlineFetcher()->fetchOutline(info, this, tiltLine, 1.0, 0.0, true, 0, 0));
         }
     }
     return path;
 }
 
 
 #include <brushengine/kis_slider_based_paintop_property.h>
 #include <brushengine/kis_combo_based_paintop_property.h>
 #include "kis_paintop_preset.h"
 #include "kis_paintop_settings_update_proxy.h"
 #include "kis_brush_size_option.h"
 #include "kis_deform_option.h"
 #include "kis_standard_uniform_properties_factory.h"
 
 
 QList<KisUniformPaintOpPropertySP> KisDeformPaintOpSettings::uniformProperties(KisPaintOpSettingsSP settings)
 {
     QList<KisUniformPaintOpPropertySP> props =
         listWeakToStrong(m_d->uniformProperties);
 
     if (props.isEmpty()) {
         {
             KisDoubleSliderBasedPaintOpPropertyCallback *prop =
                 new KisDoubleSliderBasedPaintOpPropertyCallback(
                     KisDoubleSliderBasedPaintOpPropertyCallback::Double,
                     "deform_amount",
                     i18n("Amount"),
                     settings, 0);
 
             prop->setRange(0.01, 1.0);
             prop->setSingleStep(0.01);
             prop->setDecimals(2);
 
             prop->setReadCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     DeformOption option;
                     option.readOptionSetting(prop->settings().data());
                     prop->setValue(option.deform_amount);
                 });
             prop->setWriteCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     DeformOption option;
                     option.readOptionSetting(prop->settings().data());
                     option.deform_amount = prop->value().toReal();
                     option.writeOptionSetting(prop->settings().data());
                 });
 
             QObject::connect(preset()->updateProxy(), SIGNAL(sigSettingsChanged()), prop, SLOT(requestReadValue()));
             prop->requestReadValue();
             props << toQShared(prop);
         }
 
         {
             KisComboBasedPaintOpPropertyCallback *prop =
                 new KisComboBasedPaintOpPropertyCallback(
                     "deform_mode",
                     i18n("Deform Mode"),
                     settings, 0);
 
             QList<QString> modes;
             modes << i18n("Grow");
             modes << i18n("Shrink");
             modes << i18n("Swirl CW");
             modes << i18n("Swirl CCW");
             modes << i18n("Move");
             modes << i18n("Lens Zoom In");
             modes << i18n("Lens Zoom Out");
             modes << i18n("Color Deformation");
 
             prop->setItems(modes);
 
             prop->setReadCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     DeformOption option;
                     option.readOptionSetting(prop->settings().data());
                     prop->setValue(int(option.deform_action - 1));
                 });
             prop->setWriteCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     DeformOption option;
                     option.readOptionSetting(prop->settings().data());
                     option.deform_action = prop->value().toInt() + 1;
                     option.writeOptionSetting(prop->settings().data());
                 });
 
             QObject::connect(preset()->updateProxy(), SIGNAL(sigSettingsChanged()), prop, SLOT(requestReadValue()));
             prop->requestReadValue();
             props << toQShared(prop);
         }
 
 
         {
             KisIntSliderBasedPaintOpPropertyCallback *prop =
                 new KisIntSliderBasedPaintOpPropertyCallback(
                     KisIntSliderBasedPaintOpPropertyCallback::Int,
                     "deform_angle",
                     i18n("Angle"),
                     settings, 0);
 
             const QString degree = QChar(Qt::Key_degree);
             prop->setRange(0, 360);
             prop->setSingleStep(1);
             prop->setSuffix(degree);
 
             prop->setReadCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     BrushSizeOption option;
                     option.readOptionSetting(prop->settings().data());
 
                     prop->setValue(int(option.brush_rotation));
                 });
             prop->setWriteCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     BrushSizeOption option;
                     option.readOptionSetting(prop->settings().data());
                     option.brush_rotation = prop->value().toInt();
                     option.writeOptionSetting(prop->settings().data());
                 });
 
             QObject::connect(preset()->updateProxy(), SIGNAL(sigSettingsChanged()), prop, SLOT(requestReadValue()));
             prop->requestReadValue();
             props << toQShared(prop);
         }
     }
 
     {
         using namespace KisStandardUniformPropertiesFactory;
 
         Q_FOREACH (KisUniformPaintOpPropertySP prop, KisPaintOpSettings::uniformProperties(settings)) {
             if (prop->id() == opacity.id() ||
                 prop->id() == size.id()) {
                 props.prepend(prop);
             }
         }
     }
 
     return props;
 }
diff --git a/plugins/paintops/libpaintop/kis_auto_brush_widget.cpp b/plugins/paintops/libpaintop/kis_auto_brush_widget.cpp
index 049f3b9a55..400de06ade 100644
--- a/plugins/paintops/libpaintop/kis_auto_brush_widget.cpp
+++ b/plugins/paintops/libpaintop/kis_auto_brush_widget.cpp
@@ -1,297 +1,297 @@
 /*
  *  Copyright (c) 2004,2007,2009 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2010 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 <compositeops/KoVcMultiArchBuildSupport.h> //MSVC requires that Vc come first
 #include "kis_auto_brush_widget.h"
 
 #include <kconfig.h>
 #include <ksharedconfig.h>
 #include <kconfiggroup.h>
 
 #include <math.h>
 #include <kis_debug.h>
 #include <QSpinBox>
 #include <QToolButton>
 #include <QImage>
 #include <QComboBox>
 #include <QLabel>
 #include <QPixmap>
 #include <QResizeEvent>
 
 #include <kis_fixed_paint_device.h>
 #include <kis_mask_generator.h>
 #include <kis_slider_spin_box.h>
 #include "kis_signals_blocker.h"
 #include "kis_signal_compressor.h"
 #include "kis_aspect_ratio_locker.h"
 
 
 #define showSlider(input, step) input->setRange(input->minimum(), input->maximum(), step)
 #include <kis_cubic_curve.h>
 
 KisAutoBrushWidget::KisAutoBrushWidget(QWidget *parent, const char* name)
     : KisWdgAutoBrush(parent, name)
     , m_autoBrush(0)
     , m_updateCompressor(new KisSignalCompressor(100, KisSignalCompressor::FIRST_ACTIVE))
     , m_fadeAspectLocker(new KisAspectRatioLocker())
 {
     connect(m_updateCompressor.data(), SIGNAL(timeout()), SLOT(paramChanged()));
 
     connect((QObject*)comboBoxShape, SIGNAL(activated(int)), m_updateCompressor.data(), SLOT(start()));
 
     inputRadius->setRange(0, KSharedConfig::openConfig()->group("").readEntry("maximumBrushSize", 1000), 2);
     inputRadius->setExponentRatio(3.0);
     inputRadius->setSingleStep(1);
     inputRadius->setValue(5);
     inputRadius->setSuffix(i18n(" px"));
     inputRadius->setBlockUpdateSignalOnDrag(true);
     connect(inputRadius, SIGNAL(valueChanged(qreal)), m_updateCompressor.data(), SLOT(start()));
 
     inputRatio->setRange(0.0, 1.0, 2);
     inputRatio->setSingleStep(0.1);
     inputRatio->setValue(1.0);
     inputRatio->setBlockUpdateSignalOnDrag(true);
     connect(inputRatio, SIGNAL(valueChanged(qreal)), m_updateCompressor.data(), SLOT(start()));
 
     inputHFade->setRange(0.0, 1.0, 2);
     inputHFade->setSingleStep(0.1);
     inputHFade->setValue(0.5);
 
     inputVFade->setRange(0.0, 1.0, 2);
     inputVFade->setSingleStep(0.1);
     inputVFade->setValue(0.5);
 
     aspectButton->setKeepAspectRatio(true);
 
     m_fadeAspectLocker->connectSpinBoxes(inputHFade, inputVFade, aspectButton);
     m_fadeAspectLocker->setBlockUpdateSignalOnDrag(true);
     connect(m_fadeAspectLocker.data(), SIGNAL(sliderValueChanged()), m_updateCompressor.data(), SLOT(start()));
     connect(m_fadeAspectLocker.data(), SIGNAL(aspectButtonChanged()), m_updateCompressor.data(), SLOT(start()));
 
     inputSpikes->setRange(2, 20);
     inputSpikes->setValue(2);
     inputSpikes->setBlockUpdateSignalOnDrag(true);
     connect(inputSpikes, SIGNAL(valueChanged(int)), m_updateCompressor.data(), SLOT(start()));
 
     inputRandomness->setRange(0, 100);
     inputRandomness->setValue(0);
     inputRandomness->setBlockUpdateSignalOnDrag(true);
     connect(inputRandomness, SIGNAL(valueChanged(qreal)), m_updateCompressor.data(), SLOT(start()));
 
     inputAngle->setRange(0, 360);
     inputAngle->setSuffix(QChar(Qt::Key_degree));
     inputAngle->setValue(0);
     inputAngle->setBlockUpdateSignalOnDrag(true);
     connect(inputAngle, SIGNAL(valueChanged(int)), m_updateCompressor.data(), SLOT(start()));
 
     connect(spacingWidget, SIGNAL(sigSpacingChanged()), m_updateCompressor.data(), SLOT(start()));
 
     connect(timedSpacingWidget, SIGNAL(sigTimedSpacingChanged()), m_updateCompressor.data(),
             SLOT(start()));
 
     density->setRange(0, 100, 0);
     density->setSingleStep(1);
     density->setValue(100);
     density->setSuffix("%");
     density->setBlockUpdateSignalOnDrag(true);
     connect(density, SIGNAL(valueChanged(qreal)), m_updateCompressor.data(), SLOT(start()));
 
     KisCubicCurve topLeftBottomRightLinearCurve;
     topLeftBottomRightLinearCurve.setPoint(0, QPointF(0.0, 1.0));
     topLeftBottomRightLinearCurve.setPoint(1, QPointF(1.0, 0.0));
     softnessCurve->setCurve(topLeftBottomRightLinearCurve);
     connect(softnessCurve, SIGNAL(modified()), m_updateCompressor.data(), SLOT(start()));
 
     m_brush = QImage(1, 1, QImage::Format_RGB32);
 
     connect(brushPreview, SIGNAL(clicked()), m_updateCompressor.data(), SLOT(start()));
 
     QList<KoID> ids = KisMaskGenerator::maskGeneratorIds();
     for (int i = 0; i < ids.size(); i++) {
         comboBoxMaskType->insertItem(i, ids[i].name());
     }
 
     connect(comboBoxMaskType, SIGNAL(activated(int)), m_updateCompressor.data(), SLOT(start()));
     connect(comboBoxMaskType, SIGNAL(currentIndexChanged(int)), SLOT(setStackedWidget(int)));
     setStackedWidget(comboBoxMaskType->currentIndex());
 
     brushPreview->setIconSize(QSize(100, 100));
 
     connect(btnAntialiasing, SIGNAL(toggled(bool)), m_updateCompressor.data(), SLOT(start()));
 
     m_updateCompressor->start();
 
 }
 
 KisAutoBrushWidget::~KisAutoBrushWidget()
 {
 }
 
 void KisAutoBrushWidget::resizeEvent(QResizeEvent *)
 {
     brushPreview->setMinimumHeight(brushPreview->width()); // dirty hack !
     brushPreview->setMaximumHeight(brushPreview->width()); // dirty hack !
 }
 
 void KisAutoBrushWidget::activate()
 {
     m_updateCompressor->start();
 }
 
 void KisAutoBrushWidget::paramChanged()
 {
     KisMaskGenerator* kas;
 
     bool antialiasEdges = btnAntialiasing->isChecked();
 
     if (comboBoxMaskType->currentIndex() == 2) { // gaussian brush
         if (comboBoxShape->currentIndex() == 0) {
             kas = new KisGaussCircleMaskGenerator(inputRadius->value(),  inputRatio->value(), inputHFade->value(), inputVFade->value(), inputSpikes->value(), antialiasEdges);
         }
         else {
             kas = new KisGaussRectangleMaskGenerator(inputRadius->value(),  inputRatio->value(), inputHFade->value(), inputVFade->value(), inputSpikes->value(), antialiasEdges);
         }
     }
     else if (comboBoxMaskType->currentIndex() == 1) { // soft brush
         if (comboBoxShape->currentIndex() == 0) {
             kas = new KisCurveCircleMaskGenerator(inputRadius->value(),  inputRatio->value(), inputHFade->value(), inputVFade->value(), inputSpikes->value(), softnessCurve->curve(), antialiasEdges);
         }
         else {
             kas = new KisCurveRectangleMaskGenerator(inputRadius->value(),  inputRatio->value(), inputHFade->value(), inputVFade->value(), inputSpikes->value(), softnessCurve->curve(), antialiasEdges);
         }
     }
     else {// default == 0 or any other
         if (comboBoxShape->currentIndex() == 0) { // use index compare instead of comparing a translatable string
             kas = new KisCircleMaskGenerator(inputRadius->value(),  inputRatio->value(), inputHFade->value(), inputVFade->value(), inputSpikes->value(), antialiasEdges);
         }
         else {
             kas = new KisRectangleMaskGenerator(inputRadius->value(),  inputRatio->value(), inputHFade->value(), inputVFade->value(), inputSpikes->value(), antialiasEdges);
         }
     }
     Q_CHECK_PTR(kas);
 
     m_autoBrush = new KisAutoBrush(kas, inputAngle->value() / 180.0 * M_PI, inputRandomness->value() / 100.0, density->value() / 100.0);
     m_autoBrush->setSpacing(spacingWidget->spacing());
     m_autoBrush->setAutoSpacing(spacingWidget->autoSpacingActive(), spacingWidget->autoSpacingCoeff());
     m_autoBrush->setTimedSpacing(timedSpacingWidget->isTimedSpacingEnabled(),
                                  timedSpacingWidget->rate());
     m_brush = m_autoBrush->image();
 
     QImage pi(m_brush);
     double coeff = 1.0;
     int bPw = brushPreview->width() - 3;
     if (pi.width() > bPw) {
         coeff =  bPw / (double)pi.width();
     }
     int bPh = brushPreview->height() - 3;
     if (pi.height() > coeff * bPh) {
         coeff = bPh / (double)pi.height();
     }
     if (coeff < 1.0) {
         pi = pi.scaled((int)(coeff * pi.width()) , (int)(coeff * pi.height()),  Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
     }
 
     QPixmap p = QPixmap::fromImage(pi);
     brushPreview->setIcon(QIcon(p));
 
     emit sigBrushChanged();
 }
 
 void KisAutoBrushWidget::setStackedWidget(int index)
 {
     if (index == 1) {
         stackedWidget->setCurrentIndex(1);
     }
     else {
         stackedWidget->setCurrentIndex(0);
     }
 }
 
 KisBrushSP KisAutoBrushWidget::brush()
 {
     return m_autoBrush;
 }
 
 void KisAutoBrushWidget::setBrush(KisBrushSP brush)
 {
     m_autoBrush = brush;
     m_brush = brush->image();
     // XXX: lock, set and unlock the widgets.
     KisAutoBrush* aBrush = dynamic_cast<KisAutoBrush*>(brush.data());
 
     KisSignalsBlocker b1(comboBoxShape, comboBoxMaskType);
     KisSignalsBlocker b2(inputRadius, inputRatio, inputHFade, inputVFade, inputAngle, inputSpikes);
     KisSignalsBlocker b3(spacingWidget, timedSpacingWidget, inputRandomness, density, softnessCurve,
                          btnAntialiasing);
 
     if (aBrush->maskGenerator()->type() == KisMaskGenerator::CIRCLE) {
         comboBoxShape->setCurrentIndex(0);
     }
     else if (aBrush->maskGenerator()->type() == KisMaskGenerator::RECTANGLE) {
         comboBoxShape->setCurrentIndex(1);
     }
     else {
         comboBoxShape->setCurrentIndex(2);
     }
 
     const int mastTypeIndex = comboBoxMaskType->findText(aBrush->maskGenerator()->name());
     comboBoxMaskType->setCurrentIndex(mastTypeIndex);
     setStackedWidget(mastTypeIndex); // adjusting manually because the signals are blocked
 
     inputRadius->setValue(aBrush->maskGenerator()->diameter());
     inputRatio->setValue(aBrush->maskGenerator()->ratio());
     inputHFade->setValue(aBrush->maskGenerator()->horizontalFade());
     inputVFade->setValue(aBrush->maskGenerator()->verticalFade());
     inputAngle->setValue(aBrush->angle() * 180 / M_PI);
     inputSpikes->setValue(aBrush->maskGenerator()->spikes());
     spacingWidget->setSpacing(aBrush->autoSpacingActive(),
                               aBrush->autoSpacingActive() ?
                               aBrush->autoSpacingCoeff() : aBrush->spacing());
-    timedSpacingWidget->setTimedSpacing(aBrush->isTimedSpacingEnabled(),
+    timedSpacingWidget->setTimedSpacing(aBrush->timedSpacingEnabled(),
                                         aBrush->timedSpacingRate());
     inputRandomness->setValue(aBrush->randomness() * 100);
     density->setValue(aBrush->density() * 100);
 
     if (!aBrush->maskGenerator()->curveString().isEmpty()) {
         KisCubicCurve curve;
         curve.fromString(aBrush->maskGenerator()->curveString());
         softnessCurve->setCurve(curve);
     }
 
     btnAntialiasing->setChecked(aBrush->maskGenerator()->antialiasEdges());
 }
 
 
 void KisAutoBrushWidget::setBrushSize(qreal dxPixels, qreal dyPixels)
 {
     Q_UNUSED(dyPixels);
 
     qreal newWidth = inputRadius->value() + dxPixels;
     newWidth = qMax(newWidth, qreal(0.1));
 
     inputRadius->setValue(newWidth);
 }
 
 QSizeF KisAutoBrushWidget::brushSize() const
 {
     return QSizeF(inputRadius->value(), inputRadius->value() * inputRatio->value());
 }
 
 #include "moc_kis_auto_brush_widget.cpp"
diff --git a/plugins/paintops/libpaintop/kis_brush_chooser.cpp b/plugins/paintops/libpaintop/kis_brush_chooser.cpp
index b0fa96e3a2..81326c673c 100644
--- a/plugins/paintops/libpaintop/kis_brush_chooser.cpp
+++ b/plugins/paintops/libpaintop/kis_brush_chooser.cpp
@@ -1,405 +1,405 @@
 /*
  *  Copyright (c) 2004 Adrian Page <adrian@pagenet.plus.com>
  *  Copyright (c) 2009 Sven Langkamp <sven.langkamp@gmail.com>
  *  Copyright (c) 2010 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2010 Lukáš Tvrdý <lukast.dev@gmail.com>
  *  Copyright (C) 2011 Srikanth Tiyyagura <srikanth.tulasiram@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_brush_chooser.h"
 
 #include <QLabel>
 #include <QLayout>
 #include <QCheckBox>
 #include <QPushButton>
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 #include <QGridLayout>
 #include <QPainter>
 #include <QAbstractItemDelegate>
 #include <klocalizedstring.h>
 
 #include <kconfig.h>
 #include <ksharedconfig.h>
 #include <kconfiggroup.h>
 
 #include <KoResourceItemChooser.h>
 
 #include <kis_icon.h>
 #include "kis_brush_registry.h"
 #include "kis_brush_server.h"
 #include "widgets/kis_slider_spin_box.h"
 #include "widgets/kis_multipliers_double_slider_spinbox.h"
 #include "kis_spacing_selection_widget.h"
 #include "kis_signals_blocker.h"
 
 #include "kis_custom_brush_widget.h"
 #include "kis_clipboard_brush_widget.h"
 
 #include "kis_global.h"
 #include "kis_gbr_brush.h"
 #include "kis_debug.h"
 #include "kis_image.h"
 
 /// The resource item delegate for rendering the resource preview
 class KisBrushDelegate : public QAbstractItemDelegate
 {
 public:
     KisBrushDelegate(QObject * parent = 0) : QAbstractItemDelegate(parent) {}
     ~KisBrushDelegate() override {}
     /// reimplemented
     void paint(QPainter *, const QStyleOptionViewItem &, const QModelIndex &) const override;
     /// reimplemented
     QSize sizeHint(const QStyleOptionViewItem & option, const QModelIndex &) const override {
         return option.decorationSize;
     }
 };
 
 void KisBrushDelegate::paint(QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index) const
 {
     if (! index.isValid())
         return;
 
     KisBrush *brush = static_cast<KisBrush*>(index.internalPointer());
 
     QRect itemRect = option.rect;
     QImage thumbnail = brush->image();
 
     if (thumbnail.height() > itemRect.height() || thumbnail.width() > itemRect.width()) {
         thumbnail = thumbnail.scaled(itemRect.size() , Qt::KeepAspectRatio, Qt::SmoothTransformation);
     }
 
     painter->save();
     int dx = (itemRect.width() - thumbnail.width()) / 2;
     int dy = (itemRect.height() - thumbnail.height()) / 2;
     painter->drawImage(itemRect.x() + dx, itemRect.y() + dy, thumbnail);
 
     if (option.state & QStyle::State_Selected) {
         painter->setPen(QPen(option.palette.highlight(), 2.0));
         painter->drawRect(option.rect);
         painter->setCompositionMode(QPainter::CompositionMode_HardLight);
         painter->setOpacity(0.65);
         painter->fillRect(option.rect, option.palette.highlight());
     }
 
     painter->restore();
 }
 
 
 KisPredefinedBrushChooser::KisPredefinedBrushChooser(QWidget *parent, const char *name)
     : QWidget(parent),
       m_stampBrushWidget(0),
       m_clipboardBrushWidget(0)
 {
     setObjectName(name);
 
     setupUi(this);
 
     brushSizeSpinBox->setRange(0, KSharedConfig::openConfig()->group("").readEntry("maximumBrushSize", 1000), 2);
     brushSizeSpinBox->setValue(5);
     brushSizeSpinBox->setExponentRatio(3.0);
     brushSizeSpinBox->setSuffix(i18n(" px"));
     brushSizeSpinBox->setExponentRatio(3.0);
 
     QObject::connect(brushSizeSpinBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetItemSize(qreal)));
 
 
     brushRotationSpinBox->setRange(0, 360, 0);
     brushRotationSpinBox->setValue(0);
     brushRotationSpinBox->setSuffix(QChar(Qt::Key_degree));
     QObject::connect(brushRotationSpinBox, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetItemRotation(qreal)));
 
     brushSpacingSelectionWidget->setSpacing(true, 1.0);
     connect(brushSpacingSelectionWidget, SIGNAL(sigSpacingChanged()), SLOT(slotSpacingChanged()));
 
     connect(timedSpacingSelectionWidget, SIGNAL(sigTimedSpacingChanged()),
-            SLOT(slotTimedSpacingChanged());
+            SLOT(slotTimedSpacingChanged()));
 
 
     QObject::connect(useColorAsMaskCheckbox, SIGNAL(toggled(bool)), this, SLOT(slotSetItemUseColorAsMask(bool)));
 
 
     KisBrushResourceServer* rServer = KisBrushServer::instance()->brushServer();
     QSharedPointer<KisBrushResourceServerAdapter> adapter(new KisBrushResourceServerAdapter(rServer));
 
 
     m_itemChooser = new KoResourceItemChooser(adapter, this);
 
     m_itemChooser->showTaggingBar(true);
     m_itemChooser->setColumnCount(10);
     m_itemChooser->setRowHeight(30);
     m_itemChooser->setItemDelegate(new KisBrushDelegate(this));
     m_itemChooser->setCurrentItem(0, 0);
     m_itemChooser->setSynced(true);
     m_itemChooser->setMinimumWidth(100);
     m_itemChooser->setMinimumHeight(150);
     m_itemChooser->showButtons(false); // turn the import and delete buttons since we want control over them
 
 
     addPresetButton->setIcon(KisIconUtils::loadIcon("list-add"));
     deleteBrushTipButton->setIcon(KisIconUtils::loadIcon("trash-empty"));
 
 
 
     connect(addPresetButton, SIGNAL(clicked(bool)), this, SLOT(slotImportNewBrushResource()));
     connect(deleteBrushTipButton, SIGNAL(clicked(bool)), this, SLOT(slotDeleteBrushResource()));
 
     presetsLayout->addWidget(m_itemChooser);
 
 
     connect(m_itemChooser, SIGNAL(resourceSelected(KoResource *)), this, SLOT(update(KoResource *)));
 
     stampButton->setIcon(KisIconUtils::loadIcon("list-add"));
     stampButton->setToolTip(i18n("Creates a brush tip from the current image selection."
                                "\n If no selection is present the whole image will be used."));
 
     clipboardButton->setIcon(KisIconUtils::loadIcon("list-add"));
     clipboardButton->setToolTip(i18n("Creates a brush tip from the image in the clipboard."));
 
 
     connect(stampButton, SIGNAL(clicked()), this,  SLOT(slotOpenStampBrush()));
     connect(clipboardButton, SIGNAL(clicked()), SLOT(slotOpenClipboardBrush()));
 
     QGridLayout *spacingLayout = new QGridLayout();
     spacingLayout->setObjectName("spacing grid layout");
 
     resetBrushButton->setToolTip(i18n("Reloads Spacing from file\nSets Scale to 1.0\nSets Rotation to 0.0"));
     connect(resetBrushButton, SIGNAL(clicked()), SLOT(slotResetBrush()));
 
     update(m_itemChooser->currentResource());
 }
 
 KisPredefinedBrushChooser::~KisPredefinedBrushChooser()
 {
 }
 
 void KisPredefinedBrushChooser::setBrush(KisBrushSP _brush)
 {
     m_itemChooser->setCurrentResource(_brush.data());
     update(_brush.data());
 }
 
 void KisPredefinedBrushChooser::slotResetBrush()
 {
     KisBrush *brush = dynamic_cast<KisBrush *>(m_itemChooser->currentResource());
     if (brush) {
         brush->load();
         brush->setScale(1.0);
         brush->setAngle(0.0);
 
         slotActivatedBrush(brush);
         update(brush);
         emit sigBrushChanged();
     }
 }
 
 void KisPredefinedBrushChooser::slotSetItemSize(qreal sizeValue)
 {
     KisBrush *brush = dynamic_cast<KisBrush *>(m_itemChooser->currentResource());
 
     if (brush) {
         int brushWidth = brush->width();
 
         brush->setScale(sizeValue / qreal(brushWidth));
         slotActivatedBrush(brush);
         emit sigBrushChanged();
     }
 }
 
 void KisPredefinedBrushChooser::slotSetItemRotation(qreal rotationValue)
 {
     KisBrush *brush = dynamic_cast<KisBrush *>(m_itemChooser->currentResource());
     if (brush) {
         brush->setAngle(rotationValue / 180.0 * M_PI);
         slotActivatedBrush(brush);
 
         emit sigBrushChanged();
     }
 }
 
 void KisPredefinedBrushChooser::slotSpacingChanged()
 {
     KisBrush *brush = dynamic_cast<KisBrush *>(m_itemChooser->currentResource());
     if (brush) {
         brush->setSpacing(brushSpacingSelectionWidget->spacing());
         brush->setAutoSpacing(brushSpacingSelectionWidget->autoSpacingActive(), brushSpacingSelectionWidget->autoSpacingCoeff());
         slotActivatedBrush(brush);
 
         emit sigBrushChanged();
     }
 }
 
 void KisPredefinedBrushChooser::slotTimedSpacingChanged()
 {
     KisBrush *brush = dynamic_cast<KisBrush *>(m_itemChooser->currentResource());
     if (brush) {
         brush->setTimedSpacing(timedSpacingSelectionWidget->isTimedSpacingEnabled(),
                                timedSpacingSelectionWidget->rate());
         slotActivatedBrush(brush);
 
         emit sigBrushChanged();
     }
 }
 
 void KisPredefinedBrushChooser::slotSetItemUseColorAsMask(bool useColorAsMask)
 {
     KisGbrBrush *brush = dynamic_cast<KisGbrBrush *>(m_itemChooser->currentResource());
     if (brush) {
         brush->setUseColorAsMask(useColorAsMask);
         slotActivatedBrush(brush);
 
         emit sigBrushChanged();
     }
 }
 
 void KisPredefinedBrushChooser::slotOpenStampBrush()
 {
     if(!m_stampBrushWidget) {
         m_stampBrushWidget = new KisCustomBrushWidget(this, i18n("Stamp"), m_image);
         m_stampBrushWidget->setModal(false);
         connect(m_stampBrushWidget, SIGNAL(sigNewPredefinedBrush(KoResource *)),
                                     SLOT(slotNewPredefinedBrush(KoResource *)));
     }
 
     QDialog::DialogCode result = (QDialog::DialogCode)m_stampBrushWidget->exec();
 
     if(result) {
         update(m_itemChooser->currentResource());
     }
 }
 void KisPredefinedBrushChooser::slotOpenClipboardBrush()
 {
     if(!m_clipboardBrushWidget) {
         m_clipboardBrushWidget = new KisClipboardBrushWidget(this, i18n("Clipboard"), m_image);
         m_clipboardBrushWidget->setModal(true);
         connect(m_clipboardBrushWidget, SIGNAL(sigNewPredefinedBrush(KoResource *)),
                                         SLOT(slotNewPredefinedBrush(KoResource *)));
     }
 
     QDialog::DialogCode result = (QDialog::DialogCode)m_clipboardBrushWidget->exec();
 
     if(result) {
         update(m_itemChooser->currentResource());
     }
 }
 
 void KisPredefinedBrushChooser::update(KoResource * resource)
 {
     KisBrush* brush = dynamic_cast<KisBrush*>(resource);
 
     if (brush) {
 
 
         brushTipNameLabel->setText(i18n(brush->name().toUtf8().data()));
 
         QString brushTypeString = "";
 
         if (brush->brushType() == INVALID) {
             brushTypeString = i18n("Invalid");
         } else if (brush->brushType() == MASK) {
             brushTypeString = i18n("Mask");
         } else if (brush->brushType() == IMAGE) {
             brushTypeString = i18n("GBR");
         } else if (brush->brushType() == PIPE_MASK ) {
             brushTypeString = i18n("Animated Mask");
         } else if (brush->brushType() == PIPE_IMAGE ) {
             brushTypeString = i18n("Animated Image");
         }
 
 
         QString brushDetailsText = QString("%1 (%2 x %3)")
                        .arg(brushTypeString)
                        .arg(brush->width())
                        .arg(brush->height());
 
         brushDetailsLabel->setText(brushDetailsText);
 
 
         brushSpacingSelectionWidget->setSpacing(brush->autoSpacingActive(),
                                 brush->autoSpacingActive() ?
                                 brush->autoSpacingCoeff() : brush->spacing());
 
         timedSpacingSelectionWidget->setTimedSpacing(brush->timedSpacingEnabled(),
                                                      brush->timedSpacingRate());
 
         brushRotationSpinBox->setValue(brush->angle() * 180 / M_PI);
         brushSizeSpinBox->setValue(brush->width() * brush->scale());
 
         // useColorAsMask support is only in gimp brush so far
         KisGbrBrush *gimpBrush = dynamic_cast<KisGbrBrush*>(resource);
         if (gimpBrush) {
             useColorAsMaskCheckbox->setChecked(gimpBrush->useColorAsMask());
         }
         useColorAsMaskCheckbox->setEnabled(brush->hasColor() && gimpBrush);
 
         slotActivatedBrush(brush);
         emit sigBrushChanged();
     }
 }
 
 void KisPredefinedBrushChooser::slotActivatedBrush(KoResource * resource)
 {
     KisBrush* brush = dynamic_cast<KisBrush*>(resource);
 
     if (m_brush != brush) {
         if (m_brush) {
             m_brush->clearBrushPyramid();
         }
 
         m_brush = brush;
 
         if (m_brush) {
             m_brush->prepareBrushPyramid();
         }
     }
 }
 
 void KisPredefinedBrushChooser::slotNewPredefinedBrush(KoResource *resource)
 {
     m_itemChooser->setCurrentResource(resource);
     update(resource);
 }
 
 void KisPredefinedBrushChooser::setBrushSize(qreal xPixels, qreal yPixels)
 {
     Q_UNUSED(yPixels);
     qreal oldWidth = m_brush->width() * m_brush->scale();
     qreal newWidth = oldWidth + xPixels;
 
     newWidth = qMax(newWidth, qreal(0.1));
 
     brushSizeSpinBox->setValue(newWidth);
 }
 
 void KisPredefinedBrushChooser::setImage(KisImageWSP image)
 {
     m_image = image;
 }
 
 void KisPredefinedBrushChooser::slotImportNewBrushResource() {
     m_itemChooser->slotButtonClicked(KoResourceItemChooser::Button_Import);
 }
 
 void KisPredefinedBrushChooser::slotDeleteBrushResource() {
     m_itemChooser->slotButtonClicked(KoResourceItemChooser::Button_Remove);
 }
 
 
 
 #include "moc_kis_brush_chooser.cpp"