diff --git a/libs/brush/kis_brush.cpp b/libs/brush/kis_brush.cpp
index 641a1791d2..fcfc8ddfc3 100644
--- a/libs/brush/kis_brush.cpp
+++ b/libs/brush/kis_brush.cpp
@@ -1,666 +1,666 @@
 /*
  *  Copyright (c) 1999 Matthias Elter  <me@kde.org>
  *  Copyright (c) 2003 Patrick Julien  <freak@codepimps.org>
  *  Copyright (c) 2004-2008 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2004 Adrian Page <adrian@pagenet.plus.com>
  *  Copyright (c) 2005 Bart Coppens <kde@bartcoppens.be>
  *  Copyright (c) 2007 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_brush.h"
 
 #include <limits>
 
 #include <QDomElement>
 #include <QFile>
 #include <QPoint>
 #include <QFileInfo>
 #include <QBuffer>
 
 #include <kis_debug.h>
 #include <klocalizedstring.h>
 
 #include <KoColor.h>
 #include <KoColorSpaceMaths.h>
 #include <KoColorSpaceRegistry.h>
 
 #include "kis_datamanager.h"
 #include "kis_paint_device.h"
 #include "kis_global.h"
 #include "kis_boundary.h"
 #include "kis_image.h"
 #include "kis_iterator_ng.h"
 #include "kis_brush_registry.h"
 #include <brushengine/kis_paint_information.h>
 #include <kis_fixed_paint_device.h>
 #include <kis_qimage_pyramid.h>
 #include <brushengine/kis_paintop_lod_limitations.h>
 
 
 KisBrush::ColoringInformation::~ColoringInformation()
 {
 }
 
 KisBrush::PlainColoringInformation::PlainColoringInformation(const quint8* color) : m_color(color)
 {
 }
 
 KisBrush::PlainColoringInformation::~PlainColoringInformation()
 {
 }
 
 const quint8* KisBrush::PlainColoringInformation::color() const
 {
     return m_color;
 }
 
 void KisBrush::PlainColoringInformation::nextColumn()
 {
 }
 
 void KisBrush::PlainColoringInformation::nextRow()
 {
 }
 
 KisBrush::PaintDeviceColoringInformation::PaintDeviceColoringInformation(const KisPaintDeviceSP source, int width)
     : m_source(source)
     , m_iterator(m_source->createHLineConstIteratorNG(0, 0, width))
 {
 }
 
 KisBrush::PaintDeviceColoringInformation::~PaintDeviceColoringInformation()
 {
 }
 
 const quint8* KisBrush::PaintDeviceColoringInformation::color() const
 {
     return m_iterator->oldRawData();
 }
 
 void KisBrush::PaintDeviceColoringInformation::nextColumn()
 {
     m_iterator->nextPixel();
 }
 void KisBrush::PaintDeviceColoringInformation::nextRow()
 {
     m_iterator->nextRow();
 }
 
 
 struct KisBrush::Private {
     Private()
         : boundary(0)
         , angle(0)
         , scale(1.0)
         , hasColor(false)
         , brushType(INVALID)
         , autoSpacingActive(false)
         , autoSpacingCoeff(1.0)
         , timedSpacingEnabled(false)
         , timedSpacingDelay(100.0)
     {}
 
     ~Private() {
         delete boundary;
     }
 
     mutable KisBoundary* boundary;
     qreal angle;
     qreal scale;
     bool hasColor;
     enumBrushType brushType;
 
     qint32 width;
     qint32 height;
     double spacing;
     QPointF hotSpot;
 
     mutable QSharedPointer<const KisQImagePyramid> brushPyramid;
 
     QImage brushTipImage;
 
     bool autoSpacingActive;
     qreal autoSpacingCoeff;
 
     bool timedSpacingEnabled;
     qreal timedSpacingDelay;
 };
 
 KisBrush::KisBrush()
     : KoResource(QString())
     , d(new Private)
 {
 }
 
 KisBrush::KisBrush(const QString& filename)
     : KoResource(filename)
     , d(new Private)
 {
 }
 
 KisBrush::KisBrush(const KisBrush& rhs)
     : KoResource(QString())
     , KisShared()
     , d(new Private)
 {
     setBrushTipImage(rhs.brushTipImage());
     d->brushType = rhs.d->brushType;
     d->width = rhs.d->width;
     d->height = rhs.d->height;
     d->spacing = rhs.d->spacing;
     d->hotSpot = rhs.d->hotSpot;
     d->hasColor = rhs.d->hasColor;
     d->angle = rhs.d->angle;
     d->scale = rhs.d->scale;
     d->autoSpacingActive = rhs.d->autoSpacingActive;
     d->autoSpacingCoeff = rhs.d->autoSpacingCoeff;
     setFilename(rhs.filename());
 
     /**
      * Be careful! The pyramid is shared between two brush objects,
      * therefore you cannot change it, only recreate! That i sthe
      * reason why it is defined as const!
      */
     d->brushPyramid = rhs.d->brushPyramid;
 
     // don't copy the boundary, it will be regenerated -- see bug 291910
 }
 
 KisBrush::~KisBrush()
 {
     clearBrushPyramid();
     delete d;
 }
 
 QImage KisBrush::brushTipImage() const
 {
     if (d->brushTipImage.isNull()) {
         const_cast<KisBrush*>(this)->load();
     }
     return d->brushTipImage;
 }
 
 qint32 KisBrush::width() const
 {
     return d->width;
 }
 
 void KisBrush::setWidth(qint32 width)
 {
     d->width = width;
 }
 
 qint32 KisBrush::height() const
 {
     return d->height;
 }
 
 void KisBrush::setHeight(qint32 height)
 {
     d->height = height;
 }
 
 void KisBrush::setHotSpot(QPointF pt)
 {
     double x = pt.x();
     double y = pt.y();
 
     if (x < 0)
         x = 0;
     else if (x >= width())
         x = width() - 1;
 
     if (y < 0)
         y = 0;
     else if (y >= height())
         y = height() - 1;
 
     d->hotSpot = QPointF(x, y);
 }
 
 QPointF KisBrush::hotSpot(KisDabShape const& shape, const KisPaintInformation& info) const
 {
     Q_UNUSED(info);
 
     QSizeF metric = characteristicSize(shape);
 
     qreal w = metric.width();
     qreal h = metric.height();
 
     // The smallest brush we can produce is a single pixel.
     if (w < 1) {
         w = 1;
     }
 
     if (h < 1) {
         h = 1;
     }
 
     // XXX: This should take d->hotSpot into account, though it
     // isn't specified by gimp brushes so it would default to the center
     // anyway.
     QPointF p(w / 2, h / 2);
     return p;
 }
 
 
 bool KisBrush::hasColor() const
 {
     return d->hasColor;
 }
 
 void KisBrush::setHasColor(bool hasColor)
 {
     d->hasColor = hasColor;
 }
 
 bool KisBrush::isPiercedApprox() const
 {
     QImage image = brushTipImage();
 
     qreal w = image.width();
     qreal h = image.height();
 
     qreal xPortion = qMin(0.1, 5.0 / w);
     qreal yPortion = qMin(0.1, 5.0 / h);
 
     int x0 = std::floor((0.5 - xPortion) * w);
     int x1 = std::ceil((0.5 + xPortion) * w);
 
     int y0 = std::floor((0.5 - yPortion) * h);
     int y1 = std::ceil((0.5 + yPortion) * h);
 
     const int maxNumSamples = (x1 - x0 + 1) * (y1 - y0 + 1);
     const int failedPixelsThreshold = 0.1 * maxNumSamples;
     const int thresholdValue = 0.95 * 255;
     int failedPixels = 0;
 
     for (int y = y0; y <= y1; y++) {
         for (int x = x0; x <= x1; x++) {
             QRgb pixel = image.pixel(x,y);
 
             if (qRed(pixel) > thresholdValue) {
                 failedPixels++;
             }
         }
     }
 
     return failedPixels > failedPixelsThreshold;
 }
 
 bool KisBrush::canPaintFor(const KisPaintInformation& /*info*/)
 {
     return true;
 }
 
 void KisBrush::setBrushTipImage(const QImage& image)
 {
     //Q_ASSERT(!image.isNull());
     d->brushTipImage = image;
 
     if (!image.isNull()) {
         if (image.width() > 128 || image.height() > 128) {
             KoResource::setImage(image.scaled(128, 128, Qt::KeepAspectRatio, Qt::SmoothTransformation));
         }
         else {
             KoResource::setImage(image);
         }
         setWidth(image.width());
         setHeight(image.height());
     }
     clearBrushPyramid();
 
 }
 
 void KisBrush::setBrushType(enumBrushType type)
 {
     d->brushType = type;
 }
 
 enumBrushType KisBrush::brushType() const
 {
     return d->brushType;
 }
 
 void KisBrush::predefinedBrushToXML(const QString &type, QDomElement& e) const
 {
     e.setAttribute("type", type);
     e.setAttribute("filename", shortFilename());
     e.setAttribute("spacing", QString::number(spacing()));
     e.setAttribute("useAutoSpacing", QString::number(autoSpacingActive()));
     e.setAttribute("autoSpacingCoeff", QString::number(autoSpacingCoeff()));
     e.setAttribute("useTimedSpacing", QString::number(timedSpacingEnabled()));
     e.setAttribute("timedSpacingRate", QString::number(timedSpacingRate()));
     e.setAttribute("angle", QString::number(angle()));
     e.setAttribute("scale", QString::number(scale()));
 }
 
 void KisBrush::toXML(QDomDocument& /*document*/ , QDomElement& element) const
 {
     element.setAttribute("BrushVersion", "2");
 }
 
 KisBrushSP KisBrush::fromXML(const QDomElement& element, bool forceCopy)
 {
     KisBrushSP brush = KisBrushRegistry::instance()->getOrCreateBrush(element, forceCopy);
     if (brush && element.attribute("BrushVersion", "1") == "1") {
         brush->setScale(brush->scale() * 2.0);
     }
     return brush;
 }
 
 QSizeF KisBrush::characteristicSize(KisDabShape const& shape) const
 {
     KisDabShape normalizedShape(
          shape.scale() * d->scale,
          shape.ratio(),
          normalizeAngle(shape.rotation() + d->angle));
     return KisQImagePyramid::characteristicSize(
         QSize(width(), height()), normalizedShape);
 }
 
 qint32 KisBrush::maskWidth(KisDabShape const& shape, qreal subPixelX, qreal subPixelY, const KisPaintInformation& info) const
 {
     Q_UNUSED(info);
 
     qreal angle = normalizeAngle(shape.rotation() + d->angle);
     qreal scale = shape.scale() * d->scale;
 
     return KisQImagePyramid::imageSize(QSize(width(), height()),
                                        KisDabShape(scale, shape.ratio(), angle),
                                        subPixelX, subPixelY).width();
 }
 
 qint32 KisBrush::maskHeight(KisDabShape const& shape, qreal subPixelX, qreal subPixelY, const KisPaintInformation& info) const
 {
     Q_UNUSED(info);
 
     qreal angle = normalizeAngle(shape.rotation() + d->angle);
     qreal scale = shape.scale() * d->scale;
 
     return KisQImagePyramid::imageSize(QSize(width(), height()),
                                        KisDabShape(scale, shape.ratio(), angle),
                                        subPixelX, subPixelY).height();
 }
 
 double KisBrush::maskAngle(double angle) const
 {
     return normalizeAngle(angle + d->angle);
 }
 
 quint32 KisBrush::brushIndex(const KisPaintInformation& info) const
 {
     Q_UNUSED(info);
     return 0;
 }
 
 void KisBrush::setSpacing(double s)
 {
     if (s < 0.02) s = 0.02;
     d->spacing = s;
 }
 
 double KisBrush::spacing() const
 {
     return d->spacing;
 }
 
 void KisBrush::setAutoSpacing(bool active, qreal coeff)
 {
     d->autoSpacingCoeff = coeff;
     d->autoSpacingActive = active;
 }
 
 bool KisBrush::autoSpacingActive() const
 {
     return d->autoSpacingActive;
 }
 
 qreal KisBrush::autoSpacingCoeff() const
 {
     return d->autoSpacingCoeff;
 }
 
 void KisBrush::setTimedSpacing(bool enabled, qreal rate) {
     d->timedSpacingEnabled = enabled;
     // Since the time delay is likely to be accessed more often than the rate, we store the delay
     // instead of storing the rate directly. If rate is zero, the delay will be infinity.
     d->timedSpacingDelay = 1000.0 / rate;
 }
 
 bool KisBrush::timedSpacingEnabled() const {
     return d->timedSpacingEnabled;
 }
 
 qreal KisBrush::timedSpacingRate() const {
     return 1000.0 / timedSpacingDelay();
 }
 
 qreal KisBrush::timedSpacingDelay() const {
-    return timedSpacingEnabled() ? d->timedSpacingDelay : std::numeric_limits<qreal>::infinity();
+    return d->timedSpacingDelay;
 }
 
 void KisBrush::notifyStrokeStarted()
 {
 }
 
 void KisBrush::notifyCachedDabPainted(const KisPaintInformation& info)
 {
     Q_UNUSED(info);
 }
 
 void KisBrush::prepareBrushPyramid() const
 {
     if (!d->brushPyramid) {
         d->brushPyramid = toQShared(new KisQImagePyramid(brushTipImage()));
     }
 }
 
 void KisBrush::clearBrushPyramid()
 {
     d->brushPyramid.clear();
 }
 
 void KisBrush::mask(KisFixedPaintDeviceSP dst, KisDabShape const& shape, const KisPaintInformation& info , double subPixelX, double subPixelY, qreal softnessFactor) const
 {
     generateMaskAndApplyMaskOrCreateDab(dst, 0, shape, info, subPixelX, subPixelY, softnessFactor);
 }
 
 void KisBrush::mask(KisFixedPaintDeviceSP dst, const KoColor& color, KisDabShape const& shape, const KisPaintInformation& info, double subPixelX, double subPixelY, qreal softnessFactor) const
 {
     PlainColoringInformation pci(color.data());
     generateMaskAndApplyMaskOrCreateDab(dst, &pci, shape, info, subPixelX, subPixelY, softnessFactor);
 }
 
 void KisBrush::mask(KisFixedPaintDeviceSP dst, const KisPaintDeviceSP src, KisDabShape const& shape, const KisPaintInformation& info, double subPixelX, double subPixelY, qreal softnessFactor) const
 {
     PaintDeviceColoringInformation pdci(src, maskWidth(shape, subPixelX, subPixelY, info));
     generateMaskAndApplyMaskOrCreateDab(dst, &pdci, shape, info, subPixelX, subPixelY, softnessFactor);
 }
 
 
 void KisBrush::generateMaskAndApplyMaskOrCreateDab(KisFixedPaintDeviceSP dst,
         ColoringInformation* coloringInformation,
         KisDabShape const& shape,
         const KisPaintInformation& info_,
         double subPixelX, double subPixelY, qreal softnessFactor) const
 {
     Q_ASSERT(valid());
     Q_UNUSED(info_);
     Q_UNUSED(softnessFactor);
 
     prepareBrushPyramid();
     QImage outputImage = d->brushPyramid->createImage(KisDabShape(
             shape.scale() * d->scale, shape.ratio(),
             -normalizeAngle(shape.rotation() + d->angle)),
         subPixelX, subPixelY);
 
     qint32 maskWidth = outputImage.width();
     qint32 maskHeight = outputImage.height();
 
     dst->setRect(QRect(0, 0, maskWidth, maskHeight));
     dst->initialize();
 
     quint8* color = 0;
 
     if (coloringInformation) {
         if (dynamic_cast<PlainColoringInformation*>(coloringInformation)) {
             color = const_cast<quint8*>(coloringInformation->color());
         }
     }
 
     const KoColorSpace *cs = dst->colorSpace();
     qint32 pixelSize = cs->pixelSize();
     quint8 *dabPointer = dst->data();
     quint8 *rowPointer = dabPointer;
     quint8 *alphaArray = new quint8[maskWidth];
     bool hasColor = this->hasColor();
 
     for (int y = 0; y < maskHeight; y++) {
         const quint8* maskPointer = outputImage.constScanLine(y);
         if (coloringInformation) {
             for (int x = 0; x < maskWidth; x++) {
                 if (color) {
                     memcpy(dabPointer, color, pixelSize);
                 }
                 else {
                     memcpy(dabPointer, coloringInformation->color(), pixelSize);
                     coloringInformation->nextColumn();
                 }
                 dabPointer += pixelSize;
             }
         }
 
         if (hasColor) {
             const quint8 *src = maskPointer;
             quint8 *dst = alphaArray;
             for (int x = 0; x < maskWidth; x++) {
                 const QRgb *c = reinterpret_cast<const QRgb*>(src);
 
                 *dst = KoColorSpaceMaths<quint8>::multiply(255 - qGray(*c), qAlpha(*c));
                 src += 4;
                 dst++;
             }
         }
         else {
             const quint8 *src = maskPointer;
             quint8 *dst = alphaArray;
             for (int x = 0; x < maskWidth; x++) {
                 const QRgb *c = reinterpret_cast<const QRgb*>(src);
 
                 *dst = KoColorSpaceMaths<quint8>::multiply(255 - *src, qAlpha(*c));
                 src += 4;
                 dst++;
             }
         }
 
         cs->applyAlphaU8Mask(rowPointer, alphaArray, maskWidth);
         rowPointer += maskWidth * pixelSize;
         dabPointer = rowPointer;
 
         if (!color && coloringInformation) {
             coloringInformation->nextRow();
         }
     }
 
     delete[] alphaArray;
 }
 
 KisFixedPaintDeviceSP KisBrush::paintDevice(const KoColorSpace * colorSpace,
         KisDabShape const& shape,
         const KisPaintInformation& info,
         double subPixelX, double subPixelY) const
 {
     Q_ASSERT(valid());
     Q_UNUSED(info);
     double angle = normalizeAngle(shape.rotation() + d->angle);
     double scale = shape.scale() * d->scale;
 
     prepareBrushPyramid();
     QImage outputImage = d->brushPyramid->createImage(
         KisDabShape(scale, shape.ratio(), -angle), subPixelX, subPixelY);
 
     KisFixedPaintDeviceSP dab = new KisFixedPaintDevice(colorSpace);
     Q_CHECK_PTR(dab);
     dab->convertFromQImage(outputImage, "");
 
     return dab;
 }
 
 void KisBrush::resetBoundary()
 {
     delete d->boundary;
     d->boundary = 0;
 }
 
 void KisBrush::generateBoundary() const
 {
     KisFixedPaintDeviceSP dev;
     KisDabShape inverseTransform(1.0 / scale(), 1.0, -angle());
 
     if (brushType() == IMAGE || brushType() == PIPE_IMAGE) {
         dev = paintDevice(KoColorSpaceRegistry::instance()->rgb8(),
             inverseTransform, KisPaintInformation());
     }
     else {
         const KoColorSpace* cs = KoColorSpaceRegistry::instance()->rgb8();
         dev = new KisFixedPaintDevice(cs);
         mask(dev, KoColor(Qt::black, cs), inverseTransform, KisPaintInformation());
     }
 
     d->boundary = new KisBoundary(dev);
     d->boundary->generateBoundary();
 }
 
 const KisBoundary* KisBrush::boundary() const
 {
     if (!d->boundary)
         generateBoundary();
     return d->boundary;
 }
 
 void KisBrush::setScale(qreal _scale)
 {
     d->scale = _scale;
 }
 
 qreal KisBrush::scale() const
 {
     return d->scale;
 }
 
 void KisBrush::setAngle(qreal _rotation)
 {
     d->angle = _rotation;
 }
 
 qreal KisBrush::angle() const
 {
     return d->angle;
 }
 
 QPainterPath KisBrush::outline() const
 {
     return boundary()->path();
 }
 
 void KisBrush::lodLimitations(KisPaintopLodLimitations *l) const
 {
     if (spacing() > 0.5) {
         l->limitations << KoID("huge-spacing", i18nc("PaintOp instant preview limitation", "Spacing > 0.5, consider disabling Instant Preview"));
     }
 }
diff --git a/libs/brush/kis_brush.h b/libs/brush/kis_brush.h
index 2af0f016f1..1647e56256 100644
--- a/libs/brush/kis_brush.h
+++ b/libs/brush/kis_brush.h
@@ -1,402 +1,401 @@
 /*
  *  Copyright (c) 1999 Matthias Elter  <me@kde.org>
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2004 Boudewijn Rempt <boud@valdyas.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef KIS_BRUSH_
 #define KIS_BRUSH_
 
 #include <QImage>
 
 #include <resources/KoResource.h>
 
 #include <kis_types.h>
 #include <kis_shared.h>
 #include <kis_dab_shape.h>
 #include <kritabrush_export.h>
 
 class KisQImagemask;
 typedef KisSharedPtr<KisQImagemask> KisQImagemaskSP;
 
 class QString;
 class KoColor;
 class KoColorSpace;
 
 class KisPaintInformation;
 class KisBoundary;
 class KisPaintopLodLimitations;
 
 enum enumBrushType {
     INVALID,
     MASK,
     IMAGE,
     PIPE_MASK,
     PIPE_IMAGE
 };
 
 static const qreal DEFAULT_SOFTNESS_FACTOR = 1.0;
 
 class KisBrush;
 typedef KisSharedPtr<KisBrush> KisBrushSP;
 
 /**
  * KisBrush is the base class for brush resources. A brush resource
  * defines one or more images that are used to potato-stamp along
  * the drawn path. The brush type defines how this brush is used --
  * the important difference is between masks (which take the current
  * painting color) and images (which do not). It is up to the paintop
  * to make use of this feature.
  *
  * Brushes must be serializable to an xml representation and provide
  * a factory class that can recreate or retrieve the brush based on
  * this representation.
  *
  * XXX: This api is still a big mess -- it needs a good refactoring.
  * And the whole KoResource architecture is way over-designed.
  */
 class BRUSH_EXPORT KisBrush : public KoResource, public KisShared
 {
 
 
 public:
     class ColoringInformation
     {
     public:
         virtual ~ColoringInformation();
         virtual const quint8* color() const = 0;
         virtual void nextColumn() = 0;
         virtual void nextRow() = 0;
     };
 
 protected:
 
     class PlainColoringInformation : public ColoringInformation
     {
     public:
         PlainColoringInformation(const quint8* color);
         ~PlainColoringInformation() override;
         const quint8* color() const override ;
         void nextColumn() override;
         void nextRow() override;
     private:
         const quint8* m_color;
     };
 
     class PaintDeviceColoringInformation : public ColoringInformation
     {
 
     public:
 
         PaintDeviceColoringInformation(const KisPaintDeviceSP source, int width);
         ~PaintDeviceColoringInformation() override;
         const quint8* color() const override ;
         void nextColumn() override;
         void nextRow() override;
 
     private:
 
         const KisPaintDeviceSP m_source;
         KisHLineConstIteratorSP m_iterator;
     };
 
 public:
 
     KisBrush();
     KisBrush(const QString& filename);
 
     ~KisBrush() override;
 
     virtual qreal userEffectiveSize() const = 0;
     virtual void setUserEffectiveSize(qreal value) = 0;
 
     bool load() override {
         return false;
     }
 
     bool loadFromDevice(QIODevice *) override {
         return false;
     }
 
 
     bool save() override {
         return false;
     }
 
     bool saveToDevice(QIODevice* ) const override {
         return false;
     }
 
     /**
      * @brief brushImage the image the brush tip can paint with. Not all brush types have a single
      * image.
      * @return a valid QImage.
      */
     virtual QImage brushTipImage() const;
 
     /**
      * Change the spacing of the brush.
      * @param spacing a spacing of 1.0 means that strokes will be separated from one time the size
      *                of the brush.
      */
     virtual void setSpacing(double spacing);
 
     /**
      * @return the spacing between two strokes for this brush
      */
     double spacing() const;
 
     void setAutoSpacing(bool active, qreal coeff);
 
     bool autoSpacingActive() const;
     qreal autoSpacingCoeff() const;
 
     /**
      * @param enabled True if and only if timed spacing should be enabled
      * @param rate The timed spacing rate, in dabs per second
      */
     virtual void setTimedSpacing(bool enabled, qreal rate);
 
     /**
      * @return True if and only if timed spacing is enabled
      */
     bool timedSpacingEnabled() const;
 
     /**
-     * @return The timed spacing rate, in dabs per second. Returns zero if timed spacing is
-     * disabled.
+     * @return The timed spacing rate, in dabs per second. This value should be ignored if timed
+     * spacing is disabled.
      */
     qreal timedSpacingRate() const;
 
     /**
      * @return The delay between dabs for the current timed spacing settings, in milliseconds.
-     * Returns infinity if timed spacing is disabled.
+     * This value should be ignored if timed spacing is disabled.
      */
     qreal timedSpacingDelay() const;
 
-
     /**
      * @return the width (for scale == 1.0)
      */
     qint32 width() const;
 
     /**
      * @return the height (for scale == 1.0)
      */
     qint32 height() const;
 
     /**
      * @return the width of the mask for the given scale and angle
      */
     virtual qint32 maskWidth(KisDabShape const&, qreal subPixelX, qreal subPixelY, const KisPaintInformation& info) const;
 
     /**
      * @return the height of the mask for the given scale and angle
      */
     virtual qint32 maskHeight(KisDabShape const&, qreal subPixelX, qreal subPixelY, const KisPaintInformation& info) const;
 
     /**
      * @return the logical size of the brush, that is the size measured
      *         in floating point value.
      *
      *         This value should not be used for calculating future dab sizes
      *         because it doesn't take any rounding into account. The only use
      *         of this metric is calculation of brush-size derivatives like
      *         hotspots and spacing.
      */
      virtual QSizeF characteristicSize(KisDabShape const&) const;
 
     /**
      * @return the angle of the mask adding the given angle
      */
     double maskAngle(double angle = 0) const;
 
     /**
      * @return the index of the brush
      *         if the brush consists of multiple images
      */
     virtual quint32 brushIndex(const KisPaintInformation& info) const;
 
     /**
      * The brush type defines how the brush is used.
      */
     virtual enumBrushType brushType() const;
 
     QPointF hotSpot(KisDabShape const&, const KisPaintInformation& info) const;
 
     /**
      * Returns true if this brush can return something useful for the info. This is used
      * by Pipe Brushes that can't paint sometimes
      **/
     virtual bool canPaintFor(const KisPaintInformation& /*info*/);
 
 
     /**
      * Is called by the paint op when a paintop starts a stroke.  The
      * point is that we store brushes a server while the paint ops are
      * are recreated all the time. Is means that upon a stroke start
      * the brushes may need to clear its state.
      */
     virtual void notifyStrokeStarted();
 
     /**
      * Is called by the cache, when cache hit has happened.
      * Having got this notification the brush can update the counters
      * of dabs, generate some new random values if needed.
      *
      * Currently, this is used by pipe'd brushes to implement
      * incremental and random parasites
      */
     virtual void notifyCachedDabPainted(const KisPaintInformation& info);
 
     /**
      * Return a fixed paint device that contains a correctly scaled image dab.
      */
     virtual KisFixedPaintDeviceSP paintDevice(const KoColorSpace * colorSpace,
             KisDabShape const&,
             const KisPaintInformation& info,
             double subPixelX = 0, double subPixelY = 0) const;
 
     /**
      * Apply the brush mask to the pixels in dst. Dst should be big enough!
      */
     void mask(KisFixedPaintDeviceSP dst,
               KisDabShape const& shape,
               const KisPaintInformation& info,
               double subPixelX = 0, double subPixelY = 0, qreal softnessFactor = DEFAULT_SOFTNESS_FACTOR) const;
 
     /**
      * clear dst fill it with a mask colored with KoColor
      */
     void mask(KisFixedPaintDeviceSP dst,
               const KoColor& color,
               KisDabShape const& shape,
               const KisPaintInformation& info,
               double subPixelX = 0, double subPixelY = 0, qreal softnessFactor = DEFAULT_SOFTNESS_FACTOR) const;
 
     /**
      * clear dst and fill it with a mask colored with the corresponding colors of src
      */
     void mask(KisFixedPaintDeviceSP dst,
               const KisPaintDeviceSP src,
               KisDabShape const& shape,
               const KisPaintInformation& info,
               double subPixelX = 0, double subPixelY = 0, qreal softnessFactor = DEFAULT_SOFTNESS_FACTOR) const;
 
 
     virtual bool hasColor() const;
 
     /**
      * Create a mask and either mask dst (that is, change all alpha values of the
      * existing pixels to those of the mask) or, if coloringInfo is present, clear
      * dst and fill dst with pixels according to coloringInfo, masked according to the
      * generated mask.
      *
      * @param dst the destination that will be draw on the image, and this function
      *            will edit its alpha channel
      * @param coloringInfo coloring information that will be copied on the dab, it can be null
      * @param scale a scale applied on the alpha mask
      * @param angle a rotation applied on the alpha mask
      * @param info the painting information (this is only and should only be used by
      *             KisImagePipeBrush and only to be backward compatible with the Gimp,
      *             KisImagePipeBrush is ignoring scale and angle information)
      * @param subPixelX sub position of the brush (contained between 0.0 and 1.0)
      * @param subPixelY sub position of the brush (contained between 0.0 and 1.0)
      *
      * @return a mask computed from the grey-level values of the
      * pixels in the brush.
      */
     virtual void generateMaskAndApplyMaskOrCreateDab(KisFixedPaintDeviceSP dst,
             ColoringInformation* coloringInfo,
             KisDabShape const&,
             const KisPaintInformation& info,
             double subPixelX = 0, double subPixelY = 0, qreal softnessFactor = DEFAULT_SOFTNESS_FACTOR) const;
 
 
     /**
      * Serialize this brush to XML.
      */
     virtual void toXML(QDomDocument& , QDomElement&) const;
 
     static KisBrushSP fromXML(const QDomElement& element, bool forceCopy = false);
 
     virtual const KisBoundary* boundary() const;
     virtual QPainterPath outline() const;
 
     virtual void setScale(qreal _scale);
     qreal scale() const;
     virtual void setAngle(qreal _angle);
     qreal angle() const;
 
     void prepareBrushPyramid() const;
     void clearBrushPyramid();
 
     virtual void lodLimitations(KisPaintopLodLimitations *l) const;
 
     virtual KisBrush* clone() const = 0;
 
 //protected:
 
     KisBrush(const KisBrush& rhs);
 
     void setWidth(qint32 width);
 
     void setHeight(qint32 height);
 
     void setHotSpot(QPointF);
 
     /**
      * The image is used to represent the brush in the gui, and may also, depending on the brush type
      * be used to define the actual brush instance.
      */
     virtual void setBrushTipImage(const QImage& image);
 
     /**
      * XXX
      */
     virtual void setBrushType(enumBrushType type);
 
     virtual void setHasColor(bool hasColor);
 
     /**
      * Returns true if the brush has a bunch of pixels almost
      * fully transparent in the very center. If the brush is pierced,
      * then dulling mode may not work correctly due to empty samples.
      *
      * WARNING: this method is relatively expensive since it iterates
      *          up to 100 pixels of the brush.
      */
     bool isPiercedApprox() const;
 
 protected:
 
     void resetBoundary();
 
     void predefinedBrushToXML(const QString &type, QDomElement& e) const;
 
 private:
 
     // Initialize our boundary
     void generateBoundary() const;
 
     struct Private;
     Private* const d;
 
 };
 
 
 #endif // KIS_BRUSH_