diff --git a/libs/brush/tests/CMakeLists.txt b/libs/brush/tests/CMakeLists.txt
index 1458e253b0..7ae6ecbb8a 100644
--- a/libs/brush/tests/CMakeLists.txt
+++ b/libs/brush/tests/CMakeLists.txt
@@ -1,30 +1,31 @@
 ########### next target ###############
 
 set( EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR} )
 include_directories(    
     ${CMAKE_SOURCE_DIR}/libs/image/metadata 
     ${CMAKE_SOURCE_DIR}/sdk/tests 
 )
 include_directories(SYSTEM
     ${EIGEN3_INCLUDE_DIR}
 )
 
 if(HAVE_VC)
   include_directories(SYSTEM
       ${Vc_INCLUDE_DIR}
   )
 endif()
 
 macro_add_unittest_definitions()
 
 include(ECMAddTests)
 
 ecm_add_tests(
     kis_auto_brush_test.cpp
+    kis_auto_brush_factory_test.cpp
     kis_gbr_brush_test.cpp
     kis_boundary_test.cpp
     kis_imagepipe_brush_test.cpp
     NAME_PREFIX "krita-libbrush-"
     LINK_LIBRARIES kritaimage kritalibbrush Qt5::Test
 )
 
diff --git a/libs/brush/tests/kis_auto_brush_factory_test.cpp b/libs/brush/tests/kis_auto_brush_factory_test.cpp
new file mode 100644
index 0000000000..0b9930b46b
--- /dev/null
+++ b/libs/brush/tests/kis_auto_brush_factory_test.cpp
@@ -0,0 +1,51 @@
+#include "kis_auto_brush_factory_test.h"
+
+#include <QTest>
+#include <testutil.h>
+#include "kis_auto_brush.h"
+#include "kis_auto_brush_factory.h"
+#include "kis_mask_generator.h"
+#include <KoColor.h>
+#include <brushengine/kis_paint_information.h>
+
+void KisAutoBrushFactoryTest::testXMLClone()
+{
+    // Set up an autobrush.
+    KisBrushSP brush = new KisAutoBrush(new KisCircleMaskGenerator(20, 0.6, 0.8, 0.4, 3, true), 1.0,
+                                        0.0);
+    brush->setSpacing(0.15);
+    brush->setAutoSpacing(true, 0.1);
+
+    // Try to clone the brush by converting to XML and back.
+    QDomDocument d;
+    QDomElement e = d.createElement("Brush");
+    brush->toXML(d, e);
+    KisBrushSP clone = KisAutoBrushFactory().getOrCreateBrush(e, false);
+
+    // Test that the clone has the same settings as the original brush.
+    QCOMPARE(brush->width(), clone->width());
+    QCOMPARE(brush->height(), clone->height());
+    QCOMPARE(brush->angle(), clone->angle());
+    QCOMPARE(brush->spacing(), clone->spacing());
+    QCOMPARE(brush->autoSpacingActive(), clone->autoSpacingActive());
+    QCOMPARE(brush->autoSpacingCoeff(), clone->autoSpacingCoeff());
+
+    // Test that the clone draws the same as the original brush.
+
+    const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
+    KisPaintInformation info(QPointF(100.0, 100.0), 0.5);
+    KisDabShape shape(0.9, 0.7, 1.0);
+    KoColor color(Qt::yellow, cs);
+
+    KisFixedPaintDeviceSP fdev1 = new KisFixedPaintDevice(cs);
+    brush->mask(fdev1, color, shape, info);
+    QImage res1 = fdev1->convertToQImage(0);
+
+    KisFixedPaintDeviceSP fdev2 = new KisFixedPaintDevice(cs);
+    clone->mask(fdev2, color, shape, info);
+    QImage res2 = fdev2->convertToQImage(0);
+
+    QCOMPARE(res1, res2);
+}
+
+QTEST_MAIN(KisAutoBrushFactoryTest)
diff --git a/libs/brush/tests/kis_auto_brush_factory_test.h b/libs/brush/tests/kis_auto_brush_factory_test.h
new file mode 100644
index 0000000000..f75deee7ca
--- /dev/null
+++ b/libs/brush/tests/kis_auto_brush_factory_test.h
@@ -0,0 +1,13 @@
+#ifndef KIS_AUTO_BRUSH_FACTORY_TEST_H
+#define KIS_AUTO_BRUSH_FACTORY_TEST_H
+
+#include <QtTest>
+
+class KisAutoBrushFactoryTest : public QObject
+{
+    Q_OBJECT
+private Q_SLOTS:
+    void testXMLClone();
+};
+
+#endif // KIS_AUTO_BRUSH_FACTORY_TEST_H
diff --git a/libs/global/kis_algebra_2d.cpp b/libs/global/kis_algebra_2d.cpp
index 1ba61509d0..9081b4428a 100644
--- a/libs/global/kis_algebra_2d.cpp
+++ b/libs/global/kis_algebra_2d.cpp
@@ -1,570 +1,586 @@
 /*
  *  Copyright (c) 2014 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_algebra_2d.h"
 
 #include <QTransform>
 #include <QPainterPath>
 #include <kis_debug.h>
 
 #include <boost/accumulators/accumulators.hpp>
 #include <boost/accumulators/statistics/stats.hpp>
 #include <boost/accumulators/statistics/min.hpp>
 #include <boost/accumulators/statistics/max.hpp>
 
 #include <array>
+#include <QVector2D>
 #include <QVector3D>
 
 #define SANITY_CHECKS
 
 namespace KisAlgebra2D {
 
 void adjustIfOnPolygonBoundary(const QPolygonF &poly, int polygonDirection, QPointF *pt)
 {
     const int numPoints = poly.size();
     for (int i = 0; i < numPoints; i++) {
         int nextI = i + 1;
         if (nextI >= numPoints) {
             nextI = 0;
         }
 
         const QPointF &p0 = poly[i];
         const QPointF &p1 = poly[nextI];
 
         QPointF edge = p1 - p0;
 
         qreal cross = crossProduct(edge, *pt - p0)
             / (0.5 * edge.manhattanLength());
 
         if (cross < 1.0 &&
             isInRange(pt->x(), p0.x(), p1.x()) &&
             isInRange(pt->y(), p0.y(), p1.y())) {
 
             QPointF salt = 1.0e-3 * inwardUnitNormal(edge, polygonDirection);
 
             QPointF adjustedPoint = *pt + salt;
 
             // in case the polygon is self-intersecting, polygon direction
             // might not help
             if (kisDistanceToLine(adjustedPoint, QLineF(p0, p1)) < 1e-4) {
                 adjustedPoint = *pt - salt;
 
 #ifdef SANITY_CHECKS
                 if (kisDistanceToLine(adjustedPoint, QLineF(p0, p1)) < 1e-4) {
                     dbgKrita << ppVar(*pt);
                     dbgKrita << ppVar(adjustedPoint);
                     dbgKrita << ppVar(QLineF(p0, p1));
                     dbgKrita << ppVar(salt);
 
                     dbgKrita << ppVar(poly.containsPoint(*pt, Qt::OddEvenFill));
 
                     dbgKrita << ppVar(kisDistanceToLine(*pt, QLineF(p0, p1)));
                     dbgKrita << ppVar(kisDistanceToLine(adjustedPoint, QLineF(p0, p1)));
                 }
 
                 *pt = adjustedPoint;
 
                 KIS_ASSERT_RECOVER_NOOP(kisDistanceToLine(*pt, QLineF(p0, p1)) > 1e-4);
 #endif /* SANITY_CHECKS */
             }
         }
     }
 }
 
 QPointF transformAsBase(const QPointF &pt, const QPointF &base1, const QPointF &base2) {
     qreal len1 = norm(base1);
     if (len1 < 1e-5) return pt;
     qreal sin1 = base1.y() / len1;
     qreal cos1 = base1.x() / len1;
 
     qreal len2 = norm(base2);
     if (len2 < 1e-5) return QPointF();
     qreal sin2 = base2.y() / len2;
     qreal cos2 = base2.x() / len2;
 
     qreal sinD = sin2 * cos1 - cos2 * sin1;
     qreal cosD = cos1 * cos2 + sin1 * sin2;
     qreal scaleD = len2 / len1;
 
     QPointF result;
     result.rx() = scaleD * (pt.x() * cosD - pt.y() * sinD);
     result.ry() = scaleD * (pt.x() * sinD + pt.y() * cosD);
 
     return result;
 }
 
 qreal angleBetweenVectors(const QPointF &v1, const QPointF &v2)
 {
     qreal a1 = std::atan2(v1.y(), v1.x());
     qreal a2 = std::atan2(v2.y(), v2.x());
 
     return a2 - a1;
 }
 
+qreal directionBetweenPoints(const QPointF &p1, const QPointF &p2, qreal defaultAngle)
+{
+    if (fuzzyPointCompare(p1, p2)) {
+        return defaultAngle;
+    }
+
+    const QVector2D diff(p2 - p1);
+    return std::atan2(diff.y(), diff.x());
+}
+
 QPainterPath smallArrow()
 {
     QPainterPath p;
 
     p.moveTo(5, 2);
     p.lineTo(-3, 8);
     p.lineTo(-5, 5);
     p.lineTo( 2, 0);
     p.lineTo(-5,-5);
     p.lineTo(-3,-8);
     p.lineTo( 5,-2);
     p.arcTo(QRectF(3, -2, 4, 4), 90, -180);
 
     return p;
 }
 
 template <class Point, class Rect>
 inline Point ensureInRectImpl(Point pt, const Rect &bounds)
 {
     if (pt.x() > bounds.right()) {
         pt.rx() = bounds.right();
     } else if (pt.x() < bounds.left()) {
         pt.rx() = bounds.left();
     }
 
     if (pt.y() > bounds.bottom()) {
         pt.ry() = bounds.bottom();
     } else if (pt.y() < bounds.top()) {
         pt.ry() = bounds.top();
     }
 
     return pt;
 }
 
 QPoint ensureInRect(QPoint pt, const QRect &bounds)
 {
     return ensureInRectImpl(pt, bounds);
 }
 
 QPointF ensureInRect(QPointF pt, const QRectF &bounds)
 {
     return ensureInRectImpl(pt, bounds);
 }
 
 bool intersectLineRect(QLineF &line, const QRect rect)
 {
     QPointF pt1 = QPointF(), pt2 = QPointF();
     QPointF tmp;
 
     if (line.intersect(QLineF(rect.topLeft(), rect.topRight()), &tmp) != QLineF::NoIntersection) {
         if (tmp.x() >= rect.left() && tmp.x() <= rect.right()) {
             pt1 = tmp;
         }
     }
 
     if (line.intersect(QLineF(rect.topRight(), rect.bottomRight()), &tmp) != QLineF::NoIntersection) {
         if (tmp.y() >= rect.top() && tmp.y() <= rect.bottom()) {
             if (pt1.isNull()) pt1 = tmp;
             else pt2 = tmp;
         }
     }
     if (line.intersect(QLineF(rect.bottomRight(), rect.bottomLeft()), &tmp) != QLineF::NoIntersection) {
         if (tmp.x() >= rect.left() && tmp.x() <= rect.right()) {
             if (pt1.isNull()) pt1 = tmp;
             else pt2 = tmp;
         }
     }
     if (line.intersect(QLineF(rect.bottomLeft(), rect.topLeft()), &tmp) != QLineF::NoIntersection) {
         if (tmp.y() >= rect.top() && tmp.y() <= rect.bottom()) {
             if (pt1.isNull()) pt1 = tmp;
             else pt2 = tmp;
         }
     }
 
     if (pt1.isNull() || pt2.isNull()) return false;
 
     // Attempt to retain polarity of end points
     if ((line.x1() < line.x2()) != (pt1.x() > pt2.x()) || (line.y1() < line.y2()) != (pt1.y() > pt2.y())) {
         tmp = pt1;
         pt1 = pt2;
         pt2 = tmp;
     }
 
     line.setP1(pt1);
     line.setP2(pt2);
 
     return true;
 }
 
     template <class Rect, class Point>
     QVector<Point> sampleRectWithPoints(const Rect &rect)
     {
         QVector<Point> points;
 
         Point m1 = 0.5 * (rect.topLeft() + rect.topRight());
         Point m2 = 0.5 * (rect.bottomLeft() + rect.bottomRight());
 
         points << rect.topLeft();
         points << m1;
         points << rect.topRight();
 
         points << 0.5 * (rect.topLeft() + rect.bottomLeft());
         points << 0.5 * (m1 + m2);
         points << 0.5 * (rect.topRight() + rect.bottomRight());
 
         points << rect.bottomLeft();
         points << m2;
         points << rect.bottomRight();
 
         return points;
     }
 
     QVector<QPoint> sampleRectWithPoints(const QRect &rect)
     {
         return sampleRectWithPoints<QRect, QPoint>(rect);
     }
 
     QVector<QPointF> sampleRectWithPoints(const QRectF &rect)
     {
         return sampleRectWithPoints<QRectF, QPointF>(rect);
     }
 
 
     template <class Rect, class Point, bool alignPixels>
     Rect approximateRectFromPointsImpl(const QVector<Point> &points)
     {
         using namespace boost::accumulators;
         accumulator_set<qreal, stats<tag::min, tag::max > > accX;
         accumulator_set<qreal, stats<tag::min, tag::max > > accY;
 
         Q_FOREACH (const Point &pt, points) {
             accX(pt.x());
             accY(pt.y());
         }
 
         Rect resultRect;
 
         if (alignPixels) {
             resultRect.setCoords(std::floor(min(accX)), std::floor(min(accY)),
                                  std::ceil(max(accX)), std::ceil(max(accY)));
         } else {
             resultRect.setCoords(min(accX), min(accY),
                                  max(accX), max(accY));
         }
 
         return resultRect;
     }
 
     QRect approximateRectFromPoints(const QVector<QPoint> &points)
     {
         return approximateRectFromPointsImpl<QRect, QPoint, true>(points);
     }
 
     QRectF approximateRectFromPoints(const QVector<QPointF> &points)
     {
         return approximateRectFromPointsImpl<QRectF, QPointF, false>(points);
     }
 
     QRect approximateRectWithPointTransform(const QRect &rect, std::function<QPointF(QPointF)> func)
     {
         QVector<QPoint> points = sampleRectWithPoints(rect);
 
         using namespace boost::accumulators;
         accumulator_set<qreal, stats<tag::min, tag::max > > accX;
         accumulator_set<qreal, stats<tag::min, tag::max > > accY;
 
         Q_FOREACH (const QPoint &pt, points) {
             QPointF dstPt = func(pt);
 
             accX(dstPt.x());
             accY(dstPt.y());
         }
 
         QRect resultRect;
         resultRect.setCoords(std::floor(min(accX)), std::floor(min(accY)),
                              std::ceil(max(accX)), std::ceil(max(accY)));
 
         return resultRect;
     }
 
 
 QRectF cutOffRect(const QRectF &rc, const KisAlgebra2D::RightHalfPlane &p)
 {
     QVector<QPointF> points;
 
     const QLineF cutLine = p.getLine();
 
     points << rc.topLeft();
     points << rc.topRight();
     points << rc.bottomRight();
     points << rc.bottomLeft();
 
     QPointF p1 = points[3];
     bool p1Valid = p.pos(p1) >= 0;
 
     QVector<QPointF> resultPoints;
 
     for (int i = 0; i < 4; i++) {
         const QPointF p2 = points[i];
         const bool p2Valid = p.pos(p2) >= 0;
 
         if (p1Valid != p2Valid) {
             QPointF intersection;
             cutLine.intersect(QLineF(p1, p2), &intersection);
             resultPoints << intersection;
         }
 
         if (p2Valid) {
             resultPoints << p2;
         }
 
         p1 = p2;
         p1Valid = p2Valid;
     }
 
     return approximateRectFromPoints(resultPoints);
 }
 
 int quadraticEquation(qreal a, qreal b, qreal c, qreal *x1, qreal *x2)
 {
     int numSolutions = 0;
 
     const qreal D = pow2(b) - 4 * a * c;
 
     if (D < 0) {
         return 0;
     } else if (qFuzzyCompare(D, 0)) {
         *x1 = -b / (2 * a);
         numSolutions = 1;
     } else {
         const qreal sqrt_D = std::sqrt(D);
 
         *x1 = (-b + sqrt_D) / (2 * a);
         *x2 = (-b - sqrt_D) / (2 * a);
         numSolutions = 2;
     }
 
     return numSolutions;
 }
 
 QVector<QPointF> intersectTwoCircles(const QPointF &center1, qreal r1,
                                      const QPointF &center2, qreal r2)
 {
     QVector<QPointF> points;
 
     const QPointF diff = (center2 - center1);
     const QPointF c1;
     const QPointF c2 = diff;
 
     const qreal centerDistance = norm(diff);
 
     if (centerDistance > r1 + r2) return points;
     if (centerDistance < qAbs(r1 - r2)) return points;
 
     if (centerDistance < qAbs(r1 - r2) + 0.001) {
         qDebug() << "Skipping intersection" << ppVar(center1) << ppVar(center2) << ppVar(r1) << ppVar(r2) << ppVar(centerDistance) << ppVar(qAbs(r1-r2));
         return points;
     }
 
     const qreal x_kp1 = diff.x();
     const qreal y_kp1 = diff.y();
 
     const qreal F2 =
         0.5 * (pow2(x_kp1) +
                pow2(y_kp1) + pow2(r1) - pow2(r2));
 
     if (qFuzzyCompare(diff.y(), 0)) {
         qreal x = F2 / diff.x();
         qreal y1, y2;
         int result = KisAlgebra2D::quadraticEquation(
             1, 0,
             pow2(x) - pow2(r2),
             &y1, &y2);
 
         KIS_SAFE_ASSERT_RECOVER(result > 0) { return points; }
 
         if (result == 1) {
             points << QPointF(x, y1);
         } else if (result == 2) {
             KisAlgebra2D::RightHalfPlane p(c1, c2);
 
             QPointF p1(x, y1);
             QPointF p2(x, y2);
 
             if (p.pos(p1) >= 0) {
                 points << p1;
                 points << p2;
             } else {
                 points << p2;
                 points << p1;
             }
         }
     } else {
         const qreal A = diff.x() / diff.y();
         const qreal C = F2 / diff.y();
 
         qreal x1, x2;
         int result = KisAlgebra2D::quadraticEquation(
             1 + pow2(A), -2 * A * C,
             pow2(C) - pow2(r1),
             &x1, &x2);
 
         KIS_SAFE_ASSERT_RECOVER(result > 0) { return points; }
 
         if (result == 1) {
             points << QPointF(x1, C - x1 * A);
         } else if (result == 2) {
             KisAlgebra2D::RightHalfPlane p(c1, c2);
 
             QPointF p1(x1, C - x1 * A);
             QPointF p2(x2, C - x2 * A);
 
             if (p.pos(p1) >= 0) {
                 points << p1;
                 points << p2;
             } else {
                 points << p2;
                 points << p1;
             }
         }
     }
 
     for (int i = 0; i < points.size(); i++) {
         points[i] = center1 + points[i];
     }
 
     return points;
 }
 
 QTransform mapToRect(const QRectF &rect)
 {
     return
         QTransform(rect.width(), 0, 0, rect.height(),
                    rect.x(), rect.y());
 }
 
 bool fuzzyMatrixCompare(const QTransform &t1, const QTransform &t2, qreal delta) {
     return
             qAbs(t1.m11() - t2.m11()) < delta &&
             qAbs(t1.m12() - t2.m12()) < delta &&
             qAbs(t1.m13() - t2.m13()) < delta &&
             qAbs(t1.m21() - t2.m21()) < delta &&
             qAbs(t1.m22() - t2.m22()) < delta &&
             qAbs(t1.m23() - t2.m23()) < delta &&
             qAbs(t1.m31() - t2.m31()) < delta &&
             qAbs(t1.m32() - t2.m32()) < delta &&
             qAbs(t1.m33() - t2.m33()) < delta;
 }
 
+bool fuzzyPointCompare(const QPointF &p1, const QPointF &p2)
+{
+    return qFuzzyCompare(p1.x(), p2.x()) && qFuzzyCompare(p1.y(), p2.y());
+}
+
 
 /********************************************************/
 /*             DecomposedMatix                          */
 /********************************************************/
 
 DecomposedMatix::DecomposedMatix()
 {
 }
 
 DecomposedMatix::DecomposedMatix(const QTransform &t0)
 {
     QTransform t(t0);
 
     QTransform projMatrix;
 
     if (t.m33() == 0.0 || t0.determinant() == 0.0) {
         qWarning() << "Cannot decompose matrix!" << t;
         valid = false;
         return;
     }
 
     if (t.type() == QTransform::TxProject) {
         QTransform affineTransform(t.toAffine());
         projMatrix = affineTransform.inverted() * t;
 
         t = affineTransform;
         proj[0] = projMatrix.m13();
         proj[1] = projMatrix.m23();
         proj[2] = projMatrix.m33();
     }
 
 
     std::array<QVector3D, 3> rows;
 
     rows[0] = QVector3D(t.m11(), t.m12(), t.m13());
     rows[1] = QVector3D(t.m21(), t.m22(), t.m23());
     rows[2] = QVector3D(t.m31(), t.m32(), t.m33());
 
     if (!qFuzzyCompare(t.m33(), 1.0)) {
         const qreal invM33 = 1.0 / t.m33();
 
         for (auto row : rows) {
             row *= invM33;
         }
     }
 
     dx = rows[2].x();
     dy = rows[2].y();
 
     rows[2] = QVector3D(0,0,1);
 
     scaleX = rows[0].length();
     rows[0] *= 1.0 / scaleX;
 
     shearXY = QVector3D::dotProduct(rows[0], rows[1]);
     rows[1] = rows[1] - shearXY * rows[0];
 
     scaleY = rows[1].length();
     rows[1] *= 1.0 / scaleY;
     shearXY *= 1.0 / scaleY;
 
     // If determinant is negative, one axis was flipped.
     qreal determinant = rows[0].x() * rows[1].y() - rows[0].y() * rows[1].x();
     if (determinant < 0) {
         // Flip axis with minimum unit vector dot product.
         if (rows[0].x() < rows[1].y()) {
             scaleX = -scaleX;
             rows[0] = -rows[0];
         } else {
             scaleY = -scaleY;
             rows[1] = -rows[1];
         }
         shearXY = - shearXY;
     }
 
     angle = kisRadiansToDegrees(std::atan2(rows[0].y(), rows[0].x()));
 
     if (angle != 0.0) {
         // Rotate(-angle) = [cos(angle), sin(angle), -sin(angle), cos(angle)]
         //                = [row0x, -row0y, row0y, row0x]
         // Thanks to the normalization above.
 
         qreal sn = -rows[0].y();
         qreal cs = rows[0].x();
         qreal m11 = rows[0].x();
         qreal m12 = rows[0].y();
         qreal m21 = rows[1].x();
         qreal m22 = rows[1].y();
         rows[0].setX(cs * m11 + sn * m21);
         rows[0].setY(cs * m12 + sn * m22);
         rows[1].setX(-sn * m11 + cs * m21);
         rows[1].setY(-sn * m12 + cs * m22);
     }
 
     QTransform leftOver(
                 rows[0].x(), rows[0].y(), rows[0].z(),
             rows[1].x(), rows[1].y(), rows[1].z(),
             rows[2].x(), rows[2].y(), rows[2].z());
 
     KIS_SAFE_ASSERT_RECOVER_NOOP(fuzzyMatrixCompare(leftOver, QTransform(), 1e-4));
 }
 
 }
diff --git a/libs/global/kis_algebra_2d.h b/libs/global/kis_algebra_2d.h
index e95cab697b..97e1248b1d 100644
--- a/libs/global/kis_algebra_2d.h
+++ b/libs/global/kis_algebra_2d.h
@@ -1,569 +1,582 @@
 /*
  *  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_ALGEBRA_2D_H
 #define __KIS_ALGEBRA_2D_H
 
 #include <QPoint>
 #include <QPointF>
 #include <QVector>
 #include <QPolygonF>
 #include <QTransform>
 #include <cmath>
 #include <kis_global.h>
 #include <kritaglobal_export.h>
 #include <functional>
 
 class QPainterPath;
 class QTransform;
 
 namespace KisAlgebra2D {
 
 template <class T>
 struct PointTypeTraits
 {
 };
 
 template <>
 struct PointTypeTraits<QPoint>
 {
     typedef int value_type;
     typedef qreal calculation_type;
     typedef QRect rect_type;
 };
 
 template <>
 struct PointTypeTraits<QPointF>
 {
     typedef qreal value_type;
     typedef qreal calculation_type;
     typedef QRectF rect_type;
 };
 
 
 template <class T>
 typename PointTypeTraits<T>::value_type dotProduct(const T &a, const T &b)
 {
     return a.x() * b.x() + a.y() * b.y();
 }
 
 template <class T>
 typename PointTypeTraits<T>::value_type crossProduct(const T &a, const T &b)
 {
     return a.x() * b.y() - a.y() * b.x();
 }
 
 template <class T>
 qreal norm(const T &a)
 {
     return std::sqrt(pow2(a.x()) + pow2(a.y()));
 }
 
 template <class Point>
 Point normalize(const Point &a)
 {
     const qreal length = norm(a);
     return (1.0 / length) * a;
 }
 
 /**
  * Usual sign() function with positive zero
  */
 template <typename T>
 T signPZ(T x) {
     return x >= T(0) ? T(1) : T(-1);
 }
 
 /**
  * Usual sign() function with zero returning zero
  */
 template <typename T>
 T signZZ(T x) {
     return x == T(0) ? T(0) : x > T(0) ? T(1) : T(-1);
 }
 
 /**
  * Copies the sign of \p y into \p x and returns the result
  */
 template <typename T>
     inline T copysign(T x, T y) {
     T strippedX = qAbs(x);
     return y >= T(0) ? strippedX : -strippedX;
 }
 
 template <class T>
 T leftUnitNormal(const T &a)
 {
     T result = a.x() != 0 ? T(-a.y() / a.x(), 1) : T(-1, 0);
     qreal length = norm(result);
     result *= (crossProduct(a, result) >= 0 ? 1 : -1) / length;
 
     return -result;
 }
 
 template <class T>
 T rightUnitNormal(const T &a)
 {
     return -leftUnitNormal(a);
 }
 
 template <class T>
 T inwardUnitNormal(const T &a, int polygonDirection)
 {
     return polygonDirection * leftUnitNormal(a);
 }
 
 /**
  * \return 1 if the polygon is counterclockwise
  *        -1 if the polygon is clockwise
  *
  * Note: the sign is flipped because our 0y axis
  *       is reversed
  */
 template <class T>
 int polygonDirection(const QVector<T> &polygon) {
 
     typename PointTypeTraits<T>::value_type doubleSum = 0;
 
     const int numPoints = polygon.size();
     for (int i = 1; i <= numPoints; i++) {
         int prev = i - 1;
         int next = i == numPoints ? 0 : i;
 
         doubleSum +=
             (polygon[next].x() - polygon[prev].x()) *
             (polygon[next].y() + polygon[prev].y());
     }
 
     return doubleSum >= 0 ? 1 : -1;
 }
 
 template <typename T>
 bool isInRange(T x, T a, T b) {
     T length = qAbs(a - b);
     return qAbs(x - a) <= length && qAbs(x - b) <= length;
 }
 
 void KRITAGLOBAL_EXPORT adjustIfOnPolygonBoundary(const QPolygonF &poly, int polygonDirection, QPointF *pt);
 
 /**
  * Let \p pt, \p base1 are two vectors. \p base1 is uniformly scaled
  * and then rotated into \p base2 using transformation matrix S *
  * R. The function applies the same transformation to \pt and returns
  * the result.
  **/
 QPointF KRITAGLOBAL_EXPORT transformAsBase(const QPointF &pt, const QPointF &base1, const QPointF &base2);
 
 qreal KRITAGLOBAL_EXPORT angleBetweenVectors(const QPointF &v1, const QPointF &v2);
 
+/**
+ * Computes an angle indicating the direction from p1 to p2. If p1 and p2 are too close together to
+ * compute an angle, defaultAngle is returned.
+ */
+qreal KRITAGLOBAL_EXPORT directionBetweenPoints(const QPointF &p1, const QPointF &p2,
+                                                qreal defaultAngle);
+
 namespace Private {
     inline void resetEmptyRectangle(const QPoint &pt, QRect *rc) {
         *rc = QRect(pt, QSize(1, 1));
     }
 
     inline void resetEmptyRectangle(const QPointF &pt, QRectF *rc) {
         static const qreal eps = 1e-10;
         *rc = QRectF(pt, QSizeF(eps, eps));
     }
 }
 
 template <class Point, class Rect>
 inline void accumulateBounds(const Point &pt, Rect *bounds)
 {
     if (bounds->isEmpty()) {
         Private::resetEmptyRectangle(pt, bounds);
     }
 
     if (pt.x() > bounds->right()) {
         bounds->setRight(pt.x());
     }
 
     if (pt.x() < bounds->left()) {
         bounds->setLeft(pt.x());
     }
 
     if (pt.y() > bounds->bottom()) {
         bounds->setBottom(pt.y());
     }
 
     if (pt.y() < bounds->top()) {
         bounds->setTop(pt.y());
     }
 }
 
 template <template <class T> class Container, class Point, class Rect>
 inline void accumulateBounds(const Container<Point> &points, Rect *bounds)
 {
     Q_FOREACH (const Point &pt, points) {
         accumulateBounds(pt, bounds);
     }
 }
 
 template <template <class T> class Container, class Point>
 inline typename PointTypeTraits<Point>::rect_type
 accumulateBounds(const Container<Point> &points)
 {
     typename PointTypeTraits<Point>::rect_type result;
 
     Q_FOREACH (const Point &pt, points) {
         accumulateBounds(pt, &result);
     }
 
     return result;
 }
 
 template <class Point, class Rect>
 inline Point clampPoint(Point pt, const Rect &bounds)
 {
     if (pt.x() > bounds.right()) {
         pt.rx() = bounds.right();
     }
 
     if (pt.x() < bounds.left()) {
         pt.rx() = bounds.left();
     }
 
     if (pt.y() > bounds.bottom()) {
         pt.ry() = bounds.bottom();
     }
 
     if (pt.y() < bounds.top()) {
         pt.ry() = bounds.top();
     }
 
     return pt;
 }
 
 template <class Size>
 auto maxDimension(Size size) -> decltype(size.width()) {
     return qMax(size.width(), size.height());
 }
 
 template <class Size>
 auto minDimension(Size size) -> decltype(size.width()) {
     return qMin(size.width(), size.height());
 }
 
 QPainterPath KRITAGLOBAL_EXPORT smallArrow();
 
 /**
  * Multiply width and height of \p rect by \p coeff keeping the
  * center of the rectangle pinned
  */
 template <class Rect>
 Rect blowRect(const Rect &rect, qreal coeff)
 {
     typedef decltype(rect.x()) CoordType;
 
     CoordType w = rect.width() * coeff;
     CoordType h = rect.height() * coeff;
 
     return rect.adjusted(-w, -h, w, h);
 }
 
 QPoint KRITAGLOBAL_EXPORT ensureInRect(QPoint pt, const QRect &bounds);
 QPointF KRITAGLOBAL_EXPORT ensureInRect(QPointF pt, const QRectF &bounds);
 
 template <class Rect>
 Rect ensureRectNotSmaller(Rect rc, const decltype(Rect().size()) &size)
 {
     typedef decltype(Rect().size()) Size;
     typedef decltype(Rect().top()) ValueType;
 
     if (rc.width() < size.width() ||
         rc.height() < size.height()) {
 
         ValueType width = qMax(rc.width(), size.width());
         ValueType  height = qMax(rc.height(), size.height());
 
         rc = Rect(rc.topLeft(), Size(width, height));
     }
 
     return rc;
 }
 
 template <class Size>
 Size ensureSizeNotSmaller(const Size &size, const Size &bounds)
 {
     Size result = size;
 
     const auto widthBound = qAbs(bounds.width());
     auto width = result.width();
     if (qAbs(width) < widthBound) {
         width = copysign(widthBound, width);
         result.setWidth(width);
     }
 
     const auto heightBound = qAbs(bounds.height());
     auto height = result.height();
     if (qAbs(height) < heightBound) {
         height = copysign(heightBound, height);
         result.setHeight(height);
     }
 
     return result;
 }
 
 
 /**
  * Attempt to intersect a line to the area of the a rectangle.
  *
  * If the line intersects the rectange, it will be modified to represent the intersecting line segment and true is returned.
  * If the line does not intersect the area, it remains unmodified and false will be returned.
  *
  * @param segment
  * @param area
  * @return true if successful
  */
 bool KRITAGLOBAL_EXPORT intersectLineRect(QLineF &line, const QRect rect);
 
 
 template <class Point>
 inline Point abs(const Point &pt) {
     return Point(qAbs(pt.x()), qAbs(pt.y()));
 }
 
 
 class RightHalfPlane {
 public:
 
     RightHalfPlane(const QPointF &a, const QPointF &b)
         : m_a(a), m_p(b - a), m_norm_p_inv(1.0 / norm(m_p))
     {
     }
 
     RightHalfPlane(const QLineF &line)
         : RightHalfPlane(line.p1(), line.p2())
     {
     }
 
     qreal valueSq(const QPointF &pt) const {
         const qreal val = value(pt);
         return signZZ(val) * pow2(val);
     }
 
     qreal value(const QPointF &pt) const {
         return crossProduct(m_p, pt - m_a) * m_norm_p_inv;
     }
 
     int pos(const QPointF &pt) const {
         return signZZ(value(pt));
     }
 
     QLineF getLine() const {
         return QLineF(m_a, m_a + m_p);
     }
 
 private:
     const QPointF m_a;
     const QPointF m_p;
     const qreal m_norm_p_inv;
 };
 
 class OuterCircle {
 public:
 
     OuterCircle(const QPointF &c, qreal radius)
         : m_c(c),
           m_radius(radius),
           m_radius_sq(pow2(radius)),
           m_fadeCoeff(1.0 / (pow2(radius + 1.0) - m_radius_sq))
     {
     }
 
     qreal valueSq(const QPointF &pt) const {
         const qreal val = value(pt);
 
         return signZZ(val) * pow2(val);
     }
 
     qreal value(const QPointF &pt) const {
         return kisDistance(pt, m_c) - m_radius;
     }
 
     int pos(const QPointF &pt) const {
         return signZZ(valueSq(pt));
     }
 
     qreal fadeSq(const QPointF &pt) const {
         const qreal valSq = kisSquareDistance(pt, m_c);
         return (valSq - m_radius_sq) * m_fadeCoeff;
     }
 
 private:
     const QPointF m_c;
     const qreal m_radius;
     const qreal m_radius_sq;
     const qreal m_fadeCoeff;
 };
 
 QVector<QPoint> KRITAGLOBAL_EXPORT sampleRectWithPoints(const QRect &rect);
 QVector<QPointF> KRITAGLOBAL_EXPORT sampleRectWithPoints(const QRectF &rect);
 
 QRect KRITAGLOBAL_EXPORT approximateRectFromPoints(const QVector<QPoint> &points);
 QRectF KRITAGLOBAL_EXPORT approximateRectFromPoints(const QVector<QPointF> &points);
 
 QRect KRITAGLOBAL_EXPORT approximateRectWithPointTransform(const QRect &rect, std::function<QPointF(QPointF)> func);
 
 
 /**
  * Cuts off a portion of a rect \p rc defined by a half-plane \p p
  * \return the bounding rect of the resulting polygon
  */
 KRITAGLOBAL_EXPORT
 QRectF cutOffRect(const QRectF &rc, const KisAlgebra2D::RightHalfPlane &p);
 
 
 /**
  * Solves a quadratic equation in a form:
  *
  * a * x^2 + b * x + c = 0
  *
  * WARNING: Please note that \p a *must* be nonzero!  Otherwise the
  * equation is not quadratic! And this function doesn't check that!
  *
  * \return the number of solutions. It can be 0, 1 or 2.
  *
  * \p x1, \p x2 --- the found solution. The variables are filled with
  *                  data iff the corresponding solution is found. That
  *                  is: 0 solutions --- variabled are not touched, 1
  *                  solution --- x1 is filled with the result, 2
  *                  solutions --- x1 and x2 are filled.
  */
 KRITAGLOBAL_EXPORT
 int quadraticEquation(qreal a, qreal b, qreal c, qreal *x1, qreal *x2);
 
 /**
  * Finds the points of intersections between two circles
  * \return the found circles, the result can have 0, 1 or 2 points
  */
 KRITAGLOBAL_EXPORT
 QVector<QPointF> intersectTwoCircles(const QPointF &c1, qreal r1,
                                      const QPointF &c2, qreal r2);
 
 KRITAGLOBAL_EXPORT
 QTransform mapToRect(const QRectF &rect);
 
 /**
  * Scale the relative point \pt into the bounds of \p rc. The point might be
  * outside the rectangle.
  */
 inline QPointF relativeToAbsolute(const QPointF &pt, const QRectF &rc) {
     return rc.topLeft() + QPointF(pt.x() * rc.width(), pt.y() * rc.height());
 }
 
 /**
  * Get the relative position of \p pt inside rectangle \p rc. The point can be
  * outside the rectangle.
  */
 inline QPointF absoluteToRelative(const QPointF &pt, const QRectF &rc) {
     if (!rc.isValid()) return QPointF();
 
     const QPointF rel = pt - rc.topLeft();
     return QPointF(rel.x() / rc.width(), rel.y() / rc.height());
 
 }
 
 /**
  * Compare the matrices with tolerance \p delta
  */
 bool KRITAGLOBAL_EXPORT fuzzyMatrixCompare(const QTransform &t1, const QTransform &t2, qreal delta);
 
+/**
+ * Returns true if the two points are equal within some tolerance, where the tolerance is determined
+ * by Qt's built-in fuzzy comparison functions.
+ */
+bool KRITAGLOBAL_EXPORT fuzzyPointCompare(const QPointF &p1, const QPointF &p2);
+
 /**
  * Compare two rectangles with tolerance \p tolerance. The tolerance means that the
  * coordinates of top left and bottom right corners should not differ more than \p tolerance
  * pixels.
  */
 template<class Rect, typename Difference = decltype(Rect::width())>
 bool fuzzyCompareRects(const Rect &r1, const Rect &r2, Difference tolerance) {
     typedef decltype(r1.topLeft()) Point;
 
     const Point d1 = abs(r1.topLeft() - r2.topLeft());
     const Point d2 = abs(r1.bottomRight() - r2.bottomRight());
 
     const Difference maxError = std::max({d1.x(), d1.y(), d2.x(), d2.y()});
     return maxError < tolerance;
 }
 
 struct KRITAGLOBAL_EXPORT DecomposedMatix {
     DecomposedMatix();
 
     DecomposedMatix(const QTransform &t0);
 
     inline QTransform scaleTransform() const
     {
         return QTransform::fromScale(scaleX, scaleY);
     }
 
     inline QTransform shearTransform() const
     {
         QTransform t;
         t.shear(shearXY, 0);
         return t;
     }
 
     inline QTransform rotateTransform() const
     {
         QTransform t;
         t.rotate(angle);
         return t;
     }
 
     inline QTransform translateTransform() const
     {
         return QTransform::fromTranslate(dx, dy);
     }
 
     inline QTransform projectTransform() const
     {
         return
             QTransform(
                 1,0,proj[0],
                 0,1,proj[1],
                 0,0,proj[2]);
     }
 
     inline QTransform transform() const {
         return
             scaleTransform() *
             shearTransform() *
             rotateTransform() *
             translateTransform() *
             projectTransform();
     }
 
     inline bool isValid() const {
         return valid;
     }
 
     qreal scaleX = 1.0;
     qreal scaleY = 1.0;
     qreal shearXY = 0.0;
     qreal angle = 0.0;
     qreal dx = 0.0;
     qreal dy = 0.0;
     qreal proj[3] = {0.0, 0.0, 1.0};
 
 private:
     bool valid = true;
 };
 
 }
 
 
 #endif /* __KIS_ALGEBRA_2D_H */
diff --git a/libs/image/brushengine/kis_paint_information.cc b/libs/image/brushengine/kis_paint_information.cc
index 2a6deea6a3..4e066320b6 100644
--- a/libs/image/brushengine/kis_paint_information.cc
+++ b/libs/image/brushengine/kis_paint_information.cc
@@ -1,572 +1,589 @@
 /*
  *  Copyright (c) 2007,2010 Cyrille Berger <cberger@cberger.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include <brushengine/kis_paint_information.h>
 
 #include <QDomElement>
 #include <QScopedPointer>
 
 #include <Eigen/Core>
 
 #include "kis_paintop.h"
 #include "kis_algebra_2d.h"
 #include "kis_lod_transform.h"
 
 #include <kis_dom_utils.h>
 
 struct KisPaintInformation::Private {
     EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
     Private(const QPointF & pos_,
             qreal pressure_,
             qreal xTilt_, qreal yTilt_,
             qreal rotation_,
             qreal tangentialPressure_,
             qreal perspective_,
             qreal time_,
             qreal speed_,
             bool isHoveringMode_)
         :
         pos(pos_),
         pressure(pressure_),
         xTilt(xTilt_),
         yTilt(yTilt_),
         rotation(rotation_),
         tangentialPressure(tangentialPressure_),
         perspective(perspective_),
         time(time_),
         speed(speed_),
         isHoveringMode(isHoveringMode_),
         randomSource(0),
         currentDistanceInfo(0),
         levelOfDetail(0)
     {
     }
 
 
 
     ~Private() {
         KIS_ASSERT_RECOVER_NOOP(!currentDistanceInfo);
     }
     Private(const Private &rhs) {
         copy(rhs);
     }
     Private& operator=(const Private &rhs) {
         copy(rhs);
         return *this;
     }
 
     void copy(const Private &rhs) {
         pos = rhs.pos;
         pressure = rhs.pressure;
         xTilt = rhs.xTilt;
         yTilt = rhs.yTilt;
         rotation = rhs.rotation;
         tangentialPressure = rhs.tangentialPressure;
         perspective = rhs.perspective;
         time = rhs.time;
         speed = rhs.speed;
         isHoveringMode = rhs.isHoveringMode;
         randomSource = rhs.randomSource;
         currentDistanceInfo = rhs.currentDistanceInfo;
         canvasRotation = rhs.canvasRotation;
         canvasMirroredH = rhs.canvasMirroredH;
         if (rhs.drawingAngleOverride) {
             drawingAngleOverride.reset(new qreal(*rhs.drawingAngleOverride));
         }
 
         levelOfDetail = rhs.levelOfDetail;
     }
 
 
     QPointF pos;
     qreal pressure;
     qreal xTilt;
     qreal yTilt;
     qreal rotation;
     qreal tangentialPressure;
     qreal perspective;
     qreal time;
     qreal speed;
     bool isHoveringMode;
     KisRandomSourceSP randomSource;
     int canvasRotation;
     bool canvasMirroredH;
 
     QScopedPointer<qreal> drawingAngleOverride;
     KisDistanceInformation *currentDistanceInfo;
 
     int levelOfDetail;
 
     void registerDistanceInfo(KisDistanceInformation *di) {
         currentDistanceInfo = di;
     }
 
     void unregisterDistanceInfo() {
         currentDistanceInfo = 0;
     }
 };
 
 KisPaintInformation::DistanceInformationRegistrar::
 DistanceInformationRegistrar(KisPaintInformation *_p, KisDistanceInformation *distanceInfo)
     : p(_p)
 {
     p->d->registerDistanceInfo(distanceInfo);
 }
 
 KisPaintInformation::DistanceInformationRegistrar::
 ~DistanceInformationRegistrar()
 {
     p->d->unregisterDistanceInfo();
 }
 
 KisPaintInformation::KisPaintInformation(const QPointF & pos,
                                          qreal pressure,
                                          qreal xTilt, qreal yTilt,
                                          qreal rotation,
                                          qreal tangentialPressure,
                                          qreal perspective,
                                          qreal time,
                                          qreal speed)
     : d(new Private(pos,
                     pressure,
                     xTilt, yTilt,
                     rotation,
                     tangentialPressure,
                     perspective,
                     time,
                     speed,
                     false))
 {
 }
 
 KisPaintInformation::KisPaintInformation(const QPointF & pos,
                                          qreal pressure,
                                          qreal xTilt,
                                          qreal yTilt,
                                          qreal rotation)
     : d(new Private(pos,
                     pressure,
                     xTilt, yTilt,
                     rotation,
                     0.0,
                     1.0,
                     0.0,
                     0.0,
                     false))
 {
 
 }
 
 KisPaintInformation::KisPaintInformation(const QPointF &pos,
                                          qreal pressure)
     : d(new Private(pos,
                     pressure,
                     0.0, 0.0,
                     0.0,
                     0.0,
                     1.0,
                     0.0,
                     0.0,
                     false))
 {
 }
 
 KisPaintInformation::KisPaintInformation(const KisPaintInformation& rhs)
     : d(new Private(*rhs.d))
 {
 }
 
 void KisPaintInformation::operator=(const KisPaintInformation & rhs)
 {
     *d = *rhs.d;
 }
 
 KisPaintInformation::~KisPaintInformation()
 {
     delete d;
 }
 
 bool KisPaintInformation::isHoveringMode() const
 {
     return d->isHoveringMode;
 }
 
 
 KisPaintInformation
 KisPaintInformation::createHoveringModeInfo(const QPointF &pos,
         qreal pressure,
         qreal xTilt, qreal yTilt,
         qreal rotation,
         qreal tangentialPressure,
         qreal perspective,
         qreal speed,
         int canvasrotation,
         bool canvasMirroredH)
 {
     KisPaintInformation info(pos,
                              pressure,
                              xTilt, yTilt,
                              rotation,
                              tangentialPressure,
                              perspective, 0, speed);
     info.d->isHoveringMode = true;
     info.d->canvasRotation = canvasrotation;
     info.d->canvasMirroredH = canvasMirroredH;
     return info;
 }
 
 
 int KisPaintInformation::canvasRotation() const
 {
     return d->canvasRotation;
 }
 
 void KisPaintInformation::setCanvasRotation(int rotation)
 {
     if (rotation < 0) {
         d->canvasRotation= 360- abs(rotation % 360);
     } else {
         d->canvasRotation= rotation % 360;
     }
 
 }
 
 bool KisPaintInformation::canvasMirroredH() const
 {
     return d->canvasMirroredH;
 }
 
 void KisPaintInformation::setCanvasHorizontalMirrorState(bool mir)
 {
     d->canvasMirroredH = mir;
 
 }
 
 void KisPaintInformation::toXML(QDomDocument&, QDomElement& e) const
 {
     // hovering mode infos are not supposed to be saved
     KIS_ASSERT_RECOVER_NOOP(!d->isHoveringMode);
 
     e.setAttribute("pointX", QString::number(pos().x(), 'g', 15));
     e.setAttribute("pointY", QString::number(pos().y(), 'g', 15));
     e.setAttribute("pressure", QString::number(pressure(), 'g', 15));
     e.setAttribute("xTilt", QString::number(xTilt(), 'g', 15));
     e.setAttribute("yTilt", QString::number(yTilt(), 'g', 15));
     e.setAttribute("rotation", QString::number(rotation(), 'g', 15));
     e.setAttribute("tangentialPressure", QString::number(tangentialPressure(), 'g', 15));
     e.setAttribute("perspective", QString::number(perspective(), 'g', 15));
     e.setAttribute("time", QString::number(d->time, 'g', 15));
     e.setAttribute("speed", QString::number(d->speed, 'g', 15));
 }
 
 KisPaintInformation KisPaintInformation::fromXML(const QDomElement& e)
 {
     qreal pointX = qreal(KisDomUtils::toDouble(e.attribute("pointX", "0.0")));
     qreal pointY = qreal(KisDomUtils::toDouble(e.attribute("pointY", "0.0")));
     qreal pressure = qreal(KisDomUtils::toDouble(e.attribute("pressure", "0.0")));
     qreal rotation = qreal(KisDomUtils::toDouble(e.attribute("rotation", "0.0")));
     qreal tangentialPressure = qreal(KisDomUtils::toDouble(e.attribute("tangentialPressure", "0.0")));
     qreal perspective = qreal(KisDomUtils::toDouble(e.attribute("perspective", "0.0")));
     qreal xTilt = qreal(KisDomUtils::toDouble(e.attribute("xTilt", "0.0")));
     qreal yTilt = qreal(KisDomUtils::toDouble(e.attribute("yTilt", "0.0")));
     qreal time = KisDomUtils::toDouble(e.attribute("time", "0"));
     qreal speed = KisDomUtils::toDouble(e.attribute("speed", "0"));
 
     return KisPaintInformation(QPointF(pointX, pointY), pressure, xTilt, yTilt,
                                rotation, tangentialPressure, perspective, time, speed);
 }
 
 const QPointF& KisPaintInformation::pos() const
 {
     return d->pos;
 }
 
 void KisPaintInformation::setPos(const QPointF& p)
 {
     d->pos = p;
 }
 
 qreal KisPaintInformation::pressure() const
 {
     return d->pressure;
 }
 
 void KisPaintInformation::setPressure(qreal p)
 {
     d->pressure = p;
 }
 
 qreal KisPaintInformation::xTilt() const
 {
     return d->xTilt;
 }
 
 qreal KisPaintInformation::yTilt() const
 {
     return d->yTilt;
 }
 
 void KisPaintInformation::overrideDrawingAngle(qreal angle)
 {
     d->drawingAngleOverride.reset(new qreal(angle));
 }
 
 qreal KisPaintInformation::drawingAngleSafe(const KisDistanceInformation &distance) const
 {
     if (d->drawingAngleOverride) return *d->drawingAngleOverride;
 
-    QVector2D diff(pos() - distance.lastPosition());
-    return atan2(diff.y(), diff.x());
+    if (!distance.hasLastDabInformation()) {
+        warnKrita << "KisPaintInformation::drawingAngleSafe()" << "Cannot access Distance Info last dab data";
+        return 0.0;
+    }
+
+    return distance.nextDrawingAngle(pos());
 }
 
 KisPaintInformation::DistanceInformationRegistrar
 KisPaintInformation::registerDistanceInformation(KisDistanceInformation *distance)
 {
     return DistanceInformationRegistrar(this, distance);
 }
 
 qreal KisPaintInformation::drawingAngle() const
 {
     if (d->drawingAngleOverride) return *d->drawingAngleOverride;
 
     if (!d->currentDistanceInfo || !d->currentDistanceInfo->hasLastDabInformation()) {
         warnKrita << "KisPaintInformation::drawingAngle()" << "Cannot access Distance Info last dab data";
         return 0.0;
     }
 
-    if (d->currentDistanceInfo->hasLockedDrawingAngle()) {
-        return d->currentDistanceInfo->lockedDrawingAngle();
-    }
-
-    QVector2D diff(pos() - d->currentDistanceInfo->lastPosition());
-    return atan2(diff.y(), diff.x());
+    return d->currentDistanceInfo->nextDrawingAngle(pos());
 }
 
 void KisPaintInformation::lockCurrentDrawingAngle(qreal alpha_unused) const
 {
     Q_UNUSED(alpha_unused);
 
-    if (!d->currentDistanceInfo) {
+    if (!d->currentDistanceInfo || !d->currentDistanceInfo->hasLastDabInformation()) {
         warnKrita << "KisPaintInformation::lockCurrentDrawingAngle()" << "Cannot access Distance Info last dab data";
         return;
     }
 
-    const QVector2D diff(pos() - d->currentDistanceInfo->lastPosition());
-    const qreal angle = atan2(diff.y(), diff.x());
+    qreal angle = d->currentDistanceInfo->nextDrawingAngle(pos(), false);
 
     qreal newAngle = angle;
 
     if (d->currentDistanceInfo->hasLockedDrawingAngle()) {
         const qreal stabilizingCoeff = 20.0;
         const qreal dist = stabilizingCoeff * d->currentDistanceInfo->currentSpacing().scalarApprox();
         const qreal alpha = qMax(0.0, dist - d->currentDistanceInfo->scalarDistanceApprox()) / dist;
 
         const qreal oldAngle = d->currentDistanceInfo->lockedDrawingAngle();
 
         if (shortestAngularDistance(oldAngle, newAngle) < M_PI / 6) {
             newAngle = (1.0 - alpha) * oldAngle + alpha * newAngle;
         } else {
             newAngle = oldAngle;
         }
     }
 
     d->currentDistanceInfo->setLockedDrawingAngle(newAngle);
 }
 
 QPointF KisPaintInformation::drawingDirectionVector() const
 {
     if (d->drawingAngleOverride) {
         qreal angle = *d->drawingAngleOverride;
         return QPointF(cos(angle), sin(angle));
     }
 
     if (!d->currentDistanceInfo || !d->currentDistanceInfo->hasLastDabInformation()) {
         warnKrita << "KisPaintInformation::drawingDirectionVector()" << "Cannot access Distance Info last dab data";
         return QPointF(1.0, 0.0);
     }
 
-    QPointF diff(pos() - d->currentDistanceInfo->lastPosition());
-    return KisAlgebra2D::normalize(diff);
+    return d->currentDistanceInfo->nextDrawingDirectionVector(pos());
 }
 
 qreal KisPaintInformation::drawingDistance() const
 {
     if (!d->currentDistanceInfo || !d->currentDistanceInfo->hasLastDabInformation()) {
         warnKrita << "KisPaintInformation::drawingDistance()" << "Cannot access Distance Info last dab data";
         return 1.0;
     }
 
     QVector2D diff(pos() - d->currentDistanceInfo->lastPosition());
     qreal length = diff.length();
 
     if (d->levelOfDetail) {
         length *= KisLodTransform::lodToInvScale(d->levelOfDetail);
     }
 
     return length;
 }
 
 qreal KisPaintInformation::drawingSpeed() const
 {
     return d->speed;
 }
 
 qreal KisPaintInformation::rotation() const
 {
     return d->rotation;
 }
 
 qreal KisPaintInformation::tangentialPressure() const
 {
     return d->tangentialPressure;
 }
 
 qreal KisPaintInformation::perspective() const
 {
     return d->perspective;
 }
 
 qreal KisPaintInformation::currentTime() const
 {
     return d->time;
 }
 
 KisRandomSourceSP KisPaintInformation::randomSource() const
 {
     if (!d->randomSource) {
         d->randomSource = new KisRandomSource();
     }
 
     return d->randomSource;
 }
 
 void KisPaintInformation::setRandomSource(KisRandomSourceSP value)
 {
     d->randomSource = value;
 }
 
 void KisPaintInformation::setLevelOfDetail(int levelOfDetail) const
 {
     d->levelOfDetail = levelOfDetail;
 }
 
 QDebug operator<<(QDebug dbg, const KisPaintInformation &info)
 {
 #ifdef NDEBUG
     Q_UNUSED(info);
 #else
     dbg.nospace() << "Position: " << info.pos();
     dbg.nospace() << ", Pressure: " << info.pressure();
     dbg.nospace() << ", X Tilt: " << info.xTilt();
     dbg.nospace() << ", Y Tilt: " << info.yTilt();
     dbg.nospace() << ", Rotation: " << info.rotation();
     dbg.nospace() << ", Tangential Pressure: " << info.tangentialPressure();
     dbg.nospace() << ", Perspective: " << info.perspective();
     dbg.nospace() << ", Drawing Angle: " << info.drawingAngle();
     dbg.nospace() << ", Drawing Speed: " << info.drawingSpeed();
     dbg.nospace() << ", Drawing Distance: " << info.drawingDistance();
     dbg.nospace() << ", Time: " << info.currentTime();
 #endif
     return dbg.space();
 }
 
 KisPaintInformation KisPaintInformation::mixOnlyPosition(qreal t, const KisPaintInformation& mixedPi, const KisPaintInformation& basePi)
 {
     QPointF pt = (1 - t) * mixedPi.pos() + t * basePi.pos();
-    KisPaintInformation result(pt,
-                               basePi.pressure(),
-                               basePi.xTilt(),
-                               basePi.yTilt(),
-                               basePi.rotation(),
-                               basePi.tangentialPressure(),
-                               basePi.perspective(),
-                               basePi.currentTime(),
-                               basePi.drawingSpeed());
-
-    result.setRandomSource(basePi.randomSource());
-    return result;
+    return mixImpl(pt, t, mixedPi, basePi, true, false);
 }
 
 KisPaintInformation KisPaintInformation::mix(qreal t, const KisPaintInformation& pi1, const KisPaintInformation& pi2)
 {
     QPointF pt = (1 - t) * pi1.pos() + t * pi2.pos();
     return mix(pt, t, pi1, pi2);
 }
 
 KisPaintInformation KisPaintInformation::mix(const QPointF& p, qreal t, const KisPaintInformation& pi1, const KisPaintInformation& pi2)
 {
-    qreal pressure = (1 - t) * pi1.pressure() + t * pi2.pressure();
-    qreal xTilt = (1 - t) * pi1.xTilt() + t * pi2.xTilt();
-    qreal yTilt = (1 - t) * pi1.yTilt() + t * pi2.yTilt();
+    return mixImpl(p, t, pi1, pi2, false, true);
+}
 
-    qreal rotation = pi1.rotation();
+KisPaintInformation KisPaintInformation::mixWithoutTime(qreal t, const KisPaintInformation& pi1, const KisPaintInformation& pi2)
+{
+    QPointF pt = (1 - t) * pi1.pos() + t * pi2.pos();
+    return mixWithoutTime(pt, t, pi1, pi2);
+}
 
-    if (pi1.rotation() != pi2.rotation()) {
-        qreal a1 = kisDegreesToRadians(pi1.rotation());
-        qreal a2 = kisDegreesToRadians(pi2.rotation());
-        qreal distance = shortestAngularDistance(a2, a1);
+KisPaintInformation KisPaintInformation::mixWithoutTime(const QPointF& p, qreal t, const KisPaintInformation& pi1, const KisPaintInformation& pi2)
+{
+    return mixImpl(p, t, pi1, pi2, false, false);
+}
 
-        rotation = kisRadiansToDegrees(incrementInDirection(a1, t * distance, a2));
+KisPaintInformation KisPaintInformation::mixImpl(const QPointF &p, qreal t, const KisPaintInformation &pi1, const KisPaintInformation &pi2, bool posOnly, bool mixTime)
+{
+    if (posOnly) {
+        KisPaintInformation result(p,
+                                   pi2.pressure(),
+                                   pi2.xTilt(),
+                                   pi2.yTilt(),
+                                   pi2.rotation(),
+                                   pi2.tangentialPressure(),
+                                   pi2.perspective(),
+                                   pi2.currentTime(),
+                                   pi2.drawingSpeed());
+        result.setRandomSource(pi2.randomSource());
+        return result;
     }
+    else {
+        qreal pressure = (1 - t) * pi1.pressure() + t * pi2.pressure();
+        qreal xTilt = (1 - t) * pi1.xTilt() + t * pi2.xTilt();
+        qreal yTilt = (1 - t) * pi1.yTilt() + t * pi2.yTilt();
 
-    qreal tangentialPressure = (1 - t) * pi1.tangentialPressure() + t * pi2.tangentialPressure();
-    qreal perspective = (1 - t) * pi1.perspective() + t * pi2.perspective();
-    qreal time = (1 - t) * pi1.currentTime() + t * pi2.currentTime();
-    qreal speed = (1 - t) * pi1.drawingSpeed() + t * pi2.drawingSpeed();
+        qreal rotation = pi1.rotation();
 
-    KisPaintInformation result(p, pressure, xTilt, yTilt, rotation, tangentialPressure, perspective, time, speed);
-    KIS_ASSERT_RECOVER_NOOP(pi1.isHoveringMode() == pi2.isHoveringMode());
-    result.d->isHoveringMode = pi1.isHoveringMode();
-    result.d->levelOfDetail = pi1.d->levelOfDetail;
-    result.d->randomSource = pi1.d->randomSource;
-    result.d->canvasRotation = pi2.canvasRotation();
-    result.d->canvasMirroredH = pi2.canvasMirroredH();
+        if (pi1.rotation() != pi2.rotation()) {
+            qreal a1 = kisDegreesToRadians(pi1.rotation());
+            qreal a2 = kisDegreesToRadians(pi2.rotation());
+            qreal distance = shortestAngularDistance(a2, a1);
 
-    return result;
+            rotation = kisRadiansToDegrees(incrementInDirection(a1, t * distance, a2));
+        }
+
+        qreal tangentialPressure = (1 - t) * pi1.tangentialPressure() + t * pi2.tangentialPressure();
+        qreal perspective = (1 - t) * pi1.perspective() + t * pi2.perspective();
+        qreal time = mixTime ? ((1 - t) * pi1.currentTime() + t * pi2.currentTime()) : pi2.currentTime();
+        qreal speed = (1 - t) * pi1.drawingSpeed() + t * pi2.drawingSpeed();
+
+        KisPaintInformation result(p, pressure, xTilt, yTilt, rotation, tangentialPressure, perspective, time, speed);
+        KIS_ASSERT_RECOVER_NOOP(pi1.isHoveringMode() == pi2.isHoveringMode());
+        result.d->isHoveringMode = pi1.isHoveringMode();
+        result.d->levelOfDetail = pi1.d->levelOfDetail;
+        result.d->randomSource = pi1.d->randomSource;
+        result.d->canvasRotation = pi2.canvasRotation();
+        result.d->canvasMirroredH = pi2.canvasMirroredH();
+
+        return result;
+    }
 }
 
 qreal KisPaintInformation::tiltDirection(const KisPaintInformation& info, bool normalize)
 {
     qreal xTilt = info.xTilt();
     qreal yTilt = info.yTilt();
     // radians -PI, PI
     qreal tiltDirection = atan2(-xTilt, yTilt);
     // if normalize is true map to 0.0..1.0
     return normalize ? (tiltDirection / (2 * M_PI) + 0.5) : tiltDirection;
 }
 
 qreal KisPaintInformation::tiltElevation(const KisPaintInformation& info, qreal maxTiltX, qreal maxTiltY, bool normalize)
 {
     qreal xTilt = qBound(qreal(-1.0), info.xTilt() / maxTiltX , qreal(1.0));
     qreal yTilt = qBound(qreal(-1.0), info.yTilt() / maxTiltY , qreal(1.0));
 
     qreal e;
     if (fabs(xTilt) > fabs(yTilt)) {
         e = sqrt(qreal(1.0) + yTilt * yTilt);
     } else {
         e = sqrt(qreal(1.0) + xTilt * xTilt);
     }
 
     qreal cosAlpha    = sqrt(xTilt * xTilt + yTilt * yTilt) / e;
     qreal tiltElevation = acos(cosAlpha); // in radians in [0, 0.5 * PI]
 
     // mapping to 0.0..1.0 if normalize is true
     return normalize ? (tiltElevation / (M_PI * qreal(0.5))) : tiltElevation;
 }
 
diff --git a/libs/image/brushengine/kis_paint_information.h b/libs/image/brushengine/kis_paint_information.h
index 06073bbedc..0a08a9cbb7 100644
--- a/libs/image/brushengine/kis_paint_information.h
+++ b/libs/image/brushengine/kis_paint_information.h
@@ -1,271 +1,282 @@
 /*
  *  Copyright (c) 2004 Cyrille Berger <cberger@cberger.net>
  *  Copyright (c) 2006 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef _KIS_PAINT_INFORMATION_
 #define _KIS_PAINT_INFORMATION_
 
 #include <kis_debug.h>
 #include <QTime>
 
 #include "kis_global.h"
 #include "kritaimage_export.h"
 #include <kis_distance_information.h>
 #include "kis_random_source.h"
 
 
 class QDomDocument;
 class QDomElement;
 class KisDistanceInformation;
 
 
 /**
  * KisPaintInformation contains information about the input event that
  * causes the brush action to happen to the brush engine's paint
  * methods.
  *
  * XXX: we directly pass the KoPointerEvent x and y tilt to
  * KisPaintInformation, and their range is -60 to +60!
  *
  * @param pos: the position of the paint event in subpixel accuracy
  * @param pressure: the pressure of the stylus
  * @param xTilt: the angle between the device (a pen, for example) and
  * the perpendicular in the direction of the x axis. Positive values
  * are towards the bottom of the tablet. The angle is within the range
  * 0 to 1
  * @param yTilt: the angle between the device (a pen, for example) and
  * the perpendicular in the direction of the y axis. Positive values
  * are towards the bottom of the tablet. The angle is within the range
  * 0 to .
  * @param movement: current position minus the last position of the call to paintAt
  * @param rotation
  * @param tangentialPressure
  * @param perspective
  **/
 class KRITAIMAGE_EXPORT KisPaintInformation
 {
 public:
     /**
      * Note, that this class is relied on the compiler optimization
      * of the return value. So if it doesn't work for some reason,
      * please implement a proper copy c-tor
      */
     class KRITAIMAGE_EXPORT DistanceInformationRegistrar
     {
     public:
         DistanceInformationRegistrar(KisPaintInformation *_p, KisDistanceInformation *distanceInfo);
         ~DistanceInformationRegistrar();
     private:
         KisPaintInformation *p;
     };
 
 public:
 
     /**
      * Create a new KisPaintInformation object.
      */
     KisPaintInformation(const QPointF & pos,
                         qreal pressure,
                         qreal xTilt,
                         qreal yTilt,
                         qreal rotation,
                         qreal tangentialPressure,
                         qreal perspective,
                         qreal time,
                         qreal speed);
 
     KisPaintInformation(const QPointF & pos,
                         qreal pressure,
                         qreal xTilt,
                         qreal yTilt,
                         qreal rotation);
 
     KisPaintInformation(const QPointF & pos = QPointF(),
                         qreal pressure = PRESSURE_DEFAULT);
 
     KisPaintInformation(const KisPaintInformation& rhs);
 
     void operator=(const KisPaintInformation& rhs);
 
     ~KisPaintInformation();
 
     template <class PaintOp>
     void paintAt(PaintOp &op, KisDistanceInformation *distanceInfo) {
         KisSpacingInformation spacingInfo;
 
         {
             DistanceInformationRegistrar r = registerDistanceInformation(distanceInfo);
             spacingInfo = op.paintAt(*this);
         }
 
         distanceInfo->registerPaintedDab(*this, spacingInfo);
     }
 
     const QPointF& pos() const;
     void setPos(const QPointF& p);
 
     /// The pressure of the value (from 0.0 to 1.0)
     qreal pressure() const;
 
     /// Set the pressure
     void setPressure(qreal p);
 
     /// The tilt of the pen on the horizontal axis (from 0.0 to 1.0)
     qreal xTilt() const;
 
     /// The tilt of the pen on the vertical axis (from 0.0 to 1.0)
     qreal yTilt() const;
 
     /// XXX !!! :-| Please add dox!
     void overrideDrawingAngle(qreal angle);
 
     /// XXX !!! :-| Please add dox!
     qreal drawingAngleSafe(const KisDistanceInformation &distance) const;
 
-    /// XXX !!! :-| Please add dox!
+    /**
+     * Causes the specified distance information to be temporarily registered with this
+     * KisPaintInformation object, so that the KisPaintInformation can compute certain values that
+     * may be needed at painting time, such as the drawing direction. When the returned object is
+     * destroyed, the KisDistanceInformation will be unregistered. At most one
+     * KisDistanceInformation can be registered with a given KisPaintInformation at a time.
+     */
     DistanceInformationRegistrar registerDistanceInformation(KisDistanceInformation *distance);
 
     /**
      * Current brush direction computed from the cursor movement
      *
      * WARNING: this method is available *only* inside paintAt() call,
      * that is when the distance information is registered.
      */
     qreal drawingAngle() const;
 
     /**
      * Lock current drawing angle for the rest of the stroke. If some
      * value has already been locked, \p alpha shown the coefficient
      * with which the new velue should be blended in.
      */
     void lockCurrentDrawingAngle(qreal alpha) const;
 
     /**
      * Current brush direction vector computed from the cursor movement
      *
      * WARNING: this method is available *only* inside paintAt() call,
      * that is when the distance information is registered.
      */
     QPointF drawingDirectionVector() const;
 
     /**
      * Current brush speed computed from the cursor movement
      *
      * WARNING: this method is available *only* inside paintAt() call,
      * that is when the distance information is registered.
      */
     qreal drawingSpeed() const;
 
     /**
      * Current distance from the previous dab
      *
      * WARNING: this method is available *only* inside paintAt() call,
      * that is when the distance information is registered.
      */
     qreal drawingDistance() const;
 
     /// rotation as given by the tablet event
     qreal rotation() const;
 
     /// tangential pressure (i.e., rate for an airbrush device)
     qreal tangentialPressure() const;
 
     /// reciprocal of distance on the perspective grid
     qreal perspective() const;
 
     /// Number of ms since the beginning of the stroke
     qreal currentTime() const;
 
     // random source for generating in-stroke effects
     KisRandomSourceSP randomSource() const;
 
     // the stroke should initialize random source of all the used
     // paint info objects, otherwise it shows a warning
     void setRandomSource(KisRandomSourceSP value);
 
     // set level of detail which info object has been generated for
     void setLevelOfDetail(int levelOfDetail) const;
 
     /**
      * The paint information may be generated not only during real
      * stroke when the actual painting is happening, but also when the
      * cursor is hovering the canvas. In this mode some of the sensors
      * work a bit differently. The most outstanding example is Fuzzy
      * sensor, which returns unit value in this mode, otherwise it is
      * too irritating for a user.
      *
      * This value is true only for paint information objects created with
      * createHoveringModeInfo() constructor.
      *
      * \see createHoveringModeInfo()
      */
     bool isHoveringMode() const;
 
     /**
      * Create a fake info object with isHoveringMode() property set to
      * true.
      *
      * \see isHoveringMode()
      */
     static KisPaintInformation createHoveringModeInfo(const QPointF &pos,
             qreal pressure = PRESSURE_DEFAULT,
             qreal xTilt = 0.0, qreal yTilt = 0.0,
             qreal rotation = 0.0,
             qreal tangentialPressure = 0.0,
             qreal perspective = 1.0,
 	        qreal speed = 0.0,
             int canvasrotation = 0,
             bool canvasMirroredH = false);
     /**
      *Returns the canvas rotation if that has been given to the kispaintinformation.
      */
     int canvasRotation() const;
     /**
      *set the canvas rotation.
      */
     void setCanvasRotation(int rotation);
     
     /*
      *Whether the canvas is mirrored for the paint-operation.
      */
     bool canvasMirroredH() const;
     
     /*
      *Set whether the canvas is mirrored for the paint-operation.
      */
     void setCanvasHorizontalMirrorState(bool mir);
     
     void toXML(QDomDocument&, QDomElement&) const;
 
     static KisPaintInformation fromXML(const QDomElement&);
 
     /// (1-t) * p1 + t * p2
     static KisPaintInformation mixOnlyPosition(qreal t, const KisPaintInformation& mixedPi, const KisPaintInformation& basePi);
     static KisPaintInformation mix(const QPointF& p, qreal t, const KisPaintInformation& p1, const KisPaintInformation& p2);
     static KisPaintInformation mix(qreal t, const KisPaintInformation& pi1, const KisPaintInformation& pi2);
+    static KisPaintInformation mixWithoutTime(const QPointF &p, qreal t, const KisPaintInformation &p1, const KisPaintInformation &p2);
+    static KisPaintInformation mixWithoutTime(qreal t, const KisPaintInformation &pi1, const KisPaintInformation &pi2);
     static qreal tiltDirection(const KisPaintInformation& info, bool normalize = true);
     static qreal tiltElevation(const KisPaintInformation& info, qreal maxTiltX = 60.0, qreal maxTiltY = 60.0, bool normalize = true);
 
+private:
+    static KisPaintInformation mixImpl(const QPointF &p, qreal t, const KisPaintInformation &p1, const KisPaintInformation &p2, bool posOnly, bool mixTime);
+
 private:
     struct Private;
     Private* const d;
 };
 
 KRITAIMAGE_EXPORT QDebug operator<<(QDebug debug, const KisPaintInformation& info);
 
 
 #endif
diff --git a/libs/image/brushengine/kis_paintop_settings.cpp b/libs/image/brushengine/kis_paintop_settings.cpp
index 8cdb613799..be3f1678e7 100644
--- a/libs/image/brushengine/kis_paintop_settings.cpp
+++ b/libs/image/brushengine/kis_paintop_settings.cpp
@@ -1,434 +1,450 @@
 /*
  *  Copyright (c) 2007 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2008 Lukáš Tvrdý <lukast.dev@gmail.com>
  *  Copyright (c) 2014 Mohit Goyal <mohit.bits2011@gmail.com>
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include <brushengine/kis_paintop_settings.h>
 
 #include <QImage>
 #include <QColor>
 #include <QPointer>
 
 #include <KoPointerEvent.h>
 #include <KoColor.h>
 #include <KoCompositeOpRegistry.h>
 #include <KoViewConverter.h>
 
 #include "kis_paint_layer.h"
 #include "kis_image.h"
 #include "kis_painter.h"
 #include "kis_paint_device.h"
 #include "kis_paintop_registry.h"
 #include <brushengine/kis_paint_information.h>
 #include "kis_paintop_config_widget.h"
 #include <brushengine/kis_paintop_preset.h>
 #include "kis_paintop_settings_update_proxy.h"
 #include <time.h>
-#include<kis_types.h>
+#include <kis_types.h>
 #include <kis_signals_blocker.h>
 
 #include <brushengine/kis_locked_properties_server.h>
 #include <brushengine/kis_locked_properties_proxy.h>
 
 
 struct Q_DECL_HIDDEN KisPaintOpSettings::Private {
     Private()
         : disableDirtyNotifications(false)
     {}
 
     QPointer<KisPaintOpConfigWidget> settingsWidget;
     QString modelName;
     KisPaintOpPresetWSP preset;
     QList<KisUniformPaintOpPropertyWSP> uniformProperties;
 
     bool disableDirtyNotifications;
 
     class DirtyNotificationsLocker {
     public:
         DirtyNotificationsLocker(KisPaintOpSettings::Private *d)
             : m_d(d),
               m_oldNotificationsState(d->disableDirtyNotifications)
         {
             m_d->disableDirtyNotifications = true;
         }
 
         ~DirtyNotificationsLocker() {
             m_d->disableDirtyNotifications = m_oldNotificationsState;
         }
 
     private:
         KisPaintOpSettings::Private *m_d;
         bool m_oldNotificationsState;
         Q_DISABLE_COPY(DirtyNotificationsLocker)
     };
 
     KisPaintopSettingsUpdateProxy* updateProxyNoCreate() const {
         auto presetSP = preset.toStrongRef();
         return presetSP ? presetSP->updateProxyNoCreate() : 0;
     }
 
     KisPaintopSettingsUpdateProxy* updateProxyCreate() const {
         auto presetSP = preset.toStrongRef();
         return presetSP ? presetSP->updateProxy() : 0;
     }
 };
 
 
 KisPaintOpSettings::KisPaintOpSettings()
     : d(new Private)
 {
     d->preset = 0;
 }
 
 KisPaintOpSettings::~KisPaintOpSettings()
 {
 }
 
 KisPaintOpSettings::KisPaintOpSettings(const KisPaintOpSettings &rhs)
     : KisPropertiesConfiguration(rhs)
     , d(new Private)
 {
     d->settingsWidget = 0;
     d->preset = rhs.preset();
     d->modelName = rhs.modelName();
 }
 
 void KisPaintOpSettings::setOptionsWidget(KisPaintOpConfigWidget* widget)
 {
     d->settingsWidget = widget;
 }
 void KisPaintOpSettings::setPreset(KisPaintOpPresetWSP preset)
 {
     d->preset = preset;
 }
 KisPaintOpPresetWSP KisPaintOpSettings::preset() const
 {
     return d->preset;
 }
 
 bool KisPaintOpSettings::mousePressEvent(const KisPaintInformation &paintInformation, Qt::KeyboardModifiers modifiers, KisNodeWSP currentNode)
 {
     Q_UNUSED(modifiers);
     Q_UNUSED(currentNode);
     setRandomOffset(paintInformation);
     return true; // ignore the event by default
 }
 
 void KisPaintOpSettings::setRandomOffset(const KisPaintInformation &paintInformation)
 {
     if (getBool("Texture/Pattern/Enabled")) {
         if (getBool("Texture/Pattern/isRandomOffsetX")) {
             setProperty("Texture/Pattern/OffsetX",
                         paintInformation.randomSource()->generate(0, KisPropertiesConfiguration::getInt("Texture/Pattern/MaximumOffsetX")));
         }
         if (getBool("Texture/Pattern/isRandomOffsetY")) {
             setProperty("Texture/Pattern/OffsetY",
                         paintInformation.randomSource()->generate(0, KisPropertiesConfiguration::getInt("Texture/Pattern/MaximumOffsetY")));
 
         }
     }
 
 }
 
 
 KisPaintOpSettingsSP KisPaintOpSettings::clone() const
 {
     QString paintopID = getString("paintop");
     if (paintopID.isEmpty())
         return 0;
 
     KisPaintOpSettingsSP settings = KisPaintOpRegistry::instance()->settings(KoID(paintopID, ""));
     QMapIterator<QString, QVariant> i(getProperties());
     while (i.hasNext()) {
         i.next();
         settings->setProperty(i.key(), QVariant(i.value()));
     }
     settings->setPreset(this->preset());
     return settings;
 }
 
 void KisPaintOpSettings::activate()
 {
 }
 
 void KisPaintOpSettings::setPaintOpOpacity(qreal value)
 {
     KisLockedPropertiesProxySP proxy(
                 KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(this));
 
     proxy->setProperty("OpacityValue", value);
 }
 
 void KisPaintOpSettings::setPaintOpFlow(qreal value)
 {
     KisLockedPropertiesProxySP proxy(
                 KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(this));
 
     proxy->setProperty("FlowValue", value);
 }
 
 void KisPaintOpSettings::setPaintOpCompositeOp(const QString &value)
 {
     KisLockedPropertiesProxySP proxy(
                 KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(this));
 
     proxy->setProperty("CompositeOp", value);
 }
 
 qreal KisPaintOpSettings::paintOpOpacity()
 {
     KisLockedPropertiesProxySP proxy = KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(this);
 
     return proxy->getDouble("OpacityValue", 1.0);
 }
 
 qreal KisPaintOpSettings::paintOpFlow()
 {
     KisLockedPropertiesProxySP proxy(
                 KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(this));
 
     return proxy->getDouble("FlowValue", 1.0);
 }
 
 QString KisPaintOpSettings::paintOpCompositeOp()
 {
     KisLockedPropertiesProxySP proxy(
                 KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(this));
 
     return proxy->getString("CompositeOp", COMPOSITE_OVER);
 }
 
 void KisPaintOpSettings::setEraserMode(bool value)
 {
     KisLockedPropertiesProxySP proxy(
                 KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(this));
 
     proxy->setProperty("EraserMode", value);
 }
 
 bool KisPaintOpSettings::eraserMode()
 {
     KisLockedPropertiesProxySP proxy(
                 KisLockedPropertiesServer::instance()->createLockedPropertiesProxy(this));
 
     return proxy->getBool("EraserMode", false);
 }
 
 QString KisPaintOpSettings::effectivePaintOpCompositeOp()
 {
     return !eraserMode() ? paintOpCompositeOp() : COMPOSITE_ERASE;
 }
 
 qreal KisPaintOpSettings::savedEraserSize() const
 {
     return getDouble("SavedEraserSize", 0.0);
 }
 
 void KisPaintOpSettings::setSavedEraserSize(qreal value)
 {
     setProperty("SavedEraserSize", value);
     setPropertyNotSaved("SavedEraserSize");
 }
 
 qreal KisPaintOpSettings::savedBrushSize() const
 {
     return getDouble("SavedBrushSize", 0.0);
 }
 
 void KisPaintOpSettings::setSavedBrushSize(qreal value)
 {
     setProperty("SavedBrushSize", value);
     setPropertyNotSaved("SavedBrushSize");
 }
 
 qreal KisPaintOpSettings::savedEraserOpacity() const
 {
     return getDouble("SavedEraserOpacity", 0.0);
 }
 
 void KisPaintOpSettings::setSavedEraserOpacity(qreal value)
 {
     setProperty("SavedEraserOpacity", value);
     setPropertyNotSaved("SavedEraserOpacity");
 }
 
 qreal KisPaintOpSettings::savedBrushOpacity() const
 {
     return getDouble("SavedBrushOpacity", 0.0);
 }
 
 void KisPaintOpSettings::setSavedBrushOpacity(qreal value)
 {
     setProperty("SavedBrushOpacity", value);
     setPropertyNotSaved("SavedBrushOpacity");
 }
 
 QString KisPaintOpSettings::modelName() const
 {
     return d->modelName;
 }
 
 void KisPaintOpSettings::setModelName(const QString & modelName)
 {
     d->modelName = modelName;
 }
 
 KisPaintOpConfigWidget* KisPaintOpSettings::optionsWidget() const
 {
     if (d->settingsWidget.isNull())
         return 0;
 
     return d->settingsWidget.data();
 }
 
 bool KisPaintOpSettings::isValid() const
 {
     return true;
 }
 
 bool KisPaintOpSettings::isLoadable()
 {
     return isValid();
 }
 
 QString KisPaintOpSettings::indirectPaintingCompositeOp() const
 {
     return COMPOSITE_ALPHA_DARKEN;
 }
 
+bool KisPaintOpSettings::isAirbrushing() const
+{
+    return getBool(AIRBRUSH_ENABLED, false);
+}
+
+qreal KisPaintOpSettings::airbrushInterval() const
+{
+    qreal rate = getDouble(AIRBRUSH_RATE, 1.0);
+    if (rate == 0.0) {
+        return 1000.0;
+    }
+    else {
+        return 1000.0 / rate;
+    }
+}
+
 QPainterPath KisPaintOpSettings::brushOutline(const KisPaintInformation &info, OutlineMode mode)
 {
     QPainterPath path;
     if (mode == CursorIsOutline || mode == CursorIsCircleOutline || mode == CursorTiltOutline) {
         path = ellipseOutline(10, 10, 1.0, 0);
 
         if (mode == CursorTiltOutline) {
             path.addPath(makeTiltIndicator(info, QPointF(0.0, 0.0), 0.0, 2.0));
         }
 
         path.translate(info.pos());
     }
 
     return path;
 }
 
 QPainterPath KisPaintOpSettings::ellipseOutline(qreal width, qreal height, qreal scale, qreal rotation)
 {
     QPainterPath path;
     QRectF ellipse(0, 0, width * scale, height * scale);
     ellipse.translate(-ellipse.center());
     path.addEllipse(ellipse);
 
     QTransform m;
     m.reset();
     m.rotate(rotation);
     path = m.map(path);
     return path;
 }
 
 QPainterPath KisPaintOpSettings::makeTiltIndicator(KisPaintInformation const& info,
                                                    QPointF const& start, qreal maxLength, qreal angle)
 {
     if (maxLength == 0.0) maxLength = 50.0;
     maxLength = qMax(maxLength, 50.0);
     qreal const length = maxLength * (1 - info.tiltElevation(info, 60.0, 60.0, true));
     qreal const baseAngle = 360.0 - fmod(KisPaintInformation::tiltDirection(info, true) * 360.0 + 270.0, 360.0);
 
     QLineF guideLine = QLineF::fromPolar(length, baseAngle + angle);
     guideLine.translate(start);
     QPainterPath ret;
     ret.moveTo(guideLine.p1());
     ret.lineTo(guideLine.p2());
     guideLine.setAngle(baseAngle - angle);
     ret.lineTo(guideLine.p2());
     ret.lineTo(guideLine.p1());
     return ret;
 }
 
 void KisPaintOpSettings::setCanvasRotation(qreal angle)
 {
     Private::DirtyNotificationsLocker locker(d.data());
 
     setProperty("runtimeCanvasRotation", angle);
     setPropertyNotSaved("runtimeCanvasRotation");
 }
 
 void KisPaintOpSettings::setCanvasMirroring(bool xAxisMirrored, bool yAxisMirrored)
 {
     Private::DirtyNotificationsLocker locker(d.data());
 
     setProperty("runtimeCanvasMirroredX", xAxisMirrored);
     setPropertyNotSaved("runtimeCanvasMirroredX");
 
     setProperty("runtimeCanvasMirroredY", yAxisMirrored);
     setPropertyNotSaved("runtimeCanvasMirroredY");
 }
 
 void KisPaintOpSettings::setProperty(const QString & name, const QVariant & value)
 {
     if (value != KisPropertiesConfiguration::getProperty(name) &&
             !d->disableDirtyNotifications) {
         KisPaintOpPresetSP presetSP = preset().toStrongRef();
         if (presetSP) {
             presetSP->setPresetDirty(true);
         }
     }
 
     KisPropertiesConfiguration::setProperty(name, value);
     onPropertyChanged();
 }
 
 
 void KisPaintOpSettings::onPropertyChanged()
 {
     KisPaintopSettingsUpdateProxy *proxy = d->updateProxyNoCreate();
 
     if (proxy) {
         proxy->notifySettingsChanged();
     }
 }
 
 bool KisPaintOpSettings::isLodUserAllowed(const KisPropertiesConfigurationSP config)
 {
     return config->getBool("lodUserAllowed", true);
 }
 
 void KisPaintOpSettings::setLodUserAllowed(KisPropertiesConfigurationSP config, bool value)
 {
     config->setProperty("lodUserAllowed", value);
 }
 
 #include "kis_standard_uniform_properties_factory.h"
 
 QList<KisUniformPaintOpPropertySP> KisPaintOpSettings::uniformProperties(KisPaintOpSettingsSP settings)
 {
     QList<KisUniformPaintOpPropertySP> props =
             listWeakToStrong(d->uniformProperties);
 
 
     if (props.isEmpty()) {
         using namespace KisStandardUniformPropertiesFactory;
 
         props.append(createProperty(opacity, settings, d->updateProxyCreate()));
         props.append(createProperty(size, settings, d->updateProxyCreate()));
         props.append(createProperty(flow, settings, d->updateProxyCreate()));
 
         d->uniformProperties = listStrongToWeak(props);
     }
 
     return props;
 }
diff --git a/libs/image/brushengine/kis_paintop_settings.h b/libs/image/brushengine/kis_paintop_settings.h
index 1be1e04447..1d9ac1a280 100644
--- a/libs/image/brushengine/kis_paintop_settings.h
+++ b/libs/image/brushengine/kis_paintop_settings.h
@@ -1,282 +1,303 @@
 /*
  *  Copyright (c) 2007 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_PAINTOP_SETTINGS_H_
 #define KIS_PAINTOP_SETTINGS_H_
 
 #include "kis_types.h"
 #include "kritaimage_export.h"
 
 #include <QImage>
 #include <QScopedPointer>
 
 #include "kis_properties_configuration.h"
 #include <brushengine/kis_paint_information.h>
 #include <brushengine/kis_uniform_paintop_property.h>
 
 
 
 class KisPaintOpConfigWidget;
 class KisPaintopSettingsUpdateProxy;
 
+/**
+ * Configuration property used to control whether airbrushing is enabled.
+ */
+const QString AIRBRUSH_ENABLED = "PaintOpSettings/isAirbrushing";
+
+/**
+ * Configuration property used to control airbrushing rate. The value should be in dabs per second.
+ */
+const QString AIRBRUSH_RATE = "PaintOpSettings/rate";
+
+/**
+ * Configuration property used to control whether airbrushing is configured to ignore distance-based
+ * spacing.
+ */
+const QString AIRBRUSH_IGNORE_SPACING = "PaintOpSettings/ignoreSpacing";
+
 /**
  * This class is used to cache the settings for a paintop
  * between two creations. There is one KisPaintOpSettings per input device (mouse, tablet,
  * etc...).
  *
  * The settings may be stored in a preset or a recorded brush stroke. Note that if your
  * paintop's settings subclass has data that is not stored as a property, that data is not
  * saved and restored.
  *
  * The object also contains a pointer to its parent KisPaintOpPreset object.This is to control the DirtyPreset
  * property of KisPaintOpPreset. Whenever the settings are changed/modified from the original -- the preset is
  * set to dirty.
  */
 class KRITAIMAGE_EXPORT KisPaintOpSettings : public KisPropertiesConfiguration
 {
 
 public:
 
     KisPaintOpSettings();
     ~KisPaintOpSettings() override;
     KisPaintOpSettings(const KisPaintOpSettings &rhs);
 
     /**
      *
      */
     virtual void setOptionsWidget(KisPaintOpConfigWidget* widget);
 
     /**
      * This function is called by a tool when the mouse is pressed. It's useful if
      * the paintop needs mouse interaction for instance in the case of the clone op.
      * If the tool is supposed to ignore the event, the paint op should return false
      * and if the tool is supposed to use the event, return true.
      */
     virtual bool mousePressEvent(const KisPaintInformation &paintInformation, Qt::KeyboardModifiers modifiers, KisNodeWSP currentNode);
 
     /**
      * Clone the current settings object. Override this if your settings instance doesn't
      * store everything as properties.
      */
     virtual KisPaintOpSettingsSP clone() const;
 
     /**
      * @return the node the paintop is working on.
      */
     KisNodeSP node() const;
 
     /**
      * Call this function when the paint op is selected or the tool is activated
      */
     virtual void activate();
 
     /**
      * XXX: Remove this after 2.0, when the paint operation (incremental/non incremental) will
      *      be completely handled in the paintop, not in the tool. This is a filthy hack to move
      *      the option to the right place, at least.
      * @return true if we paint incrementally, false if we paint like Photoshop. By default, paintops
      *      do not support non-incremental.
      */
     virtual bool paintIncremental() {
         return true;
     }
 
     /**
      * @return the composite op it to which the indirect painting device
      * should be initialized to. This is used by clone op to reset
      * the composite op to COMPOSITE_COPY
      */
     virtual QString indirectPaintingCompositeOp() const;
 
     /**
-     * Whether this paintop wants to deposit paint even when not moving, i.e. the
-     * tool needs to activate its timer.
+     * Whether this paintop wants to deposit paint even when not moving, i.e. the tool needs to
+     * activate its timer. If this is true, painting updates need to be generated at regular
+     * intervals even in the absence of input device events, e.g. when the cursor is not moving.
+     *
+     * The default implementation checks the property AIRBRUSH_ENABLED, defaulting to false if the
+     * property is not found. This should be suitable for most paintops.
      */
-    virtual bool isAirbrushing() const {
-        return false;
-    }
+    virtual bool isAirbrushing() const;
 
     /**
-    * If this paintop deposit the paint even when not moving, the tool needs to know the rate of it in miliseconds
-    */
-    virtual int rate() const {
-        return 100;
-    }
+     * Indicates the minimum time interval that might be needed between airbrush dabs, in
+     * milliseconds. A lower value means painting updates need to happen more frequently. This value
+     * should be ignored if isAirbrushing() is false.
+     *
+     * The default implementation uses the property AIRBRUSH_RATE, defaulting to an interval of
+     * one second if the property is not found. This should be suitable for most paintops.
+     */
+    virtual qreal airbrushInterval() const;
 
     /**
      * This enum defines the current mode for painting an outline.
      */
     enum OutlineMode {
         CursorIsOutline = 1, ///< When this mode is set, an outline is painted around the cursor
         CursorIsCircleOutline,
         CursorNoOutline,
         CursorTiltOutline,
         CursorColorOutline
     };
 
     /**
      * Returns the brush outline in pixel coordinates. Tool is responsible for conversion into view coordinates.
      * Outline mode has to be passed to the paintop which builds the outline as some paintops have to paint outline
      * always like clone paintop indicating the duplicate position
      */
     virtual QPainterPath brushOutline(const KisPaintInformation &info, OutlineMode mode);
 
     /**
     * Helpers for drawing the brush outline
     */
     static QPainterPath ellipseOutline(qreal width, qreal height, qreal scale, qreal rotation);
 
     /**
      * Helper for drawing a triangle representing the tilt of the stylus.
      *
      * @param start is the offset from the brush's outline's bounding box
      * @param lengthScale is used for deciding the size of the triangle.
      * Brush diameter or width are common choices for this.
      * @param angle is the angle between the two sides of the triangle.
      */
     static QPainterPath makeTiltIndicator(KisPaintInformation const& info,
         QPointF const& start, qreal lengthScale, qreal angle);
 
     /**
      * Set paintop opacity directly in the properties
      */
     void setPaintOpOpacity(qreal value);
 
     /**
      * Set paintop flow directly in the properties
      */
     void setPaintOpFlow(qreal value);
 
     /**
      * Set paintop composite mode directly in the properties
      */
     void setPaintOpCompositeOp(const QString &value);
 
     /**
      * @return opacity saved in the properties
      */
     qreal paintOpOpacity();
 
     /**
      * @return flow saved in the properties
      */
     qreal paintOpFlow();
 
     /**
      * @return composite mode saved in the properties
      */
     QString paintOpCompositeOp();
 
     /**
      * Set paintop size directly in the properties
      */
     virtual void setPaintOpSize(qreal value) = 0;
 
     /**
      * @return size saved in the properties
      */
     virtual qreal paintOpSize() const = 0;
 
     void setEraserMode(bool value);
     bool eraserMode();
 
     qreal savedEraserSize() const;
     void setSavedEraserSize(qreal value);
     qreal savedBrushSize() const;
     void setSavedBrushSize(qreal value);
 
     qreal savedEraserOpacity() const;
     void setSavedEraserOpacity(qreal value);
     qreal savedBrushOpacity() const;
     void setSavedBrushOpacity(qreal value);
 
     QString effectivePaintOpCompositeOp();
 
     void setPreset(KisPaintOpPresetWSP preset);
 
     KisPaintOpPresetWSP preset() const;
 
     /**
      * @return filename of the 3D brush model, empty if no brush is set
      */
     virtual QString modelName() const;
 
     /**
     * Set filename of 3D brush model. By default no brush is set
     */
     void setModelName(const QString & modelName);
 
     /// Check if the settings are valid, setting might be invalid through missing brushes etc
     /// Overwrite if the settings of a paintop can be invalid
     /// @return state of the settings, default implementation is true
     virtual bool isValid() const;
 
     /// Check if the settings are loadable, that might the case if we can fallback to something
     /// Overwrite if the settings can do some kind of fallback
     /// @return loadable state of the settings, by default implementation return the same as isValid()
     virtual bool isLoadable();
 
     /**
      * These methods are populating properties with runtime
      * information about canvas rotation/mirroring. This information
      * is set directly by KisToolFreehand. Later the data is accessed
      * by the pressure options to make a final decision.
      */
     void setCanvasRotation(qreal angle);
     void setCanvasMirroring(bool xAxisMirrored, bool yAxisMirrored);
 
     /**
      * Overrides the method in KisPropertiesCofiguration to allow
      * onPropertyChanged() callback
      */
     void setProperty(const QString & name, const QVariant & value) override;
 
     virtual QList<KisUniformPaintOpPropertySP> uniformProperties(KisPaintOpSettingsSP settings);
 
     static bool isLodUserAllowed(const KisPropertiesConfigurationSP config);
     static void setLodUserAllowed(KisPropertiesConfigurationSP config, bool value);
 
     /**
     * @return the option widget of the paintop (can be 0 is no option widgets is set)
     */
     KisPaintOpConfigWidget* optionsWidget() const;
 
 
     /**
      * This function is called to set random offsets to the brush whenever the mouse is clicked. It is
      * specific to when the pattern option is set.
      *
      */
     virtual void setRandomOffset(const KisPaintInformation &paintInformation);
 
 protected:
 
     /**
      * The callback is called every time when a property changes
      */
     virtual void onPropertyChanged();
 
 private:
 
 
 
     struct Private;
     const QScopedPointer<Private> d;
 };
 
 #endif
diff --git a/libs/image/brushengine/kis_paintop_utils.h b/libs/image/brushengine/kis_paintop_utils.h
index c8899d7879..58d5d1ba6e 100644
--- a/libs/image/brushengine/kis_paintop_utils.h
+++ b/libs/image/brushengine/kis_paintop_utils.h
@@ -1,194 +1,198 @@
 /*
  *  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;
-    QPointF pt = pi1.pos();
     qreal t = 0.0;
 
-    while ((t = currentDistance->getNextPointPosition(pt, end)) >= 0.0) {
-        pt = pt + t * (end - pt);
-        pi = KisPaintInformation::mix(pt, t, pi, pi2);
+    while ((t = currentDistance->getNextPointPosition(pi.pos(), end, pi.currentTime(), endTime)) >= 0.0) {
+        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,
+                                       qreal rateExtraScale,
+                                       bool distanceSpacingEnabled,
                                        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;
 
-    return KisSpacingInformation(spacing, rotation, axesFlipped);
+    return KisSpacingInformation(distanceSpacingEnabled, spacing, rotation, axesFlipped,
+                                 timedSpacingEnabled, timedSpacingInterval / rateExtraScale);
 }
 
 }
 
 #endif /* __KIS_PAINTOP_UTILS_H */
diff --git a/libs/image/kis_distance_information.cpp b/libs/image/kis_distance_information.cpp
index ed160596d6..8e167627a7 100644
--- a/libs/image/kis_distance_information.cpp
+++ b/libs/image/kis_distance_information.cpp
@@ -1,271 +1,400 @@
 /*
  *  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"
 
+const qreal MIN_DISTANCE_SPACING = 0.5;
+
+// Smallest allowed interval when timed spacing is enabled, in milliseconds.
+const qreal MIN_TIMED_INTERVAL = 0.5;
+
+// Largest allowed interval when timed spacing is enabled, in milliseconds.
+const qreal MAX_TIMED_INTERVAL = 1000.0;
 
 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) {}
 
-    QPointF distance;
+    QPointF accumDistance;
+    qreal accumTime;
     KisSpacingInformation spacing;
+
     QPointF lastPosition;
     qreal lastTime;
+    qreal lastAngle;
     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)
+                                               qreal lastTime,
+                                               qreal lastAngle)
     : m_d(new Private)
 {
     m_d->lastPosition = lastPosition;
     m_d->lastTime = lastTime;
+    m_d->lastAngle = lastAngle;
 
     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)
+void KisDistanceInformation::overrideLastValues(const QPointF &lastPosition, qreal lastTime,
+                                                qreal lastAngle)
 {
     m_d->lastPosition = lastPosition;
     m_d->lastTime = lastTime;
+    m_d->lastAngle = lastAngle;
 
     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->lastAngle = nextDrawingAngle(info.pos());
     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)
+                                                   const QPointF &end,
+                                                   qreal startTime,
+                                                   qreal endTime)
 {
-    return m_d->spacing.isIsotropic() ?
-        getNextPointPositionIsotropic(start, end) :
-        getNextPointPositionAnisotropic(start, end);
+    // Compute interpolation factor based on distance.
+    qreal distanceFactor = -1.0;
+    if (m_d->spacing.isDistanceSpacingEnabled()) {
+        distanceFactor = m_d->spacing.isIsotropic() ?
+            getNextPointPositionIsotropic(start, end) :
+            getNextPointPositionAnisotropic(start, end);
+    }
+
+    // Compute interpolation factor based on time.
+    qreal timeFactor = -1.0;
+    if (m_d->spacing.isTimedSpacingEnabled()) {
+        timeFactor = getNextPointPositionTimed(startTime, endTime);
+    }
+
+    // Return the distance-based or time-based factor, whichever is smallest.
+    if (distanceFactor < 0.0) {
+        return timeFactor;
+    } else if (timeFactor < 0.0) {
+        return distanceFactor;
+    } else {
+        return qMin(distanceFactor, timeFactor);
+    }
 }
 
 qreal KisDistanceInformation::getNextPointPositionIsotropic(const QPointF &start,
                                                             const QPointF &end)
 {
-    qreal distance = m_d->distance.x();
-    qreal spacing = qMax(qreal(0.5), m_d->spacing.spacing().x());
+    qreal distance = m_d->accumDistance.x();
+    qreal spacing = qMax(MIN_DISTANCE_SPACING, m_d->spacing.distanceSpacing().x());
 
     if (start == end) {
         return -1;
     }
 
     qreal dragVecLength = QVector2D(end - start).length();
     qreal nextPointDistance = spacing - distance;
 
     qreal t;
 
     if (nextPointDistance <= dragVecLength) {
         t = nextPointDistance / dragVecLength;
-        m_d->distance = QPointF();
+        resetAccumulators();
     } else {
         t = -1;
-        m_d->distance.rx() += dragVecLength;
+        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 a_rev = 1.0 / qMax(MIN_DISTANCE_SPACING, m_d->spacing.distanceSpacing().x());
+    qreal b_rev = 1.0 / qMax(MIN_DISTANCE_SPACING, m_d->spacing.distanceSpacing().y());
 
-    qreal x = m_d->distance.x();
-    qreal y = m_d->distance.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;
-            m_d->distance = QPointF();
+            resetAccumulators();
         } else {
-            m_d->distance += KisAlgebra2D::abs(diff);
+            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, do not interpolate.
+    if (!(startTime < endTime)) {
+        return -1.0;
+    }
+
+    qreal timedSpacingInterval = qBound(MIN_TIMED_INTERVAL, m_d->spacing.timedSpacingInterval(),
+                                        MAX_TIMED_INTERVAL);
+    qreal nextPointInterval = timedSpacingInterval - m_d->accumTime;
+    
+    // Note: nextPointInterval SHOULD always be positive, but I wasn't sure if floating point
+    // roundoff error might make it nonpositive in some cases, so I included this check.
+    if (nextPointInterval <= 0.0) {
+        resetAccumulators();
+        return 0.0;
+    }
+    else if (nextPointInterval <= endTime - startTime) {
+        resetAccumulators();
+        return nextPointInterval / (endTime - startTime);
+    }
+    else {
+        m_d->accumTime += endTime - startTime;
+        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::nextDrawingAngle(const QPointF &nextPos,
+                                               bool considerLockedAngle) const
+{
+    if (!m_d->lastDabInfoValid) {
+        warnKrita << "KisDistanceInformation::nextDrawingAngle()" << "No last dab data";
+        return 0.0;
+    }
+
+    // Compute the drawing angle. If the new position is the same as the previous position, an angle
+    // can't be computed. In that case, act as if the angle is the same as in the previous dab.
+    return drawingAngleImpl(m_d->lastPosition, nextPos, considerLockedAngle, m_d->lastAngle);
+}
+
+QPointF KisDistanceInformation::nextDrawingDirectionVector(const QPointF &nextPos,
+                                                           bool considerLockedAngle) const
+{
+    if (!m_d->lastDabInfoValid) {
+        warnKrita << "KisDistanceInformation::nextDrawingDirectionVector()" << "No last dab data";
+        return QPointF(1.0, 0.0);
+    }
+
+    // Compute the direction vector. If the new position is the same as the previous position, a
+    // direction can't be computed. In that case, act as if the direction is the same as in the
+    // previous dab.
+    return drawingDirectionVectorImpl(m_d->lastPosition, nextPos, considerLockedAngle,
+                                      m_d->lastAngle);
+}
+
 qreal KisDistanceInformation::scalarDistanceApprox() const
 {
     return m_d->totalDistance;
 }
+
+qreal KisDistanceInformation::drawingAngleImpl(const QPointF &start, const QPointF &end,
+                                               bool considerLockedAngle, qreal defaultAngle) const
+{
+    if (m_d->hasLockedDrawingAngle && considerLockedAngle) {
+        return m_d->lockedDrawingAngle;
+    }
+
+    // If the start and end positions are the same, we can't compute an angle. In that case, use the
+    // provided default.
+    return KisAlgebra2D::directionBetweenPoints(start, end, defaultAngle);
+}
+
+QPointF KisDistanceInformation::drawingDirectionVectorImpl(const QPointF &start, const QPointF &end,
+                                                           bool considerLockedAngle,
+                                                           qreal defaultAngle) const
+{
+    if (m_d->hasLockedDrawingAngle && considerLockedAngle) {
+        return QPointF(cos(m_d->lockedDrawingAngle), sin(m_d->lockedDrawingAngle));
+    }
+
+    // If the start and end positions are the same, we can't compute a drawing direction. In that
+    // case, use the provided default.
+    if (KisAlgebra2D::fuzzyPointCompare(start, end)) {
+        return QPointF(cos(defaultAngle), sin(defaultAngle));
+    }
+
+    const QPointF diff(end - start);
+    return KisAlgebra2D::normalize(diff);
+}
diff --git a/libs/image/kis_distance_information.h b/libs/image/kis_distance_information.h
index 68d196fe57..742ea1d2b0 100644
--- a/libs/image/kis_distance_information.h
+++ b/libs/image/kis_distance_information.h
@@ -1,136 +1,254 @@
 /*
  *  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.
  */
 
 #ifndef _KIS_DISTANCE_INFORMATION_H_
 #define _KIS_DISTANCE_INFORMATION_H_
 
 #include <QPointF>
 #include <QVector2D>
 #include "kritaimage_export.h"
 
 class KisPaintInformation;
 
 
 /**
  * This structure contains information about the desired spacing
  * requested by the paintAt call
  */
 class KisSpacingInformation {
 public:
     explicit KisSpacingInformation()
-        : m_spacing(0.0, 0.0)
+        : m_distanceSpacingEnabled(true)
+        , m_distanceSpacing(0.0, 0.0)
+        , m_timedSpacingEnabled(false)
+        , m_timedSpacingInterval(0.0)
         , m_rotation(0.0)
         , m_coordinateSystemFlipped(false)
     {
     }
 
     explicit KisSpacingInformation(qreal isotropicSpacing)
-        : m_spacing(isotropicSpacing, isotropicSpacing)
+        : m_distanceSpacingEnabled(true)
+        , m_distanceSpacing(isotropicSpacing, isotropicSpacing)
+        , m_timedSpacingEnabled(false)
+        , m_timedSpacingInterval(0.0)
         , m_rotation(0.0)
         , m_coordinateSystemFlipped(false)
     {
     }
 
     explicit KisSpacingInformation(const QPointF &anisotropicSpacing, qreal rotation, bool coordinateSystemFlipped)
-        : m_spacing(anisotropicSpacing)
+        : m_distanceSpacingEnabled(true)
+        , m_distanceSpacing(anisotropicSpacing)
+        , m_timedSpacingEnabled(false)
+        , m_timedSpacingInterval(0.0)
         , m_rotation(rotation)
         , m_coordinateSystemFlipped(coordinateSystemFlipped)
     {
     }
 
-    inline QPointF spacing() const {
-        return m_spacing;
+    explicit KisSpacingInformation(qreal isotropicSpacing,
+                                   qreal timedSpacingInterval)
+        : m_distanceSpacingEnabled(true)
+        , m_distanceSpacing(isotropicSpacing, isotropicSpacing)
+        , m_timedSpacingEnabled(true)
+        , m_timedSpacingInterval(timedSpacingInterval)
+        , m_rotation(0.0)
+        , m_coordinateSystemFlipped(false)
+    {
+    }
+
+    explicit KisSpacingInformation(const QPointF &anisotropicSpacing,
+                                   qreal rotation,
+                                   bool coordinateSystemFlipped,
+                                   qreal timedSpacingInterval)
+        : m_distanceSpacingEnabled(true)
+        , m_distanceSpacing(anisotropicSpacing)
+        , m_timedSpacingEnabled(true)
+        , m_timedSpacingInterval(timedSpacingInterval)
+        , m_rotation(rotation)
+        , m_coordinateSystemFlipped(coordinateSystemFlipped)
+    {
+    }
+
+    explicit KisSpacingInformation(bool distanceSpacingEnabled,
+                                   qreal isotropicSpacing,
+                                   bool timedSpacingEnabled,
+                                   qreal timedSpacingInterval)
+        : m_distanceSpacingEnabled(distanceSpacingEnabled)
+        , m_distanceSpacing(isotropicSpacing, isotropicSpacing)
+        , m_timedSpacingEnabled(timedSpacingEnabled)
+        , m_timedSpacingInterval(timedSpacingInterval)
+        , m_rotation(0.0)
+        , m_coordinateSystemFlipped(false)
+    {
+    }
+
+    explicit KisSpacingInformation(bool distanceSpacingEnabled,
+                                   const QPointF &anisotropicSpacing,
+                                   qreal rotation,
+                                   bool coordinateSystemFlipped,
+                                   bool timedSpacingEnabled,
+                                   qreal timedSpacingInterval)
+        : m_distanceSpacingEnabled(distanceSpacingEnabled)
+        , m_distanceSpacing(anisotropicSpacing)
+        , m_timedSpacingEnabled(timedSpacingEnabled)
+        , m_timedSpacingInterval(timedSpacingInterval)
+        , m_rotation(rotation)
+        , m_coordinateSystemFlipped(coordinateSystemFlipped)
+    {
+    }
+
+    /**
+     * @return True if and only if distance-based spacing is enabled.
+     */
+    inline bool isDistanceSpacingEnabled() const {
+        return m_distanceSpacingEnabled;
+    }
+
+    inline QPointF distanceSpacing() const {
+        return m_distanceSpacing;
+    }
+
+    /**
+     * @return True if and only if time-based spacing is enabled.
+     */
+    inline bool isTimedSpacingEnabled() const {
+        return m_timedSpacingEnabled;
+    }
+
+    /**
+     * @return The desired maximum amount of time between dabs, in milliseconds. Returns a time of
+     * approximately 1 year if time-based spacing is disabled.
+     */
+    inline qreal timedSpacingInterval() const {
+        return isTimedSpacingEnabled() ?
+                    m_timedSpacingInterval :
+                    32000000000.0;
     }
 
     inline bool isIsotropic() const {
-        return m_spacing.x() == m_spacing.y();
+        return m_distanceSpacing.x() == m_distanceSpacing.y();
     }
 
     inline qreal scalarApprox() const {
-        return isIsotropic() ? m_spacing.x() : QVector2D(m_spacing).length();
+        return isIsotropic() ? m_distanceSpacing.x() : QVector2D(m_distanceSpacing).length();
     }
 
     inline qreal rotation() const {
         return m_rotation;
     }
 
     bool coordinateSystemFlipped() const {
         return m_coordinateSystemFlipped;
     }
 
 private:
-    QPointF m_spacing;
+
+    // Distance-based spacing
+    bool m_distanceSpacingEnabled;
+    QPointF m_distanceSpacing;
+
+    // Time-based spacing (interval is in milliseconds)
+    bool m_timedSpacingEnabled;
+    qreal m_timedSpacingInterval;
+
     qreal m_rotation;
     bool m_coordinateSystemFlipped;
 };
 
 /**
  * This structure is used as return value of paintLine to contain
  * information that is needed to be passed for the next call.
  */
 class KRITAIMAGE_EXPORT KisDistanceInformation {
 public:
     KisDistanceInformation();
-    KisDistanceInformation(const QPointF &lastPosition, qreal lastTime);
+    KisDistanceInformation(const QPointF &lastPosition, qreal lastTime, qreal lastAngle);
     KisDistanceInformation(const KisDistanceInformation &rhs);
     KisDistanceInformation(const KisDistanceInformation &rhs, int levelOfDetail);
     KisDistanceInformation& operator=(const KisDistanceInformation &rhs);
 
     ~KisDistanceInformation();
 
     const KisSpacingInformation& currentSpacing() const;
     bool hasLastDabInformation() const;
     QPointF lastPosition() const;
     qreal lastTime() const;
     qreal lastDrawingAngle() const;
 
     bool hasLastPaintInformation() const;
     const KisPaintInformation& lastPaintInformation() const;
 
     void registerPaintedDab(const KisPaintInformation &info,
                             const KisSpacingInformation &spacing);
 
     qreal getNextPointPosition(const QPointF &start,
-                               const QPointF &end);
+                               const QPointF &end,
+                               qreal startTime,
+                               qreal endTime);
 
     /**
      * \return true if at least one dab has been painted with this
      *         distance information
      */
     bool isStarted() const;
 
     bool hasLockedDrawingAngle() const;
     qreal lockedDrawingAngle() const;
     void setLockedDrawingAngle(qreal angle);
 
+    /**
+     * Computes the next drawing angle assuming that the next painting position will be nextPos.
+     * This method should not be called when hasLastDabInformation() is false.
+     */
+    qreal nextDrawingAngle(const QPointF &nextPos, bool considerLockedAngle = true) const;
+
+    /**
+     * Returns a unit vector pointing in the direction that would have been indicated by a call to
+     * nextDrawingAngle. This method should not be called when hasLastDabInformation() is false.
+     */
+    QPointF nextDrawingDirectionVector(const QPointF &nextPos,
+                                       bool considerLockedAngle = true) const;
+
     qreal scalarDistanceApprox() const;
 
-    void overrideLastValues(const QPointF &lastPosition, qreal lastTime);
+    void overrideLastValues(const QPointF &lastPosition, qreal lastTime, qreal lastAngle);
 
 private:
     qreal getNextPointPositionIsotropic(const QPointF &start,
                                         const QPointF &end);
     qreal getNextPointPositionAnisotropic(const QPointF &start,
                                           const QPointF &end);
+    qreal getNextPointPositionTimed(qreal startTime,
+                                    qreal endTime);
+    void resetAccumulators();
+
+    qreal drawingAngleImpl(const QPointF &start, const QPointF &end,
+                           bool considerLockedAngle = true, qreal defaultAngle = 0.0) const;
+    QPointF drawingDirectionVectorImpl(const QPointF &start, const QPointF &end,
+                                       bool considerLockedAngle = true,
+                                       qreal defaultAngle = 0.0) const;
+
 private:
     struct Private;
     Private * const m_d;
 };
 
 #endif
diff --git a/libs/ui/tool/kis_resources_snapshot.cpp b/libs/ui/tool/kis_resources_snapshot.cpp
index 765a0a05f6..971b6d76d5 100644
--- a/libs/ui/tool/kis_resources_snapshot.cpp
+++ b/libs/ui/tool/kis_resources_snapshot.cpp
@@ -1,389 +1,389 @@
 /*
  *  Copyright (c) 2011 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_resources_snapshot.h"
 
 #include <KoColor.h>
 #include <resources/KoAbstractGradient.h>
 #include <KoCompositeOpRegistry.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <brushengine/kis_paintop_settings.h>
 #include <brushengine/kis_paintop_registry.h>
 #include <kis_threaded_text_rendering_workaround.h>
 #include <resources/KoPattern.h>
 #include "kis_canvas_resource_provider.h"
 #include "filter/kis_filter_configuration.h"
 #include "kis_image.h"
 #include "kis_paint_device.h"
 #include "kis_paint_layer.h"
 #include "recorder/kis_recorded_paint_action.h"
 #include "kis_selection.h"
 #include "kis_selection_mask.h"
 #include "kis_algebra_2d.h"
 
 
 struct KisResourcesSnapshot::Private {
     Private()
         : currentPattern(0)
         , currentGradient(0)
         , currentGenerator(0)
         , compositeOp(0)
     {
     }
 
     KisImageSP image;
     KisDefaultBoundsBaseSP bounds;
     KoColor currentFgColor;
     KoColor currentBgColor;
     KoPattern *currentPattern;
     KoAbstractGradient *currentGradient;
     KisPaintOpPresetSP currentPaintOpPreset;
     KisNodeSP currentNode;
     qreal currentExposure;
     KisFilterConfigurationSP currentGenerator;
 
     QPointF axesCenter;
     bool mirrorMaskHorizontal;
     bool mirrorMaskVertical;
 
     quint8 opacity;
     QString compositeOpId;
     const KoCompositeOp *compositeOp;
 
     KisPainter::StrokeStyle strokeStyle;
     KisPainter::FillStyle fillStyle;
 
     bool globalAlphaLock;
     qreal effectiveZoom;
     bool presetAllowsLod;
     KisSelectionSP selectionOverride;
 };
 
 KisResourcesSnapshot::KisResourcesSnapshot(KisImageSP image, KisNodeSP currentNode, KoCanvasResourceManager *resourceManager, KisDefaultBoundsBaseSP bounds)
     : m_d(new Private())
 {
     m_d->image = image;
     if (!bounds) {
         bounds = new KisDefaultBounds(m_d->image);
     }
     m_d->bounds = bounds;
     m_d->currentFgColor = resourceManager->resource(KoCanvasResourceManager::ForegroundColor).value<KoColor>();
     m_d->currentBgColor = resourceManager->resource(KoCanvasResourceManager::BackgroundColor).value<KoColor>();
     m_d->currentPattern = resourceManager->resource(KisCanvasResourceProvider::CurrentPattern).value<KoPattern*>();
     m_d->currentGradient = resourceManager->resource(KisCanvasResourceProvider::CurrentGradient).value<KoAbstractGradient*>();
 
     /**
      * We should deep-copy the preset, so that long-runnign actions
      * will have correct brush parameters. Theoretically this cloniong
      * can be expensive, but according to measurements, it takes
      * something like 0.1 ms for an average preset.
      */
     m_d->currentPaintOpPreset = resourceManager->resource(KisCanvasResourceProvider::CurrentPaintOpPreset).value<KisPaintOpPresetSP>()->clone();
 
 #ifdef HAVE_THREADED_TEXT_RENDERING_WORKAROUND
     KisPaintOpRegistry::instance()->preinitializePaintOpIfNeeded(m_d->currentPaintOpPreset);
 #endif /* HAVE_THREADED_TEXT_RENDERING_WORKAROUND */
 
     m_d->currentExposure = resourceManager->resource(KisCanvasResourceProvider::HdrExposure).toDouble();
     m_d->currentGenerator = resourceManager->resource(KisCanvasResourceProvider::CurrentGeneratorConfiguration).value<KisFilterConfiguration*>();
 
 
     QPointF relativeAxesCenter(0.5, 0.5);
     if (m_d->image) {
         relativeAxesCenter = m_d->image->mirrorAxesCenter();
     }
     m_d->axesCenter = KisAlgebra2D::relativeToAbsolute(relativeAxesCenter, m_d->bounds->bounds());
 
     m_d->mirrorMaskHorizontal = resourceManager->resource(KisCanvasResourceProvider::MirrorHorizontal).toBool();
     m_d->mirrorMaskVertical = resourceManager->resource(KisCanvasResourceProvider::MirrorVertical).toBool();
 
 
     qreal normOpacity = resourceManager->resource(KisCanvasResourceProvider::Opacity).toDouble();
     m_d->opacity = quint8(normOpacity * OPACITY_OPAQUE_U8);
 
     m_d->compositeOpId = resourceManager->resource(KisCanvasResourceProvider::CurrentEffectiveCompositeOp).toString();
     setCurrentNode(currentNode);
 
     /**
      * Fill and Stroke styles are not a part of the resource manager
      * so the tools should set them manually
      * TODO: port stroke and fill styles to be a part
      *       of the resource manager
      */
     m_d->strokeStyle = KisPainter::StrokeStyleBrush;
     m_d->fillStyle = KisPainter::FillStyleNone;
 
     m_d->globalAlphaLock = resourceManager->resource(KisCanvasResourceProvider::GlobalAlphaLock).toBool();
     m_d->effectiveZoom = resourceManager->resource(KisCanvasResourceProvider::EffectiveZoom).toDouble();
     m_d->presetAllowsLod = resourceManager->resource(KisCanvasResourceProvider::PresetAllowsLod).toBool();
 }
 
 KisResourcesSnapshot::KisResourcesSnapshot(KisImageSP image, KisNodeSP currentNode, KisDefaultBoundsBaseSP bounds)
     : m_d(new Private())
 {
     m_d->image = image;
     if (!bounds) {
         bounds = new KisDefaultBounds(m_d->image);
     }
     m_d->bounds = bounds;
 
 #ifdef HAVE_THREADED_TEXT_RENDERING_WORKAROUND
     KisPaintOpRegistry::instance()->preinitializePaintOpIfNeeded(m_d->currentPaintOpPreset);
 #endif /* HAVE_THREADED_TEXT_RENDERING_WORKAROUND */
 
     QPointF relativeAxesCenter(0.5, 0.5);
     if (m_d->image) {
         relativeAxesCenter = m_d->image->mirrorAxesCenter();
     }
     m_d->axesCenter = KisAlgebra2D::relativeToAbsolute(relativeAxesCenter, m_d->bounds->bounds());
     m_d->opacity = OPACITY_OPAQUE_U8;
 
     setCurrentNode(currentNode);
 
     /**
      * Fill and Stroke styles are not a part of the resource manager
      * so the tools should set them manually
      * TODO: port stroke and fill styles to be a part
      *       of the resource manager
      */
     m_d->strokeStyle = KisPainter::StrokeStyleBrush;
     m_d->fillStyle = KisPainter::FillStyleNone;
 }
 
 
 KisResourcesSnapshot::~KisResourcesSnapshot()
 {
     delete m_d;
 }
 
 void KisResourcesSnapshot::setupPainter(KisPainter* painter)
 {
     painter->setPaintColor(m_d->currentFgColor);
     painter->setBackgroundColor(m_d->currentBgColor);
     painter->setGenerator(m_d->currentGenerator);
     painter->setPattern(m_d->currentPattern);
     painter->setGradient(m_d->currentGradient);
 
     QBitArray lockflags = channelLockFlags();
     if (lockflags.size() > 0) {
         painter->setChannelFlags(lockflags);
     }
 
     painter->setOpacity(m_d->opacity);
     painter->setCompositeOp(m_d->compositeOp);
     painter->setMirrorInformation(m_d->axesCenter, m_d->mirrorMaskHorizontal, m_d->mirrorMaskVertical);
 
     painter->setStrokeStyle(m_d->strokeStyle);
     painter->setFillStyle(m_d->fillStyle);
 
     /**
      * The paintOp should be initialized the last, because it may
      * ask the painter for some options while initialization
      */
     painter->setPaintOpPreset(m_d->currentPaintOpPreset, m_d->currentNode, m_d->image);
 }
 
 void KisResourcesSnapshot::setupPaintAction(KisRecordedPaintAction *action)
 {
     action->setPaintOpPreset(m_d->currentPaintOpPreset);
     action->setPaintIncremental(!needsIndirectPainting());
 
     action->setPaintColor(m_d->currentFgColor);
     action->setBackgroundColor(m_d->currentBgColor);
     action->setGenerator(m_d->currentGenerator);
     action->setGradient(m_d->currentGradient);
     action->setPattern(m_d->currentPattern);
 
     action->setOpacity(m_d->opacity / qreal(OPACITY_OPAQUE_U8));
     action->setCompositeOp(m_d->compositeOp->id());
 
     action->setStrokeStyle(m_d->strokeStyle);
     action->setFillStyle(m_d->fillStyle);
 }
 
 KisPostExecutionUndoAdapter* KisResourcesSnapshot::postExecutionUndoAdapter() const
 {
     return m_d->image ? m_d->image->postExecutionUndoAdapter() : 0;
 }
 
 void KisResourcesSnapshot::setCurrentNode(KisNodeSP node)
 {
     m_d->currentNode = node;
 
     KisPaintDeviceSP device;
     if(m_d->currentNode && (device = m_d->currentNode->paintDevice())) {
         m_d->compositeOp = device->colorSpace()->compositeOp(m_d->compositeOpId);
         if(!m_d->compositeOp) {
             m_d->compositeOp = device->colorSpace()->compositeOp(COMPOSITE_OVER);
         }
     }
 }
 
 void KisResourcesSnapshot::setStrokeStyle(KisPainter::StrokeStyle strokeStyle)
 {
     m_d->strokeStyle = strokeStyle;
 }
 
 void KisResourcesSnapshot::setFillStyle(KisPainter::FillStyle fillStyle)
 {
     m_d->fillStyle = fillStyle;
 }
 
 KisNodeSP KisResourcesSnapshot::currentNode() const
 {
     return m_d->currentNode;
 }
 
 KisImageSP KisResourcesSnapshot::image() const
 {
     return m_d->image;
 }
 
 bool KisResourcesSnapshot::needsIndirectPainting() const
 {
     return !m_d->currentPaintOpPreset->settings()->paintIncremental();
 }
 
 QString KisResourcesSnapshot::indirectPaintingCompositeOp() const
 {
     return m_d->currentPaintOpPreset->settings()->indirectPaintingCompositeOp();
 }
 
 KisSelectionSP KisResourcesSnapshot::activeSelection() const
 {
     /**
      * It is possible to have/use the snapshot without the image. Such
      * usecase is present for example in the scratchpad.
      */
     if (m_d->selectionOverride) {
         return m_d->selectionOverride;
     }
 
     KisSelectionSP selection = m_d->image ? m_d->image->globalSelection() : 0;
 
     KisLayerSP layer = qobject_cast<KisLayer*>(m_d->currentNode.data());
     KisSelectionMaskSP mask;
     if((layer = qobject_cast<KisLayer*>(m_d->currentNode.data()))) {
          selection = layer->selection();
     } else if ((mask = dynamic_cast<KisSelectionMask*>(m_d->currentNode.data())) &&
                mask->selection() == selection) {
 
          selection = 0;
     }
 
     return selection;
 }
 
 bool KisResourcesSnapshot::needsAirbrushing() const
 {
     return m_d->currentPaintOpPreset->settings()->isAirbrushing();
 }
 
-int KisResourcesSnapshot::airbrushingRate() const
+qreal KisResourcesSnapshot::airbrushingInterval() const
 {
-    return m_d->currentPaintOpPreset->settings()->rate();
+    return m_d->currentPaintOpPreset->settings()->airbrushInterval();
 }
 
 void KisResourcesSnapshot::setOpacity(qreal opacity)
 {
     m_d->opacity = opacity * OPACITY_OPAQUE_U8;
 }
 
 quint8 KisResourcesSnapshot::opacity() const
 {
     return m_d->opacity;
 }
 
 const KoCompositeOp* KisResourcesSnapshot::compositeOp() const
 {
     return m_d->compositeOp;
 }
 
 QString KisResourcesSnapshot::compositeOpId() const
 {
     return m_d->compositeOpId;
 }
 
 KoPattern* KisResourcesSnapshot::currentPattern() const
 {
     return m_d->currentPattern;
 }
 
 KoColor KisResourcesSnapshot::currentFgColor() const
 {
     return m_d->currentFgColor;
 }
 
 KoColor KisResourcesSnapshot::currentBgColor() const
 {
     return m_d->currentBgColor;
 }
 
 KisPaintOpPresetSP KisResourcesSnapshot::currentPaintOpPreset() const
 {
     return m_d->currentPaintOpPreset;
 }
 
 
 QBitArray KisResourcesSnapshot::channelLockFlags() const
 {
     QBitArray channelFlags;
     KisPaintLayer *paintLayer;
     if ((paintLayer = dynamic_cast<KisPaintLayer*>(m_d->currentNode.data()))) {
 
         channelFlags = paintLayer->channelLockFlags();
         if (m_d->globalAlphaLock) {
             if (channelFlags.isEmpty()) {
                 channelFlags = paintLayer->colorSpace()->channelFlags(true, true);
             }
 
             channelFlags &= paintLayer->colorSpace()->channelFlags(true, false);
         }
     }
     return channelFlags;
 }
 
 qreal KisResourcesSnapshot::effectiveZoom() const
 {
     return m_d->effectiveZoom;
 }
 
 bool KisResourcesSnapshot::presetAllowsLod() const
 {
     return m_d->presetAllowsLod;
 }
 
 void KisResourcesSnapshot::setFGColorOverride(const KoColor &color)
 {
     m_d->currentFgColor = color;
 }
 
 void KisResourcesSnapshot::setBGColorOverride(const KoColor &color)
 {
     m_d->currentBgColor = color;
 }
 
 void KisResourcesSnapshot::setSelectionOverride(KisSelectionSP selection)
 {
     m_d->selectionOverride = selection;
 }
 
 void KisResourcesSnapshot::setBrush(const KisPaintOpPresetSP &brush)
 {
     m_d->currentPaintOpPreset = brush;
 }
diff --git a/libs/ui/tool/kis_resources_snapshot.h b/libs/ui/tool/kis_resources_snapshot.h
index 8051507552..08d6c968ca 100644
--- a/libs/ui/tool/kis_resources_snapshot.h
+++ b/libs/ui/tool/kis_resources_snapshot.h
@@ -1,104 +1,104 @@
 /*
  *  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_RESOURCES_SNAPSHOT_H
 #define __KIS_RESOURCES_SNAPSHOT_H
 
 #include "kis_shared.h"
 #include "kis_shared_ptr.h"
 #include "kis_types.h"
 #include "kritaui_export.h"
 #include "kis_painter.h"
 #include "kis_default_bounds.h"
 
 class KoCanvasResourceManager;
 class KoCompositeOp;
 class KisPainter;
 class KisPostExecutionUndoAdapter;
 class KisRecordedPaintAction;
 class KoPattern;
 
 /**
  * @brief The KisResourcesSnapshot class takes a snapshot of the various resources
  * like colors and settings used at the begin of a stroke or a recording so subsequent
  * changes don't impact the running stroke. The main reason for the snapshot is that the
  * user can *change* the options while the stroke is being executed in the background.
  */
 class KRITAUI_EXPORT KisResourcesSnapshot : public KisShared
 {
 public:
     KisResourcesSnapshot(KisImageSP image, KisNodeSP currentNode, KoCanvasResourceManager *resourceManager, KisDefaultBoundsBaseSP bounds = 0);
     KisResourcesSnapshot(KisImageSP image, KisNodeSP currentNode, KisDefaultBoundsBaseSP bounds = 0);
     ~KisResourcesSnapshot();
 
     void setupPainter(KisPainter *painter);
     // XXX: This was marked as KDE_DEPRECATED, but no althernative was
     //      given in the apidox.
     void setupPaintAction(KisRecordedPaintAction *action);
 
     KisPostExecutionUndoAdapter* postExecutionUndoAdapter() const;
     void setCurrentNode(KisNodeSP node);
     void setStrokeStyle(KisPainter::StrokeStyle strokeStyle);
     void setFillStyle(KisPainter::FillStyle fillStyle);
 
     KisNodeSP currentNode() const;
     KisImageSP image() const;
     bool needsIndirectPainting() const;
     QString indirectPaintingCompositeOp() const;
 
     /**
      * \return currently active selection. Note that it will return
      *         null if current node *is* the current selection. This
      *         is done to avoid recursive selection application when
      *         painting on selectgion masks.
      */
     KisSelectionSP activeSelection() const;
 
     bool needsAirbrushing() const;
-    int airbrushingRate() const;
+    qreal airbrushingInterval() const;
 
     void setOpacity(qreal opacity);
     quint8 opacity() const;
     const KoCompositeOp* compositeOp() const;
     QString compositeOpId() const;
 
     KoPattern* currentPattern() const;
     KoColor currentFgColor() const;
     KoColor currentBgColor() const;
     KisPaintOpPresetSP currentPaintOpPreset() const;
 
     /// @return the channel lock flags of the current node with the global override applied
     QBitArray channelLockFlags() const;
 
     qreal effectiveZoom() const;
     bool presetAllowsLod() const;
 
     void setFGColorOverride(const KoColor &color);
     void setBGColorOverride(const KoColor &color);
     void setSelectionOverride(KisSelectionSP selection);
     void setBrush(const KisPaintOpPresetSP &brush);
 
 private:
     struct Private;
     Private * const m_d;
 };
 
 typedef KisSharedPtr<KisResourcesSnapshot> KisResourcesSnapshotSP;
 
 
 #endif /* __KIS_RESOURCES_SNAPSHOT_H */
diff --git a/libs/ui/tool/kis_tool_freehand.cc b/libs/ui/tool/kis_tool_freehand.cc
index 47b93df966..179da1ad20 100644
--- a/libs/ui/tool/kis_tool_freehand.cc
+++ b/libs/ui/tool/kis_tool_freehand.cc
@@ -1,458 +1,466 @@
 /*
  *  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;
 }
 
+void KisToolFreehand::mouseMoveEvent(KoPointerEvent *event)
+{
+    KisToolPaint::mouseMoveEvent(event);
+    m_helper->cursorMoved(convertToPixelCoord(event));
+}
+
 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
            |KisTool::FLAG_USES_CUSTOM_SIZE;
 }
 
 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(),
+    m_helper->initPaint(event,
+                        convertToPixelCoord(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);
+    QPointF imagePos = convertToPixelCoord(documentPos);
 
     if (currentPaintOpPreset())
         return m_helper->paintOpOutline(imagePos,
                                         event,
                                         currentPaintOpPreset()->settings(),
                                         outlineMode);
     else
         return QPainterPath();
 }
 
 
diff --git a/libs/ui/tool/kis_tool_freehand.h b/libs/ui/tool/kis_tool_freehand.h
index 356229d5ae..dce7d73a57 100644
--- a/libs/ui/tool/kis_tool_freehand.h
+++ b/libs/ui/tool/kis_tool_freehand.h
@@ -1,141 +1,142 @@
 /*
  *  Copyright (c) 2003-2008 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_TOOL_FREEHAND_H_
 #define KIS_TOOL_FREEHAND_H_
 
 #include <Eigen/Core>
 
 #include <brushengine/kis_paint_information.h>
 #include <brushengine/kis_paintop_settings.h>
 #include <kis_distance_information.h>
 
 #include "kis_types.h"
 #include "kis_tool_paint.h"
 #include "kis_smoothing_options.h"
 #include "kis_signal_compressor_with_param.h"
 
 #include "kritaui_export.h"
 
 class KoPointerEvent;
 class KoCanvasBase;
 
 
 
 class KisPaintingInformationBuilder;
 class KisToolFreehandHelper;
 class KisRecordingAdapter;
 
 
 class KRITAUI_EXPORT KisToolFreehand : public KisToolPaint
 {
 
     Q_OBJECT
 
 public:
     EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
     KisToolFreehand(KoCanvasBase * canvas, const QCursor & cursor, const KUndo2MagicString &transactionText);
     ~KisToolFreehand() override;
     int flags() const override;
+    void mouseMoveEvent(KoPointerEvent *event) override;
 
 public Q_SLOTS:
     void activate(ToolActivation toolActivation, const QSet<KoShape*> &shapes) override;
     void deactivate() override;
 
 protected:
     bool tryPickByPaintOp(KoPointerEvent *event, AlternateAction action);
 
     bool primaryActionSupportsHiResEvents() const override;
     void beginPrimaryAction(KoPointerEvent *event) override;
     void continuePrimaryAction(KoPointerEvent *event) override;
     void endPrimaryAction(KoPointerEvent *event) override;
 
     void activateAlternateAction(AlternateAction action) override;
     void deactivateAlternateAction(AlternateAction action) override;
 
     void beginAlternateAction(KoPointerEvent *event, AlternateAction action) override;
     void continueAlternateAction(KoPointerEvent *event, AlternateAction action) override;
     void endAlternateAction(KoPointerEvent *event, AlternateAction action) override;
 
     bool wantsAutoScroll() const override;
 
 
     virtual void initStroke(KoPointerEvent *event);
     virtual void doStroke(KoPointerEvent *event);
     virtual void endStroke();
 
     QPainterPath getOutlinePath(const QPointF &documentPos,
                                         const KoPointerEvent *event,
                                         KisPaintOpSettings::OutlineMode outlineMode) override;
 
 
     KisPaintingInformationBuilder* paintingInformationBuilder() const;
     KisRecordingAdapter* recordingAdapter() const;
     void resetHelper(KisToolFreehandHelper *helper);
 
 protected Q_SLOTS:
 
     void explicitUpdateOutline();
     void resetCursorStyle() override;
     void setAssistant(bool assistant);
     void setOnlyOneAssistantSnap(bool assistant);
     void slotDoResizeBrush(qreal newSize);
 
 private:
     friend class KisToolFreehandPaintingInformationBuilder;
 
     /**
      * Adjusts a coordinates according to a KisPaintingAssitant,
      * if available.
      */
     QPointF adjustPosition(const QPointF& point, const QPointF& strokeBegin);
 
     /**
      * Calculates a coefficient for KisPaintInformation
      * according to perspective grid values
      */
     qreal calculatePerspective(const QPointF &documentPoint);
 
 protected:
     friend class KisViewManager;
     friend class KisView;
     friend class KisSketchView;
     KisSmoothingOptionsSP smoothingOptions() const;
     bool m_assistant;
     double m_magnetism;
     bool m_only_one_assistant;
 
 private:
     KisPaintingInformationBuilder *m_infoBuilder;
     KisToolFreehandHelper *m_helper;
     KisRecordingAdapter *m_recordingAdapter;
 
     QPointF m_initialGestureDocPoint;
     QPointF m_lastDocumentPoint;
     qreal m_lastPaintOpSize;
     QPoint m_initialGestureGlobalPoint;
 
     bool m_paintopBasedPickingInAction;
     KisSignalCompressorWithParam<qreal> m_brushResizeCompressor;
 };
 
 
 
 #endif // KIS_TOOL_FREEHAND_H_
 
diff --git a/libs/ui/tool/kis_tool_freehand_helper.cpp b/libs/ui/tool/kis_tool_freehand_helper.cpp
index 0818dfed24..b1a61b33ba 100644
--- a/libs/ui/tool/kis_tool_freehand_helper.cpp
+++ b/libs/ui/tool/kis_tool_freehand_helper.cpp
@@ -1,892 +1,963 @@
 /*
  *  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_algebra_2d.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, relative to the actual airbrushing rate.
+// Setting this less than 1 makes the timer-generated pseudo-events happen faster than the desired
+// airbrush rate, which can improve responsiveness.
+const qreal AIRBRUSH_INTERVAL_FACTOR = 0.5;
+
 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;
+    // Keeps track of past cursor positions. This is used to determine the drawing angle when
+    // drawing the brush outline or starting a stroke.
+    KisPaintOpUtils::PositionHistory lastCursorPos;
 
     // 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);
+    QPointF prevPoint = m_d->lastCursorPos.pushThroughHistory(savedCursorPos);
+    qreal startAngle = KisAlgebra2D::directionBetweenPoints(prevPoint, savedCursorPos, 0);
     info.setCanvasRotation(m_d->canvasRotation);
     info.setCanvasHorizontalMirrorState( m_d->canvasMirroredH );
-    KisDistanceInformation distanceInfo(m_d->lastOutlinePos.pushThroughHistory(savedCursorPos), 0);
+    KisDistanceInformation distanceInfo(prevPoint, 0, startAngle);
 
     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);
+            distanceInfo.overrideLastValues(prevPoint, 0, startAngle);
 
         } 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::cursorMoved(const QPointF &cursorPos)
+{
+    m_d->lastCursorPos.pushThroughHistory(cursorPos);
+}
+
 void KisToolFreehandHelper::initPaint(KoPointerEvent *event,
+                                      const QPointF &pixelCoords,
                                       KoCanvasResourceManager *resourceManager,
                                       KisImageWSP image, KisNodeSP currentNode,
                                       KisStrokesFacade *strokesFacade,
                                       KisNodeSP overrideNode,
                                       KisDefaultBoundsBaseSP bounds)
 {
+    QPointF prevPoint = m_d->lastCursorPos.pushThroughHistory(pixelCoords);
+    m_d->strokeTime.start();
     KisPaintInformation pi =
         m_d->infoBuilder->startStroke(event, elapsedStrokeTime(), resourceManager);
+    qreal startAngle = KisAlgebra2D::directionBetweenPoints(prevPoint, pixelCoords, 0.0);
 
-    initPaintImpl(pi,
+    initPaintImpl(startAngle,
+                  pi,
                   resourceManager,
                   image,
                   currentNode,
                   strokesFacade,
                   overrideNode,
                   bounds);
 }
 
 bool KisToolFreehandHelper::isRunning() const
 {
     return m_d->strokeId;
 }
 
-void KisToolFreehandHelper::initPaintImpl(const KisPaintInformation &previousPaintInformation,
+void KisToolFreehandHelper::initPaintImpl(qreal startAngle,
+                                          const KisPaintInformation &pi,
                                           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;
+    m_d->previousPaintInformation = pi;
 
     createPainters(m_d->painterInfos,
                    m_d->previousPaintInformation.pos(),
-                   m_d->previousPaintInformation.currentTime());
+                   m_d->previousPaintInformation.currentTime(),
+                   startAngle);
 
     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(m_d->resources->airbrushingRate());
+        m_d->airbrushingTimer.setInterval(computeAirbrushTimerInterval());
         m_d->airbrushingTimer.start();
     }
 
     if (m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::STABILIZER) {
         stabilizerStart(m_d->previousPaintInformation);
     }
+
+    // If airbrushing, paint an initial dab immediately. This is a workaround for an issue where
+    // some paintops (Dyna, Particle, Sketch) might never initialize their spacing information until
+    // paintAt is called.
+    if (m_d->resources->needsAirbrushing()) {
+        paintAt(pi);
+    }
 }
 
 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::paint(KoPointerEvent *event)
+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(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);
+            if (newTangent.isNull() || m_d->previousTangent.isNull())
+            {
+                paintLine(m_d->previousPaintInformation, info);
+            } else {
+                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);
+KisToolFreehandHelper::getStabilizedPaintInfo(const QQueue<KisPaintInformation> &queue,
+                                              const KisPaintInformation &lastPaintInfo)
+{
+    KisPaintInformation result(lastPaintInfo.pos(),
+                               lastPaintInfo.pressure(),
+                               lastPaintInfo.xTilt(),
+                               lastPaintInfo.yTilt(),
+                               lastPaintInfo.rotation(),
+                               lastPaintInfo.tangentialPressure(),
+                               lastPaintInfo.perspective(),
+                               elapsedStrokeTime(),
+                               lastPaintInfo.drawingSpeed());
 
     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()) {
+        if (m_d->smoothingOptions->stabilizeSensors()) {
             while (it != end) {
                 qreal k = qreal(i - 1) / i; // coeff for uniform averaging
-                result = KisPaintInformation::mix(k, *it, result);
+                result = KisPaintInformation::mixWithoutTime(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 (!(dx > R)) {
+                if (m_d->resources->needsAirbrushing()) {
+                    sampledInfo.setPos(m_d->previousPaintInformation.pos());
+                }
+                else {
+                    canPaint = false;
+                }
+            }
         }
 
         if (canPaint) {
-            KisPaintInformation newInfo =
-                    m_d->getStabilizedPaintInfo(m_d->stabilizerDeque, sampledInfo);
+            KisPaintInformation newInfo = 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()) {
-        paintAt(m_d->previousPaintInformation);
+    // Check that the stroke hasn't ended.
+    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);
+        paint(nextPaint);
     }
 }
 
+int KisToolFreehandHelper::computeAirbrushTimerInterval() const
+{
+    qreal realInterval = m_d->resources->airbrushingInterval() * AIRBRUSH_INTERVAL_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)
+                                           int lastTime,
+                                           qreal lastAngle)
 {
-    painterInfos << new PainterInfo(lastPosition, lastTime);
+    painterInfos << new PainterInfo(lastPosition, lastTime, lastAngle);
 }
 
 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 9833a31e17..21431b5eba 100644
--- a/libs/ui/tool/kis_tool_freehand_helper.h
+++ b/libs/ui/tool/kis_tool_freehand_helper.h
@@ -1,152 +1,164 @@
 /*
  *  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() override;
 
     void setSmoothness(KisSmoothingOptionsSP smoothingOptions);
     KisSmoothingOptionsSP smoothingOptions() const;
 
     bool isRunning() const;
 
+    void cursorMoved(const QPointF &cursorPos);
+
+    /**
+     * @param pixelCoords - The position of the KoPointerEvent, in pixel coordinates.
+     */
     void initPaint(KoPointerEvent *event,
+                   const QPointF &pixelCoords,
                    KoCanvasResourceManager *resourceManager,
                    KisImageWSP image,
                    KisNodeSP currentNode,
                    KisStrokesFacade *strokesFacade,
                    KisNodeSP overrideNode = 0,
                    KisDefaultBoundsBaseSP bounds = 0);
-    void paint(KoPointerEvent *event);
+    void paintEvent(KoPointerEvent *event);
     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,
+    void initPaintImpl(qreal startAngle,
+                       const KisPaintInformation &pi,
                        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);
+                                int lastTime,
+                                qreal lastAngle);
 
     // 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();
+    KisPaintInformation getStabilizedPaintInfo(const QQueue<KisPaintInformation> &queue,
+                                               const KisPaintInformation &lastPaintInfo);
+    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/tool/kis_tool_multihand_helper.cpp b/libs/ui/tool/kis_tool_multihand_helper.cpp
index d67e0d3edd..3d78d78e9d 100644
--- a/libs/ui/tool/kis_tool_multihand_helper.cpp
+++ b/libs/ui/tool/kis_tool_multihand_helper.cpp
@@ -1,148 +1,149 @@
 /*
  *  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_multihand_helper.h"
 
 #include <QTransform>
 
 #include "kis_painter.h"
 
 
 struct KisToolMultihandHelper::Private
 {
     QVector<QTransform> transformations;
 };
 
 KisToolMultihandHelper::KisToolMultihandHelper(KisPaintingInformationBuilder *infoBuilder,
                                                const KUndo2MagicString &transactionText,
                                                KisRecordingAdapter *recordingAdapter)
     : KisToolFreehandHelper(infoBuilder, transactionText, recordingAdapter)
     , d(new Private)
 {
 }
 
 KisToolMultihandHelper::~KisToolMultihandHelper()
 {
     delete d;
 }
 
 void KisToolMultihandHelper::setupTransformations(const QVector<QTransform> &transformations)
 {
     d->transformations = transformations;
 }
 
 void KisToolMultihandHelper::createPainters(QVector<PainterInfo*> &painterInfos,
                                             const QPointF &lastPosition,
-                                            int lastTime)
+                                            int lastTime,
+                                            qreal lastAngle)
 {
     for (int i = 0; i < d->transformations.size(); i++) {
-        painterInfos << new PainterInfo(lastPosition, lastTime);
+        painterInfos << new PainterInfo(lastPosition, lastTime, lastAngle);
     }
 }
 
 void KisToolMultihandHelper::paintAt(const KisPaintInformation &pi)
 {
     for (int i = 0; i < d->transformations.size(); i++) {
         const QTransform &transform = d->transformations[i];
 
         KisPaintInformation __pi = pi;
         QLineF rotateme(QPointF (0.0,0.0), QPointF (10.0,10.0));
         rotateme.setAngle(__pi.canvasRotation());
         QLineF rotated = transform.map(rotateme);
         
         __pi.setPos(transform.map(__pi.pos()));
         __pi.setCanvasRotation(rotated.angle());
 
         if (__pi.canvasMirroredH()) {
             __pi.setCanvasRotation(180-__pi.canvasRotation());
             __pi.setCanvasRotation(__pi.canvasRotation()+180);
         }
 
         paintAt(i, __pi);
     }
 }
 
 void KisToolMultihandHelper::paintLine(const KisPaintInformation &pi1,
                                        const KisPaintInformation &pi2)
 {
     for (int i = 0; i < d->transformations.size(); i++) {
         const QTransform &transform = d->transformations[i];
 
         KisPaintInformation __pi1 = pi1;
         KisPaintInformation __pi2 = pi2;
         __pi1.setPos(transform.map(__pi1.pos()));
         __pi2.setPos(transform.map(__pi2.pos()));
         
         QLineF rotateme(QPointF (0.0,0.0), QPointF (10.0,10.0));
         rotateme.setAngle(__pi1.canvasRotation());
         QLineF rotated = transform.map(rotateme);
         __pi1.setCanvasRotation(rotated.angle());
 
         rotateme.setAngle(__pi2.canvasRotation());
         rotated = transform.map(rotateme);
         __pi2.setCanvasRotation(rotated.angle());
 
         //check mirroring
         if (__pi2.canvasMirroredH()) {
             __pi1.setCanvasRotation(180-__pi1.canvasRotation());
             __pi1.setCanvasRotation(__pi1.canvasRotation()+180);            
             __pi2.setCanvasRotation(180-__pi2.canvasRotation());
             __pi2.setCanvasRotation(__pi2.canvasRotation()+180);
         }
         
 
         paintLine(i, __pi1, __pi2);
     }
 }
 
 void KisToolMultihandHelper::paintBezierCurve(const KisPaintInformation &pi1,
                                               const QPointF &control1,
                                               const QPointF &control2,
                                               const KisPaintInformation &pi2)
 {
     for (int i = 0; i < d->transformations.size(); i++) {
         const QTransform &transform = d->transformations[i];
 
         KisPaintInformation __pi1 = pi1;
         KisPaintInformation __pi2 = pi2;
         __pi1.setPos(transform.map(__pi1.pos()));
         __pi2.setPos(transform.map(__pi2.pos()));
         
         QLineF rotateme(QPointF (0.0,0.0), QPointF (10.0,10.0));
         rotateme.setAngle(__pi1.canvasRotation());
         QLineF rotated = transform.map(rotateme);
         __pi1.setCanvasRotation(rotated.angle());
         
         rotateme.setAngle(__pi2.canvasRotation());
         rotated = transform.map(rotateme);
         __pi2.setCanvasRotation(rotated.angle());
         
         if (__pi2.canvasMirroredH()) {
             __pi1.setCanvasRotation(180-__pi1.canvasRotation());
             __pi1.setCanvasRotation(__pi1.canvasRotation()+180);            
             __pi2.setCanvasRotation(180-__pi2.canvasRotation());
             __pi2.setCanvasRotation(__pi2.canvasRotation()+180);
         }
         
 
         QPointF __control1 = transform.map(control1);
         QPointF __control2 = transform.map(control2);
 
         paintBezierCurve(i, __pi1, __control1, __control2, __pi2);
     }
 }
diff --git a/libs/ui/tool/kis_tool_multihand_helper.h b/libs/ui/tool/kis_tool_multihand_helper.h
index c67ca9feb7..d6e4e9559d 100644
--- a/libs/ui/tool/kis_tool_multihand_helper.h
+++ b/libs/ui/tool/kis_tool_multihand_helper.h
@@ -1,61 +1,62 @@
 /*
  *  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_MULTIHAND_HELPER_H
 #define __KIS_TOOL_MULTIHAND_HELPER_H
 
 #include "kis_tool_freehand_helper.h"
 
 
 class KRITAUI_EXPORT KisToolMultihandHelper : public KisToolFreehandHelper
 {
     Q_OBJECT
 
 public:
     KisToolMultihandHelper(KisPaintingInformationBuilder *infoBuilder,
                            const KUndo2MagicString &transactionText,
                            KisRecordingAdapter *recordingAdapter = 0);
     ~KisToolMultihandHelper() override;
 
     void setupTransformations(const QVector<QTransform> &transformations);
 
 protected:
     void createPainters(QVector<PainterInfo*> &painterInfos,
                         const QPointF &lastPosition,
-                        int lastTime) override;
+                        int lastTime,
+                        qreal lastAngle) override;
 
     void paintAt(const KisPaintInformation &pi) override;
 
     void paintLine(const KisPaintInformation &pi1,
                    const KisPaintInformation &pi2) override;
 
     void paintBezierCurve(const KisPaintInformation &pi1,
                           const QPointF &control1,
                           const QPointF &control2,
                           const KisPaintInformation &pi2) override;
 
     using KisToolFreehandHelper::paintAt;
     using KisToolFreehandHelper::paintLine;
     using KisToolFreehandHelper::paintBezierCurve;
 
 private:
     struct Private;
     Private * const d;
 };
 
 #endif /* __KIS_TOOL_MULTIHAND_HELPER_H */
diff --git a/libs/ui/tool/strokes/kis_painter_based_stroke_strategy.cpp b/libs/ui/tool/strokes/kis_painter_based_stroke_strategy.cpp
index 8a05c53142..f32730134f 100644
--- a/libs/ui/tool/strokes/kis_painter_based_stroke_strategy.cpp
+++ b/libs/ui/tool/strokes/kis_painter_based_stroke_strategy.cpp
@@ -1,316 +1,317 @@
 /*
  *  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_painter_based_stroke_strategy.h"
 
 #include <KoColorSpace.h>
 #include <KoColor.h>
 #include <KoCompositeOp.h>
 #include "kis_painter.h"
 #include "kis_paint_device.h"
 #include "kis_paint_layer.h"
 #include "kis_transaction.h"
 #include "kis_image.h"
 #include <kis_distance_information.h>
 #include "kis_undo_stores.h"
 
 
 KisPainterBasedStrokeStrategy::PainterInfo::PainterInfo()
     : painter(new KisPainter()),
       dragDistance(new KisDistanceInformation()),
       m_parentPainterInfo(0),
       m_childPainterInfo(0)
 {
 }
 
-KisPainterBasedStrokeStrategy::PainterInfo::PainterInfo(const QPointF &lastPosition, int lastTime)
+KisPainterBasedStrokeStrategy::PainterInfo::PainterInfo(const QPointF &lastPosition, int lastTime,
+                                                        qreal lastAngle)
     : painter(new KisPainter()),
-      dragDistance(new KisDistanceInformation(lastPosition, lastTime)),
+      dragDistance(new KisDistanceInformation(lastPosition, lastTime, lastAngle)),
       m_parentPainterInfo(0),
       m_childPainterInfo(0)
 {
 }
 
 KisPainterBasedStrokeStrategy::PainterInfo::PainterInfo(PainterInfo *rhs, int levelOfDetail)
     : painter(new KisPainter()),
       dragDistance(new KisDistanceInformation(*rhs->dragDistance, levelOfDetail)),
       m_parentPainterInfo(rhs)
 {
     rhs->m_childPainterInfo = this;
 }
 
 KisPainterBasedStrokeStrategy::PainterInfo::~PainterInfo()
 {
     if (m_parentPainterInfo) {
         m_parentPainterInfo->m_childPainterInfo = 0;
     }
 
     delete(painter);
     delete(dragDistance);
 }
 
 KisDistanceInformation* KisPainterBasedStrokeStrategy::PainterInfo::buddyDragDistance()
 {
     return m_childPainterInfo ? m_childPainterInfo->dragDistance : 0;
 }
 
 KisPainterBasedStrokeStrategy::KisPainterBasedStrokeStrategy(const QString &id,
                                                              const KUndo2MagicString &name,
                                                              KisResourcesSnapshotSP resources,
                                                              QVector<PainterInfo*> painterInfos,bool useMergeID)
     : KisSimpleStrokeStrategy(id, name),
       m_resources(resources),
       m_painterInfos(painterInfos),
       m_transaction(0),
       m_useMergeID(useMergeID)
 {
     init();
 }
 
 KisPainterBasedStrokeStrategy::KisPainterBasedStrokeStrategy(const QString &id,
                                                              const KUndo2MagicString &name,
                                                              KisResourcesSnapshotSP resources,
                                                              PainterInfo *painterInfo,bool useMergeID)
     : KisSimpleStrokeStrategy(id, name),
       m_resources(resources),
       m_painterInfos(QVector<PainterInfo*>() <<  painterInfo),
       m_transaction(0),
       m_useMergeID(useMergeID)
 {
     init();
 }
 
 void KisPainterBasedStrokeStrategy::init()
 {
     enableJob(KisSimpleStrokeStrategy::JOB_INIT);
     enableJob(KisSimpleStrokeStrategy::JOB_FINISH);
     enableJob(KisSimpleStrokeStrategy::JOB_CANCEL, true, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
 
     enableJob(KisSimpleStrokeStrategy::JOB_SUSPEND);
     enableJob(KisSimpleStrokeStrategy::JOB_RESUME);
 }
 
 KisPainterBasedStrokeStrategy::KisPainterBasedStrokeStrategy(const KisPainterBasedStrokeStrategy &rhs, int levelOfDetail)
     : KisSimpleStrokeStrategy(rhs),
       m_resources(rhs.m_resources),
       m_transaction(rhs.m_transaction),
       m_useMergeID(rhs.m_useMergeID)
 {
     Q_FOREACH (PainterInfo *info, rhs.m_painterInfos) {
         m_painterInfos.append(new PainterInfo(info, levelOfDetail));
     }
 
     KIS_ASSERT_RECOVER_NOOP(
         !rhs.m_transaction &&
         !rhs.m_targetDevice &&
         !rhs.m_activeSelection &&
         "After the stroke has been started, no copying must happen");
 }
 
 KisPaintDeviceSP KisPainterBasedStrokeStrategy::targetDevice() const
 {
     return m_targetDevice;
 }
 
 KisSelectionSP KisPainterBasedStrokeStrategy::activeSelection() const
 {
     return m_activeSelection;
 }
 
 const QVector<KisPainterBasedStrokeStrategy::PainterInfo*>
 KisPainterBasedStrokeStrategy::painterInfos() const
 {
     return m_painterInfos;
 }
 
 void KisPainterBasedStrokeStrategy::initPainters(KisPaintDeviceSP targetDevice,
                                                  KisSelectionSP selection,
                                                  bool hasIndirectPainting,
                                                  const QString &indirectPaintingCompositeOp)
 {
     Q_FOREACH (PainterInfo *info, m_painterInfos) {
         KisPainter *painter = info->painter;
 
         painter->begin(targetDevice, !hasIndirectPainting ? selection : 0);
         m_resources->setupPainter(painter);
 
         if(hasIndirectPainting) {
             painter->setCompositeOp(targetDevice->colorSpace()->compositeOp(indirectPaintingCompositeOp));
             painter->setOpacity(OPACITY_OPAQUE_U8);
             painter->setChannelFlags(QBitArray());
         }
     }
 }
 
 void KisPainterBasedStrokeStrategy::deletePainters()
 {
     Q_FOREACH (PainterInfo *info, m_painterInfos) {
         delete info;
     }
 
     m_painterInfos.clear();
 }
 
 void KisPainterBasedStrokeStrategy::initStrokeCallback()
 {
     KisNodeSP node = m_resources->currentNode();
     KisPaintDeviceSP paintDevice = node->paintDevice();
     KisPaintDeviceSP targetDevice = paintDevice;
     bool hasIndirectPainting = needsIndirectPainting();
 
     KisSelectionSP selection = m_resources->activeSelection();
 
     if (hasIndirectPainting) {
         KisIndirectPaintingSupport *indirect =
             dynamic_cast<KisIndirectPaintingSupport*>(node.data());
 
         if (indirect) {
             targetDevice = paintDevice->createCompositionSourceDevice();
             targetDevice->setParentNode(node);
             indirect->setCurrentColor(m_resources->currentFgColor());
             indirect->setTemporaryTarget(targetDevice);
 
             indirect->setTemporaryCompositeOp(m_resources->compositeOpId());
             indirect->setTemporaryOpacity(m_resources->opacity());
             indirect->setTemporarySelection(selection);
 
             QBitArray channelLockFlags = m_resources->channelLockFlags();
             indirect->setTemporaryChannelFlags(channelLockFlags);
         }
         else {
             hasIndirectPainting = false;
         }
     }
     if(m_useMergeID){
         m_transaction = new KisTransaction(name(), targetDevice,0,timedID(this->id()));
     }
     else{
         m_transaction = new KisTransaction(name(), targetDevice);
     }
 
 
 
     initPainters(targetDevice, selection, hasIndirectPainting, indirectPaintingCompositeOp());
 
     m_targetDevice = targetDevice;
     m_activeSelection = selection;
 
     // sanity check: selection should be applied only once
     if (selection && !m_painterInfos.isEmpty()) {
         KisIndirectPaintingSupport *indirect =
             dynamic_cast<KisIndirectPaintingSupport*>(node.data());
         KIS_ASSERT_RECOVER_RETURN(hasIndirectPainting || m_painterInfos.first()->painter->selection());
         KIS_ASSERT_RECOVER_RETURN(!hasIndirectPainting || !indirect->temporarySelection() || !m_painterInfos.first()->painter->selection());
     }
 }
 
 void KisPainterBasedStrokeStrategy::finishStrokeCallback()
 {
     KisNodeSP node = m_resources->currentNode();
     KisIndirectPaintingSupport *indirect =
         dynamic_cast<KisIndirectPaintingSupport*>(node.data());
 
     KisPostExecutionUndoAdapter *undoAdapter =
         m_resources->postExecutionUndoAdapter();
 
     QScopedPointer<KisPostExecutionUndoAdapter> dumbUndoAdapter;
     QScopedPointer<KisUndoStore> dumbUndoStore;
 
     if (!undoAdapter) {
         dumbUndoStore.reset(new KisDumbUndoStore());
         dumbUndoAdapter.reset(new KisPostExecutionUndoAdapter(dumbUndoStore.data(), 0));
 
         undoAdapter = dumbUndoAdapter.data();
     }
 
 
     if (indirect && indirect->hasTemporaryTarget()) {
         KUndo2MagicString transactionText = m_transaction->text();
         m_transaction->end();
         if(m_useMergeID){
             indirect->mergeToLayer(node,
                                    undoAdapter,
                                    transactionText,timedID(this->id()));
         }
         else{
             indirect->mergeToLayer(node,
                                    undoAdapter,
                                    transactionText);
         }
     }
     else {
         m_transaction->commit(undoAdapter);
     }
     delete m_transaction;
     deletePainters();
 }
 
 void KisPainterBasedStrokeStrategy::cancelStrokeCallback()
 {
     KisNodeSP node = m_resources->currentNode();
     KisIndirectPaintingSupport *indirect =
         dynamic_cast<KisIndirectPaintingSupport*>(node.data());
 
     bool revert = true;
     if (indirect) {
         KisPaintDeviceSP t = indirect->temporaryTarget();
         if (t) {
             delete m_transaction;
             deletePainters();
 
             QRegion region = t->region();
             indirect->setTemporaryTarget(0);
             node->setDirty(region);
             revert = false;
         }
     }
 
     if (revert) {
         m_transaction->revert();
         delete m_transaction;
         deletePainters();
     }
 }
 
 void KisPainterBasedStrokeStrategy::suspendStrokeCallback()
 {
     KisNodeSP node = m_resources->currentNode();
     KisIndirectPaintingSupport *indirect =
         dynamic_cast<KisIndirectPaintingSupport*>(node.data());
 
     if(indirect && indirect->hasTemporaryTarget()) {
         indirect->setTemporaryTarget(0);
     }
 }
 
 void KisPainterBasedStrokeStrategy::resumeStrokeCallback()
 {
     KisNodeSP node = m_resources->currentNode();
     KisIndirectPaintingSupport *indirect =
         dynamic_cast<KisIndirectPaintingSupport*>(node.data());
 
     if(indirect) {
         // todo: don't ask about paint device
         if (node->paintDevice() != m_targetDevice) {
             indirect->setTemporaryTarget(m_targetDevice);
             indirect->setTemporaryCompositeOp(m_resources->compositeOpId());
             indirect->setTemporaryOpacity(m_resources->opacity());
             indirect->setTemporarySelection(m_activeSelection);
         }
     }
 }
diff --git a/libs/ui/tool/strokes/kis_painter_based_stroke_strategy.h b/libs/ui/tool/strokes/kis_painter_based_stroke_strategy.h
index ab5540b5d1..56d20aa484 100644
--- a/libs/ui/tool/strokes/kis_painter_based_stroke_strategy.h
+++ b/libs/ui/tool/strokes/kis_painter_based_stroke_strategy.h
@@ -1,110 +1,110 @@
 /*
  *  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_PAINTER_BASED_STROKE_STRATEGY_H
 #define __KIS_PAINTER_BASED_STROKE_STRATEGY_H
 
 #include "kis_simple_stroke_strategy.h"
 #include "kis_resources_snapshot.h"
 #include "kis_selection.h"
 
 class KisPainter;
 class KisDistanceInformation;
 class KisTransaction;
 
 
 class KRITAUI_EXPORT KisPainterBasedStrokeStrategy : public KisSimpleStrokeStrategy
 {
 public:
     /**
      * The distance information should be associated with each
      * painter individually, so we strore and manipulate with
      * them together using the structure PainterInfo
      */
     class KRITAUI_EXPORT PainterInfo {
     public:
         PainterInfo();
-        PainterInfo(const QPointF &lastPosition, int lastTime);
+        PainterInfo(const QPointF &lastPosition, int lastTime, qreal lastAngle);
         PainterInfo(PainterInfo *rhs, int levelOfDetail);
         ~PainterInfo();
 
         KisPainter *painter;
         KisDistanceInformation *dragDistance;
 
         /**
          * The distance inforametion of the associated LodN
          * stroke. Returns zero if LodN stroke has already finished
          * execution or does not exist.
          */
         KisDistanceInformation* buddyDragDistance();
 
     private:
         PainterInfo *m_parentPainterInfo;
         PainterInfo *m_childPainterInfo;
     };
 
 public:
     KisPainterBasedStrokeStrategy(const QString &id,
                                   const KUndo2MagicString &name,
                                   KisResourcesSnapshotSP resources,
                                   QVector<PainterInfo*> painterInfos,bool useMergeID = false);
 
     KisPainterBasedStrokeStrategy(const QString &id,
                                   const KUndo2MagicString &name,
                                   KisResourcesSnapshotSP resources,
                                   PainterInfo *painterInfo,bool useMergeID = false);
 
     void initStrokeCallback() override;
     void finishStrokeCallback() override;
     void cancelStrokeCallback() override;
 
     void suspendStrokeCallback() override;
     void resumeStrokeCallback() override;
 
 protected:
     KisPaintDeviceSP targetDevice() const;
     KisSelectionSP activeSelection() const;
     const QVector<PainterInfo*> painterInfos() const;
 
     void setUndoEnabled(bool value);
 
 protected:
     KisPainterBasedStrokeStrategy(const KisPainterBasedStrokeStrategy &rhs, int levelOfDetail);
 
 private:
     void init();
     void initPainters(KisPaintDeviceSP targetDevice,
                       KisSelectionSP selection,
                       bool hasIndirectPainting,
                       const QString &indirectPaintingCompositeOp);
     void deletePainters();
     inline int timedID(const QString &id){
         return int(qHash(id));
     }
 
 private:
     KisResourcesSnapshotSP m_resources;
     QVector<PainterInfo*> m_painterInfos;
     KisTransaction *m_transaction;
 
     KisPaintDeviceSP m_targetDevice;
     KisSelectionSP m_activeSelection;
     bool m_useMergeID;
 };
 
 #endif /* __KIS_PAINTER_BASED_STROKE_STRATEGY_H */
diff --git a/libs/ui/widgets/kis_scratch_pad.cpp b/libs/ui/widgets/kis_scratch_pad.cpp
index 89d7dce416..b18fa65da0 100644
--- a/libs/ui/widgets/kis_scratch_pad.cpp
+++ b/libs/ui/widgets/kis_scratch_pad.cpp
@@ -1,469 +1,471 @@
 /* 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);
+    setMouseTracking(true);
 
     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)
 {
+    m_helper->cursorMoved(documentToWidget().map(event->point));
     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,
+                        documentToWidget().map(event->point),
                         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/chalk/kis_chalk_paintop.cpp b/plugins/paintops/chalk/kis_chalk_paintop.cpp
index 504e6e48a3..fa43ff9910 100644
--- a/plugins/paintops/chalk/kis_chalk_paintop.cpp
+++ b/plugins/paintops/chalk/kis_chalk_paintop.cpp
@@ -1,91 +1,97 @@
 /*
  *  Copyright (c) 2008-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_chalk_paintop.h"
 #include "kis_chalk_paintop_settings.h"
 
 #include <cmath>
 #include <QRect>
 
 #include <KoColor.h>
 #include <KoColorSpace.h>
 
 #include <kis_image.h>
 #include <kis_debug.h>
 
 #include <kis_global.h>
 #include <kis_paint_device.h>
 #include <kis_painter.h>
 #include <kis_types.h>
 #include <brushengine/kis_paintop.h>
 #include <brushengine/kis_paint_information.h>
 
 #include <kis_pressure_opacity_option.h>
 #include <kis_lod_transform.h>
+#include <kis_paintop_plugin_utils.h>
 
 
 KisChalkPaintOp::KisChalkPaintOp(const KisPaintOpSettingsSP settings, KisPainter * painter, KisNodeSP node, KisImageSP image)
     : KisPaintOp(painter)
 {
     Q_UNUSED(image);
     Q_UNUSED(node);
+    m_airbrushOption.readOptionSetting(settings);
     m_opacityOption.readOptionSetting(settings);
+    m_rateOption.readOptionSetting(settings);
     m_opacityOption.resetAllSensors();
+    m_rateOption.resetAllSensors();
 
     m_properties.readOptionSetting(settings);
 
     KoColorTransformation* transfo = 0;
     if (m_properties.inkDepletion && m_properties.useSaturation) {
         transfo = painter->device()->compositionSourceColorSpace()->createColorTransformation("hsv_adjustment", QHash<QString, QVariant>());
     }
     m_chalkBrush = new ChalkBrush(&m_properties, transfo);
 }
 
 KisChalkPaintOp::~KisChalkPaintOp()
 {
     delete m_chalkBrush;
 }
 
 KisSpacingInformation KisChalkPaintOp::paintAt(const KisPaintInformation& info)
 {
     if (!painter()) return KisSpacingInformation(1.0);
 
     if (!m_dab) {
         m_dab = source()->createCompositionSourceDevice();
     }
     else {
         m_dab->clear();
     }
 
     qreal x1, y1;
 
     x1 = info.pos().x();
     y1 = info.pos().y();
 
     const qreal additionalScale = KisLodTransform::lodToScale(painter()->device());
 
     quint8 origOpacity = m_opacityOption.apply(painter(), info);
     m_chalkBrush->paint(m_dab, x1, y1, painter()->paintColor(), additionalScale);
 
     QRect rc = m_dab->extent();
 
     painter()->bitBlt(rc.x(), rc.y(), m_dab, rc.x(), rc.y(), rc.width(), rc.height());
     painter()->renderMirrorMask(rc, m_dab);
     painter()->setOpacity(origOpacity);
-    return KisSpacingInformation(1.0);
+
+    return KisPaintOpPluginUtils::effectiveSpacing(1.0, 1.0, true, 0.0, false, 1.0, false, 1.0, 1.0,
+                                                   &m_airbrushOption, nullptr, &m_rateOption, info);
 }
diff --git a/plugins/paintops/chalk/kis_chalk_paintop.h b/plugins/paintops/chalk/kis_chalk_paintop.h
index b94d4bdbef..da42438918 100644
--- a/plugins/paintops/chalk/kis_chalk_paintop.h
+++ b/plugins/paintops/chalk/kis_chalk_paintop.h
@@ -1,48 +1,52 @@
 /*
  *  Copyright (c) 2008 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2008, 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.
  */
 
 #ifndef KIS_CHALK_PAINTOP_H_
 #define KIS_CHALK_PAINTOP_H_
 
 #include <brushengine/kis_paintop.h>
 #include <kis_types.h>
 
 #include "chalk_brush.h"
 #include "kis_chalk_paintop_settings.h"
+#include "kis_airbrush_option.h"
+#include "kis_pressure_rate_option.h"
 
 class KisPainter;
 
 class KisChalkPaintOp : public KisPaintOp
 {
 
 public:
 
     KisChalkPaintOp(const KisPaintOpSettingsSP settings, KisPainter *painter, KisNodeSP node, KisImageSP image);
     ~KisChalkPaintOp() override;
 
     KisSpacingInformation paintAt(const KisPaintInformation& info) override;
 
 private:
     KisPaintDeviceSP m_dab;
     ChalkBrush * m_chalkBrush;
+    KisAirbrushOption m_airbrushOption;
     KisPressureOpacityOption m_opacityOption;
+    KisPressureRateOption m_rateOption;
     ChalkProperties m_properties;
 };
 
 #endif // KIS_CHALK_PAINTOP_H_
diff --git a/plugins/paintops/chalk/kis_chalk_paintop_settings.cpp b/plugins/paintops/chalk/kis_chalk_paintop_settings.cpp
index e4c3188749..2409d03618 100644
--- a/plugins/paintops/chalk/kis_chalk_paintop_settings.cpp
+++ b/plugins/paintops/chalk/kis_chalk_paintop_settings.cpp
@@ -1,74 +1,64 @@
 /*
  *  Copyright (c) 2008 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_chalk_paintop_settings.h"
 
 #include <kis_chalkop_option.h>
 
 #include <kis_paint_action_type_option.h>
 #include <kis_airbrush_option.h>
 
 KisChalkPaintOpSettings::KisChalkPaintOpSettings()
 {
 }
 
 bool KisChalkPaintOpSettings::paintIncremental()
 {
     return (enumPaintActionType)getInt("PaintOpAction", WASH) == BUILDUP;
 }
 
-bool KisChalkPaintOpSettings::isAirbrushing() const
-{
-    return getBool(AIRBRUSH_ENABLED);
-}
-
-int KisChalkPaintOpSettings::rate() const
-{
-    return getInt(AIRBRUSH_RATE);
-}
-
 QPainterPath KisChalkPaintOpSettings::brushOutline(const KisPaintInformation &info, OutlineMode mode)
 {
     QPainterPath path;
     if (mode == CursorIsOutline || mode == CursorIsCircleOutline || mode == CursorTiltOutline) {
         qreal size = getInt(CHALK_RADIUS) * 2 + 1;
         path = ellipseOutline(size, size, 1.0, 0.0);
 
         if (mode == CursorTiltOutline) {
             path.addPath(makeTiltIndicator(info, QPointF(0.0, 0.0), size * 0.5, 3.0));
         }
 
         path.translate(info.pos());
     }
     return path;
 }
 
 void KisChalkPaintOpSettings::setPaintOpSize(qreal value)
 {
     ChalkProperties properties;
     properties.readOptionSetting(this);
     properties.radius = qRound(0.5 * value);
     properties.writeOptionSetting(this);
 }
 
 qreal KisChalkPaintOpSettings::paintOpSize() const
 {
     ChalkProperties properties;
     properties.readOptionSetting(this);
     return properties.radius * 2;
 }
diff --git a/plugins/paintops/chalk/kis_chalk_paintop_settings.h b/plugins/paintops/chalk/kis_chalk_paintop_settings.h
index 808d8c5c66..3096f50727 100644
--- a/plugins/paintops/chalk/kis_chalk_paintop_settings.h
+++ b/plugins/paintops/chalk/kis_chalk_paintop_settings.h
@@ -1,48 +1,45 @@
 /*
  *  Copyright (c) 2008,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.
  */
 
 #ifndef KIS_CHALK_PAINTOP_SETTINGS_H_
 #define KIS_CHALK_PAINTOP_SETTINGS_H_
 
 #include <brushengine/kis_paintop_settings.h>
 #include <kis_types.h>
 
 #include "kis_chalk_paintop_settings_widget.h"
 
 #include <kis_pressure_opacity_option.h>
 
 
 class KisChalkPaintOpSettings : public KisPaintOpSettings
 {
 
 public:
     KisChalkPaintOpSettings();
     ~KisChalkPaintOpSettings() override {}
 
     QPainterPath brushOutline(const KisPaintInformation &info, OutlineMode mode) override;
 
     void setPaintOpSize(qreal value) override;
     qreal paintOpSize() const override;
 
     bool paintIncremental() override;
-    bool isAirbrushing() const override;
-    int rate() const override;
-
 };
 
 #endif
diff --git a/plugins/paintops/chalk/kis_chalk_paintop_settings_widget.cpp b/plugins/paintops/chalk/kis_chalk_paintop_settings_widget.cpp
index 93010fc283..d57d7c8ee7 100644
--- a/plugins/paintops/chalk/kis_chalk_paintop_settings_widget.cpp
+++ b/plugins/paintops/chalk/kis_chalk_paintop_settings_widget.cpp
@@ -1,52 +1,54 @@
 /*
  *  Copyright (c) 2008 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_chalk_paintop_settings_widget.h"
 
 #include "kis_chalkop_option.h"
 #include "kis_chalk_paintop_settings.h"
 
 #include <kis_curve_option_widget.h>
 #include <kis_pressure_opacity_option.h>
+#include <kis_pressure_rate_option.h>
 
 #include <kis_paintop_settings_widget.h>
 #include <kis_paint_action_type_option.h>
 #include <kis_airbrush_option.h>
 
 KisChalkPaintOpSettingsWidget:: KisChalkPaintOpSettingsWidget(QWidget* parent)
     : KisPaintOpSettingsWidget(parent)
 {
     m_chalkOption = new KisChalkOpOption();
     addPaintOpOption(m_chalkOption, i18n("Brush size"));
     addPaintOpOption(new KisCurveOptionWidget(new KisPressureOpacityOption(), i18n("Transparent"), i18n("Opaque")), i18n("Opacity"));
     addPaintOpOption(new KisAirbrushOption(false), i18n("Airbrush"));
+    addPaintOpOption(new KisCurveOptionWidget(new KisPressureRateOption(), i18n("0%"), i18n("100%")), i18n("Rate"));
     addPaintOpOption(new KisPaintActionTypeOption(), i18n("Painting Mode"));
 }
 
 KisChalkPaintOpSettingsWidget::~ KisChalkPaintOpSettingsWidget()
 {
 }
 
 KisPropertiesConfigurationSP  KisChalkPaintOpSettingsWidget::configuration() const
 {
     KisChalkPaintOpSettings* config = new KisChalkPaintOpSettings();
     config->setOptionsWidget(const_cast<KisChalkPaintOpSettingsWidget*>(this));
     config->setProperty("paintop", "chalkbrush"); // XXX: make this a const id string
     writeConfiguration(config);
     return config;
 }
diff --git a/plugins/paintops/defaultpaintops/brush/kis_brushop.cpp b/plugins/paintops/defaultpaintops/brush/kis_brushop.cpp
index e4b7380d1f..76c3f3c49c 100644
--- a/plugins/paintops/defaultpaintops/brush/kis_brushop.cpp
+++ b/plugins/paintops/defaultpaintops/brush/kis_brushop.cpp
@@ -1,193 +1,197 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2004-2008 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2004 Clarence Dang <dang@kde.org>
  *  Copyright (c) 2004 Adrian Page <adrian@pagenet.plus.com>
  *  Copyright (c) 2004 Cyrille Berger <cberger@cberger.net>
  *  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 "kis_brushop.h"
 
 #include <QRect>
 
 #include <kis_image.h>
 #include <kis_vec.h>
 #include <kis_debug.h>
 
 #include <KoColorTransformation.h>
 #include <KoColor.h>
 
 #include <kis_brush.h>
 #include <kis_global.h>
 #include <kis_paint_device.h>
 #include <kis_painter.h>
 #include <kis_brush_based_paintop_settings.h>
 #include <kis_color_source.h>
 #include <kis_pressure_sharpness_option.h>
 #include <kis_fixed_paint_device.h>
 #include <kis_lod_transform.h>
 
 
 KisBrushOp::KisBrushOp(const KisPaintOpSettingsSP settings, KisPainter *painter, KisNodeSP node, KisImageSP image)
     : KisBrushBasedPaintOp(settings, painter)
     , m_opacityOption(node)
     , m_hsvTransformation(0)
 {
     Q_UNUSED(image);
     Q_ASSERT(settings);
 
     KisColorSourceOption colorSourceOption;
     colorSourceOption.readOptionSetting(settings);
     m_colorSource = colorSourceOption.createColorSource(painter);
 
     m_hsvOptions.append(KisPressureHSVOption::createHueOption());
     m_hsvOptions.append(KisPressureHSVOption::createSaturationOption());
     m_hsvOptions.append(KisPressureHSVOption::createValueOption());
 
     Q_FOREACH (KisPressureHSVOption * option, m_hsvOptions) {
         option->readOptionSetting(settings);
         option->resetAllSensors();
         if (option->isChecked() && !m_hsvTransformation) {
             m_hsvTransformation = painter->backgroundColor().colorSpace()->createColorTransformation("hsv_adjustment", QHash<QString, QVariant>());
         }
     }
 
+    m_airbrushOption.readOptionSetting(settings);
+
     m_opacityOption.readOptionSetting(settings);
     m_flowOption.readOptionSetting(settings);
     m_sizeOption.readOptionSetting(settings);
     m_ratioOption.readOptionSetting(settings);
     m_spacingOption.readOptionSetting(settings);
+    m_rateOption.readOptionSetting(settings);
     m_softnessOption.readOptionSetting(settings);
     m_sharpnessOption.readOptionSetting(settings);
     m_darkenOption.readOptionSetting(settings);
     m_rotationOption.readOptionSetting(settings);
     m_mixOption.readOptionSetting(settings);
     m_scatterOption.readOptionSetting(settings);
 
     m_opacityOption.resetAllSensors();
     m_flowOption.resetAllSensors();
     m_sizeOption.resetAllSensors();
     m_ratioOption.resetAllSensors();
+    m_rateOption.resetAllSensors();
     m_softnessOption.resetAllSensors();
     m_sharpnessOption.resetAllSensors();
     m_darkenOption.resetAllSensors();
     m_rotationOption.resetAllSensors();
     m_scatterOption.resetAllSensors();
 
     m_dabCache->setSharpnessPostprocessing(&m_sharpnessOption);
     m_rotationOption.applyFanCornersInfo(this);
 }
 
 KisBrushOp::~KisBrushOp()
 {
     qDeleteAll(m_hsvOptions);
     delete m_colorSource;
     delete m_hsvTransformation;
 }
 
 KisSpacingInformation KisBrushOp::paintAt(const KisPaintInformation& info)
 {
     if (!painter()->device()) return KisSpacingInformation(1.0);
 
     KisBrushSP brush = m_brush;
     Q_ASSERT(brush);
     if (!brush)
         return KisSpacingInformation(1.0);
 
     if (!brush->canPaintFor(info))
         return KisSpacingInformation(1.0);
 
     qreal scale = m_sizeOption.apply(info);
     scale *= KisLodTransform::lodToScale(painter()->device());
     if (checkSizeTooSmall(scale)) return KisSpacingInformation();
 
     qreal rotation = m_rotationOption.apply(info);
     qreal ratio = m_ratioOption.apply(info);
 
     KisPaintDeviceSP device = painter()->device();
 
 
     KisDabShape shape(scale, ratio, rotation);
     QPointF cursorPos =
         m_scatterOption.apply(info,
                               brush->maskWidth(shape, 0, 0, info),
                               brush->maskHeight(shape, 0, 0, info));
 
     quint8 origOpacity = painter()->opacity();
 
     m_opacityOption.setFlow(m_flowOption.apply(info));
     m_opacityOption.apply(painter(), info);
     m_colorSource->selectColor(m_mixOption.apply(info), info);
     m_darkenOption.apply(m_colorSource, info);
 
     if (m_hsvTransformation) {
         Q_FOREACH (KisPressureHSVOption * option, m_hsvOptions) {
             option->apply(m_hsvTransformation, info);
         }
         m_colorSource->applyColorTransformation(m_hsvTransformation);
     }
 
     QRect dabRect;
     KisFixedPaintDeviceSP dab = m_dabCache->fetchDab(device->compositionSourceColorSpace(),
                                 m_colorSource,
                                 cursorPos,
                                 shape,
                                 info,
                                 m_softnessOption.apply(info),
                                 &dabRect);
 
     // sanity check for the size calculation code
     if (dab->bounds().size() != dabRect.size()) {
         warnKrita << "KisBrushOp: dab bounds is not dab rect. See bug 327156" << dab->bounds().size() << dabRect.size();
     }
 
     painter()->bltFixed(dabRect.topLeft(), dab, dab->bounds());
 
     painter()->renderMirrorMaskSafe(dabRect,
                                     dab,
                                     !m_dabCache->needSeparateOriginal());
     painter()->setOpacity(origOpacity);
 
-    return effectiveSpacing(scale, rotation,
-                            m_spacingOption, info);
+    return effectiveSpacing(scale, rotation, &m_airbrushOption, &m_spacingOption, &m_rateOption,
+                            info);
 }
 
 void KisBrushOp::paintLine(const KisPaintInformation& pi1, const KisPaintInformation& pi2, KisDistanceInformation *currentDistance)
 {
     if (m_sharpnessOption.isChecked() && m_brush && (m_brush->width() == 1) && (m_brush->height() == 1)) {
 
         if (!m_lineCacheDevice) {
             m_lineCacheDevice = source()->createCompositionSourceDevice();
         }
         else {
             m_lineCacheDevice->clear();
         }
 
         KisPainter p(m_lineCacheDevice);
         p.setPaintColor(painter()->paintColor());
         p.drawDDALine(pi1.pos(), pi2.pos());
 
         QRect rc = m_lineCacheDevice->extent();
         painter()->bitBlt(rc.x(), rc.y(), m_lineCacheDevice, rc.x(), rc.y(), rc.width(), rc.height());
     //fixes Bug 338011
     painter()->renderMirrorMask(rc, m_lineCacheDevice);
     }
     else {
         KisPaintOp::paintLine(pi1, pi2, currentDistance);
     }
 }
diff --git a/plugins/paintops/defaultpaintops/brush/kis_brushop.h b/plugins/paintops/defaultpaintops/brush/kis_brushop.h
index 473e318284..798ac4856f 100644
--- a/plugins/paintops/defaultpaintops/brush/kis_brushop.h
+++ b/plugins/paintops/defaultpaintops/brush/kis_brushop.h
@@ -1,77 +1,81 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2004-2008 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2004 Clarence Dang <dang@kde.org>
  *  Copyright (c) 2004 Adrian Page <adrian@pagenet.plus.com>
  *  Copyright (c) 2004 Cyrille Berger <cberger@cberger.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_BRUSHOP_H_
 #define KIS_BRUSHOP_H_
 
 #include "kis_brush_based_paintop.h"
+#include <kis_airbrush_option.h>
 #include <kis_pressure_darken_option.h>
 #include <kis_pressure_flow_opacity_option.h>
 #include <kis_pressure_size_option.h>
 #include <kis_pressure_ratio_option.h>
 #include <kis_pressure_flow_option.h>
 #include <kis_pressure_rotation_option.h>
 #include <kis_pressure_mix_option.h>
 #include <kis_pressure_hsv_option.h>
 #include <kis_pressure_scatter_option.h>
 #include <kis_pressure_softness_option.h>
 #include <kis_pressure_sharpness_option.h>
 #include <kis_color_source_option.h>
 #include <kis_pressure_spacing_option.h>
+#include <kis_pressure_rate_option.h>
 #include <kis_brush_based_paintop_settings.h>
 
 class KisPainter;
 class KisColorSource;
 
 
 class KisBrushOp : public KisBrushBasedPaintOp
 {
 
 public:
 
     KisBrushOp(const KisPaintOpSettingsSP settings, KisPainter * painter, KisNodeSP node, KisImageSP image);
     ~KisBrushOp() override;
 
     KisSpacingInformation paintAt(const KisPaintInformation& info) override;
     void paintLine(const KisPaintInformation &pi1, const KisPaintInformation &pi2, KisDistanceInformation *currentDistance) override;
 
 private:
     KisColorSource *m_colorSource;
+    KisAirbrushOption m_airbrushOption;
     KisPressureSizeOption m_sizeOption;
     KisPressureRatioOption m_ratioOption;
     KisPressureSpacingOption m_spacingOption;
+    KisPressureRateOption m_rateOption;
     KisPressureFlowOption m_flowOption;
     KisFlowOpacityOption m_opacityOption;
     KisPressureSoftnessOption m_softnessOption;
     KisPressureSharpnessOption m_sharpnessOption;
     KisPressureDarkenOption m_darkenOption;
     KisPressureRotationOption m_rotationOption;
     KisPressureMixOption m_mixOption;
     KisPressureScatterOption m_scatterOption;
     QList<KisPressureHSVOption*> m_hsvOptions;
 
     KoColorTransformation *m_hsvTransformation;
     KisPaintDeviceSP m_lineCacheDevice;
     KisPaintDeviceSP m_colorSourceDevice;
 };
 
 #endif // KIS_BRUSHOP_H_
diff --git a/plugins/paintops/defaultpaintops/brush/kis_brushop_settings_widget.cpp b/plugins/paintops/defaultpaintops/brush/kis_brushop_settings_widget.cpp
index 6d37dd26e9..bbe667d467 100644
--- a/plugins/paintops/defaultpaintops/brush/kis_brushop_settings_widget.cpp
+++ b/plugins/paintops/defaultpaintops/brush/kis_brushop_settings_widget.cpp
@@ -1,97 +1,99 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2004-2008 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2004 Clarence Dang <dang@kde.org>
  *  Copyright (c) 2004 Adrian Page <adrian@pagenet.plus.com>
  *  Copyright (c) 2004 Cyrille Berger <cberger@cberger.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_brushop_settings_widget.h"
 #include <kis_brush_based_paintop_settings.h>
 #include <kis_pressure_darken_option.h>
 #include <kis_pressure_opacity_option.h>
 #include <kis_pressure_flow_option.h>
 #include <kis_pressure_size_option.h>
 #include <kis_pressure_ratio_option.h>
 #include <kis_paint_action_type_option.h>
 #include <kis_pressure_rotation_option.h>
 #include <kis_pressure_mix_option.h>
 #include <kis_curve_option_widget.h>
 #include <kis_pressure_hsv_option.h>
 #include <kis_airbrush_option.h>
 #include <kis_pressure_scatter_option_widget.h>
 #include <kis_pressure_softness_option.h>
 #include <kis_pressure_sharpness_option_widget.h>
 #include <kis_color_source_option_widget.h>
 #include <kis_compositeop_option.h>
 #include <kis_pressure_flow_opacity_option_widget.h>
 #include <kis_pressure_spacing_option_widget.h>
+#include <kis_pressure_rate_option.h>
 #include "kis_texture_option.h"
 #include "kis_curve_option_widget.h"
 #include <kis_pressure_mirror_option_widget.h>
 #include "kis_pressure_texture_strength_option.h"
 
 
 KisBrushOpSettingsWidget::KisBrushOpSettingsWidget(QWidget* parent)
     : KisBrushBasedPaintopOptionWidget(parent)
 {
     setObjectName("brush option widget");
     setPrecisionEnabled(true);
 
     // Brush tip options
     addPaintOpOption(new KisCompositeOpOption(true), i18n("Blending Mode"));
     addPaintOpOption(new KisFlowOpacityOptionWidget(), i18n("Opacity"));
     addPaintOpOption(new KisCurveOptionWidget(new KisPressureFlowOption(), i18n("0%"), i18n("100%")), i18n("Flow"));
     addPaintOpOption(new KisCurveOptionWidget(new KisPressureSizeOption(), i18n("0%"), i18n("100%")), i18n("Size"));
     addPaintOpOption(new KisCurveOptionWidget(new KisPressureRatioOption(), i18n("0%"), i18n("100%")), i18n("Ratio"));
     addPaintOpOption(new KisPressureSpacingOptionWidget(), i18n("Spacing"));
     addPaintOpOption(new KisPressureMirrorOptionWidget(), i18n("Mirror"));
 
 
     addPaintOpOption(new KisCurveOptionWidget(new KisPressureSoftnessOption(), i18n("Soft"), i18n("Hard")), i18n("Softness"));
     addPaintOpOption(new KisPressureSharpnessOptionWidget(), i18n("Sharpness"));
     addPaintOpOption(new KisCurveOptionWidget(new KisPressureRotationOption(), i18n("-180°"), i18n("180°")), i18n("Rotation"));
     addPaintOpOption(new KisPressureScatterOptionWidget(), i18n("Scatter"));
 
     // Colors options
     addPaintOpOption(new KisColorSourceOptionWidget(), i18n("Source"));
     addPaintOpOption(new KisCurveOptionWidget(new KisPressureDarkenOption(), i18n("0.0"), i18n("1.0")), i18n("Darken"));
     addPaintOpOption(new KisCurveOptionWidget(new KisPressureMixOption(), i18n("Foreground"), i18n("Background")), i18n("Mix"));
     addPaintOpOption(new KisCurveOptionWidget(KisPressureHSVOption::createHueOption(), KisPressureHSVOption::hueMinLabel(), KisPressureHSVOption::huemaxLabel()), i18n("Hue"));
     addPaintOpOption(new KisCurveOptionWidget(KisPressureHSVOption::createSaturationOption(), KisPressureHSVOption::saturationMinLabel(), KisPressureHSVOption::saturationmaxLabel()), i18n("Saturation"));
     addPaintOpOption(new KisCurveOptionWidget(KisPressureHSVOption::createValueOption(), KisPressureHSVOption::valueMinLabel(), KisPressureHSVOption::valuemaxLabel()), i18n("Value"));
     addPaintOpOption(new KisAirbrushOption(false), i18n("Airbrush"));
+    addPaintOpOption(new KisCurveOptionWidget(new KisPressureRateOption(), i18n("0%"), i18n("100%")), i18n("Rate"));
     addPaintOpOption(new KisPaintActionTypeOption(), i18n("Painting Mode"));
 
     addPaintOpOption(new KisTextureOption(), i18n("Pattern"));
     addPaintOpOption(new KisCurveOptionWidget(new KisPressureTextureStrengthOption(), i18n("Weak"), i18n("Strong")), i18n("Strength"));
 
 }
 
 KisBrushOpSettingsWidget::~KisBrushOpSettingsWidget()
 {
 }
 
 KisPropertiesConfigurationSP KisBrushOpSettingsWidget::configuration() const
 {
     KisBrushBasedPaintOpSettingsSP config = new KisBrushBasedPaintOpSettings();
     config->setOptionsWidget(const_cast<KisBrushOpSettingsWidget*>(this));
     config->setProperty("paintop", "paintbrush"); // XXX: make this a const id string
     writeConfiguration(config);
     return config;
 }
 
diff --git a/plugins/paintops/deform/kis_deform_paintop.cpp b/plugins/paintops/deform/kis_deform_paintop.cpp
index 6cea8bbf43..66d8d1adf8 100644
--- a/plugins/paintops/deform/kis_deform_paintop.cpp
+++ b/plugins/paintops/deform/kis_deform_paintop.cpp
@@ -1,145 +1,153 @@
 /*
  *  Copyright (c) 2008-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.h"
 #include "kis_deform_paintop_settings.h"
 
 #include <cmath>
 
 #include <QtGlobal>
 #include <QRect>
 
 #include <kis_image.h>
 #include <kis_debug.h>
 
 #include "kis_global.h"
 #include "kis_paint_device.h"
 #include "kis_painter.h"
 #include "kis_selection.h"
 #include "kis_random_accessor_ng.h"
+#include "kis_lod_transform.h"
 
 #include <kis_fixed_paint_device.h>
 
 #include "kis_deform_option.h"
 #include "kis_brush_size_option.h"
+#include "kis_paintop_plugin_utils.h"
 #include <KoColorSpaceRegistry.h>
 #include <KoCompositeOp.h>
 
 #ifdef Q_OS_WIN
 // quoting DRAND48(3) man-page:
 // These functions are declared obsolete by  SVID  3,
 // which  states  that rand(3) should be used instead.
 #define drand48() (static_cast<double>(qrand()) / static_cast<double>(RAND_MAX))
 #endif
 
 KisDeformPaintOp::KisDeformPaintOp(const KisPaintOpSettingsSP settings, KisPainter * painter, KisNodeSP node, KisImageSP image)
     : KisPaintOp(painter)
 {
     Q_UNUSED(image);
     Q_UNUSED(node);
     Q_ASSERT(settings);
 
     m_sizeProperties.readOptionSetting(settings);
     m_properties.readOptionSetting(settings);
+    m_airbrushOption.readOptionSetting(settings);
 
     // sensors
     m_sizeOption.readOptionSetting(settings);
     m_opacityOption.readOptionSetting(settings);
     m_rotationOption.readOptionSetting(settings);
+    m_rateOption.readOptionSetting(settings);
     m_sizeOption.resetAllSensors();
     m_opacityOption.resetAllSensors();
     m_rotationOption.resetAllSensors();
+    m_rateOption.resetAllSensors();
 
     m_deformBrush.setProperties(&m_properties);
     m_deformBrush.setSizeProperties(&m_sizeProperties);
 
     m_deformBrush.initDeformAction();
 
     m_dev = source();
 
     if ((m_sizeProperties.brush_diameter * 0.5) > 1) {
         m_ySpacing = m_xSpacing = m_sizeProperties.brush_diameter * 0.5 * m_sizeProperties.brush_spacing;
     }
     else {
         m_ySpacing = m_xSpacing = 1.0;
     }
     m_spacing = m_xSpacing;
 
 
 
 }
 
 KisDeformPaintOp::~KisDeformPaintOp()
 {
 }
 
 KisSpacingInformation KisDeformPaintOp::paintAt(const KisPaintInformation& info)
 {
     if (!painter()) return KisSpacingInformation(m_spacing);
     if (!m_dev) return KisSpacingInformation(m_spacing);
 
     KisFixedPaintDeviceSP dab = cachedDab(source()->compositionSourceColorSpace());
 
     qint32 x;
     qreal subPixelX;
     qint32 y;
     qreal subPixelY;
 
     QPointF pt = info.pos();
     if (m_sizeProperties.brush_jitter_movement_enabled) {
         pt.setX(pt.x() + ((m_sizeProperties.brush_diameter * drand48()) - m_sizeProperties.brush_diameter * 0.5) * m_sizeProperties.brush_jitter_movement);
         pt.setY(pt.y() + ((m_sizeProperties.brush_diameter * drand48()) - m_sizeProperties.brush_diameter * 0.5) * m_sizeProperties.brush_jitter_movement);
     }
 
     qreal rotation = m_rotationOption.apply(info);
 
     // Deform Brush is capable of working with zero scale,
     // so no additional checks for 'zero'ness are needed
     qreal scale = m_sizeOption.apply(info);
 
 
     rotation += m_sizeProperties.brush_rotation;
     scale *= m_sizeProperties.brush_scale;
 
     QPointF pos = pt - m_deformBrush.hotSpot(scale, rotation);
 
     splitCoordinate(pos.x(), &x, &subPixelX);
     splitCoordinate(pos.y(), &y, &subPixelY);
 
     KisFixedPaintDeviceSP mask = m_deformBrush.paintMask(dab, m_dev,
                                  scale, rotation,
                                  info.pos(),
                                  subPixelX, subPixelY,
                                  x, y
                                                         );
 
     // this happens for the first dab of the move mode, we need more information for being able to move
     if (!mask) {
         return KisSpacingInformation(m_spacing);
     }
 
     quint8 origOpacity = m_opacityOption.apply(painter(), info);
     painter()->bltFixedWithFixedSelection(x, y, dab, mask, mask->bounds().width() , mask->bounds().height());
     painter()->renderMirrorMask(QRect(QPoint(x, y), QSize(mask->bounds().width() , mask->bounds().height())), dab, mask);
     painter()->setOpacity(origOpacity);
 
-    return KisSpacingInformation(m_spacing);
+    return KisPaintOpPluginUtils::effectiveSpacing(1.0, 1.0, true, 0.0, false, m_spacing, false,
+                                                   1.0,
+                                                   KisLodTransform::lodToScale(painter()->device()),
+                                                   &m_airbrushOption, nullptr, &m_rateOption, info);
 }
 
 
 
diff --git a/plugins/paintops/deform/kis_deform_paintop.h b/plugins/paintops/deform/kis_deform_paintop.h
index b2e80cd08d..7a65684bb3 100644
--- a/plugins/paintops/deform/kis_deform_paintop.h
+++ b/plugins/paintops/deform/kis_deform_paintop.h
@@ -1,63 +1,68 @@
 /*
  *  Copyright (c) 2008,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.
  */
 
 #ifndef KIS_DEFORMPAINTOP_H_
 #define KIS_DEFORMPAINTOP_H_
 
 #include <brushengine/kis_paintop.h>
 #include <kis_types.h>
 
+#include <kis_airbrush_option.h>
 #include <kis_pressure_size_option.h>
 #include <kis_pressure_opacity_option.h>
 #include <kis_pressure_rotation_option.h>
+#include <kis_pressure_rate_option.h>
 
 #include "deform_brush.h"
 
 #include "kis_deform_paintop_settings.h"
 #include "kis_deform_option.h"
 
 class KisPainter;
 
 class KisDeformPaintOp : public KisPaintOp
 {
 
 public:
     KisDeformPaintOp(const KisPaintOpSettingsSP settings, KisPainter * painter, KisNodeSP node, KisImageSP image);
     ~KisDeformPaintOp() override;
 
     KisSpacingInformation paintAt(const KisPaintInformation& info) override;
 
 private:
 
     KisPaintDeviceSP m_dab;
     KisPaintDeviceSP m_dev;
 
     DeformBrush m_deformBrush;
     DeformOption m_properties;
     BrushSizeOption m_sizeProperties;
 
+    KisAirbrushOption m_airbrushOption;
+
     KisPressureSizeOption m_sizeOption;
     KisPressureOpacityOption m_opacityOption;
     KisPressureRotationOption m_rotationOption;
+    KisPressureRateOption m_rateOption;
 
     qreal m_xSpacing;
     qreal m_ySpacing;
     qreal m_spacing;
 };
 
 #endif // KIS_DEFORMPAINTOP_H_
diff --git a/plugins/paintops/deform/kis_deform_paintop_settings.cpp b/plugins/paintops/deform/kis_deform_paintop_settings.cpp
index 7cb4fa59ea..c04b3e1228 100644
--- a/plugins/paintops/deform/kis_deform_paintop_settings.cpp
+++ b/plugins/paintops/deform/kis_deform_paintop_settings.cpp
@@ -1,245 +1,235 @@
 /*
  *  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);
     }
 }
 
-int KisDeformPaintOpSettings::rate() const
-{
-    if (hasProperty(AIRBRUSH_RATE)) {
-        return getInt(AIRBRUSH_RATE);
-    }
-    else {
-        return KisPaintOpSettings::rate();
-    }
-}
-
 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/deform/kis_deform_paintop_settings.h b/plugins/paintops/deform/kis_deform_paintop_settings.h
index 76484b2748..2139f809a4 100644
--- a/plugins/paintops/deform/kis_deform_paintop_settings.h
+++ b/plugins/paintops/deform/kis_deform_paintop_settings.h
@@ -1,49 +1,48 @@
 /*
  *  Copyright (c) 2008 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2008,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.
  */
 #ifndef KIS_DEFORM_PAINTOP_SETTINGS_H_
 #define KIS_DEFORM_PAINTOP_SETTINGS_H_
 
 #include <QScopedPointer>
 #include <brushengine/kis_paintop_settings.h>
 #include <kis_types.h>
 #include <kis_outline_generation_policy.h>
 
 class KisDeformPaintOpSettings : public KisOutlineGenerationPolicy<KisPaintOpSettings>
 {
 
 public:
     KisDeformPaintOpSettings();
     ~KisDeformPaintOpSettings() override;
 
     void setPaintOpSize(qreal value) override;
     qreal paintOpSize() const override;
 
     QPainterPath brushOutline(const KisPaintInformation &info, OutlineMode mode) override;
 
     bool paintIncremental() override;
     bool isAirbrushing() const override;
-    int rate() const override;
 
     QList<KisUniformPaintOpPropertySP> uniformProperties(KisPaintOpSettingsSP settings) override;
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 #endif
diff --git a/plugins/paintops/deform/kis_deform_paintop_settings_widget.cpp b/plugins/paintops/deform/kis_deform_paintop_settings_widget.cpp
index 75276ec58c..2dcee3099e 100644
--- a/plugins/paintops/deform/kis_deform_paintop_settings_widget.cpp
+++ b/plugins/paintops/deform/kis_deform_paintop_settings_widget.cpp
@@ -1,61 +1,63 @@
 /*
  *  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_deform_option.h"
 
 #include <kis_paintop_settings_widget.h>
 #include <kis_brush_size_option.h>
 
 #include <kis_pressure_rotation_option.h>
 #include <kis_pressure_opacity_option.h>
 #include <kis_pressure_size_option.h>
+#include <kis_pressure_rate_option.h>
 #include <kis_curve_option_widget.h>
 #include <kis_airbrush_option.h>
 #include <kis_compositeop_option.h>
 
 KisDeformPaintOpSettingsWidget::KisDeformPaintOpSettingsWidget(QWidget* parent)
     : KisPaintOpSettingsWidget(parent)
 {
     m_deformOption = new KisDeformOption();
     m_brushSizeOption = new KisBrushSizeOption();
     m_brushSizeOption->setDiameter(200);
 
     addPaintOpOption(m_brushSizeOption, i18n("Brush size"));
     addPaintOpOption(m_deformOption, i18n("Deform Options"));
     addPaintOpOption(new KisCompositeOpOption(true), i18n("Blending Mode"));
     addPaintOpOption(new KisCurveOptionWidget(new KisPressureOpacityOption(), i18n("Transparent"), i18n("Opaque")), i18n("Opacity"));
     addPaintOpOption(new KisCurveOptionWidget(new KisPressureSizeOption(), i18n("0%"), i18n("100%")), i18n("Size"));
     addPaintOpOption(new KisCurveOptionWidget(new KisPressureRotationOption(), i18n("-180°"), i18n("180°")), i18n("Rotation"));
-    addPaintOpOption(new KisAirbrushOption(), i18n("Airbrush"));
+    addPaintOpOption(new KisAirbrushOption(false), i18n("Airbrush"));
+    addPaintOpOption(new KisCurveOptionWidget(new KisPressureRateOption(), i18n("0%"), i18n("100%")), i18n("Rate"));
 }
 
 KisDeformPaintOpSettingsWidget::~ KisDeformPaintOpSettingsWidget()
 {
 }
 
 
 KisPropertiesConfigurationSP KisDeformPaintOpSettingsWidget::configuration() const
 {
     KisDeformPaintOpSettings* config = new KisDeformPaintOpSettings();
     config->setOptionsWidget(const_cast<KisDeformPaintOpSettingsWidget*>(this));
     config->setProperty("paintop", "deformBrush");
     writeConfiguration(config);
     return config;
 }
 
diff --git a/plugins/paintops/dynadraw/kis_dyna_paintop.cpp b/plugins/paintops/dynadraw/kis_dyna_paintop.cpp
index 1a9a636537..1a868e3e5a 100644
--- a/plugins/paintops/dynadraw/kis_dyna_paintop.cpp
+++ b/plugins/paintops/dynadraw/kis_dyna_paintop.cpp
@@ -1,112 +1,132 @@
 /*
  *  Copyright (c) 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_dyna_paintop.h"
 #include "kis_dyna_paintop_settings.h"
 
 #include <cmath>
 
 #include <QRect>
 
 #include <kis_image.h>
 #include <kis_debug.h>
 
 #include <kis_vec.h>
 #include <kis_global.h>
 #include <kis_paint_device.h>
 #include <kis_painter.h>
 #include <brushengine/kis_paint_information.h>
 #include <kis_types.h>
 #include <brushengine/kis_paintop.h>
 #include <kis_selection.h>
 #include <kis_random_accessor_ng.h>
+#include <kis_paintop_plugin_utils.h>
+#include <kis_lod_transform.h>
 
 #include "kis_dynaop_option.h"
 
 #include "filter.h"
 
 KisDynaPaintOp::KisDynaPaintOp(const KisPaintOpSettingsSP settings, KisPainter * painter, KisNodeSP node, KisImageSP image)
     : KisPaintOp(painter)
 {
     Q_UNUSED(node);
 
     if (image) {
         m_dynaBrush.setCanvasSize(image->width(), image->height());
     }
     else {
         // some dummy values for scratchpad
         m_dynaBrush.setCanvasSize(1000, 1000);
     }
 
     m_properties.initWidth = settings->getDouble(DYNA_WIDTH);
     m_properties.action = settings->getDouble(DYNA_ACTION);
     m_properties.mass = settings->getDouble(DYNA_MASS);
     m_properties.drag = settings->getDouble(DYNA_DRAG);
 
     double angle = settings->getDouble(DYNA_ANGLE);
     m_properties.xAngle = cos(angle * M_PI / 180.0);
     m_properties.yAngle = sin(angle * M_PI / 180.0);
 
     m_properties.widthRange = settings->getDouble(DYNA_WIDTH_RANGE);
     m_properties.diameter = settings->getInt(DYNA_DIAMETER);
     m_properties.lineCount = settings->getInt(DYNA_LINE_COUNT);
     m_properties.lineSpacing = settings->getDouble(DYNA_LINE_SPACING);
     m_properties.enableLine = settings->getBool(DYNA_ENABLE_LINE);
     m_properties.useTwoCircles = settings->getBool(DYNA_USE_TWO_CIRCLES);
     m_properties.useFixedAngle = settings->getBool(DYNA_USE_FIXED_ANGLE);
 
     m_dynaBrush.setProperties(&m_properties);
+
+    m_airbrushOption.readOptionSetting(settings);
+
+    m_rateOption.readOptionSetting(settings);
+    m_rateOption.resetAllSensors();
 }
 
 KisDynaPaintOp::~KisDynaPaintOp()
 {
 }
 
-void KisDynaPaintOp::paintLine(const KisPaintInformation &pi1, const KisPaintInformation &pi2, KisDistanceInformation *currentDistance)
+void KisDynaPaintOp::paintLine(const KisPaintInformation &pi1, const KisPaintInformation &pi2,
+                                 KisDistanceInformation *currentDistance)
+{
+    // Use superclass behavior for lines of zero length. Otherwise, airbrushing can happen faster
+    // than it is supposed to.
+    if (pi1.pos() == pi2.pos()) {
+        KisPaintOp::paintLine(pi1, pi2, currentDistance);
+    }
+    else {
+        doPaintLine(pi1, pi2);
+    }
+}
+
+void KisDynaPaintOp::doPaintLine(const KisPaintInformation &pi1, const KisPaintInformation &pi2)
 {
-    Q_UNUSED(currentDistance);
     Q_UNUSED(pi2);
     if (!painter()) return;
 
     if (!m_dab) {
         m_dab = source()->createCompositionSourceDevice();
     }
     else {
         m_dab->clear();
     }
 
     qreal x1, y1;
 
     x1 = pi1.pos().x();
     y1 = pi1.pos().y();
 
     m_dynaBrush.updateCursorPosition(pi1.pos());
     m_dynaBrush.paint(m_dab, x1, y1, painter()->paintColor());
 
     QRect rc = m_dab->extent();
 
     painter()->bitBlt(rc.topLeft(), m_dab, rc);
     painter()->renderMirrorMask(rc, m_dab);
 }
 
 KisSpacingInformation KisDynaPaintOp::paintAt(const KisPaintInformation& info)
 {
-    KisDistanceInformation di;
-    paintLine(info, info, &di);
-    return di.currentSpacing();
+    doPaintLine(info, info);
+    return KisPaintOpPluginUtils::effectiveSpacing(0.0, 0.0, true, 0.0, false, 0.0, false, 0.0,
+                                                   KisLodTransform::lodToScale(painter()->device()),
+                                                   &m_airbrushOption, nullptr, &m_rateOption, info);
 }
diff --git a/plugins/paintops/dynadraw/kis_dyna_paintop.h b/plugins/paintops/dynadraw/kis_dyna_paintop.h
index f9be4aea7e..70bace33a4 100644
--- a/plugins/paintops/dynadraw/kis_dyna_paintop.h
+++ b/plugins/paintops/dynadraw/kis_dyna_paintop.h
@@ -1,53 +1,60 @@
 /*
  *  Copyright (c) 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.
  */
 
 #ifndef KIS_DYNA_PAINTOP_H_
 #define KIS_DYNA_PAINTOP_H_
 
 #include <klocalizedstring.h>
 #include <brushengine/kis_paintop.h>
 #include <kis_types.h>
 
+#include "kis_airbrush_option.h"
+#include "kis_pressure_rate_option.h"
 #include "dyna_brush.h"
 
 
 class KisPainter;
 class KisDynaPaintOpSettings;
 
 class KisDynaPaintOp : public KisPaintOp
 {
 
 public:
 
     KisDynaPaintOp(const KisPaintOpSettingsSP settings, KisPainter * painter, KisNodeSP node, KisImageSP image);
     ~KisDynaPaintOp() override;
 
     KisSpacingInformation paintAt(const KisPaintInformation& info) override;
     void paintLine(const KisPaintInformation &pi1, const KisPaintInformation &pi2, KisDistanceInformation *currentDistance) override;
 
     virtual bool incremental() const {
         return true;
     }
 
+private:
+    void doPaintLine(const KisPaintInformation &pi1, const KisPaintInformation &pi2);
+
 private:
     KisDynaProperties m_properties;
     KisPaintDeviceSP m_dab;
     DynaBrush m_dynaBrush;
+    KisAirbrushOption m_airbrushOption;
+    KisPressureRateOption m_rateOption;
 };
 
 #endif // KIS_DYNA_PAINTOP_H_
diff --git a/plugins/paintops/dynadraw/kis_dyna_paintop_settings.cpp b/plugins/paintops/dynadraw/kis_dyna_paintop_settings.cpp
index e315b9876b..6636a876a6 100644
--- a/plugins/paintops/dynadraw/kis_dyna_paintop_settings.cpp
+++ b/plugins/paintops/dynadraw/kis_dyna_paintop_settings.cpp
@@ -1,264 +1,254 @@
 /*
  *  Copyright (c) 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_dyna_paintop_settings.h"
 #include <kis_paint_action_type_option.h>
 #include <kis_airbrush_option.h>
 #include "kis_dynaop_option.h"
 #include <kis_config.h>
 
 struct KisDynaPaintOpSettings::Private
 {
     QList<KisUniformPaintOpPropertyWSP> uniformProperties;
 };
 
 KisDynaPaintOpSettings::KisDynaPaintOpSettings()
     : m_d(new Private)
 {
 }
 
 KisDynaPaintOpSettings::~KisDynaPaintOpSettings()
 {
 }
 
 void KisDynaPaintOpSettings::setPaintOpSize(qreal value)
 {
     DynaOption option;
     option.readOptionSetting(this);
     option.dyna_diameter = value;
     option.writeOptionSetting(this);
 }
 
 qreal KisDynaPaintOpSettings::paintOpSize() const
 {
     DynaOption option;
     option.readOptionSetting(this);
 
     return option.dyna_diameter;
 }
 
 bool KisDynaPaintOpSettings::paintIncremental()
 {
     return (enumPaintActionType)getInt("PaintOpAction", WASH) == BUILDUP;
 }
 
-bool KisDynaPaintOpSettings::isAirbrushing() const
-{
-    return getBool(AIRBRUSH_ENABLED);
-}
-
-int KisDynaPaintOpSettings::rate() const
-{
-    return getInt(AIRBRUSH_RATE);
-}
-
 
 #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_standard_uniform_properties_factory.h"
 
 
 QList<KisUniformPaintOpPropertySP> KisDynaPaintOpSettings::uniformProperties(KisPaintOpSettingsSP settings)
 {
     QList<KisUniformPaintOpPropertySP> props =
         listWeakToStrong(m_d->uniformProperties);
 
     if (props.isEmpty()) {
         {
             KisIntSliderBasedPaintOpPropertyCallback *prop =
                 new KisIntSliderBasedPaintOpPropertyCallback(
                     KisIntSliderBasedPaintOpPropertyCallback::Int,
                     "dyna_diameter",
                     i18n("Diameter"),
                     settings, 0);
 
             prop->setRange(0, KisConfig().readEntry("maximumBrushSize", 1000));
             prop->setSingleStep(1);
             prop->setSuffix(i18n(" px"));
 
             prop->setReadCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     DynaOption option;
                     option.readOptionSetting(prop->settings().data());
 
                     prop->setValue(option.dyna_diameter);
                 });
             prop->setWriteCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     DynaOption option;
                     option.readOptionSetting(prop->settings().data());
                     option.dyna_diameter = prop->value().toInt();
                     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,
                     "dyna_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) {
                     DynaOption option;
                     option.readOptionSetting(prop->settings().data());
 
                     prop->setValue(int(option.dyna_angle));
                 });
             prop->setWriteCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     DynaOption option;
                     option.readOptionSetting(prop->settings().data());
                     option.dyna_angle = prop->value().toInt();
                     option.writeOptionSetting(prop->settings().data());
                 });
             prop->setIsVisibleCallback(
                 [](const KisUniformPaintOpProperty *prop) {
                     DynaOption option;
                     option.readOptionSetting(prop->settings().data());
                     return option.dyna_use_fixed_angle;
                 });
 
             QObject::connect(preset()->updateProxy(), SIGNAL(sigSettingsChanged()), prop, SLOT(requestReadValue()));
             prop->requestReadValue();
             props << toQShared(prop);
         }
         {
             KisDoubleSliderBasedPaintOpPropertyCallback *prop =
                 new KisDoubleSliderBasedPaintOpPropertyCallback(
                     KisDoubleSliderBasedPaintOpPropertyCallback::Double,
                     "dyna_mass",
                     i18n("Mass"),
                     settings, 0);
 
             prop->setRange(0.01, 3);
             prop->setSingleStep(0.01);
             prop->setDecimals(2);
             prop->setExponentRatio(3);
 
             prop->setReadCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     DynaOption option;
                     option.readOptionSetting(prop->settings().data());
                     prop->setValue(option.dyna_mass);
                 });
             prop->setWriteCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     DynaOption option;
                     option.readOptionSetting(prop->settings().data());
                     option.dyna_mass = prop->value().toReal();
                     option.writeOptionSetting(prop->settings().data());
                 });
 
             QObject::connect(preset()->updateProxy(), SIGNAL(sigSettingsChanged()), prop, SLOT(requestReadValue()));
             prop->requestReadValue();
             props << toQShared(prop);
         }
         {
             KisDoubleSliderBasedPaintOpPropertyCallback *prop =
                 new KisDoubleSliderBasedPaintOpPropertyCallback(
                     KisDoubleSliderBasedPaintOpPropertyCallback::Double,
                     "dyna_drag",
                     i18n("Drag"),
                     settings, 0);
 
             prop->setRange(0, 0.99);
             prop->setSingleStep(0.01);
             prop->setDecimals(2);
             prop->setExponentRatio(3);
 
             prop->setReadCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     DynaOption option;
                     option.readOptionSetting(prop->settings().data());
                     prop->setValue(option.dyna_drag);
                 });
             prop->setWriteCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     DynaOption option;
                     option.readOptionSetting(prop->settings().data());
                     option.dyna_drag = 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(
                     "dyna_shape",
                     i18n("Shape"),
                     settings, 0);
 
             QList<QString> shapes;
             shapes << i18n("Circle");
             shapes << i18n("Polygon");
             shapes << i18n("Wire");
             shapes << i18n("Lines");
 
             prop->setItems(shapes);
 
             prop->setReadCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     DynaOption option;
                     option.readOptionSetting(prop->settings().data());
 
                     prop->setValue(option.dyna_action);
                 });
             prop->setWriteCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     DynaOption option;
                     option.readOptionSetting(prop->settings().data());
                     option.dyna_action = 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() == flow.id()) {
 
                 props.prepend(prop);
             }
         }
     }
 
     return props;
 }
diff --git a/plugins/paintops/dynadraw/kis_dyna_paintop_settings.h b/plugins/paintops/dynadraw/kis_dyna_paintop_settings.h
index d2fb762e51..13f4de701f 100644
--- a/plugins/paintops/dynadraw/kis_dyna_paintop_settings.h
+++ b/plugins/paintops/dynadraw/kis_dyna_paintop_settings.h
@@ -1,46 +1,44 @@
 /*
  *  Copyright (c) 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.
  */
 
 #ifndef KIS_DYNA_PAINTOP_SETTINGS_H_
 #define KIS_DYNA_PAINTOP_SETTINGS_H_
 
 #include <QScopedPointer>
 #include <brushengine/kis_paintop_settings.h>
 
 class KisDynaPaintOpSettings : public KisPaintOpSettings
 {
 
 public:
     KisDynaPaintOpSettings();
     ~KisDynaPaintOpSettings() override;
 
     void setPaintOpSize(qreal value) override;
     qreal paintOpSize() const override;
 
     bool paintIncremental() override;
-    bool isAirbrushing() const override;
-    int rate() const override;
 
     QList<KisUniformPaintOpPropertySP> uniformProperties(KisPaintOpSettingsSP settings) override;
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 #endif
diff --git a/plugins/paintops/dynadraw/kis_dyna_paintop_settings_widget.cpp b/plugins/paintops/dynadraw/kis_dyna_paintop_settings_widget.cpp
index 940551fd9a..c5a236becb 100644
--- a/plugins/paintops/dynadraw/kis_dyna_paintop_settings_widget.cpp
+++ b/plugins/paintops/dynadraw/kis_dyna_paintop_settings_widget.cpp
@@ -1,49 +1,53 @@
 /*
  *  Copyright (c) 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_dyna_paintop_settings_widget.h"
 
 #include "kis_dynaop_option.h"
 #include "kis_dyna_paintop_settings.h"
 
 #include <kis_paintop_settings_widget.h>
+#include <kis_curve_option_widget.h>
 #include <kis_paint_action_type_option.h>
 #include <kis_airbrush_option.h>
 #include <kis_compositeop_option.h>
+#include <kis_pressure_rate_option.h>
 #include <klocalizedstring.h>
 
 KisDynaPaintOpSettingsWidget:: KisDynaPaintOpSettingsWidget(QWidget* parent)
     : KisPaintOpSettingsWidget(parent)
 {
     addPaintOpOption(new KisDynaOpOption(), i18n("Brush size"));
     addPaintOpOption(new KisCompositeOpOption(true), i18n("Blending Mode"));
-    addPaintOpOption(new KisAirbrushOption(), i18n("Airbrush"));
+    addPaintOpOption(new KisAirbrushOption(false, false), i18n("Airbrush"));
+    addPaintOpOption(new KisCurveOptionWidget(new KisPressureRateOption(), i18n("0%"),
+                                              i18n("100%")), i18n("Rate"));
     addPaintOpOption(new KisPaintActionTypeOption(), i18n("Painting Mode"));
 }
 
 KisDynaPaintOpSettingsWidget::~ KisDynaPaintOpSettingsWidget()
 {
 }
 
 KisPropertiesConfigurationSP  KisDynaPaintOpSettingsWidget::configuration() const
 {
     KisDynaPaintOpSettings* config = new KisDynaPaintOpSettings();
     config->setOptionsWidget(const_cast<KisDynaPaintOpSettingsWidget*>(this));
     config->setProperty("paintop", "dynabrush"); // XXX: make this a const id string
     writeConfiguration(config);
     return config;
 }
diff --git a/plugins/paintops/libpaintop/CMakeLists.txt b/plugins/paintops/libpaintop/CMakeLists.txt
index 153950f752..7bd94aecc1 100644
--- a/plugins/paintops/libpaintop/CMakeLists.txt
+++ b/plugins/paintops/libpaintop/CMakeLists.txt
@@ -1,99 +1,100 @@
 set(kritalibpaintop_LIB_SRCS
     kis_airbrush_option.cpp
     kis_auto_brush_widget.cpp
     kis_spacing_selection_widget.cpp
     kis_bidirectional_mixing_option.cpp
     kis_bidirectional_mixing_option_widget.cpp
     kis_brush_based_paintop.cpp
     kis_brush_chooser.cpp
     kis_brush_option_widget.cpp
     kis_brush_option.cpp
     kis_brush_selection_widget.cpp
     kis_color_option.cpp
     kis_color_source.cpp
     kis_color_source_option.cpp
     kis_color_source_option_widget.cpp
     kis_curve_option.cpp
     kis_curve_option_widget.cpp
     kis_curve_option_uniform_property.cpp
     kis_custom_brush_widget.cpp
     kis_clipboard_brush_widget.cpp
     kis_dynamic_sensor.cc
     kis_dab_cache.cpp
     kis_filter_option.cpp
     kis_multi_sensors_model_p.cpp
     kis_multi_sensors_selector.cpp
     kis_paint_action_type_option.cpp
     kis_precision_option.cpp
     kis_pressure_darken_option.cpp
     kis_pressure_hsv_option.cpp
     kis_pressure_opacity_option.cpp
     kis_pressure_flow_option.cpp
     kis_pressure_mirror_option.cpp
     kis_pressure_scatter_option.cpp
     kis_pressure_scatter_option_widget.cpp
     kis_pressure_sharpness_option.cpp
     kis_pressure_sharpness_option_widget.cpp
     kis_pressure_mirror_option_widget.cpp
     kis_pressure_rotation_option.cpp
     kis_pressure_size_option.cpp
     kis_pressure_spacing_option.cpp
+    kis_pressure_rate_option.cpp
     kis_pressure_softness_option.cpp
     kis_pressure_mix_option.cpp
     kis_pressure_gradient_option.cpp
     kis_pressure_flow_opacity_option.cpp
     kis_pressure_flow_opacity_option_widget.cpp
     kis_pressure_spacing_option_widget.cpp
     kis_pressure_ratio_option.cpp
     kis_current_outline_fetcher.cpp
     kis_text_brush_chooser.cpp
     kis_brush_based_paintop_options_widget.cpp
     kis_brush_based_paintop_settings.cpp
     kis_compositeop_option.cpp
     kis_texture_option.cpp
     kis_pressure_texture_strength_option.cpp
     kis_embedded_pattern_manager.cpp
     sensors/kis_dynamic_sensors.cc
     sensors/kis_dynamic_sensor_drawing_angle.cpp
     sensors/kis_dynamic_sensor_distance.cc
     sensors/kis_dynamic_sensor_time.cc
     sensors/kis_dynamic_sensor_fade.cpp
     sensors/kis_dynamic_sensor_fuzzy.cpp
 )
 
 ki18n_wrap_ui(kritalibpaintop_LIB_SRCS
     forms/wdgautobrush.ui
     forms/wdgBrushSizeOptions.ui
     forms/wdgcurveoption.ui
     forms/wdgcustombrush.ui
     forms/wdgclipboardbrush.ui
     forms/wdgtextbrush.ui
     forms/wdgincremental.ui
     forms/wdgmultisensorsselector.ui
     forms/wdgairbrush.ui
     forms/wdgfilteroption.ui
     forms/wdgcoloroptions.ui
     forms/wdgbrushchooser.ui
     forms/wdgpredefinedbrushchooser.ui
     forms/wdgCompositeOpOption.ui
     forms/wdgflowopacityoption.ui
     sensors/SensorDistanceConfiguration.ui
     sensors/SensorTimeConfiguration.ui
     sensors/SensorFadeConfiguration.ui
 
 )
 
 add_library(kritalibpaintop SHARED ${kritalibpaintop_LIB_SRCS} )
 generate_export_header(kritalibpaintop BASE_NAME kritapaintop EXPORT_MACRO_NAME PAINTOP_EXPORT)
 
 target_link_libraries(kritalibpaintop kritaui kritalibbrush kritawidgetutils)
 target_link_libraries(kritalibpaintop LINK_INTERFACE_LIBRARIES kritaui kritalibbrush)
 
 set_target_properties(kritalibpaintop PROPERTIES
     VERSION ${GENERIC_KRITA_LIB_VERSION} SOVERSION ${GENERIC_KRITA_LIB_SOVERSION}
 )
 
 install(TARGETS kritalibpaintop  ${INSTALL_TARGETS_DEFAULT_ARGS})
 
 
 add_subdirectory(tests)
diff --git a/plugins/paintops/libpaintop/forms/wdgairbrush.ui b/plugins/paintops/libpaintop/forms/wdgairbrush.ui
index 9ef638d926..43c6d628b9 100644
--- a/plugins/paintops/libpaintop/forms/wdgairbrush.ui
+++ b/plugins/paintops/libpaintop/forms/wdgairbrush.ui
@@ -1,81 +1,104 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgAirbrush</class>
  <widget class="QWidget" name="WdgAirbrush">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>400</width>
     <height>300</height>
    </rect>
   </property>
   <layout class="QGridLayout" name="gridLayout_2">
    <item row="0" column="0">
     <layout class="QGridLayout" name="gridLayout">
      <property name="leftMargin">
       <number>0</number>
      </property>
      <property name="topMargin">
       <number>0</number>
      </property>
      <property name="rightMargin">
       <number>0</number>
      </property>
      <property name="bottomMargin">
       <number>0</number>
      </property>
      <property name="horizontalSpacing">
       <number>5</number>
      </property>
      <property name="verticalSpacing">
       <number>0</number>
      </property>
      <item row="0" column="0">
       <widget class="QLabel" name="rateLbl">
        <property name="text">
         <string>Rate:</string>
        </property>
        <property name="alignment">
         <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
        </property>
       </widget>
      </item>
      <item row="0" column="1">
-      <widget class="KisSliderSpinBox" name="sliderRate">
+      <widget class="KisDoubleSliderSpinBox" name="sliderRate" native="true">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Expanding" vsizetype="Minimum">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
       </widget>
      </item>
     </layout>
    </item>
-   <item row="1" column="0">
+   <item row="3" column="0">
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>40</height>
       </size>
      </property>
     </spacer>
    </item>
+   <item row="2" column="0">
+    <widget class="QCheckBox" name="checkBoxIgnoreSpacing">
+     <property name="text">
+      <string>Override Spacing</string>
+     </property>
+    </widget>
+   </item>
+   <item row="1" column="0">
+    <spacer name="verticalSpacer_2">
+     <property name="orientation">
+      <enum>Qt::Vertical</enum>
+     </property>
+     <property name="sizeType">
+      <enum>QSizePolicy::Preferred</enum>
+     </property>
+     <property name="sizeHint" stdset="0">
+      <size>
+       <width>20</width>
+       <height>5</height>
+      </size>
+     </property>
+    </spacer>
+   </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
-   <class>KisSliderSpinBox</class>
+   <class>KisDoubleSliderSpinBox</class>
    <extends>QWidget</extends>
    <header>kis_slider_spin_box.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/plugins/paintops/libpaintop/kis_airbrush_option.cpp b/plugins/paintops/libpaintop/kis_airbrush_option.cpp
index 2e28201d07..96e527a757 100644
--- a/plugins/paintops/libpaintop/kis_airbrush_option.cpp
+++ b/plugins/paintops/libpaintop/kis_airbrush_option.cpp
@@ -1,68 +1,139 @@
 /*
  *  Copyright (c) 2008 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "kis_airbrush_option.h"
+#include "kis_paintop_settings.h"
 #include <klocalizedstring.h>
 
 #include <QWidget>
 #include <QRadioButton>
 
 #include "ui_wdgairbrush.h"
 
-const int MAXIMUM_RATE = 1000;
+const qreal MINIMUM_RATE = 1.0;
+const qreal MAXIMUM_RATE = 1000.0;
+const int RATE_NUM_DECIMALS = 2;
+const qreal RATE_EXPONENT_RATIO = 2.0;
+const qreal RATE_SINGLE_STEP = 1.0;
+const qreal DEFAULT_RATE = 20.0;
 
 class KisAirbrushWidget: public QWidget, public Ui::WdgAirbrush
 {
 public:
-    KisAirbrushWidget(QWidget *parent = 0)
+    KisAirbrushWidget(QWidget *parent = 0, bool canIgnoreSpacing = true)
         : QWidget(parent) {
         setupUi(this);
 
-        sliderRate->setRange(0, MAXIMUM_RATE);
-        sliderRate->setExponentRatio(1.8);
-        sliderRate->setValue(100);
+        sliderRate->setRange(MINIMUM_RATE, MAXIMUM_RATE, RATE_NUM_DECIMALS);
+        sliderRate->setExponentRatio(RATE_EXPONENT_RATIO);
+        sliderRate->setSingleStep(RATE_SINGLE_STEP);
+        sliderRate->setValue(DEFAULT_RATE);
+
+        checkBoxIgnoreSpacing->setVisible(canIgnoreSpacing);
+        checkBoxIgnoreSpacing->setEnabled(canIgnoreSpacing);
     }
 };
 
+struct KisAirbrushOption::Private {
+public:
+    bool ignoreSpacing;
+    // We store the airbrush interval (in milliseconds) instead of the rate because the interval is
+    // likely to be accessed more often.
+    qreal airbrushInterval;
+    KisAirbrushWidget *configPage;
+};
 
-KisAirbrushOption::KisAirbrushOption(bool enabled)
+KisAirbrushOption::KisAirbrushOption(bool enabled, bool canIgnoreSpacing)
     : KisPaintOpOption(KisPaintOpOption::COLOR, enabled)
+    , m_d(new Private())
 {
-    setObjectName("KisAirBrushOption");
+    setObjectName("KisAirbrushOption");
+
+    // Initialize GUI.
     m_checkable = true;
-    m_optionWidget = new KisAirbrushWidget();
-    connect(m_optionWidget->sliderRate, SIGNAL(valueChanged(int)), SLOT(emitSettingChanged()));
-    setConfigurationPage(m_optionWidget);
-}
+    m_d->configPage = new KisAirbrushWidget(nullptr, canIgnoreSpacing);
+    connect(m_d->configPage->sliderRate, SIGNAL(valueChanged(qreal)), SLOT(slotIntervalChanged()));
+    connect(m_d->configPage->checkBoxIgnoreSpacing, SIGNAL(toggled(bool)),
+            SLOT(slotIgnoreSpacingChanged()));
+    setConfigurationPage(m_d->configPage);
 
+    // Read initial configuration from the GUI.
+    updateIgnoreSpacing();
+    updateInterval();
+}
 
 KisAirbrushOption::~KisAirbrushOption()
 {
+    delete m_d;
 }
 
 void KisAirbrushOption::writeOptionSetting(KisPropertiesConfigurationSP setting) const
 {
+    KIS_SAFE_ASSERT_RECOVER (m_d->airbrushInterval > 0.0) {
+        m_d->airbrushInterval = 1.0;
+    }
     setting->setProperty(AIRBRUSH_ENABLED, isChecked());
-    setting->setProperty(AIRBRUSH_RATE, m_optionWidget->sliderRate->value());
+    setting->setProperty(AIRBRUSH_RATE, 1000.0 / m_d->airbrushInterval);
+    setting->setProperty(AIRBRUSH_IGNORE_SPACING, m_d->ignoreSpacing);
 }
 
 void KisAirbrushOption::readOptionSetting(const KisPropertiesConfigurationSP setting)
 {
     setChecked(setting->getBool(AIRBRUSH_ENABLED));
-    m_optionWidget->sliderRate->setValue(setting->getInt(AIRBRUSH_RATE, 100));
+    // Update settings in the widget. The widget's signals should cause the changes to be propagated
+    // to this->m_d as well.
+    m_d->configPage->sliderRate->setValue(setting->getDouble(AIRBRUSH_RATE, DEFAULT_RATE));
+    m_d->configPage->checkBoxIgnoreSpacing->setChecked(setting->getBool(AIRBRUSH_IGNORE_SPACING,
+                                                                        false));
+}
+
+qreal KisAirbrushOption::airbrushInterval() const
+{
+    return m_d->airbrushInterval;
+}
+
+bool KisAirbrushOption::ignoreSpacing() const
+{
+    return m_d->ignoreSpacing;
 }
 
+void KisAirbrushOption::slotIntervalChanged()
+{
+    updateInterval();
+    emitSettingChanged();
+}
+
+void KisAirbrushOption::slotIgnoreSpacingChanged()
+{
+    updateIgnoreSpacing();
+    emitSettingChanged();
+}
+
+void KisAirbrushOption::updateInterval()
+{
+    // Get rate in dabs per second, then convert to interval in milliseconds.
+    qreal rate = m_d->configPage->sliderRate->value();
+    KIS_SAFE_ASSERT_RECOVER(rate > 0.0) {
+        rate = 1.0;
+    }
+    m_d->airbrushInterval = 1000.0 / rate;
+}
+
+void KisAirbrushOption::updateIgnoreSpacing()
+{
+    m_d->ignoreSpacing = m_d->configPage->checkBoxIgnoreSpacing->isChecked();
+}
diff --git a/plugins/paintops/libpaintop/kis_airbrush_option.h b/plugins/paintops/libpaintop/kis_airbrush_option.h
index fed1b2c9f8..5d624d1b92 100644
--- a/plugins/paintops/libpaintop/kis_airbrush_option.h
+++ b/plugins/paintops/libpaintop/kis_airbrush_option.h
@@ -1,47 +1,66 @@
 /*
  *  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.
  */
 #ifndef KIS_AIRBRUSH_OPTION_H
 #define KIS_AIRBRUSH_OPTION_H
 
 #include <kis_paintop_option.h>
 #include <kritapaintop_export.h>
 
-const QString AIRBRUSH_ENABLED = "AirbrushOption/isAirbrushing";
-const QString AIRBRUSH_RATE = "AirbrushOption/rate";
-
-class KisAirbrushWidget;
-
 /**
  * Allows the user to activate airbrushing of the brush mask (brush is painted at the same position over and over)
  * Rate is set in miliseconds.
  */
 class PAINTOP_EXPORT KisAirbrushOption : public KisPaintOpOption
 {
+    Q_OBJECT
+
 public:
-    KisAirbrushOption(bool enabled = true);
+    KisAirbrushOption(bool enabled = true, bool canIgnoreSpacing = true);
     ~KisAirbrushOption() override;
 
     void writeOptionSetting(KisPropertiesConfigurationSP setting) const override;
     void readOptionSetting(const KisPropertiesConfigurationSP setting) override;
 
+    /**
+     * Returns the airbrushing interval, in milliseconds. This value should be ignored if the
+     * KisAirbrushOption is not checked according to isChecked().
+     */
+    qreal airbrushInterval() const;
+
+    /**
+     * Returns true if regular distance-based spacing should be ignored and overridden by time-based
+     * spacing. This value should be ignored if the KisAirbrushOption is not checked according to
+     * isChecked().
+     */
+    bool ignoreSpacing() const;
+
+private Q_SLOTS:
+    void slotIntervalChanged();
+    void slotIgnoreSpacingChanged();
+
 private:
-    KisAirbrushWidget * m_optionWidget;
+    // Reads the airbrush interval from the GUI.
+    void updateInterval();
+    // Reads the "ignore spacing" setting from the GUI.
+    void updateIgnoreSpacing();
 
+    struct Private;
+    Private *const m_d;
 };
 
 #endif
diff --git a/plugins/paintops/libpaintop/kis_brush_based_paintop.cpp b/plugins/paintops/libpaintop/kis_brush_based_paintop.cpp
index bcec8a796b..e2c2a9fd41 100644
--- a/plugins/paintops/libpaintop/kis_brush_based_paintop.cpp
+++ b/plugins/paintops/libpaintop/kis_brush_based_paintop.cpp
@@ -1,166 +1,183 @@
 /*
  *  Copyright (c) 2008 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #include "kis_brush_based_paintop.h"
 #include "kis_properties_configuration.h"
 #include <brushengine/kis_paintop_settings.h>
 #include "kis_brush_option.h"
 #include <kis_pressure_spacing_option.h>
+#include <kis_pressure_rate_option.h>
 #include "kis_painter.h"
 #include <kis_lod_transform.h>
 #include "kis_paintop_utils.h"
+#include "kis_paintop_plugin_utils.h"
 
 #include <QGlobalStatic>
 
 #include <QImage>
 #include <QPainter>
 
 #ifdef HAVE_THREADED_TEXT_RENDERING_WORKAROUND
 
 Q_GLOBAL_STATIC(TextBrushInitializationWorkaround, s_instance)
 
 
 TextBrushInitializationWorkaround *TextBrushInitializationWorkaround::instance()
 {
     return s_instance;
 }
 
 void TextBrushInitializationWorkaround::preinitialize(KisPropertiesConfigurationSP settings)
 {
     if (KisBrushOption::isTextBrush(settings.data())) {
         KisBrushOption brushOption;
         brushOption.readOptionSettingForceCopy(settings);
         m_brush = brushOption.brush();
         m_settings = settings;
     }
     else {
         m_brush = 0;
         m_settings = 0;
     }
 }
 
 KisBrushSP TextBrushInitializationWorkaround::tryGetBrush(const KisPropertiesConfigurationSP settings)
 {
     return (settings && settings == m_settings ? m_brush : 0);
 }
 
 TextBrushInitializationWorkaround::TextBrushInitializationWorkaround()
     : m_settings(0)
 {}
 
 TextBrushInitializationWorkaround::~TextBrushInitializationWorkaround()
 {}
 
 
 
 void KisBrushBasedPaintOp::preinitializeOpStatically(KisPaintOpSettingsSP settings)
 {
     TextBrushInitializationWorkaround::instance()->preinitialize(settings);
 }
 
 #endif /* HAVE_THREADED_TEXT_RENDERING_WORKAROUND */
 
 
 KisBrushBasedPaintOp::KisBrushBasedPaintOp(const KisPropertiesConfigurationSP settings, KisPainter* painter)
     : KisPaintOp(painter),
       m_textureProperties(painter->device()->defaultBounds()->currentLevelOfDetail())
 {
     Q_ASSERT(settings);
 
 #ifdef HAVE_THREADED_TEXT_RENDERING_WORKAROUND
     m_brush =
             TextBrushInitializationWorkaround::instance()->tryGetBrush(settings);
 #endif /* HAVE_THREADED_TEXT_RENDERING_WORKAROUND */
 
     if (!m_brush) {
         KisBrushOption brushOption;
         brushOption.readOptionSettingForceCopy(settings);
         m_brush = brushOption.brush();
     }
 
     m_brush->notifyStrokeStarted();
 
     m_precisionOption.readOptionSetting(settings);
     m_dabCache = new KisDabCache(m_brush);
     m_dabCache->setPrecisionOption(&m_precisionOption);
 
     m_mirrorOption.readOptionSetting(settings);
     m_dabCache->setMirrorPostprocessing(&m_mirrorOption);
 
     m_textureProperties.fillProperties(settings);
     m_dabCache->setTexturePostprocessing(&m_textureProperties);
 }
 
 KisBrushBasedPaintOp::~KisBrushBasedPaintOp()
 {
     delete m_dabCache;
 }
 
 bool KisBrushBasedPaintOp::checkSizeTooSmall(qreal scale)
 {
     scale *= m_brush->scale();
     return KisPaintOpUtils::checkSizeTooSmall(scale, m_brush->width(), m_brush->height());
 }
 
 KisSpacingInformation KisBrushBasedPaintOp::effectiveSpacing(qreal scale) const
 {
     // we parse dab rotation separately, so don't count it
     QSizeF metric = m_brush->characteristicSize(KisDabShape(scale, 1.0, 0));
     return effectiveSpacing(metric.width(), metric.height(), 1.0, false, 0.0, false);
 }
 
 KisSpacingInformation KisBrushBasedPaintOp::effectiveSpacing(qreal scale, qreal rotation, const KisPaintInformation &pi) const
 {
-    MirrorProperties prop = m_mirrorOption.apply(pi);
-    const bool implicitFlipped = prop.horizontalMirror != prop.verticalMirror;
+    return effectiveSpacing(scale, rotation, nullptr, nullptr, nullptr, pi);
+}
 
-    // we parse dab rotation separately, so don't count it
-    QSizeF metric = m_brush->characteristicSize(KisDabShape(scale, 1.0, 0));
-    return effectiveSpacing(metric.width(), metric.height(), 1.0, false, rotation, implicitFlipped);
+KisSpacingInformation KisBrushBasedPaintOp::effectiveSpacing(qreal scale, qreal rotation, const KisPressureSpacingOption &spacingOption, const KisPaintInformation &pi) const
+{
+    return effectiveSpacing(scale, rotation, nullptr, &spacingOption, nullptr, pi);
 }
 
-KisSpacingInformation KisBrushBasedPaintOp::effectiveSpacing(qreal scale, qreal rotation, const KisPressureSpacingOption &spacingOption, const KisPaintInformation &pi) const {
-    qreal extraSpacingScale = 1.0;
-    if (spacingOption.isChecked()) {
-        extraSpacingScale = spacingOption.apply(pi);
-    }
+KisSpacingInformation KisBrushBasedPaintOp::effectiveSpacing(qreal scale, qreal rotation,
+                                                             const KisAirbrushOption *airbrushOption,
+                                                             const KisPressureSpacingOption *spacingOption,
+                                                             const KisPressureRateOption *rateOption,
+                                                             const KisPaintInformation &pi) const
+{
+    bool isotropicSpacing = spacingOption && spacingOption->isotropicSpacing();
 
     MirrorProperties prop = m_mirrorOption.apply(pi);
     const bool implicitFlipped = prop.horizontalMirror != prop.verticalMirror;
 
     // we parse dab rotation separately, so don't count it
     QSizeF metric = m_brush->characteristicSize(KisDabShape(scale, 1.0, 0));
-    return effectiveSpacing(metric.width(), metric.height(), extraSpacingScale, spacingOption.isotropicSpacing(), rotation, implicitFlipped);
+
+    return KisPaintOpPluginUtils::effectiveSpacing(metric.width(), metric.height(),
+                                                   isotropicSpacing, rotation, implicitFlipped,
+                                                   m_brush->spacing(),
+                                                   m_brush->autoSpacingActive(),
+                                                   m_brush->autoSpacingCoeff(),
+                                                   KisLodTransform::lodToScale(painter()->device()),
+                                                   airbrushOption, spacingOption, rateOption,
+                                                   pi);
 }
 
-KisSpacingInformation KisBrushBasedPaintOp::effectiveSpacing(qreal dabWidth, qreal dabHeight, qreal extraScale, bool isotropicSpacing, qreal rotation, bool axesFlipped) const
+KisSpacingInformation KisBrushBasedPaintOp::effectiveSpacing(qreal dabWidth, qreal dabHeight,
+                                                             qreal extraScale,
+                                                             bool isotropicSpacing, qreal rotation,
+                                                             bool axesFlipped) const
 {
     return KisPaintOpUtils::effectiveSpacing(dabWidth, dabHeight,
-                                             extraScale,
+                                             extraScale, 1.0,
+                                             true,
                                              isotropicSpacing,
                                              rotation,
                                              axesFlipped,
                                              m_brush->spacing(),
                                              m_brush->autoSpacingActive(),
                                              m_brush->autoSpacingCoeff(),
+                                             false, 1000.0,
                                              KisLodTransform::lodToScale(painter()->device()));
 }
 
 bool KisBrushBasedPaintOp::canPaint() const
 {
     return m_brush != 0;
 }
diff --git a/plugins/paintops/libpaintop/kis_brush_based_paintop.h b/plugins/paintops/libpaintop/kis_brush_based_paintop.h
index 3c7626a3df..518be396e5 100644
--- a/plugins/paintops/libpaintop/kis_brush_based_paintop.h
+++ b/plugins/paintops/libpaintop/kis_brush_based_paintop.h
@@ -1,93 +1,102 @@
 /*
  *  Copyright (c) 2008 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef KIS_BRUSH_BASED_PAINTOP_H
 #define KIS_BRUSH_BASED_PAINTOP_H
 
 #include "kritapaintop_export.h"
 #include <brushengine/kis_paintop.h>
 #include "kis_dab_cache.h"
 #include "kis_brush.h"
 #include "kis_texture_option.h"
 #include "kis_precision_option.h"
+#include "kis_airbrush_option.h"
 #include "kis_pressure_mirror_option.h"
 #include <kis_threaded_text_rendering_workaround.h>
 
 
 class KisPropertiesConfiguration;
 class KisPressureSpacingOption;
+class KisPressureRateOption;
 class KisDabCache;
 
 /// Internal
 class TextBrushInitializationWorkaround
 {
 public:
     TextBrushInitializationWorkaround();
     ~TextBrushInitializationWorkaround();
     static TextBrushInitializationWorkaround* instance();
 
     void preinitialize(KisPropertiesConfigurationSP settings);
 
     KisBrushSP tryGetBrush(const KisPropertiesConfigurationSP settings);
 
 
 private:
     KisBrushSP m_brush;
     KisPropertiesConfigurationSP m_settings;
 };
 
 
 /**
  * This is a base class for paintops that use a KisBrush or derived
  * brush to paint with. This is mainly important for the spacing
  * generation.
  */
 class PAINTOP_EXPORT KisBrushBasedPaintOp : public KisPaintOp
 {
 
 public:
 
     KisBrushBasedPaintOp(const KisPropertiesConfigurationSP settings, KisPainter* painter);
     ~KisBrushBasedPaintOp() override;
 
     bool checkSizeTooSmall(qreal scale);
 
     KisSpacingInformation effectiveSpacing(qreal scale) const;
     KisSpacingInformation effectiveSpacing(qreal scale, qreal rotation, const KisPaintInformation &pi) const;
     KisSpacingInformation effectiveSpacing(qreal scale, qreal rotation, const KisPressureSpacingOption &spacingOption, const KisPaintInformation &pi) const;
+    KisSpacingInformation effectiveSpacing(qreal scale,
+                                           qreal rotation,
+                                           const KisAirbrushOption *airbrushOption,
+                                           const KisPressureSpacingOption *spacingOption,
+                                           const KisPressureRateOption *rateOption,
+                                           const KisPaintInformation &pi) const;
 
     ///Reimplemented, false if brush is 0
     bool canPaint() const override;
 
 #ifdef HAVE_THREADED_TEXT_RENDERING_WORKAROUND
     typedef int needs_preinitialization;
     static void preinitializeOpStatically(KisPaintOpSettingsSP settings);
 #endif /* HAVE_THREADED_TEXT_RENDERING_WORKAROUND */
 
 private:
     KisSpacingInformation effectiveSpacing(qreal dabWidth, qreal dabHeight, qreal extraScale, bool isotropicSpacing, qreal rotation, bool axesFlipped) const;
 
 protected: // XXX: make private!
-
+    KisDabCache *m_dabCache;
     KisBrushSP m_brush;
+
+private:
     KisTextureProperties m_textureProperties;
     KisPressureMirrorOption m_mirrorOption;
     KisPrecisionOption m_precisionOption;
-    KisDabCache *m_dabCache;
 };
 
 #endif
diff --git a/plugins/paintops/libpaintop/kis_brush_based_paintop_settings.cpp b/plugins/paintops/libpaintop/kis_brush_based_paintop_settings.cpp
index fb4e3c612e..97b9a7ddda 100644
--- a/plugins/paintops/libpaintop/kis_brush_based_paintop_settings.cpp
+++ b/plugins/paintops/libpaintop/kis_brush_based_paintop_settings.cpp
@@ -1,342 +1,331 @@
 /*
  *  Copyright (c) 2010 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_brush_based_paintop_settings.h"
 
 #include <kis_paint_action_type_option.h>
 #include <kis_airbrush_option.h>
 #include "kis_brush_based_paintop_options_widget.h"
 #include <kis_boundary.h>
 #include "kis_brush_server.h"
 #include <QLineF>
 #include "kis_signals_blocker.h"
 #include "kis_brush_option.h"
 
 struct BrushReader {
     BrushReader(const KisBrushBasedPaintOpSettings *parent)
         : m_parent(parent)
     {
         m_option.readOptionSetting(m_parent);
     }
 
     KisBrushSP brush() {
         return m_option.brush();
     }
 
     const KisBrushBasedPaintOpSettings *m_parent;
     KisBrushOption m_option;
 };
 
 struct BrushWriter {
     BrushWriter(KisBrushBasedPaintOpSettings *parent)
         : m_parent(parent)
     {
         m_option.readOptionSetting(m_parent);
     }
 
     ~BrushWriter() {
         m_option.writeOptionSetting(m_parent);
     }
 
     KisBrushSP brush() {
         return m_option.brush();
     }
 
     KisBrushBasedPaintOpSettings *m_parent;
     KisBrushOption m_option;
 };
 
 
 KisBrushBasedPaintOpSettings::KisBrushBasedPaintOpSettings()
     : KisOutlineGenerationPolicy<KisPaintOpSettings>(KisCurrentOutlineFetcher::SIZE_OPTION |
             KisCurrentOutlineFetcher::ROTATION_OPTION |
             KisCurrentOutlineFetcher::MIRROR_OPTION)
 {
 }
 
 bool KisBrushBasedPaintOpSettings::paintIncremental()
 {
     if (hasProperty("PaintOpAction")) {
         return (enumPaintActionType)getInt("PaintOpAction", WASH) == BUILDUP;
     }
     return true;
 }
 
-bool KisBrushBasedPaintOpSettings::isAirbrushing() const
-{
-    return getBool(AIRBRUSH_ENABLED);
-}
-
-
-int KisBrushBasedPaintOpSettings::rate() const
-{
-    return getInt(AIRBRUSH_RATE);
-}
-
 KisPaintOpSettingsSP KisBrushBasedPaintOpSettings::clone() const
 {
     KisPaintOpSettingsSP _settings = KisOutlineGenerationPolicy<KisPaintOpSettings>::clone();
     KisBrushBasedPaintOpSettingsSP settings = dynamic_cast<KisBrushBasedPaintOpSettings*>(_settings.data());
     settings->m_savedBrush = this->brush();
     return settings;
 }
 
 KisBrushSP KisBrushBasedPaintOpSettings::brush() const
 {
     KisBrushSP brush = m_savedBrush;
 
     if (!brush) {
         BrushReader w(this);
         brush = w.brush();
         m_savedBrush = brush;
     }
 
     return brush;
 }
 
 QPainterPath KisBrushBasedPaintOpSettings::brushOutlineImpl(const KisPaintInformation &info,
                                                             OutlineMode mode,
                                                             qreal additionalScale,
                                                             bool forceOutline)
 {
     QPainterPath path;
 
     if (forceOutline || mode == CursorIsOutline || mode == CursorIsCircleOutline || mode == CursorTiltOutline) {
         KisBrushSP brush = this->brush();
         if (!brush) return path;
         qreal finalScale = brush->scale() * additionalScale;
 
         QPainterPath realOutline = brush->outline();
 
         if (mode == CursorIsCircleOutline || mode == CursorTiltOutline ||
             (forceOutline && mode == CursorNoOutline)) {
 
             QPainterPath ellipse;
             ellipse.addEllipse(realOutline.boundingRect());
             realOutline = ellipse;
         }
 
         path = outlineFetcher()->fetchOutline(info, this, realOutline, finalScale, brush->angle());
 
         if (mode == CursorTiltOutline) {
             QPainterPath tiltLine = makeTiltIndicator(info,
                 realOutline.boundingRect().center(),
                 realOutline.boundingRect().width() * 0.5,
                 3.0);
             path.addPath(outlineFetcher()->fetchOutline(info, this, tiltLine, finalScale, 0.0, true, realOutline.boundingRect().center().x(), realOutline.boundingRect().center().y()));
         }
     }
 
     return path;
 }
 
 QPainterPath KisBrushBasedPaintOpSettings::brushOutline(const KisPaintInformation &info, OutlineMode mode)
 {
     return brushOutlineImpl(info, mode, 1.0);
 }
 
 bool KisBrushBasedPaintOpSettings::isValid() const
 {
     QString filename = getString("requiredBrushFile", QString());
     if (!filename.isEmpty()) {
         KisBrushSP brush = KisBrushServer::instance()->brushServer()->resourceByFilename(filename);
         if (!brush) {
             return false;
         }
     }
     return true;
 }
 
 bool KisBrushBasedPaintOpSettings::isLoadable()
 {
     return (KisBrushServer::instance()->brushServer()->resources().count() > 0);
 }
 
 void KisBrushBasedPaintOpSettings::setAngle(qreal value)
 {
     BrushWriter w(this);
     if (!w.brush()) return;
     w.brush()->setAngle(value);
 }
 
 qreal KisBrushBasedPaintOpSettings::angle()
 {
     return this->brush()->angle();
 }
 
 void KisBrushBasedPaintOpSettings::setSpacing(qreal value)
 {
     BrushWriter w(this);
     if (!w.brush()) return;
     w.brush()->setSpacing(value);
 }
 
 qreal KisBrushBasedPaintOpSettings::spacing()
 {
     return this->brush()->spacing();
 }
 
 void KisBrushBasedPaintOpSettings::setAutoSpacing(bool active, qreal coeff)
 {
     BrushWriter w(this);
     if (!w.brush()) return;
     w.brush()->setAutoSpacing(active, coeff);
 }
 
 
 bool KisBrushBasedPaintOpSettings::autoSpacingActive()
 {
     return this->brush()->autoSpacingActive();
 }
 
 qreal KisBrushBasedPaintOpSettings::autoSpacingCoeff()
 {
     return this->brush()->autoSpacingCoeff();
 }
 
 void KisBrushBasedPaintOpSettings::setPaintOpSize(qreal value)
 {
     BrushWriter w(this);
     if (!w.brush()) return;
 
     w.brush()->setUserEffectiveSize(value);
 }
 
 qreal KisBrushBasedPaintOpSettings::paintOpSize() const
 {
     return this->brush()->userEffectiveSize();
 }
 
 
 
 #include <brushengine/kis_slider_based_paintop_property.h>
 #include "kis_paintop_preset.h"
 #include "kis_paintop_settings_update_proxy.h"
 
 QList<KisUniformPaintOpPropertySP> KisBrushBasedPaintOpSettings::uniformProperties(KisPaintOpSettingsSP settings)
 {
     QList<KisUniformPaintOpPropertySP> props =
         listWeakToStrong(m_uniformProperties);
 
     if (props.isEmpty()) {
         {
             KisIntSliderBasedPaintOpPropertyCallback *prop =
                 new KisIntSliderBasedPaintOpPropertyCallback(
                     KisIntSliderBasedPaintOpPropertyCallback::Int,
                     "angle",
                     "Angle",
                     settings, 0);
 
             prop->setRange(0, 360);
 
             prop->setReadCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisBrushBasedPaintOpSettings *s =
                         dynamic_cast<KisBrushBasedPaintOpSettings*>(prop->settings().data());
 
                     const qreal angleResult = kisRadiansToDegrees(s->angle());
                     prop->setValue(angleResult);
                 });
             prop->setWriteCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisBrushBasedPaintOpSettings *s =
                         dynamic_cast<KisBrushBasedPaintOpSettings*>(prop->settings().data());
 
                     s->setAngle(kisDegreesToRadians(prop->value().toReal()));
                 });
 
             QObject::connect(preset()->updateProxy(), SIGNAL(sigSettingsChanged()), prop, SLOT(requestReadValue()));
             prop->requestReadValue();
             props << toQShared(prop);
         }
         {
             KisUniformPaintOpPropertyCallback *prop =
                 new KisUniformPaintOpPropertyCallback(
                     KisUniformPaintOpPropertyCallback::Bool,
                     "auto_spacing",
                     "Auto Spacing",
                     settings, 0);
 
             prop->setReadCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisBrushBasedPaintOpSettings *s =
                         dynamic_cast<KisBrushBasedPaintOpSettings*>(prop->settings().data());
 
                     prop->setValue(s->autoSpacingActive());
                 });
             prop->setWriteCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisBrushBasedPaintOpSettings *s =
                         dynamic_cast<KisBrushBasedPaintOpSettings*>(prop->settings().data());
 
                     s->setAutoSpacing(prop->value().toBool(), s->autoSpacingCoeff());
                 });
 
             QObject::connect(preset()->updateProxy(), SIGNAL(sigSettingsChanged()), prop, SLOT(requestReadValue()));
             prop->requestReadValue();
             props << toQShared(prop);
         }
 
         {
             KisDoubleSliderBasedPaintOpPropertyCallback *prop =
                 new KisDoubleSliderBasedPaintOpPropertyCallback(
                     KisDoubleSliderBasedPaintOpPropertyCallback::Double,
                     "spacing",
                     "Spacing",
                     settings, 0);
 
             prop->setRange(0.01, 10);
             prop->setSingleStep(0.01);
             prop->setExponentRatio(3.0);
 
 
             prop->setReadCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisBrushBasedPaintOpSettings *s =
                         dynamic_cast<KisBrushBasedPaintOpSettings*>(prop->settings().data());
 
                     const qreal value = s->autoSpacingActive() ?
                         s->autoSpacingCoeff() : s->spacing();
                     prop->setValue(value);
                 });
             prop->setWriteCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisBrushBasedPaintOpSettings *s =
                         dynamic_cast<KisBrushBasedPaintOpSettings*>(prop->settings().data());
 
                     if (s->autoSpacingActive()) {
                         s->setAutoSpacing(true, prop->value().toReal());
                     } else {
                         s->setSpacing(prop->value().toReal());
                     }
                 });
 
             QObject::connect(preset()->updateProxy(), SIGNAL(sigSettingsChanged()), prop, SLOT(requestReadValue()));
             prop->requestReadValue();
             props << toQShared(prop);
         }
     }
 
     return KisPaintOpSettings::uniformProperties(settings) + props;
 }
 
 void KisBrushBasedPaintOpSettings::onPropertyChanged()
 {
     m_savedBrush.clear();
     KisOutlineGenerationPolicy<KisPaintOpSettings>::onPropertyChanged();
 }
diff --git a/plugins/paintops/libpaintop/kis_brush_based_paintop_settings.h b/plugins/paintops/libpaintop/kis_brush_based_paintop_settings.h
index 996c691ebf..4bd7911741 100644
--- a/plugins/paintops/libpaintop/kis_brush_based_paintop_settings.h
+++ b/plugins/paintops/libpaintop/kis_brush_based_paintop_settings.h
@@ -1,90 +1,84 @@
 /*
  *  Copyright (c) 2010 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_BRUSH_BASED_PAINTOP_SETTINGS_H
 #define KIS_BRUSH_BASED_PAINTOP_SETTINGS_H
 
 #include <brushengine/kis_paintop_settings.h>
 #include <kritapaintop_export.h>
 #include <kis_outline_generation_policy.h>
 #include <kis_brush.h>
 #include <kis_shared.h>
 #include <kis_shared_ptr.h>
 
 
 class PAINTOP_EXPORT KisBrushBasedPaintOpSettings : public KisOutlineGenerationPolicy<KisPaintOpSettings>
 {
 public:
     KisBrushBasedPaintOpSettings();
     ~KisBrushBasedPaintOpSettings() override {}
 
     ///Reimplemented
     bool paintIncremental() override;
 
-    ///Reimplemented
-    bool isAirbrushing() const override;
-
-    ///Reimplemented
-    int rate() const override;
-
     using KisPaintOpSettings::brushOutline;
     QPainterPath brushOutline(const KisPaintInformation &info, OutlineMode mode) override;
 
     ///Reimplemented
     bool isValid() const override;
 
     ///Reimplemented
     bool isLoadable() override;
 
     KisBrushSP brush() const;
 
     KisPaintOpSettingsSP clone() const override;
 
     void setAngle(qreal value);
     qreal angle();
 
     void setSpacing(qreal spacing);
     qreal spacing();
 
     void setAutoSpacing(bool active, qreal coeff);
 
     bool autoSpacingActive();
     qreal autoSpacingCoeff();
 
     void setPaintOpSize(qreal value) override;
     qreal paintOpSize() const override;
 
     QList<KisUniformPaintOpPropertySP> uniformProperties(KisPaintOpSettingsSP settings) override;
 
 protected:
 
     void onPropertyChanged() override;
     QPainterPath brushOutlineImpl(const KisPaintInformation &info, OutlineMode mode, qreal additionalScale, bool forceOutline = false);
     mutable KisBrushSP m_savedBrush;
     QList<KisUniformPaintOpPropertyWSP> m_uniformProperties;
 
 private:
 
     Q_DISABLE_COPY(KisBrushBasedPaintOpSettings)
 
 };
 
 class KisBrushBasedPaintOpSettings;
 typedef KisPinnedSharedPtr<KisBrushBasedPaintOpSettings> KisBrushBasedPaintOpSettingsSP;
 
 #endif // KIS_BRUSH_BASED_PAINTOP_SETTINGS_H
diff --git a/plugins/paintops/libpaintop/kis_compositeop_option.h b/plugins/paintops/libpaintop/kis_compositeop_option.h
index 271734ba4b..61c616c447 100644
--- a/plugins/paintops/libpaintop/kis_compositeop_option.h
+++ b/plugins/paintops/libpaintop/kis_compositeop_option.h
@@ -1,62 +1,59 @@
 /*
  *  Copyright (c) 2011 Silvio Heinrich <plassy@web.de>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef KIS_COMPOSITEOP_OPTION_H
 #define KIS_COMPOSITEOP_OPTION_H
 
 #include <kis_paintop_option.h>
 #include <kritapaintop_export.h>
 #include <QString>
 
-// const QString AIRBRUSH_ENABLED = "AirbrushOption/isAirbrushing";
-// const QString AIRBRUSH_RATE = "AirbrushOption/rate";
-
 class QLabel;
 class QModelIndex;
 class QPushButton;
 class KisCompositeOpListWidget;
 class KoID;
 
 class PAINTOP_EXPORT KisCompositeOpOption: public KisPaintOpOption
 {
     Q_OBJECT
 
 public:
     KisCompositeOpOption(bool createConfigWidget = false);
     ~KisCompositeOpOption() override;
 
     void writeOptionSetting(KisPropertiesConfigurationSP setting) const override;
     void readOptionSetting(const KisPropertiesConfigurationSP setting) override;
 
 private Q_SLOTS:
     void slotCompositeOpChanged(const QModelIndex& index);
     void slotEraserToggled(bool toggled);
 
 private:
     void changeCompositeOp(const KoID& compositeOp);
 
 private:
     QLabel*                   m_label;
     QPushButton*              m_bnEraser;
     KisCompositeOpListWidget* m_list;
     QString                   m_currCompositeOpID;
     bool                      m_createConfigWidget;
     bool                      m_eraserMode;
 
 };
 
 #endif
diff --git a/plugins/paintops/libpaintop/kis_paintop_plugin_utils.h b/plugins/paintops/libpaintop/kis_paintop_plugin_utils.h
new file mode 100644
index 0000000000..41b656c1f5
--- /dev/null
+++ b/plugins/paintops/libpaintop/kis_paintop_plugin_utils.h
@@ -0,0 +1,87 @@
+/*
+ *  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_PLUGIN_UTILS_H
+#define __KIS_PAINTOP_PLUGIN_UTILS_H
+
+#include "kis_paint_information.h"
+#include "kis_paintop_utils.h"
+#include "kis_paintop_settings.h"
+#include "kis_airbrush_option.h"
+#include "kis_pressure_spacing_option.h"
+#include "kis_pressure_rate_option.h"
+
+namespace KisPaintOpPluginUtils {
+
+/**
+ * Similar to KisPaintOpUtils::effectiveSpacing, but some of the required parameters are obtained
+ * from the provided configuration options. This function assumes a common configuration where
+ * curve-based spacing and rate options provide pressure sensitivity, and airbrush settings are
+ * configured through a KisAirbrushOption. This type of configuration is used by several different
+ * paintops.
+ * @param airbrushOption - The airbrushing option. Can be null for paintops that don't support
+ *                         airbrushing.
+ * @param spacingOption - The pressure-curve spacing option. Can be null for paintops that don't
+ *                        support pressure-based spacing.
+ * @param rateOption - The pressure-curve airbrush rate option. Can be null for paintops that don't
+ *                     support a pressure-based airbrush rate.
+ */
+
+KisSpacingInformation effectiveSpacing(qreal dabWidth,
+                                       qreal dabHeight,
+                                       bool isotropicSpacing,
+                                       qreal rotation,
+                                       bool axesFlipped,
+                                       qreal spacingVal,
+                                       bool autoSpacingActive,
+                                       qreal autoSpacingCoeff,
+                                       qreal lodScale,
+                                       const KisAirbrushOption *airbrushOption,
+                                       const KisPressureSpacingOption *spacingOption,
+                                       const KisPressureRateOption *rateOption,
+                                       const KisPaintInformation &pi)
+{
+    // Extract required parameters.
+    bool distanceSpacingEnabled = true;
+    bool timedSpacingEnabled = false;
+    qreal timedSpacingInterval = 0.0;
+    if (airbrushOption) {
+        timedSpacingEnabled = airbrushOption->isChecked();
+        distanceSpacingEnabled
+                = !(timedSpacingEnabled && airbrushOption->ignoreSpacing());
+        timedSpacingInterval = airbrushOption->airbrushInterval();
+    }
+    qreal extraScale = 1.0;
+    if (spacingOption && spacingOption->isChecked()) {
+        extraScale = spacingOption->apply(pi);
+    }
+    qreal rateExtraScale = 1.0;
+    if (rateOption && rateOption->isChecked()) {
+        rateExtraScale = rateOption->apply(pi);
+    }
+
+    return KisPaintOpUtils::effectiveSpacing(dabWidth, dabHeight, extraScale, rateExtraScale,
+                                             distanceSpacingEnabled, isotropicSpacing, rotation,
+                                             axesFlipped, spacingVal, autoSpacingActive,
+                                             autoSpacingCoeff, timedSpacingEnabled,
+                                             timedSpacingInterval, lodScale);
+}
+
+}
+
+#endif /* __KIS_PAINTOP_PLUGIN_UTILS_H */
diff --git a/plugins/paintops/libpaintop/kis_pressure_rate_option.cpp b/plugins/paintops/libpaintop/kis_pressure_rate_option.cpp
new file mode 100644
index 0000000000..337554bd5a
--- /dev/null
+++ b/plugins/paintops/libpaintop/kis_pressure_rate_option.cpp
@@ -0,0 +1,11 @@
+#include "kis_pressure_rate_option.h"
+
+KisPressureRateOption::KisPressureRateOption()
+    : KisCurveOption("Rate", KisPaintOpOption::GENERAL, false)
+{
+}
+
+double KisPressureRateOption::apply(const KisPaintInformation &info) const
+{
+    return isChecked() ? computeSizeLikeValue(info) : 1.0;
+}
diff --git a/plugins/paintops/libpaintop/kis_pressure_rate_option.h b/plugins/paintops/libpaintop/kis_pressure_rate_option.h
new file mode 100644
index 0000000000..726bb811b0
--- /dev/null
+++ b/plugins/paintops/libpaintop/kis_pressure_rate_option.h
@@ -0,0 +1,15 @@
+#ifndef KIS_PRESSURE_RATE_OPTION_H
+#define KIS_PRESSURE_RATE_OPTION_H
+
+#include "kis_curve_option.h"
+#include <brushengine/kis_paint_information.h>
+#include <kritapaintop_export.h>
+
+class PAINTOP_EXPORT KisPressureRateOption : public KisCurveOption
+{
+public:
+    KisPressureRateOption();
+    double apply(const KisPaintInformation &info) const;
+};
+
+#endif // KIS_PRESSURE_RATE_OPTION_H
diff --git a/plugins/paintops/particle/kis_particle_paintop.cpp b/plugins/paintops/particle/kis_particle_paintop.cpp
index ecb8d27428..45182e665a 100644
--- a/plugins/paintops/particle/kis_particle_paintop.cpp
+++ b/plugins/paintops/particle/kis_particle_paintop.cpp
@@ -1,94 +1,113 @@
 /*
  *  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 "kis_particle_paintop.h"
 #include "kis_particle_paintop_settings.h"
 
 #include <cmath>
 
 #include "kis_vec.h"
 
 #include <KoCompositeOp.h>
 
 #include <kis_image.h>
 #include <kis_debug.h>
 
 #include <kis_global.h>
 #include <kis_paint_device.h>
 #include <kis_painter.h>
+#include <kis_lod_transform.h>
 #include <kis_types.h>
+#include <kis_paintop_plugin_utils.h>
 #include <brushengine/kis_paintop.h>
 #include <brushengine/kis_paint_information.h>
 
 #include "kis_particleop_option.h"
 
 #include "particle_brush.h"
 
 KisParticlePaintOp::KisParticlePaintOp(const KisPaintOpSettingsSP settings, KisPainter * painter, KisNodeSP node, KisImageSP image)
     : KisPaintOp(painter)
 {
     Q_UNUSED(image);
     Q_UNUSED(node);
 
     m_properties.particleCount = settings->getInt(PARTICLE_COUNT);
     m_properties.iterations = settings->getInt(PARTICLE_ITERATIONS);
     m_properties.gravity = settings->getDouble(PARTICLE_GRAVITY);
     m_properties.weight = settings->getDouble(PARTICLE_WEIGHT);
     m_properties.scale = QPointF(settings->getDouble(PARTICLE_SCALE_X), settings->getDouble(PARTICLE_SCALE_Y));
 
     m_particleBrush.setProperties(&m_properties);
     m_particleBrush.initParticles();
 
+    m_airbrushOption.readOptionSetting(settings);
+
+    m_rateOption.readOptionSetting(settings);
+    m_rateOption.resetAllSensors();
+
     m_first = true;
 }
 
 KisParticlePaintOp::~KisParticlePaintOp()
 {
 }
 
 KisSpacingInformation KisParticlePaintOp::paintAt(const KisPaintInformation& info)
 {
-    KisDistanceInformation di;
-    paintLine(info, info, &di);
-    return di.currentSpacing();
+    doPaintLine(info, info);
+    return KisPaintOpPluginUtils::effectiveSpacing(0.0, 0.0, true, 0.0, false, 0.0, false, 0.0,
+                                                   KisLodTransform::lodToScale(painter()->device()),
+                                                   &m_airbrushOption, nullptr, &m_rateOption, info);
+}
+
+void KisParticlePaintOp::paintLine(const KisPaintInformation &pi1, const KisPaintInformation &pi2,
+                                   KisDistanceInformation *currentDistance)
+{
+    // Use superclass behavior for lines of zero length. Otherwise, airbrushing can happen faster
+    // than it is supposed to.
+    if (pi1.pos() == pi2.pos()) {
+        KisPaintOp::paintLine(pi1, pi2, currentDistance);
+    } else {
+        doPaintLine(pi1, pi2);
+    }
 }
 
-void KisParticlePaintOp::paintLine(const KisPaintInformation &pi1, const KisPaintInformation &pi2, KisDistanceInformation *currentDistance)
+void KisParticlePaintOp::doPaintLine(const KisPaintInformation &pi1, const KisPaintInformation &pi2)
 {
-    Q_UNUSED(currentDistance);
     if (!painter()) return;
 
     if (!m_dab) {
         m_dab = source()->createCompositionSourceDevice();
     }
     else {
         m_dab->clear();
     }
 
 
     if (m_first) {
         m_particleBrush.setInitialPosition(pi1.pos());
         m_first = false;
     }
 
     m_particleBrush.draw(m_dab, painter()->paintColor(), pi2.pos());
     QRect rc = m_dab->extent();
 
     painter()->bitBlt(rc.x(), rc.y(), m_dab, rc.x(), rc.y(), rc.width(), rc.height());
     painter()->renderMirrorMask(rc, m_dab);
 }
diff --git a/plugins/paintops/particle/kis_particle_paintop.h b/plugins/paintops/particle/kis_particle_paintop.h
index 0bd16e0386..ab85a4355e 100644
--- a/plugins/paintops/particle/kis_particle_paintop.h
+++ b/plugins/paintops/particle/kis_particle_paintop.h
@@ -1,49 +1,56 @@
 /*
  *  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.
  */
 
 #ifndef KIS_PARTICLE_PAINTOP_H_
 #define KIS_PARTICLE_PAINTOP_H_
 
 #include <brushengine/kis_paintop.h>
 #include <kis_types.h>
+#include <kis_airbrush_option.h>
+#include <kis_pressure_rate_option.h>
 
 #include "kis_particle_paintop_settings.h"
 #include "particle_brush.h"
 
 class KisPainter;
 class KisPaintInformation;
 
 class KisParticlePaintOp : public KisPaintOp
 {
 
 public:
 
     KisParticlePaintOp(const KisPaintOpSettingsSP settings, KisPainter * painter, KisNodeSP node, KisImageSP image);
     ~KisParticlePaintOp() override;
 
     KisSpacingInformation paintAt(const KisPaintInformation& info) override;
     void paintLine(const KisPaintInformation &pi1, const KisPaintInformation &pi2, KisDistanceInformation *currentDistance) override;
 
+private:
+    void doPaintLine(const KisPaintInformation &pi1, const KisPaintInformation &pi2);
+
 private:
     KisParticleBrushProperties m_properties;
     KisPaintDeviceSP m_dab;
     ParticleBrush m_particleBrush;
+    KisAirbrushOption m_airbrushOption;
+    KisPressureRateOption m_rateOption;
     bool m_first;
 };
 
 #endif // KIS_PARTICLE_PAINTOP_H_
diff --git a/plugins/paintops/particle/kis_particle_paintop_settings.cpp b/plugins/paintops/particle/kis_particle_paintop_settings.cpp
index b075519242..c631ceeafe 100644
--- a/plugins/paintops/particle/kis_particle_paintop_settings.cpp
+++ b/plugins/paintops/particle/kis_particle_paintop_settings.cpp
@@ -1,262 +1,252 @@
 /*
  *  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 "kis_particle_paintop_settings.h"
 
 #include "kis_particle_paintop_settings_widget.h"
 #include "kis_particleop_option.h"
 
 #include <kis_paint_action_type_option.h>
 #include <kis_airbrush_option.h>
 
 struct KisParticlePaintOpSettings::Private
 {
     QList<KisUniformPaintOpPropertyWSP> uniformProperties;
 };
 
 KisParticlePaintOpSettings::KisParticlePaintOpSettings()
     : m_d(new Private)
 {
 }
 
 KisParticlePaintOpSettings::~KisParticlePaintOpSettings()
 {
 }
 
 bool KisParticlePaintOpSettings::paintIncremental()
 {
     return (enumPaintActionType)getInt("PaintOpAction", WASH) == BUILDUP;
 }
 
-bool KisParticlePaintOpSettings::isAirbrushing() const
-{
-    return getBool(AIRBRUSH_ENABLED);
-}
-
-int KisParticlePaintOpSettings::rate() const
-{
-    return getInt(AIRBRUSH_RATE);
-}
-
 
 #include <brushengine/kis_slider_based_paintop_property.h>
 #include "kis_paintop_preset.h"
 #include "kis_paintop_settings_update_proxy.h"
 #include "kis_particleop_option.h"
 #include "kis_standard_uniform_properties_factory.h"
 
 
 QList<KisUniformPaintOpPropertySP> KisParticlePaintOpSettings::uniformProperties(KisPaintOpSettingsSP settings)
 {
     QList<KisUniformPaintOpPropertySP> props =
         listWeakToStrong(m_d->uniformProperties);
 
     if (props.isEmpty()) {
         {
             KisIntSliderBasedPaintOpPropertyCallback *prop =
                 new KisIntSliderBasedPaintOpPropertyCallback(
                     KisIntSliderBasedPaintOpPropertyCallback::Int,
                     "particle_particles",
                     i18n("Particles"),
                     settings, 0);
 
             prop->setRange(1, 500);
             prop->setSingleStep(1);
 
             prop->setReadCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     ParticleOption option;
                     option.readOptionSetting(prop->settings().data());
 
                     prop->setValue(int(option.particle_count));
                 });
             prop->setWriteCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     ParticleOption option;
                     option.readOptionSetting(prop->settings().data());
                     option.particle_count = prop->value().toInt();
                     option.writeOptionSetting(prop->settings().data());
                 });
 
             QObject::connect(preset()->updateProxy(), SIGNAL(sigSettingsChanged()), prop, SLOT(requestReadValue()));
             prop->requestReadValue();
             props << toQShared(prop);
         }
         {
             KisDoubleSliderBasedPaintOpPropertyCallback *prop =
                 new KisDoubleSliderBasedPaintOpPropertyCallback(
                     KisDoubleSliderBasedPaintOpPropertyCallback::Double,
                     "particle_opecityweight",
                     i18n("Opacity Weight"),
                     settings, 0);
 
             prop->setRange(0.01, 1.0);
             prop->setSingleStep(0.01);
             prop->setDecimals(2);
 
             prop->setReadCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     ParticleOption option;
                     option.readOptionSetting(prop->settings().data());
                     prop->setValue(option.particle_weight);
                 });
             prop->setWriteCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     ParticleOption option;
                     option.readOptionSetting(prop->settings().data());
                     option.particle_weight = prop->value().toReal();
                     option.writeOptionSetting(prop->settings().data());
                 });
 
             QObject::connect(preset()->updateProxy(), SIGNAL(sigSettingsChanged()), prop, SLOT(requestReadValue()));
             prop->requestReadValue();
             props << toQShared(prop);
         }
         {
             KisDoubleSliderBasedPaintOpPropertyCallback *prop =
                 new KisDoubleSliderBasedPaintOpPropertyCallback(
                     KisDoubleSliderBasedPaintOpPropertyCallback::Double,
                     "particle_dx_scale",
                     i18n("dx scale"),
                     settings, 0);
 
             prop->setRange(-2, 2);
             prop->setSingleStep(0.01);
             prop->setDecimals(2);
 
             prop->setReadCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     ParticleOption option;
                     option.readOptionSetting(prop->settings().data());
                     prop->setValue(option.particle_scale_x);
                 });
             prop->setWriteCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     ParticleOption option;
                     option.readOptionSetting(prop->settings().data());
                     option.particle_scale_x = prop->value().toReal();
                     option.writeOptionSetting(prop->settings().data());
                 });
 
             QObject::connect(preset()->updateProxy(), SIGNAL(sigSettingsChanged()), prop, SLOT(requestReadValue()));
             prop->requestReadValue();
             props << toQShared(prop);
         }
         {
             KisDoubleSliderBasedPaintOpPropertyCallback *prop =
                 new KisDoubleSliderBasedPaintOpPropertyCallback(
                     KisDoubleSliderBasedPaintOpPropertyCallback::Double,
                     "particle_dy_scale",
                     i18n("dy scale"),
                     settings, 0);
 
             prop->setRange(-2, 2);
             prop->setSingleStep(0.01);
             prop->setDecimals(2);
 
             prop->setReadCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     ParticleOption option;
                     option.readOptionSetting(prop->settings().data());
                     prop->setValue(option.particle_scale_y);
                 });
             prop->setWriteCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     ParticleOption option;
                     option.readOptionSetting(prop->settings().data());
                     option.particle_scale_y = prop->value().toReal();
                     option.writeOptionSetting(prop->settings().data());
                 });
 
             QObject::connect(preset()->updateProxy(), SIGNAL(sigSettingsChanged()), prop, SLOT(requestReadValue()));
             prop->requestReadValue();
             props << toQShared(prop);
         }
         {
             KisDoubleSliderBasedPaintOpPropertyCallback *prop =
                 new KisDoubleSliderBasedPaintOpPropertyCallback(
                     KisDoubleSliderBasedPaintOpPropertyCallback::Double,
                     "particle_gravity",
                     i18n("Gravity"),
                     settings, 0);
 
             prop->setRange(0.01, 1.0);
             prop->setSingleStep(0.01);
             prop->setDecimals(2);
 
             prop->setReadCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     ParticleOption option;
                     option.readOptionSetting(prop->settings().data());
                     prop->setValue(option.particle_gravity);
                 });
             prop->setWriteCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     ParticleOption option;
                     option.readOptionSetting(prop->settings().data());
                     option.particle_gravity = prop->value().toReal();
                     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,
                     "particle_iterations",
                     i18n("Iterations"),
                     settings, 0);
 
             prop->setRange(1, 300);
             prop->setSingleStep(1);
 
             prop->setReadCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     ParticleOption option;
                     option.readOptionSetting(prop->settings().data());
 
                     prop->setValue(int(option.particle_iterations));
                 });
             prop->setWriteCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     ParticleOption option;
                     option.readOptionSetting(prop->settings().data());
                     option.particle_iterations = 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()) {
                 props.prepend(prop);
             }
         }
     }
 
     return props;
 }
diff --git a/plugins/paintops/particle/kis_particle_paintop_settings.h b/plugins/paintops/particle/kis_particle_paintop_settings.h
index 84acccb212..bc461dc192 100644
--- a/plugins/paintops/particle/kis_particle_paintop_settings.h
+++ b/plugins/paintops/particle/kis_particle_paintop_settings.h
@@ -1,45 +1,43 @@
 /*
  *  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.
  */
 
 #ifndef KIS_PARTICLE_PAINTOP_SETTINGS_H_
 #define KIS_PARTICLE_PAINTOP_SETTINGS_H_
 
 #include <QScopedPointer>
 #include <brushengine/kis_no_size_paintop_settings.h>
 #include <kis_types.h>
 
 class KisParticlePaintOpSettings : public KisNoSizePaintOpSettings
 {
 
 public:
 
     KisParticlePaintOpSettings();
     ~KisParticlePaintOpSettings() override;
 
     bool paintIncremental() override;
-    bool isAirbrushing() const override;
-    int rate() const override;
 
     QList<KisUniformPaintOpPropertySP> uniformProperties(KisPaintOpSettingsSP settings) override;
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 #endif
diff --git a/plugins/paintops/particle/kis_particle_paintop_settings_widget.cpp b/plugins/paintops/particle/kis_particle_paintop_settings_widget.cpp
index 7956eed888..a5d87f7223 100644
--- a/plugins/paintops/particle/kis_particle_paintop_settings_widget.cpp
+++ b/plugins/paintops/particle/kis_particle_paintop_settings_widget.cpp
@@ -1,52 +1,56 @@
 /*
  *  Copyright (c) 2008 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_particle_paintop_settings_widget.h"
 
 #include "kis_particleop_option.h"
 #include "kis_particle_paintop_settings.h"
 
 #include <kis_paintop_settings_widget.h>
+#include <kis_curve_option_widget.h>
 #include <kis_paint_action_type_option.h>
 #include <kis_airbrush_option.h>
 #include <kis_compositeop_option.h>
+#include <kis_pressure_rate_option.h>
 
 KisParticlePaintOpSettingsWidget:: KisParticlePaintOpSettingsWidget(QWidget* parent)
     : KisPaintOpSettingsWidget(parent)
 {
     m_paintActionTypeOption = new KisPaintActionTypeOption();
     m_particleOption =  new KisParticleOpOption();
 
     addPaintOpOption(m_particleOption, i18n("Brush size"));
     addPaintOpOption(new KisCompositeOpOption(true), i18n("Blending Mode"));
-    addPaintOpOption(new KisAirbrushOption(), i18n("Airbrush"));
+    addPaintOpOption(new KisAirbrushOption(false, false), i18n("Airbrush"));
+    addPaintOpOption(new KisCurveOptionWidget(new KisPressureRateOption(), i18n("0%"),
+                                              i18n("100%")), i18n("Rate"));
     addPaintOpOption(m_paintActionTypeOption, i18n("Painting Mode"));
 }
 
 KisParticlePaintOpSettingsWidget::~ KisParticlePaintOpSettingsWidget()
 {
 }
 
 KisPropertiesConfigurationSP  KisParticlePaintOpSettingsWidget::configuration() const
 {
     KisParticlePaintOpSettings* config = new KisParticlePaintOpSettings();
     config->setOptionsWidget(const_cast<KisParticlePaintOpSettingsWidget*>(this));
     config->setProperty("paintop", "particlebrush"); // XXX: make this a const id string
     writeConfiguration(config);
     return config;
 }
diff --git a/plugins/paintops/roundmarker/kis_roundmarkerop.cpp b/plugins/paintops/roundmarker/kis_roundmarkerop.cpp
index d38d41a030..5652db39f6 100644
--- a/plugins/paintops/roundmarker/kis_roundmarkerop.cpp
+++ b/plugins/paintops/roundmarker/kis_roundmarkerop.cpp
@@ -1,149 +1,151 @@
 /*
  *  Copyright (c) 2016 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_roundmarkerop.h"
 
 #include <cmath>
 #include <memory>
 #include <QRect>
 
 #include <KoColorSpaceRegistry.h>
 #include <KoColor.h>
 #include <KoColorProfile.h>
 #include <KoCompositeOpRegistry.h>
 
 #include <kis_brush.h>
 #include <kis_global.h>
 #include <kis_paint_device.h>
 #include <kis_painter.h>
 #include <kis_image.h>
 #include <kis_selection.h>
 #include <kis_brush_based_paintop_settings.h>
 #include <kis_cross_device_color_picker.h>
 #include <kis_fixed_paint_device.h>
 #include <kis_lod_transform.h>
 #include "kis_marker_painter.h"
 #include "kis_paintop_utils.h"
 
 
 
 KisRoundMarkerOp::KisRoundMarkerOp(KisPaintOpSettingsSP settings, KisPainter* painter, KisNodeSP node, KisImageSP image)
     : KisPaintOp(painter)
     , m_firstRun(true)
     , m_image(image)
     , m_lastRadius(1.0)
 {
     Q_UNUSED(node);
 
     Q_ASSERT(settings);
     Q_ASSERT(painter);
 
     m_markerOption.readOptionSetting(*settings);
     m_sizeOption.readOptionSetting(settings);
     m_spacingOption.readOptionSetting(settings);
 
     m_sizeOption.resetAllSensors();
     m_spacingOption.resetAllSensors();
 }
 
 KisRoundMarkerOp::~KisRoundMarkerOp()
 {
 }
 
 KisSpacingInformation KisRoundMarkerOp::paintAt(const KisPaintInformation& info)
 {
     // Simple error catching
     if (!painter()->device()) {
         return KisSpacingInformation(1.0);
     }
 
     // get the scaling factor calculated by the size option
     const qreal lodScale = KisLodTransform::lodToScale(painter()->device());
     const qreal scale = m_sizeOption.apply(info) * lodScale;
     const qreal rotation = 0; // TODO
     const bool axesFlipped = false; // TODO
 
     const qreal diameter = m_markerOption.diameter * scale;
     qreal radius = 0.5 * diameter;
 
     if (KisPaintOpUtils::checkSizeTooSmall(scale, diameter, diameter)) return KisSpacingInformation();
     KisDabShape shape(scale, 1.0, rotation);
 
 
     QPointF pos = info.pos();
 
     KisMarkerPainter gc(painter()->device(), painter()->paintColor());
 
     if (m_firstRun) {
         gc.fillFullCircle(pos, radius);
     } else {
         gc.fillCirclesDiff(m_lastPaintPos, m_lastRadius,
                            pos, radius);
     }
 
     m_firstRun = false;
     m_lastPaintPos = pos;
     m_lastRadius = radius;
 
     QRectF dirtyRect(pos.x() - radius, pos.y() - radius,
                      2 * radius, 2 * radius);
     dirtyRect = kisGrowRect(dirtyRect, 1);
     painter()->addDirtyRect(dirtyRect.toAlignedRect());
 
     // QPointF scatteredPos =
     //     m_scatterOption.apply(info,
     //                           brush->maskWidth(shape, 0, 0, info),
     //                           brush->maskHeight(shape, 0, 0, info));
 
 
 
     //updateMask(info, scale, rotation, scatteredPos);
 
     //QPointF newCenterPos = QRectF(m_dstDabRect).center();
     /**
      * Save the center of the current dab to know where to read the
      * data during the next pass. We do not save scatteredPos here,
      * because it may differ slightly from the real center of the
      * brush (due to rounding effects), which will result in a
      * really weird quality.
      */
     //QRect srcDabRect = m_dstDabRect.translated((m_lastPaintPos - newCenterPos).toPoint());
 
     //m_lastPaintPos = newCenterPos;
 
     qreal extraSpacingScale = 1.0;
     if (m_spacingOption.isChecked()) {
         extraSpacingScale = m_spacingOption.apply(info);
     }
 
     KisSpacingInformation spacingInfo =
         KisPaintOpUtils::effectiveSpacing(diameter, diameter,
-                                          extraSpacingScale, true, rotation, axesFlipped,
+                                          extraSpacingScale, 1.0, true, true, rotation, axesFlipped,
                                           m_markerOption.spacing,
                                           m_markerOption.use_auto_spacing,
                                           m_markerOption.auto_spacing_coeff,
+                                          false,
+                                          0.0,
                                           lodScale);
 
     if (m_firstRun) {
         m_firstRun = false;
         return spacingInfo;
     }
 
 
     return spacingInfo;
 }
diff --git a/plugins/paintops/roundmarker/kis_roundmarkerop_settings.h b/plugins/paintops/roundmarker/kis_roundmarkerop_settings.h
index 5a29f2b006..28077d62f5 100644
--- a/plugins/paintops/roundmarker/kis_roundmarkerop_settings.h
+++ b/plugins/paintops/roundmarker/kis_roundmarkerop_settings.h
@@ -1,47 +1,57 @@
 /*
  *  Copyright (c) 2016 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KIS_ROUNDMARKEROP_SETTINGS_H
 #define __KIS_ROUNDMARKEROP_SETTINGS_H
 
 #include <QScopedPointer>
 #include <kis_paintop_settings.h>
 #include <kis_outline_generation_policy.h>
 
 
 class KisRoundMarkerOpSettings : public KisOutlineGenerationPolicy<KisPaintOpSettings>
 {
 public:
     KisRoundMarkerOpSettings();
     ~KisRoundMarkerOpSettings() override;
 
     bool paintIncremental() override;
 
     qreal paintOpSize() const override;
     void setPaintOpSize(qreal value) override;
 
+    bool isAirbrushing() const override
+    {
+        return false;
+    }
+
+    qreal airbrushInterval() const override
+    {
+        return 1000.0;
+    }
+
     QPainterPath brushOutline(const KisPaintInformation &info, OutlineMode mode) override;
 
     QList<KisUniformPaintOpPropertySP> uniformProperties(KisPaintOpSettingsSP settings) override;
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 #endif /* __KIS_ROUNDMARKEROP_SETTINGS_H */
diff --git a/plugins/paintops/sketch/kis_sketch_paintop.cpp b/plugins/paintops/sketch/kis_sketch_paintop.cpp
index c3c70dd4db..ba1e89f827 100644
--- a/plugins/paintops/sketch/kis_sketch_paintop.cpp
+++ b/plugins/paintops/sketch/kis_sketch_paintop.cpp
@@ -1,300 +1,315 @@
 /*
  *  Copyright (c) 2010 Lukáš Tvrdý <lukast.dev@gmail.com>
  *  Copyright (c) 2010 Ricardo Cabello <hello@mrdoob.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_sketch_paintop.h"
 #include "kis_sketch_paintop_settings.h"
 
 #include <cmath>
 #include <QRect>
 
 #include <KoColor.h>
 #include <KoColorSpace.h>
 
 #include <kis_image.h>
 #include <kis_debug.h>
 
 #include <kis_global.h>
 #include <kis_paint_device.h>
 #include <kis_painter.h>
 #include <kis_types.h>
+#include <kis_paintop_plugin_utils.h>
 #include <brushengine/kis_paintop.h>
 #include <brushengine/kis_paint_information.h>
 #include <kis_fixed_paint_device.h>
 
 #include <kis_pressure_opacity_option.h>
 #include <kis_dab_cache.h>
 #include "kis_lod_transform.h"
 
 
 #include <QtGlobal>
 
 /*
 * Based on Harmony project http://github.com/mrdoob/harmony/
 */
 // chrome : diff 0.2, sketchy : 0.3, fur: 0.5
 // fur : distance / thresholdDistance
 
 // shaded: opacity per line :/
 // ((1 - (d / 1000)) * 0.1 * BRUSH_PRESSURE), offset == 0
 // chrome: color per line :/
 //this.context.strokeStyle = "rgba(" + Math.floor(Math.random() * COLOR[0]) + ", " + Math.floor(Math.random() * COLOR[1]) + ", " + Math.floor(Math.random() * COLOR[2]) + ", " + 0.1 * BRUSH_PRESSURE + " )";
 
 // long fur
 // from: count + offset * -random
 // to: i point - (offset * -random)  + random * 2
 // probability distance / thresholdDistnace
 
 // shaded: probabity : paint always - 0.0 density
 
 KisSketchPaintOp::KisSketchPaintOp(const KisPaintOpSettingsSP settings, KisPainter *painter, KisNodeSP node, KisImageSP image)
     : KisPaintOp(painter)
 {
     Q_UNUSED(image);
     Q_UNUSED(node);
 
+    m_airbrushOption.readOptionSetting(settings);
     m_opacityOption.readOptionSetting(settings);
     m_sizeOption.readOptionSetting(settings);
     m_rotationOption.readOptionSetting(settings);
+    m_rateOption.readOptionSetting(settings);
     m_sketchProperties.readOptionSetting(settings);
     m_brushOption.readOptionSettingForceCopy(settings);
     m_densityOption.readOptionSetting(settings);
     m_lineWidthOption.readOptionSetting(settings);
     m_offsetScaleOption.readOptionSetting(settings);
 
     m_brush = m_brushOption.brush();
     m_dabCache = new KisDabCache(m_brush);
 
     m_opacityOption.resetAllSensors();
     m_sizeOption.resetAllSensors();
     m_rotationOption.resetAllSensors();
+    m_rateOption.resetAllSensors();
 
     m_painter = 0;
     m_count = 0;
 }
 
 KisSketchPaintOp::~KisSketchPaintOp()
 {
     delete m_painter;
     delete m_dabCache;
 }
 
 void KisSketchPaintOp::drawConnection(const QPointF& start, const QPointF& end, double lineWidth)
 {
     if (lineWidth == 1.0) {
         m_painter->drawThickLine(start, end, lineWidth, lineWidth);
     }
     else {
         m_painter->drawLine(start, end, lineWidth, true);
     }
 }
 
 void KisSketchPaintOp::updateBrushMask(const KisPaintInformation& info, qreal scale, qreal rotation)
 {
     QRect dstRect;
     m_maskDab = m_dabCache->fetchDab(m_dab->colorSpace(),
                                      painter()->paintColor(),
                                      info.pos(),
                                      KisDabShape(scale, 1.0, rotation),
                                      info, 1.0,
                                      &dstRect);
 
     m_brushBoundingBox = dstRect;
     m_hotSpot = QPointF(0.5 * m_brushBoundingBox.width(),
                         0.5 * m_brushBoundingBox.height());
 }
 
-void KisSketchPaintOp::paintLine(const KisPaintInformation &pi1, const KisPaintInformation &pi2, KisDistanceInformation *currentDistance)
+void KisSketchPaintOp::paintLine(const KisPaintInformation &pi1, const KisPaintInformation &pi2,
+                                 KisDistanceInformation *currentDistance)
+{
+    // Use superclass behavior for lines of zero length. Otherwise, airbrushing can happen faster
+    // than it is supposed to.
+    if (pi1.pos() == pi2.pos()) {
+        KisPaintOp::paintLine(pi1, pi2, currentDistance);
+    }
+    else {
+        doPaintLine(pi1, pi2);
+    }
+} 
+void KisSketchPaintOp::doPaintLine(const KisPaintInformation &pi1, const KisPaintInformation &pi2)
 {
-    Q_UNUSED(currentDistance);
-
     if (!m_brush || !painter()) return;
 
     if (!m_dab) {
         m_dab = source()->createCompositionSourceDevice();
         m_painter = new KisPainter(m_dab);
         m_painter->setPaintColor(painter()->paintColor());
     }
     else {
         m_dab->clear();
     }
 
     QPointF prevMouse = pi1.pos();
     QPointF mousePosition = pi2.pos();
     m_points.append(mousePosition);
 
 
     const qreal lodAdditionalScale = KisLodTransform::lodToScale(painter()->device());
     const qreal scale = lodAdditionalScale * m_sizeOption.apply(pi2);
     if ((scale * m_brush->width()) <= 0.01 || (scale * m_brush->height()) <= 0.01) return;
 
     const qreal currentLineWidth = qMax(0.9, lodAdditionalScale * m_lineWidthOption.apply(pi2, m_sketchProperties.lineWidth));
 
     const qreal currentOffsetScale = m_offsetScaleOption.apply(pi2, m_sketchProperties.offset);
     const double rotation = m_rotationOption.apply(pi2);
     const double currentProbability = m_densityOption.apply(pi2, m_sketchProperties.probability);
 
     // shaded: does not draw this line, chrome does, fur does
     if (m_sketchProperties.makeConnection) {
         drawConnection(prevMouse, mousePosition, currentLineWidth);
     }
 
 
     qreal thresholdDistance = 0.0;
 
     // update the mask for simple mode only once
     // determine the radius
     if (m_count == 0 && m_sketchProperties.simpleMode) {
         updateBrushMask(pi2, 1.0, 0.0);
         //m_radius = qMax(m_maskDab->bounds().width(),m_maskDab->bounds().height()) * 0.5;
         m_radius = 0.5 * qMax(m_brush->width(), m_brush->height());
     }
 
     if (!m_sketchProperties.simpleMode) {
         updateBrushMask(pi2, scale, rotation);
         m_radius = qMax(m_maskDab->bounds().width(), m_maskDab->bounds().height()) * 0.5;
         thresholdDistance = pow(m_radius, 2);
     }
 
     if (m_sketchProperties.simpleMode) {
         // update the radius according scale in simple mode
         thresholdDistance = pow(m_radius * scale, 2);
     }
 
     // determine density
     const qreal density = thresholdDistance * currentProbability;
 
     // probability behaviour
     qreal probability = 1.0 - currentProbability;
 
     QColor painterColor = painter()->paintColor().toQColor();
     QColor randomColor;
     KoColor color(m_dab->colorSpace());
 
     int w = m_maskDab->bounds().width();
     quint8 opacityU8 = 0;
     quint8 * pixel;
     qreal distance;
     QPoint  positionInMask;
     QPointF diff;
 
     int size = m_points.size();
     // MAIN LOOP
     for (int i = 0; i < size; i++) {
         diff = m_points.at(i) - mousePosition;
         distance = diff.x() * diff.x() + diff.y() * diff.y();
 
         // circle test
         bool makeConnection = false;
         if (m_sketchProperties.simpleMode) {
             if (distance < thresholdDistance) {
                 makeConnection = true;
             }
             // mask test
         }
         else {
             if (m_brushBoundingBox.contains(m_points.at(i))) {
                 positionInMask = (diff + m_hotSpot).toPoint();
                 uint pos = ((positionInMask.y() * w + positionInMask.x()) * m_maskDab->pixelSize());
                 if (pos < m_maskDab->allocatedPixels() * m_maskDab->pixelSize()) {
                     pixel = m_maskDab->data() + pos;
                     opacityU8 = m_maskDab->colorSpace()->opacityU8(pixel);
                     if (opacityU8 != 0) {
                         makeConnection = true;
                     }
                 }
             }
 
         }
 
         if (!makeConnection) {
             // check next point
             continue;
         }
 
         if (m_sketchProperties.distanceDensity) {
             probability =  distance / density;
         }
 
         KisRandomSourceSP randomSource = pi2.randomSource();
 
         // density check
         if (randomSource->generateNormalized() >= probability) {
             QPointF offsetPt = diff * currentOffsetScale;
 
             if (m_sketchProperties.randomRGB) {
                 /**
                  * Since the order of calculation of function
                  * parameters is not defined by C++ standard, we
                  * should generate values in an external code snippet
                  * which has a definite order of execution.
                  */
                 qreal r1 = randomSource->generateNormalized();
                 qreal r2 = randomSource->generateNormalized();
                 qreal r3 = randomSource->generateNormalized();
 
                 // some color transformation per line goes here
                 randomColor.setRgbF(r1 * painterColor.redF(),
                                     r2 * painterColor.greenF(),
                                     r3 * painterColor.blueF());
                 color.fromQColor(randomColor);
                 m_painter->setPaintColor(color);
             }
 
             // distance based opacity
             quint8 opacity = OPACITY_OPAQUE_U8;
             if (m_sketchProperties.distanceOpacity) {
                 opacity *= qRound((1.0 - (distance / thresholdDistance)));
             }
 
             if (m_sketchProperties.randomOpacity) {
                 opacity *= randomSource->generateNormalized();
             }
 
             m_painter->setOpacity(opacity);
 
             if (m_sketchProperties.magnetify) {
                 drawConnection(mousePosition + offsetPt, m_points.at(i) - offsetPt, currentLineWidth);
             }
             else {
                 drawConnection(mousePosition + offsetPt, mousePosition - offsetPt, currentLineWidth);
             }
 
 
 
         }
     }// end of MAIN LOOP
 
     m_count++;
 
     QRect rc = m_dab->extent();
     quint8 origOpacity = m_opacityOption.apply(painter(), pi2);
 
     painter()->bitBlt(rc.x(), rc.y(), m_dab, rc.x(), rc.y(), rc.width(), rc.height());
     painter()->renderMirrorMask(rc, m_dab);
     painter()->setOpacity(origOpacity);
 }
 
 
 
 KisSpacingInformation KisSketchPaintOp::paintAt(const KisPaintInformation& info)
 {
-    KisDistanceInformation di;
-    paintLine(info, info, &di);
-    return di.currentSpacing();
+    doPaintLine(info, info);
+    return KisPaintOpPluginUtils::effectiveSpacing(0.0, 0.0, true, 0.0, false, 0.0, false, 0.0,
+                                                   KisLodTransform::lodToScale(painter()->device()),
+                                                   &m_airbrushOption, nullptr, &m_rateOption, info);
 }
diff --git a/plugins/paintops/sketch/kis_sketch_paintop.h b/plugins/paintops/sketch/kis_sketch_paintop.h
index e6b233e305..3f21bb1eb7 100644
--- a/plugins/paintops/sketch/kis_sketch_paintop.h
+++ b/plugins/paintops/sketch/kis_sketch_paintop.h
@@ -1,84 +1,88 @@
 /*
  *  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.
  */
 
 #ifndef KIS_SKETCH_PAINTOP_H_
 #define KIS_SKETCH_PAINTOP_H_
 
 #include <brushengine/kis_paintop.h>
 #include <kis_types.h>
 
 #include "kis_density_option.h"
 #include "kis_sketchop_option.h"
 #include "kis_sketch_paintop_settings.h"
 
 #include "kis_painter.h"
+#include <kis_airbrush_option.h>
 #include <kis_pressure_size_option.h>
 #include <kis_brush_option.h>
 #include <kis_pressure_rotation_option.h>
+#include <kis_pressure_rate_option.h>
 #include "kis_linewidth_option.h"
 #include "kis_offset_scale_option.h"
 
 class KisDabCache;
 
 
 class KisSketchPaintOp : public KisPaintOp
 {
 
 public:
 
     KisSketchPaintOp(const KisPaintOpSettingsSP settings, KisPainter *painter, KisNodeSP node, KisImageSP image);
     ~KisSketchPaintOp() override;
 
     void paintLine(const KisPaintInformation &pi1, const KisPaintInformation &pi2, KisDistanceInformation *currentDistance) override;
     KisSpacingInformation paintAt(const KisPaintInformation& info) override;
 
 private:
     // pixel buffer
     KisPaintDeviceSP m_dab;
 
     // mask detection area
     KisFixedPaintDeviceSP m_maskDab;
     QRectF m_brushBoundingBox;
     QPointF m_hotSpot;
 
     // simple mode
     qreal m_radius;
 
     KisPressureOpacityOption m_opacityOption;
     KisPressureSizeOption m_sizeOption;
     KisPressureRotationOption m_rotationOption;
+    KisPressureRateOption m_rateOption;
     KisDensityOption m_densityOption;
     KisLineWidthOption m_lineWidthOption;
     KisOffsetScaleOption m_offsetScaleOption;
+    KisAirbrushOption m_airbrushOption;
 
     KisBrushOption m_brushOption;
     SketchProperties m_sketchProperties;
 
     QVector<QPointF> m_points;
     int m_count;
     KisPainter * m_painter;
     KisBrushSP m_brush;
     KisDabCache *m_dabCache;
 
 private:
     void drawConnection(const QPointF &start, const QPointF &end, double lineWidth);
     void updateBrushMask(const KisPaintInformation& info, qreal scale, qreal rotation);
-
+    void doPaintLine(const KisPaintInformation &pi1, const KisPaintInformation &pi2);
 };
 
 #endif // KIS_SKETCH_PAINTOP_H_
diff --git a/plugins/paintops/sketch/kis_sketch_paintop_settings.cpp b/plugins/paintops/sketch/kis_sketch_paintop_settings.cpp
index 43588bbf1e..3b0572ff38 100644
--- a/plugins/paintops/sketch/kis_sketch_paintop_settings.cpp
+++ b/plugins/paintops/sketch/kis_sketch_paintop_settings.cpp
@@ -1,74 +1,64 @@
 /*
  *  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 "kis_sketch_paintop_settings.h"
 
 #include <kis_sketchop_option.h>
 
 #include <kis_paint_action_type_option.h>
 #include <kis_airbrush_option.h>
 #include "kis_current_outline_fetcher.h"
 
 
 KisSketchPaintOpSettings::KisSketchPaintOpSettings()
 {
 }
 
 bool KisSketchPaintOpSettings::paintIncremental()
 {
     return (enumPaintActionType)getInt("PaintOpAction", WASH) == BUILDUP;
 }
 
-bool KisSketchPaintOpSettings::isAirbrushing() const
-{
-    return getBool(AIRBRUSH_ENABLED);
-}
-
-int KisSketchPaintOpSettings::rate() const
-{
-    return getInt(AIRBRUSH_RATE);
-}
-
 QPainterPath KisSketchPaintOpSettings::brushOutline(const KisPaintInformation &info, OutlineMode mode)
 {
     bool isSimpleMode = getBool(SKETCH_USE_SIMPLE_MODE);
 
     if (!isSimpleMode) {
         return KisBrushBasedPaintOpSettings::brushOutline(info, mode);
     }
 
     KisBrushBasedPaintopOptionWidget *widget = dynamic_cast<KisBrushBasedPaintopOptionWidget*>(optionsWidget());
     QPainterPath path;
 
     if (widget && (mode == CursorIsOutline || mode == CursorIsCircleOutline || mode == CursorTiltOutline)) {
         KisBrushSP brush = widget->brush();
         // just circle supported
         qreal diameter = qMax(brush->width(), brush->height());
         path = ellipseOutline(diameter, diameter, 1.0, 0.0/*brush->scale(), brush->angle()*/);
 
         QPainterPath tiltLine =
             makeTiltIndicator(info, path.boundingRect().center(), diameter * 0.5, 3.0);
         path = outlineFetcher()->fetchOutline(info, this, path);
         if (mode == CursorTiltOutline) {
             tiltLine.translate(info.pos());
             path.addPath(outlineFetcher()->fetchOutline(info, this, tiltLine, 1.0, 0.0, true, path.boundingRect().center().x(), path.boundingRect().center().y()));
         }
     }
     return path;
 }
 
diff --git a/plugins/paintops/sketch/kis_sketch_paintop_settings.h b/plugins/paintops/sketch/kis_sketch_paintop_settings.h
index ad5a7e6557..581e698e45 100644
--- a/plugins/paintops/sketch/kis_sketch_paintop_settings.h
+++ b/plugins/paintops/sketch/kis_sketch_paintop_settings.h
@@ -1,46 +1,44 @@
 /*
  *  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.
  */
 
 #ifndef KIS_SKETCH_PAINTOP_SETTINGS_H_
 #define KIS_SKETCH_PAINTOP_SETTINGS_H_
 
 #include <kis_brush_based_paintop_settings.h>
 #include <kis_types.h>
 
 #include "kis_sketch_paintop_settings_widget.h"
 
 #include <kis_pressure_opacity_option.h>
 
 
 class KisSketchPaintOpSettings : public KisBrushBasedPaintOpSettings
 {
 
 public:
     KisSketchPaintOpSettings();
     ~KisSketchPaintOpSettings() override {}
 
     QPainterPath brushOutline(const KisPaintInformation &info, OutlineMode mode) override;
 
     bool paintIncremental() override;
-    bool isAirbrushing() const override;
-    int rate() const override;
 };
 
 typedef KisSharedPtr<KisSketchPaintOpSettings> KisSketchPaintOpSettingsSP;
 
 #endif
diff --git a/plugins/paintops/sketch/kis_sketch_paintop_settings_widget.cpp b/plugins/paintops/sketch/kis_sketch_paintop_settings_widget.cpp
index d3412e85d2..365d9698f0 100644
--- a/plugins/paintops/sketch/kis_sketch_paintop_settings_widget.cpp
+++ b/plugins/paintops/sketch/kis_sketch_paintop_settings_widget.cpp
@@ -1,86 +1,88 @@
 /*
  *  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 "kis_sketch_paintop_settings_widget.h"
 
 #include "kis_sketchop_option.h"
 #include "kis_sketch_paintop_settings.h"
 
 #include <kis_curve_option_widget.h>
 #include <kis_pressure_opacity_option.h>
 #include <kis_paintop_settings_widget.h>
 #include <kis_paint_action_type_option.h>
 #include <kis_airbrush_option.h>
 #include <kis_pressure_size_option.h>
+#include <kis_pressure_rate_option.h>
 #include <kis_compositeop_option.h>
 
 #include <QDomDocument>
 #include <QDomElement>
 #include <kis_pressure_rotation_option.h>
 #include "kis_density_option.h"
 #include "kis_linewidth_option.h"
 #include "kis_offset_scale_option.h"
 
 KisSketchPaintOpSettingsWidget::KisSketchPaintOpSettingsWidget(QWidget* parent)
     : KisBrushBasedPaintopOptionWidget(parent)
 {
     m_sketchOption =  new KisSketchOpOption();
 
     addPaintOpOption(m_sketchOption, i18n("Brush size"));
     addPaintOpOption(new KisCompositeOpOption(true), i18n("Blending Mode"));
     addPaintOpOption(new KisCurveOptionWidget(new KisPressureOpacityOption(), i18n("Transparent"), i18n("Opaque")), i18n("Opacity"));
     addPaintOpOption(new KisCurveOptionWidget(new KisPressureSizeOption(), i18n("0%"), i18n("100%")), i18n("Size"));
     addPaintOpOption(new KisCurveOptionWidget(new KisPressureRotationOption(), i18n("-180°"), i18n("180°")), i18n("Rotation"));
     addPaintOpOption(new KisCurveOptionWidget(new KisLineWidthOption()  , i18n("0%"), i18n("100%")), i18n("Line width"));
     addPaintOpOption(new KisCurveOptionWidget(new KisOffsetScaleOption(), i18n("0%"), i18n("100%")), i18n("Offset scale"));
     addPaintOpOption(new KisCurveOptionWidget(new KisDensityOption(), i18n("0%"), i18n("100%")), i18n("Density"));
-    addPaintOpOption(new KisAirbrushOption(false), i18n("Airbrush"));
+    addPaintOpOption(new KisAirbrushOption(false, false), i18n("Airbrush"));
+    addPaintOpOption(new KisCurveOptionWidget(new KisPressureRateOption(), i18n("0%"), i18n("100%")), i18n("Rate"));
 
     m_paintActionType = new KisPaintActionTypeOption();
     KisPropertiesConfigurationSP defaultSetting = new KisPropertiesConfiguration();
     defaultSetting->setProperty("PaintOpAction", BUILDUP);
     m_paintActionType->readOptionSetting(defaultSetting);
 
     addPaintOpOption(m_paintActionType, i18n("Painting Mode"));
 
     KisPropertiesConfigurationSP reconfigurationCourier = configuration();
     QDomDocument xMLAnalyzer;
     xMLAnalyzer.setContent(reconfigurationCourier->getString("brush_definition"));
 
     QDomElement firstTag = xMLAnalyzer.documentElement();
     QDomElement firstTagsChild = firstTag.elementsByTagName("MaskGenerator").item(0).toElement();
 
     firstTagsChild.attributeNode("diameter").setValue("128");
 
     reconfigurationCourier->setProperty("brush_definition", xMLAnalyzer.toString());
     setConfiguration(reconfigurationCourier);
 }
 
 KisSketchPaintOpSettingsWidget::~ KisSketchPaintOpSettingsWidget()
 {
 }
 
 KisPropertiesConfigurationSP  KisSketchPaintOpSettingsWidget::configuration() const
 {
     KisSketchPaintOpSettingsSP config = new KisSketchPaintOpSettings();
     config->setOptionsWidget(const_cast<KisSketchPaintOpSettingsWidget*>(this));
     config->setProperty("paintop", "sketchbrush"); // XXX: make this a const id string
     writeConfiguration(config);
     return config;
 }
 
diff --git a/plugins/paintops/spray/kis_spray_paintop.cpp b/plugins/paintops/spray/kis_spray_paintop.cpp
index 835beafbf4..7ba0c3e92b 100644
--- a/plugins/paintops/spray/kis_spray_paintop.cpp
+++ b/plugins/paintops/spray/kis_spray_paintop.cpp
@@ -1,131 +1,138 @@
 /*
  *  Copyright (c) 2008-2012 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_spray_paintop.h"
 #include "kis_spray_paintop_settings.h"
 
 #include <cmath>
 
 #include <QRect>
 #include <kis_global.h>
 #include <kis_paint_device.h>
 #include <kis_painter.h>
 #include <kis_types.h>
 #include <brushengine/kis_paintop.h>
 #include <kis_node.h>
 
 #include <kis_pressure_rotation_option.h>
 #include <kis_pressure_opacity_option.h>
 #include <kis_pressure_size_option.h>
 #include <kis_fixed_paint_device.h>
 #include <kis_brush_option.h>
 #include <kis_sprayop_option.h>
 #include <kis_spray_shape_option.h>
 #include <kis_color_option.h>
 #include <kis_lod_transform.h>
+#include <kis_paintop_plugin_utils.h>
 
 
 KisSprayPaintOp::KisSprayPaintOp(const KisPaintOpSettingsSP settings, KisPainter *painter, KisNodeSP node, KisImageSP image)
     : KisPaintOp(painter)
-    , m_settings(static_cast<KisSprayPaintOpSettings*>(const_cast<KisPaintOpSettings*>(settings.data())))
     , m_isPresetValid(true)
     , m_node(node)
 {
     Q_ASSERT(settings);
     Q_ASSERT(painter);
     Q_UNUSED(image);
 
+    m_airbrushOption.readOptionSetting(settings);
+
     m_rotationOption.readOptionSetting(settings);
     m_opacityOption.readOptionSetting(settings);
     m_sizeOption.readOptionSetting(settings);
+    m_rateOption.readOptionSetting(settings);
 
     m_rotationOption.resetAllSensors();
     m_opacityOption.resetAllSensors();
     m_sizeOption.resetAllSensors();
+    m_rateOption.resetAllSensors();
 
     m_brushOption.readOptionSettingForceCopy(settings);
 
     m_colorProperties.fillProperties(settings);
     m_properties.readOptionSetting(settings);
     // first load tip properties as shape properties are dependent on diameter/scale/aspect
     m_shapeProperties.loadSettings(settings, m_properties.diameter * m_properties.scale, m_properties.diameter * m_properties.aspect * m_properties.scale);
 
     // TODO: what to do with proportional sizes?
     m_shapeDynamicsProperties.loadSettings(settings);
 
     if (!m_shapeProperties.enabled && !m_brushOption.brush()) {
         // in case the preset does not contain the definition for KisBrush
         m_isPresetValid = false;
         dbgKrita << "Preset is not valid. Painting is not possible. Use the preset editor to fix current brush engine preset.";
     }
 
     m_sprayBrush.setProperties(&m_properties, &m_colorProperties,
                                &m_shapeProperties, &m_shapeDynamicsProperties, m_brushOption.brush());
 
     m_sprayBrush.setFixedDab(cachedDab());
 
     // spacing
     if ((m_properties.diameter * 0.5) > 1) {
         m_ySpacing = m_xSpacing = m_properties.diameter * 0.5 * m_properties.spacing;
     }
     else {
         m_ySpacing = m_xSpacing = 1.0;
     }
     m_spacing = m_xSpacing;
 }
 
 KisSprayPaintOp::~KisSprayPaintOp()
 {
 }
 
 KisSpacingInformation KisSprayPaintOp::paintAt(const KisPaintInformation& info)
 {
     if (!painter() || !m_isPresetValid) {
         return KisSpacingInformation(m_spacing);
     }
 
     if (!m_dab) {
         m_dab = source()->createCompositionSourceDevice();
     }
     else {
         m_dab->clear();
     }
 
     qreal rotation = m_rotationOption.apply(info);
     quint8 origOpacity = m_opacityOption.apply(painter(), info);
     // Spray Brush is capable of working with zero scale,
     // so no additional checks for 'zero'ness are needed
     const qreal scale = m_sizeOption.apply(info);
     const qreal additionalScale = KisLodTransform::lodToScale(painter()->device());
 
 
     m_sprayBrush.paint(m_dab,
                        m_node->paintDevice(),
                        info,
                        rotation,
                        scale, additionalScale,
                        painter()->paintColor(),
                        painter()->backgroundColor());
 
     QRect rc = m_dab->extent();
     painter()->bitBlt(rc.topLeft(), m_dab, rc);
     painter()->renderMirrorMask(rc, m_dab);
     painter()->setOpacity(origOpacity);
 
-    return KisSpacingInformation(m_spacing * additionalScale);
+    return KisPaintOpPluginUtils::effectiveSpacing(1.0, 1.0, true, 0.0, false,
+                                                   m_spacing * additionalScale, false, 1.0,
+                                                   KisLodTransform::lodToScale(painter()->device()),
+                                                   &m_airbrushOption, nullptr, &m_rateOption, info);
 }
diff --git a/plugins/paintops/spray/kis_spray_paintop.h b/plugins/paintops/spray/kis_spray_paintop.h
index 82241f616d..ef4420e3d2 100644
--- a/plugins/paintops/spray/kis_spray_paintop.h
+++ b/plugins/paintops/spray/kis_spray_paintop.h
@@ -1,64 +1,66 @@
 /*
  *  Copyright (c) 2008-2012 Lukáš Tvrdý <lukast.dev@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_SPRAY_PAINTOP_H_
 #define KIS_SPRAY_PAINTOP_H_
 
 #include <brushengine/kis_paintop.h>
 #include <kis_types.h>
 
 #include "spray_brush.h"
 #include "kis_spray_paintop_settings.h"
 #include "kis_brush_option.h"
+#include <kis_airbrush_option.h>
 #include <kis_pressure_rotation_option.h>
 #include <kis_pressure_opacity_option.h>
 #include <kis_pressure_size_option.h>
+#include <kis_pressure_rate_option.h>
 
 class KisPainter;
 
 
 class KisSprayPaintOp : public KisPaintOp
 {
 
 public:
 
     KisSprayPaintOp(const KisPaintOpSettingsSP settings, KisPainter * painter, KisNodeSP node, KisImageSP image);
     ~KisSprayPaintOp() override;
 
     KisSpacingInformation paintAt(const KisPaintInformation& info) override;
 
 private:
     KisShapeProperties m_shapeProperties;
     KisSprayProperties m_properties;
     KisShapeDynamicsProperties m_shapeDynamicsProperties;
     KisColorProperties m_colorProperties;
     KisBrushOption m_brushOption;
 
-    KisSprayPaintOpSettingsSP m_settings;
-
     KisPaintDeviceSP m_dab;
     SprayBrush m_sprayBrush;
     qreal m_xSpacing, m_ySpacing, m_spacing;
     bool m_isPresetValid;
+    KisAirbrushOption m_airbrushOption;
     KisPressureRotationOption m_rotationOption;
     KisPressureSizeOption m_sizeOption;
     KisPressureOpacityOption m_opacityOption;
+    KisPressureRateOption m_rateOption;
     KisNodeSP m_node;
 };
 
 #endif // KIS_SPRAY_PAINTOP_H_
diff --git a/plugins/paintops/spray/kis_spray_paintop_settings.cpp b/plugins/paintops/spray/kis_spray_paintop_settings.cpp
index 154562824b..865d148757 100644
--- a/plugins/paintops/spray/kis_spray_paintop_settings.cpp
+++ b/plugins/paintops/spray/kis_spray_paintop_settings.cpp
@@ -1,239 +1,229 @@
 /*
  *  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 <cmath>
 
 #include <kis_paint_action_type_option.h>
 #include <kis_color_option.h>
 
 #include "kis_spray_paintop_settings.h"
 #include "kis_sprayop_option.h"
 #include "kis_spray_shape_option.h"
 #include <kis_airbrush_option.h>
 
 struct KisSprayPaintOpSettings::Private
 {
     QList<KisUniformPaintOpPropertyWSP> uniformProperties;
 };
 
 
 KisSprayPaintOpSettings::KisSprayPaintOpSettings()
     : KisOutlineGenerationPolicy<KisPaintOpSettings>(KisCurrentOutlineFetcher::SIZE_OPTION |
                                                      KisCurrentOutlineFetcher::ROTATION_OPTION),
     m_d(new Private)
 {
 }
 
 KisSprayPaintOpSettings::~KisSprayPaintOpSettings()
 {
 }
 
 void KisSprayPaintOpSettings::setPaintOpSize(qreal value)
 {
     KisSprayProperties option;
     option.readOptionSetting(this);
     option.diameter = value;
     option.writeOptionSetting(this);
 }
 
 qreal KisSprayPaintOpSettings::paintOpSize() const
 {
 
     KisSprayProperties option;
     option.readOptionSetting(this);
 
     return option.diameter;
 }
 
 bool KisSprayPaintOpSettings::paintIncremental()
 {
     return (enumPaintActionType)getInt("PaintOpAction", WASH) == BUILDUP;
 }
 
-bool KisSprayPaintOpSettings::isAirbrushing() const
-{
-    return getBool(AIRBRUSH_ENABLED);
-}
-
-int KisSprayPaintOpSettings::rate() const
-{
-    return getInt(AIRBRUSH_RATE);
-}
-
 
 QPainterPath KisSprayPaintOpSettings::brushOutline(const KisPaintInformation &info, OutlineMode mode)
 {
     QPainterPath path;
     if (mode == CursorIsOutline || mode == CursorIsCircleOutline || mode == CursorTiltOutline) {
         qreal width = getInt(SPRAY_DIAMETER);
         qreal height = getInt(SPRAY_DIAMETER) * getDouble(SPRAY_ASPECT);
         path = ellipseOutline(width, height, getDouble(SPRAY_SCALE), getDouble(SPRAY_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 "kis_paintop_preset.h"
 #include "kis_paintop_settings_update_proxy.h"
 #include "kis_standard_uniform_properties_factory.h"
 
 
 QList<KisUniformPaintOpPropertySP> KisSprayPaintOpSettings::uniformProperties(KisPaintOpSettingsSP settings)
 {
     QList<KisUniformPaintOpPropertySP> props =
         listWeakToStrong(m_d->uniformProperties);
 
     if (props.isEmpty()) {
         {
             KisDoubleSliderBasedPaintOpPropertyCallback *prop =
                 new KisDoubleSliderBasedPaintOpPropertyCallback(
                     KisDoubleSliderBasedPaintOpPropertyCallback::Double,
                     "spacing",
                     i18n("Spacing"),
                     settings, 0);
 
             prop->setRange(0.01, 10);
             prop->setSingleStep(0.01);
             prop->setExponentRatio(3.0);
 
             prop->setReadCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisSprayProperties option;
                     option.readOptionSetting(prop->settings().data());
 
                     prop->setValue(option.spacing);
                 });
             prop->setWriteCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisSprayProperties option;
                     option.readOptionSetting(prop->settings().data());
                     option.spacing = prop->value().toReal();
                     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,
                     "spray_particlecount",
                     i18n("Particle Count"),
                     settings, 0);
 
             prop->setRange(0, 1000);
             prop->setExponentRatio(3);
 
             prop->setReadCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisSprayProperties option;
                     option.readOptionSetting(prop->settings().data());
 
                     prop->setValue(int(option.particleCount));
                 });
             prop->setWriteCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisSprayProperties option;
                     option.readOptionSetting(prop->settings().data());
                     option.particleCount = prop->value().toInt();
                     option.writeOptionSetting(prop->settings().data());
                 });
             prop->setIsVisibleCallback(
                 [](const KisUniformPaintOpProperty *prop) {
                     KisSprayProperties option;
                     option.readOptionSetting(prop->settings().data());
                     return !option.useDensity;
                 });
 
             QObject::connect(preset()->updateProxy(), SIGNAL(sigSettingsChanged()), prop, SLOT(requestReadValue()));
             prop->requestReadValue();
             props << toQShared(prop);
         }
         {
             KisDoubleSliderBasedPaintOpPropertyCallback *prop =
                 new KisDoubleSliderBasedPaintOpPropertyCallback(
                     KisDoubleSliderBasedPaintOpPropertyCallback::Double,
                     "spray_density",
                     i18n("Density"),
                     settings, 0);
 
             prop->setRange(0.1, 100);
             prop->setSingleStep(0.01);
             prop->setDecimals(2);
             prop->setExponentRatio(3);
             prop->setSuffix(i18n("%"));
 
             prop->setReadCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisSprayProperties option;
                     option.readOptionSetting(prop->settings().data());
                     prop->setValue(option.coverage);
                 });
             prop->setWriteCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisSprayProperties option;
                     option.readOptionSetting(prop->settings().data());
                     option.coverage = prop->value().toReal();
                     option.writeOptionSetting(prop->settings().data());
                 });
             prop->setIsVisibleCallback(
                 [](const KisUniformPaintOpProperty *prop) {
                     KisSprayProperties option;
                     option.readOptionSetting(prop->settings().data());
                     return option.useDensity;
                 });
 
             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/spray/kis_spray_paintop_settings.h b/plugins/paintops/spray/kis_spray_paintop_settings.h
index 40516f50ed..269814ec67 100644
--- a/plugins/paintops/spray/kis_spray_paintop_settings.h
+++ b/plugins/paintops/spray/kis_spray_paintop_settings.h
@@ -1,64 +1,62 @@
 /*
  *  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.
  */
 
 #ifndef KIS_SPRAY_PAINTOP_SETTINGS_H_
 #define KIS_SPRAY_PAINTOP_SETTINGS_H_
 
 #include <QScopedPointer>
 
 #include <brushengine/kis_no_size_paintop_settings.h>
 #include <kis_types.h>
 
 #include <kis_outline_generation_policy.h>
 #include "kis_spray_paintop_settings_widget.h"
 
 
 class KisSprayPaintOpSettings : public KisOutlineGenerationPolicy<KisPaintOpSettings>
 {
 public:
     KisSprayPaintOpSettings();
     ~KisSprayPaintOpSettings() override;
 
     void setPaintOpSize(qreal value) override;
     qreal paintOpSize() const override;
 
     QPainterPath brushOutline(const KisPaintInformation &info, OutlineMode mode) override;
 
     QString modelName() const override {
         return "airbrush";
     }
 
     bool paintIncremental() override;
-    bool isAirbrushing() const override;
-    int rate() const override;
 
 protected:
 
     QList<KisUniformPaintOpPropertySP> uniformProperties(KisPaintOpSettingsSP settings) override;
 
 private:
     Q_DISABLE_COPY(KisSprayPaintOpSettings)
 
     struct Private;
     const QScopedPointer<Private> m_d;
 
 };
 
 typedef KisSharedPtr<KisSprayPaintOpSettings> KisSprayPaintOpSettingsSP;
 
 #endif
diff --git a/plugins/paintops/spray/kis_spray_paintop_settings_widget.cpp b/plugins/paintops/spray/kis_spray_paintop_settings_widget.cpp
index e68912dd78..05ace53f44 100644
--- a/plugins/paintops/spray/kis_spray_paintop_settings_widget.cpp
+++ b/plugins/paintops/spray/kis_spray_paintop_settings_widget.cpp
@@ -1,67 +1,69 @@
 /*
  *  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_spray_paintop_settings_widget.h"
 
 #include "kis_sprayop_option.h"
 #include "kis_spray_paintop_settings.h"
 #include "kis_spray_shape_option.h"
 
 #include <kis_color_option.h>
 #include <kis_paintop_settings_widget.h>
 #include <kis_paint_action_type_option.h>
 
 #include <kis_pressure_rotation_option.h>
 #include <kis_pressure_opacity_option.h>
 #include <kis_pressure_size_option.h>
+#include <kis_pressure_rate_option.h>
 #include <kis_curve_option_widget.h>
 #include <kis_brush_option_widget.h>
 #include "kis_spray_shape_dynamics.h"
 #include <kis_airbrush_option.h>
 #include <kis_compositeop_option.h>
 
 KisSprayPaintOpSettingsWidget:: KisSprayPaintOpSettingsWidget(QWidget* parent)
     : KisPaintOpSettingsWidget(parent)
     , m_sprayArea(new KisSprayOpOption())
 {
     addPaintOpOption(m_sprayArea, i18n("Spray Area"));
     addPaintOpOption(new KisSprayShapeOption(), i18n("Spray shape"));
     addPaintOpOption(new KisBrushOptionWidget(), i18n("Brush Tip"));
     addPaintOpOption(new KisCurveOptionWidget(new KisPressureOpacityOption(), i18n("Transparent"), i18n("Opaque")), i18n("Opacity"));
     addPaintOpOption(new KisCurveOptionWidget(new KisPressureSizeOption(), i18n("0%"), i18n("100%")), i18n("Size"));
     addPaintOpOption(new KisCompositeOpOption(true), i18n("Blending Mode"));
 
     addPaintOpOption(new KisSprayShapeDynamicsOption(), i18n("Shape dynamics"));
     addPaintOpOption(new KisColorOption(), i18n("Color options"));
 
     addPaintOpOption(new KisCurveOptionWidget(new KisPressureRotationOption(), i18n("-180°"), i18n("180°")), i18n("Rotation"));
-    addPaintOpOption(new KisAirbrushOption(), i18n("Airbrush"));
+    addPaintOpOption(new KisAirbrushOption(false), i18n("Airbrush"));
+    addPaintOpOption(new KisCurveOptionWidget(new KisPressureRateOption(), i18n("0%"), i18n("100%")), i18n("Rate"));
     addPaintOpOption(new KisPaintActionTypeOption(), i18n("Painting Mode"));
 }
 
 KisSprayPaintOpSettingsWidget::~ KisSprayPaintOpSettingsWidget()
 {
 }
 
 KisPropertiesConfigurationSP  KisSprayPaintOpSettingsWidget::configuration() const
 {
     KisSprayPaintOpSettings* config = new KisSprayPaintOpSettings();
     config->setOptionsWidget(const_cast<KisSprayPaintOpSettingsWidget*>(this));
     config->setProperty("paintop", "spraybrush"); // XXX: make this a const id string
     writeConfiguration(config);
     return config;
 }
diff --git a/plugins/paintops/tangentnormal/kis_tangent_normal_paintop.cpp b/plugins/paintops/tangentnormal/kis_tangent_normal_paintop.cpp
index 871b5750cb..2116b9872d 100644
--- a/plugins/paintops/tangentnormal/kis_tangent_normal_paintop.cpp
+++ b/plugins/paintops/tangentnormal/kis_tangent_normal_paintop.cpp
@@ -1,232 +1,235 @@
 /*
  *  Copyright (C) 2015 Wolthera van Hövell tot Westerflier <griffinvalley@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_tangent_normal_paintop.h"
 
 #include <QRect>
 
 #include <KoColorSpaceRegistry.h>
 #include <KoColor.h>
 
 #include <kis_brush.h>
 #include <kis_paint_device.h>
 #include <kis_painter.h>
 #include <kis_node.h>
 #include <kis_brush_based_paintop_settings.h>
 #include <kis_fixed_paint_device.h>
 #include <kis_image.h>
 #include <kis_lod_transform.h>
 
 
 KisTangentNormalPaintOp::KisTangentNormalPaintOp(const KisPaintOpSettingsSP settings, KisPainter* painter, KisNodeSP node, KisImageSP image):
     KisBrushBasedPaintOp(settings, painter),
     m_opacityOption(node),
     m_tempDev(painter->device()->createCompositionSourceDevice())
 
 {
     Q_UNUSED(image);
     //Init, read settings, etc//
     m_tangentTiltOption.readOptionSetting(settings);
+    m_airbrushOption.readOptionSetting(settings);
     m_sizeOption.readOptionSetting(settings);
     m_opacityOption.readOptionSetting(settings);
     m_flowOption.readOptionSetting(settings);
     m_spacingOption.readOptionSetting(settings);
+    m_rateOption.readOptionSetting(settings);
     m_softnessOption.readOptionSetting(settings);
     m_sharpnessOption.readOptionSetting(settings);
     m_rotationOption.readOptionSetting(settings);
     m_scatterOption.readOptionSetting(settings);
 
     m_sizeOption.resetAllSensors();
     m_opacityOption.resetAllSensors();
     m_flowOption.resetAllSensors();
     m_spacingOption.resetAllSensors();
+    m_rateOption.resetAllSensors();
     m_softnessOption.resetAllSensors();
     m_sharpnessOption.resetAllSensors();
     m_rotationOption.resetAllSensors();
     m_scatterOption.resetAllSensors();
 
     m_dabCache->setSharpnessPostprocessing(&m_sharpnessOption);
     m_rotationOption.applyFanCornersInfo(this);
 }
 
 KisTangentNormalPaintOp::~KisTangentNormalPaintOp()
 {
     //destroy things here//
 }
 
 KisSpacingInformation KisTangentNormalPaintOp::paintAt(const KisPaintInformation& info)
 {
     /*
      * For the color, the precision of tilt is only 60x60, and the precision of direction and rotation are 360 and 360*90.
      * You can't get more precise than 8bit. Therefore, we will check if the current space is RGB,
      * if so we request a profile with that space and 8bit bit depth, if not, just sRGB
      */
     KoColor currentColor = painter()->paintColor();
     QString currentSpace = currentColor.colorSpace()->colorModelId().id();
     const KoColorSpace* rgbColorSpace = KoColorSpaceRegistry::instance()->rgb8();
     if (currentSpace != "RGBA") {
     rgbColorSpace = KoColorSpaceRegistry::instance()->rgb8();
     } else {
     rgbColorSpace = currentColor.colorSpace();
     }
     QVector <float> channelValues(4);
     qreal r, g, b;
 
     if (currentColor.colorSpace()->colorDepthId().id()=="F16" || currentColor.colorSpace()->colorDepthId().id()=="F32"){
         channelValues[0] = 0.5;//red
         channelValues[1] = 0.5;//green
         channelValues[2] = 1.0;//blue
         channelValues[3] = 1.0;//alpha, leave alone.
 
 
         m_tangentTiltOption.apply(info, &r, &g, &b);
 
         channelValues[0] = r;//red
         channelValues[1] = g;//green
         channelValues[2] = b;//blue
     } else {
         channelValues[0] = 1.0;//blue
         channelValues[1] = 0.5;//green
         channelValues[2] = 0.5;//red
         channelValues[3] = 1.0;//alpha, leave alone.
 
         m_tangentTiltOption.apply(info, &r, &g, &b);
 
         channelValues[0] = b;//blue
         channelValues[1] = g;//green
         channelValues[2] = r;//red
     }
 
     quint8 data[4];
     rgbColorSpace->fromNormalisedChannelsValue(data, channelValues);
     KoColor color(data, rgbColorSpace);//Should be default RGB(0.5,0.5,1.0)
     //draw stuff here, return kisspacinginformation.
     KisBrushSP brush = m_brush;
 
     if (!painter()->device() || !brush || !brush->canPaintFor(info)) {
         return KisSpacingInformation(1.0);
     }
 
     qreal scale    = m_sizeOption.apply(info);
     scale *= KisLodTransform::lodToScale(painter()->device());
     qreal rotation = m_rotationOption.apply(info);
     if (checkSizeTooSmall(scale)) return KisSpacingInformation();
     KisDabShape shape(scale, 1.0, rotation);
 
 
     QPointF cursorPos =
         m_scatterOption.apply(info,
                               brush->maskWidth(shape, 0, 0, info),
                               brush->maskHeight(shape, 0, 0, info));
 
     m_maskDab =
         m_dabCache->fetchDab(rgbColorSpace, color, cursorPos,
                              shape,
                              info, m_softnessOption.apply(info),
                              &m_dstDabRect);
 
     if (m_dstDabRect.isEmpty()) return KisSpacingInformation(1.0);
 
     QRect dabRect = m_maskDab->bounds();
 
     // sanity check
     Q_ASSERT(m_dstDabRect.size() == dabRect.size());
     Q_UNUSED(dabRect);
 
     quint8  oldOpacity = painter()->opacity();
     QString oldCompositeOpId = painter()->compositeOp()->id();
 
 
     m_opacityOption.setFlow(m_flowOption.apply(info));
     m_opacityOption.apply(painter(), info);
     //paint with the default color? Copied this from color smudge.//
     //painter()->setCompositeOp(COMPOSITE_COPY);
     //painter()->fill(0, 0, m_dstDabRect.width(), m_dstDabRect.height(), color);
     painter()->bltFixed(m_dstDabRect.topLeft(), m_maskDab, m_maskDab->bounds());
     painter()->renderMirrorMaskSafe(m_dstDabRect, m_maskDab, !m_dabCache->needSeparateOriginal());
 
     // restore orginal opacity and composite mode values
     painter()->setOpacity(oldOpacity);
     painter()->setCompositeOp(oldCompositeOpId);
 
-    return effectiveSpacing(scale, rotation,
-                            m_spacingOption, info);
+    return effectiveSpacing(scale, rotation, &m_airbrushOption, &m_spacingOption, &m_rateOption,
+                            info);
 }
 
 void KisTangentNormalPaintOp::paintLine(const KisPaintInformation& pi1, const KisPaintInformation& pi2, KisDistanceInformation *currentDistance)
 {
     if (m_sharpnessOption.isChecked() && m_brush && (m_brush->width() == 1) && (m_brush->height() == 1)) {
 
         if (!m_lineCacheDevice) {
             m_lineCacheDevice = m_tempDev;
         }
         else {
             m_lineCacheDevice->clear();
         }
 
         KisPainter p(m_lineCacheDevice);
     KoColor currentColor = painter()->paintColor();
     QString currentSpace = currentColor.colorSpace()->colorModelId().id();
     const KoColorSpace* rgbColorSpace = KoColorSpaceRegistry::instance()->rgb8();
     if (currentSpace != "RGBA") {
         rgbColorSpace = KoColorSpaceRegistry::instance()->rgb8();
     } else {
         rgbColorSpace = currentColor.colorSpace();
     }
     QVector <float> channelValues(4);
     qreal r, g, b;
 
     if (currentColor.colorSpace()->colorDepthId().id()=="F16" || currentColor.colorSpace()->colorDepthId().id()=="F32"){
         channelValues[0] = 0.5;//red
         channelValues[1] = 0.5;//green
         channelValues[2] = 1.0;//blue
         channelValues[3] = 1.0;//alpha, leave alone.
 
 
         m_tangentTiltOption.apply(pi2, &r, &g, &b);
 
         channelValues[0] = r;//red
         channelValues[1] = g;//green
         channelValues[2] = b;//blue
     } else {
         channelValues[0] = 1.0;//blue
         channelValues[1] = 0.5;//green
         channelValues[2] = 0.5;//red
         channelValues[3] = 1.0;//alpha, leave alone.
 
         m_tangentTiltOption.apply(pi2, &r, &g, &b);
 
         channelValues[0] = b;//blue
         channelValues[1] = g;//green
         channelValues[2] = r;//red
     }
 
     quint8 data[4];
     rgbColorSpace->fromNormalisedChannelsValue(data, channelValues);
     KoColor color(data, rgbColorSpace);
         p.setPaintColor(color);
         p.drawDDALine(pi1.pos(), pi2.pos());
 
         QRect rc = m_lineCacheDevice->extent();
         painter()->bitBlt(rc.x(), rc.y(), m_lineCacheDevice, rc.x(), rc.y(), rc.width(), rc.height());
     painter()->renderMirrorMask(rc, m_lineCacheDevice);
     }
     else {
         KisPaintOp::paintLine(pi1, pi2, currentDistance);
     }
 }
diff --git a/plugins/paintops/tangentnormal/kis_tangent_normal_paintop.h b/plugins/paintops/tangentnormal/kis_tangent_normal_paintop.h
index 15b74dc91b..ea036fccf9 100644
--- a/plugins/paintops/tangentnormal/kis_tangent_normal_paintop.h
+++ b/plugins/paintops/tangentnormal/kis_tangent_normal_paintop.h
@@ -1,70 +1,74 @@
 /*
  *  Copyright (C) 2015 Wolthera van Hövell tot Westerflier <griffinvalley@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_TANGENTNORMALPAINTOP_H_
 #define _KIS_TANGENTNORMALPAINTOP_H_
 
 #include <QRect>
 
 #include <kis_brush_based_paintop.h>
 #include <kis_types.h>
 
 #include <kis_pressure_size_option.h>
 #include <kis_tangent_tilt_option.h>
+#include <kis_airbrush_option.h>
 #include <kis_pressure_flow_opacity_option.h>
 #include <kis_pressure_spacing_option.h>
+#include <kis_pressure_rate_option.h>
 #include <kis_pressure_rotation_option.h>
 #include <kis_pressure_scatter_option.h>
 #include <kis_pressure_flow_option.h>
 #include <kis_pressure_softness_option.h>
 #include <kis_pressure_sharpness_option.h>
 
 class KisBrushBasedPaintOpSettings;
 class KisPainter;
 
 class KisTangentNormalPaintOp: public KisBrushBasedPaintOp
 {
 public:
     //public functions//
 
     /* Create a Tangent Normal Brush Operator*/
     KisTangentNormalPaintOp(const KisPaintOpSettingsSP settings, KisPainter* painter, KisNodeSP node, KisImageSP image);
     ~KisTangentNormalPaintOp() override;
 
     /*paint the dabs*/
     KisSpacingInformation paintAt(const KisPaintInformation& info) override;
     void paintLine(const KisPaintInformation &pi1, const KisPaintInformation &pi2, KisDistanceInformation *currentDistance) override;
 private:
     //private functions//
     KisPressureSizeOption m_sizeOption;
     KisFlowOpacityOption m_opacityOption;
     KisPressureSpacingOption m_spacingOption;
+    KisPressureRateOption m_rateOption;
     KisPressureRotationOption m_rotationOption;
     KisPressureScatterOption m_scatterOption;
     KisTangentTiltOption m_tangentTiltOption;
+    KisAirbrushOption m_airbrushOption;
     KisPressureSoftnessOption m_softnessOption;
     KisPressureSharpnessOption m_sharpnessOption;
     KisPressureFlowOption m_flowOption;
 
     KisFixedPaintDeviceSP m_maskDab;
     KisPaintDeviceSP m_tempDev;
     QRect m_dstDabRect;
 
     KisPaintDeviceSP m_lineCacheDevice;
 };
 #endif // _KIS_TANGENTNORMALPAINTOP_H_
diff --git a/plugins/paintops/tangentnormal/kis_tangent_normal_paintop_settings_widget.cpp b/plugins/paintops/tangentnormal/kis_tangent_normal_paintop_settings_widget.cpp
index 94babbbe01..631d1aafe6 100644
--- a/plugins/paintops/tangentnormal/kis_tangent_normal_paintop_settings_widget.cpp
+++ b/plugins/paintops/tangentnormal/kis_tangent_normal_paintop_settings_widget.cpp
@@ -1,86 +1,86 @@
 /*
  *  Copyright (C) 2015 Wolthera van Hövell tot Westerflier <griffinvalley@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_tangent_normal_paintop_settings_widget.h"
 #include "kis_brush_based_paintop_settings.h"
 #include "kis_tangent_tilt_option.h"
 
 #include <kis_properties_configuration.h>
 #include <kis_paintop_settings_widget.h>
-#include <kis_pressure_size_option.h>
 #include <kis_curve_option_widget.h>
 #include <kis_pressure_rotation_option.h>
 #include <kis_pressure_scatter_option_widget.h>
 #include <kis_pressure_opacity_option.h>
 #include <kis_pressure_flow_option.h>
 #include <kis_paint_action_type_option.h>
-#include <kis_pressure_spacing_option_widget.h>
 #include <kis_pressure_size_option.h>
 #include <kis_curve_option_widget.h>
 #include <kis_pressure_softness_option.h>
 #include <kis_pressure_sharpness_option_widget.h>
 #include <kis_airbrush_option.h>
 #include <kis_pressure_flow_opacity_option_widget.h>
 #include <kis_pressure_spacing_option_widget.h>
+#include <kis_pressure_rate_option.h>
 #include <kis_compositeop_option.h>
 #include "kis_texture_option.h"
 #include "kis_curve_option_widget.h"
 #include <kis_pressure_mirror_option_widget.h>
 #include "kis_pressure_texture_strength_option.h"
 
 
 
 KisTangentNormalPaintOpSettingsWidget::KisTangentNormalPaintOpSettingsWidget(QWidget* parent):
     KisBrushBasedPaintopOptionWidget(parent)
 {
     setObjectName("brush option widget");
     setPrecisionEnabled(true);
 
     addPaintOpOption(new KisCompositeOpOption(true), i18n("Blending Mode"));
     addPaintOpOption(new KisCurveOptionWidget(new KisPressureOpacityOption(), i18n("Transparent"), i18n("Opaque")), i18n("Opacity"));
     addPaintOpOption(new KisCurveOptionWidget(new KisPressureFlowOption(), i18n("0%"), i18n("100%")), i18n("Flow"));
     addPaintOpOption(new KisCurveOptionWidget(new KisPressureSizeOption(), i18n("0%"), i18n("100%")), i18n("Size"));
 
     addPaintOpOption(new KisTangentTiltOption(), i18n("Tangent Tilt"));
 
     addPaintOpOption(new KisPressureSpacingOptionWidget(), i18n("Spacing"));
     addPaintOpOption(new KisPressureMirrorOptionWidget(), i18n("Mirror"));
 
     addPaintOpOption(new KisCurveOptionWidget(new KisPressureSoftnessOption(), i18n("Soft"), i18n("Hard")), i18n("Softness"));
     addPaintOpOption(new KisPressureSharpnessOptionWidget(), i18n("Sharpness"));
     addPaintOpOption(new KisPressureScatterOptionWidget(), i18n("Scatter"));
     addPaintOpOption(new KisCurveOptionWidget(new KisPressureRotationOption(), i18n("-180°"), i18n("180°")), i18n("Rotation"));
     addPaintOpOption(new KisAirbrushOption(false), i18n("Airbrush"));
+    addPaintOpOption(new KisCurveOptionWidget(new KisPressureRateOption(), i18n("0%"), i18n("100%")), i18n("Rate"));
     addPaintOpOption(new KisPaintActionTypeOption(), i18n("Painting Mode"));
 
     addPaintOpOption(new KisTextureOption(), i18n("Pattern"));
     addPaintOpOption(new KisCurveOptionWidget(new KisPressureTextureStrengthOption(), i18n("Weak"), i18n("Strong")), i18n("Strength"));
 }
 
 KisTangentNormalPaintOpSettingsWidget::~KisTangentNormalPaintOpSettingsWidget() { }
 
 KisPropertiesConfigurationSP KisTangentNormalPaintOpSettingsWidget::configuration() const
 {
     KisBrushBasedPaintOpSettingsSP config = new KisBrushBasedPaintOpSettings();
     config->setOptionsWidget(const_cast<KisTangentNormalPaintOpSettingsWidget*>(this));
     config->setProperty("paintop", "tangentnormal");
     writeConfiguration(config);
     return config;
 }
 
 
diff --git a/plugins/tools/basictools/kis_tool_line_helper.cpp b/plugins/tools/basictools/kis_tool_line_helper.cpp
index c3541f7874..c70e529f11 100644
--- a/plugins/tools/basictools/kis_tool_line_helper.cpp
+++ b/plugins/tools/basictools/kis_tool_line_helper.cpp
@@ -1,174 +1,185 @@
 /*
  *  Copyright (c) 2014 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_tool_line_helper.h"
 
+#include "kis_algebra_2d.h"
 #include "kis_painting_information_builder.h"
 #include "kis_image.h"
 
 struct KisToolLineHelper::Private
 {
     Private(KisPaintingInformationBuilder *_infoBuilder)
         : infoBuilder(_infoBuilder),
           useSensors(true),
           enabled(true)
     {
     }
 
     QVector<KisPaintInformation> linePoints;
     KisPaintingInformationBuilder *infoBuilder;
     bool useSensors;
     bool enabled;
 };
 
 KisToolLineHelper::KisToolLineHelper(KisPaintingInformationBuilder *infoBuilder,
                                      const KUndo2MagicString &transactionText,
                                      KisRecordingAdapter *recordingAdapter)
     : KisToolFreehandHelper(infoBuilder,
                             transactionText,
                             recordingAdapter,
                             new KisSmoothingOptions(false)),
       m_d(new Private(infoBuilder))
 {
 }
 
 KisToolLineHelper::~KisToolLineHelper()
 {
     delete m_d;
 }
 
 void KisToolLineHelper::setEnabled(bool value)
 {
     m_d->enabled = value;
 }
 
 void KisToolLineHelper::setUseSensors(bool value)
 {
     m_d->useSensors = value;
 }
 
 void KisToolLineHelper::repaintLine(KoCanvasResourceManager *resourceManager,
                                     KisImageWSP image, KisNodeSP node,
                                     KisStrokesFacade *strokesFacade)
 {
     if (!m_d->enabled) return;
 
     cancelPaint();
     if (m_d->linePoints.isEmpty()) return;
 
+    qreal startAngle = 0.0;
+    if (m_d->linePoints.length() > 1) {
+        startAngle = KisAlgebra2D::directionBetweenPoints(m_d->linePoints[0].pos(),
+                                                          m_d->linePoints[1].pos(),
+                                                          0.0);
+    }
+
     QVector<KisPaintInformation>::const_iterator it = m_d->linePoints.constBegin();
     QVector<KisPaintInformation>::const_iterator end = m_d->linePoints.constEnd();
 
-    initPaintImpl(*it, resourceManager, image, node, strokesFacade);
+    initPaintImpl(startAngle, *it, resourceManager, image, node, strokesFacade);
     ++it;
 
     while (it != end) {
         paintLine(*(it - 1), *it);
         ++it;
     }
 }
 
 void KisToolLineHelper::start(KoPointerEvent *event, KoCanvasResourceManager *resourceManager)
 {
     if (!m_d->enabled) return;
 
+    // Ignore the elapsed stroke time, so that the line tool will behave as if the whole stroke is
+    // drawn at once. This should prevent any possible spurious dabs caused by airbrushing features.
     KisPaintInformation pi =
-            m_d->infoBuilder->startStroke(event, elapsedStrokeTime(), resourceManager);
+            m_d->infoBuilder->startStroke(event, 0, resourceManager);
 
     if (!m_d->useSensors) {
         pi = KisPaintInformation(pi.pos());
     }
 
     m_d->linePoints.append(pi);
 }
 
 void KisToolLineHelper::addPoint(KoPointerEvent *event, const QPointF &overridePos)
 {
     if (!m_d->enabled) return;
 
+    // Ignore the elapsed stroke time.
     KisPaintInformation pi =
-            m_d->infoBuilder->continueStroke(event, elapsedStrokeTime());
+            m_d->infoBuilder->continueStroke(event, 0);
 
     if (!m_d->useSensors) {
         pi = KisPaintInformation(pi.pos());
     }
 
     if (!overridePos.isNull()) {
         pi.setPos(overridePos);
     }
 
     if (m_d->linePoints.size() > 1) {
         const QPointF startPos = m_d->linePoints.first().pos();
         const QPointF endPos = pi.pos();
         const qreal maxDistance = kisDistance(startPos, endPos);
         const QPointF unit = (endPos - startPos) / maxDistance;
 
         QVector<KisPaintInformation>::iterator it = m_d->linePoints.begin();
         ++it;
         while (it != m_d->linePoints.end()) {
             qreal dist = kisDistance(startPos, it->pos());
             if (dist < maxDistance) {
                 QPointF pos = startPos + unit * dist;
                 it->setPos(pos);
                 ++it;
             } else {
                 it = m_d->linePoints.erase(it);
             }
         }
     }
 
     m_d->linePoints.append(pi);
 }
 
 void KisToolLineHelper::translatePoints(const QPointF &offset)
 {
     if (!m_d->enabled) return;
 
     QVector<KisPaintInformation>::iterator it = m_d->linePoints.begin();
     while (it != m_d->linePoints.end()) {
         it->setPos(it->pos() + offset);
         ++it;
     }
 }
 
 void KisToolLineHelper::end()
 {
     if (!m_d->enabled) return;
     KIS_ASSERT_RECOVER_RETURN(isRunning());
 
     endPaint();
     m_d->linePoints.clear();
 }
 
 
 void KisToolLineHelper::cancel()
 {
     if (!m_d->enabled) return;
     KIS_ASSERT_RECOVER_RETURN(isRunning());
 
     cancelPaint();
     m_d->linePoints.clear();
 }
 
 
 void KisToolLineHelper::clearPaint()
 {
     if (!m_d->enabled) return;
 
     cancelPaint();
 }
diff --git a/plugins/tools/tool_transform2/kis_liquify_paint_helper.cpp b/plugins/tools/tool_transform2/kis_liquify_paint_helper.cpp
index 54329dedb2..3f6a8a9009 100644
--- a/plugins/tools/tool_transform2/kis_liquify_paint_helper.cpp
+++ b/plugins/tools/tool_transform2/kis_liquify_paint_helper.cpp
@@ -1,139 +1,142 @@
 /*
  *  Copyright (c) 2014 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_liquify_paint_helper.h"
 
+#include "kis_algebra_2d.h"
 #include "KoPointerEvent.h"
 #include <brushengine/kis_paint_information.h>
 #include "kis_painting_information_builder.h"
 #include "kis_liquify_transform_worker.h"
 #include <brushengine/kis_paintop_utils.h>
 #include "kis_coordinates_converter.h"
 #include "kis_liquify_paintop.h"
 #include "kis_liquify_properties.h"
 
 struct KisLiquifyPaintHelper::Private
 {
     Private(const KisCoordinatesConverter *_converter)
         : converter(_converter),
           infoBuilder(new KisConverterPaintingInformationBuilder(converter)),
           hasPaintedAtLeastOnce(false)
     {
     }
 
     KisPaintInformation previousPaintInfo;
 
     QScopedPointer<KisLiquifyPaintop> paintOp;
     KisDistanceInformation currentDistance;
     const KisCoordinatesConverter *converter;
     QScopedPointer<KisPaintingInformationBuilder> infoBuilder;
 
     QTime strokeTime;
 
     bool hasPaintedAtLeastOnce;
 
     KisDistanceInformation previousDistanceInfo;
     KisPaintOpUtils::PositionHistory lastOutlinePos;
     void updatePreviousPaintInfo(const KisPaintInformation &info);
 };
 
 
 KisLiquifyPaintHelper::KisLiquifyPaintHelper(const KisCoordinatesConverter *converter)
     : m_d(new Private(converter))
 {
 }
 
 KisLiquifyPaintHelper::~KisLiquifyPaintHelper()
 {
 }
 
 void KisLiquifyPaintHelper::Private::updatePreviousPaintInfo(const KisPaintInformation &info)
 {
+    QPointF prevPos = lastOutlinePos.pushThroughHistory(info.pos());
+    qreal angle = KisAlgebra2D::directionBetweenPoints(prevPos, info.pos(), 0);
+
     previousDistanceInfo =
-        KisDistanceInformation(
-            lastOutlinePos.pushThroughHistory(info.pos()), 0);
+        KisDistanceInformation(prevPos, 0, angle);
 
     previousPaintInfo = info;
 }
 
 QPainterPath KisLiquifyPaintHelper::brushOutline(const KisLiquifyProperties &props)
 {
     KisPaintInformation::DistanceInformationRegistrar registrar =
         m_d->previousPaintInfo.registerDistanceInformation(&m_d->previousDistanceInfo);
 
     return KisLiquifyPaintop::brushOutline(props, m_d->previousPaintInfo);
 }
 
 void KisLiquifyPaintHelper::configurePaintOp(const KisLiquifyProperties &props,
                                              KisLiquifyTransformWorker *worker)
 {
     m_d->paintOp.reset(new KisLiquifyPaintop(props, worker));
 }
 
 void KisLiquifyPaintHelper::startPaint(KoPointerEvent *event, const KoCanvasResourceManager *manager)
 {
     KIS_ASSERT_RECOVER_RETURN(m_d->paintOp);
 
     m_d->strokeTime.start();
     KisPaintInformation pi =
         m_d->infoBuilder->startStroke(event, m_d->strokeTime.elapsed(), manager);
 
     m_d->updatePreviousPaintInfo(pi);
     m_d->hasPaintedAtLeastOnce = false;
 }
 
 void KisLiquifyPaintHelper::continuePaint(KoPointerEvent *event)
 {
     KIS_ASSERT_RECOVER_RETURN(m_d->paintOp);
 
     KisPaintInformation pi =
         m_d->infoBuilder->continueStroke(event, m_d->strokeTime.elapsed());
 
     KisPaintOpUtils::paintLine(*m_d->paintOp.data(),
                                m_d->previousPaintInfo,
                                pi,
                                &m_d->currentDistance,
                                false, false);
 
     m_d->updatePreviousPaintInfo(pi);
     m_d->hasPaintedAtLeastOnce = true;
 }
 
 bool KisLiquifyPaintHelper::endPaint(KoPointerEvent *event)
 {
     KIS_ASSERT_RECOVER(m_d->paintOp) { return false; }
 
     if (!m_d->hasPaintedAtLeastOnce) {
         KisPaintInformation pi =
             m_d->infoBuilder->continueStroke(event, m_d->strokeTime.elapsed());
 
         pi.paintAt(*m_d->paintOp.data(), &m_d->previousDistanceInfo);
     }
 
     m_d->paintOp.reset();
 
     return !m_d->hasPaintedAtLeastOnce;
 }
 
 void KisLiquifyPaintHelper::hoverPaint(KoPointerEvent *event)
 {
     QPointF imagePoint = m_d->converter->documentToImage(event->pos());
     KisPaintInformation pi = m_d->infoBuilder->hover(imagePoint, event);
 
     m_d->updatePreviousPaintInfo(pi);
 }